Get-WinEvent

Riferimento

Modulo:: Microsoft.PowerShell.Diagnostics

Ottiene gli eventi dai registri eventi e dai file di registro di traccia eventi nei computer locali e remoti.

Sintassi

Get-WinEvent
   [[-LogName] <String[]>]
   [-MaxEvents <Int64>]
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [-FilterXPath <String>]
   [-Force]
   [-Oldest]
   [<CommonParameters>]

Get-WinEvent
   [-ListLog] <String[]>
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [-Force]
   [<CommonParameters>]

Get-WinEvent
   [-ListProvider] <String[]>
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [<CommonParameters>]

Get-WinEvent
   [-ProviderName] <String[]>
   [-MaxEvents <Int64>]
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [-FilterXPath <String>]
   [-Force]
   [-Oldest]
   [<CommonParameters>]

Get-WinEvent
   [-Path] <String[]>
   [-MaxEvents <Int64>]
   [-Credential <PSCredential>]
   [-FilterXPath <String>]
   [-Oldest]
   [<CommonParameters>]

Get-WinEvent
   [-MaxEvents <Int64>]
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [-FilterHashtable] <Hashtable[]>
   [-Force]
   [-Oldest]
   [<CommonParameters>]

Get-WinEvent
   [-MaxEvents <Int64>]
   [-ComputerName <String>]
   [-Credential <PSCredential>]
   [-FilterXml] <XmlDocument>
   [-Oldest]
   [<CommonParameters>]

Descrizione

Questo cmdlet è disponibile solo nella piattaforma Windows.

Il Get-WinEvent cmdlet ottiene gli eventi dai registri eventi, inclusi i log classici, ad esempio i log di sistema e delle applicazioni . Il cmdlet ottiene i dati dai registri eventi generati dalla tecnologia Registro eventi di Windows introdotta in Windows Vista ed eventi nei file di log generati da Event Tracing for Windows (ETW). Per impostazione predefinita, Get-WinEvent restituisce le informazioni sugli eventi nell'ordine più recente a meno recente.

Get-WinEvent elenca i registri eventi e i provider di log eventi. Per interrompere il comando, premere CTRL+C. È possibile ottenere gli eventi dal registri selezionati o dai registri generati dai provider di eventi selezionati. Ed è anche possibile combinare gli eventi da più origini in un unico comando. Get-WinEvent consente di filtrare gli eventi usando query XPath, query XML strutturate e query di tabella hash.

Se PowerShell non è in esecuzione come amministratore, è possibile che vengano visualizzati messaggi di errore che non è possibile recuperare informazioni su un log.

Esempio

Esempio 1: Ottenere tutti i log da un computer locale

Questo comando ottiene tutti i registri eventi nel computer locale. I log sono elencati nell'ordine in cui Get-WinEvent vengono visualizzati. I log classici vengono recuperati per primi, seguiti dai nuovi registri eventi di Windows. È possibile che il recordCount di un log sia null, ovvero vuoto o zero.

Get-WinEvent -ListLog *

LogMode   MaximumSizeInBytes RecordCount LogName
-------   ------------------ ----------- -------
Circular            15532032       14500 Application
Circular             1052672         117 Azure Information Protection
Circular             1052672        3015 CxAudioSvcLog
Circular            20971520             ForwardedEvents
Circular            20971520           0 HardwareEvents

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListLog usa il carattere jolly asterisco (*) per visualizzare informazioni su ogni log.

Esempio 2: Ottenere il log di installazione classico

Questo comando ottiene un oggetto EventLogConfiguration che rappresenta il log di installazione classico. L'oggetto include informazioni sul log, ad esempio dimensioni del file, provider, percorso file e se il log è abilitato.

Get-WinEvent -ListLog Setup | Format-List -Property *

FileSize                       : 69632
IsLogFull                      : False
LastAccessTime                 : 3/13/2019 09:41:46
LastWriteTime                  : 3/13/2019 09:41:46
OldestRecordNumber             : 1
RecordCount                    : 23
LogName                        : Setup
LogType                        : Operational
LogIsolation                   : Application
IsEnabled                      : True
IsClassicLog                   : False
SecurityDescriptor             : O:BAG:SYD: ...
LogFilePath                    : %SystemRoot%\System32\Winevt\Logs\Setup.evtx
MaximumSizeInBytes             : 1052672
LogMode                        : Circular
OwningProviderName             : Microsoft-Windows-Eventlog
ProviderNames                  : {Microsoft-Windows-WUSA, Microsoft-Windows-ActionQueue...
ProviderLevel                  :
ProviderKeywords               :
ProviderBufferSize             : 64
ProviderMinimumNumberOfBuffers : 0
ProviderMaximumNumberOfBuffers : 64
ProviderLatency                : 1000
ProviderControlGuid            :

Il Get-WinEvent cmdlet usa il parametro ListLog per specificare il log di installazione . L'oggetto viene inviato alla pipeline al Format-List cmdlet . Format-List utilizza il parametro Property con il carattere jolly asterisco (*) per visualizzare ogni proprietà.

Esempio 3: Configurare il log di sicurezza classico

Questo comando ottiene un oggetto EventLogConfiguration che rappresenta il log di sicurezza classico. L'oggetto viene quindi usato per configurare le impostazioni per il log, ad esempio dimensioni massime del file, percorso del file e se il log è abilitato.

$log = Get-WinEvent -ListLog Security
$log.MaximumSizeInBytes = 1gb
try{
   $log.SaveChanges()
   Get-WinEvent -ListLog Security | Format-List -Property *
}catch [System.UnauthorizedAccessException]{
   $ErrMsg  = 'You do not have permission to configure this log!'
   $ErrMsg += ' Try running this script with administrator privileges. '
   $ErrMsg += $_.Exception.Message
   Write-Error $ErrMsg
}

FileSize                       : 69632
IsLogFull                      : False
LastAccessTime                 : 3/13/2019 09:41:46
LastWriteTime                  : 3/13/2019 09:41:46
OldestRecordNumber             : 1
RecordCount                    : 23
LogName                        : Security
LogType                        : Administrative
LogIsolation                   : Custom
IsEnabled                      : True
IsClassicLog                   : True
SecurityDescriptor             : O:BAG:SYD: ...
LogFilePath                    : %SystemRoot%\System32\Winevt\Logs\Security.evtx
MaximumSizeInBytes             : 1073741824
LogMode                        : Circular
OwningProviderName             :
ProviderNames                  : {Microsoft-Windows-WUSA, Microsoft-Windows-ActionQueue...
ProviderLevel                  :
ProviderKeywords               :
ProviderBufferSize             : 64
ProviderMinimumNumberOfBuffers : 0
ProviderMaximumNumberOfBuffers : 64
ProviderLatency                : 1000
ProviderControlGuid            :

Il Get-WinEvent cmdlet usa il parametro ListLog per specificare il log di sicurezza . L'oggetto viene salvato in una variabile. La proprietà MaximumSizeInBytes è impostata su 1 gigabyte nell'oggetto . Il metodo SaveChanges viene chiamato per eseguire il push della modifica nel sistema all'interno di un blocco try per gestire le violazioni di accesso. Il Get-WinEvent cmdlet viene chiamato nuovamente nel log di sicurezza e inviato tramite pipe al Format-List cmdlet per verificare che la proprietà MaximumSizeInBytes sia stata salvata nel computer.

Esempio 4: Ottenere i registri eventi da un server

Questo comando ottiene solo i registri eventi nel computer locale che contengono eventi. È possibile che l'oggetto RecordCount di un log sia null o zero. Nell'esempio viene utilizzata la $_ variabile . Per altre informazioni, vedere about_Automatic_Variables.

Get-WinEvent -ListLog * -ComputerName localhost | Where-Object { $_.RecordCount }

LogMode   MaximumSizeInBytes RecordCount LogName
-------   ------------------ ----------- -------
Circular            15532032       14546 Application
Circular             1052672         117 Azure Information Protection
Circular             1052672        2990 CxAudioSvcLog
Circular             1052672           9 MSFTVPN Setup
Circular             1052672         282 OAlerts

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListLog usa il carattere jolly asterisco (*) per visualizzare informazioni su ogni log. Il parametro ComputerName specifica di ottenere i log dal computer locale localhost. Gli oggetti vengono inviati alla pipeline al Where-Object cmdlet . Where-Object usa $_.RecordCount per restituire solo i log che contengono dati. $_ è una variabile che rappresenta l'oggetto corrente nella pipeline. RecordCount è una proprietà dell'oggetto con un valore non Null.

Esempio 5: Ottenere i log eventi da più server

Questo esempio ottiene oggetti che rappresentano i registri eventi dell'applicazione in tre computer: Server01, Server02 e Server03. La parola chiave ForEach viene utilizzata perché il parametro ComputerName accetta un solo valore. Per altre informazioni, vedere about_Foreach.

$S = 'Server01', 'Server02', 'Server03'
ForEach ($Server in $S) {
  Get-WinEvent -ListLog Application -ComputerName $Server |
    Select-Object LogMode, MaximumSizeInBytes, RecordCount, LogName,
      @{name='ComputerName'; expression={$Server}} |
    Format-Table -AutoSize
}

LogMode MaximumSizeInBytes RecordCount LogName     ComputerName
 ------- ------------------ ----------- -------     ------------
Circular           15532032       14577 Application Server01
Circular           15532032        9689 Application Server02
Circular           15532032        5309 Application Server03

La variabile $S archivia i nomi tre server: Server01, Server02 e Server03. L'istruzione ForEach usa un ciclo per elaborare ogni server, ($Server in $S). Il blocco di script nelle parentesi graffe ({ }) esegue il Get-WinEvent comando . Il parametro ListLog specifica il log applicazioni . Il parametro ComputerName usa la variabile $Server per ottenere informazioni di log da ogni server.

Gli oggetti vengono inviati alla pipeline al Select-Object cmdlet . Select-Objectottiene le proprietà LogMode, MaximumSizeInBytes, RecordCount, LogName e usa un'espressione calcolata per visualizzare ComputerName usando la $Server variabile . Gli oggetti vengono inviati alla pipeline al Format-Table cmdlet per visualizzare l'output nella console di PowerShell. Il parametro AutoSize formatta l'output in modo che si adatti allo schermo.

Esempio 6: Ottenere i provider e i nomi dei log eventi

Questo comando ottiene i provider del registro eventi e i log in cui scrivono.

Get-WinEvent -ListProvider *

Name     : .NET Runtime
LogLinks : {Application}
Opcodes  : {}
Tasks    : {}

Name     : .NET Runtime Optimization Service
LogLinks : {Application}
Opcodes  : {}
Tasks    : {}

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListProvider usa il carattere jolly asterisco (*) per visualizzare informazioni su ogni provider. Nell'output il nome è il provider e LogLinks è il log in cui scrive il provider.

Esempio 7: Ottenere tutti i provider di log eventi che scrivono in un log specifico

Questo comando ottiene tutti i provider che scrivono nel registro applicazioni .

(Get-WinEvent -ListLog Application).ProviderNames

.NET Runtime
.NET Runtime Optimization Service
Application
Application Error
Application Hang
Application Management

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListLog usa Application per ottenere oggetti per tale log. ProviderNames è una proprietà dell'oggetto e visualizza i provider che scrivono nel registro applicazioni .

Esempio 8: Ottenere i nomi del provider del registro eventi che contengono una stringa specifica

Questo comando ottiene i provider del registro eventi con nomi che includono una stringa specifica nel nome del provider.

Get-WinEvent -ListProvider *Policy*

Name     : Group Policy Applications
LogLinks : {Application}
Opcodes  : {}
Tasks    : {}

Name     : Group Policy Client
LogLinks : {Application}
Opcodes  : {}
Tasks    : {}

Name     : Group Policy Data Sources
LogLinks : {Application}
Opcodes  : {}
Tasks    : {}

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListProvider usa il carattere jolly asterisco (*) per trovare Criteri in qualsiasi punto all'interno del nome del provider.

Esempio 9: Ottenere gli ID evento generati dal provider di eventi

Questo comando elenca gli ID evento generati dal provider di eventi Microsoft-Windows-GroupPolicy insieme alla descrizione dell'evento.

(Get-WinEvent -ListProvider Microsoft-Windows-GroupPolicy).Events | Format-Table Id, Description

Id  Description
  --  -----------
1500  The Group Policy settings for the computer were processed successfully...
1501  The Group Policy settings for the user were processed successfully...
4115  Group Policy Service started.
4116  Started the Group Policy service initialization phase.
4117  Group Policy Session started.

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro ListProvider specifica il provider Microsoft-Windows-GroupPolicy. L'espressione viene racchiusa tra parentesi e usa la proprietà Events per ottenere oggetti . Gli oggetti vengono inviati alla pipeline al Format-Table cmdlet . Format-Tablevisualizza l'ID e la descrizione degli oggetti evento.

Esempio 10: Ottenere informazioni di log dalle proprietà dell'oggetto evento

In questo esempio viene illustrato come ottenere informazioni sul contenuto di un log usando le proprietà dell'oggetto evento. Gli oggetti evento vengono archiviati in una variabile e quindi raggruppati e conteggiati in base all'ID evento e al livello.

$Event = Get-WinEvent -LogName 'Windows PowerShell'
$Event.Count
$Event | Group-Object -Property Id -NoElement | Sort-Object -Property Count -Descending
$Event | Group-Object -Property LevelDisplayName -NoElement

195

Count  Name
-----  ----
  147  600
   22  400
   21  601
    3  403
    2  103

Count  Name
-----  ----
    2  Warning
  193  Information

Il Get-WinEvent cmdlet usa il parametro LogName per specificare il registro eventi di Windows PowerShell . Gli oggetti evento vengono archiviati nella $Event variabile . La proprietà Count di $Eventmostra il numero totale di eventi registrati.

La $Event variabile viene inviata alla pipeline al Group-Object cmdlet . Group-Object utilizza il parametro Property per specificare la proprietà Id e conta gli oggetti in base al valore id evento. Il parametro NoElement rimuove altre proprietà dall'output degli oggetti. Gli oggetti raggruppati vengono inviati alla pipeline al Sort-Object cmdlet . Sort-Object utilizza il parametro Property per ordinare gli oggetti in base a Count. Il parametro Descending visualizza l'output in base al conteggio, dal più alto al più basso. Nell'output la colonna Count contiene il numero totale di ogni evento. La colonna Name contiene i numeri di ID evento raggruppati.

La $Event variabile viene inviata alla pipeline al Group-Object cmdlet . Group-Object utilizza il parametro Property per specificare la proprietà LevelDisplayName e conta gli oggetti per LevelDisplayName. Gli oggetti sono raggruppati in base ai livelli, ad esempio Avviso e Informazioni. Il parametro NoElement rimuove altre proprietà dall'output. Nell'output la colonna Count contiene il numero totale di ogni evento. La colonna Name contiene il LevelDisplayName raggruppato.

Esempio 11: Ottenere eventi di errore con una stringa specificata nel nome

In questo esempio viene usata una stringa delimitata da virgole di nomi di log. L'output viene raggruppato in base al livello, ad esempio l'errore o l'avviso e il nome del log.

Get-WinEvent -LogName *PowerShell*, Microsoft-Windows-Kernel-WHEA* |
  Group-Object -Property LevelDisplayName, LogName -NoElement |
    Format-Table -AutoSize

Count  Name
-----  ----
    1  Error, PowerShellCore/Operational
   26  Information, Microsoft-Windows-Kernel-WHEA/Operational
  488  Information, Microsoft-Windows-PowerShell/Operational
   77  Information, PowerShellCore/Operational
 9835  Information, Windows PowerShell
   19  Verbose, PowerShellCore/Operational
  444  Warning, Microsoft-Windows-PowerShell/Operational
  512  Warning, PowerShellCore/Operational

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro LogName usa una stringa delimitata da virgole con il carattere jolly asterisco (*) per specificare i nomi di log. Gli oggetti vengono inviati alla pipeline al Group-Object cmdlet . Group-Object utilizza il parametro Property per raggruppare gli oggetti in base a LevelDisplayName e LogName. Il parametro NoElement rimuove altre proprietà dall'output. Gli oggetti raggruppati vengono inviati alla pipeline al Format-Table cmdlet . Format-Table usa il parametro AutoSize per formattare le colonne. La colonna Count contiene il numero totale di ogni evento. La colonna Name contiene il LevelDisplayName raggruppato e LogName.

Esempio 12: Ottenere eventi da un registro eventi archiviato

Get-WinEvent può ottenere informazioni sugli eventi dai file di log salvati. Questo esempio usa un log di PowerShell archiviato archiviato nel computer locale.

Get-WinEvent -Path 'C:\Test\Windows PowerShell.evtx'

ProviderName: PowerShell

TimeCreated              Id LevelDisplayName  Message
-----------              -- ----------------  -------
3/15/2019 13:54:13      403 Information       Engine state is changed from Available to Stopped...
3/15/2019 13:54:13      400 Information       Engine state is changed from None to Available...
3/15/2019 13:54:13      600 Information       Provider "Variable" is Started...
3/15/2019 13:54:13      600 Information       Provider "Function" is Started...
3/15/2019 13:54:13      600 Information       Provider "FileSystem" is Started...

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro Path specifica la directory e il nome file.

Esempio 13: Ottenere un numero specifico di eventi da un registro eventi archiviato

Questi comandi ottengono un numero specifico di eventi da un registro eventi archiviato. Get-WinEvent contiene parametri che possono ottenere un numero massimo di eventi o gli eventi meno recenti. Questo esempio usa un log di PowerShell archiviato archiviato in C:\Test\PowerShellCore Operational.evtx.

Get-WinEvent -Path 'C:\Test\PowerShellCore Operational.evtx' -MaxEvents 100

ProviderName: PowerShellCore

TimeCreated                 Id   LevelDisplayName  Message
-----------                 --   ----------------  -------
3/15/2019 09:54:54        4104   Warning           Creating Scriptblock text (1 of 1):...
3/15/2019 09:37:13       40962   Information       PowerShell console is ready for user input
3/15/2019 07:56:24        4104   Warning           Creating Scriptblock text (1 of 1):...
...
3/7/2019 10:53:22        40961   Information       PowerShell console is starting up
3/7/2019 10:53:22         8197   Verbose           Runspace state changed to Opening
3/7/2019 10:53:22         8195   Verbose           Opening RunspacePool

Il Get-WinEvent cmdlet ottiene le informazioni di log dal computer. Il parametro Path specifica la directory e il nome file. Il parametro MaxEvents specifica che vengono visualizzati 100 record, dal più recente al meno recente.

Esempio 14: Traccia eventi per Windows

Event Tracing for Windows (ETW) scrive gli eventi nel log man mano che si verificano eventi. Gli eventi vengono archiviati nell'ordine dei meno recenti a quello più recente. Un file ETW archiviato viene salvato come .etl traceLog.etl. Gli eventi vengono elencati nell'ordine in cui vengono scritti nel log, quindi è necessario il parametro Meno recente .

Get-WinEvent -Path 'C:\Tracing\TraceLog.etl' -Oldest |
  Sort-Object -Property TimeCreated -Descending |
    Select-Object -First 100

Il Get-WinEvent cmdlet ottiene le informazioni di log dal file archiviato. Il parametro Path specifica la directory e il nome file. Il parametro Meno recente viene usato per restituire gli eventi nell'ordine in cui vengono scritti, meno recenti. Gli oggetti vengono inviati verso il basso nella pipeline al Sort-Object cmdlet Sort-Object ordinano gli oggetti in ordine decrescente in base al valore della proprietà TimeCreated . Gli oggetti vengono inviati alla pipeline al Select-Object cmdlet che visualizza i 100 eventi più recenti.

Esempio 15: Ottenere eventi da un log di traccia eventi

Questo esempio illustra come ottenere gli eventi da un file di log di traccia eventi (.etl) e da un file di log di Windows PowerShell archiviato (.evtx). È possibile combinare più tipi di file in un unico comando. Poiché i file contengono lo stesso tipo di oggetto .NET Framework , EventLogRecord, è possibile filtrarli con le stesse proprietà. Il comando richiede il parametro Meno recente perché legge da un .etl file, ma il parametro Meno recente si applica a ogni file.

Get-WinEvent -Path 'C:\Tracing\TraceLog.etl', 'C:\Test\Windows PowerShell.evtx' -Oldest |
  Where-Object { $_.Id -eq '403' }

Il Get-WinEvent cmdlet ottiene le informazioni di log dai file archiviati. Il parametro Path usa un elenco delimitato da virgole per specificare ogni directory di file e nome file. Il parametro Meno recente viene usato per restituire gli eventi nell'ordine in cui vengono scritti, meno recenti. Gli oggetti vengono inviati alla pipeline al Where-Object cmdlet . Where-Objectusa un blocco di script per trovare gli eventi con ID 403. La $_ variabile rappresenta l'oggetto corrente nella pipeline e ID è la proprietà Id evento.

Esempio 16: Filtrare i risultati del registro eventi

Questo esempio mostra un'ampia gamma di metodi per filtrare e selezionare gli eventi da un registro eventi. Tutti questi comandi ottengono eventi che si sono verificati nelle ultime 24 ore dal registro eventi di Windows PowerShell . I metodi di filtro sono più efficienti rispetto all'uso del Where-Object cmdlet . I filtri vengono applicati quando vengono recuperati gli oggetti. Where-Object recupera tutti gli oggetti, quindi applica filtri a tutti gli oggetti.

# Using the Where-Object cmdlet:
$Yesterday = (Get-Date) - (New-TimeSpan -Day 1)
Get-WinEvent -LogName 'Windows PowerShell' | Where-Object { $_.TimeCreated -ge $Yesterday }

# Using the FilterHashtable parameter:
$Yesterday = (Get-Date) - (New-TimeSpan -Day 1)
Get-WinEvent -FilterHashtable @{ LogName='Windows PowerShell'; Level=3; StartTime=$Yesterday }

# Using the FilterXML parameter:
$xmlQuery = @'
<QueryList>
  <Query Id="0" Path="Windows PowerShell">
    <Select Path="System">*[System[(Level=3) and
        TimeCreated[timediff(@SystemTime) &lt;= 86400000]]]</Select>
  </Query>
</QueryList>
'@
Get-WinEvent -FilterXML $xmlQuery

# Using the FilterXPath parameter:
$XPath = '*[System[Level=3 and TimeCreated[timediff(@SystemTime) &lt;= 86400000]]]'
Get-WinEvent -LogName 'Windows PowerShell' -FilterXPath $XPath

Esempio 17: Usare FilterHashtable per ottenere eventi dal log applicazioni

In questo esempio viene usato il parametro FilterHashtable per ottenere eventi dal registro applicazioni . La tabella hash usa coppie chiave/valore . Per altre informazioni sul parametro FilterHashtable , vedere Creazione di query Get-WinEvent con FilterHashtable. Per altre informazioni sulle tabelle hash, vedere about_Hash_Tables.

$Date = (Get-Date).AddDays(-2)
Get-WinEvent -FilterHashtable @{ LogName='Application'; StartTime=$Date; Id='1003' }

Il Get-Date cmdlet usa il metodo AddDays per ottenere una data di due giorni prima della data corrente. L'oggetto date viene archiviato nella $Date variabile .

Il Get-WinEvent cmdlet ottiene le informazioni di log. Il parametro FilterHashtable viene usato per filtrare l'output. La chiave LogName specifica il valore come registro applicazioni . La chiave StartTime usa il valore archiviato nella $Date variabile . La chiave ID usa un valore id evento 1003.

Esempio 18: Usare FilterHashtable per ottenere errori dell'applicazione

In questo esempio viene utilizzato il parametro FilterHashtable per trovare gli errori dell'applicazione Internet Explorer che si sono verificati nell'ultima settimana.

$StartTime = (Get-Date).AddDays(-7)
Get-WinEvent -FilterHashtable @{
  Logname='Application'
  ProviderName='Application Error'
  Data='iexplore.exe'
  StartTime=$StartTime
}

Il Get-Date cmdlet usa il metodo AddDays per ottenere una data di sette giorni prima della data corrente. L'oggetto date viene archiviato nella $StartTime variabile .

Il Get-WinEvent cmdlet ottiene le informazioni di log. Il parametro FilterHashtable viene usato per filtrare l'output. La chiave LogName specifica il valore come registro applicazioni . La chiave ProviderName usa il valore Application Error, ovvero l'origine dell'evento. La chiave Data usa il valore iexplore.exe La chiave StartTime usa il valore archiviato nella $StartTime variabile.

Esempio 19: Usare SuppressHashFilter per filtrare gli errori dell'applicazione

Come nell'esempio 16 precedente, questo esempio usa il parametro FilterHashtable per ottenere eventi dal registro applicazioni . Tuttavia, aggiungiamo la chiave SuppressHashFilter per filtrare gli eventi a livello di informazioni .

$Date = (Get-Date).AddDays(-2)
$filter = @{
  LogName='Application'
  StartTime=$Date
  SuppressHashFilter=@{Level=4}
}
Get-WinEvent -FilterHashtable $filter

In questo esempio, Get-WinEvent ottiene tutti gli eventi dal registro applicazioni per gli ultimi due giorni, ad eccezione di quelli con livello 4 (informazioni).

Parametri

-ComputerName

Specifica il nome del computer in cui il cmdlet ottiene gli eventi dai registri eventi. Digitare il nome NetBIOS, un indirizzo IP o il nome di dominio completo (FQDN) del computer. Il valore predefinito è il computer locale localhost. Questo parametro accetta un solo nome di computer alla volta.

Per ottenere i registri eventi dai computer remoti, configurare la porta del firewall per il servizio registro eventi per consentire l'accesso remoto.

Questo cmdlet non si basa sulla comunicazione remota di PowerShell. È possibile utilizzare il parametro ComputerName anche se il computer non è configurato per eseguire comandi remoti.

Tipo:	String
Alias:	Cn
Posizione:	Named
Valore predefinito:	Local computer
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Credential

Specifica un account utente che dispone delle autorizzazioni per eseguire questa azione. L'impostazione predefinita è l'utente corrente.

Digitare un nome utente, ad esempio User01 o Domain01\User01. In alternativa, immettere un oggetto PSCredential , ad esempio quello generato dal Get-Credential cmdlet . Se si digita un nome utente, viene richiesta una password. Se si digita solo il nome del parametro, viene richiesto sia un nome utente che una password.

Tipo:	PSCredential
Posizione:	Named
Valore predefinito:	Current user
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-FilterHashtable

Specifica una query in formato tabella hash per selezionare gli eventi da uno o più registri eventi. La query contiene una tabella hash con una o più coppie chiave/valore .

Di seguito sono riportate le regole per l'esecuzione di query tramite tabella hash:

Le chiavi e i valori non fanno distinzione tra maiuscole e minuscole.
I caratteri jolly sono validi solo nei valori associati alle chiavi LogName e ProviderName .
Ogni chiave può essere elencata una sola volta in ogni tabella hash.
Il valore Path accetta i percorsi dei .etlfile di log , .evte .evtx .
Le chiavi LogName, Path e ProviderName possono essere usate nella stessa query.
La chiave UserID può accettare un SID (Security Identifier) valido o un nome di account di dominio che può essere usato per costruire un oggetto System.Security.Principal.NTAccount valido.
Il valore Data accetta i dati dell'evento in un campo senza nome. Ad esempio, eventi nei registri eventi classici.
<named-data> key rappresenta un campo dati evento denominato.

Quando Get-WinEvent non riesce a interpretare una coppia chiave/valore , interpreta la chiave come nome con distinzione tra maiuscole e minuscole per i dati dell'evento nell'evento.

Le coppie chiave/valore valide Get-WinEvent sono le seguenti:

LogName=<String[]>
ProviderName=<String[]>
Percorso=<String[]>
Parole chiave=<Long[]>
ID=<Int32[]>
Livello=<Int32[]>
StartTime=<DateTime>
EndTime=<DateTime>
UserID=<SID>
Dati=<String[]>
<named-data>=<String[]>
SuppressHashFilter=<Hashtable>

Tipo:	Hashtable[]
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-FilterXml

Specifica una query XML strutturata che questo cmdlet seleziona gli eventi da uno o più registri eventi.

Per generare una query XML valida, utilizzare le funzionalità Crea visualizzazione personalizzata e Filtra log corrente in Windows Visualizzatore eventi. Usare le voci nella finestra di dialogo per creare una query e quindi fare clic sulla scheda XML per visualizzare la query in formato XML. È possibile copiare il codice XML dalla scheda XML nel valore del parametro FilterXml . Per altre informazioni sulle funzionalità del Visualizzatore eventi, vedere la Guida del Visualizzatore eventi.

Usare una query XML per creare una query complessa contenente diverse istruzioni XPath. Il formato XML consente inoltre di utilizzare un elemento Suppress XML che esclude gli eventi dalla query. Per altre informazioni su XML Schema per le query del log eventi, vedere Query Schema e la sezione Query sugli eventi XML di Selezione eventi.

È anche possibile creare un elemento Suppress usando il parametro FilterHashtable .

Tipo:	XmlDocument
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-FilterXPath

Specifica una query XPath selezionata da uno o più log da questo cmdlet.

Per altre informazioni sul linguaggio XPath, vedere Informazioni di riferimento su XPath e la sezione Filtri di selezione di Selezione eventi.

Tipo:	String
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Force

Ottiene i registri di debug e i registri analitici, oltre ad altri registri eventi. Il parametro Force è necessario per ottenere un log di debug o analitico quando il valore del parametro name include caratteri jolly.

Per impostazione predefinita, il Get-WinEvent cmdlet esclude questi log a meno che non si specifichi il nome completo di un log di debug o analitico.

Tipo:	SwitchParameter
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-ListLog

Specifica i registri eventi. Immettere i nomi dei registri eventi in un elenco delimitato da virgole. I caratteri jolly sono consentiti. Per ottenere tutti i log, usare il carattere jolly asterisco (*).

Tipo:	String[]
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	True

-ListProvider

Specifica i provider del registro eventi che ottiene questo cmdlet. Un provider del registro eventi è un programma o servizio che scrive gli eventi nel registro eventi.

Immettere i nomi dei provider in un elenco delimitato da virgole. I caratteri jolly sono consentiti. Per ottenere i provider di tutti i registri eventi nel computer, usare il carattere jolly asterisco (*).

Tipo:	String[]
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	True

-LogName

Specifica i registri eventi da cui questo cmdlet ottiene gli eventi. Immettere i nomi dei registri eventi in un elenco delimitato da virgole. I caratteri jolly sono consentiti. È anche possibile inviare tramite pipe i nomi dei log al Get-WinEvent cmdlet .

Nota

PowerShell non limita la quantità di log che è possibile richiedere. Tuttavia, il Get-WinEvent cmdlet esegue una query sull'API Windows con un limite di 256. Ciò può rendere difficile filtrare tutti i log contemporaneamente. È possibile risolvere questo problema usando un foreach ciclo per scorrere ogni log come segue: Get-WinEvent -ListLog * | ForEach-Object{ Get-WinEvent -LogName $_.Logname }

Tipo:	String[]
Posizione:	0
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	True
Accettare caratteri jolly:	True

-MaxEvents

Specifica il numero massimo di eventi restituiti. Immettere un numero intero, ad esempio 100. Per impostazione predefinita, vengono restituiti tutti gli eventi nei registri o nei file.

Tipo:	Int64
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Oldest

Indicare che questo cmdlet ottiene gli eventi nell'ordine meno recente. Per impostazione predefinita, gli eventi vengono restituiti a partire dal più recente.

Questo parametro è necessario per ottenere eventi da .etl file e .evt da log di debug e analitici. In questi file gli eventi vengono registrati a partire dal primo e gli eventi possono essere restituiti solo in quest'ordine.

Tipo:	SwitchParameter
Posizione:	Named
Valore predefinito:	None
Necessario:	False
Accettare l'input della pipeline:	False
Accettare caratteri jolly:	False

-Path

Specifica il percorso dei file di log eventi da cui questo cmdlet ottiene gli eventi. Immettere i percorsi dei file di registro in un elenco delimitato da virgole o usare caratteri jolly per creare modelli di percorso file.

Get-WinEvent supporta i file con le .evtestensioni di file , .evtxe .etl . È possibile includere gli eventi da file e tipi di file diversi nello stesso comando.

Tipo:	String[]
Alias:	PSPath
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	True
Accettare caratteri jolly:	True

-ProviderName

Specifica, come matrice di stringhe, i provider del registro eventi da cui questo cmdlet ottiene gli eventi. Immettere i nomi dei provider in un elenco delimitato da virgole o usare caratteri jolly per creare modelli di nome di provider.

Un provider del registro eventi è un programma o servizio che scrive gli eventi nel registro eventi. Non è un provider di PowerShell.

Tipo:	String[]
Posizione:	0
Valore predefinito:	None
Necessario:	True
Accettare l'input della pipeline:	True
Accettare caratteri jolly:	True

Input

String

È possibile inviare tramite pipe un LogName (stringa) a questo cmdlet.

XmlDocument

È possibile inviare tramite pipe una query FilterXML a questo cmdlet.

Hashtable

È possibile inviare tramite pipe una query FilterHashtable a questo cmdlet.

Output

EventLogConfiguration

Con il parametro ListLog , questo cmdlet restituisce oggetti EventLogConfiguration .

EventLogRecord

Per impostazione predefinita, questo cmdlet restituisce oggetti EventLogRecord .

ProviderMetadata

Con il parametro ListProvider , questo cmdlet restituisce gli oggetti ProviderMetadata .

Note

Get-WinEvent è progettato per sostituire il Get-EventLog cmdlet nei computer che eseguono Windows Vista e versioni successive di Windows. Get-EventLog ottiene gli eventi solo nei registri eventi classici. Get-EventLog viene mantenuta per compatibilità con le versioni precedenti.

I Get-WinEvent cmdlet e Get-EventLog non sono supportati nell'ambiente di preinstallazione di Windows (Windows PE).

Condividi tramite