Descripción general

Crea reglas grok personalizadas para analizar el mensaje completo o un atributo específico de su evento en bruto. Como mejor práctica, se recomienda utilizar un máximo de 10 reglas de análisis dentro de un procesador grok.

Haga clic en Analizar Mis Eventos para iniciar un conjunto de tres reglas de análisis para los eventos que fluyen a través de la canalización subyacente. Refine la nomenclatura de los atributos desde allí y agregue nuevas reglas para otros tipos de eventos si es necesario. Esta función requiere que los eventos correspondientes estén siendo indexados y fluyendo realmente; puede desactivar temporalmente o reducir los filtros de exclusión para que esto funcione para usted.

Seleccione una muestra haciendo clic en ella para activar su evaluación contra la regla de análisis y mostrar el resultado en la parte inferior de la pantalla.

Se pueden guardar hasta cinco muestras con el procesador, y cada muestra puede tener hasta 5000 caracteres de longitud. Todas las muestras muestran un estado (coincidencia o no coincidencia), lo que resalta si una de las reglas de parseo del analizador grok coincide con la muestra.

Sintaxis Grok

El Analizador Grok extrae atributos de mensajes de texto semiestructurados. Grok viene con patrones reutilizables para analizar enteros, direcciones IP, nombres de host y más. Estos valores deben ser enviados al analizador grok como cadenas.

Puede escribir reglas de análisis con la %{MATCHER:EXTRACT:FILTER} sintaxis:

• Coincidente: Una regla (posiblemente una referencia a otra regla de token) que describe qué esperar (número, palabra, no espacio, etc.).

• Extraer (opcional): Un identificador que representa el destino de captura para el fragmento de texto coincidente con el Coincidente.

• Filtrar (opcional): Un post-procesador de la coincidencia para transformarla.

Ejemplo de un evento clásico no estructurado:

john connected on 11/08/2017

Con la siguiente regla de análisis:

MyParsingRule %{word:user} connected on %{date("MM/dd/yyyy"):date}

Después de procesar, se genera el siguiente evento estructurado:

Nota:

• Si tiene múltiples reglas de análisis en un solo Analizador Grok:
  • Solo una puede coincidir con cualquier evento dado. La primera que coincida, de arriba hacia abajo, es la que realiza el análisis.
  • Cada regla puede hacer referencia a reglas de análisis definidas por encima de sí misma en la lista.
• Debe tener nombres de regla únicos dentro del mismo Analizador Grok.
• El nombre de la regla debe contener solo: caracteres alfanuméricos, _, y .. Debe comenzar con un carácter alfanumérico.
• Las propiedades con valores nulos o vacíos no se muestran.
• El comparador de regex aplica un ^ implícito, para coincidir con el inicio de una cadena, y un $, para coincidir con el final de una cadena.
• Ciertos eventos pueden producir grandes espacios en blanco. Utilice \n y \s+ para tener en cuenta los saltos de línea y los espacios en blanco.

Comparador y filtro

Aquí hay una lista de todos los matchers y filtros implementados nativamente por Datadog:

Configuraciones avanzadas

En la parte inferior de sus mosaicos del procesador Grok, hay una sección de Configuraciones Avanzadas:

Analizando un atributo de texto específico

Utilice el campo Extraer de para aplicar su procesador Grok a un atributo de texto dado en lugar del atributo predeterminado message.

Por ejemplo, considere un evento que contiene un atributo command.line que debe ser analizado como un par clave-valor. Podría analizar este evento de la siguiente manera:

Usando reglas auxiliares para factorizar múltiples reglas de análisis

Utilice el campo Reglas Auxiliares para definir tokens para sus reglas de análisis. Las reglas auxiliares le ayudan a factorizar patrones Grok en sus reglas de análisis. Esto es útil cuando tiene varias reglas en el mismo Analizador Grok que utilizan los mismos tokens.

Ejemplo de un evento clásico no estructurado:

john id:12345 connected on 11/08/2017 on server XYZ in production

Utilice la siguiente regla de análisis:

MyParsingRule %{user} %{connection} %{server}

Con los siguientes auxiliares:

user %{word:user.name} id:%{integer:user.id}
connection connected on %{date("MM/dd/yyyy"):connect_date}
server on server %{notSpace:server.name} in %{notSpace:server.env}

Ejemplos

Algunos ejemplos que demuestran cómo usar analizadores:

• Clave valor o logfmt
• Parseo de fechas
• Patrones alternantes
• Atributo opcional
• JSON anidado
• Expresión regular
• Listas y arreglos
• Formato Glog
• XML
• CSV

Clave-valor o logfmt

Este es el filtro central de clave-valor: keyvalue([separatorStr[, characterAllowList[, quotingStr[, delimiter]]]]) donde:

• separatorStr: define el separador entre claves y valores. Por defecto es =.
• characterAllowList: define caracteres adicionales de valor no escapados además del valor por defecto \\w.\\-_@. Se utiliza solo para valores no entrecomillados (por ejemplo, key=@valueStr).
• quotingStr: define comillas, reemplazando la detección de comillas por defecto: <>, "", ''.
• delimiter: define el separador entre los diferentes pares de clave-valor (por ejemplo, | es el delimitador en key1=value1|key2=value2). Por defecto es (espacio normal), , y ;.

Utilice filtros como clave-valor para mapear más fácilmente cadenas a atributos para formatos de clave-valor o logfmt:

Evento:

user=john connect_date=11/08/2017 id=123 action=click

Regla:

rule %{data::keyvalue}

No es necesario especificar el nombre de sus parámetros ya que ya están contenidos en el evento. Si agrega un atributo de extracción my_attribute en su patrón de regla, verá:

Si = no es el separador predeterminado entre su clave y valores, agregue un parámetro en su regla de parseo con un separador.

Evento:

user: john connect_date: 11/08/2017 id: 123 action: click

Regla:

rule %{data::keyvalue(": ")}

Si el evento contiene caracteres especiales en un valor de atributo, como / en una URL, agréguelo a la lista de permitidos en su regla de parseo:

Evento:

url=https://app.datadoghq.com/event/stream user=john

Regla:

rule %{data::keyvalue("=","/:")}

Otros ejemplos:

Ejemplo de cadena de múltiples comillas: Cuando se definen múltiples cadenas de comillas, el comportamiento predeterminado se reemplaza con un carácter de comillas definido. La clave-valor siempre coincide con las entradas sin ningún carácter de comillas, independientemente de lo que se especifique en quotingStr. Cuando se utilizan caracteres de comillas, se ignora el characterAllowList ya que todo lo que está entre los caracteres de comillas se extrae.

Evento:

key1:=valueStr key2:=</valueStr2> key3:="valueStr3"

Regla:

rule %{data::keyvalue(":=","","<>")}

Resultado:

{"key1": "valueStr", "key2": "/valueStr2"}

Nota:

• Los valores vacíos (key=) o los valores null (key=null) no se muestran en el JSON de salida.
• Si define un filtro de clave-valor en un data objeto, y este filtro no coincide, entonces se devuelve un JSON vacío {} (por ejemplo, entrada: key:=valueStr, regla de parseo: rule_test %{data::keyvalue("=")}, salida: {}).
• Definir "" como quotingStr mantiene la configuración predeterminada para las comillas.

Parseo de fechas

El comparador de fechas transforma su marca de tiempo en el formato EPOCH (unidad de medida milisegundo).

¹ Utilice el timezone parámetro si realiza sus propias localizaciones y sus marcas de tiempo no están en UTC. El formato soportado para zonas horarias es:

• GMT, UTC, UT o Z
• +h, +hh, +hh:mm, -hh:mm, +hhmm, -hhmm, +hh:mm:ss, -hh:mm:ss, +hhmmss o -hhmmss . El rango máximo soportado es de +18:00 a -18:00 inclusive.
• Zonas horarias que comienzan con UTC+, UTC-, GMT+, GMT-, UT+ o UT-. El rango máximo soportado es de +18:00 a -18:00 inclusive.
• IDs de zona horaria extraídos de la base de datos TZ. Para más información, consulte nombres de la base de datos TZ.

Nota: El parseo de una fecha no establece su valor como la fecha oficial del evento. Para esto, utilice el Remapeador de Fecha de Evento en un Procesador posterior.

Patrón alternante

Si tiene eventos con dos formatos posibles que difieren en solo un atributo, establezca una única regla utilizando alternante con (<REGEX_1>|<REGEX_2>). Esta regla es equivalente a un OR booleano.

Evento:

john connected on 11/08/2017
12345 connected on 11/08/2017

Regla: Tenga en cuenta que “id” es un entero y no una cadena.

MyParsingRule (%{integer:user.id}|%{word:user.firstname}) connected on %{date("MM/dd/yyyy"):connect_date}

Resultados:

Atributo opcional

Algunos eventos contienen valores que solo aparecen parte del tiempo. En este caso, haga que la extracción de atributos sea opcional con ()?.

Evento:

john 1234 connected on 11/08/2017

Regla:

MyParsingRule %{word:user.firstname} (%{integer:user.id} )?connected on %{date("MM/dd/yyyy"):connect_date}

Nota: Una regla no coincidirá si incluye un espacio después de la primera palabra en la sección opcional.

JSON anidado

Utilice el filtro json para analizar un objeto JSON anidado después de un prefijo de texto sin procesar:

Evento:

Sep 06 09:13:38 vagrant program[123]: server.1 {"method":"GET", "status_code":200, "url":"https://app.datadoghq.com/logs/pipelines", "duration":123456}

Regla:

parsing_rule %{date("MMM dd HH:mm:ss"):timestamp} %{word:vm} %{word:app}\[%{number:logger.thread_id}\]: %{notSpace:server} %{data::json}

Regex

Evento:

john_1a2b3c4 connected on 11/08/2017

Regla:

MyParsingRule %{regex("[a-z]*"):user.firstname}_%{regex("[a-zA-Z0-9]*"):user.id} .*

Lista a arreglo

Utilice el filtro array([[openCloseStr, ] separator][, subRuleOrFilter) para extraer una lista en un arreglo en un solo atributo. El subRuleOrFilter es opcional y acepta estos filtros.

Evento:

Users [John, Oliver, Marc, Tom] have been added to the database

Regla:

myParsingRule Users %{data:users:array("[]",",")} have been added to the database

Evento:

Users {John-Oliver-Marc-Tom} have been added to the database

Regla:

myParsingRule Users %{data:users:array("{}","-")} have been added to the database

Regla usando subRuleOrFilter:

myParsingRule Users %{data:users:array("{}","-", uppercase)} have been added to the database

Formato Glog

Los componentes de Kubernetes a veces registran en el formato glog; este ejemplo es del elemento Kube Scheduler en la Biblioteca de Canalización.

Ejemplo de Evento:

W0424 11:47:41.605188       1 authorization.go:47] Authorization is disabled

Regla de parseo:

kube_scheduler %{regex("\\w"):level}%{date("MMdd HH:mm:ss.SSSSSS"):timestamp}\s+%{number:logger.thread_id} %{notSpace:logger.name}:%{number:logger.lineno}\] %{data:msg}

Y JSON extraído:

{
  "level": "W",
  "timestamp": 1587728861605,
  "logger": {
    "thread_id": 1,
    "name": "authorization.go"
  },
  "lineno": 47,
  "msg": "Authorization is disabled"
}

Parseo XML

El analizador XML transforma mensajes formateados en XML a JSON.

Evento:

<book category="CHILDREN">
  <title lang="en">Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
</book>

Regla:

rule %{data::xml}

Resultado:

{
"book": {
  "year": "2005",
  "author": "J K. Rowling",
  "category": "CHILDREN",
  "title": {
    "lang": "en",
    "value": "Harry Potter"
  }
}
}

Notas:

• Si el XML contiene etiquetas que tienen tanto un atributo como un valor de cadena entre las dos etiquetas, se genera un atributo value. Por ejemplo: <title lang="en">Harry Potter</title> se convierte en {"title": {"lang": "en", "value": "Harry Potter" } }
• Las etiquetas repetidas se convierten automáticamente en arreglos. Por ejemplo: <bookstore><book>Harry Potter</book><book>Everyday Italian</book></bookstore> se convierte en { "bookstore": { "book": [ "Harry Potter", "Everyday Italian" ] } }

Parseo CSV

Utiliza el filtro CSV para mapear más fácilmente cadenas a atributos cuando están separadas por un carácter dado (, por defecto).

El filtro CSV se define como csv(headers[, separator[, quotingcharacter]]) donde:

• headers: Define los nombres de las claves separados por ,. Los nombres de las claves deben comenzar con un carácter alfabético y pueden contener cualquier carácter alfanumérico además de _.
• separator: Define los separadores utilizados para separar los diferentes valores. Solo se acepta un carácter. Predeterminado: ,. Nota: Utilice tab para el separator para representar el carácter de tabulación para TSVs.
• quotingcharacter: Define el carácter de comillas. Solo se acepta un carácter. Predeterminado: "

Nota:

• Los valores que contienen un carácter separador deben estar entre comillas.
• Los valores entre comillas que contienen un carácter de comillas deben escaparse con un carácter de comillas. Por ejemplo, "" dentro de un valor entre comillas representa ".
• Si el evento no contiene la misma cantidad de valores que la cantidad de claves en el encabezado, el analizador CSV emparejará los primeros.
• Los enteros y dobles se convierten automáticamente si es posible.

Evento:

John,Doe,120,Jefferson St.,Riverside

Regla:

myParsingRule %{data:user:csv("first_name,name,st_nb,st_name,city")}

Resultado:

{
  "user": {
    "first_name": "John",
    "name": "Doe",
    "st_nb": 120,
    "st_name": "Jefferson St.",
    "city": "Riverside"
  }
}

Otros ejemplos:

Utiliza el comparador de datos para descartar texto innecesario

Si tiene un evento en el que, después de haber parseado lo necesario y saber que el texto posterior es seguro descartar, puede utilizar el comparador de datos para ello. Para el siguiente ejemplo de evento, puede usar el data comparador para descartar el % al final.

Evento:

Usage: 24.3%

Regla:

MyParsingRule Usage\:\s+%{number:usage}%{data:ignore}

Resultado:

{
  "usage": 24.3,
  "ignore": "%"
}

Caracteres de control ASCII

Si sus eventos contienen caracteres de control ASCII, se serializan al ser ingeridos. Estos pueden ser manejados escapando explícitamente el valor serializado dentro de su parser grok.