diff --git a/cmd/mdatagen/internal/loader_test.go b/cmd/mdatagen/internal/loader_test.go index b84b59c8e55..21796b9374f 100644 --- a/cmd/mdatagen/internal/loader_test.go +++ b/cmd/mdatagen/internal/loader_test.go @@ -244,6 +244,14 @@ func TestLoadMetadata(t *testing.T) { FullName: "opt_in_bool_attr", RequirementLevel: AttributeRequirementLevelOptIn, }, + "required_string_attr": { + Description: "A required attribute with a string value", + Type: ValueType{ + ValueType: pcommon.ValueTypeStr, + }, + FullName: "required_string_attr", + RequirementLevel: AttributeRequirementLevelRequired, + }, }, Metrics: map[MetricName]Metric{ "default.metric": { @@ -267,7 +275,7 @@ func TestLoadMetadata(t *testing.T) { "reaggregate.metric": { Signal: Signal{ Enabled: true, - Description: "Metric for testing spacial reaggregation", + Description: "Metric for testing spatial reaggregation", Stability: Stability{Level: component.StabilityLevelBeta}, Attributes: []AttributeName{"string_attr", "boolean_attr"}, }, @@ -276,6 +284,18 @@ func TestLoadMetadata(t *testing.T) { MetricValueType: MetricValueType{pmetric.NumberDataPointValueTypeDouble}, }, }, + "reaggregate.metric.with_required": { + Signal: Signal{ + Enabled: true, + Description: "Metric for testing spatial reaggregation with required attributes", + Stability: Stability{Level: component.StabilityLevelBeta}, + Attributes: []AttributeName{"required_string_attr", "string_attr", "boolean_attr"}, + }, + Unit: strPtr("1"), + Gauge: &Gauge{ + MetricValueType: MetricValueType{pmetric.NumberDataPointValueTypeDouble}, + }, + }, "system.cpu.time": { Signal: Signal{ Enabled: true, diff --git a/cmd/mdatagen/internal/samplereceiver/documentation.md b/cmd/mdatagen/internal/samplereceiver/documentation.md index 392823cbc68..ef72066bdb8 100644 --- a/cmd/mdatagen/internal/samplereceiver/documentation.md +++ b/cmd/mdatagen/internal/samplereceiver/documentation.md @@ -65,7 +65,7 @@ Monotonic cumulative sum int metric with string input_type enabled by default. ### reaggregate.metric -Metric for testing spacial reaggregation +Metric for testing spatial reaggregation | Unit | Metric Type | Value Type | Stability | | ---- | ----------- | ---------- | --------- | @@ -78,6 +78,22 @@ Metric for testing spacial reaggregation | string_attr | Attribute with any string value. | Any Str | Recommended | | boolean_attr | Attribute with a boolean value. | Any Bool | Recommended | +### reaggregate.metric.with_required + +Metric for testing spatial reaggregation with required attributes + +| Unit | Metric Type | Value Type | Stability | +| ---- | ----------- | ---------- | --------- | +| 1 | Gauge | Double | Beta | + +#### Attributes + +| Name | Description | Values | Requirement Level | +| ---- | ----------- | ------ | -------- | +| required_string_attr | A required attribute with a string value | Any Str | Required | +| string_attr | Attribute with any string value. | Any Str | Recommended | +| boolean_attr | Attribute with a boolean value. | Any Bool | Recommended | + ### system.cpu.time Monotonic cumulative sum int metric enabled by default. diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config.go index 26452622fbf..394caca2b59 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config.go @@ -60,13 +60,14 @@ type AttributeConfig struct { // MetricsConfig provides config for sample metrics. type MetricsConfig struct { - DefaultMetric MetricConfig `mapstructure:"default.metric"` - DefaultMetricToBeRemoved MetricConfig `mapstructure:"default.metric.to_be_removed"` - MetricInputType MetricConfig `mapstructure:"metric.input_type"` - OptionalMetric MetricConfig `mapstructure:"optional.metric"` - OptionalMetricEmptyUnit MetricConfig `mapstructure:"optional.metric.empty_unit"` - ReaggregateMetric MetricConfig `mapstructure:"reaggregate.metric"` - SystemCPUTime MetricConfig `mapstructure:"system.cpu.time"` + DefaultMetric MetricConfig `mapstructure:"default.metric"` + DefaultMetricToBeRemoved MetricConfig `mapstructure:"default.metric.to_be_removed"` + MetricInputType MetricConfig `mapstructure:"metric.input_type"` + OptionalMetric MetricConfig `mapstructure:"optional.metric"` + OptionalMetricEmptyUnit MetricConfig `mapstructure:"optional.metric.empty_unit"` + ReaggregateMetric MetricConfig `mapstructure:"reaggregate.metric"` + ReaggregateMetricWithRequired MetricConfig `mapstructure:"reaggregate.metric.with_required"` + SystemCPUTime MetricConfig `mapstructure:"system.cpu.time"` } func DefaultMetricsConfig() MetricsConfig { @@ -119,6 +120,14 @@ func DefaultMetricsConfig() MetricsConfig { definedAttributes: []string{"string_attr", "boolean_attr"}, EnabledAttributes: []string{"string_attr", "boolean_attr"}, }, + ReaggregateMetricWithRequired: MetricConfig{ + Enabled: true, + + AggregationStrategy: AggregationStrategyAvg, + requiredAttributes: []string{"required_string_attr"}, + definedAttributes: []string{"required_string_attr", "string_attr", "boolean_attr"}, + EnabledAttributes: []string{"required_string_attr", "string_attr", "boolean_attr"}, + }, SystemCPUTime: MetricConfig{ Enabled: true, diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config_test.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config_test.go index b10e0ac6cb2..dd90f1d0860 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config_test.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_config_test.go @@ -57,6 +57,11 @@ func TestMetricsBuilderConfig(t *testing.T) { AggregationStrategy: AggregationStrategyAvg, EnabledAttributes: []string{"string_attr", "boolean_attr"}, }, + ReaggregateMetricWithRequired: MetricConfig{ + Enabled: true, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"required_string_attr", "string_attr", "boolean_attr"}, + }, SystemCPUTime: MetricConfig{ Enabled: true, AggregationStrategy: AggregationStrategySum, @@ -109,6 +114,11 @@ func TestMetricsBuilderConfig(t *testing.T) { AggregationStrategy: AggregationStrategyAvg, EnabledAttributes: []string{"string_attr", "boolean_attr"}, }, + ReaggregateMetricWithRequired: MetricConfig{ + Enabled: false, + AggregationStrategy: AggregationStrategyAvg, + EnabledAttributes: []string{"required_string_attr", "string_attr", "boolean_attr"}, + }, SystemCPUTime: MetricConfig{ Enabled: false, AggregationStrategy: AggregationStrategySum, diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go index cebe111f7e2..71dbabba1e0 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics.go @@ -73,19 +73,23 @@ var MetricsInfo = metricsInfo{ ReaggregateMetric: metricInfo{ Name: "reaggregate.metric", }, + ReaggregateMetricWithRequired: metricInfo{ + Name: "reaggregate.metric.with_required", + }, SystemCPUTime: metricInfo{ Name: "system.cpu.time", }, } type metricsInfo struct { - DefaultMetric metricInfo - DefaultMetricToBeRemoved metricInfo - MetricInputType metricInfo - OptionalMetric metricInfo - OptionalMetricEmptyUnit metricInfo - ReaggregateMetric metricInfo - SystemCPUTime metricInfo + DefaultMetric metricInfo + DefaultMetricToBeRemoved metricInfo + MetricInputType metricInfo + OptionalMetric metricInfo + OptionalMetricEmptyUnit metricInfo + ReaggregateMetric metricInfo + ReaggregateMetricWithRequired metricInfo + SystemCPUTime metricInfo } type metricInfo struct { @@ -608,7 +612,7 @@ type metricReaggregateMetric struct { // init fills reaggregate.metric metric with initial data. func (m *metricReaggregateMetric) init() { m.data.SetName("reaggregate.metric") - m.data.SetDescription("Metric for testing spacial reaggregation") + m.data.SetDescription("Metric for testing spatial reaggregation") m.data.SetUnit("1") m.data.SetEmptyGauge() m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) @@ -689,6 +693,100 @@ func newMetricReaggregateMetric(cfg MetricConfig) metricReaggregateMetric { return m } +type metricReaggregateMetricWithRequired struct { + data pmetric.Metric // data buffer for generated metric. + config MetricConfig // metric config provided by user. + capacity int // max observed number of data points added to the metric. + aggDataPoints []float64 // slice containing number of aggregated datapoints at each index +} + +// init fills reaggregate.metric.with_required metric with initial data. +func (m *metricReaggregateMetricWithRequired) init() { + m.data.SetName("reaggregate.metric.with_required") + m.data.SetDescription("Metric for testing spatial reaggregation with required attributes") + m.data.SetUnit("1") + m.data.SetEmptyGauge() + m.data.Gauge().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricReaggregateMetricWithRequired) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val float64, requiredStringAttrAttributeValue string, stringAttrAttributeValue string, booleanAttrAttributeValue bool) { + if !m.config.Enabled { + return + } + + dp := pmetric.NewNumberDataPoint() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + if slices.Contains(m.config.EnabledAttributes, "required_string_attr") { + dp.Attributes().PutStr("required_string_attr", requiredStringAttrAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "string_attr") { + dp.Attributes().PutStr("string_attr", stringAttrAttributeValue) + } + if slices.Contains(m.config.EnabledAttributes, "boolean_attr") { + dp.Attributes().PutBool("boolean_attr", booleanAttrAttributeValue) + } + + var s string + dps := m.data.Gauge().DataPoints() + for i := 0; i < dps.Len(); i++ { + dpi := dps.At(i) + if dp.Attributes().Equal(dpi.Attributes()) && dp.StartTimestamp() == dpi.StartTimestamp() && dp.Timestamp() == dpi.Timestamp() { + switch s = m.config.AggregationStrategy; s { + case AggregationStrategySum, AggregationStrategyAvg: + dpi.SetDoubleValue(dpi.DoubleValue() + val) + m.aggDataPoints[i] += 1 + return + case AggregationStrategyMin: + if dpi.DoubleValue() > val { + dpi.SetDoubleValue(val) + } + return + case AggregationStrategyMax: + if dpi.DoubleValue() < val { + dpi.SetDoubleValue(val) + } + return + } + } + } + + dp.SetDoubleValue(val) + m.aggDataPoints = append(m.aggDataPoints, 1) + dp.MoveTo(dps.AppendEmpty()) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricReaggregateMetricWithRequired) updateCapacity() { + if m.data.Gauge().DataPoints().Len() > m.capacity { + m.capacity = m.data.Gauge().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricReaggregateMetricWithRequired) emit(metrics pmetric.MetricSlice) { + if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + if m.config.AggregationStrategy == AggregationStrategyAvg { + for i, aggCount := range m.aggDataPoints { + m.data.Gauge().DataPoints().At(i).SetDoubleValue(m.data.Gauge().DataPoints().At(i).DoubleValue() / aggCount) + } + } + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricReaggregateMetricWithRequired(cfg MetricConfig) metricReaggregateMetricWithRequired { + m := metricReaggregateMetricWithRequired{config: cfg} + + if cfg.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + type metricSystemCPUTime struct { data pmetric.Metric // data buffer for generated metric. config MetricConfig // metric config provided by user. @@ -778,20 +876,21 @@ func newMetricSystemCPUTime(cfg MetricConfig) metricSystemCPUTime { // MetricsBuilder provides an interface for scrapers to report metrics while taking care of all the transformations // required to produce metric representation defined in metadata and user config. type MetricsBuilder struct { - config MetricsBuilderConfig // config of the metrics builder. - startTime pcommon.Timestamp // start time that will be applied to all recorded data points. - metricsCapacity int // maximum observed number of metrics per resource. - metricsBuffer pmetric.Metrics // accumulates metrics data before emitting. - buildInfo component.BuildInfo // contains version information. - resourceAttributeIncludeFilter map[string]filter.Filter - resourceAttributeExcludeFilter map[string]filter.Filter - metricDefaultMetric metricDefaultMetric - metricDefaultMetricToBeRemoved metricDefaultMetricToBeRemoved - metricMetricInputType metricMetricInputType - metricOptionalMetric metricOptionalMetric - metricOptionalMetricEmptyUnit metricOptionalMetricEmptyUnit - metricReaggregateMetric metricReaggregateMetric - metricSystemCPUTime metricSystemCPUTime + config MetricsBuilderConfig // config of the metrics builder. + startTime pcommon.Timestamp // start time that will be applied to all recorded data points. + metricsCapacity int // maximum observed number of metrics per resource. + metricsBuffer pmetric.Metrics // accumulates metrics data before emitting. + buildInfo component.BuildInfo // contains version information. + resourceAttributeIncludeFilter map[string]filter.Filter + resourceAttributeExcludeFilter map[string]filter.Filter + metricDefaultMetric metricDefaultMetric + metricDefaultMetricToBeRemoved metricDefaultMetricToBeRemoved + metricMetricInputType metricMetricInputType + metricOptionalMetric metricOptionalMetric + metricOptionalMetricEmptyUnit metricOptionalMetricEmptyUnit + metricReaggregateMetric metricReaggregateMetric + metricReaggregateMetricWithRequired metricReaggregateMetricWithRequired + metricSystemCPUTime metricSystemCPUTime } // MetricBuilderOption applies changes to default metrics builder. @@ -834,19 +933,20 @@ func NewMetricsBuilder(mbc MetricsBuilderConfig, settings receiver.Settings, opt settings.Logger.Warn("[WARNING] `string.resource.attr_to_be_removed` should not be enabled: This resource_attribute is deprecated and will be removed soon.") } mb := &MetricsBuilder{ - config: mbc, - startTime: pcommon.NewTimestampFromTime(time.Now()), - metricsBuffer: pmetric.NewMetrics(), - buildInfo: settings.BuildInfo, - metricDefaultMetric: newMetricDefaultMetric(mbc.Metrics.DefaultMetric), - metricDefaultMetricToBeRemoved: newMetricDefaultMetricToBeRemoved(mbc.Metrics.DefaultMetricToBeRemoved), - metricMetricInputType: newMetricMetricInputType(mbc.Metrics.MetricInputType), - metricOptionalMetric: newMetricOptionalMetric(mbc.Metrics.OptionalMetric), - metricOptionalMetricEmptyUnit: newMetricOptionalMetricEmptyUnit(mbc.Metrics.OptionalMetricEmptyUnit), - metricReaggregateMetric: newMetricReaggregateMetric(mbc.Metrics.ReaggregateMetric), - metricSystemCPUTime: newMetricSystemCPUTime(mbc.Metrics.SystemCPUTime), - resourceAttributeIncludeFilter: make(map[string]filter.Filter), - resourceAttributeExcludeFilter: make(map[string]filter.Filter), + config: mbc, + startTime: pcommon.NewTimestampFromTime(time.Now()), + metricsBuffer: pmetric.NewMetrics(), + buildInfo: settings.BuildInfo, + metricDefaultMetric: newMetricDefaultMetric(mbc.Metrics.DefaultMetric), + metricDefaultMetricToBeRemoved: newMetricDefaultMetricToBeRemoved(mbc.Metrics.DefaultMetricToBeRemoved), + metricMetricInputType: newMetricMetricInputType(mbc.Metrics.MetricInputType), + metricOptionalMetric: newMetricOptionalMetric(mbc.Metrics.OptionalMetric), + metricOptionalMetricEmptyUnit: newMetricOptionalMetricEmptyUnit(mbc.Metrics.OptionalMetricEmptyUnit), + metricReaggregateMetric: newMetricReaggregateMetric(mbc.Metrics.ReaggregateMetric), + metricReaggregateMetricWithRequired: newMetricReaggregateMetricWithRequired(mbc.Metrics.ReaggregateMetricWithRequired), + metricSystemCPUTime: newMetricSystemCPUTime(mbc.Metrics.SystemCPUTime), + resourceAttributeIncludeFilter: make(map[string]filter.Filter), + resourceAttributeExcludeFilter: make(map[string]filter.Filter), } if mbc.ResourceAttributes.MapResourceAttr.MetricsInclude != nil { mb.resourceAttributeIncludeFilter["map.resource.attr"] = filter.CreateFilter(mbc.ResourceAttributes.MapResourceAttr.MetricsInclude) @@ -972,6 +1072,7 @@ func (mb *MetricsBuilder) EmitForResource(options ...ResourceMetricsOption) { mb.metricOptionalMetric.emit(ils.Metrics()) mb.metricOptionalMetricEmptyUnit.emit(ils.Metrics()) mb.metricReaggregateMetric.emit(ils.Metrics()) + mb.metricReaggregateMetricWithRequired.emit(ils.Metrics()) mb.metricSystemCPUTime.emit(ils.Metrics()) for _, op := range options { @@ -1039,6 +1140,11 @@ func (mb *MetricsBuilder) RecordReaggregateMetricDataPoint(ts pcommon.Timestamp, mb.metricReaggregateMetric.recordDataPoint(mb.startTime, ts, val, stringAttrAttributeValue, booleanAttrAttributeValue) } +// RecordReaggregateMetricWithRequiredDataPoint adds a data point to reaggregate.metric.with_required metric. +func (mb *MetricsBuilder) RecordReaggregateMetricWithRequiredDataPoint(ts pcommon.Timestamp, val float64, requiredStringAttrAttributeValue string, stringAttrAttributeValue string, booleanAttrAttributeValue bool) { + mb.metricReaggregateMetricWithRequired.recordDataPoint(mb.startTime, ts, val, requiredStringAttrAttributeValue, stringAttrAttributeValue, booleanAttrAttributeValue) +} + // RecordSystemCPUTimeDataPoint adds a data point to system.cpu.time metric. func (mb *MetricsBuilder) RecordSystemCPUTimeDataPoint(ts pcommon.Timestamp, val int64) { mb.metricSystemCPUTime.recordDataPoint(mb.startTime, ts, val) diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go index e7224bd3b32..cc852b3623b 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/generated_metrics_test.go @@ -74,6 +74,7 @@ func TestMetricsBuilder(t *testing.T) { aggMap["OptionalMetric"] = mb.metricOptionalMetric.config.AggregationStrategy aggMap["OptionalMetricEmptyUnit"] = mb.metricOptionalMetricEmptyUnit.config.AggregationStrategy aggMap["ReaggregateMetric"] = mb.metricReaggregateMetric.config.AggregationStrategy + aggMap["ReaggregateMetricWithRequired"] = mb.metricReaggregateMetricWithRequired.config.AggregationStrategy aggMap["SystemCPUTime"] = mb.metricSystemCPUTime.config.AggregationStrategy expectedWarnings := 0 @@ -152,6 +153,13 @@ func TestMetricsBuilder(t *testing.T) { mb.RecordReaggregateMetricDataPoint(ts, 3, "string_attr-val-2", false) } + defaultMetricsCount++ + allMetricsCount++ + mb.RecordReaggregateMetricWithRequiredDataPoint(ts, 1, "required_string_attr-val", "string_attr-val", true) + if tt.name == "reaggregate_set" { + mb.RecordReaggregateMetricWithRequiredDataPoint(ts, 3, "required_string_attr-val", "string_attr-val-2", false) + } + defaultMetricsCount++ allMetricsCount++ mb.RecordSystemCPUTimeDataPoint(ts, 1) @@ -469,7 +477,7 @@ func TestMetricsBuilder(t *testing.T) { validatedMetrics["reaggregate.metric"] = true assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Metric for testing spacial reaggregation", ms.At(i).Description()) + assert.Equal(t, "Metric for testing spatial reaggregation", ms.At(i).Description()) assert.Equal(t, "1", ms.At(i).Unit()) dp := ms.At(i).Gauge().DataPoints().At(0) assert.Equal(t, start, dp.StartTimestamp()) @@ -487,7 +495,7 @@ func TestMetricsBuilder(t *testing.T) { validatedMetrics["reaggregate.metric"] = true assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) - assert.Equal(t, "Metric for testing spacial reaggregation", ms.At(i).Description()) + assert.Equal(t, "Metric for testing spatial reaggregation", ms.At(i).Description()) assert.Equal(t, "1", ms.At(i).Unit()) dp := ms.At(i).Gauge().DataPoints().At(0) assert.Equal(t, start, dp.StartTimestamp()) @@ -508,6 +516,56 @@ func TestMetricsBuilder(t *testing.T) { _, ok = dp.Attributes().Get("boolean_attr") assert.False(t, ok) } + case "reaggregate.metric.with_required": + if tt.name != "reaggregate_set" { + assert.False(t, validatedMetrics["reaggregate.metric.with_required"], "Found a duplicate in the metrics slice: reaggregate.metric.with_required") + validatedMetrics["reaggregate.metric.with_required"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Metric for testing spatial reaggregation with required attributes", ms.At(i).Description()) + assert.Equal(t, "1", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + attrVal, ok := dp.Attributes().Get("required_string_attr") + assert.True(t, ok) + assert.Equal(t, "required_string_attr-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("string_attr") + assert.True(t, ok) + assert.Equal(t, "string_attr-val", attrVal.Str()) + attrVal, ok = dp.Attributes().Get("boolean_attr") + assert.True(t, ok) + assert.True(t, attrVal.Bool()) + } else { + assert.False(t, validatedMetrics["reaggregate.metric.with_required"], "Found a duplicate in the metrics slice: reaggregate.metric.with_required") + validatedMetrics["reaggregate.metric.with_required"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "Metric for testing spatial reaggregation with required attributes", ms.At(i).Description()) + assert.Equal(t, "1", ms.At(i).Unit()) + dp := ms.At(i).Gauge().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeDouble, dp.ValueType()) + switch aggMap["reaggregate.metric.with_required"] { + case "sum": + assert.InDelta(t, float64(4), dp.DoubleValue(), 0.01) + case "avg": + assert.InDelta(t, float64(2), dp.DoubleValue(), 0.01) + case "min": + assert.InDelta(t, float64(1), dp.DoubleValue(), 0.01) + case "max": + assert.InDelta(t, float64(3), dp.DoubleValue(), 0.01) + } + _, ok := dp.Attributes().Get("required_string_attr") + assert.True(t, ok) + _, ok = dp.Attributes().Get("string_attr") + assert.False(t, ok) + _, ok = dp.Attributes().Get("boolean_attr") + assert.False(t, ok) + } case "system.cpu.time": if tt.name != "reaggregate_set" { assert.False(t, validatedMetrics["system.cpu.time"], "Found a duplicate in the metrics slice: system.cpu.time") diff --git a/cmd/mdatagen/internal/samplereceiver/internal/metadata/testdata/config.yaml b/cmd/mdatagen/internal/samplereceiver/internal/metadata/testdata/config.yaml index 5fa13473d88..9d11a3a39cd 100644 --- a/cmd/mdatagen/internal/samplereceiver/internal/metadata/testdata/config.yaml +++ b/cmd/mdatagen/internal/samplereceiver/internal/metadata/testdata/config.yaml @@ -19,6 +19,9 @@ all_set: reaggregate.metric: enabled: true attributes: ["string_attr","boolean_attr"] + reaggregate.metric.with_required: + enabled: true + attributes: ["required_string_attr","string_attr","boolean_attr"] system.cpu.time: enabled: true attributes: [] @@ -66,6 +69,9 @@ reaggregate_set: reaggregate.metric: enabled: true attributes: [] + reaggregate.metric.with_required: + enabled: true + attributes: ["required_string_attr"] system.cpu.time: enabled: true attributes: [] @@ -113,6 +119,9 @@ none_set: reaggregate.metric: enabled: false attributes: ["string_attr","boolean_attr"] + reaggregate.metric.with_required: + enabled: false + attributes: ["required_string_attr","string_attr","boolean_attr"] system.cpu.time: enabled: false attributes: [] diff --git a/cmd/mdatagen/internal/samplereceiver/metadata.yaml b/cmd/mdatagen/internal/samplereceiver/metadata.yaml index 77c502160e2..0e4738dec62 100644 --- a/cmd/mdatagen/internal/samplereceiver/metadata.yaml +++ b/cmd/mdatagen/internal/samplereceiver/metadata.yaml @@ -116,6 +116,11 @@ attributes: description: Integer attribute with overridden name. type: int + required_string_attr: + description: A required attribute with a string value + type: string + requirement_level: required + slice_attr: description: Attribute with a slice value. type: slice @@ -239,7 +244,7 @@ metrics: reaggregate.metric: enabled: true - description: Metric for testing spacial reaggregation + description: Metric for testing spatial reaggregation unit: "1" stability: level: beta @@ -247,6 +252,16 @@ metrics: value_type: double attributes: [string_attr, boolean_attr] + reaggregate.metric.with_required: + enabled: true + description: Metric for testing spatial reaggregation with required attributes + unit: "1" + stability: + level: beta + gauge: + value_type: double + attributes: [required_string_attr, string_attr, boolean_attr] + system.cpu.time: enabled: true stability: diff --git a/cmd/mdatagen/internal/templates/metrics_test.go.tmpl b/cmd/mdatagen/internal/templates/metrics_test.go.tmpl index ab3fe09932c..08be437a3cb 100644 --- a/cmd/mdatagen/internal/templates/metrics_test.go.tmpl +++ b/cmd/mdatagen/internal/templates/metrics_test.go.tmpl @@ -159,7 +159,11 @@ func TestMetricsBuilder(t *testing.T) { mb.Record{{ $name.Render }}DataPoint(ts, {{ if $metric.Data.HasMetricInputType }}"3"{{ else }}3{{ end }} {{- range $metric.Attributes -}} {{- if not (attributeInfo .).IsConditional -}} + {{- if (attributeInfo .).IsRequired -}} + , {{- template "getAttributeValue" . -}} + {{- else -}} , {{- template "getAttributeValueTwo" . -}} + {{- end -}} {{- end -}} {{- end -}} {{- range $metric.Attributes -}} diff --git a/cmd/mdatagen/internal/templates/testdata/config.yaml.tmpl b/cmd/mdatagen/internal/templates/testdata/config.yaml.tmpl index ee2c73712ee..d665cdddd94 100644 --- a/cmd/mdatagen/internal/templates/testdata/config.yaml.tmpl +++ b/cmd/mdatagen/internal/templates/testdata/config.yaml.tmpl @@ -28,11 +28,11 @@ reaggregate_set: {{- end }} {{- if .Metrics }} metrics: - {{- range $name, $_ := .Metrics }} + {{- range $name, $metric := .Metrics }} {{ $name }}: enabled: true {{- if $reag }} - attributes: [] + attributes: [{{- range $index, $attr := requiredAttributes $metric.Attributes -}}{{ if $index }},{{ end }}"{{ $attr }}"{{- end -}}] {{- end }} {{- end }} {{- end }}