Consulte Logs de Eventos de Forma Eficiente com Get-EventLog do PowerShell

PS> Get-EventLog -LogName Application -InstanceId 916

PS> Get-EventLog -LogName Application -InstanceId 916 -Message '*svchost*'

.SYNOPSIS
    Este script procura em um computador com Windows todas as entradas de log de eventos ou logs de texto
    entre um horário de início e término especificado.
.DESCRIPTION
    Este script enumera todos os logs de eventos dentro de um intervalo de tempo especificado e todos os logs de texto
    que têm um horário de última gravação dentro desse intervalo ou contêm uma linha com uma data/hora
    referência dentro do intervalo. Ele registra essas informações em um conjunto de arquivos e copia
    qualquer arquivo de log interessante para análise posterior.
.EXAMPLE
    PS> .\Get-EventsFromTimeframe.ps1 -StartTimestamp '01-29-2014 13:25:00' -EndTimeStamp '01-29-2014 13:28:00' -ComputerName NOME_DO_COMPUTADOR

    Este exemplo encontra todas as entradas de log de eventos entre StartTimestamp e EndTimestamp e qualquer arquivo
    com uma extensão dentro do parâmetro $FileExtension que foi gravado pela última vez dentro do intervalo
    ou contém uma linha com uma referência de data/hora dentro do intervalo.
.PARAMETER StartTimestamp
 A data/hora mais cedo que você gostaria de começar a procurar eventos.
.PARAMETER EndTimestamp
 A data/hora mais recente que você gostaria de começar a procurar eventos.
.PARAMETER Computername
 O nome do computador remoto (ou local) que você gostaria de pesquisar.
.PARAMETER OutputFolderPath
 O caminho da pasta que conterá os arquivos de texto com os eventos.
.PARAMETER LogAuditFilPath
 O caminho do arquivo de texto que documentará o arquivo de log, número da linha e tipo de correspondência
 para os logs que foram correspondidos.
.PARAMETER EventLogsOnly
 Use este parâmetro de switch se quiser procurar apenas nos logs de eventos.
.PARAMETER LogFilesOnly
 Use este parâmetro se quiser procurar apenas logs no sistema de arquivos.
.PARAMETER ExcludeDirectory
 Se estiver procurando no sistema de arquivos, especifique quais pastas você gostaria de pular.
.PARAMETER FileExtension
 Especifique uma ou mais conjuntos de extensões de arquivo separados por vírgula que você gostaria de procurar no sistema de arquivos.
 Isso padrão para extensões 'log,txt,wer'.
#>
[CmdletBinding(DefaultParameterSetName = 'Neither')]
param (
    [Parameter(Mandatory)]
    [datetime]$StartTimestamp,
    [Parameter(Mandatory)]
    [datetime]$EndTimestamp,
    [Parameter(ValueFromPipeline,
        ValueFromPipelineByPropertyName)]
    [string]$ComputerName = 'localhost',
    [Parameter()]
 [string]$OutputFolderPath = ".\$Computername",
 [Parameter(ParameterSetName = 'LogFiles')]
 [string]$LogAuditFilePath = "$OutputFolderPath\LogActivity.csv",
 [Parameter(ParameterSetName = 'EventLogs')]
 [switch]$EventLogsOnly,
    [Parameter(ParameterSetName = 'LogFiles')]
    [switch]$LogFilesOnly,
    [Parameter(ParameterSetName = 'LogFiles')]
 [string[]]$ExcludeDirectory,
 [Parameter(ParameterSetName = 'LogFiles')]
 [string[]]$FileExtension = @('log', 'txt', 'wer')
)
 
begin {
 if (!$EventLogsOnly.IsPresent) {
 ## Crie o diretório local onde armazenar os arquivos de log que correspondem aos critérios
 $LogsFolderPath = "$OutputFolderPath\logs"
 if (!(Test-Path $LogsFolderPath)) {
 mkdir $LogsFolderPath | Out-Null
 }
 }
 
 function Add-ToLog($FilePath,$LineText,$LineNumber,$MatchType) {
 $Audit = @{
 'FilePath' = $FilePath;
 'LineText' = $LineText
 'LineNumber' = $LineNumber
 'MatchType' = $MatchType
 }
 [pscustomobject]$Audit | Export-Csv -Path $LogAuditFilePath -Append -NoTypeInformation
 }
}
 
process {
 
    ## Execute apenas se o usuário quiser encontrar entradas de log de eventos
    if (!$LogFilesOnly.IsPresent) {
 ## Encontre todos os nomes de log de eventos que contenham pelo menos 1 evento
 $Logs = (Get-WinEvent -ListLog * -ComputerName $ComputerName | where { $_.RecordCount }).LogName
 $FilterTable = @{
 'StartTime' = $StartTimestamp
 'EndTime' = $EndTimestamp
 'LogName' = $Logs
 }
 
 ## Encontre todos os eventos em todos os logs de eventos que estão entre os horários de início e término
 $Events = Get-WinEvent -ComputerName $ComputerName -FilterHashtable $FilterTable -ea 'SilentlyContinue'
 Write-Verbose "Found $($Events.Count) total events"
 
 ## Converta as propriedades para algo mais amigável e acrescente cada evento ao arquivo de texto do log de eventos
 $LogProps = @{ }
 [System.Collections.ArrayList]$MyEvents = @()
 foreach ($Event in $Events) {
 $LogProps.Time = $Event.TimeCreated
 $LogProps.Source = $Event.ProviderName
 $LogProps.EventId = $Event.Id
 if ($Event.Message) {
 $LogProps.Message = $Event.Message.Replace("<code>n", '|').Replace("</code>r", '|')
 }
 $LogProps.EventLog = $Event.LogName
 $MyEvents.Add([pscustomobject]$LogProps) | Out-Null
 }
 $MyEvents | sort Time | Export-Csv -Path "$OutputFolderPath\eventlogs.txt" -Append -NoTypeInformation
 }
 
 ## Execute apenas se o usuário quiser encontrar arquivos de log
 if (!$EventLogsOnly.IsPresent) {
        ## Enumere todas as compartilhamentos administrativos remotos no computador remoto. Faço isso em vez de enumerar todas as unidades físicas porque
        ## a unidade pode estar lá e o compartilhamento pode não estar, o que significa que não consigo acessar a unidade de qualquer maneira.
 $Shares = Get-WmiObject -ComputerName $ComputerName -Class Win32_Share | where { $_.Path -match '^\w{1}:\\$' }
 [System.Collections.ArrayList]$AccessibleShares = @()
 ## Certifique-se de que é possível acessar todos os compartilhamentos administrativos remotos
 foreach ($Share in $Shares) {
 $Share = "\\$ComputerName\$($Share.Name)"
 if (!(Test-Path $Share)) {
 Write-Warning "Unable to access the '$Share' share on '$Computername'"
 } else {
 $AccessibleShares.Add($Share) | Out-Null 
 }
 }
 
 $AllFilesQueryParams = @{
 Path = $AccessibleShares
 Recurse = $true
 Force = $true
 ErrorAction = 'SilentlyContinue'
 File = $true
 }
 ## Adicione quaisquer diretórios especificados no parâmetro $ExcludeDirectory para não procurar arquivos de log
 if ($ExcludeDirectory) {
 $AllFilesQueryParams.ExcludeDirectory = $ExcludeDirectory 
 }
 ## Crie a sequência de regex complicada que uso para procurar por uma variedade de formatos de data/hora diferentes.
 ## Isso é usado na tentativa de procurar strings de data/hora em cada arquivo de texto encontrado
 ##TODO: Adicionar capacidade de corresponder em Jan,Feb,Mar,etc
 $DateTimeRegex = "($($StartTimestamp.Month)[\\.\-/]?$($StartTimestamp.Day)[\\.\-/]?[\\.\-/]$($StartTimestamp.Year))|($($StartTimestamp.Year)[\\.\-/]?$($StartTimestamp.Month)[\\.\-/]?[\\.\-/]?$($StartTimestamp.Day))"
 ## Enumere todos os arquivos que correspondam aos parâmetros de consulta que têm conteúdo
 Get-ChildItem @AllFilesQueryParams | where { $_.Length -ne 0 } | foreach {
 try {
 Write-Verbose "Processing file '$($_.Name)'"
 ## Grave o arquivo se o horário de última gravação estiver dentro do intervalo. Isso encontra arquivos de log que podem não registrar um 
 ## timestamp de data/hora, mas ainda podem estar envolvidos no evento que o usuário está tentando encontrar.
 if (($_.LastWriteTime -ge $StartTimestamp) -and ($_.LastWriteTime -le $EndTimestamp)) {
 Write-Verbose "Last write time within timeframe for file '$($_.Name)'"
 Add-ToLog -FilePath $_.FullName -MatchType 'LastWriteTime'
 }
 ## Se o arquivo encontrado corresponder ao conjunto de extensões que estou tentando encontrar e for realmente um arquivo de texto simples.
 ## Eu uso o Get-Content apenas para verificar se é texto simples antes de analisá-lo.
 if ($FileExtension -contains $_.Extension.Replace('.','') -and !((Get-Content $_.FullName -Encoding Byte -TotalCount 1024) -contains 0)) {
 ## Verifique o conteúdo do arquivo de texto para referências a datas no intervalo de tempo
 Write-Verbose "Checking log file '$($_.Name)' for date/time match in contents"
 $LineMatches = Select-String -Path $_.FullName -Pattern $DateTimeRegex
 if ($LineMatches) {
 Write-Verbose "Date/time match found in file '$($_.FullName)'"
 ## Registre todas as linhas correspondentes no arquivo de auditoria.
 foreach ($Match in $LineMatches) {
 Add-ToLog -FilePath $_.FullName -LineNumber $Match.LineNumber -LineText $Match.Line -MatchType 'Contents'
 }
 ## Crie o mesmo caminho para o arquivo de log no computador remoto dentro do diretório de log de saída e 
 ## copie o arquivo de log com um evento dentro do intervalo para esse caminho.
 ## Isso não funcionará se um caminho de arquivo acima de 255 caracteres for encontrado.
 $Trim = $_.FullName.Replace("\\$Computername\", '')
 $Destination = "$OutputFolderPath\$Trim"
 if (!(Test-Path $Destination)) {
 ##TODO: Remover a ação de erro quando o suporte a caminhos longos for implementado
 mkdir $Destination -ErrorAction SilentlyContinue | Out-Null
 }
 Copy-Item -Path $_.FullName -Destination $Destination -ErrorAction SilentlyContinue -Recurse
 }
 }
 } catch {
 Write-Warning $_.Exception.Message 
 }
 }
 }
}