Get-Counter

Get-Counter [-Counter] <string[]> [-ComputerName <string[]>] [-Continuous] [-MaxSamples <Int64>] [-SampleInterval <int>] [<CommonParameters>]

Get-Counter -ListSet <string[]> [-ComputerName <string[]>] [<CommonParameters>]

C:\PS>get-counter -ListSet *

This command gets all of the counter sets on the local computer.

Because many of the counter sets are protected by access control lists (ACLs), to see all counter sets, open Windows PowerShell with the "Run as administrator" option before using the Get-Counter command.

C:\PS>get-counter -Counter "\Processor(_Total)\% Processor Time" -SampleInterval 2 -MaxSamples 3

This command gets the current "% Processor Time" combined values for all processors on the local computer. It collects data every 2 seconds until it has three values.

C:\PS>get-counter -listset * | sort-object  countersetname | format-table countersetname

This command gets an alphabetically sorted list of the names of all of the counter sets on the local computer.

C:\PS>(get-counter -listset memory).paths

C:\PS> (get-counter -listset memory).paths | where {$_ -like "*cache*"}

C:\PS> (get-counter -listset memory).paths

\Memory\Page Faults/sec
\Memory\Available Bytes
\Memory\Committed Bytes
\Memory\Commit Limit
\Memory\Write Copies/sec
\Memory\Transition Faults/sec
\Memory\Cache Faults/sec
\Memory\Demand Zero Faults/sec
\Memory\Pages/sec
\Memory\Pages Input/sec
...

C:\PS> (get-counter -listset memory).paths | where {$_ -like "*cache*"}

\Memory\Cache Faults/sec
\Memory\Cache Bytes
\Memory\Cache Bytes Peak
\Memory\System Cache Resident Bytes
\Memory\Standby Cache Reserve Bytes
\Memory\Standby Cache Normal Priority Bytes
\Memory\Standby Cache Core Bytes


Description
-----------
These commands use the Path property of a counter set to find the correctly formatted path names for the performance counters. You can use a command like this one to get the correct counter path names.

The first command gets the path names of the performance counters in the Memory counter set on the local computer.  

The second command gets the path names that include "cache".

C:\PS>$diskreads = "\LogicalDisk(C:)\Disk Reads/sec"

C:\PS> $diskreads | get-counter -computer Server01, Server02 -maxsamples 10

These commands get the Disk Reads/sec counter data from the Server01 and Server02 computers. The second command uses the MaxSamples parameter to limit the return to 10 samples.

C:\PS>(get-counter -list physicaldisk).pathswithinstances

This command gets the correctly formatted path names for the PhysicalDisk  performance counters, including the instance names.

C:\PS>C:\PS> $servers = get-random (get-content servers.txt) -count 50

C:\PS> $counter = "\Processor(*)\% DPC Time"

C:\PS> get-counter -Counter $counter -computername $servers

These commands get the value of the "% DPC Time" performance counter on 50 randomly select computers in the enterprise. 

The first command uses the Get-Content cmdlet to get the list of enterprise servers from the Servers.txt file. It uses the Get-Random cmdlet to select 50 server names randomly from the Servers.txt file contents. The results are saved in the $servers variable.

The second command saves the counter path to the "% DPC Time" cmdlet in the $Counter variable. The counter path includes a wildcard character in the instance name to get the data on all of the processors on each of the computers. 

The third command uses the Get-Counter cmdlet to get the counter values. It uses the Counter parameter to specify the counters and the ComputerName parameter to specify the computers saved in the $servers variable.

C:\PS>$memCounters = (get-counter -list memory).paths

C:\PS> get-counter -counter $memCounters

These commands get a single value for all of the performance counters in the memory counter set on the local computer.

The first command gets the counter paths and saves them in the $memCounters variable.

The second command uses the Get-Counter cmdlet to get the counter data for each counter. It uses the Counter parameter to specify the counters in $memCounters.

C:\PS>$counter = "\\SERVER01\Process(Idle)\% Processor Time" 

C:\PS> $data = get-counter $counter

C:\PS> $data.countersamples | format-list -property *

Path             : \\SERVER01\process(idle)\% processor time
InstanceName     : idle
CookedValue      : 198.467899571389
RawValue         : 14329160321003
SecondValue      : 128606459528326201
MultipleCount    : 1
CounterType      : Timer100Ns
Timestamp        : 7/15/2008 6:39:12 PM
Timestamp100NSec : 128606207528320000
Status           : 0
DefaultScale     : 0
TimeBase         : 10000000


Description
-----------
This example shows the property values in the PerformanceCounterSample object that represents each data sample.

The first command saves a counter path in the $counter variable. 

The second command uses the Get-Counter cmdlet to get one sample of the counter values. It saves the results in the $data variable.

The third command uses the Format-List cmdlet to display all the properties of the CounterSamples property of the sample set object as a list.

You can use the properties of the CounterSamples object to examine, select, sort,  and group the data.

C:\PS>$counters = "\LogicalDisk(_Total)\% Free Space"

C:\PS> start-job -scriptblock {get-counter -counter $counters -maxsamples 1000)

The command runs a Get-Counter command as background job. For more information, see Start-Job.

C:\PS>get-counter -computername (get-random servers.txt -count 50) -counter "\LogicalDisk(*)\% Free Space"

This command uses the Get-Counter and Get-Random cmdlets to find the percentage of free disk space on 50 computers selected randomly from the Servers.txt file.

C:\PS>$a = get-counter "\LogicalDisk(_Total)\% Free Space" -comp s1, s2

C:\PS> $a

C:\PS> $a.countersamples | format-table -auto

C:\PS> $a.countersamples[0] | format-table -property * 

C:\PS> $a.countersamples | where {$_.cookedvalue -lt 15}

C:\PS> $a

Counter Paths: \\s1\\logicaldisk(c:)\% free space, \\s1\\logicaldisk(d:)\% free space, \\s1\\logicaldisk(_total)\% free space, \\s2\\logicaldisk(c:)\% free space, \\s2\\logicaldisk(_total)\% free space

Timestamp     : 7/15/2008 5:09:08 PM
Cooked Values : "0.327058823529412", "17.8952248493278", "12.9994033060778", "75.0754805595626", "75.0754805595626"

C:\PS> $a.countersamples | format-table -auto

Path                                     InstanceName       CookedValue
----                                     ------------       -----------
\\s1\\logicaldisk(c:)\% free space       c:           0.327058823529412
\\s1\\logicaldisk(d:)\% free space       d:            17.8952248493278
\\s1\\logicaldisk(_total)\% free space   _total        12.9994033060778
\\s2\\logicaldisk(c:)\% free space       c:            75.0754805595626
\\s2\\logicaldisk(_total)\% free space   _total        75.0754805595626


C:\PS> ($a.countersamples)[0] | fl *


Path             : \\s1\\logicaldisk(c:)\% free space
InstanceName     : c:
CookedValue      : 0.327058823529412
RawValue         : 139
SecondValue      : 42500
MultipleCount    : 1
CounterType      : RawFraction
Timestamp        : 7/15/2008 5:09:08 PM
Timestamp100NSec : 128606153488500000
Status           : 0
DefaultScale     : 0
TimeBase         : 3312060


C:\PS> $a.countersamples | where {$_.cookedvalue -lt 15}

Path                                     InstanceName       CookedValue
----                                     ------------       -----------
\\s1\\logicaldisk(c:)\% free space       c:           0.327058823529412
\\s1\\logicaldisk(_total)\% free space   _total        12.9994033060778


Description
-----------
This example shows how to associate counter data with the computer on which it originated, and how to manipulate the data.

The first command uses the Get-Counter cmdlet to get the "LogicalDisk\% Free Space" counter value from two remote computers, S1 and S2. It saves the result in the $a variable.

The second command displays the results in the $a variable. All of the data is stored in the object, but it is not easy to see it in this form.

The third command displays in a table the value of the CounterSamples property of the PerformanceCounterSampleSet object that Get-Counter returns. (To see all of the properties and methods of the object, pipe it to the Get-Member cmdlet.) 

The CounterSamples property contains a PerformanceCounterSample object with its own properties and methods. The fourth command uses array notation to get the first counter sample and a pipeline operator to send the counter sample object to the Format-List cmdlet, which displays all of its properties and methods in a list. This display shows the richness of the data in each counter sample object.

The fourth command shows how to select data from the counter samples. It uses the Where-Object cmdlet to get only the counter samples with a CookedValue of less than 15.

C:\PS>$p = get-counter '\Process(*)\% Processor Time' 

C:\PS> $p.CounterSamples | sort-object -property CookedValue -Descending | format-table -auto

Path                                              InstanceName      CookedValue
----                                              ------------      -----------
\\server01\process(_total)\% processor time        _total        200.00641042078
\\server01\process(idle)\% processor time          idle          200.00641042078
\\server01\process(explorer#1)\% processor time    explorer                    0
\\server01\process(dwm#1)\% processor time         dwm                         0
\\server01\process(taskeng#1)\% processor time     taskeng                     0
\\server01\process(taskhost#1)\% processor time    taskhost                    0
\\server01\process(winlogon)\% processor time      winlogon                    0
\\server01\process(csrss)\% processor time         csrss                       0


Description
-----------
This example shows how to sort the performance counter data that you retrieve. The example finds the processes on the computer that are using the most processor time during the sampling.

The first command gets the "Process\% Processor Time" counter for all the processes on the computer. The command saves the results in the $p variable.

The second command gets the CounterSamples property of the sample set object in $p and it sorts the samples in descending order based on the cooked value of the sample. The command uses the Format-Table cmdlet and its AutoFormat parameter to position the columns in the table.

C:\PS>$ws = get-counter "\Process(*)\Working Set - Private"

C:\PS> $ws.countersamples | sort-object -property cookedvalue -descending | format-table -property InstanceName, CookedValue -auto

InstanceName  CookedValue
------------  -----------
_total          162983936
svchost          40370176
powershell       15110144
explorer         14135296
svchost          10928128
svchost           9027584
...


Description
-----------
These commands find the processes on the computer with the largest working sets. They list the processes in descending order based on their working set size. 

The first command gets one sample of the "Process\Working Set - Private" counter for each process. The command saves the counter data in the $ws variable.

The second command uses a pipeline operator (|) to send the data in the CounterSamples property of the $ws variable to the Sort-Object cmdlet, where the process data is sorted in descending order by the value of the CookedValue property. Another pipeline sends the sorted data to the Format-Table cmdlet, where the data is formatted as a table with InstanceName and CookedValue columns.

C:\PS>get-counter -counter "\processor(_total)\% processor time" -continuous

This command gets a series of samples of the Processor\% Processor Time counter at the default one second interval. To stop the command, press CTRL + C.