[receiver/hostmetricsreceiver] Add system.memory.linux.shared metric

.chloggen/hostmetricsreceiver-add-systemmemoryshared-metric.yaml

@@ -0,0 +1,34 @@
+# 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. receiver/filelog)
+component: receiver/hostmetrics
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add optional `system.memory.shared` metric (currently Linux only)
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [32712]
+
+# (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: |
+    This metric reports shared memory usage, including tmpfs filesystems,
+    System V shared memory, and POSIX shared memory. Currently only available
+    on Linux systems due to platform-specific data availability.
+    This corresponds to the `Shmem` field in `/proc/meminfo`.
+
+    Support for other platforms may be added in the future when the underlying
+    gopsutil library provides the necessary data.
+
+# 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]

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/documentation.md

@@ -68,6 +68,14 @@ A constant value for the system's configured page size.
 | ---- | ----------- | ---------- | --------- |
 | By | Gauge | Int | Development |
 
+### system.memory.shared
+
+Shared memory usage, including tmpfs filesystems and System V/POSIX shared memory. Currently only supported on Linux.
+
+| Unit | Metric Type | Value Type | Aggregation Temporality | Monotonic | Stability |
+| ---- | ----------- | ---------- | ----------------------- | --------- | --------- |
+| By | Sum | Int | Cumulative | false | Development |
+
 ### system.memory.utilization
 
 Percentage of memory bytes in use.

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata/testdata/config.yaml

@@ -9,6 +9,8 @@ all_set:
       enabled: true
     system.memory.page_size:
       enabled: true
+    system.memory.shared:
+      enabled: true
     system.memory.usage:
       enabled: true
     system.memory.utilization:
@@ -23,6 +25,8 @@ none_set:
       enabled: false
     system.memory.page_size:
       enabled: false
+    system.memory.shared:
+      enabled: false
     system.memory.usage:
       enabled: false
     system.memory.utilization:

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux.go

@@ -37,6 +37,10 @@ func (s *memoryScraper) recordMemoryUsageMetric(now pcommon.Timestamp, memInfo *
 	s.mb.RecordSystemMemoryUsageDataPoint(now, int64(memInfo.Sunreclaim), metadata.AttributeStateSlabUnreclaimable)
 }
 
+func (s *memoryScraper) recordMemorySharedMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) {
+	s.mb.RecordSystemMemorySharedDataPoint(now, int64(memInfo.Shared))
+}
+
 func (s *memoryScraper) recordMemoryUtilizationMetric(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) {
 	// TODO: rely on memInfo.Used value once https://github.com/shirou/gopsutil/pull/1882 is released
 	// gopsutil formula: https://github.com/shirou/gopsutil/pull/1882/files#diff-5af8322731595fb792b48f3c38f31ddb24f596cf11a74a9c37b19734597baef6R321
@@ -66,4 +70,5 @@ func (s *memoryScraper) recordLinuxMemoryDirtyMetric(now pcommon.Timestamp, memI
 func (s *memoryScraper) recordSystemSpecificMetrics(now pcommon.Timestamp, memInfo *mem.VirtualMemoryStat) {
 	s.recordLinuxMemoryAvailableMetric(now, memInfo)
 	s.recordLinuxMemoryDirtyMetric(now, memInfo)
+	s.recordMemorySharedMetric(now, memInfo)
 }

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_linux_test.go

@@ -12,6 +12,7 @@ import (
 	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/featuregate"
 	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.opentelemetry.io/collector/scraper/scrapertest"
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/hostmetricsreceiver/internal/scraper/memoryscraper/internal/metadata"
@@ -53,3 +54,40 @@ func TestScrape_UseMemAvailable(t *testing.T) {
 	assert.Greater(t, memUsedMd.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0).Sum().DataPoints().At(0).IntValue(), legacyMd.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(0).Sum().DataPoints().At(0).IntValue(), "system.memory.usage for the used state should be greater when computed using memAvailable")
 	assert.Greater(t, memUsedMd.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1).Gauge().DataPoints().At(0).DoubleValue(), legacyMd.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics().At(1).Gauge().DataPoints().At(0).DoubleValue(), "system.memory.utilization for the used state should be greater when computed using memAvailable")
 }
+
+func TestScrape_SharedMemory(t *testing.T) {
+	mbc := metadata.DefaultMetricsBuilderConfig()
+	mbc.Metrics.SystemMemoryShared.Enabled = true
+	scraperConfig := Config{
+		MetricsBuilderConfig: mbc,
+	}
+	scraper := newMemoryScraper(t.Context(), scrapertest.NewNopSettings(metadata.Type), &scraperConfig)
+
+	err := scraper.start(t.Context(), componenttest.NewNopHost())
+	require.NoError(t, err, "Failed to initialize memory scraper: %v", err)
+
+	memInfo, err := scraper.virtualMemory(t.Context())
+	require.NoError(t, err)
+	require.NotNil(t, memInfo)
+
+	scraper.recordMemorySharedMetric(pcommon.NewTimestampFromTime(time.Now()), memInfo)
+	md := scraper.mb.Emit()
+
+	require.Equal(t, 1, md.ResourceMetrics().Len())
+	require.Equal(t, 1, md.ResourceMetrics().At(0).ScopeMetrics().Len())
+
+	metrics := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics()
+	require.Equal(t, 1, metrics.Len(), "Expected exactly one metric")
+
+	metric := metrics.At(0)
+	assert.Equal(t, "system.memory.shared", metric.Name())
+	assert.Equal(t, pmetric.MetricTypeSum, metric.Type())
+
+	dataPoints := metric.Sum().DataPoints()
+	require.Equal(t, 1, dataPoints.Len(), "Expected exactly one data point")
+
+	assert.GreaterOrEqual(t, dataPoints.At(0).IntValue(), int64(0))
+
+	_, hasState := dataPoints.At(0).Attributes().Get("state")
+	assert.False(t, hasState, "system.memory.shared should not have a state attribute")
+}

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/memory_scraper_test.go

@@ -61,12 +61,15 @@ func TestScrape(t *testing.T) {
 						SystemLinuxMemoryDirty: metadata.MetricConfig{
 							Enabled: true,
 						},
+						SystemMemoryShared: metadata.MetricConfig{
+							Enabled: true,
+						},
 					},
 				},
 			},
 			expectedMetricCount: func() int {
 				if runtime.GOOS == "linux" {
-					return 5
+					return 6
 				}
 				return 3
 			}(),
@@ -127,15 +130,22 @@ func TestScrape(t *testing.T) {
 
 			metrics := md.ResourceMetrics().At(0).ScopeMetrics().At(0).Metrics()
 			memUsageIdx := -1
+			memSharedIdx := -1
 			for i := 0; i < md.MetricCount(); i++ {
 				if metrics.At(i).Name() == "system.memory.usage" {
 					memUsageIdx = i
 				}
+				if metrics.At(i).Name() == "system.memory.shared" {
+					memSharedIdx = i
+				}
 			}
 			assert.NotEqual(t, -1, memUsageIdx)
 			assertMemoryUsageMetricValid(t, metrics.At(memUsageIdx), "system.memory.usage")
 
 			if runtime.GOOS == "linux" {
+				if memSharedIdx != -1 {
+					assertMemorySharedMetricValid(t, metrics.At(memSharedIdx), "system.memory.shared")
+				}
 				assertMemoryUsageMetricHasLinuxSpecificStateLabels(t, metrics.At(memUsageIdx))
 			} else if runtime.GOOS != "windows" {
 				internal.AssertSumMetricHasAttributeValue(t, metrics.At(memUsageIdx), 2, "state",
@@ -202,6 +212,20 @@ func TestScrape_MemoryUtilization(t *testing.T) {
 	}
 }
 
+func assertMemorySharedMetricValid(t *testing.T, metric pmetric.Metric, expectedName string) {
+	assert.Equal(t, expectedName, metric.Name())
+	assert.Equal(t, pmetric.MetricTypeSum, metric.Type())
+	assert.Equal(t, "By", metric.Unit())
+	assert.Equal(t, "Shared memory usage, including tmpfs filesystems and System V/POSIX shared memory. Currently only supported on Linux.", metric.Description())
+	assert.False(t, metric.Sum().IsMonotonic(), "shared memory is not monotonic")
+	assert.Equal(t, pmetric.AggregationTemporalityCumulative, metric.Sum().AggregationTemporality())
+	dataPoints := metric.Sum().DataPoints()
+	assert.Equal(t, 1, dataPoints.Len(), "should have exactly one data point (no state attribute)")
+	assert.GreaterOrEqual(t, dataPoints.At(0).IntValue(), int64(0), "shared memory should be non-negative")
+	_, hasState := dataPoints.At(0).Attributes().Get("state")
+	assert.False(t, hasState, "system.memory.shared should not have a state attribute")
+}
+
 func assertMemoryUsageMetricValid(t *testing.T, metric pmetric.Metric, expectedName string) {
 	assert.Equal(t, expectedName, metric.Name())
 	assert.GreaterOrEqual(t, metric.Sum().DataPoints().Len(), 2)

receiver/hostmetricsreceiver/internal/scraper/memoryscraper/metadata.yaml

@@ -38,6 +38,7 @@ metrics:
       value_type: int
       aggregation_temporality: cumulative
       monotonic: false
+
   system.memory.limit:
     enabled: false
     description: Total bytes of memory available.
@@ -60,6 +61,17 @@ metrics:
       aggregation_temporality: cumulative
       monotonic: false
 
+  system.memory.shared:
+    enabled: false
+    description: Shared memory usage, including tmpfs filesystems and System V/POSIX shared memory. Currently only supported on Linux.
+    unit: By
+    stability:
+      level: development
+    sum:
+      value_type: int
+      aggregation_temporality: cumulative
+      monotonic: false
+
   system.memory.usage:
     enabled: true
     description: Bytes of memory in use.