Get-Counter

Questo cmdlet è disponibile solo nella piattaforma Windows.

Il cmdlet Get-Counter ottiene i dati dei contatori delle prestazioni direttamente dalla strumentazione del monitoraggio delle prestazioni nella famiglia di sistemi operativi Windows. Get-Counter ottiene i dati sulle prestazioni da un computer locale o da computer remoti.

È possibile usare i parametri Get-Counter per specificare uno o più computer, elencare i set di contatori delle prestazioni e le istanze che contengono, impostare gli intervalli di campionamento e specificare il numero massimo di campioni. Senza parametri, Get-Counter ottiene i dati del contatore delle prestazioni per un set di contatori di sistema.

Molti insiemi di contatori sono protetti da elenchi di controllo di accesso (ACL). Per visualizzare tutti i set di contatori, aprire PowerShell con l'opzione esegui come amministratore .

Questo cmdlet è stato reintrodotto in PowerShell 7.

In questo esempio viene visualizzato l'elenco di insiemi di contatori del computer locale.

Get-Counter -ListSet *

CounterSetName     : Processor
MachineName        : .
CounterSetType     : MultiInstance
Description        : The Processor performance object consists of counters that measure aspects ...
                     computer that performs arithmetic and logical computations, initiates ...
                     computer can have multiple processors.  The processor object represents ...
Paths              : {\Processor(*)\% Processor Time, \Processor(*)\% User Time, ...
PathsWithInstances : {\Processor(0)\% Processor Time, \Processor(1)\% Processor Time, ...
Counter            : {\Processor(*)\% Processor Time, \Processor(*)\% User Time, ...

Get-Counter usa il parametro ListSet con un asterisco (*) per ottenere l'elenco dei set di contatori. Il punto (.) nella colonna machineName rappresenta il computer locale.

In questo esempio vengono visualizzati i dati del contatore per tutti i processori nel computer locale. I dati vengono raccolti a intervalli di due secondi fino a quando non sono presenti tre campioni.

Get-Counter -Counter "\Processor(_Total)\% Processor Time" -SampleInterval 2 -MaxSamples 3

Timestamp                 CounterSamples
---------                 --------------
6/18/2019 14:39:56        \\Computer01\processor(_total)\% processor time :
                          20.7144271584086

6/18/2019 14:39:58        \\Computer01\processor(_total)\% processor time :
                          10.4391790575511

6/18/2019 14:40:01        \\Computer01\processor(_total)\% processor time :
                          37.5968799396998

Get-Counter usa il parametro Counter per specificare il percorso \Processor(_Total)\% Processor Timedel contatore. Il parametro SampleInterval imposta un intervallo di due secondi per controllare il contatore. MaxSamples determina che tre sono il numero massimo di volte per controllare il contatore.

Questo esempio raccoglie campioni continui per un contatore ogni secondo. Per arrestare il comando, premere CTRL+C. Per specificare un intervallo più lungo tra esempi, usare il parametro SampleInterval.

Get-Counter -Counter "\Processor(_Total)\% Processor Time" -Continuous

Timestamp                 CounterSamples
---------                 --------------
6/19/2019 15:35:03        \\Computer01\processor(_total)\% processor time :
                          43.8522842937022

6/19/2019 15:35:04        \\Computer01\processor(_total)\% processor time :
                          29.7896844697383

6/19/2019 15:35:05        \\Computer01\processor(_total)\% processor time :
                          29.4962645638135

6/19/2019 15:35:06        \\Computer01\processor(_total)\% processor time :
                          25.5901500127408

Get-Counter usa il parametro counter per specificare il contatore \Processor\% Processor Time. Il parametro continuo specifica di ottenere campioni ogni secondo finché il comando non viene arrestato con CTRL+C.

In questo esempio viene usata la pipeline per ottenere il set di elenchi di contatori e quindi ordinare l'elenco in ordine alfabetico.

Get-Counter -ListSet * |
  Sort-Object -Property CounterSetName |
    Format-Table CounterSetName, CounterSetType -AutoSize

CounterSetName                        CounterSetType
--------------                        --------------
.NET CLR Data                         SingleInstance
.NET Data Provider for SqlServer      SingleInstance
AppV Client Streamed Data Percentage  SingleInstance
Authorization Manager Applications    SingleInstance
BitLocker                             MultiInstance
Bluetooth Device                      SingleInstance
Cache                                 SingleInstance
Client Side Caching                   SingleInstance

Get-Counter usa il parametro ListSet con un asterisco (*) per ottenere un elenco completo di set di contatori. Gli oggetti CounterSet vengono inviati nella pipeline. Sort-Object utilizza il parametro Property per specificare che gli oggetti vengono ordinati in base CounterSetName. Gli oggetti vengono inviati alla pipeline a Format-Table. Il parametro AutoSize regola le larghezze delle colonne per ridurre al minimo il troncamento.

Il punto (.) nella colonna machineName rappresenta il computer locale.

In questo esempio, Start-Job esegue un comando Get-Counter come processo in background nel computer locale. Visualizza l'output del contatore delle prestazioni dall'attività, usando il cmdlet Receive-Job.

Start-Job -ScriptBlock {
    Get-Counter -Counter "\LogicalDisk(_Total)\% Free Space" -MaxSamples 1000
}

Id     Name  PSJobTypeName   State    HasMoreData  Location   Command
--     ----  -------------   -----    -----------  --------   -------
1      Job1  BackgroundJob   Running  True         localhost  Get-Counter -Counter

Start-Job usa il parametro ScriptBlock per eseguire un comando Get-Counter. Get-Counter usa il parametro Counter per specificare il percorso \LogicalDisk(_Total)\% Free Spacedel contatore. Il parametro MaxSamples consente di ottenere 1000 campioni del contatore.

In questo esempio viene usata una variabile per ottenere i dati del contatore delle prestazioni da due computer.

$DiskReads = "\LogicalDisk(C:)\Disk Reads/sec"
$DiskReads | Get-Counter -ComputerName Server01, Server02 -MaxSamples 10

Timestamp                 CounterSamples
---------                 --------------
6/21/2019 10:51:04        \\Server01\logicaldisk(C:)\disk reads/sec :
                          0

                          \\Server02\logicaldisk(C:)\disk reads/sec :
                          0.983050344269146

La variabile $DiskReads archivia il percorso del contatore \LogicalDisk(C:)\Disk Reads/sec. La variabile $DiskReads viene inviata alla pipeline fino a Get-Counter. Counter è il primo parametro di posizione e accetta il percorso archiviato in $DiskReads. ComputerName specifica i due computer e MaxSamples specifica di ottenere 10 campioni da ogni computer.

Questo esempio ottiene il valore di un contatore delle prestazioni su 50 computer remoti casuali nell'organizzazione. Il parametro ComputerName usa nomi computer casuali archiviati in una variabile. Per aggiornare i nomi dei computer nella variabile, ricreare la variabile.

Un'alternativa per i nomi dei server nel parametro ComputerName consiste nell'usare un file di testo. Per esempio:

-ComputerName (Get-Random (Get-Content -Path C:\Servers.txt) -Count 50)

Il percorso del contatore include un asterisco (*) nel nome dell'istanza per ottenere i dati per ognuno dei processori del computer remoto.

$Servers = Get-Random (Get-Content -Path C:\Servers.txt) -Count 50
$Counter = "\Processor(*)\% Processor Time"
Get-Counter -Counter $Counter -ComputerName $Servers

Timestamp                 CounterSamples
---------                 --------------
6/20/2019 12:20:35        \\Server01\processor(0)\% processor time :
                          6.52610319637854

                          \\Server01\processor(1)\% processor time :
                          3.41030663625782

                          \\Server01\processor(2)\% processor time :
                          9.64189975649925

                          \\Server01\processor(3)\% processor time :
                          1.85240835619747

                          \\Server01\processor(_total)\% processor time :
                          5.35768447160776

Il cmdlet Get-Random usa Get-Content per selezionare 50 nomi di computer casuali dal file Servers.txt. I nomi dei computer remoti vengono archiviati nella variabile $Servers. Il percorso del contatore \Processor(*)\% Processor Time viene archiviato nella variabile $Counter. Get-Counter utilizza il parametro Counter per definire i contatori nella variabile $Counter. Il parametro ComputerName specifica i nomi dei computer nella variabile $Servers.

In questo esempio viene utilizzata la proprietà Path di un insieme di contatori per trovare i nomi di percorso formattati per i contatori delle prestazioni.

La pipeline viene usata con il cmdlet Where-Object per trovare un sottoinsieme dei nomi dei percorsi. Per trovare un elenco completo dei percorsi dei set di contatori, rimuovere la parte della pipeline (|) e il comando Where-Object.

Il $_ è una variabile automatica per l'oggetto corrente nella pipeline. Per altre informazioni, vedere about_Automatic_Variables.

(Get-Counter -ListSet Memory).Paths | Where-Object { $_ -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
\Memory\Long-Term Average Standby Cache Lifetime (s)

Get-Counter usa il parametro ListSet per specificare il set di contatori memoria. Il comando è racchiuso tra parentesi in modo che la proprietà percorsi restituisca ogni percorso come stringa. Gli oggetti vengono inviati alla pipeline a Where-Object. Where-Object usa la variabile $_ per elaborare ogni oggetto e usa l'operatore -like per trovare corrispondenze per la stringa *Cache*. Gli asterischi (*) sono caratteri jolly per rappresentare qualsiasi carattere.

Questo esempio ottiene i nomi di percorso formattati che includono le istanze per i contatori delle prestazioni PhysicalDisk.

(Get-Counter -ListSet PhysicalDisk).PathsWithInstances

\PhysicalDisk(0 C:)\Current Disk Queue Length
\PhysicalDisk(_Total)\Current Disk Queue Length
\PhysicalDisk(0 C:)\% Disk Time
\PhysicalDisk(_Total)\% Disk Time
\PhysicalDisk(0 C:)\Avg. Disk Queue Length
\PhysicalDisk(_Total)\Avg. Disk Queue Length
\PhysicalDisk(0 C:)\% Disk Read Time
\PhysicalDisk(_Total)\% Disk Read Time

Get-Counter utilizza il parametro ListSet per specificare il set di contatori di dischi fisici. Il comando è racchiuso tra parentesi in modo che la proprietà PathsWithInstances restituisca ogni istanza del percorso come stringa.

In questo esempio viene restituito un singolo valore per ogni contatore delle prestazioni nella serie di contatori memoria del computer locale.

$MemCounters = (Get-Counter -ListSet Memory).Paths
Get-Counter -Counter $MemCounters

Timestamp                 CounterSamples
---------                 --------------
6/19/2019 12:05:00        \\Computer01\memory\page faults/sec :
                          868.772077545597

                          \\Computer01\memory\available bytes :
                          9031176192

                          \\Computer01\memory\committed bytes :
                          8242982912

                          \\Computer01\memory\commit limit :
                          19603333120

Get-Counter usa il parametro ListSet per specificare il set di contatori memoria. Il comando è racchiuso tra parentesi in modo che la proprietà percorsi restituisca ogni percorso come stringa. I percorsi vengono archiviati nella variabile $MemCounters. Get-Counter usa il parametro Contatore per specificare i percorsi dei contatori nella variabile $MemCounters.

I valori delle proprietà nell'oggetto PerformanceCounterSample rappresentano ogni esempio di dati. In questo esempio vengono usate le proprietà dell'oggetto CounterSamples per esaminare, selezionare, ordinare e raggruppare i dati.

$Counter = "\\Server01\Process(Idle)\% Processor Time"
$Data = Get-Counter $Counter
$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        : 6/19/2019 12:20:49
Timestamp100NSec : 128606207528320000
Status           : 0
DefaultScale     : 0
TimeBase         : 10000000

Il percorso del contatore viene archiviato nella variabile $Counter. Get-Counter ottiene un campione dei valori del contatore e archivia i risultati nella variabile $Data. La variabile $Data usa la proprietà CounterSamples per ottenere le proprietà dell'oggetto. L'oggetto viene inviato alla pipeline a Format-List. Il parametro Property usa un carattere jolly asterisco (*) per selezionare tutte le proprietà.

In questo esempio una variabile archivia ogni contatore delle prestazioni. La proprietà CounterSamples è una matrice in grado di visualizzare valori di contatori specifici.

Per visualizzare ogni esempio di contatore, usare $Counter.CounterSamples.

$Counter = Get-Counter -Counter "\Processor(*)\% Processor Time"
$Counter.CounterSamples[0]

Path                                         InstanceName        CookedValue
----                                         ------------        -----------
\\Computer01\processor(0)\% processor time   0              1.33997091699662

Get-Counter utilizza il parametro Counter per specificare il contatore \Processor(*)\% Processor Time. I valori vengono archiviati nella variabile $Counter. $Counter.CounterSamples[0] visualizza il valore della matrice per il primo valore del contatore.

In questo esempio viene trovata la quantità di tempo del processore usata da ogni processore nel computer locale. La proprietà counterSamples viene utilizzata per confrontare i dati del contatore con un valore specificato.

Per visualizzare ogni esempio di contatore, usare $Counter.CounterSamples.

$Counter = Get-Counter -Counter "\Processor(*)\% Processor Time"
$Counter.CounterSamples | Where-Object { $_.CookedValue -lt "20" }

Path                                         InstanceName        CookedValue
----                                         ------------        -----------
\\Computer01\processor(0)\% processor time   0              12.6398025240208
\\Computer01\processor(1)\% processor time   1              15.7598095767344

Get-Counter utilizza il parametro Counter per specificare il contatore \Processor(*)\% Processor Time. I valori vengono archiviati nella variabile $Counter. Gli oggetti archiviati in $Counter.CounterSamples vengono inviati nella pipeline. Where-Object usa un blocco di script per confrontare ogni valore di oggetti con un valore specificato di 20. Il $_.CookedValue è una variabile dell'oggetto corrente nella pipeline. Vengono visualizzati i contatori con un CookedValue minore di 20.

In questo esempio viene illustrato come ordinare i dati dei contatori delle prestazioni. Nell'esempio vengono trovati i processi nel computer che utilizzano la maggior parte del tempo del processore durante l'esempio.

$Procs = Get-Counter -Counter "\Process(*)\% Processor Time"
$Procs.CounterSamples | Sort-Object -Property CookedValue -Descending |
   Format-Table -Property Path, InstanceName, CookedValue -AutoSize

Path                                                         InstanceName             CookedValue
----                                                         ------------             -----------
\\Computer01\process(_total)\% processor time                _total              395.464129650573
\\Computer01\process(idle)\% processor time                  idle                389.356575524695
\\Computer01\process(mssense)\% processor time               mssense             3.05377706293879
\\Computer01\process(csrss#1)\% processor time               csrss               1.52688853146939
\\Computer01\process(microsoftedgecp#10)\% processor time    microsoftedgecp     1.52688853146939
\\Computer01\process(runtimebroker#5)\% processor time       runtimebroker                      0
\\Computer01\process(settingsynchost)\% processor time       settingsynchost                    0
\\Computer01\process(microsoftedgecp#16)\% processor time    microsoftedgecp                    0

Get-Counter utilizza il parametro Counter per specificare il contatore \Process(*)\% Processor Time per tutti i processi nel computer locale. Il risultato viene archiviato nella variabile $Procs. La variabile $Procs con la proprietà CounterSamples invia gli oggetti PerformanceCounterSample nella pipeline. Sort-Object usa il parametro Property per ordinare gli oggetti in base a CookedValue in ordine decrescente. Format-Table usa il parametro Proprietà per selezionare le colonne di output. Il parametro AutoSize regola le larghezze delle colonne per ridurre al minimo il troncamento.

String[]

Get-Counter accetta l'input della pipeline per i percorsi dei contatori e i nomi dei set di contatori.

CounterSet

Con il parametro ListSet, questo cmdlet restituisce gli oggetti CounterSet.

PerformanceCounterSampleSet

Per impostazione predefinita e con il parametro Counter, questo cmdlet restituisce oggetti PerformanceCounterSampleSet.

Se non vengono specificati parametri, Get-Counter ottiene un campione per ogni contatore delle prestazioni specificato. Usare i parametri MaxSamples e continuous per ottenere altri esempi.

Get-Counter usa un intervallo di un secondo tra i campioni. Usare il parametro SampleInterval per aumentare l'intervallo.

I valori MaxSamples e SampleInterval si applicano su tutti i contatori di ogni computer nel comando. Per impostare valori diversi per contatori diversi, immettere comandi Get-Counter separati.

In PowerShell 7, quando si usa il parametro ListSet, Get-Counter non è in grado di recuperare la proprietà description del set di contatori. Il Description è impostato su $null.