# pdh

**Repository Path**: general252/pdh

## Basic Information

- **Project Name**: pdh
- **Description**: Windows 下使用PDH 获取CPU 使用率
- **Primary Language**: Go
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-09-21
- **Last Updated**: 2023-10-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README



##### windows性能监视

1. 进程监控 wmi.ProcessMonitor (wmi Win32_ProcessStartTrace)
2. 获取进程列表、内存、处理器、磁盘、系统信息(wmi)
3. 实时获取 
   1. CPU使用率
   2. 内存
   3. 网络速率
   4. 进程内存、进程CPU使用率、进程IO、进程网络连接
   5. 磁盘速率
   6. 抓包 
   7. ...

> 抓包需要借助第三方库
> 在使用 gopacket 包时，首先要确保在 windows 平台下安装了 npcap 或 winpcap，或者是在 linux 平台下安装了 libpcap 库。 
> npcap 下载地址：https://nmap.org/npcap/  
> libpcap 下载地址:https://www.tcpdump.org/  


##### query
```
import (
	"log"
	"time"

    "gitee.com/general252/pdh"
	"gitee.com/general252/pdh/core"
)

func main() {
    query := pdh.NewQuery()
	if err := query.Open(); err != nil {
		log.Println(err)
		return
	}

	defer query.Close()

	if objects, err := query.EnumObject(); err != nil {
		log.Println(err)
		return
	} else {
		for idx, object := range objects {
			log.Printf("%v %v", idx, object)
		}
	}

	if instances, err := query.EnumObjectItems("Processor Information"); err != nil {
		log.Println(err)
		return
	} else {
		for idx, instance := range instances {
			log.Printf("%v %v", idx, instance)
		}
	}

	var (
		err        error
		cpuCounter core.PDH_HCOUNTER
		memCounter core.PDH_HCOUNTER
	)

	if cpuCounter, err = query.AddCounter("\\Processor Information(_Total)\\% Processor Utility"); err != nil {
		log.Println(err)
		return
	}
	if memCounter, err = query.AddCounter("\\Memory\\Available MBytes"); err != nil {
		log.Println(err)
		return
	}

	_ = query.CollectData()
	for {
		time.Sleep(time.Second)
		_ = query.CollectData()

		cpuValue, _ := query.GetFormattedCounterValueDouble(cpuCounter)
		memValue, _ := query.GetFormattedCounterValueDouble(memCounter)

		log.Printf("%4.2v%% %vMB", cpuValue, memValue)
	}
}
```


##### performance
```
import (
	"log"
	"time"

    "gitee.com/general252/pdh"
	"gitee.com/general252/pdh/core"
)

func main() {
   const appName = "processor_demo"

	var names []*pdh.CounterName
	if true {
		names = pdh.NewCounterNameBuilder().
			WithCPU().
			WithProcessCPU(appName).
			WithProcessMemory(appName).
			WithProcessHandleCount(appName).
			WithProcessIOWriteBytesPerSec(appName).
			WithProcessIOReadBytesPerSec(appName).
			Build()
	}

	performance := pdh.NewPerformance()
	performance.AddCounter(names...)

	err := performance.Open(
		func(data []*pdh.ObjectCounterValue) {
			log.Println()
			for _, item := range data {
				log.Printf("%30v %20v %-30v [%-10v] [%30v]",
					item.LastTime.Format(time.RFC3339),
					item.ValueString(),
					item.Type, item.Param, item.Field)
			}
		},
		func(ins *pdh.Performance) {
			builder := pdh.NewCounterNameBuilder()

			if true {
				// 网卡
				if items, err := ins.GetQuery().EnumObjectItems(string(pdh.CounterTypeNetworkInterface)); err != nil {
					log.Println(err)
				} else {
					for _, item := range items {
						if item == pdh.Total {
							continue
						}
						builder.WithNetworkInterfaceBytesReceivedPerSec(item)
						builder.WithNetworkInterfaceBytesSentPerSec(item)
						builder.WithNetworkInterfaceCurrentBandwidth(item)
					}
				}
			}

			if true {
				// 硬盘
				if items, err := ins.GetQuery().EnumObjectItems(string(pdh.CounterTypePhysicalDisk)); err != nil {
					log.Println(err)
				} else {
					for _, item := range items {
						if item == pdh.Total {
							continue
						}
						builder.WithPhysicalDiskDiskTime(item)
						builder.WithPhysicalDiskAvgDiskBytesPerRead(item)
						builder.WithPhysicalDiskAvgDiskBytesPerWrite(item)
						builder.WithPhysicalDiskAvgDiskSecPerTransfer(item)
						builder.WithPhysicalDiskDiskTransfersPerSec(item)
					}
				}
			}

			ins.AddCounter(builder.Build()...)
		})
	if err != nil {
		log.Println(err)
		return
	}

	defer performance.Close()

	pdh.WaitForAppQuitSignal(true, func(sign os.Signal) {
	})
}
```