[cpu/windows] Switch to performance counters

go.mod

@@ -4,7 +4,7 @@ go 1.22.8
 
 require (
 	github.com/docker/docker v26.1.5+incompatible
-	github.com/elastic/elastic-agent-libs v0.9.13
+	github.com/elastic/elastic-agent-libs v0.17.4-0.20241126154321-6ed75416832d
 	github.com/elastic/go-licenser v0.4.2
 	github.com/elastic/go-structform v0.0.9
 	github.com/elastic/go-sysinfo v1.14.1

go.sum

@@ -21,8 +21,8 @@ github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKoh
 github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/elastic/elastic-agent-libs v0.9.13 h1:D1rh1s67zlkDWmixWQaNWzn+qy6DafIDPTQnLpBNBUA=
-github.com/elastic/elastic-agent-libs v0.9.13/go.mod h1:G9ljFvDE+muOOOQBf2eRituF0fE4suGkv25rfjTwY+c=
+github.com/elastic/elastic-agent-libs v0.17.4-0.20241126154321-6ed75416832d h1:nY8LSeTYU1uSDAAg7WwGH/cALgdovAXLdIzV25Ky0Bo=
+github.com/elastic/elastic-agent-libs v0.17.4-0.20241126154321-6ed75416832d/go.mod h1:5CR02awPrBr+tfmjBBK+JI+dMmHNQjpVY24J0wjbC7M=
 github.com/elastic/go-licenser v0.4.2 h1:bPbGm8bUd8rxzSswFOqvQh1dAkKGkgAmrPxbUi+Y9+A=
 github.com/elastic/go-licenser v0.4.2/go.mod h1:W8eH6FaZDR8fQGm+7FnVa7MxI1b/6dAqxz+zPB8nm5c=
 github.com/elastic/go-structform v0.0.9 h1:HpcS7xljL4kSyUfDJ8cXTJC6rU5ChL1wYb6cx3HLD+o=

metric/cpu/metric_windows_test.go

@@ -0,0 +1,51 @@
+// Licensed to Elasticsearch B.V. under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Elasticsearch B.V. licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//go:build windows
+
+package cpu
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCounterLength(t *testing.T) {
+	query, err := buildQuery()
+	require.NoError(t, err)
+	require.NoError(t, query.CollectData())
+
+	kernelRawData, err := query.GetRawCounterArray(totalKernelTimeCounter, true)
+	require.NoError(t, err)
+
+	idleRawData, err := query.GetRawCounterArray(totalIdleTimeCounter, true)
+	require.NoError(t, err)
+
+	userRawData, err := query.GetRawCounterArray(totalUserTimeCounter, true)
+	require.NoError(t, err)
+
+	require.Equal(t, len(kernelRawData), len(idleRawData))
+	require.Equal(t, len(userRawData), len(idleRawData))
+
+	for i := 0; i < len(userRawData); i++ {
+		require.Equal(t, userRawData[i].InstanceName, kernelRawData[i].InstanceName, "InstanceName should be equal")
+	}
+	for i := 0; i < len(kernelRawData); i++ {
+		require.Equal(t, kernelRawData[i].InstanceName, idleRawData[i].InstanceName, "InstanceName should be equal")
+	}
+}

metric/cpu/metrics.go

@@ -84,6 +84,18 @@ The below code implements a "metrics tracker" that gives us the ability to
 calculate CPU percentages, as we average usage across a time period.
 */
 
+type option struct {
+	usePerformanceCounter bool
+}
+
+type OptionFunc func(*option)
+
+func WithPerformanceCounter() OptionFunc {
+	return func(o *option) {
+		o.usePerformanceCounter = true
+	}
+}
+
 // Monitor is used to monitor the overall CPU usage of the system over time.
 type Monitor struct {
 	lastSample CPUMetrics
@@ -98,8 +110,8 @@ func New(hostfs resolve.Resolver) *Monitor {
 
 // Fetch collects a new sample of the CPU usage metrics.
 // This will overwrite the currently stored samples.
-func (m *Monitor) Fetch() (Metrics, error) {
-	metric, err := Get(m.Hostfs)
+func (m *Monitor) Fetch(opts ...OptionFunc) (Metrics, error) {
+	metric, err := Get(m.Hostfs, opts...)
 	if err != nil {
 		return Metrics{}, fmt.Errorf("error fetching CPU metrics: %w", err)
 	}
@@ -112,9 +124,8 @@ func (m *Monitor) Fetch() (Metrics, error) {
 
 // FetchCores collects a new sample of CPU usage metrics per-core
 // This will overwrite the currently stored samples.
-func (m *Monitor) FetchCores() ([]Metrics, error) {
-
-	metric, err := Get(m.Hostfs)
+func (m *Monitor) FetchCores(opts ...OptionFunc) ([]Metrics, error) {
+	metric, err := Get(m.Hostfs, opts...)
 	if err != nil {
 		return nil, fmt.Errorf("error fetching CPU metrics: %w", err)
 	}

metric/cpu/metrics_aix.go

@@ -58,7 +58,7 @@ func tick2msec(val uint64) uint64 {
 }
 
 // Get returns a metrics object for CPU data
-func Get(_ resolve.Resolver) (CPUMetrics, error) {
+func Get(_ resolve.Resolver, _ ...OptionFunc) (CPUMetrics, error) {
 
 	totals, err := getCPUTotals()
 	if err != nil {

metric/cpu/metrics_darwin.go

@@ -27,7 +27,7 @@ import (
 )
 
 // Get is the Darwin implementation of Get
-func Get(_ resolve.Resolver) (CPUMetrics, error) {
+func Get(_ resolve.Resolver, _ ...OptionFunc) (CPUMetrics, error) {
 	// We're using the gopsutil library here.
 	// The code used by both gosigar and go-sysinfo appears to be
 	// the same code as gopsutil, including copy-pasted comments.

metric/cpu/metrics_openbsd.go

@@ -41,7 +41,7 @@ import (
 )
 
 // Get is the OpenBSD implementation of get
-func Get(_ resolve.Resolver) (CPUMetrics, error) {
+func Get(_ resolve.Resolver, _ ...OptionFunc) (CPUMetrics, error) {
 
 	// see man 2 sysctl
 	loadGlobal := [C.CPUSTATES]C.long{

metric/cpu/metrics_procfs_common.go

@@ -31,7 +31,7 @@ import (
 )
 
 // Get returns a metrics object for CPU data
-func Get(procfs resolve.Resolver) (CPUMetrics, error) {
+func Get(procfs resolve.Resolver, _ ...OptionFunc) (CPUMetrics, error) {
 	path := procfs.ResolveHostFS("/proc/stat")
 	fd, err := os.Open(path)
 	defer func() {

metric/cpu/metrics_windows.go

@@ -26,13 +26,97 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/elastic/elastic-agent-libs/helpers/windows/pdh"
 	"github.com/elastic/elastic-agent-libs/opt"
 	"github.com/elastic/elastic-agent-system-metrics/metric/system/resolve"
 	"github.com/elastic/gosigar/sys/windows"
 )
 
+var (
+	processorInformationCounter = "\\Processor Information(%s)\\%s"
+	totalKernelTimeCounter      = fmt.Sprintf(processorInformationCounter, "*", "% Privileged Time")
+	totalIdleTimeCounter        = fmt.Sprintf(processorInformationCounter, "*", "% Idle Time")
+	totalUserTimeCounter        = fmt.Sprintf(processorInformationCounter, "*", "% User Time")
+)
+
+var query, qError = buildQuery()
+
 // Get fetches Windows CPU system times
-func Get(_ resolve.Resolver) (CPUMetrics, error) {
+func Get(_ resolve.Resolver, opts ...OptionFunc) (CPUMetrics, error) {
+	op := option{}
+	for _, o := range opts {
+		o(&op)
+	}
+	if !op.usePerformanceCounter {
+		return defaultGet()
+	}
+	globalMetrics := CPUMetrics{}
+	if qError != nil {
+		return globalMetrics, qError
+	}
+
+	if err := query.CollectData(); err != nil {
+		return globalMetrics, err
+	}
+
+	kernelRawData, err := query.GetRawCounterArray(totalKernelTimeCounter, true)
+	if err != nil {
+		return globalMetrics, fmt.Errorf("error calling GetRawCounterArray for kernel counter: %w", err)
+	}
+	idleRawData, err := query.GetRawCounterArray(totalIdleTimeCounter, true)
+	if err != nil {
+		return globalMetrics, fmt.Errorf("error calling GetRawCounterArray for idle counter: %w", err)
+	}
+	userRawData, err := query.GetRawCounterArray(totalUserTimeCounter, true)
+	if err != nil {
+		return globalMetrics, fmt.Errorf("error calling GetRawCounterArray for user counter: %w", err)
+	}
+	var idle, kernel, user time.Duration
+	globalMetrics.list = make([]CPU, len(userRawData))
+	for i := 0; i < len(globalMetrics.list); i++ {
+		// The values returned by GetRawCounterArray are of equal length and are sorted by instance names.
+		// For CPU core {i}, idleRawData[i], kernelRawData[i], and userRawData[i] correspond to the idle time, kernel time, and user time, respectively.
+
+		// values returned by counter are in 100-ns intervals. Hence, convert it to millisecond.
+		idleTime := time.Duration(idleRawData[i].RawValue.FirstValue*100) / time.Millisecond
+		kernelTime := time.Duration(kernelRawData[i].RawValue.FirstValue*100) / time.Millisecond
+		userTime := time.Duration(userRawData[i].RawValue.FirstValue*100) / time.Millisecond
+
+		globalMetrics.list[i].Idle = opt.UintWith(uint64(idleTime))
+		globalMetrics.list[i].Sys = opt.UintWith(uint64(kernelTime))
+		globalMetrics.list[i].User = opt.UintWith(uint64(userTime))
+
+		// add the per-cpu time to track the total time spent by system
+		idle += idleTime
+		kernel += kernelTime
+		user += userTime
+	}
+
+	globalMetrics.totals.Idle = opt.UintWith(uint64(idle))
+	globalMetrics.totals.Sys = opt.UintWith(uint64(kernel))
+	globalMetrics.totals.User = opt.UintWith(uint64(user))
+
+	return globalMetrics, nil
+}
+
+func buildQuery() (pdh.Query, error) {
+	var q pdh.Query
+	if err := q.Open(); err != nil {
+		return q, fmt.Errorf("failed to open query: %w", err)
+	}
+	if err := q.AddCounter(totalKernelTimeCounter, "", "", true, true); err != nil {
+		return q, fmt.Errorf("error calling AddCounter for kernel counter: %w", err)
+	}
+	if err := q.AddCounter(totalUserTimeCounter, "", "", true, true); err != nil {
+		return q, fmt.Errorf("error calling AddCounter for user counter: %w", err)
+	}
+	if err := q.AddCounter(totalIdleTimeCounter, "", "", true, true); err != nil {
+		return q, fmt.Errorf("error calling AddCounter for idle counter: %w", err)
+	}
+	return q, nil
+}
+
+func defaultGet() (CPUMetrics, error) {
 	idle, kernel, user, err := windows.GetSystemTimes()
 	if err != nil {
 		return CPUMetrics{}, fmt.Errorf("call to GetSystemTimes failed: %w", err)