[windows] - Introduce PdhGetRawCounterArrayW

helpers/windows/pdh/pdh_query_windows.go

@@ -80,7 +80,7 @@ func (q *Query) AddEnglishCounter(counterPath string) (PdhCounterHandle, error)
 }
 
 // AddCounter adds the specified counter to the query.
-func (q *Query) AddCounter(counterPath string, instance string, format string, wildcard bool) error {
+func (q *Query) AddCounter(counterPath string, instance string, format string, wildcard bool, english bool) error {
 	if _, found := q.Counters[counterPath]; found {
 		return nil
 	}
@@ -95,7 +95,12 @@ func (q *Query) AddCounter(counterPath string, instance string, format string, w
 	} else {
 		instanceName = instance
 	}
-	h, err := PdhAddCounter(q.Handle, counterPath, 0)
+	var h PdhCounterHandle
+	if english {
+		h, err = PdhAddEnglishCounter(q.Handle, counterPath, 0)
+	} else {
+		h, err = PdhAddCounter(q.Handle, counterPath, 0)
+	}
 	if err != nil {
 		return err
 	}
@@ -203,11 +208,22 @@ func (q *Query) GetCountersAndInstances(objectName string) ([]string, []string,
 	return UTF16ToStringArray(counters), UTF16ToStringArray(instances), nil
 }
 
-func (q *Query) GetRawCounterValue(counterName string) (*PdhRawCounter, error) {
+func (q *Query) GetRawCounterValue(counterName string) (PdhRawCounter, error) {
 	if _, ok := q.Counters[counterName]; !ok {
-		return nil, fmt.Errorf("%s doesn't exist in the map; call AddCounter()", counterName)
+		return PdhRawCounter{}, fmt.Errorf("%s doesn't exist in the map; call AddCounter()", counterName)
 	}
 	c, err := PdhGetRawCounterValue(q.Counters[counterName].handle)
+	if err != nil {
+		return PdhRawCounter{}, err
+	}
+	return c, nil
+}
+
+func (q *Query) GetRawCounterArray(counterName string, filterTotal bool) (RawCounterArray, error) {
+	if _, ok := q.Counters[counterName]; !ok {
+		return nil, fmt.Errorf("%s doesn't exist in the map; call AddCounter()", counterName)
+	}
+	c, err := PdhGetRawCounterArray(q.Counters[counterName].handle, filterTotal)
 	if err != nil {
 		return nil, err
 	}

helpers/windows/pdh/pdh_query_windows_test.go

@@ -38,7 +38,7 @@ func TestAddCounterInvalidArgWhenQueryClosed(t *testing.T) {
 	queryPath, err := q.GetCounterPaths(validQuery)
 	// if windows os language is ENG then err will be nil, else the GetCounterPaths will execute the AddCounter
 	if assert.NoError(t, err) {
-		err = q.AddCounter(queryPath[0], "TestInstanceName", "float", false)
+		err = q.AddCounter(queryPath[0], "TestInstanceName", "float", false, false)
 		assert.Error(t, err, PDH_INVALID_HANDLE)
 	} else {
 		assert.Error(t, err, PDH_INVALID_ARGUMENT)
@@ -73,7 +73,7 @@ func TestSuccessfulQuery(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = q.AddCounter(queryPath[0], "TestInstanceName", "floar", false)
+	err = q.AddCounter(queryPath[0], "TestInstanceName", "floar", false, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -193,3 +193,49 @@ func TestUTF16ToStringArray(t *testing.T) {
 		assert.Contains(t, array, res)
 	}
 }
+
+func TestSortOrder(t *testing.T) {
+	scenarios := []struct {
+		name     string
+		counters []string
+	}{{
+		name: "processor-information",
+		counters: []string{
+			"\\Processor Information(*)\\% User Time",
+			"\\Processor Information(*)\\% Privileged Time",
+			"\\Processor Information(*)\\% Idle Time",
+		},
+	}, {
+		name: "processor",
+		counters: []string{
+			"\\Processor(*)\\% User Time",
+			"\\Processor(*)\\% Privileged Time",
+			"\\Processor(*)\\% Idle Time",
+		},
+	}}
+	for _, s := range scenarios {
+		t.Run(s.name, func(t *testing.T) {
+			var q Query
+			assert.NoError(t, q.Open())
+			for _, counter := range s.counters {
+				assert.NoError(t, q.AddCounter(counter, "", "", false, false))
+			}
+			assert.NoError(t, q.CollectData())
+			rawCounters := make([][]PdhRawCounterItem, 0)
+			for _, counter := range s.counters {
+				arr, err := q.GetRawCounterArray(counter, true)
+				assert.NoError(t, err)
+				rawCounters = append(rawCounters, arr)
+			}
+			for i := 0; i < len(rawCounters)-1; i++ {
+				assert.Equalf(t, len(rawCounters[i]), len(rawCounters[i+1]), "returned counters should be equal")
+			}
+			// confirm that each index corresponds to one particular instance (i.e. core)
+			for i := 0; i < len(rawCounters)-1; i++ {
+				for j := 0; j < len(rawCounters[i]); j++ {
+					assert.Equalf(t, rawCounters[i][j].InstanceName, rawCounters[i+1][j].InstanceName, "Instance name should be equal")
+				}
+			}
+		})
+	}
+}

helpers/windows/pdh/pdh_windows.go

@@ -20,7 +20,9 @@
 package pdh
 
 import (
+	"sort"
 	"strconv"
+	"strings"
 	"syscall"
 	"unicode/utf16"
 	"unsafe"
@@ -108,6 +110,31 @@ type PdhRawCounter struct {
 	SecondValue int64
 	MultiCount  uint32
 }
+type pdhRawCounterItem struct {
+	// Pointer to a null-terminated string that specifies the instance name of the counter. The string is appended to the end of this structure.
+	SzName *uint16
+	//A pdhRawCounter structure that contains the raw counter value of the instance
+	RawValue PdhRawCounter
+}
+
+type PdhRawCounterItem struct {
+	InstanceName string
+	RawValue     PdhRawCounter
+}
+
+type RawCounterArray []PdhRawCounterItem
+
+func (a RawCounterArray) Len() int {
+	return len(a)
+}
+
+func (a RawCounterArray) Swap(i, j int) {
+	a[i], a[j] = a[j], a[i]
+}
+
+func (a RawCounterArray) Less(i, j int) bool {
+	return a[i].InstanceName < a[j].InstanceName
+}
 
 // PdhOpenQuery creates a new query.
 func PdhOpenQuery(dataSource string, userData uintptr) (PdhQueryHandle, error) {
@@ -207,13 +234,43 @@ func PdhGetFormattedCounterValueLong(counter PdhCounterHandle) (uint32, *PdhCoun
 }
 
 // PdhGetRawCounterValue returns the raw value of a given counter.
-func PdhGetRawCounterValue(counter PdhCounterHandle) (*PdhRawCounter, error) {
+func PdhGetRawCounterValue(counter PdhCounterHandle) (PdhRawCounter, error) {
 	var value PdhRawCounter
 	if err := _PdhGetRawCounter(counter, uintptr(unsafe.Pointer(&value))); err != nil {
-		return &value, PdhErrno(err.(syscall.Errno))
+		return value, PdhErrno(err.(syscall.Errno))
 	}
 
-	return &value, nil
+	return value, nil
+}
+
+func PdhGetRawCounterArray(counter PdhCounterHandle, filterTotal bool) (RawCounterArray, error) {
+	var bufferSize, itemCount uint32
+	if err := _PdhGetRawCounterArray(counter, &bufferSize, &itemCount, nil); err != nil {
+		if PdhErrno(err.(syscall.Errno)) != PDH_MORE_DATA {
+			return nil, PdhErrno(err.(syscall.Errno))
+		}
+		buf := make([]byte, bufferSize)
+		if err := _PdhGetRawCounterArray(counter, &bufferSize, &itemCount, &buf[0]); err != nil {
+			return nil, PdhErrno(err.(syscall.Errno))
+		}
+		items := unsafe.Slice((*pdhRawCounterItem)(unsafe.Pointer(&buf[0])), itemCount)
+		ret := make([]PdhRawCounterItem, 0, len(items))
+		for _, item := range items {
+			instance := windows.UTF16PtrToString(item.SzName)
+			if filterTotal && strings.Contains(instance, "_Total") {
+				continue
+			}
+			ret = append(ret, PdhRawCounterItem{
+				RawValue:     item.RawValue,
+				InstanceName: instance,
+			})
+		}
+		// we sort the array by the instance name to ensure that each index in the final array corresponds to a specific core
+		// This is important because we will be collecting three different types of counters, and sorting ensures that each index in each counter aligns with the correct core.
+		sort.Sort(RawCounterArray(ret))
+		return ret, nil
+	}
+	return nil, PdhErrno(syscall.ERROR_NOT_FOUND)
 }
 
 // PdhExpandWildCardPath returns counter paths that match the given counter path.