feat: windows cpu calculation fix using PDH counters

* feat: windows cpu calculation using PDH counters

* feat: bug fix with cpu darwin

* feat: linting fixes and additional test cases

* feat: change logic to use PdhGetRawCounterArray to handle multiple cPU groups

* feat: linting fixes

* feat: liniting fixes

* feat: linting fixes

* review fixes

* feat: linting fixes

* feat: linting fixes

* feat: linting fixes

* feat: linting fixes

Author: ujwalsah

internal/windows/api/pdh.go

@@ -125,6 +125,12 @@ type (
 	PDH_HCOUNTER HANDLE // counter handle
 )
 
+// Windows FILETIME structure
+type FILETIME struct {
+	LowDateTime  uint32
+	HighDateTime uint32
+}
+
 // Union specialization for double values
 type PDH_FMT_COUNTERVALUE_DOUBLE struct {
 	CStatus     uint32
@@ -162,6 +168,21 @@ type PDH_FMT_COUNTERVALUE_ITEM_LONG struct {
 	FmtValue PDH_FMT_COUNTERVALUE_LONG
 }
 
+// Raw counter value structure
+type PDH_RAW_COUNTER struct {
+	CStatus     uint32
+	TimeStamp   FILETIME
+	FirstValue  int64 // For rate-based counters, this is typically the numerator or the current sample value.
+	SecondValue int64 // For rate-based counters, this is typically the denominator or the previous sample value.
+	MultiCount  uint32
+}
+
+// Raw counter array item structure
+type PDH_RAW_COUNTER_ITEM struct {
+	SzName   *uint16 // pointer to a string
+	RawValue PDH_RAW_COUNTER
+}
+
 var (
 	// Library
 	libpdhDll *syscall.DLL
@@ -173,6 +194,7 @@ var (
 	pdh_CollectQueryData          *syscall.Proc
 	pdh_GetFormattedCounterValue  *syscall.Proc
 	pdh_GetFormattedCounterArrayW *syscall.Proc
+	pdh_GetRawCounterArrayW       *syscall.Proc
 	pdh_OpenQuery                 *syscall.Proc
 	pdh_ValidatePathW             *syscall.Proc
 )
@@ -188,6 +210,7 @@ func init() {
 	pdh_CollectQueryData = libpdhDll.MustFindProc("PdhCollectQueryData")
 	pdh_GetFormattedCounterValue = libpdhDll.MustFindProc("PdhGetFormattedCounterValue")
 	pdh_GetFormattedCounterArrayW = libpdhDll.MustFindProc("PdhGetFormattedCounterArrayW")
+	pdh_GetRawCounterArrayW = libpdhDll.MustFindProc("PdhGetRawCounterArrayW")
 	pdh_OpenQuery = libpdhDll.MustFindProc("PdhOpenQuery")
 	pdh_ValidatePathW = libpdhDll.MustFindProc("PdhValidatePathW")
 
@@ -439,3 +462,38 @@ func PdhValidatePath(path string) uint32 {
 
 	return uint32(ret)
 }
+
+// Returns an array of raw counter values for a counter that contains a wildcard character for the instance name.
+// This function is particularly useful for collecting CPU metrics from multiple CPU groups.
+// The itemBuffer must be a slice of type PDH_RAW_COUNTER_ITEM.
+func PdhGetRawCounterArray(hCounter PDH_HCOUNTER, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *PDH_RAW_COUNTER_ITEM) uint32 {
+	ret, _, _ := pdh_GetRawCounterArrayW.Call(
+		uintptr(hCounter),
+		uintptr(unsafe.Pointer(lpdwBufferSize)),
+		uintptr(unsafe.Pointer(lpdwBufferCount)),
+		uintptr(unsafe.Pointer(itemBuffer)))
+
+	return uint32(ret)
+}
+
+// UTF16PtrToString converts a UTF16 pointer to a Go string
+func UTF16PtrToString(ptr *uint16) string {
+	if ptr == nil {
+		return ""
+	}
+
+	// Find the length of the null-terminated wide string
+	length := 0
+	for p := ptr; *p != 0; {
+		length++
+		p = (*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 2))
+	}
+
+	if length == 0 {
+		return ""
+	}
+
+	// Convert to []uint16 slice and then to string
+	slice := unsafe.Slice(ptr, length)
+	return syscall.UTF16ToString(slice)
+}

internal/windows/api/pdh_test.go

@@ -0,0 +1,222 @@
+//go:build windows
+// +build windows
+
+// Copyright 2020 New Relic Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package winapi
+
+import (
+	"syscall"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUTF16PtrToString(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Empty string",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "Simple ASCII string",
+			input:    "hello",
+			expected: "hello",
+		},
+		{
+			name:     "String with spaces",
+			input:    "hello world",
+			expected: "hello world",
+		},
+		{
+			name:     "String with numbers",
+			input:    "test123",
+			expected: "test123",
+		},
+		{
+			name:     "String with special characters",
+			input:    "test@#$%",
+			expected: "test@#$%",
+		},
+		{
+			name:     "Long string",
+			input:    "this is a much longer string to test the function with more data",
+			expected: "this is a much longer string to test the function with more data",
+		},
+		{
+			name:     "String with unicode characters",
+			input:    "héllo wørld",
+			expected: "héllo wørld",
+		},
+		{
+			name:     "Windows path-like string",
+			input:    "\\Processor(_Total)\\% Processor Time",
+			expected: "\\Processor(_Total)\\% Processor Time",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Convert input string to UTF16 pointer using syscall
+			utf16Ptr, err := syscall.UTF16PtrFromString(tt.input)
+			require.NoError(t, err, "Failed to create UTF16 pointer from string")
+
+			// Test the function
+			result := UTF16PtrToString(utf16Ptr)
+
+			// Verify the result
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestUTF16PtrToString_NilPointer(t *testing.T) {
+	t.Parallel()
+
+	// Test with nil pointer
+	result := UTF16PtrToString(nil)
+	assert.Equal(t, "", result, "Should return empty string for nil pointer")
+}
+
+func TestUTF16PtrToString_ZeroLengthString(t *testing.T) {
+	t.Parallel()
+
+	// Create a UTF16 string that points to a null terminator (zero-length string)
+	nullTerminator := uint16(0)
+	ptr := &nullTerminator
+
+	result := UTF16PtrToString(ptr)
+	assert.Equal(t, "", result, "Should return empty string for zero-length UTF16 string")
+}
+
+func TestUTF16PtrToString_ManualUTF16Array(t *testing.T) {
+	t.Parallel()
+
+	// Manually create a UTF16 array: "test" + null terminator
+	utf16Array := []uint16{
+		0x0074, // 't'
+		0x0065, // 'e'
+		0x0073, // 's'
+		0x0074, // 't'
+		0x0000, // null terminator
+	}
+
+	// Get pointer to first element
+	ptr := &utf16Array[0]
+
+	result := UTF16PtrToString(ptr)
+	assert.Equal(t, "test", result, "Should correctly parse manually created UTF16 array")
+}
+
+func TestUTF16PtrToString_EdgeCases(t *testing.T) {
+	t.Parallel()
+
+	t.Run("Single character", func(t *testing.T) {
+		t.Parallel()
+
+		utf16Ptr, err := syscall.UTF16PtrFromString("A")
+		require.NoError(t, err)
+
+		result := UTF16PtrToString(utf16Ptr)
+		assert.Equal(t, "A", result)
+	})
+
+	t.Run("String with newlines", func(t *testing.T) {
+		t.Parallel()
+
+		input := "line1\nline2\r\nline3"
+		utf16Ptr, err := syscall.UTF16PtrFromString(input)
+		require.NoError(t, err)
+
+		result := UTF16PtrToString(utf16Ptr)
+		assert.Equal(t, input, result)
+	})
+
+	t.Run("String with tabs", func(t *testing.T) {
+		t.Parallel()
+
+		input := "col1\tcol2\tcol3"
+		utf16Ptr, err := syscall.UTF16PtrFromString(input)
+		require.NoError(t, err)
+
+		result := UTF16PtrToString(utf16Ptr)
+		assert.Equal(t, input, result)
+	})
+}
+
+// BenchmarkUTF16PtrToString benchmarks the performance of the function.
+func BenchmarkUTF16PtrToString(b *testing.B) {
+	// Create test string
+	testString := "\\Processor(_Total)\\% Processor Time"
+	utf16Ptr, err := syscall.UTF16PtrFromString(testString)
+	require.NoError(b, err)
+
+	b.ResetTimer()
+
+	for range b.N {
+		_ = UTF16PtrToString(utf16Ptr)
+	}
+}
+
+// BenchmarkUTF16PtrToString_LongString benchmarks with a longer string.
+func BenchmarkUTF16PtrToString_LongString(b *testing.B) {
+	// Create a longer test string
+	testString := "This is a much longer string to test the performance of the UTF16PtrToString function with more realistic data that might be encountered in real-world scenarios"
+	utf16Ptr, err := syscall.UTF16PtrFromString(testString)
+	require.NoError(b, err)
+
+	b.ResetTimer()
+
+	for range b.N {
+		_ = UTF16PtrToString(utf16Ptr)
+	}
+}
+
+// TestUTF16PtrToString_CompareWithSyscall verifies our implementation matches syscall behavior.
+func TestUTF16PtrToString_CompareWithSyscall(t *testing.T) {
+	t.Parallel()
+
+	testStrings := []string{
+		"hello",
+		"hello world",
+		"\\Processor(_Total)\\% Processor Time",
+		"test with unicode: héllo wørld 你好",
+		"",
+		"A",
+		"special chars: !@#$%^&*()",
+	}
+
+	for _, testStr := range testStrings {
+		t.Run("Compare_"+testStr, func(t *testing.T) {
+			t.Parallel()
+
+			// Convert to UTF16 slice first, then get pointer
+			utf16Slice, err := syscall.UTF16FromString(testStr)
+			require.NoError(t, err)
+
+			// Get pointer to first element (if slice is not empty)
+			if len(utf16Slice) > 0 {
+				ptr := &utf16Slice[0]
+
+				// Test our function
+				ourResult := UTF16PtrToString(ptr)
+
+				// Compare with syscall's implementation
+				syscallResult := syscall.UTF16ToString(utf16Slice[:len(utf16Slice)-1]) // Remove null terminator for syscall
+
+				assert.Equal(t, syscallResult, ourResult, "Our implementation should match syscall.UTF16ToString")
+			}
+		})
+	}
+}