Lectura y creación de registros de cliente SCCM con PowerShell

Si es administrador de SCCM, probablemente esté familiarizado con la herramienta de lectura de registros CMtrace. CMTrace conoce el esquema específico de los registros del cliente SCCM, pero ¿sabía que puede usar PowerShell de manera muy similar a CMTrace?

Usando PowerShell, puedes leer:

Registros de instalación del software del cliente SCCM
Registros de actualización del software del cliente SCCM
Registros de inventario de hardware del cliente SCCM

..y casi todos los demás!

Los registros del cliente SCCM siguen un esquema determinado. Para obtener algún tipo de resultado estandarizado de ellos, es necesario comprender ese esquema. Por suerte para ti, eso ya se ha hecho.

Lectura de registros de cliente SCCM con PowrShell

Eche un vistazo al código de PowerShell a continuación que consulta los registros del cliente SCCM.

Esta función de PowerShell Get-SCCMClientLog tiene dos parámetros; ComputerName y LogName le permiten consultar computadoras remotas y especificar el nombre del registro que desea ver.

Relacionado: Introducción a la función PowerShell

Una vez que esta función esté disponible en su consola PowerShell, podrá ejecutarla como se muestra a continuación. El siguiente ejemplo consultaría la computadora remota llamada PC y recuperaría el archivo de registro execmgr.

Get-SccmClientLog -ComputerName PC -LogName execmgr

Todo el trabajo pesado ya se ha hecho por usted en la función.

Creación de sus propios registros de cliente SCCM

¿Qué sucede si desea utilizar la función Get-SCCMClientLog pero para otros fines? ¡También puedes crear tus propios archivos de registro tipo cliente SCCM!

¡Solo mira la belleza de las columnas ordenables y el resaltado rojo! Al principio, podría pensar que puede ver cualquier tipo de registro de texto en CMTrace y estaría en lo cierto. Sin embargo, echemos un vistazo al archivo WindowsUpdate.log en CMTrace.

¿Notas que todas las columnas han desaparecido? CMTrace seguirá viendo los archivos de registro habituales, pero no obtendrá algunas de las funciones que hacen que CMTrace sea excelente. Pronto descubrirá que un archivo de texto debe tener el formato adecuado para que aparezcan todas esas columnas útiles y para definir correctamente qué líneas deben resaltarse en amarillo o en rojo. versus nada en absoluto.

Me gustaría mostrarles un par de funciones de PowerShell llamadas Write-Log y Start-Log. Estas funciones se crearon específicamente para registrar la actividad de su secuencia de comandos en un archivo de registro que luego se puede leer en CMTrace.

Al final de esta publicación, tendrá una función a la que puede llamar en sus scripts para crear archivos de registro de manera que CMTrace los lea correctamente.

Iniciar registro

Para evitar tener que especificar la misma ruta del archivo de registro del cliente SCCM una y otra vez, elegí crear una función llamada Start-Log. Esta función está destinada a ser llamada en la parte superior de su secuencia de comandos. Esta función simplemente crea un archivo de texto y (la parte importante) establece una variable global llamada ScriptLogFilePath.

[CmdletBinding()]
param (
    [ValidateScript({ Split-Path $_ -Parent | Test-Path })]
    [string]$FilePath
)
try {
    if (!(Test-Path $FilePath)) {
        ## Create the log file
        New-Item $FilePath -Type File | Out-Null
    }
    ## Set the global variable to be used as the FilePath for all subsequent Write-Log calls in this session
    $global:ScriptLogFilePath = $FilePath
} catch {
    Write-Error $_.Exception.Message
}

Esta función es súper simple. Sin embargo, es necesario para evitar que tengamos que pasar LogFile cada vez que necesitemos llamar a nuestra función Write-Log en nuestros scripts. Simplemente creando una variable global con anticipación, podemos simplemente llamar a Write-Log y conocerá la ruta del archivo de registro.

Registro de escritura

Una vez que haya llamado Start-Log en su secuencia de comandos, ahora podrá ejecutar Write-Log para escribir mensajes de registro del cliente SCCM en el archivo de registro. Write-Log tiene dos parámetros; Mensaje y Nivel de registro. Mensaje es fácil. Eso es simplemente lo que le gustaría escribir en el registro. LogLevel requiere algunas explicaciones.

Para que CMTrace resalte líneas en rojo o amarillo, la línea debe registrarse de cierta manera. Más específicamente, debe tener una cadena como esta: type="1". Este tipo de clave puede ser 1, 2 o 3. Estas indican niveles de gravedad en su script.

Por ejemplo, si quisiera registrar un mensaje informativo simple, sería un 1. Si quisiera registrar una actividad más grave, podría usar 2, que se resaltaría en amarillo. Finalmente, puedo elegir 3 si quiero que esa línea esté resaltada en rojo en CMTrace.

param (
    [Parameter(Mandatory = $true)]
    [string]$Message,

    [Parameter()]
    [ValidateSet(1, 2, 3)]
    [int]$LogLevel = 1
)

¿Observa el parámetro LogLevel? De forma predeterminada, lo establecerá en 1, pero siempre podrá anularlo si es necesario si desea escribir alguna actividad más grave que ocurra durante la ejecución de su script.

A continuación, necesita que esa práctica columna de fecha/hora aparezca correctamente. Para hacer esto se requiere un formato de fecha/hora específico que se logra mediante este asistente de manipulación de cadenas.

$TimeGenerated = "$(Get-Date -Format HH:mm:ss).$((Get-Date).Millisecond)+000"

A continuación, crearé una plantilla de línea de registro utilizando todo el formato apropiado que la línea debe tener para mostrarse correctamente en CMTrace.

$Line = '<![LOG[{0}]LOG]!><time="{1}" date="{2}" component="{3}" context="" type="{4}" thread="" file="">'

Una vez que tengas la plantilla, es cuestión de construir lo que irá en los {}. Aquí, construyo una matriz que luego pasaré a $Line para reemplazar todos nuestros {} con información real.

$LineFormat = $Message, $TimeGenerated, (Get-Date -Format MM-dd-yyyy), "$($MyInvocation.ScriptName | Split-Path -Leaf):$($MyInvocation.ScriptLineNumber)", $LogLevel

Estos están en el mismo orden que los {} anteriores. {0} se convertirá a $Message, {1} se convertirá a $TimeGenerated, {2} se convertirá a la fecha de hoy y {4} se convertirá a $LogLevel.

¿Notas que me salté {3}? Aquí es donde te pongo todo ninja. CMTrace tiene una columna de componentes que nunca usé mucho, así que decidí hacer algo con ella.

Quería ver el nombre del script y el número de línea en la que se llamó a Write-Log. Esta cadena: "$ ($MyInvocation.ScriptName | Split-Path -Leaf):$ ($MyInvocation.ScriptLineNumber)" es lo que hace que eso suceda.

Luego reúno estas dos variables usando el formato de cadena de PowerShell para crear $Line.

$Line = $Line -f $LineFormat

Entonces es sólo cuestión de escribir $Line en un archivo de texto que ya ha sido definido por Start-Log.

Add-Content -Value $Line -Path $ScriptLogFilePath

Cómo funciona

Digamos que construyo un script que se parece a este llamado LogDemo.ps1:

Start-Log -FilePath C:\MyLog.log
Write-Host "Script log file path is [$ScriptLogFilePath]"
Write-Log -Message 'simple activity'
Write-Log -Message 'warning' -LogLevel 2
Write-Log -Message 'Error' -LogLevel 3

Este script crea nuestro archivo de registro en C:\MyLog.log y luego procede a escribir 3 niveles de gravedad en el registro mediante el uso de los parámetros LogLevel que expliqué anteriormente.

Cuando reviso el resultado de este archivo con Get-Content, se ve bastante feo.

<![LOG[simple activity]LOG]!><time="18:56:26.307+000" date="12-03-2015" component="LogDemo.ps1:3" context="" type="1" thread="" file=""> <![LOG[warning]LOG]!><time="18:56:26.307+000" date="12-03-2015" component="LogDemo.ps1:4" context="" type="2" thread="" file=""> <![LOG[Error]LOG]!><time="18:56:26.307+000" date="12-03-2015" component="LogDemo.ps1:5" context="" type="3" thread="" file="">

Sin embargo, abramos esto en CMTrace y veamos cómo se ve.

¿No es hermoso?

Incluso si no es administrador de SCCM, le recomiendo utilizar CMTrace para todas sus necesidades de visualización de registros.