From 35ca8dc732a65badaec6ebe9e966cb339fab2390 Mon Sep 17 00:00:00 2001 From: Dmitry Date: Sun, 27 Mar 2022 11:31:11 -0700 Subject: [PATCH 1/2] [receiver/hostmetrics] Migrate Processes scraper to the Metrics builder --- CHANGELOG.md | 2 + receiver/hostmetricsreceiver/config_test.go | 2 +- .../hostmetrics_receiver_test.go | 2 +- .../scraper/processesscraper/config.go | 8 +- .../internal/scraper/processesscraper/doc.go | 2 +- .../scraper/processesscraper/documentation.md | 9 +- .../scraper/processesscraper/factory.go | 5 +- .../internal/metadata/generated_metrics.go | 136 --------- .../internal/metadata/generated_metrics_v2.go | 274 ++++++++++++++++++ .../processesscraper/processes_scraper.go | 44 +-- .../processes_scraper_test.go | 22 +- 11 files changed, 321 insertions(+), 185 deletions(-) delete mode 100644 receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics.go create mode 100644 receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 9b9688c8980e..6f716e35e79f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,8 @@ - `dynatraceexporter`: add multi-instance deployment note to README.md (#8848) - `resourcedetectionprocessor`: Add attribute allowlist (#8547) - `datadogexporter`: Metrics payload data and Sketches payload data will be logged if collector is started in debug mode (#8929) +- `cmd/mdatagen`: Add resource attributes definition to metadata.yaml and move `pdata.Metrics` creation to the + generated code (#5270) ### ๐Ÿ›‘ Breaking changes ๐Ÿ›‘ diff --git a/receiver/hostmetricsreceiver/config_test.go b/receiver/hostmetricsreceiver/config_test.go index d909a7e07060..6099cb722cd6 100644 --- a/receiver/hostmetricsreceiver/config_test.go +++ b/receiver/hostmetricsreceiver/config_test.go @@ -84,7 +84,7 @@ func TestLoadConfig(t *testing.T) { } return cfg })(), - processesscraper.TypeStr: &processesscraper.Config{}, + processesscraper.TypeStr: (&processesscraper.Factory{}).CreateDefaultConfig(), pagingscraper.TypeStr: (&pagingscraper.Factory{}).CreateDefaultConfig(), processscraper.TypeStr: (func() internal.Config { cfg := (&processscraper.Factory{}).CreateDefaultConfig() diff --git a/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go b/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go index 682ae3f07351..710b7b60109c 100644 --- a/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go +++ b/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go @@ -112,7 +112,7 @@ func TestGatherMetrics_EndToEnd(t *testing.T) { memoryscraper.TypeStr: scraperFactories[memoryscraper.TypeStr].CreateDefaultConfig(), networkscraper.TypeStr: scraperFactories[networkscraper.TypeStr].CreateDefaultConfig(), pagingscraper.TypeStr: scraperFactories[pagingscraper.TypeStr].CreateDefaultConfig(), - processesscraper.TypeStr: &processesscraper.Config{}, + processesscraper.TypeStr: scraperFactories[processesscraper.TypeStr].CreateDefaultConfig(), }, } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/config.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/config.go index 4b5b0accb5e7..8757ff699679 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/config.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/config.go @@ -14,9 +14,15 @@ package processesscraper // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal/scraper/processesscraper" -import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal" +import ( + "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal" + "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata" +) // Config relating to Processes Metric Scraper. type Config struct { internal.ConfigSettings `mapstructure:",squash"` // squash ensures fields are correctly decoded in embedded struct + + // Metrics allows customizing scraped metrics representation. + Metrics metadata.MetricsSettings `mapstructure:"metrics"` } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/doc.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/doc.go index bc5cf0354f16..975b7383badb 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/doc.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/doc.go @@ -15,6 +15,6 @@ //go:build !windows // +build !windows -//go:generate mdatagen metadata.yaml +//go:generate mdatagen --experimental-gen metadata.yaml package processesscraper // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal/scraper/processesscraper" diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/documentation.md b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/documentation.md index a2d27dcef307..0aa165ba5089 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/documentation.md +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/documentation.md @@ -11,7 +11,14 @@ These are the metrics available for this scraper. | **system.processes.count** | Total number of processes in each state. | {processes} | Sum(Int) | | | **system.processes.created** | Total number of created processes. | {processes} | Sum(Int) | | -**Highlighted metrics** are emitted by default. +**Highlighted metrics** are emitted by default. Other metrics are optional and not emitted by default. +Any metric can be enabled or disabled with the following scraper configuration: + +```yaml +metrics: + : + enabled: +``` ## Metric attributes diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/factory.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/factory.go index 213f3739f593..85eece1a41ef 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/factory.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/factory.go @@ -21,6 +21,7 @@ import ( "go.uber.org/zap" "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal" + "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata" ) // This file implements Factory for Processes scraper. @@ -36,7 +37,9 @@ type Factory struct { // CreateDefaultConfig creates the default configuration for the Scraper. func (f *Factory) CreateDefaultConfig() internal.Config { - return &Config{} + return &Config{ + Metrics: metadata.DefaultMetricsSettings(), + } } // CreateMetricsScraper creates a scraper based on provided config. diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics.go deleted file mode 100644 index 3f9dc84fffd4..000000000000 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics.go +++ /dev/null @@ -1,136 +0,0 @@ -// Code generated by mdatagen. DO NOT EDIT. - -package metadata - -import ( - "go.opentelemetry.io/collector/config" - "go.opentelemetry.io/collector/model/pdata" -) - -// Type is the component type name. -const Type config.Type = "hostmetricsreceiver/processes" - -// MetricIntf is an interface to generically interact with generated metric. -type MetricIntf interface { - Name() string - New() pdata.Metric - Init(metric pdata.Metric) -} - -// Intentionally not exposing this so that it is opaque and can change freely. -type metricImpl struct { - name string - initFunc func(pdata.Metric) -} - -// Name returns the metric name. -func (m *metricImpl) Name() string { - return m.name -} - -// New creates a metric object preinitialized. -func (m *metricImpl) New() pdata.Metric { - metric := pdata.NewMetric() - m.Init(metric) - return metric -} - -// Init initializes the provided metric object. -func (m *metricImpl) Init(metric pdata.Metric) { - m.initFunc(metric) -} - -type metricStruct struct { - SystemProcessesCount MetricIntf - SystemProcessesCreated MetricIntf -} - -// Names returns a list of all the metric name strings. -func (m *metricStruct) Names() []string { - return []string{ - "system.processes.count", - "system.processes.created", - } -} - -var metricsByName = map[string]MetricIntf{ - "system.processes.count": Metrics.SystemProcessesCount, - "system.processes.created": Metrics.SystemProcessesCreated, -} - -func (m *metricStruct) ByName(n string) MetricIntf { - return metricsByName[n] -} - -// Metrics contains a set of methods for each metric that help with -// manipulating those metrics. -var Metrics = &metricStruct{ - &metricImpl{ - "system.processes.count", - func(metric pdata.Metric) { - metric.SetName("system.processes.count") - metric.SetDescription("Total number of processes in each state.") - metric.SetUnit("{processes}") - metric.SetDataType(pdata.MetricDataTypeSum) - metric.Sum().SetIsMonotonic(false) - metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) - }, - }, - &metricImpl{ - "system.processes.created", - func(metric pdata.Metric) { - metric.SetName("system.processes.created") - metric.SetDescription("Total number of created processes.") - metric.SetUnit("{processes}") - metric.SetDataType(pdata.MetricDataTypeSum) - metric.Sum().SetIsMonotonic(true) - metric.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) - }, - }, -} - -// M contains a set of methods for each metric that help with -// manipulating those metrics. M is an alias for Metrics -var M = Metrics - -// Attributes contains the possible metric attributes that can be used. -var Attributes = struct { - // Status (Breakdown status of the processes.) - Status string -}{ - "status", -} - -// A is an alias for Attributes. -var A = Attributes - -// AttributeStatus are the possible values that the attribute "status" can have. -var AttributeStatus = struct { - Blocked string - Daemon string - Detached string - Idle string - Locked string - Orphan string - Paging string - Running string - Sleeping string - Stopped string - System string - Unknown string - Zombies string -}{ - "blocked", - "daemon", - "detached", - "idle", - "locked", - "orphan", - "paging", - "running", - "sleeping", - "stopped", - "system", - "unknown", - "zombies", -} diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go new file mode 100644 index 000000000000..18aad46f4097 --- /dev/null +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/internal/metadata/generated_metrics_v2.go @@ -0,0 +1,274 @@ +// Code generated by mdatagen. DO NOT EDIT. + +package metadata + +import ( + "time" + + "go.opentelemetry.io/collector/model/pdata" +) + +// MetricSettings provides common settings for a particular metric. +type MetricSettings struct { + Enabled bool `mapstructure:"enabled"` +} + +// MetricsSettings provides settings for hostmetricsreceiver/processes metrics. +type MetricsSettings struct { + SystemProcessesCount MetricSettings `mapstructure:"system.processes.count"` + SystemProcessesCreated MetricSettings `mapstructure:"system.processes.created"` +} + +func DefaultMetricsSettings() MetricsSettings { + return MetricsSettings{ + SystemProcessesCount: MetricSettings{ + Enabled: true, + }, + SystemProcessesCreated: MetricSettings{ + Enabled: true, + }, + } +} + +type metricSystemProcessesCount struct { + data pdata.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills system.processes.count metric with initial data. +func (m *metricSystemProcessesCount) init() { + m.data.SetName("system.processes.count") + m.data.SetDescription("Total number of processes in each state.") + m.data.SetUnit("{processes}") + m.data.SetDataType(pdata.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(false) + m.data.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricSystemProcessesCount) recordDataPoint(start pdata.Timestamp, ts pdata.Timestamp, val int64, statusAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().Insert(A.Status, pdata.NewValueString(statusAttributeValue)) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemProcessesCount) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricSystemProcessesCount) emit(metrics pdata.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemProcessesCount(settings MetricSettings) metricSystemProcessesCount { + m := metricSystemProcessesCount{settings: settings} + if settings.Enabled { + m.data = pdata.NewMetric() + m.init() + } + return m +} + +type metricSystemProcessesCreated struct { + data pdata.Metric // data buffer for generated metric. + settings MetricSettings // metric settings provided by user. + capacity int // max observed number of data points added to the metric. +} + +// init fills system.processes.created metric with initial data. +func (m *metricSystemProcessesCreated) init() { + m.data.SetName("system.processes.created") + m.data.SetDescription("Total number of created processes.") + m.data.SetUnit("{processes}") + m.data.SetDataType(pdata.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pdata.MetricAggregationTemporalityCumulative) +} + +func (m *metricSystemProcessesCreated) recordDataPoint(start pdata.Timestamp, ts pdata.Timestamp, val int64) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemProcessesCreated) updateCapacity() { + if m.data.Sum().DataPoints().Len() > m.capacity { + m.capacity = m.data.Sum().DataPoints().Len() + } +} + +// emit appends recorded metric data to a metrics slice and prepares it for recording another set of data points. +func (m *metricSystemProcessesCreated) emit(metrics pdata.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemProcessesCreated(settings MetricSettings) metricSystemProcessesCreated { + m := metricSystemProcessesCreated{settings: settings} + if settings.Enabled { + m.data = pdata.NewMetric() + m.init() + } + return m +} + +// 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 settings. +type MetricsBuilder struct { + startTime pdata.Timestamp // start time that will be applied to all recorded data points. + metricsCapacity int // maximum observed number of metrics per resource. + resourceCapacity int // maximum observed number of resource attributes. + metricsBuffer pdata.Metrics // accumulates metrics data before emitting. + metricSystemProcessesCount metricSystemProcessesCount + metricSystemProcessesCreated metricSystemProcessesCreated +} + +// metricBuilderOption applies changes to default metrics builder. +type metricBuilderOption func(*MetricsBuilder) + +// WithStartTime sets startTime on the metrics builder. +func WithStartTime(startTime pdata.Timestamp) metricBuilderOption { + return func(mb *MetricsBuilder) { + mb.startTime = startTime + } +} + +func NewMetricsBuilder(settings MetricsSettings, options ...metricBuilderOption) *MetricsBuilder { + mb := &MetricsBuilder{ + startTime: pdata.NewTimestampFromTime(time.Now()), + metricsBuffer: pdata.NewMetrics(), + metricSystemProcessesCount: newMetricSystemProcessesCount(settings.SystemProcessesCount), + metricSystemProcessesCreated: newMetricSystemProcessesCreated(settings.SystemProcessesCreated), + } + for _, op := range options { + op(mb) + } + return mb +} + +// updateCapacity updates max length of metrics and resource attributes that will be used for the slice capacity. +func (mb *MetricsBuilder) updateCapacity(rm pdata.ResourceMetrics) { + if mb.metricsCapacity < rm.ScopeMetrics().At(0).Metrics().Len() { + mb.metricsCapacity = rm.ScopeMetrics().At(0).Metrics().Len() + } + if mb.resourceCapacity < rm.Resource().Attributes().Len() { + mb.resourceCapacity = rm.Resource().Attributes().Len() + } +} + +// ResourceOption applies changes to provided resource. +type ResourceOption func(pdata.Resource) + +// EmitForResource saves all the generated metrics under a new resource and updates the internal state to be ready for +// recording another set of data points as part of another resource. This function can be helpful when one scraper +// needs to emit metrics from several resources. Otherwise calling this function is not required, +// just `Emit` function can be called instead. Resource attributes should be provided as ResourceOption arguments. +func (mb *MetricsBuilder) EmitForResource(ro ...ResourceOption) { + rm := pdata.NewResourceMetrics() + rm.Resource().Attributes().EnsureCapacity(mb.resourceCapacity) + for _, op := range ro { + op(rm.Resource()) + } + ils := rm.ScopeMetrics().AppendEmpty() + ils.Scope().SetName("otelcol/hostmetricsreceiver/processes") + ils.Metrics().EnsureCapacity(mb.metricsCapacity) + mb.metricSystemProcessesCount.emit(ils.Metrics()) + mb.metricSystemProcessesCreated.emit(ils.Metrics()) + if ils.Metrics().Len() > 0 { + mb.updateCapacity(rm) + rm.MoveTo(mb.metricsBuffer.ResourceMetrics().AppendEmpty()) + } +} + +// Emit returns all the metrics accumulated by the metrics builder and updates the internal state to be ready for +// recording another set of metrics. This function will be responsible for applying all the transformations required to +// produce metric representation defined in metadata and user settings, e.g. delta or cumulative. +func (mb *MetricsBuilder) Emit(ro ...ResourceOption) pdata.Metrics { + mb.EmitForResource(ro...) + metrics := pdata.NewMetrics() + mb.metricsBuffer.MoveTo(metrics) + return metrics +} + +// RecordSystemProcessesCountDataPoint adds a data point to system.processes.count metric. +func (mb *MetricsBuilder) RecordSystemProcessesCountDataPoint(ts pdata.Timestamp, val int64, statusAttributeValue string) { + mb.metricSystemProcessesCount.recordDataPoint(mb.startTime, ts, val, statusAttributeValue) +} + +// RecordSystemProcessesCreatedDataPoint adds a data point to system.processes.created metric. +func (mb *MetricsBuilder) RecordSystemProcessesCreatedDataPoint(ts pdata.Timestamp, val int64) { + mb.metricSystemProcessesCreated.recordDataPoint(mb.startTime, ts, val) +} + +// Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, +// and metrics builder should update its startTime and reset it's internal state accordingly. +func (mb *MetricsBuilder) Reset(options ...metricBuilderOption) { + mb.startTime = pdata.NewTimestampFromTime(time.Now()) + for _, op := range options { + op(mb) + } +} + +// Attributes contains the possible metric attributes that can be used. +var Attributes = struct { + // Status (Breakdown status of the processes.) + Status string +}{ + "status", +} + +// A is an alias for Attributes. +var A = Attributes + +// AttributeStatus are the possible values that the attribute "status" can have. +var AttributeStatus = struct { + Blocked string + Daemon string + Detached string + Idle string + Locked string + Orphan string + Paging string + Running string + Sleeping string + Stopped string + System string + Unknown string + Zombies string +}{ + "blocked", + "daemon", + "detached", + "idle", + "locked", + "orphan", + "paging", + "running", + "sleeping", + "stopped", + "system", + "unknown", + "zombies", +} diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go index 7f84de2d2ad2..ea112b2eedc9 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper.go @@ -41,8 +41,8 @@ var metricsLength = func() int { // scraper for Processes Metrics type scraper struct { - config *Config - startTime pdata.Timestamp + config *Config + mb *metadata.MetricsBuilder // for mocking gopsutil getMiscStats func() (*load.MiscStat, error) @@ -80,8 +80,8 @@ func (s *scraper) start(context.Context, component.Host) error { if err != nil { return err } - // bootTime is seconds since 1970, timestamps are in nanoseconds. - s.startTime = pdata.Timestamp(bootTime * 1e9) + + s.mb = metadata.NewMetricsBuilder(s.config.Metrics, metadata.WithStartTime(pdata.Timestamp(bootTime*1e9))) return nil } @@ -89,45 +89,23 @@ func (s *scraper) scrape(_ context.Context) (pdata.Metrics, error) { now := pdata.NewTimestampFromTime(time.Now()) md := pdata.NewMetrics() - metrics := md.ResourceMetrics().AppendEmpty().ScopeMetrics().AppendEmpty().Metrics() + metrics := md.ResourceMetrics().AppendEmpty().InstrumentationLibraryMetrics().AppendEmpty().Metrics() metrics.EnsureCapacity(metricsLength) processMetadata, err := s.getProcessesMetadata() if err != nil { - return md, scrapererror.NewPartialScrapeError(err, metricsLength) + return pdata.NewMetrics(), scrapererror.NewPartialScrapeError(err, metricsLength) } if enableProcessesCount && processMetadata.countByStatus != nil { - setProcessesCountMetric(metrics.AppendEmpty(), s.startTime, now, processMetadata.countByStatus) + for status, count := range processMetadata.countByStatus { + s.mb.RecordSystemProcessesCountDataPoint(now, count, status) + } } if enableProcessesCreated && processMetadata.processesCreated != nil { - setProcessesCreatedMetric(metrics.AppendEmpty(), s.startTime, now, *processMetadata.processesCreated) + s.mb.RecordSystemProcessesCreatedDataPoint(now, *processMetadata.processesCreated) } - return md, err -} - -func setProcessesCountMetric(metric pdata.Metric, startTime, now pdata.Timestamp, countByStatus map[string]int64) { - metadata.Metrics.SystemProcessesCount.Init(metric) - ddps := metric.Sum().DataPoints() - - for status, count := range countByStatus { - setProcessesCountDataPoint(ddps.AppendEmpty(), startTime, now, status, count) - } -} - -func setProcessesCountDataPoint(dataPoint pdata.NumberDataPoint, startTime, now pdata.Timestamp, statusLabel string, value int64) { - dataPoint.Attributes().InsertString(metadata.Attributes.Status, statusLabel) - dataPoint.SetStartTimestamp(startTime) - dataPoint.SetTimestamp(now) - dataPoint.SetIntVal(value) -} - -func setProcessesCreatedMetric(metric pdata.Metric, startTime, now pdata.Timestamp, value int64) { - metadata.Metrics.SystemProcessesCreated.Init(metric) - ddp := metric.Sum().DataPoints().AppendEmpty() - ddp.SetStartTimestamp(startTime) - ddp.SetTimestamp(now) - ddp.SetIntVal(value) + return s.mb.Emit(), err } diff --git a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go index 36ea6f63e9d0..2a4336603cae 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/processesscraper/processes_scraper_test.go @@ -20,6 +20,7 @@ import ( "runtime" "testing" + "github.com/shirou/gopsutil/v3/host" "github.com/shirou/gopsutil/v3/load" "github.com/shirou/gopsutil/v3/process" "github.com/stretchr/testify/assert" @@ -36,8 +37,6 @@ var ( expectProcessesCreatedMetric = runtime.GOOS == "linux" || runtime.GOOS == "openbsd" ) -const startTime = 100 * 1e9 - func TestScrape(t *testing.T) { type testCase struct { name string @@ -74,7 +73,9 @@ func TestScrape(t *testing.T) { for _, test := range testCases { t.Run(test.name, func(t *testing.T) { assert := assert.New(t) - scraper := newProcessesScraper(context.Background(), &Config{}) + scraper := newProcessesScraper(context.Background(), &Config{ + Metrics: metadata.DefaultMetricsSettings(), + }) err := scraper.start(context.Background(), componenttest.NewNopHost()) assert.NoError(err, "Failed to initialize processes scraper: %v", err) @@ -85,7 +86,6 @@ func TestScrape(t *testing.T) { if test.getProcesses != nil { scraper.getProcesses = test.getProcesses } - scraper.startTime = startTime md, err := scraper.scrape(context.Background()) @@ -132,7 +132,7 @@ func validateRealData(t *testing.T, metrics pdata.MetricSlice) { if expectProcessesCountMetric { countMetric := metrics.At(metricIndex) metricIndex++ - internal.AssertDescriptorEqual(t, metadata.Metrics.SystemProcessesCount.New(), countMetric) + assert.Equal("system.processes.count", countMetric.Name()) assertContainsStatus := func(statusVal string) { points := countMetric.Sum().DataPoints() @@ -150,17 +150,19 @@ func validateRealData(t *testing.T, metrics pdata.MetricSlice) { if expectProcessesCreatedMetric { createdMetric := metrics.At(metricIndex) - internal.AssertDescriptorEqual(t, metadata.Metrics.SystemProcessesCreated.New(), createdMetric) + assert.Equal("system.processes.created", createdMetric.Name()) createdMetric = metrics.At(1) - internal.AssertDescriptorEqual(t, metadata.Metrics.SystemProcessesCreated.New(), createdMetric) + assert.Equal("system.processes.created", createdMetric.Name()) assert.Equal(1, createdMetric.Sum().DataPoints().Len()) assert.Equal(0, createdMetric.Sum().DataPoints().At(0).Attributes().Len()) } } func validateStartTime(t *testing.T, metrics pdata.MetricSlice) { + startTime, err := host.BootTime() + assert.NoError(t, err) for i := 0; i < metricsLength; i++ { - internal.AssertSumMetricStartTimeEquals(t, metrics.At(i), startTime) + internal.AssertSumMetricStartTimeEquals(t, metrics.At(i), pdata.Timestamp(startTime*1e9)) } } @@ -198,7 +200,7 @@ func validateFakeData(t *testing.T, metrics pdata.MetricSlice) { if expectProcessesCountMetric { countMetric := metrics.At(metricIndex) metricIndex++ - internal.AssertDescriptorEqual(t, metadata.Metrics.SystemProcessesCount.New(), countMetric) + assert.Equal("system.processes.count", countMetric.Name()) points := countMetric.Sum().DataPoints() attrs := map[string]int64{} @@ -223,7 +225,7 @@ func validateFakeData(t *testing.T, metrics pdata.MetricSlice) { if expectProcessesCreatedMetric { createdMetric := metrics.At(metricIndex) - internal.AssertDescriptorEqual(t, metadata.Metrics.SystemProcessesCreated.New(), createdMetric) + assert.Equal("system.processes.created", createdMetric.Name()) assert.Equal(1, createdMetric.Sum().DataPoints().Len()) assert.Equal(0, createdMetric.Sum().DataPoints().At(0).Attributes().Len()) } From 8e9b95c13e128ceb32e255c538ac275f913d9064 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraci=20Paix=C3=A3o=20Kr=C3=B6hling?= Date: Thu, 31 Mar 2022 13:39:38 +0200 Subject: [PATCH 2/2] Move changelog entry to unreleased MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juraci Paixรฃo Krรถhling --- CHANGELOG.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6f716e35e79f..c7e8a448ed76 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,9 @@ ### ๐Ÿ’ก Enhancements ๐Ÿ’ก +- `cmd/mdatagen`: Add resource attributes definition to metadata.yaml and move `pdata.Metrics` creation to the + generated code (#5270) + ### ๐Ÿ›‘ Breaking changes ๐Ÿ›‘ ### ๐Ÿšฉ Deprecations ๐Ÿšฉ @@ -15,8 +18,6 @@ ### ๐Ÿ’ก Enhancements ๐Ÿ’ก - `k8seventsreceiver`: Add Api_version and resource_version (#8539) -- `cmd/mdatagen`: Add resource attributes definition to metadata.yaml and move `pdata.Metrics` creation to the - generated code (#5270) - `datadogexporter`: Add `metrics::sums::cumulative_monotonic_mode` to specify export mode for cumulative monotonic sums (#8490) - `dynatraceexporter`: add multi-instance deployment note to README.md (#8848) - `resourcedetectionprocessor`: Add attribute allowlist (#8547)