func()

in plugins/outputs/cloudwatch/cloudwatch.go [412:530]

• 108 lines of code
• 31 McCabe index (conditional complexity)

func (c *CloudWatch) BuildMetricDatum(point telegraf.Metric) []*cloudwatch.MetricDatum {
	//high resolution logic
	isHighResolution := false
	highResolutionValue, ok := point.Tags()[highResolutionTagKey]
	if ok && strings.EqualFold(highResolutionValue, "true") {
		isHighResolution = true
		point.RemoveTag(highResolutionTagKey)
	}

	rawDimensions := BuildDimensions(point.Tags())
	dimensionsList := c.ProcessRollup(rawDimensions)
	//https://pratheekadidela.in/2016/02/11/is-append-in-go-efficient/
	//https://www.ardanlabs.com/blog/2013/08/understanding-slices-in-go-programming.html
	var datums []*cloudwatch.MetricDatum
	for k, v := range point.Fields() {
		log.Printf("D! #Fields of the current point: k - %s v - %f", k, v)
		var unit string
		var value float64
		var distList []distribution.Distribution

		switch t := v.(type) {
		case uint:
			value = float64(t)
		case uint8:
			value = float64(t)
		case uint16:
			value = float64(t)
		case uint32:
			value = float64(t)
		case uint64:
			value = float64(t)
		case int:
			value = float64(t)
		case int8:
			value = float64(t)
		case int16:
			value = float64(t)
		case int32:
			value = float64(t)
		case int64:
			value = float64(t)
		case float32:
			value = float64(t)
		case float64:
			value = t
		case bool:
			if t {
				value = 1
			} else {
				value = 0
			}
		case time.Time:
			value = float64(t.Unix())
		case distribution.Distribution:
			if t.Size() == 0 {
				// the distribution does not have a value
				continue
			}
			distList = resize(t, c.MaxValuesPerDatum)
			unit = t.Unit()
		default:
			// Skip unsupported type.
			continue
		}

		metricName := aws.String(c.decorateMetricName(point.Name(), k))
		if unit == "" {
			unit = c.decorateMetricUnit(point.Name(), k)
		}

		for index, dimensions := range dimensionsList {
			//index == 0 means it's the original metrics, and if the metric name and dimension matches, skip creating
			//metric datum
			if index == 0 && c.IsDropping(point.Name(), k) {
				continue
			}
			if len(distList) == 0 {
				datum := &cloudwatch.MetricDatum{
					MetricName: metricName,
					Dimensions: dimensions,
					Timestamp:  aws.Time(point.Time()),
					Value:      aws.Float64(value),
				}
				if unit != "" {
					datum.SetUnit(unit)
				}
				if isHighResolution {
					datum.SetStorageResolution(1)
				}
				datums = append(datums, datum)
			} else {
				for _, dist := range distList {
					datum := &cloudwatch.MetricDatum{
						MetricName: metricName,
						Dimensions: dimensions,
						Timestamp:  aws.Time(point.Time()),
					}
					values, counts := dist.ValuesAndCounts()
					datum.SetValues(aws.Float64Slice(values))
					datum.SetCounts(aws.Float64Slice(counts))
					datum.SetStatisticValues(&cloudwatch.StatisticSet{
						Maximum:     aws.Float64(dist.Maximum()),
						Minimum:     aws.Float64(dist.Minimum()),
						SampleCount: aws.Float64(dist.SampleCount()),
						Sum:         aws.Float64(dist.Sum()),
					})
					if unit != "" {
						datum.SetUnit(unit)
					}
					if isHighResolution {
						datum.SetStorageResolution(1)
					}
					datums = append(datums, datum)
				}
			}
		}
	}
	return datums
}