Report Windows pagefile usage in bytes

receiver/hostmetricsreceiver/internal/scraper/swapscraper/pagefile_windows.go

@@ -24,14 +24,37 @@ import (
 )
 
 var (
-	modPsapi           = windows.NewLazySystemDLL("psapi.dll")
-	procEnumPageFilesW = modPsapi.NewProc("EnumPageFilesW")
+	modKernel32 = windows.NewLazySystemDLL("kernel32.dll")
+	modPsapi    = windows.NewLazySystemDLL("psapi.dll")
+
+	procGetNativeSystemInfo = modKernel32.NewProc("GetNativeSystemInfo")
+	procEnumPageFilesW      = modPsapi.NewProc("EnumPageFilesW")
 )
 
+type systemInfo struct {
+	wProcessorArchitecture      uint16
+	wReserved                   uint16
+	dwPageSize                  uint32
+	lpMinimumApplicationAddress uintptr
+	lpMaximumApplicationAddress uintptr
+	dwActiveProcessorMask       uintptr
+	dwNumberOfProcessors        uint32
+	dwProcessorType             uint32
+	dwAllocationGranularity     uint32
+	wProcessorLevel             uint16
+	wProcessorRevision          uint16
+}
+
+func getPageSize() uint64 {
+	var sysInfo systemInfo
+	procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&sysInfo)))
+	return uint64(sysInfo.dwPageSize)
+}
+
 type pageFileData struct {
-	name  string
-	used  uint64
-	total uint64
+	name       string
+	usedPages  uint64
+	totalPages uint64
 }
 
 // system type as defined in https://docs.microsoft.com/en-us/windows/win32/api/psapi/ns-psapi-enum_page_file_information
@@ -60,9 +83,9 @@ func pEnumPageFileCallbackW(pageFiles *[]*pageFileData, enumPageFileInfo *enumPa
 	pageFileName := syscall.UTF16ToString((*lpFilenamePtr)[:])
 
 	pfData := &pageFileData{
-		name:  pageFileName,
-		used:  enumPageFileInfo.totalInUse,
-		total: enumPageFileInfo.totalSize,
+		name:       pageFileName,
+		usedPages:  enumPageFileInfo.totalInUse,
+		totalPages: enumPageFileInfo.totalSize,
 	}
 
 	*pageFiles = append(*pageFiles, pfData)

receiver/hostmetricsreceiver/internal/scraper/swapscraper/swap_metadata.go

@@ -54,7 +54,7 @@ var swapUsageDescriptor = func() pdata.Metric {
 	metric.InitEmpty()
 	metric.SetName("system.swap.usage")
 	metric.SetDescription("Swap (unix) or pagefile (windows) usage.")
-	metric.SetUnit("pages")
+	metric.SetUnit("bytes")
 	metric.SetDataType(pdata.MetricDataTypeIntSum)
 	sum := metric.IntSum()
 	sum.InitEmpty()

receiver/hostmetricsreceiver/internal/scraper/swapscraper/swap_scraper_windows.go

@@ -19,6 +19,7 @@ package swapscraper
 import (
 	"context"
 	"math"
+	"sync"
 	"time"
 
 	"go.opentelemetry.io/collector/component/componenterror"
@@ -39,6 +40,8 @@ type scraper struct {
 	pageReadsPerSecCounter  pdh.PerfCounterScraper
 	pageWritesPerSecCounter pdh.PerfCounterScraper
 
+	pageSize uint64
+
 	startTime            pdata.TimestampUnixNano
 	prevPagingScrapeTime time.Time
 	cumulativePageReads  float64
@@ -48,9 +51,16 @@ type scraper struct {
 	pageFileStats func() ([]*pageFileData, error)
 }
 
+var (
+	once     sync.Once
+	pageSize uint64
+)
+
 // newSwapScraper creates a Swap Scraper
 func newSwapScraper(_ context.Context, cfg *Config) *scraper {
-	return &scraper{config: cfg, pageFileStats: getPageFileStats}
+	once.Do(func() { pageSize = getPageSize() })
+
+	return &scraper{config: cfg, pageSize: pageSize, pageFileStats: getPageFileStats}
 }
 
 // Initialize
@@ -118,20 +128,20 @@ func (s *scraper) scrapeAndAppendSwapUsageMetric(metrics pdata.MetricSlice) erro
 
 	idx := metrics.Len()
 	metrics.Resize(idx + 1)
-	initializeSwapUsageMetric(metrics.At(idx), now, pageFiles)
+	s.initializeSwapUsageMetric(metrics.At(idx), now, pageFiles)
 	return nil
 }
 
-func initializeSwapUsageMetric(metric pdata.Metric, now pdata.TimestampUnixNano, pageFiles []*pageFileData) {
+func (s *scraper) initializeSwapUsageMetric(metric pdata.Metric, now pdata.TimestampUnixNano, pageFiles []*pageFileData) {
 	swapUsageDescriptor.CopyTo(metric)
 
 	idps := metric.IntSum().DataPoints()
 	idps.Resize(2 * len(pageFiles))
 
 	idx := 0
 	for _, pageFile := range pageFiles {
-		initializeSwapUsageDataPoint(idps.At(idx+0), now, pageFile.name, usedLabelValue, int64(pageFile.used))
-		initializeSwapUsageDataPoint(idps.At(idx+1), now, pageFile.name, freeLabelValue, int64(pageFile.total-pageFile.used))
+		initializeSwapUsageDataPoint(idps.At(idx+0), now, pageFile.name, usedLabelValue, int64(pageFile.usedPages*s.pageSize))
+		initializeSwapUsageDataPoint(idps.At(idx+1), now, pageFile.name, freeLabelValue, int64((pageFile.totalPages-pageFile.usedPages)*s.pageSize))
 		idx += 2
 	}
 }

receiver/hostmetricsreceiver/internal/scraper/swapscraper/swap_scraper_windows_test.go

@@ -30,17 +30,32 @@ import (
 func TestScrapeMetrics_Errors(t *testing.T) {
 	type testCase struct {
 		name                               string
-		pageFileError                      error
+		pageSize                           uint64
+		getPageFileStats                   func() ([]*pageFileData, error)
 		pageReadsPerSecCounterReturnValue  interface{}
 		pageWritesPerSecCounterReturnValue interface{}
 		expectedError                      string
+		expectedUsedValue                  int64
+		expectedFreeValue                  int64
 	}
 
+	testPageSize := uint64(4096)
+	testPageFileData := &pageFileData{usedPages: 100, totalPages: 300}
+
 	testCases := []testCase{
 		{
-			name:          "pageFileError",
-			pageFileError: errors.New("err1"),
-			expectedError: "err1",
+			name:     "standard",
+			pageSize: testPageSize,
+			getPageFileStats: func() ([]*pageFileData, error) {
+				return []*pageFileData{testPageFileData}, nil
+			},
+			expectedUsedValue: int64(testPageFileData.usedPages * testPageSize),
+			expectedFreeValue: int64((testPageFileData.totalPages - testPageFileData.usedPages) * testPageSize),
+		},
+		{
+			name:             "pageFileError",
+			getPageFileStats: func() ([]*pageFileData, error) { return nil, errors.New("err1") },
+			expectedError:    "err1",
 		},
 		{
 			name:                              "readsPerSecCounterError",
@@ -55,7 +70,7 @@ func TestScrapeMetrics_Errors(t *testing.T) {
 		},
 		{
 			name:                              "multipleErrors",
-			pageFileError:                     errors.New("err1"),
+			getPageFileStats:                  func() ([]*pageFileData, error) { return nil, errors.New("err1") },
 			pageReadsPerSecCounterReturnValue: errors.New("err2"),
 			expectedError:                     "[err1; err2]",
 		},
@@ -64,8 +79,14 @@ func TestScrapeMetrics_Errors(t *testing.T) {
 	for _, test := range testCases {
 		t.Run(test.name, func(t *testing.T) {
 			scraper := newSwapScraper(context.Background(), &Config{})
-			if test.pageFileError != nil {
-				scraper.pageFileStats = func() ([]*pageFileData, error) { return nil, test.pageFileError }
+			if test.getPageFileStats != nil {
+				scraper.pageFileStats = test.getPageFileStats
+			}
+			if test.pageSize > 0 {
+				scraper.pageSize = test.pageSize
+			} else {
+				assert.Greater(t, pageSize, uint64(0))
+				assert.Zero(t, pageSize%4096) // page size on Windows should always be a multiple of 4KB
 			}
 
 			err := scraper.Initialize(context.Background())
@@ -75,8 +96,15 @@ func TestScrapeMetrics_Errors(t *testing.T) {
 			scraper.pageReadsPerSecCounter = pdh.NewMockPerfCounter(test.pageReadsPerSecCounterReturnValue)
 			scraper.pageWritesPerSecCounter = pdh.NewMockPerfCounter(test.pageWritesPerSecCounterReturnValue)
 
-			_, err = scraper.ScrapeMetrics(context.Background())
-			assert.EqualError(t, err, test.expectedError)
+			metrics, err := scraper.ScrapeMetrics(context.Background())
+			if test.expectedError != "" {
+				assert.EqualError(t, err, test.expectedError)
+				return
+			}
+
+			swapUsageMetric := metrics.At(0)
+			assert.Equal(t, test.expectedUsedValue, swapUsageMetric.IntSum().DataPoints().At(0).Value())
+			assert.Equal(t, test.expectedFreeValue, swapUsageMetric.IntSum().DataPoints().At(1).Value())
 		})
 	}
 }