func()

in metricbeat/module/openmetrics/collector/data.go [74:292]

• 201 lines of code
• 44 McCabe index (conditional complexity)

func (p *openmetricEventGenerator) GenerateOpenMetricsEvents(mf *p.MetricFamily) []OpenMetricEvent {
	var events []OpenMetricEvent

	name := *mf.Name
	_ = name // skip noisy linter
	metrics := mf.Metric
	help := ""
	unit := ""
	if mf.Help != nil {
		help = *mf.Help
	}
	if mf.Unit != nil {
		unit = *mf.Unit
	}

	for _, metric := range metrics {
		labels := mapstr.M{}
		mn := metric.GetName()
		_ = mn // skip noisy linter

		if len(metric.Label) != 0 {
			for _, label := range metric.Label {
				if label.Name != "" && label.Value != "" {
					labels[label.Name] = label.Value
				}
			}
		}

		exemplars := mapstr.M{}
		if metric.Exemplar != nil {
			exemplars = mapstr.M{*mn: metric.Exemplar.Value}
			if metric.Exemplar.HasTs {
				_, _ = exemplars.Put("timestamp", metric.Exemplar.Ts)
			}
			for _, label := range metric.Exemplar.Labels {
				if label.Name != "" && label.Value != "" {
					_, _ = exemplars.Put("labels."+label.Name, label.Value)
				}
			}
		}

		counter := metric.GetCounter()
		if counter != nil {
			if !math.IsNaN(counter.GetValue()) && !math.IsInf(counter.GetValue(), 0) {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeCounter,
					Help: help,
					Unit: unit,
					Data: mapstr.M{
						"metrics": mapstr.M{
							*mn: counter.GetValue(),
						},
					},
					Labels:    labels,
					Exemplars: exemplars,
				})
			}
		}

		gauge := metric.GetGauge()
		if gauge != nil {
			if !math.IsNaN(gauge.GetValue()) && !math.IsInf(gauge.GetValue(), 0) {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeGauge,
					Help: help,
					Unit: unit,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name: gauge.GetValue(),
						},
					},
					Labels: labels,
				})
			}
		}

		info := metric.GetInfo()
		if info != nil {
			if info.HasValidValue() {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeInfo,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name: info.GetValue(),
						},
					},
					Labels: labels,
				})
			}
		}

		stateset := metric.GetStateset()
		if stateset != nil {
			if stateset.HasValidValue() {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeStateset,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name: stateset.GetValue(),
						},
					},
					Labels: labels,
				})
			}
		}

		summary := metric.GetSummary()
		if summary != nil {
			if !math.IsNaN(summary.GetSampleSum()) && !math.IsInf(summary.GetSampleSum(), 0) {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeSummary,
					Help: help,
					Unit: unit,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name + "_sum":   summary.GetSampleSum(),
							name + "_count": summary.GetSampleCount(),
						},
					},
					Labels: labels,
				})
			}

			for _, quantile := range summary.GetQuantile() {
				if math.IsNaN(quantile.GetValue()) || math.IsInf(quantile.GetValue(), 0) {
					continue
				}

				quantileLabels := labels.Clone()
				quantileLabels["quantile"] = strconv.FormatFloat(quantile.GetQuantile(), 'f', -1, 64)
				events = append(events, OpenMetricEvent{
					Data: mapstr.M{
						"metrics": mapstr.M{
							name: quantile.GetValue(),
						},
					},
					Labels: quantileLabels,
				})
			}
		}

		histogram := metric.GetHistogram()
		if histogram != nil {
			if !math.IsNaN(histogram.GetSampleSum()) && !math.IsInf(histogram.GetSampleSum(), 0) {
				var sum = "_sum"
				var count = "_count"
				_, _ = sum, count // skip noisy linter
				var typ = model.MetricTypeHistogram
				if histogram.IsGaugeHistogram {
					sum = "_gsum"
					count = "_gcount"
					typ = model.MetricTypeGaugeHistogram
				}

				events = append(events, OpenMetricEvent{
					Type: typ,
					Help: help,
					Unit: unit,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name + sum:   histogram.GetSampleSum(),
							name + count: histogram.GetSampleCount(),
						},
					},
					Labels: labels,
				})
			}

			for _, bucket := range histogram.GetBucket() {
				if bucket.GetCumulativeCount() == uint64(math.NaN()) || bucket.GetCumulativeCount() == uint64(math.Inf(0)) {
					continue
				}

				if bucket.Exemplar != nil {
					exemplars = mapstr.M{name: bucket.Exemplar.Value}
					if bucket.Exemplar.HasTs {
						_, _ = exemplars.Put("timestamp", bucket.Exemplar.Ts)
					}
					for _, label := range bucket.Exemplar.Labels {
						if label.Name != "" && label.Value != "" {
							_, _ = exemplars.Put("labels."+label.Name, label.Value)
						}
					}
				}

				bucketLabels := labels.Clone()
				bucketLabels["le"] = strconv.FormatFloat(bucket.GetUpperBound(), 'f', -1, 64)

				events = append(events, OpenMetricEvent{
					Data: mapstr.M{
						"metrics": mapstr.M{
							name + "_bucket": bucket.GetCumulativeCount(),
						},
					},
					Labels:    bucketLabels,
					Exemplars: exemplars,
				})
			}
		}

		unknown := metric.GetUnknown()
		if unknown != nil {
			if !math.IsNaN(unknown.GetValue()) && !math.IsInf(unknown.GetValue(), 0) {
				events = append(events, OpenMetricEvent{
					Type: model.MetricTypeUnknown,
					Help: help,
					Unit: unit,
					Data: mapstr.M{
						"metrics": mapstr.M{
							name: unknown.GetValue(),
						},
					},
					Labels: labels,
				})
			}
		}
	}
	return events
}