diff --git a/.chloggen/braydonk_linux-dirty-mem.yaml b/.chloggen/braydonk_linux-dirty-mem.yaml new file mode 100644 index 0000000000000..3ac344f060cd0 --- /dev/null +++ b/.chloggen/braydonk_linux-dirty-mem.yaml @@ -0,0 +1,27 @@ +# Use this changelog template to create an entry for release notes. + +# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix' +change_type: enhancement + +# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver) +component: hostmetricsreceiver + +# A brief description of the change. Surround your text with quotes ("") if it needs to start with a backtick (`). +note: Added the `system.linux.memory.dirty` and `system.memory.page_size` metrics. + +# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists. +issues: [38672] + +# (Optional) One or more lines of additional information to render under the primary note. +# These lines will be padded with 2 spaces and then inserted directly into the document. +# Use pipe (|) for multiline entries. +subtext: + +# If your change doesn't affect end users or the exported elements of any package, +# you should instead start your pull request title with [chore] or use the "Skip Changelog" label. +# Optional: The change log or logs in which this entry should be included. +# e.g. '[user]' or '[user, api]' +# Include 'user' if the change is relevant to end users. +# Include 'api' if there is a change to a library API. +# Default: '[user]' +change_logs: [user] diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/documentation.md b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/documentation.md index 76089b066ef3f..7c7d0c0792c1e 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/documentation.md +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/documentation.md @@ -44,6 +44,14 @@ An estimate of how much memory is available for starting new applications, witho | ---- | ----------- | ---------- | ----------------------- | --------- | | By | Sum | Int | Cumulative | false | +### system.linux.memory.dirty + +The amount of dirty memory according to `/proc/meminfo`. + +| Unit | Metric Type | Value Type | Aggregation Temporality | Monotonic | +| ---- | ----------- | ---------- | ----------------------- | --------- | +| By | Sum | Int | Cumulative | false | + ### system.memory.limit Total bytes of memory available. @@ -52,6 +60,14 @@ Total bytes of memory available. | ---- | ----------- | ---------- | ----------------------- | --------- | | By | Sum | Int | Cumulative | false | +### system.memory.page_size + +A constant value for the system's configured page size. + +| Unit | Metric Type | Value Type | +| ---- | ----------- | ---------- | +| By | Gauge | Int | + ### system.memory.utilization Percentage of memory bytes in use. diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config.go index 1c9c61bd56d2a..59844207cb950 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config.go @@ -28,7 +28,9 @@ func (ms *MetricConfig) Unmarshal(parser *confmap.Conf) error { // MetricsConfig provides config for memory metrics. type MetricsConfig struct { SystemLinuxMemoryAvailable MetricConfig `mapstructure:"system.linux.memory.available"` + SystemLinuxMemoryDirty MetricConfig `mapstructure:"system.linux.memory.dirty"` SystemMemoryLimit MetricConfig `mapstructure:"system.memory.limit"` + SystemMemoryPageSize MetricConfig `mapstructure:"system.memory.page_size"` SystemMemoryUsage MetricConfig `mapstructure:"system.memory.usage"` SystemMemoryUtilization MetricConfig `mapstructure:"system.memory.utilization"` } @@ -38,9 +40,15 @@ func DefaultMetricsConfig() MetricsConfig { SystemLinuxMemoryAvailable: MetricConfig{ Enabled: false, }, + SystemLinuxMemoryDirty: MetricConfig{ + Enabled: false, + }, SystemMemoryLimit: MetricConfig{ Enabled: false, }, + SystemMemoryPageSize: MetricConfig{ + Enabled: false, + }, SystemMemoryUsage: MetricConfig{ Enabled: true, }, diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config_test.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config_test.go index 19366de62f531..e1c2302f7a7f9 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_config_test.go @@ -26,7 +26,9 @@ func TestMetricsBuilderConfig(t *testing.T) { want: MetricsBuilderConfig{ Metrics: MetricsConfig{ SystemLinuxMemoryAvailable: MetricConfig{Enabled: true}, + SystemLinuxMemoryDirty: MetricConfig{Enabled: true}, SystemMemoryLimit: MetricConfig{Enabled: true}, + SystemMemoryPageSize: MetricConfig{Enabled: true}, SystemMemoryUsage: MetricConfig{Enabled: true}, SystemMemoryUtilization: MetricConfig{Enabled: true}, }, @@ -37,7 +39,9 @@ func TestMetricsBuilderConfig(t *testing.T) { want: MetricsBuilderConfig{ Metrics: MetricsConfig{ SystemLinuxMemoryAvailable: MetricConfig{Enabled: false}, + SystemLinuxMemoryDirty: MetricConfig{Enabled: false}, SystemMemoryLimit: MetricConfig{Enabled: false}, + SystemMemoryPageSize: MetricConfig{Enabled: false}, SystemMemoryUsage: MetricConfig{Enabled: false}, SystemMemoryUtilization: MetricConfig{Enabled: false}, }, diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics.go index e12f836cbf4ce..a2aef52ac49fd 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics.go @@ -109,6 +109,57 @@ func newMetricSystemLinuxMemoryAvailable(cfg MetricConfig) metricSystemLinuxMemo return m } +type metricSystemLinuxMemoryDirty 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. +} + +// init fills system.linux.memory.dirty metric with initial data. +func (m *metricSystemLinuxMemoryDirty) init() { + m.data.SetName("system.linux.memory.dirty") + m.data.SetDescription("The amount of dirty memory according to `/proc/meminfo`.") + m.data.SetUnit("By") + m.data.SetEmptySum() + m.data.Sum().SetIsMonotonic(false) + m.data.Sum().SetAggregationTemporality(pmetric.AggregationTemporalityCumulative) +} + +func (m *metricSystemLinuxMemoryDirty) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.config.Enabled { + return + } + dp := m.data.Sum().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntValue(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemLinuxMemoryDirty) 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 *metricSystemLinuxMemoryDirty) emit(metrics pmetric.MetricSlice) { + if m.config.Enabled && m.data.Sum().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemLinuxMemoryDirty(cfg MetricConfig) metricSystemLinuxMemoryDirty { + m := metricSystemLinuxMemoryDirty{config: cfg} + if cfg.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + type metricSystemMemoryLimit struct { data pmetric.Metric // data buffer for generated metric. config MetricConfig // metric config provided by user. @@ -160,6 +211,55 @@ func newMetricSystemMemoryLimit(cfg MetricConfig) metricSystemMemoryLimit { return m } +type metricSystemMemoryPageSize 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. +} + +// init fills system.memory.page_size metric with initial data. +func (m *metricSystemMemoryPageSize) init() { + m.data.SetName("system.memory.page_size") + m.data.SetDescription("A constant value for the system's configured page size.") + m.data.SetUnit("By") + m.data.SetEmptyGauge() +} + +func (m *metricSystemMemoryPageSize) recordDataPoint(start pcommon.Timestamp, ts pcommon.Timestamp, val int64) { + if !m.config.Enabled { + return + } + dp := m.data.Gauge().DataPoints().AppendEmpty() + dp.SetStartTimestamp(start) + dp.SetTimestamp(ts) + dp.SetIntValue(val) +} + +// updateCapacity saves max length of data point slices that will be used for the slice capacity. +func (m *metricSystemMemoryPageSize) 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 *metricSystemMemoryPageSize) emit(metrics pmetric.MetricSlice) { + if m.config.Enabled && m.data.Gauge().DataPoints().Len() > 0 { + m.updateCapacity() + m.data.MoveTo(metrics.AppendEmpty()) + m.init() + } +} + +func newMetricSystemMemoryPageSize(cfg MetricConfig) metricSystemMemoryPageSize { + m := metricSystemMemoryPageSize{config: cfg} + if cfg.Enabled { + m.data = pmetric.NewMetric() + m.init() + } + return m +} + type metricSystemMemoryUsage struct { data pmetric.Metric // data buffer for generated metric. config MetricConfig // metric config provided by user. @@ -273,7 +373,9 @@ type MetricsBuilder struct { metricsBuffer pmetric.Metrics // accumulates metrics data before emitting. buildInfo component.BuildInfo // contains version information. metricSystemLinuxMemoryAvailable metricSystemLinuxMemoryAvailable + metricSystemLinuxMemoryDirty metricSystemLinuxMemoryDirty metricSystemMemoryLimit metricSystemMemoryLimit + metricSystemMemoryPageSize metricSystemMemoryPageSize metricSystemMemoryUsage metricSystemMemoryUsage metricSystemMemoryUtilization metricSystemMemoryUtilization } @@ -302,7 +404,9 @@ func NewMetricsBuilder(mbc MetricsBuilderConfig, settings scraper.Settings, opti metricsBuffer: pmetric.NewMetrics(), buildInfo: settings.BuildInfo, metricSystemLinuxMemoryAvailable: newMetricSystemLinuxMemoryAvailable(mbc.Metrics.SystemLinuxMemoryAvailable), + metricSystemLinuxMemoryDirty: newMetricSystemLinuxMemoryDirty(mbc.Metrics.SystemLinuxMemoryDirty), metricSystemMemoryLimit: newMetricSystemMemoryLimit(mbc.Metrics.SystemMemoryLimit), + metricSystemMemoryPageSize: newMetricSystemMemoryPageSize(mbc.Metrics.SystemMemoryPageSize), metricSystemMemoryUsage: newMetricSystemMemoryUsage(mbc.Metrics.SystemMemoryUsage), metricSystemMemoryUtilization: newMetricSystemMemoryUtilization(mbc.Metrics.SystemMemoryUtilization), } @@ -372,7 +476,9 @@ func (mb *MetricsBuilder) EmitForResource(options ...ResourceMetricsOption) { ils.Scope().SetVersion(mb.buildInfo.Version) ils.Metrics().EnsureCapacity(mb.metricsCapacity) mb.metricSystemLinuxMemoryAvailable.emit(ils.Metrics()) + mb.metricSystemLinuxMemoryDirty.emit(ils.Metrics()) mb.metricSystemMemoryLimit.emit(ils.Metrics()) + mb.metricSystemMemoryPageSize.emit(ils.Metrics()) mb.metricSystemMemoryUsage.emit(ils.Metrics()) mb.metricSystemMemoryUtilization.emit(ils.Metrics()) @@ -401,11 +507,21 @@ func (mb *MetricsBuilder) RecordSystemLinuxMemoryAvailableDataPoint(ts pcommon.T mb.metricSystemLinuxMemoryAvailable.recordDataPoint(mb.startTime, ts, val) } +// RecordSystemLinuxMemoryDirtyDataPoint adds a data point to system.linux.memory.dirty metric. +func (mb *MetricsBuilder) RecordSystemLinuxMemoryDirtyDataPoint(ts pcommon.Timestamp, val int64) { + mb.metricSystemLinuxMemoryDirty.recordDataPoint(mb.startTime, ts, val) +} + // RecordSystemMemoryLimitDataPoint adds a data point to system.memory.limit metric. func (mb *MetricsBuilder) RecordSystemMemoryLimitDataPoint(ts pcommon.Timestamp, val int64) { mb.metricSystemMemoryLimit.recordDataPoint(mb.startTime, ts, val) } +// RecordSystemMemoryPageSizeDataPoint adds a data point to system.memory.page_size metric. +func (mb *MetricsBuilder) RecordSystemMemoryPageSizeDataPoint(ts pcommon.Timestamp, val int64) { + mb.metricSystemMemoryPageSize.recordDataPoint(mb.startTime, ts, val) +} + // RecordSystemMemoryUsageDataPoint adds a data point to system.memory.usage metric. func (mb *MetricsBuilder) RecordSystemMemoryUsageDataPoint(ts pcommon.Timestamp, val int64, stateAttributeValue AttributeState) { mb.metricSystemMemoryUsage.recordDataPoint(mb.startTime, ts, val, stateAttributeValue.String()) diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_test.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_test.go index a10f3ad4b3972..1a7f585f5471f 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/generated_metrics_test.go @@ -62,9 +62,15 @@ func TestMetricsBuilder(t *testing.T) { allMetricsCount++ mb.RecordSystemLinuxMemoryAvailableDataPoint(ts, 1) + allMetricsCount++ + mb.RecordSystemLinuxMemoryDirtyDataPoint(ts, 1) + allMetricsCount++ mb.RecordSystemMemoryLimitDataPoint(ts, 1) + allMetricsCount++ + mb.RecordSystemMemoryPageSizeDataPoint(ts, 1) + defaultMetricsCount++ allMetricsCount++ mb.RecordSystemMemoryUsageDataPoint(ts, 1, AttributeStateBuffered) @@ -108,6 +114,20 @@ func TestMetricsBuilder(t *testing.T) { assert.Equal(t, ts, dp.Timestamp()) assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) assert.Equal(t, int64(1), dp.IntValue()) + case "system.linux.memory.dirty": + assert.False(t, validatedMetrics["system.linux.memory.dirty"], "Found a duplicate in the metrics slice: system.linux.memory.dirty") + validatedMetrics["system.linux.memory.dirty"] = true + assert.Equal(t, pmetric.MetricTypeSum, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Sum().DataPoints().Len()) + assert.Equal(t, "The amount of dirty memory according to `/proc/meminfo`.", ms.At(i).Description()) + assert.Equal(t, "By", ms.At(i).Unit()) + assert.False(t, ms.At(i).Sum().IsMonotonic()) + assert.Equal(t, pmetric.AggregationTemporalityCumulative, ms.At(i).Sum().AggregationTemporality()) + dp := ms.At(i).Sum().DataPoints().At(0) + assert.Equal(t, start, dp.StartTimestamp()) + assert.Equal(t, ts, dp.Timestamp()) + assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) case "system.memory.limit": assert.False(t, validatedMetrics["system.memory.limit"], "Found a duplicate in the metrics slice: system.memory.limit") validatedMetrics["system.memory.limit"] = true @@ -122,6 +142,18 @@ func TestMetricsBuilder(t *testing.T) { assert.Equal(t, ts, dp.Timestamp()) assert.Equal(t, pmetric.NumberDataPointValueTypeInt, dp.ValueType()) assert.Equal(t, int64(1), dp.IntValue()) + case "system.memory.page_size": + assert.False(t, validatedMetrics["system.memory.page_size"], "Found a duplicate in the metrics slice: system.memory.page_size") + validatedMetrics["system.memory.page_size"] = true + assert.Equal(t, pmetric.MetricTypeGauge, ms.At(i).Type()) + assert.Equal(t, 1, ms.At(i).Gauge().DataPoints().Len()) + assert.Equal(t, "A constant value for the system's configured page size.", ms.At(i).Description()) + assert.Equal(t, "By", 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.NumberDataPointValueTypeInt, dp.ValueType()) + assert.Equal(t, int64(1), dp.IntValue()) case "system.memory.usage": assert.False(t, validatedMetrics["system.memory.usage"], "Found a duplicate in the metrics slice: system.memory.usage") validatedMetrics["system.memory.usage"] = true diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/testdata/config.yaml b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/testdata/config.yaml index f0fa3f3d0eba4..d08bd91fea43e 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/testdata/config.yaml +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/testdata/config.yaml @@ -3,8 +3,12 @@ all_set: metrics: system.linux.memory.available: enabled: true + system.linux.memory.dirty: + enabled: true system.memory.limit: enabled: true + system.memory.page_size: + enabled: true system.memory.usage: enabled: true system.memory.utilization: @@ -13,8 +17,12 @@ none_set: metrics: system.linux.memory.available: enabled: false + system.linux.memory.dirty: + enabled: false system.memory.limit: enabled: false + system.memory.page_size: + enabled: false system.memory.usage: enabled: false system.memory.utilization: diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper.go index bcc249ea8c528..0e4e22f7f8ce8 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper.go @@ -7,6 +7,7 @@ import ( "context" "errors" "fmt" + "os" "time" "github.com/shirou/gopsutil/v4/host" @@ -33,11 +34,19 @@ type memoryScraper struct { // for mocking gopsutil mem.VirtualMemory bootTime func(context.Context) (uint64, error) virtualMemory func(context.Context) (*mem.VirtualMemoryStat, error) + + pageSize int64 } // newMemoryScraper creates a Memory Scraper func newMemoryScraper(_ context.Context, settings scraper.Settings, cfg *Config) *memoryScraper { - return &memoryScraper{settings: settings, config: cfg, bootTime: host.BootTimeWithContext, virtualMemory: mem.VirtualMemoryWithContext} + return &memoryScraper{ + settings: settings, + config: cfg, + bootTime: host.BootTimeWithContext, + virtualMemory: mem.VirtualMemoryWithContext, + pageSize: int64(os.Getpagesize()), + } } func (s *memoryScraper) start(ctx context.Context, _ component.Host) error { @@ -70,7 +79,12 @@ func (s *memoryScraper) scrape(ctx context.Context) (pmetric.Metrics, error) { s.recordMemoryUtilizationMetric(now, memInfo) s.recordMemoryLimitMetric(now, memInfo) s.recordSystemSpecificMetrics(now, memInfo) + s.recordMemoryPageSizeMetric(now) } return s.mb.Emit(), nil } + +func (s *memoryScraper) recordMemoryPageSizeMetric(now pcommon.Timestamp) { + s.mb.RecordSystemMemoryPageSizeDataPoint(now, s.pageSize) +} diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go index 1a6aa11d3136c..3ed26114d52a3 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go @@ -34,6 +34,13 @@ func (s *memoryScraper) recordLinuxMemoryAvailableMetric(now pcommon.Timestamp, s.mb.RecordSystemLinuxMemoryAvailableDataPoint(now, int64(memInfo.Available)) } +func (s *memoryScraper) recordLinuxMemoryDirtyMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { + // This value is collected from /proc/meminfo and converted from kB to bytes in gopsutil: + // https://github.com/shirou/gopsutil/blob/d8750909ba41f2de9750c90a6d2074c68dfc677e/mem/mem_linux.go#L148 + s.mb.RecordSystemLinuxMemoryDirtyDataPoint(now, int64(memInfo.Dirty)) +} + func (s *memoryScraper) recordSystemSpecificMetrics(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) { s.recordLinuxMemoryAvailableMetric(now, memInfo) + s.recordLinuxMemoryDirtyMetric(now, memInfo) } diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go index e167d2daf6ff1..2cbab20ff0ba4 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go @@ -52,17 +52,23 @@ func TestScrape(t *testing.T) { SystemMemoryUsage: metadata.MetricConfig{ Enabled: true, }, + SystemMemoryPageSize: metadata.MetricConfig{ + Enabled: true, + }, SystemLinuxMemoryAvailable: metadata.MetricConfig{ Enabled: true, }, + SystemLinuxMemoryDirty: metadata.MetricConfig{ + Enabled: true, + }, }, }, }, expectedMetricCount: func() int { if runtime.GOOS == "linux" { - return 3 + return 5 } - return 2 + return 3 }(), }, { diff --git a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/metadata.yaml b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/metadata.yaml index 4adb8241c4a9a..072e8aaa994ff 100644 --- a/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/metadata.yaml +++ b/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/metadata.yaml @@ -44,6 +44,15 @@ metrics: value_type: double attributes: [state] + system.memory.page_size: + enabled: false + description: A constant value for the system's configured page size. + unit: By + gauge: + value_type: int + aggregation_temporality: cumulative + monotonic: false + system.linux.memory.available: enabled: false description: An estimate of how much memory is available for starting new applications, without swapping. This is a more accurate alternative than system.memory.usage with state=free. (Linux only) @@ -52,3 +61,12 @@ metrics: value_type: int aggregation_temporality: cumulative monotonic: false + + system.linux.memory.dirty: + enabled: false + description: The amount of dirty memory according to `/proc/meminfo`. + unit: By + sum: + value_type: int + aggregation_temporality: cumulative + monotonic: false