perfdata

package
v0.30.0-beta.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 21, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Rendered for windows/amd64

Index

Constants

View Source 
const (
	TicksToSecondScaleFactor       = 1 / 1e7
	WindowsEpoch             int64 = 116444736000000000
)

Conversion factors.

View Source 
const (
	PERF_COUNTER_RAWCOUNT_HEX           = 0x00000000
	PERF_COUNTER_LARGE_RAWCOUNT_HEX     = 0x00000100
	PERF_COUNTER_TEXT                   = 0x00000b00
	PERF_COUNTER_RAWCOUNT               = 0x00010000
	PERF_COUNTER_LARGE_RAWCOUNT         = 0x00010100
	PERF_DOUBLE_RAW                     = 0x00012000
	PERF_COUNTER_DELTA                  = 0x00400400
	PERF_COUNTER_LARGE_DELTA            = 0x00400500
	PERF_SAMPLE_COUNTER                 = 0x00410400
	PERF_COUNTER_QUEUELEN_TYPE          = 0x00450400
	PERF_COUNTER_LARGE_QUEUELEN_TYPE    = 0x00450500
	PERF_COUNTER_100NS_QUEUELEN_TYPE    = 0x00550500
	PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE = 0x00650500
	PERF_COUNTER_COUNTER                = 0x10410400
	PERF_COUNTER_BULK_COUNT             = 0x10410500
	PERF_RAW_FRACTION                   = 0x20020400
	PERF_LARGE_RAW_FRACTION             = 0x20020500
	PERF_COUNTER_TIMER                  = 0x20410500
	PERF_PRECISION_SYSTEM_TIMER         = 0x20470500
	PERF_100NSEC_TIMER                  = 0x20510500
	PERF_PRECISION_100NS_TIMER          = 0x20570500
	PERF_OBJ_TIME_TIMER                 = 0x20610500
	PERF_PRECISION_OBJECT_TIMER         = 0x20670500
	PERF_SAMPLE_FRACTION                = 0x20c20400
	PERF_COUNTER_TIMER_INV              = 0x21410500
	PERF_100NSEC_TIMER_INV              = 0x21510500
	PERF_COUNTER_MULTI_TIMER            = 0x22410500
	PERF_100NSEC_MULTI_TIMER            = 0x22510500
	PERF_COUNTER_MULTI_TIMER_INV        = 0x23410500
	PERF_100NSEC_MULTI_TIMER_INV        = 0x23510500
	PERF_AVERAGE_TIMER                  = 0x30020400
	PERF_ELAPSED_TIME                   = 0x30240500
	PERF_COUNTER_NODATA                 = 0x40000200
	PERF_AVERAGE_BULK                   = 0x40020500
	PERF_SAMPLE_BASE                    = 0x40030401
	PERF_AVERAGE_BASE                   = 0x40030402
	PERF_RAW_BASE                       = 0x40030403
	PERF_PRECISION_TIMESTAMP            = 0x40030500
	PERF_LARGE_RAW_BASE                 = 0x40030503
	PERF_COUNTER_MULTI_BASE             = 0x42030500
	PERF_COUNTER_HISTOGRAM_TYPE         = 0x80000000
)

Based on https://github.com/leoluk/perflib_exporter/blob/master/collector/mapper.go

View Source 
const (
	ErrorSuccess         = 0
	ErrorFailure         = 1
	ErrorInvalidFunction = 1
)

Error codes.

View Source 
const (
	PdhCstatusValidData                   uint32 = 0x00000000 // The returned data is valid.
	PdhCstatusNewData                     uint32 = 0x00000001 // The return data value is valid and different from the last sample.
	PdhCstatusNoMachine                   uint32 = 0x800007D0 // Unable to connect to the specified computer, or the computer is offline.
	PdhCstatusNoInstance                  uint32 = 0x800007D1
	PdhMoreData                           uint32 = 0x800007D2 // The PdhGetFormattedCounterArray* function can return this if there's 'more data to be displayed'.
	PdhCstatusItemNotValidated            uint32 = 0x800007D3
	PdhRetry                              uint32 = 0x800007D4
	PdhNoData                             uint32 = 0x800007D5 // The query does not currently contain any counters (for example, limited access)
	PdhCalcNegativeDenominator            uint32 = 0x800007D6
	PdhCalcNegativeTimebase               uint32 = 0x800007D7
	PdhCalcNegativeValue                  uint32 = 0x800007D8
	PdhDialogCancelled                    uint32 = 0x800007D9
	PdhEndOfLogFile                       uint32 = 0x800007DA
	PdhAsyncQueryTimeout                  uint32 = 0x800007DB
	PdhCannotSetDefaultRealtimeDatasource uint32 = 0x800007DC
	PdhCstatusNoObject                    uint32 = 0xC0000BB8
	PdhCstatusNoCounter                   uint32 = 0xC0000BB9 // The specified counter could not be found.
	PdhCstatusInvalidData                 uint32 = 0xC0000BBA // The counter was successfully found, but the data returned is not valid.
	PdhMemoryAllocationFailure            uint32 = 0xC0000BBB
	PdhInvalidHandle                      uint32 = 0xC0000BBC
	PdhInvalidArgument                    uint32 = 0xC0000BBD // Required argument is missing or incorrect.
	PdhFunctionNotFound                   uint32 = 0xC0000BBE
	PdhCstatusNoCountername               uint32 = 0xC0000BBF
	PdhCstatusBadCountername              uint32 = 0xC0000BC0 // Unable to parse the counter path. Check the format and syntax of the specified path.
	PdhInvalidBuffer                      uint32 = 0xC0000BC1
	PdhInsufficientBuffer                 uint32 = 0xC0000BC2
	PdhCannotConnectMachine               uint32 = 0xC0000BC3
	PdhInvalidPath                        uint32 = 0xC0000BC4
	PdhInvalidInstance                    uint32 = 0xC0000BC5
	PdhInvalidData                        uint32 = 0xC0000BC6 // specified counter does not contain valid data or a successful status code.
	PdhNoDialogData                       uint32 = 0xC0000BC7
	PdhCannotReadNameStrings              uint32 = 0xC0000BC8
	PdhLogFileCreateError                 uint32 = 0xC0000BC9
	PdhLogFileOpenError                   uint32 = 0xC0000BCA
	PdhLogTypeNotFound                    uint32 = 0xC0000BCB
	PdhNoMoreData                         uint32 = 0xC0000BCC
	PdhEntryNotInLogFile                  uint32 = 0xC0000BCD
	PdhDataSourceIsLogFile                uint32 = 0xC0000BCE
	PdhDataSourceIsRealTime               uint32 = 0xC0000BCF
	PdhUnableReadLogHeader                uint32 = 0xC0000BD0
	PdhFileNotFound                       uint32 = 0xC0000BD1
	PdhFileAlreadyExists                  uint32 = 0xC0000BD2
	PdhNotImplemented                     uint32 = 0xC0000BD3
	PdhStringNotFound                     uint32 = 0xC0000BD4
	PdhUnableMapNameFiles                 uint32 = 0x80000BD5
	PdhUnknownLogFormat                   uint32 = 0xC0000BD6
	PdhUnknownLogsvcCommand               uint32 = 0xC0000BD7
	PdhLogsvcQueryNotFound                uint32 = 0xC0000BD8
	PdhLogsvcNotOpened                    uint32 = 0xC0000BD9
	PdhWbemError                          uint32 = 0xC0000BDA
	PdhAccessDenied                       uint32 = 0xC0000BDB
	PdhLogFileTooSmall                    uint32 = 0xC0000BDC
	PdhInvalidDatasource                  uint32 = 0xC0000BDD
	PdhInvalidSqldb                       uint32 = 0xC0000BDE
	PdhNoCounters                         uint32 = 0xC0000BDF
	PdhSQLAllocFailed                     uint32 = 0xC0000BE0
	PdhSQLAllocconFailed                  uint32 = 0xC0000BE1
	PdhSQLExecDirectFailed                uint32 = 0xC0000BE2
	PdhSQLFetchFailed                     uint32 = 0xC0000BE3
	PdhSQLRowcountFailed                  uint32 = 0xC0000BE4
	PdhSQLMoreResultsFailed               uint32 = 0xC0000BE5
	PdhSQLConnectFailed                   uint32 = 0xC0000BE6
	PdhSQLBindFailed                      uint32 = 0xC0000BE7
	PdhCannotConnectWmiServer             uint32 = 0xC0000BE8
	PdhPlaCollectionAlreadyRunning        uint32 = 0xC0000BE9
	PdhPlaErrorScheduleOverlap            uint32 = 0xC0000BEA
	PdhPlaCollectionNotFound              uint32 = 0xC0000BEB
	PdhPlaErrorScheduleElapsed            uint32 = 0xC0000BEC
	PdhPlaErrorNostart                    uint32 = 0xC0000BED
	PdhPlaErrorAlreadyExists              uint32 = 0xC0000BEE
	PdhPlaErrorTypeMismatch               uint32 = 0xC0000BEF
	PdhPlaErrorFilepath                   uint32 = 0xC0000BF0
	PdhPlaServiceError                    uint32 = 0xC0000BF1
	PdhPlaValidationError                 uint32 = 0xC0000BF2
	PdhPlaValidationWarning               uint32 = 0x80000BF3
	PdhPlaErrorNameTooLong                uint32 = 0xC0000BF4
	PdhInvalidSQLLogFormat                uint32 = 0xC0000BF5
	PdhCounterAlreadyInQuery              uint32 = 0xC0000BF6
	PdhBinaryLogCorrupt                   uint32 = 0xC0000BF7
	PdhLogSampleTooSmall                  uint32 = 0xC0000BF8
	PdhOsLaterVersion                     uint32 = 0xC0000BF9
	PdhOsEarlierVersion                   uint32 = 0xC0000BFA
	PdhIncorrectAppendTime                uint32 = 0xC0000BFB
	PdhUnmatchedAppendCounter             uint32 = 0xC0000BFC
	PdhSQLAlterDetailFailed               uint32 = 0xC0000BFD
	PdhQueryPerfDataTimeout               uint32 = 0xC0000BFE
)
View Source 
const (
	PdhFmtRaw          = 0x00000010
	PdhFmtAnsi         = 0x00000020
	PdhFmtUnicode      = 0x00000040
	PdhFmtLong         = 0x00000100 // Return data as a long int.
	PdhFmtDouble       = 0x00000200 // Return data as a double precision floating point real.
	PdhFmtLarge        = 0x00000400 // Return data as a 64 bit integer.
	PdhFmtNoscale      = 0x00001000 // can be OR-ed: Do not apply the counter's default scaling factor.
	PdhFmt1000         = 0x00002000 // can be OR-ed: multiply the actual value by 1,000.
	PdhFmtNodata       = 0x00004000 // can be OR-ed: unknown what this is for, MSDN says nothing.
	PdhFmtNocap100     = 0x00008000 // can be OR-ed: do not cap values > 100.
	PerfDetailCostly   = 0x00010000
	PerfDetailStandard = 0x0000FFFF
)

Formatting options for GetFormattedCounterValue().

View Source 
const EmptyInstance = "------"

Variables

View Source 
var (
	InstanceAll   = []string{"*"}
	InstanceTotal = []string{"_Total"}
)
View Source 
var ErrNoData = NewPdhError(PdhNoData)
View Source 
var PDHErrors = map[uint32]string{
	PdhCstatusValidData:                   "PDH_CSTATUS_VALID_DATA",
	PdhCstatusNewData:                     "PDH_CSTATUS_NEW_DATA",
	PdhCstatusNoMachine:                   "PDH_CSTATUS_NO_MACHINE",
	PdhCstatusNoInstance:                  "PDH_CSTATUS_NO_INSTANCE",
	PdhMoreData:                           "PDH_MORE_DATA",
	PdhCstatusItemNotValidated:            "PDH_CSTATUS_ITEM_NOT_VALIDATED",
	PdhRetry:                              "PDH_RETRY",
	PdhNoData:                             "PDH_NO_DATA",
	PdhCalcNegativeDenominator:            "PDH_CALC_NEGATIVE_DENOMINATOR",
	PdhCalcNegativeTimebase:               "PDH_CALC_NEGATIVE_TIMEBASE",
	PdhCalcNegativeValue:                  "PDH_CALC_NEGATIVE_VALUE",
	PdhDialogCancelled:                    "PDH_DIALOG_CANCELLED",
	PdhEndOfLogFile:                       "PDH_END_OF_LOG_FILE",
	PdhAsyncQueryTimeout:                  "PDH_ASYNC_QUERY_TIMEOUT",
	PdhCannotSetDefaultRealtimeDatasource: "PDH_CANNOT_SET_DEFAULT_REALTIME_DATASOURCE",
	PdhCstatusNoObject:                    "PDH_CSTATUS_NO_OBJECT",
	PdhCstatusNoCounter:                   "PDH_CSTATUS_NO_COUNTER",
	PdhCstatusInvalidData:                 "PDH_CSTATUS_INVALID_DATA",
	PdhMemoryAllocationFailure:            "PDH_MEMORY_ALLOCATION_FAILURE",
	PdhInvalidHandle:                      "PDH_INVALID_HANDLE",
	PdhInvalidArgument:                    "PDH_INVALID_ARGUMENT",
	PdhFunctionNotFound:                   "PDH_FUNCTION_NOT_FOUND",
	PdhCstatusNoCountername:               "PDH_CSTATUS_NO_COUNTERNAME",
	PdhCstatusBadCountername:              "PDH_CSTATUS_BAD_COUNTERNAME",
	PdhInvalidBuffer:                      "PDH_INVALID_BUFFER",
	PdhInsufficientBuffer:                 "PDH_INSUFFICIENT_BUFFER",
	PdhCannotConnectMachine:               "PDH_CANNOT_CONNECT_MACHINE",
	PdhInvalidPath:                        "PDH_INVALID_PATH",
	PdhInvalidInstance:                    "PDH_INVALID_INSTANCE",
	PdhInvalidData:                        "PDH_INVALID_DATA",
	PdhNoDialogData:                       "PDH_NO_DIALOG_DATA",
	PdhCannotReadNameStrings:              "PDH_CANNOT_READ_NAME_STRINGS",
	PdhLogFileCreateError:                 "PDH_LOG_FILE_CREATE_ERROR",
	PdhLogFileOpenError:                   "PDH_LOG_FILE_OPEN_ERROR",
	PdhLogTypeNotFound:                    "PDH_LOG_TYPE_NOT_FOUND",
	PdhNoMoreData:                         "PDH_NO_MORE_DATA",
	PdhEntryNotInLogFile:                  "PDH_ENTRY_NOT_IN_LOG_FILE",
	PdhDataSourceIsLogFile:                "PDH_DATA_SOURCE_IS_LOG_FILE",
	PdhDataSourceIsRealTime:               "PDH_DATA_SOURCE_IS_REAL_TIME",
	PdhUnableReadLogHeader:                "PDH_UNABLE_READ_LOG_HEADER",
	PdhFileNotFound:                       "PDH_FILE_NOT_FOUND",
	PdhFileAlreadyExists:                  "PDH_FILE_ALREADY_EXISTS",
	PdhNotImplemented:                     "PDH_NOT_IMPLEMENTED",
	PdhStringNotFound:                     "PDH_STRING_NOT_FOUND",
	PdhUnableMapNameFiles:                 "PDH_UNABLE_MAP_NAME_FILES",
	PdhUnknownLogFormat:                   "PDH_UNKNOWN_LOG_FORMAT",
	PdhUnknownLogsvcCommand:               "PDH_UNKNOWN_LOGSVC_COMMAND",
	PdhLogsvcQueryNotFound:                "PDH_LOGSVC_QUERY_NOT_FOUND",
	PdhLogsvcNotOpened:                    "PDH_LOGSVC_NOT_OPENED",
	PdhWbemError:                          "PDH_WBEM_ERROR",
	PdhAccessDenied:                       "PDH_ACCESS_DENIED",
	PdhLogFileTooSmall:                    "PDH_LOG_FILE_TOO_SMALL",
	PdhInvalidDatasource:                  "PDH_INVALID_DATASOURCE",
	PdhInvalidSqldb:                       "PDH_INVALID_SQLDB",
	PdhNoCounters:                         "PDH_NO_COUNTERS",
	PdhSQLAllocFailed:                     "PDH_SQL_ALLOC_FAILED",
	PdhSQLAllocconFailed:                  "PDH_SQL_ALLOCCON_FAILED",
	PdhSQLExecDirectFailed:                "PDH_SQL_EXEC_DIRECT_FAILED",
	PdhSQLFetchFailed:                     "PDH_SQL_FETCH_FAILED",
	PdhSQLRowcountFailed:                  "PDH_SQL_ROWCOUNT_FAILED",
	PdhSQLMoreResultsFailed:               "PDH_SQL_MORE_RESULTS_FAILED",
	PdhSQLConnectFailed:                   "PDH_SQL_CONNECT_FAILED",
	PdhSQLBindFailed:                      "PDH_SQL_BIND_FAILED",
	PdhCannotConnectWmiServer:             "PDH_CANNOT_CONNECT_WMI_SERVER",
	PdhPlaCollectionAlreadyRunning:        "PDH_PLA_COLLECTION_ALREADY_RUNNING",
	PdhPlaErrorScheduleOverlap:            "PDH_PLA_ERROR_SCHEDULE_OVERLAP",
	PdhPlaCollectionNotFound:              "PDH_PLA_COLLECTION_NOT_FOUND",
	PdhPlaErrorScheduleElapsed:            "PDH_PLA_ERROR_SCHEDULE_ELAPSED",
	PdhPlaErrorNostart:                    "PDH_PLA_ERROR_NOSTART",
	PdhPlaErrorAlreadyExists:              "PDH_PLA_ERROR_ALREADY_EXISTS",
	PdhPlaErrorTypeMismatch:               "PDH_PLA_ERROR_TYPE_MISMATCH",
	PdhPlaErrorFilepath:                   "PDH_PLA_ERROR_FILEPATH",
	PdhPlaServiceError:                    "PDH_PLA_SERVICE_ERROR",
	PdhPlaValidationError:                 "PDH_PLA_VALIDATION_ERROR",
	PdhPlaValidationWarning:               "PDH_PLA_VALIDATION_WARNING",
	PdhPlaErrorNameTooLong:                "PDH_PLA_ERROR_NAME_TOO_LONG",
	PdhInvalidSQLLogFormat:                "PDH_INVALID_SQL_LOG_FORMAT",
	PdhCounterAlreadyInQuery:              "PDH_COUNTER_ALREADY_IN_QUERY",
	PdhBinaryLogCorrupt:                   "PDH_BINARY_LOG_CORRUPT",
	PdhLogSampleTooSmall:                  "PDH_LOG_SAMPLE_TOO_SMALL",
	PdhOsLaterVersion:                     "PDH_OS_LATER_VERSION",
	PdhOsEarlierVersion:                   "PDH_OS_EARLIER_VERSION",
	PdhIncorrectAppendTime:                "PDH_INCORRECT_APPEND_TIME",
	PdhUnmatchedAppendCounter:             "PDH_UNMATCHED_APPEND_COUNTER",
	PdhSQLAlterDetailFailed:               "PDH_SQL_ALTER_DETAIL_FAILED",
	PdhQueryPerfDataTimeout:               "PDH_QUERY_PERF_DATA_TIMEOUT",
}
View Source 
var SupportedCounterTypes = map[uint32]prometheus.ValueType{
	PERF_COUNTER_RAWCOUNT_HEX:       prometheus.GaugeValue,
	PERF_COUNTER_LARGE_RAWCOUNT_HEX: prometheus.GaugeValue,
	PERF_COUNTER_RAWCOUNT:           prometheus.GaugeValue,
	PERF_COUNTER_LARGE_RAWCOUNT:     prometheus.GaugeValue,
	PERF_COUNTER_DELTA:              prometheus.CounterValue,
	PERF_COUNTER_COUNTER:            prometheus.CounterValue,
	PERF_COUNTER_BULK_COUNT:         prometheus.CounterValue,
	PERF_RAW_FRACTION:               prometheus.GaugeValue,
	PERF_LARGE_RAW_FRACTION:         prometheus.GaugeValue,
	PERF_100NSEC_TIMER:              prometheus.CounterValue,
	PERF_PRECISION_100NS_TIMER:      prometheus.CounterValue,
	PERF_SAMPLE_FRACTION:            prometheus.GaugeValue,
	PERF_100NSEC_TIMER_INV:          prometheus.CounterValue,
	PERF_ELAPSED_TIME:               prometheus.GaugeValue,
	PERF_SAMPLE_BASE:                prometheus.GaugeValue,
	PERF_RAW_BASE:                   prometheus.GaugeValue,
	PERF_LARGE_RAW_BASE:             prometheus.GaugeValue,
}

Functions

func NewPdhError 

func NewPdhError(code uint32) error

func PdhAddCounter 

func PdhAddCounter(hQuery pdhQueryHandle, szFullCounterPath string, dwUserData uintptr, phCounter *pdhCounterHandle) uint32

PdhAddCounter adds the specified counter to the query. This is the internationalized version. Preferably, use the function PdhAddEnglishCounter instead. hQuery is the query handle, which has been fetched by PdhOpenQuery. szFullCounterPath is a full, internationalized counter path (this will differ per Windows language version). dwUserData is a 'user-defined value', which becomes part of the counter information. To retrieve this value later, call PdhGetCounterInfo() and access dwQueryUserData of the PdhCounterInfo structure.

Examples of szFullCounterPath (in an English version of Windows): 

\\Processor(_Total)\\% Idle Time
\\Processor(_Total)\\% Processor Time
\\LogicalDisk(C:)\% Free Space

To view all (internationalized...) counters on a system, there are three non-programmatic ways: perfmon utility, the typeperf command, and the v1 editor. perfmon.exe is perhaps the easiest way, because it's basically a full implementation of the pdh.dll API, except with a GUI and all that. The v1 setting also provides an interface to the available counters, and can be found at the following key: 

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\CurrentLanguage

This v1 key contains several values as follows: 

1
1847
2
System
4
Memory
6
% Processor Time
... many, many more

Somehow, these numeric values can be used as szFullCounterPath too: 

\2\6 will correspond to \\System\% Processor Time

The typeperf command may also be pretty easy. To find all performance counters, simply execute: 

typeperf -qx

func PdhAddEnglishCounter 

func PdhAddEnglishCounter(hQuery pdhQueryHandle, szFullCounterPath string, dwUserData uintptr, phCounter *pdhCounterHandle) uint32

PdhAddEnglishCounter adds the specified language-neutral counter to the query. See the PdhAddCounter function. This function only exists on Windows versions higher than Vista.

func PdhCloseQuery 

func PdhCloseQuery(hQuery pdhQueryHandle) uint32

PdhCloseQuery closes all counters contained in the specified query, closes all handles related to the query, and frees all memory associated with the query.

func PdhCollectQueryData 

func PdhCollectQueryData(hQuery pdhQueryHandle) uint32

PdhCollectQueryData collects the current raw data value for all counters in the specified query and updates the status code of each counter. With some counters, this function needs to be repeatedly called before the value of the counter can be extracted with PdhGetFormattedCounterValue(). For example, the following code requires at least two calls: 

var handle win.PDH_HQUERY
var counterHandle win.PDH_HCOUNTER
ret := win.PdhOpenQuery(0, 0, &handle)
ret = win.PdhAddEnglishCounter(handle, "\\Processor(_Total)\\% Idle Time", 0, &counterHandle)
var derp win.PDH_FMT_COUNTERVALUE_DOUBLE

ret = win.PdhCollectQueryData(handle)
fmt.Printf("Collect return code is %x\n", ret) // return code will be PDH_CSTATUS_INVALID_DATA
ret = win.PdhGetFormattedCounterValueDouble(counterHandle, 0, &derp)

ret = win.PdhCollectQueryData(handle)
fmt.Printf("Collect return code is %x\n", ret) // return code will be ERROR_SUCCESS
ret = win.PdhGetFormattedCounterValueDouble(counterHandle, 0, &derp)

The PdhCollectQueryData will return an error in the first call because it needs two values for displaying the correct data for the processor idle time. The second call will have a 0 return code.

func PdhCollectQueryDataWithTime 

func PdhCollectQueryDataWithTime(hQuery pdhQueryHandle) (uint32, time.Time)

PdhCollectQueryDataWithTime queries data from perfmon, retrieving the device/windows timestamp from the node it was collected on. Converts the filetime structure to a GO time class and returns the native time.

func PdhExpandWildCardPath 

func PdhExpandWildCardPath(szWildCardPath string, mszExpandedPathList *uint16, pcchPathListLength *uint32) uint32

PdhExpandWildCardPath examines the specified computer or log file and returns those counter paths that match the given counter path which contains wildcard characters. The general counter path format is as follows:

\\computer\object(parent/instance#index)\counter

The parent, instance, index, and counter components of the counter path may contain either a valid name or a wildcard character. The computer, parent, instance, and index components are not necessary for all counters.

The following is a list of the possible formats:

\\computer\object(parent/instance#index)\counter \\computer\object(parent/instance)\counter \\computer\object(instance#index)\counter \\computer\object(instance)\counter \\computer\object\counter \object(parent/instance#index)\counter \object(parent/instance)\counter \object(instance#index)\counter \object(instance)\counter \object\counter Use an asterisk (*) as the wildcard character, for example, \object(*)\counter.

If a wildcard character is specified in the parent name, all instances of the specified object that match the specified instance and counter fields will be returned. For example, \object(*/instance)\counter.

If a wildcard character is specified in the instance name, all instances of the specified object and parent object will be returned if all instance names corresponding to the specified index match the wildcard character. For example, \object(parent/*)\counter. If the object does not contain an instance, an error occurs.

If a wildcard character is specified in the counter name, all counters of the specified object are returned.

Partial counter path string matches (for example, "pro*") are supported.

func PdhFormatError 

func PdhFormatError(msgID uint32) string

func PdhGetCounterInfo 

func PdhGetCounterInfo(hCounter pdhCounterHandle, bRetrieveExplainText int, pdwBufferSize *uint32, lpBuffer *byte) uint32

PdhGetCounterInfo retrieves information about a counter, such as data size, counter type, path, and user-supplied data values hCounter [in] Handle of the counter from which you want to retrieve information. The PdhAddCounter function returns this handle.

bRetrieveExplainText [in] Determines whether explain text is retrieved. If you set this parameter to TRUE, the explain text for the counter is retrieved. If you set this parameter to FALSE, the field in the returned buffer is NULL.

pdwBufferSize [in, out] Size of the lpBuffer buffer, in bytes. If zero on input, the function returns PdhMoreData and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned size to reallocate the buffer.

lpBuffer [out] Caller-allocated buffer that receives a PdhCounterInfo structure. The structure is variable-length, because the string data is appended to the end of the fixed-format portion of the structure. This is done so that all data is returned in a single buffer allocated by the caller. Set to NULL if pdwBufferSize is zero.

func PdhGetCounterTimeBase 

func PdhGetCounterTimeBase(hCounter pdhCounterHandle, pTimeBase *int64) uint32

PdhGetCounterTimeBase returns the time base of the specified counter. hCounter Handle of the counter for whose current raw instance values you want to retrieve. The PdhAddCounter function returns this handle.

lpdwItemCount Time base that specifies the number of performance values a counter samples per second.

func PdhGetFormattedCounterArrayDouble 

func PdhGetFormattedCounterArrayDouble(hCounter pdhCounterHandle, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *byte) uint32

PdhGetFormattedCounterArrayDouble returns an array of formatted counter values. Use this function when you want to format the counter values of a counter that contains a wildcard character for the instance name. The itemBuffer must a slice of type PdhFmtCountervalueItemDouble. An example of how this function can be used: 

okPath := "\\Process(*)\\% Processor Time" // notice the wildcard * character

// omitted all necessary stuff ...

var bufSize uint32
var bufCount uint32
var size uint32 = uint32(unsafe.Sizeof(win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE{}))
var emptyBuf [1]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE // need at least 1 addressable null ptr.

for {
	// collect
	ret := win.PdhCollectQueryData(queryHandle)
	if ret == win.ERROR_SUCCESS {
		ret = win.PdhGetFormattedCounterArrayDouble(counterHandle, &bufSize, &bufCount, &emptyBuf[0]) // uses null ptr here according to MSDN.
		if ret == win.PDH_MORE_DATA {
			filledBuf := make([]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE, bufCount*size)
			ret = win.PdhGetFormattedCounterArrayDouble(counterHandle, &bufSize, &bufCount, &filledBuf[0])
			for i := 0; i < int(bufCount); i++ {
				c := filledBuf[i]
				var s string = win.UTF16PtrToString(c.SzName)
				fmt.Printf("Index %d -> %s, value %v\n", i, s, c.FmtValue.DoubleValue)
			}

			filledBuf = nil
			// Need to at least set bufSize to zero, because if not, the function will not
			// return PDH_MORE_DATA and will not set the bufSize.
			bufCount = 0
			bufSize = 0
		}

		time.Sleep(2000 * time.Millisecond)
	}
}

func PdhGetFormattedCounterValueDouble 

func PdhGetFormattedCounterValueDouble(hCounter pdhCounterHandle, lpdwType *uint32, pValue *PdhFmtCountervalueDouble) uint32

PdhGetFormattedCounterValueDouble formats the given hCounter using a 'double'. The result is set into the specialized union struct pValue. This function does not directly translate to a Windows counterpart due to union specialization tricks.

func PdhGetRawCounterArray 

func PdhGetRawCounterArray(hCounter pdhCounterHandle, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *byte) uint32

PdhGetRawCounterArray returns an array of raw values from the specified counter. Use this function when you want to retrieve the raw counter values of a counter that contains a wildcard character for the instance name. hCounter Handle of the counter for whose current raw instance values you want to retrieve. The PdhAddCounter function returns this handle.

lpdwBufferSize Size of the ItemBuffer buffer, in bytes. If zero on input, the function returns PdhMoreData and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned size to reallocate the buffer.

lpdwItemCount Number of raw counter values in the ItemBuffer buffer.

ItemBuffer Caller-allocated buffer that receives the array of PdhRawCounterItem structures; the structures contain the raw instance counter values. Set to NULL if lpdwBufferSize is zero.

func PdhGetRawCounterValue 

func PdhGetRawCounterValue(hCounter pdhCounterHandle, lpdwType *uint32, pValue *PdhRawCounter) uint32

PdhGetRawCounterValue returns the current raw value of the counter. If the specified counter instance does not exist, this function will return ErrorSuccess and the CStatus member of the PdhRawCounter structure will contain PdhCstatusNoInstance.

hCounter [in] Handle of the counter from which to retrieve the current raw value. The PdhAddCounter function returns this handle.

lpdwType [out] Receives the counter type. For a list of counter types, see the Counter Types section of the Windows Server 2003 Deployment Kit. This parameter is optional.

pValue [out] A PdhRawCounter structure that receives the counter value.

func PdhOpenQuery 

func PdhOpenQuery(szDataSource uintptr, dwUserData uintptr, phQuery *pdhQueryHandle) uint32

PdhOpenQuery creates a new query that is used to manage the collection of performance data. szDataSource is a null terminated string that specifies the name of the log file from which to retrieve the performance data. If 0, performance data is collected from a real-time data source. dwUserData is a user-defined value to associate with this query. To retrieve the user data later, call PdhGetCounterInfo and access dwQueryUserData of the PdhCounterInfo structure. phQuery is the handle to the query, and must be used in subsequent calls. This function returns a PDH_ constant error code, or ErrorSuccess if the call succeeded.

func PdhValidatePath 

func PdhValidatePath(path string) uint32

PdhValidatePath validates a path. Will return ErrorSuccess when ok, or PdhCstatusBadCountername when the path is erroneous.

Types

type Collector 

type Collector struct {
	// contains filtered or unexported fields
}

func NewCollector 

func NewCollector(object string, instances []string, counters []string) (*Collector, error)

func (*Collector) Close 

func (c *Collector) Close()

func (*Collector) Collect 

func (c *Collector) Collect() (map[string]map[string]CounterValues, error)

func (*Collector) Describe 

func (c *Collector) Describe() map[string]string

type Counter 

type Counter struct {
	Name      string
	Desc      string
	Instances map[string]pdhCounterHandle
	Type      uint32
	Frequency int64
}

type CounterValues 

type CounterValues struct {
	Type        prometheus.ValueType
	FirstValue  float64
	SecondValue float64
}

type Error 

type Error struct {
	ErrorCode uint32
	// contains filtered or unexported fields
}

Error represents error returned from Performance Counters API.

func (*Error) Error 

func (m *Error) Error() string

func (*Error) Is 

func (m *Error) Is(err error) bool

type HANDLE 

type HANDLE uintptr

type PdhCounterInfo 

type PdhCounterInfo struct {
	// Size of the structure, including the appended strings, in bytes.
	DwLength uint32
	// Counter type. For a list of counter types,
	// see the Counter Types section of the <a "href=http://go.microsoft.com/fwlink/p/?linkid=84422">Windows Server 2003 Deployment Kit</a>.
	// The counter type constants are defined in Winperf.h.
	DwType uint32
	// Counter version information. Not used.
	CVersion uint32
	// Counter status that indicates if the counter value is valid. For a list of possible values,
	// see <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa371894(v=vs.85).aspx">Checking PDH Interface Return Values</a>.
	CStatus uint32
	// Scale factor to use when computing the displayable value of the counter. The scale factor is a power of ten.
	// The valid range of this parameter is PDH_MIN_SCALE (–7) (the returned value is the actual value times 10–⁷) to
	// Pdh_MAX_SCALE (+7) (the returned value is the actual value times 10⁺⁷). A value of zero will set the scale to one, so that the actual value is returned.
	LScale int32
	// Default scale factor as suggested by the counter's provider.
	LDefaultScale int32
	// The value passed in the dwUserData parameter when calling PdhAddCounter.
	DwUserData *uint32
	// The value passed in the dwUserData parameter when calling PdhOpenQuery.
	DwQueryUserData *uint32
	// Null-terminated string that specifies the full counter path. The string follows this structure in memory.
	SzFullPath *uint16 // pointer to a string
	// Null-terminated string that contains the name of the computer specified in the counter path. Is NULL, if the path does not specify a computer.
	// The string follows this structure in memory.
	SzMachineName *uint16 // pointer to a string
	// Null-terminated string that contains the name of the performance object specified in the counter path. The string follows this structure in memory.
	SzObjectName *uint16 // pointer to a string
	// Null-terminated string that contains the name of the object instance specified in the counter path. Is NULL, if the path does not specify an instance.
	// The string follows this structure in memory.
	SzInstanceName *uint16 // pointer to a string
	// Null-terminated string that contains the name of the parent instance specified in the counter path.
	// Is NULL, if the path does not specify a parent instance. The string follows this structure in memory.
	SzParentInstance *uint16 // pointer to a string
	// Instance index specified in the counter path. Is 0, if the path does not specify an instance index.
	DwInstanceIndex uint32 // pointer to a string
	// Null-terminated string that contains the counter name. The string follows this structure in memory.
	SzCounterName *uint16 // pointer to a string
	// Help text that describes the counter. Is NULL if the source is a log file.
	SzExplainText *uint16 // pointer to a string
	// Start of the string data that is appended to the structure.
	DataBuffer [1]uint32 // pointer to an extra space
}

PdhCounterInfo structure contains information describing the properties of a counter. This information also includes the counter path.

type PdhFmtCounterValueItemLarge 

type PdhFmtCounterValueItemLarge struct {
	SzName   *uint16 // pointer to a string
	FmtValue PdhFmtCounterValueLarge
}

PdhFmtCounterValueItemLarge is a union specialization for 'large' values, used by PdhGetFormattedCounterArrayLarge().

type PdhFmtCounterValueItemLong 

type PdhFmtCounterValueItemLong struct {
	SzName   *uint16 // pointer to a string
	FmtValue PdhFmtCounterValueLong
}

PdhFmtCounterValueItemLong is a union specialization for long values, used by PdhGetFormattedCounterArrayLong().

type PdhFmtCounterValueLarge 

type PdhFmtCounterValueLarge struct {
	CStatus    uint32
	LargeValue int64
}

PdhFmtCounterValueLarge is a union specialization for 64-bit integer values.

type PdhFmtCounterValueLong 

type PdhFmtCounterValueLong struct {
	CStatus   uint32
	LongValue int32
	// contains filtered or unexported fields
}

PdhFmtCounterValueLong is a union specialization for long values.

type PdhFmtCountervalueDouble 

type PdhFmtCountervalueDouble struct {
	CStatus     uint32
	DoubleValue float64
}

PdhFmtCountervalueDouble is a union specialization for double values.

type PdhFmtCountervalueItemDouble 

type PdhFmtCountervalueItemDouble struct {
	SzName   *uint16
	FmtValue PdhFmtCountervalueDouble
}

PdhFmtCountervalueItemDouble is a union specialization for double values, used by PdhGetFormattedCounterArrayDouble.

type PdhRawCounter 

type PdhRawCounter struct {
	// Counter status that indicates if the counter value is valid. Check this member before using the data in a calculation or displaying its value.
	// For a list of possible values, see https://docs.microsoft.com/windows/desktop/PerfCtrs/checking-pdh-interface-return-values
	CStatus uint32
	// Local time for when the data was collected
	TimeStamp windows.Filetime
	// First raw counter value.
	FirstValue int64
	// Second raw counter value. Rate counters require two values in order to compute a displayable value.
	SecondValue int64
	// If the counter type contains the PERF_MULTI_COUNTER flag, this member contains the additional counter data used in the calculation.
	// For example, the PERF_100NSEC_MULTI_TIMER counter type contains the PERF_MULTI_COUNTER flag.
	MultiCount uint32
}

The PdhRawCounter structure returns the data as it was collected from the counter provider. No translation, formatting, or other interpretation is performed on the data.

type PdhRawCounterItem 

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
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.