diff --git a/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go b/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go index ff58c3d4d90f..18fc3f045a06 100644 --- a/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go +++ b/receiver/hostmetricsreceiver/hostmetrics_receiver_test.go @@ -58,10 +58,14 @@ var standardMetrics = []string{ "system.filesystem.usage", "system.memory.usage", "system.network.connections", - "system.network.dropped", - "system.network.errors", - "system.network.io", - "system.network.packets", + "system.network.dropped.receive", + "system.network.dropped.transmit", + "system.network.errors.receive", + "system.network.errors.transmit", + "system.network.io.receive", + "system.network.io.transmit", + "system.network.packets.receive", + "system.network.packets.transmit", "system.paging.operations", "system.paging.usage", } diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/documentation.md b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/documentation.md index 681f1adab581..378b24fa0d68 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/documentation.md +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/documentation.md @@ -9,10 +9,14 @@ These are the metrics available for this scraper. | Name | Description | Unit | Type | Attributes | | ---- | ----------- | ---- | ---- | ---------- | | **system.network.connections** | The number of connections. | {connections} | Sum(Int) | | -| **system.network.dropped** | The number of packets dropped. | {packets} | Sum(Int) | | -| **system.network.errors** | The number of errors encountered. | {errors} | Sum(Int) | | -| **system.network.io** | The number of bytes transmitted and received. | By | Sum(Int) | | -| **system.network.packets** | The number of packets transferred. | {packets} | Sum(Int) | | +| **system.network.dropped.receive** | The number of packets dropped on receive. | {packets} | Sum(Int) | | +| **system.network.dropped.transmit** | The number of packets dropped on transmit. | {packets} | Sum(Int) | | +| **system.network.errors.receive** | The number of errors encountered on receive. | {errors} | Sum(Int) | | +| **system.network.errors.transmit** | The number of errors encountered on transmit. | {errors} | Sum(Int) | | +| **system.network.io.receive** | The number of bytes received. | By | Sum(Int) | | +| **system.network.io.transmit** | The number of bytes transmitted. | By | Sum(Int) | | +| **system.network.packets.receive** | The number of packets received. | {packets} | Sum(Int) | | +| **system.network.packets.transmit** | The number of packets transmitted. | {packets} | Sum(Int) | | **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: @@ -28,6 +32,5 @@ metrics: | Name | Description | Values | | ---- | ----------- | ------ | | device | Name of the network interface. | | -| direction | Direction of flow of bytes/operations (receive or transmit). | receive, transmit | | protocol | Network protocol, e.g. TCP or UDP. | tcp | | state | State of the network connection. | | diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go index 0b2759dd9e45..28128ffdd1c4 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/internal/metadata/generated_metrics_v2.go @@ -18,11 +18,15 @@ type MetricSettings struct { // MetricsSettings provides settings for hostmetricsreceiver/network metrics. type MetricsSettings struct { - SystemNetworkConnections MetricSettings `mapstructure:"system.network.connections"` - SystemNetworkDropped MetricSettings `mapstructure:"system.network.dropped"` - SystemNetworkErrors MetricSettings `mapstructure:"system.network.errors"` - SystemNetworkIo MetricSettings `mapstructure:"system.network.io"` - SystemNetworkPackets MetricSettings `mapstructure:"system.network.packets"` + SystemNetworkConnections MetricSettings `mapstructure:"system.network.connections"` + SystemNetworkDroppedReceive MetricSettings `mapstructure:"system.network.dropped.receive"` + SystemNetworkDroppedTransmit MetricSettings `mapstructure:"system.network.dropped.transmit"` + SystemNetworkErrorsReceive MetricSettings `mapstructure:"system.network.errors.receive"` + SystemNetworkErrorsTransmit MetricSettings `mapstructure:"system.network.errors.transmit"` + SystemNetworkIoReceive MetricSettings `mapstructure:"system.network.io.receive"` + SystemNetworkIoTransmit MetricSettings `mapstructure:"system.network.io.transmit"` + SystemNetworkPacketsReceive MetricSettings `mapstructure:"system.network.packets.receive"` + SystemNetworkPacketsTransmit MetricSettings `mapstructure:"system.network.packets.transmit"` } func DefaultMetricsSettings() MetricsSettings { @@ -30,47 +34,33 @@ func DefaultMetricsSettings() MetricsSettings { SystemNetworkConnections: MetricSettings{ Enabled: true, }, - SystemNetworkDropped: MetricSettings{ + SystemNetworkDroppedReceive: MetricSettings{ Enabled: true, }, - SystemNetworkErrors: MetricSettings{ + SystemNetworkDroppedTransmit: MetricSettings{ Enabled: true, }, - SystemNetworkIo: MetricSettings{ + SystemNetworkErrorsReceive: MetricSettings{ Enabled: true, }, - SystemNetworkPackets: MetricSettings{ + SystemNetworkErrorsTransmit: MetricSettings{ + Enabled: true, + }, + SystemNetworkIoReceive: MetricSettings{ + Enabled: true, + }, + SystemNetworkIoTransmit: MetricSettings{ + Enabled: true, + }, + SystemNetworkPacketsReceive: MetricSettings{ + Enabled: true, + }, + SystemNetworkPacketsTransmit: MetricSettings{ Enabled: true, }, } } -// AttributeDirection specifies the a value direction attribute. -type AttributeDirection int - -const ( - _ AttributeDirection = iota - AttributeDirectionReceive - AttributeDirectionTransmit -) - -// String returns the string representation of the AttributeDirection. -func (av AttributeDirection) String() string { - switch av { - case AttributeDirectionReceive: - return "receive" - case AttributeDirectionTransmit: - return "transmit" - } - return "" -} - -// MapAttributeDirection is a helper map of string to AttributeDirection attribute value. -var MapAttributeDirection = map[string]AttributeDirection{ - "receive": AttributeDirectionReceive, - "transmit": AttributeDirectionTransmit, -} - // AttributeProtocol specifies the a value protocol attribute. type AttributeProtocol int @@ -147,16 +137,69 @@ func newMetricSystemNetworkConnections(settings MetricSettings) metricSystemNetw return m } -type metricSystemNetworkDropped struct { +type metricSystemNetworkDroppedReceive struct { + data pmetric.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.network.dropped.receive metric with initial data. +func (m *metricSystemNetworkDroppedReceive) init() { + m.data.SetName("system.network.dropped.receive") + m.data.SetDescription("The number of packets dropped on receive.") + m.data.SetUnit("{packets}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricSystemNetworkDroppedReceive) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemNetworkDroppedReceive) 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 *metricSystemNetworkDroppedReceive) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemNetworkDroppedReceive(settings MetricSettings) metricSystemNetworkDroppedReceive { + m := metricSystemNetworkDroppedReceive{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricSystemNetworkDroppedTransmit struct { data pmetric.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.network.dropped metric with initial data. -func (m *metricSystemNetworkDropped) init() { - m.data.SetName("system.network.dropped") - m.data.SetDescription("The number of packets dropped.") +// init fills system.network.dropped.transmit metric with initial data. +func (m *metricSystemNetworkDroppedTransmit) init() { + m.data.SetName("system.network.dropped.transmit") + m.data.SetDescription("The number of packets dropped on transmit.") m.data.SetUnit("{packets}") m.data.SetDataType(pmetric.MetricDataTypeSum) m.data.Sum().SetIsMonotonic(true) @@ -164,7 +207,7 @@ func (m *metricSystemNetworkDropped) init() { m.data.Sum().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricSystemNetworkDropped) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { +func (m *metricSystemNetworkDroppedTransmit) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { if !m.settings.Enabled { return } @@ -173,18 +216,17 @@ func (m *metricSystemNetworkDropped) recordDataPoint(start pcommon.Timestamp, ts dp.SetTimestamp(ts) dp.SetIntVal(val) dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) - dp.Attributes().Insert("direction", pcommon.NewValueString(directionAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. -func (m *metricSystemNetworkDropped) updateCapacity() { +func (m *metricSystemNetworkDroppedTransmit) 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 *metricSystemNetworkDropped) emit(metrics pmetric.MetricSlice) { +func (m *metricSystemNetworkDroppedTransmit) emit(metrics pmetric.MetricSlice) { if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) @@ -192,8 +234,8 @@ func (m *metricSystemNetworkDropped) emit(metrics pmetric.MetricSlice) { } } -func newMetricSystemNetworkDropped(settings MetricSettings) metricSystemNetworkDropped { - m := metricSystemNetworkDropped{settings: settings} +func newMetricSystemNetworkDroppedTransmit(settings MetricSettings) metricSystemNetworkDroppedTransmit { + m := metricSystemNetworkDroppedTransmit{settings: settings} if settings.Enabled { m.data = pmetric.NewMetric() m.init() @@ -201,16 +243,16 @@ func newMetricSystemNetworkDropped(settings MetricSettings) metricSystemNetworkD return m } -type metricSystemNetworkErrors struct { +type metricSystemNetworkErrorsReceive struct { data pmetric.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.network.errors metric with initial data. -func (m *metricSystemNetworkErrors) init() { - m.data.SetName("system.network.errors") - m.data.SetDescription("The number of errors encountered.") +// init fills system.network.errors.receive metric with initial data. +func (m *metricSystemNetworkErrorsReceive) init() { + m.data.SetName("system.network.errors.receive") + m.data.SetDescription("The number of errors encountered on receive.") m.data.SetUnit("{errors}") m.data.SetDataType(pmetric.MetricDataTypeSum) m.data.Sum().SetIsMonotonic(true) @@ -218,7 +260,7 @@ func (m *metricSystemNetworkErrors) init() { m.data.Sum().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricSystemNetworkErrors) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { +func (m *metricSystemNetworkErrorsReceive) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { if !m.settings.Enabled { return } @@ -227,18 +269,17 @@ func (m *metricSystemNetworkErrors) recordDataPoint(start pcommon.Timestamp, ts dp.SetTimestamp(ts) dp.SetIntVal(val) dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) - dp.Attributes().Insert("direction", pcommon.NewValueString(directionAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. -func (m *metricSystemNetworkErrors) updateCapacity() { +func (m *metricSystemNetworkErrorsReceive) 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 *metricSystemNetworkErrors) emit(metrics pmetric.MetricSlice) { +func (m *metricSystemNetworkErrorsReceive) emit(metrics pmetric.MetricSlice) { if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) @@ -246,8 +287,8 @@ func (m *metricSystemNetworkErrors) emit(metrics pmetric.MetricSlice) { } } -func newMetricSystemNetworkErrors(settings MetricSettings) metricSystemNetworkErrors { - m := metricSystemNetworkErrors{settings: settings} +func newMetricSystemNetworkErrorsReceive(settings MetricSettings) metricSystemNetworkErrorsReceive { + m := metricSystemNetworkErrorsReceive{settings: settings} if settings.Enabled { m.data = pmetric.NewMetric() m.init() @@ -255,16 +296,122 @@ func newMetricSystemNetworkErrors(settings MetricSettings) metricSystemNetworkEr return m } -type metricSystemNetworkIo struct { +type metricSystemNetworkErrorsTransmit struct { data pmetric.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.network.io metric with initial data. -func (m *metricSystemNetworkIo) init() { - m.data.SetName("system.network.io") - m.data.SetDescription("The number of bytes transmitted and received.") +// init fills system.network.errors.transmit metric with initial data. +func (m *metricSystemNetworkErrorsTransmit) init() { + m.data.SetName("system.network.errors.transmit") + m.data.SetDescription("The number of errors encountered on transmit.") + m.data.SetUnit("{errors}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricSystemNetworkErrorsTransmit) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemNetworkErrorsTransmit) 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 *metricSystemNetworkErrorsTransmit) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemNetworkErrorsTransmit(settings MetricSettings) metricSystemNetworkErrorsTransmit { + m := metricSystemNetworkErrorsTransmit{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricSystemNetworkIoReceive struct { + data pmetric.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.network.io.receive metric with initial data. +func (m *metricSystemNetworkIoReceive) init() { + m.data.SetName("system.network.io.receive") + m.data.SetDescription("The number of bytes received.") + m.data.SetUnit("By") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricSystemNetworkIoReceive) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemNetworkIoReceive) 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 *metricSystemNetworkIoReceive) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemNetworkIoReceive(settings MetricSettings) metricSystemNetworkIoReceive { + m := metricSystemNetworkIoReceive{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricSystemNetworkIoTransmit struct { + data pmetric.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.network.io.transmit metric with initial data. +func (m *metricSystemNetworkIoTransmit) init() { + m.data.SetName("system.network.io.transmit") + m.data.SetDescription("The number of bytes transmitted.") m.data.SetUnit("By") m.data.SetDataType(pmetric.MetricDataTypeSum) m.data.Sum().SetIsMonotonic(true) @@ -272,7 +419,7 @@ func (m *metricSystemNetworkIo) init() { m.data.Sum().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricSystemNetworkIo) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { +func (m *metricSystemNetworkIoTransmit) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { if !m.settings.Enabled { return } @@ -281,18 +428,17 @@ func (m *metricSystemNetworkIo) recordDataPoint(start pcommon.Timestamp, ts pcom dp.SetTimestamp(ts) dp.SetIntVal(val) dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) - dp.Attributes().Insert("direction", pcommon.NewValueString(directionAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. -func (m *metricSystemNetworkIo) updateCapacity() { +func (m *metricSystemNetworkIoTransmit) 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 *metricSystemNetworkIo) emit(metrics pmetric.MetricSlice) { +func (m *metricSystemNetworkIoTransmit) emit(metrics pmetric.MetricSlice) { if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) @@ -300,8 +446,8 @@ func (m *metricSystemNetworkIo) emit(metrics pmetric.MetricSlice) { } } -func newMetricSystemNetworkIo(settings MetricSettings) metricSystemNetworkIo { - m := metricSystemNetworkIo{settings: settings} +func newMetricSystemNetworkIoTransmit(settings MetricSettings) metricSystemNetworkIoTransmit { + m := metricSystemNetworkIoTransmit{settings: settings} if settings.Enabled { m.data = pmetric.NewMetric() m.init() @@ -309,16 +455,16 @@ func newMetricSystemNetworkIo(settings MetricSettings) metricSystemNetworkIo { return m } -type metricSystemNetworkPackets struct { +type metricSystemNetworkPacketsReceive struct { data pmetric.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.network.packets metric with initial data. -func (m *metricSystemNetworkPackets) init() { - m.data.SetName("system.network.packets") - m.data.SetDescription("The number of packets transferred.") +// init fills system.network.packets.receive metric with initial data. +func (m *metricSystemNetworkPacketsReceive) init() { + m.data.SetName("system.network.packets.receive") + m.data.SetDescription("The number of packets received.") m.data.SetUnit("{packets}") m.data.SetDataType(pmetric.MetricDataTypeSum) m.data.Sum().SetIsMonotonic(true) @@ -326,7 +472,7 @@ func (m *metricSystemNetworkPackets) init() { m.data.Sum().DataPoints().EnsureCapacity(m.capacity) } -func (m *metricSystemNetworkPackets) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue string) { +func (m *metricSystemNetworkPacketsReceive) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { if !m.settings.Enabled { return } @@ -335,18 +481,17 @@ func (m *metricSystemNetworkPackets) recordDataPoint(start pcommon.Timestamp, ts dp.SetTimestamp(ts) dp.SetIntVal(val) dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) - dp.Attributes().Insert("direction", pcommon.NewValueString(directionAttributeValue)) } // updateCapacity saves max length of data point slices that will be used for the slice capacity. -func (m *metricSystemNetworkPackets) updateCapacity() { +func (m *metricSystemNetworkPacketsReceive) 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 *metricSystemNetworkPackets) emit(metrics pmetric.MetricSlice) { +func (m *metricSystemNetworkPacketsReceive) emit(metrics pmetric.MetricSlice) { if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { m.updateCapacity() m.data.MoveTo(metrics.AppendEmpty()) @@ -354,8 +499,61 @@ func (m *metricSystemNetworkPackets) emit(metrics pmetric.MetricSlice) { } } -func newMetricSystemNetworkPackets(settings MetricSettings) metricSystemNetworkPackets { - m := metricSystemNetworkPackets{settings: settings} +func newMetricSystemNetworkPacketsReceive(settings MetricSettings) metricSystemNetworkPacketsReceive { + m := metricSystemNetworkPacketsReceive{settings: settings} + if settings.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + +type metricSystemNetworkPacketsTransmit struct { + data pmetric.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.network.packets.transmit metric with initial data. +func (m *metricSystemNetworkPacketsTransmit) init() { + m.data.SetName("system.network.packets.transmit") + m.data.SetDescription("The number of packets transmitted.") + m.data.SetUnit("{packets}") + m.data.SetDataType(pmetric.MetricDataTypeSum) + m.data.Sum().SetIsMonotonic(true) + m.data.Sum().SetAggregationTemporality(pmetric.MetricAggregationTemporalityCumulative) + m.data.Sum().DataPoints().EnsureCapacity(m.capacity) +} + +func (m *metricSystemNetworkPacketsTransmit) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + if !m.settings.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntVal(val) + dp.Attributes().Insert("device", pcommon.NewValueString(deviceAttributeValue)) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemNetworkPacketsTransmit) 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 *metricSystemNetworkPacketsTransmit) emit(metrics pmetric.MetricSlice) { + if m.settings.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemNetworkPacketsTransmit(settings MetricSettings) metricSystemNetworkPacketsTransmit { + m := metricSystemNetworkPacketsTransmit{settings: settings} if settings.Enabled { m.data = pmetric.NewMetric() m.init() @@ -366,16 +564,20 @@ func newMetricSystemNetworkPackets(settings MetricSettings) metricSystemNetworkP // 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 pcommon.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 pmetric.Metrics // accumulates metrics data before emitting. - buildInfo component.BuildInfo // contains version information - metricSystemNetworkConnections metricSystemNetworkConnections - metricSystemNetworkDropped metricSystemNetworkDropped - metricSystemNetworkErrors metricSystemNetworkErrors - metricSystemNetworkIo metricSystemNetworkIo - metricSystemNetworkPackets metricSystemNetworkPackets + startTime pcommon.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 pmetric.Metrics // accumulates metrics data before emitting. + buildInfo component.BuildInfo // contains version information + metricSystemNetworkConnections metricSystemNetworkConnections + metricSystemNetworkDroppedReceive metricSystemNetworkDroppedReceive + metricSystemNetworkDroppedTransmit metricSystemNetworkDroppedTransmit + metricSystemNetworkErrorsReceive metricSystemNetworkErrorsReceive + metricSystemNetworkErrorsTransmit metricSystemNetworkErrorsTransmit + metricSystemNetworkIoReceive metricSystemNetworkIoReceive + metricSystemNetworkIoTransmit metricSystemNetworkIoTransmit + metricSystemNetworkPacketsReceive metricSystemNetworkPacketsReceive + metricSystemNetworkPacketsTransmit metricSystemNetworkPacketsTransmit } // metricBuilderOption applies changes to default metrics builder. @@ -390,14 +592,18 @@ func WithStartTime(startTime pcommon.Timestamp) metricBuilderOption { func NewMetricsBuilder(settings MetricsSettings, buildInfo component.BuildInfo, options ...metricBuilderOption) *MetricsBuilder { mb := &MetricsBuilder{ - startTime: pcommon.NewTimestampFromTime(time.Now()), - metricsBuffer: pmetric.NewMetrics(), - buildInfo: buildInfo, - metricSystemNetworkConnections: newMetricSystemNetworkConnections(settings.SystemNetworkConnections), - metricSystemNetworkDropped: newMetricSystemNetworkDropped(settings.SystemNetworkDropped), - metricSystemNetworkErrors: newMetricSystemNetworkErrors(settings.SystemNetworkErrors), - metricSystemNetworkIo: newMetricSystemNetworkIo(settings.SystemNetworkIo), - metricSystemNetworkPackets: newMetricSystemNetworkPackets(settings.SystemNetworkPackets), + startTime: pcommon.NewTimestampFromTime(time.Now()), + metricsBuffer: pmetric.NewMetrics(), + buildInfo: buildInfo, + metricSystemNetworkConnections: newMetricSystemNetworkConnections(settings.SystemNetworkConnections), + metricSystemNetworkDroppedReceive: newMetricSystemNetworkDroppedReceive(settings.SystemNetworkDroppedReceive), + metricSystemNetworkDroppedTransmit: newMetricSystemNetworkDroppedTransmit(settings.SystemNetworkDroppedTransmit), + metricSystemNetworkErrorsReceive: newMetricSystemNetworkErrorsReceive(settings.SystemNetworkErrorsReceive), + metricSystemNetworkErrorsTransmit: newMetricSystemNetworkErrorsTransmit(settings.SystemNetworkErrorsTransmit), + metricSystemNetworkIoReceive: newMetricSystemNetworkIoReceive(settings.SystemNetworkIoReceive), + metricSystemNetworkIoTransmit: newMetricSystemNetworkIoTransmit(settings.SystemNetworkIoTransmit), + metricSystemNetworkPacketsReceive: newMetricSystemNetworkPacketsReceive(settings.SystemNetworkPacketsReceive), + metricSystemNetworkPacketsTransmit: newMetricSystemNetworkPacketsTransmit(settings.SystemNetworkPacketsTransmit), } for _, op := range options { op(mb) @@ -452,10 +658,14 @@ func (mb *MetricsBuilder) EmitForResource(rmo ...ResourceMetricsOption) { ils.Scope().SetVersion(mb.buildInfo.Version) ils.Metrics().EnsureCapacity(mb.metricsCapacity) mb.metricSystemNetworkConnections.emit(ils.Metrics()) - mb.metricSystemNetworkDropped.emit(ils.Metrics()) - mb.metricSystemNetworkErrors.emit(ils.Metrics()) - mb.metricSystemNetworkIo.emit(ils.Metrics()) - mb.metricSystemNetworkPackets.emit(ils.Metrics()) + mb.metricSystemNetworkDroppedReceive.emit(ils.Metrics()) + mb.metricSystemNetworkDroppedTransmit.emit(ils.Metrics()) + mb.metricSystemNetworkErrorsReceive.emit(ils.Metrics()) + mb.metricSystemNetworkErrorsTransmit.emit(ils.Metrics()) + mb.metricSystemNetworkIoReceive.emit(ils.Metrics()) + mb.metricSystemNetworkIoTransmit.emit(ils.Metrics()) + mb.metricSystemNetworkPacketsReceive.emit(ils.Metrics()) + mb.metricSystemNetworkPacketsTransmit.emit(ils.Metrics()) for _, op := range rmo { op(rm) } @@ -480,24 +690,44 @@ func (mb *MetricsBuilder) RecordSystemNetworkConnectionsDataPoint(ts pcommon.Tim mb.metricSystemNetworkConnections.recordDataPoint(mb.startTime, ts, val, protocolAttributeValue.String(), stateAttributeValue) } -// RecordSystemNetworkDroppedDataPoint adds a data point to system.network.dropped metric. -func (mb *MetricsBuilder) RecordSystemNetworkDroppedDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { - mb.metricSystemNetworkDropped.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) +// RecordSystemNetworkDroppedReceiveDataPoint adds a data point to system.network.dropped.receive metric. +func (mb *MetricsBuilder) RecordSystemNetworkDroppedReceiveDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkDroppedReceive.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) +} + +// RecordSystemNetworkDroppedTransmitDataPoint adds a data point to system.network.dropped.transmit metric. +func (mb *MetricsBuilder) RecordSystemNetworkDroppedTransmitDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkDroppedTransmit.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) +} + +// RecordSystemNetworkErrorsReceiveDataPoint adds a data point to system.network.errors.receive metric. +func (mb *MetricsBuilder) RecordSystemNetworkErrorsReceiveDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkErrorsReceive.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) +} + +// RecordSystemNetworkErrorsTransmitDataPoint adds a data point to system.network.errors.transmit metric. +func (mb *MetricsBuilder) RecordSystemNetworkErrorsTransmitDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkErrorsTransmit.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) +} + +// RecordSystemNetworkIoReceiveDataPoint adds a data point to system.network.io.receive metric. +func (mb *MetricsBuilder) RecordSystemNetworkIoReceiveDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkIoReceive.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) } -// RecordSystemNetworkErrorsDataPoint adds a data point to system.network.errors metric. -func (mb *MetricsBuilder) RecordSystemNetworkErrorsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { - mb.metricSystemNetworkErrors.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) +// RecordSystemNetworkIoTransmitDataPoint adds a data point to system.network.io.transmit metric. +func (mb *MetricsBuilder) RecordSystemNetworkIoTransmitDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkIoTransmit.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) } -// RecordSystemNetworkIoDataPoint adds a data point to system.network.io metric. -func (mb *MetricsBuilder) RecordSystemNetworkIoDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { - mb.metricSystemNetworkIo.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) +// RecordSystemNetworkPacketsReceiveDataPoint adds a data point to system.network.packets.receive metric. +func (mb *MetricsBuilder) RecordSystemNetworkPacketsReceiveDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkPacketsReceive.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) } -// RecordSystemNetworkPacketsDataPoint adds a data point to system.network.packets metric. -func (mb *MetricsBuilder) RecordSystemNetworkPacketsDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string, directionAttributeValue AttributeDirection) { - mb.metricSystemNetworkPackets.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue, directionAttributeValue.String()) +// RecordSystemNetworkPacketsTransmitDataPoint adds a data point to system.network.packets.transmit metric. +func (mb *MetricsBuilder) RecordSystemNetworkPacketsTransmitDataPoint(ts pcommon.Timestamp, val int64, deviceAttributeValue string) { + mb.metricSystemNetworkPacketsTransmit.recordDataPoint(mb.startTime, ts, val, deviceAttributeValue) } // Reset resets metrics builder to its initial state. It should be used when external metrics source is restarted, diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/metadata.yaml b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/metadata.yaml index 9522a8053cdb..10f1e1cffa8c 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/metadata.yaml +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/metadata.yaml @@ -6,10 +6,6 @@ attributes: device: description: Name of the network interface. - direction: - description: Direction of flow of bytes/operations (receive or transmit). - enum: [receive, transmit] - protocol: description: Network protocol, e.g. TCP or UDP. enum: [tcp] @@ -18,45 +14,85 @@ attributes: description: State of the network connection. metrics: - system.network.packets: + system.network.packets.transmit: + enabled: true + description: The number of packets transmitted. + unit: "{packets}" + sum: + value_type: int + aggregation: cumulative + monotonic: true + attributes: [device] + + system.network.packets.receive: + enabled: true + description: The number of packets received. + unit: "{packets}" + sum: + value_type: int + aggregation: cumulative + monotonic: true + attributes: [device] + + system.network.dropped.transmit: enabled: true - description: The number of packets transferred. + description: The number of packets dropped on transmit. unit: "{packets}" sum: value_type: int aggregation: cumulative monotonic: true - attributes: [device, direction] + attributes: [device] - system.network.dropped: + system.network.dropped.receive: enabled: true - description: The number of packets dropped. + description: The number of packets dropped on receive. unit: "{packets}" sum: value_type: int aggregation: cumulative monotonic: true - attributes: [device, direction] + attributes: [device] - system.network.errors: + system.network.errors.transmit: enabled: true - description: The number of errors encountered. + description: The number of errors encountered on transmit. unit: "{errors}" sum: value_type: int aggregation: cumulative monotonic: true - attributes: [device, direction] + attributes: [device] + + system.network.errors.receive: + enabled: true + description: The number of errors encountered on receive. + unit: "{errors}" + sum: + value_type: int + aggregation: cumulative + monotonic: true + attributes: [device] + + system.network.io.transmit: + enabled: true + description: The number of bytes transmitted. + unit: "By" + sum: + value_type: int + aggregation: cumulative + monotonic: true + attributes: [device] - system.network.io: + system.network.io.receive: enabled: true - description: The number of bytes transmitted and received. + description: The number of bytes received. unit: "By" sum: value_type: int aggregation: cumulative monotonic: true - attributes: [device, direction] + attributes: [device] system.network.connections: enabled: true diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go index f769d173e790..e832937f07c3 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper.go @@ -124,29 +124,29 @@ func (s *scraper) recordNetworkCounterMetrics() error { func (s *scraper) recordNetworkPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsSent), ioCounters.Name, metadata.AttributeDirectionTransmit) - s.mb.RecordSystemNetworkPacketsDataPoint(now, int64(ioCounters.PacketsRecv), ioCounters.Name, metadata.AttributeDirectionReceive) + s.mb.RecordSystemNetworkPacketsTransmitDataPoint(now, int64(ioCounters.PacketsSent), ioCounters.Name) + s.mb.RecordSystemNetworkPacketsReceiveDataPoint(now, int64(ioCounters.PacketsRecv), ioCounters.Name) } } func (s *scraper) recordNetworkDroppedPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropout), ioCounters.Name, metadata.AttributeDirectionTransmit) - s.mb.RecordSystemNetworkDroppedDataPoint(now, int64(ioCounters.Dropin), ioCounters.Name, metadata.AttributeDirectionReceive) + s.mb.RecordSystemNetworkDroppedTransmitDataPoint(now, int64(ioCounters.Dropout), ioCounters.Name) + s.mb.RecordSystemNetworkDroppedReceiveDataPoint(now, int64(ioCounters.Dropin), ioCounters.Name) } } func (s *scraper) recordNetworkErrorPacketsMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errout), ioCounters.Name, metadata.AttributeDirectionTransmit) - s.mb.RecordSystemNetworkErrorsDataPoint(now, int64(ioCounters.Errin), ioCounters.Name, metadata.AttributeDirectionReceive) + s.mb.RecordSystemNetworkErrorsTransmitDataPoint(now, int64(ioCounters.Errout), ioCounters.Name) + s.mb.RecordSystemNetworkErrorsReceiveDataPoint(now, int64(ioCounters.Errin), ioCounters.Name) } } func (s *scraper) recordNetworkIOMetric(now pcommon.Timestamp, ioCountersSlice []net.IOCountersStat) { for _, ioCounters := range ioCountersSlice { - s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesSent), ioCounters.Name, metadata.AttributeDirectionTransmit) - s.mb.RecordSystemNetworkIoDataPoint(now, int64(ioCounters.BytesRecv), ioCounters.Name, metadata.AttributeDirectionReceive) + s.mb.RecordSystemNetworkIoTransmitDataPoint(now, int64(ioCounters.BytesSent), ioCounters.Name) + s.mb.RecordSystemNetworkIoReceiveDataPoint(now, int64(ioCounters.BytesRecv), ioCounters.Name) } } diff --git a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go index 562558f5ce74..db6fe354bf65 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/networkscraper/network_scraper_test.go @@ -152,7 +152,7 @@ func TestScrape(t *testing.T) { expectedMetricCount := 1 if test.expectNetworkMetrics { - expectedMetricCount += 4 + expectedMetricCount += 8 } assert.Equal(t, expectedMetricCount, md.MetricCount()) @@ -160,10 +160,14 @@ func TestScrape(t *testing.T) { idx := 0 assertNetworkConnectionsMetricValid(t, metrics.At(idx)) if test.expectNetworkMetrics { - assertNetworkIOMetricValid(t, metrics.At(idx+1), "system.network.dropped", test.expectedStartTime) - assertNetworkIOMetricValid(t, metrics.At(idx+2), "system.network.errors", test.expectedStartTime) - assertNetworkIOMetricValid(t, metrics.At(idx+3), "system.network.io", test.expectedStartTime) - assertNetworkIOMetricValid(t, metrics.At(idx+4), "system.network.packets", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+1), "system.network.dropped.receive", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+2), "system.network.dropped.transmit", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+3), "system.network.errors.receive", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+4), "system.network.errors.transmit", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+5), "system.network.io.receive", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+6), "system.network.io.transmit", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+7), "system.network.packets.receive", test.expectedStartTime) + assertNetworkIOMetricValid(t, metrics.At(idx+8), "system.network.packets.transmit", test.expectedStartTime) internal.AssertSameTimeStampForMetrics(t, metrics, 1, 5) idx += 4 } @@ -178,12 +182,8 @@ func assertNetworkIOMetricValid(t *testing.T, metric pmetric.Metric, expectedNam if startTime != 0 { internal.AssertSumMetricStartTimeEquals(t, metric, startTime) } - assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 2) + assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 1) internal.AssertSumMetricHasAttribute(t, metric, 0, "device") - internal.AssertSumMetricHasAttributeValue(t, metric, 0, "direction", - pcommon.NewValueString(metadata.AttributeDirectionTransmit.String())) - internal.AssertSumMetricHasAttributeValue(t, metric, 1, "direction", - pcommon.NewValueString(metadata.AttributeDirectionReceive.String())) } func assertNetworkConnectionsMetricValid(t *testing.T, metric pmetric.Metric) {