Procesadores configurables tipo analizador Procesadores integrados para los AWS registros vendidos Procesadores que mutan cadenas Procesadores JSON mutan Procesadores convertidores de tipos de datos

Procesadores que puede utilizar

Esta sección contiene información sobre cada procesador que puede usar en un transformador de registro de eventos. Los procesadores se pueden clasificar en analizadores, mutadores de cadenas, mutadores JSON y procesadores de fecha.

Contenido

Procesadores configurables tipo analizador

parseJSON

El procesador ParseJSON analiza los eventos del registro JSON e inserta los pares clave-valor JSON extraídos en el destino. Si no especifica un destino, el procesador coloca el par clave-valor debajo del nodo raíz. Si parseJSON lo utiliza como primer procesador, debe analizar todo el evento del registro utilizando el campo @message de origen. Tras el análisis inicial de JSON, puede manipular campos específicos en los procesadores posteriores.

El @message contenido original no se modifica, las nuevas claves se añaden al mensaje.

Campo Descripción ¿Obligatorio? Predeterminado/a Límites

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
origen	Ruta al campo del evento de registro que se analizará. Utilice la notación de puntos para acceder a los campos secundarios. Por ejemplo, `store.book`	No	`@message`	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
destination	El campo de destino del JSON analizado	No	`Parent JSON node`	Longitud máxima: 128 Profundidad máxima de clave anidada: 3

origen

Ruta al campo del evento de registro que se analizará. Utilice la notación de puntos para acceder a los campos secundarios. Por ejemplo, store.book

@message

Longitud máxima: 128

Profundidad máxima de clave anidada: 3

destination

El campo de destino del JSON analizado

Parent JSON node

Longitud máxima: 128

Profundidad máxima de clave anidada: 3

Ejemplo

Supongamos que un evento de registro ingerido tiene este aspecto:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

Entonces, si tenemos este procesador ParseJSON:


[
   {
        "parseJSON": {
            "destination": "new_key"
        }
   }
]

El evento de registro transformado sería el siguiente.


{
    "new_key": {
        "outer_key": {
            "inner_key": "inner_value"
        }
    }
}

grok

Utilice el procesador grok para analizar y estructurar datos no estructurados mediante la coincidencia de patrones. Este procesador también puede extraer campos de los mensajes de registro.

Campo Descripción ¿Obligatorio? Predeterminado/a Límites Notas

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites	Notas
origen	Ruta del campo al que se va a aplicar la coincidencia de Grok	No	`@message`	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
match	El patrón de grok que coincide con el evento de registro	Sí		Longitud máxima: 512 Patrones de corte máximos: 20 Algunos tipos de patrones grok tienen límites de uso individuales. Se puede usar cualquier combinación de los siguientes patrones hasta cinco veces: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE} Los patrones grok no admiten conversiones de tipos. Para los patrones de formato de registro comunes (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG SYSLOG5424), solo se admite incluir los patrones DATA, GREEDYDATA o GREEDYDATA_MULTILINE después del patrón de registro común.	Consulta todos los patrones Grok compatibles

origen

Ruta del campo al que se va a aplicar la coincidencia de Grok

@message

Longitud máxima: 128

Profundidad máxima de clave anidada: 3

match

El patrón de grok que coincide con el evento de registro

Sí

Longitud máxima: 512

Patrones de corte máximos: 20

Algunos tipos de patrones grok tienen límites de uso individuales. Se puede usar cualquier combinación de los siguientes patrones hasta cinco veces: {URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA_MULTILINE}

Los patrones grok no admiten conversiones de tipos.

Para los patrones de formato de registro comunes (APACHE_ACCESS_LOG, NGINX_ACCESS_LOG SYSLOG5424), solo se admite incluir los patrones DATA, GREEDYDATA o GREEDYDATA_MULTILINE después del patrón de registro común.

Consulta todos los patrones Grok compatibles

Estructura de un patrón Grok

Esta es la estructura del patrón grok compatible:


%{PATTERN_NAME:FIELD_NAME}

PATTERN_NAME: hace referencia a una expresión regular predefinida para hacer coincidir un tipo específico de datos. Solo se admiten los patrones grok predefinidos de la lista de patrones grok compatibles. No se permite crear patrones personalizados.
FIELD_NAME: asigna un nombre al valor extraído. FIELD_NAMEes opcional, pero si no especifica este valor, los datos extraídos se eliminarán del evento de registro transformado. Si FIELD_NAME utiliza una notación punteada (p. ej., «parent.child»), se considera una ruta JSON.
Conversión de tipos: no se admiten las conversiones de tipos explícitos. Utilice el TypeConverter procesador para convertir el tipo de datos de cualquier valor extraído por grok.

Para crear expresiones coincidentes más complejas, puede combinar varios patrones grok. Se pueden combinar hasta 20 patrones grok para que coincidan con un evento logarítmico. Por ejemplo, esta combinación de patrones se %{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data} puede usar para extraer campos de una entrada de registro lenta de Redis como esta:

1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"

Ejemplos de grok

Ejemplo 1: Utilice grok para extraer un campo de registros no estructurados

Ejemplo de registro:


293750 server-01.internal-network.local OK "[Thread-000] token generated"

Transformador utilizado:


[
     {
         "grok": {
             "match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
         }
    }
]

Salida:


{
  "version": "293750",
  "hostname": "server-01.internal-network.local",
  "status": "OK",
  "logMsg": "[Thread-000] token generated"
}

Ejemplo de registro:


23/Nov/2024:10:25:15 -0900 172.16.0.1 200

Transformador utilizado:


[
    {
        "grok": {
            "match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
        }
    }
]

Salida:


{
  "timestamp": "23/Nov/2024:10:25:15 -0900",
  "clientip": "172.16.0.1",
  "response_status": "200"
}

Ejemplo 2: Utilice grok en combinación con ParseJSON para extraer campos de un evento de registro JSON

Ejemplo de registro:


{
    "timestamp": "2024-11-23T16:03:12Z",
    "level": "ERROR",
    "logMsg": "GET /page.html HTTP/1.1"
}

Transformador utilizado:


[
     {
        "parseJSON": {}
    },
    {
         "grok": {
            "source": "logMsg",
             "match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
         }
    }
]

Salida:


{
  "timestamp": "2024-11-23T16:03:12Z",
  "level": "ERROR",
  "logMsg": "GET /page.html HTTP/1.1",
  "http_method": "GET",
  "request": "/page.html",
  "http_version": "1.1"
}

Ejemplo 3: patrón Grok con anotación punteada en FIELD_NAME

Ejemplo de registro:


192.168.1.1 GET /index.html?param=value 200 1234

Transformador utilizado:


[
    {
        "grok": {
            "match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
        }
    }
]

Salida:


{
  "client": {
    "ip": "192.168.1.1"
  },
  "method": "GET",
  "request": {
    "uri": "/index.html?param=value"
  },
  "response": {
    "status": "200",
    "bytes": "1234"
  }
}

Patrones de grok compatibles

En las tablas siguientes se enumeran los patrones que admite el grok procesador.

Patrones de crecimiento generales

Patrón de grok	Descripción	Límite máximo de patrones	Ejemplo
NOMBRE DE USUARIO O USUARIO	Coincide con uno o más caracteres que pueden incluir letras minúsculas (a-z), letras mayúsculas (A-Z), dígitos (0-9), puntos (.), guiones bajos (_) o guiones (-)	20	Entrada: `user123.name-TEST` Patrón: `%{USERNAME:name}` Salida: `{"name": "user123.name-TEST"}`
INT	Coincide con un signo más o menos opcional seguido de uno o más dígitos.	20	Entrada: `-456` Patrón: `%{INT:num}` Salida: `{"num": "-456"}`
BASE10 NUM	Coincide con un número entero o un número de punto flotante con signo y coma decimal opcionales	20	Entrada: `-0.67` Patrón: `%{BASE10NUM:num}` Salida: `{"num": "-0.67"}`
BASE16NUM	Hace coincidir los números decimales y hexadecimales con un signo opcional (+ o -) y un prefijo 0x opcional	20	Entrada: `+0xA1B2` Patrón: `%{BASE16NUM:num}` Salida: `{"num": "+0xA1B2"}`
PUNTO	Coincide con números enteros positivos sin ceros a la izquierda, compuestos por uno o más dígitos (del 1 al 9 seguido del 0 al 9)	20	Entrada: `123` Patrón: `%{POSINT:num}` Salida: `{"num": "123"}`
NO NEGLIGENTE	Coincide con cualquier número entero (formado por uno o más dígitos del 0 al 9), incluido el cero y los números con ceros a la izquierda.	20	Entrada: `007` Patrón: `%{NONNEGINT:num}` Salida: `{"num": "007"}`
PALABRA	Coincide con palabras completas compuestas por uno o más caracteres verbales (\ w), incluidas letras, dígitos y guiones bajos	20	Entrada: `user_123` Patrón: `%{WORD:user}` Salida: `{"user": "user_123"}`
NO ESPACIO	Coincide con uno o más caracteres que no son espacios en blanco.	5	Entrada: `hello_world123` Patrón: `%{NOTSPACE:msg}` Salida: `{"msg": "hello_world123"}`
SPACE	Coincide con cero o más caracteres de espacio en blanco.	5	Entrada: `" "` Patrón: `%{SPACE:extra}` Salida: `{"extra": " "}`
DATA	Coincide con cualquier carácter (excepto la línea nueva) cero o más veces, no es codicioso.	5	Entrada: `abc def ghi` Patrón: `%{DATA:x} %{DATA:y}` Salida: `{"x": "abc", "y": "def ghi"}`
DATOS CODICIOSOS	Coincide con cualquier carácter (excepto la línea nueva) cero o más veces, es codicioso.	5	Entrada: `abc def ghi` Patrón: `%{GREEDYDATA:x} %{GREEDYDATA:y}` Salida: `{"x": "abc def", "y": "ghi"}`
GREEDYDATA_MULTILINE	Coincide con cualquier carácter (incluida la línea nueva) cero o más veces, es codicioso.	1	Input: `abc` `def` `ghi` Patrón: `%{GREEDYDATA_MULTILINE:data}` Salida: `{"data": "abc\ndef\nghi"}`
CADENA ENTRECOMILLADA	Hace coincidir las cadenas entre comillas (comillas simples o dobles) con caracteres de escape.	20	Entrada: `"Hello, world!"` Patrón: `%{QUOTEDSTRING:msg}` Salida: `{"msg": "Hello, world!"}`
UUID	Coincide con un formato UUID estándar: 8 caracteres hexadecimales, seguidos de tres grupos de 4 caracteres hexadecimales y termina con 12 caracteres hexadecimales, todos separados por guiones.	20	Entrada: `550e8400-e29b-41d4-a716-446655440000` Patrón: `%{UUID:id}` Salida: `{"id": "550e8400-e29b-41d4-a716-446655440000"}`
URNA	Coincide con la sintaxis URN (nombre uniforme de recurso).	20	Entrada: `urn:isbn:0451450523` Patrón: `%{URN:urn}` Salida: `{"urn": "urn:isbn:0451450523"}`

AWS patrones de grok

Patrón Descripción Límite máximo de patrones Ejemplo

Patrón	Descripción	Límite máximo de patrones	Ejemplo
ARN	Hace coincidir los nombres de los recursos de AWS Amazon (ARNs) y captura la partición (`awsaws-cn`, o`aws-us-gov`), el servicio, la región, el ID de cuenta y hasta 5 identificadores jerárquicos de recursos separados por barras diagonales. No coincidirá con la información ARNs que falte entre dos puntos.	5	Entrada: `arn:aws:iam:us-east-1:123456789012:user/johndoe` Patrón: `%{ARN:arn}` Salida: `{"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}`

ARN

Hace coincidir los nombres de los recursos de AWS Amazon (ARNs) y captura la partición (awsaws-cn, oaws-us-gov), el servicio, la región, el ID de cuenta y hasta 5 identificadores jerárquicos de recursos separados por barras diagonales. No coincidirá con la información ARNs que falte entre dos puntos.

Entrada: arn:aws:iam:us-east-1:123456789012:user/johndoe

Patrón: %{ARN:arn}

Salida: {"arn": "arn:aws:iam:us-east-1:123456789012:user/johndoe"}

Patrones de ruptura de redes

Patrón Grok	Descripción	Límite máximo de patrones	Ejemplo
CISCOMAC	Coincide con una dirección MAC en formato hexadecimal 4-4-4.	20	Entrada: `0123.4567.89AB` Patrón: `%{CISCOMAC:MacAddress}` Salida: `{"MacAddress": "0123.4567.89AB"}`
WINDOWS/MAC	Coincide con una dirección MAC en formato hexadecimal con guiones	20	Entrada: `01-23-45-67-89-AB` Patrón: `%{WINDOWSMAC:MacAddress}` Salida: `{"MacAddress": "01-23-45-67-89-AB"}`
COMMONMAC	Hace coincidir una dirección MAC en formato hexadecimal con dos puntos.	20	Entrada: `01:23:45:67:89:AB` Patrón: `%{COMMONMAC:MacAddress}` Salida: `{"MacAddress": "01:23:45:67:89:AB"}`
MAC	Coincide con uno de los patrones grok de CISCOMAC, WINDOWSMAC o COMMONMAC	20	Entrada: `01:23:45:67:89:AB` Patrón: `%{MAC:m1}` Salida: `{"m1":"01:23:45:67:89:AB"}`
IPV6	Coincide con IPv6 las direcciones, incluidos los formularios comprimidos y las direcciones IPv4 mapeadas IPv6 .	5	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Patrón: `%{IPV6:ip}` Salida: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
IPV4	Coincide con una IPv4 dirección.	20	Entrada: `192.168.0.1` Patrón: `%{IPV4:ip}` Salida: `{"ip": "192.168.0.1"}`
IP	Coincide con IPv6 las direcciones admitidas por% {IPv6} o con IPv4 las direcciones admitidas por% {IPv4}	5	Entrada: `192.168.0.1` Patrón: `%{IP:ip}` Salida: `{"ip": "192.168.0.1"}`
HOSTNAME o HOST	Coincide con los nombres de dominio, incluidos los subdominios	5	Entrada: `server-01.internal-network.local` Patrón: `%{HOST:host}` Salida: `{"host": "server-01.internal-network.local"}`
IP O HOST	Coincide con un nombre de host o una dirección IP	5	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Patrón: `%{IPORHOST:ip}` Salida: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
HOSTPORT	Coincide con una dirección IP o un nombre de host, tal como lo admite el patrón% {IPORHOST} seguido de dos puntos y un número de puerto, y captura el puerto como «PORT» en el resultado.	5	Entrada: `192.168.1.1:8080` Patrón: `%{HOSTPORT:ip}` Salida: `{"ip":"192.168.1.1:8080","PORT":"8080"}`
URIHOST	Coincide con una dirección IP o un nombre de host, tal como lo admite el patrón% {IPORHOST}, seguido opcionalmente de dos puntos y un número de puerto, capturando el puerto como «puerto» si está presente.	5	Entrada: `example.com:443 10.0.0.1` Patrón: `%{URIHOST:host} %{URIHOST:ip}` Salida: `{"host":"example.com:443","port":"443","ip":"10.0.0.1"}`

Patrones de rotura de rutas

Patrón Grok	Descripción	Límite máximo de patrones	Ejemplo
RUTA UNIX	Coincide con las rutas URL y puede incluir parámetros de consulta.	20	Entrada: `/search?q=regex` Patrón: `%{UNIXPATH:path}` Salida: `{"path":"/search?q=regex"}`
WINPATH	Coincide con las rutas de archivos de Windows.	5	Entrada: `C:\Users\John\Documents\file.txt` Patrón: `%{WINPATH:path}` Salida: `{"path": "C:\\Users\\John\\Documents\\file.txt"}`
PATH	Coincide con la URL o las rutas de los archivos de Windows	5	Entrada: `/search?q=regex` Patrón: `%{PATH:path}` Salida: `{"path":"/search?q=regex"}`
TTY	Coincide con las rutas de los dispositivos Unix para terminales y pseudoterminales.	20	Entrada: `/dev/tty1` Patrón: `%{TTY:path}` Salida: `{"path":"/dev/tty1"}`
URIPROTO	Coincide con las letras, seguidas opcionalmente por un carácter más (+) y letras adicionales o caracteres más (+)	20	Entrada: `web+transformer` Patrón: `%{URIPROTO:protocol}` Salida: `{"protocol":"web+transformer"}`
URIPATA	Coincide con el componente de ruta de un URI	20	Entrada: `/category/sub-category/product_name` Patrón: `%{URIPATH:path}` Salida: `{"path":"/category/sub-category/product_name"}`
URIPARAM	Coincide con los parámetros de consulta URL	5	Entrada: `?param1=value1&param2=value2` Patrón: `%{URIPARAM:url}` Salida: `{"url":"?param1=value1&param2=value2"}`
URIPATHPARAM	Coincide con una ruta URI seguida, opcionalmente, de parámetros de consulta	5	Entrada: `/category/sub-category/product?id=12345&color=red` Patrón: `%{URIPATHPARAM:path}` Salida: `{"path":"/category/sub-category/product?id=12345&color=red"}`
URI	Coincide con un URI completo	5	Entrada: `https://user:password@example.com/path/to/resource?param1=value1&param2=value2` Patrón: `%{URI:uri}` Salida: `{"path":"https://user:password@example.com/path/to/resource?param1=value1&param2=value2"}`

Patrones de registro de fecha y hora

Patrón de grok	Descripción	Límite máximo de patrones	Ejemplo
MONTH	Hace coincidir los nombres de los meses completos o abreviados en inglés como palabras completas	20	Entrada: `Jan` Patrón: `%{MONTH:month}` Salida: `{"month":"Jan"}` Entrada: `January` Patrón: `%{MONTH:month}` Salida: `{"month":"January"}`
NÚMERO DE MES	Coincide con los números de los meses del 1 al 12, con el cero inicial opcional para los meses de un solo dígito.	20	Entrada: `5` Patrón: `%{MONTHNUM:month}` Salida: `{"month":"5"}` Entrada: `05` Patrón: `%{MONTHNUM:month}` Salida: `{"month":"05"}`
MONTHNUM2	Coincide con números mensuales de dos dígitos del 01 al 12.	20	Entrada: `05` Patrón: `%{MONTHNUM2:month}` Salida: `{"month":"05"}`
MES/DÍA	Coincide con el día del mes del 1 al 31, con el cero inicial opcional.	20	Entrada: `31` Patrón: `%{MONTHDAY:monthDay}` Salida: `{"monthDay":"31"}`
YEAR	Coincide con el año en dos o cuatro dígitos	20	Entrada: `2024` Patrón: `%{YEAR:year}` Salida: `{"year":"2024"}` Entrada: `24` Patrón: `%{YEAR:year}` Salida: `{"year":"24"}`
DAY	Coincide con los nombres de los días completos o abreviados.	20	Entrada: `Tuesday` Patrón: `%{DAY:day}` Salida: `{"day":"Tuesday"}`
HOUR	Coincide con la hora en formato de 24 horas con un cero (0) 0-23 a la izquierda opcional.	20	Entrada: `22` Patrón: `%{HOUR:hour}` Salida: `{"hour":"22"}`
MINUTE	Minutos de partidos (00-59).	20	Entrada: `59` Patrón: `%{MINUTE:min}` Salida: `{"min":"59"}`
SECOND	Coincide con un número que representa los segundos (0) 0-60, seguido opcionalmente de un punto decimal o dos puntos y uno o más dígitos para las fracciones de minutos	20	Entrada: `3` Patrón: `%{SECOND:second}` Salida: `{"second":"3"}` Entrada: `30.5` Patrón: `%{SECOND:minSec}` Salida: `{"minSec":"30.5"}` Entrada: `30:5` Patrón: `%{SECOND:minSec}` Salida: `{"minSec":"30:5"}`
TIME	Coincide con un formato de hora con horas, minutos y segundos en el formato (H) H:mm :( s) s. Los segundos incluyen los segundos intercalares (0) 0-60.	20	Entrada: `09:45:32` Patrón: `%{TIME:time}` Salida: `{"time":"09:45:32"}`
DATE_US	Coincide con una fecha con el formato de (M) M/ (d) d/ (yy) yy o (M) M- (d) d- (yy) yy.	20	Entrada: `11/23/2024` Patrón: `%{DATE_US:date}` Salida: `{"date":"11/23/2024"}` Entrada: `1-01-24` Patrón: `%{DATE_US:date}` Salida: `{"date":"1-01-24"}`
DATE_EU	Coincide con la fecha en el formato de (d) d/ (M) M/ (yy) yy, (d) d- (M) M- (yy) yy o (d) d. (M) M. (yy) yy.	20	Entrada: `23/11/2024` Patrón: `%{DATE_EU:date}` Salida: `{"date":"23/11/2024"}` Entrada: `1.01.24` Patrón: `%{DATE_EU:date}` Salida: `{"date":"1.01.24"}`
ISO8601_TIMEZONE	Coincide con el desplazamiento UTC «Z» o el desplazamiento de zona horaria con dos puntos opcionales en el formato [+-] (H) H (:) mm.	20	Entrada: `+05:30` Patrón: `%{ISO8601_TIMEZONE:tz}` Salida: `{"tz":"+05:30"}` Entrada: `-530` Patrón: `%{ISO8601_TIMEZONE:tz}` Salida: `{"tz":"-530"}` Entrada: `Z` Patrón: `%{ISO8601_TIMEZONE:tz}` Salida: `{"tz":"Z"}`
ISO8601_SECOND	Coincide con un número que representa los segundos (0) 0-60, seguido opcionalmente por un punto decimal o dos puntos y uno o más dígitos para fracciones de segundo	20	Entrada: `60` Patrón: `%{ISO8601_SECOND:second}` Salida: `{"second":"60"}`
TIMESTAMP_ 01 ISO86	Coincide con el formato de fecha y hora ISO86 01 (yy) yy- (M) M- (d) dT (H) H:mm :mm :( (s) s) (Z\| [+-] (H) H:mm) con segundos y zona horaria opcionales.	20	Entrada: `2023-05-15T14:30:00+05:30` Patrón: `%{TIMESTAMP_ISO8601:timestamp}` Salida: `{"timestamp":"2023-05-15T14:30:00+05:30"}` Entrada: `23-5-1T1:25+5:30` Patrón: `%{TIMESTAMP_ISO8601:timestamp}` Salida: `{"timestamp":"23-5-1T1:25+5:30"}` Entrada: `23-5-1T1:25Z` Patrón: `%{TIMESTAMP_ISO8601:timestamp}` Salida: `{"timestamp":"23-5-1T1:25Z"}`
DATE	Coincide con una fecha en formato estadounidense con% {DATE_US} o en formato UE con% {DATE_EU}	20	Entrada: `11/29/2024` Patrón: `%{DATE:date}` Salida: `{"date":"11/29/2024"}` Entrada: `29.11.2024` Patrón: `%{DATE:date}` Salida: `{"date":"29.11.2024"}`
MARCA DE FECHA	Coincide con el patrón% {DATE} seguido del patrón% {TIME}, separado por un espacio o un guión.	20	Entrada: `29-11-2024 14:30:00` Patrón: `%{DATESTAMP:dateTime}` Salida: `{"dateTime":"29-11-2024 14:30:00"}`
TZ	Coincide con las abreviaturas de zonas horarias habituales (PST, PDT, MST, MDT, CST CDT, EST, EDT, UTC).	20	Entrada: `PDT` Patrón: `%{TZ:tz}` Salida: `{"tz":"PDT"}`
DATESTAMP_ RFC822	Coincide con la fecha y la hora en el formato: Día MonthName (D) D (YY) YY (H) H:mm :( s) s Zona horaria	20	Entrada: `Monday Jan 5 23 1:30:00 CDT` Patrón: `%{DATESTAMP_RFC822:dateTime}` Salida: `{"dateTime":"Monday Jan 5 23 1:30:00 CDT"}` Entrada: `Mon January 15 2023 14:30:00 PST` Patrón: `%{DATESTAMP_RFC822:dateTime}` Salida: `{"dateTime":"Mon January 15 2023 14:30:00 PST"}`
DATESTAMP_ RFC2822	RFC2822 Coincide con el formato de fecha y hora: Día, (d) d MonthName (yy) yy (H) H:mm :( s) s Z\| [+-] (H) H:mm	20	Entrada: `Mon, 15 May 2023 14:30:00 +0530` Patrón: `%{DATESTAMP_RFC2822:dateTime}` Salida: `{"dateTime":"Mon, 15 May 2023 14:30:00 +0530"}` Entrada: `Monday, 15 Jan 23 14:30:00 Z` Patrón: `%{DATESTAMP_RFC2822:dateTime}` Salida: `{"dateTime":"Monday, 15 Jan 23 14:30:00 Z"}`
DATESTAMP_OTHER	Coincide con la fecha y la hora en el formato: Día MonthName (d) d (H) H:mm :( s) s Zona horaria (yy) yy	20	Entrada: `Mon May 15 14:30:00 PST 2023` Patrón: `%{DATESTAMP_OTHER:dateTime}` Salida: `{"dateTime":"Mon May 15 14:30:00 PST 2023"}`
DATESTAMP_EVENTLOG	Coincide con el formato compacto de fecha y hora sin separadores: (yy) yMm (d) d (H) Hmm (s) s	20	Entrada: `20230515143000` Patrón: `%{DATESTAMP_EVENTLOG:dateTime}` Salida: `{"dateTime":"20230515143000"}`

Patrones de surcos largos

Patrón Grok	Descripción	Límite máximo de patrones	Ejemplo
NIVEL DE REGISTRO	Coincide con los niveles de registro estándar en diferentes mayúsculas y abreviaturas, incluidas las siguientes:`Alert/ALERT`,,`Trace/TRACE`,`Debug/DEBUG`,`Notice/NOTICE`,,`Info/INFO`,`Warn/Warning/WARN/WARNING`, `Err/Error/ERR/ERROR` `Crit/Critical/CRIT/CRITICAL` `Fatal/FATAL` `Severe/SEVERE` `Emerg/Emergency/EMERG/EMERGENCY`	20	Entrada: `INFO` Patrón: `%{LOGLEVEL:logLevel}` Salida: `{"logLevel":"INFO"}`
HTTP://DATE	Coincide con el formato de fecha y hora que se utiliza con frecuencia en los archivos de registro. Formato: (d) MonthName d/ (yy) yy :( H) H:mm :( s) s Zona horaria: coincide con los nombres de los meses en inglés completos o abreviados (ejemplo MonthName: «enero» o «enero») Zona horaria: coincide con el patrón% {INT} grok	20	Entrada: `23/Nov/2024:14:30:00 +0640` Patrón: `%{HTTPDATE:date}` Salida: `{"date":"23/Nov/2024:14:30:00 +0640"}`
SYSLOGTIMESTAMP	Coincide con el formato de fecha con MonthName (d) d (H) H:mm :( s) s: Coincide con los nombres de los meses completos o abreviados en inglés (por ejemplo MonthName: «enero» o «enero»)	20	Entrada: `Nov 29 14:30:00` Patrón: `%{SYSLOGTIMESTAMP:dateTime}` Salida: `{"dateTime":"Nov 29 14:30:00"}`
PROGRAMA	Coincide con el nombre de un programa compuesto por una cadena de letras, dígitos, puntos, guiones bajos, barras diagonales, signos porcentuales y guiones.	20	Entrada: `user.profile/settings-page` Patrón: `%{PROG:program}` Salida: `{"program":"user.profile/settings-page"}`
SYSLOGPROG	Coincide con el patrón grok de PROG seguido opcionalmente de un identificador de proceso entre corchetes.	20	Entrada: `user.profile/settings-page[1234]` Patrón: `%{SYSLOGPROG:programWithId}` Salida: `{"programWithId":"user.profile/settings-page[1234]","program":"user.profile/settings-page","pid":"1234"}`
SYSLOGHOST	Coincide con un patrón% {HOST} o% {IP}	5	Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Patrón: `%{SYSLOGHOST:ip}` Salida: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}`
SERVICIO SYSLOG	Coincide con la prioridad de syslog en formato decimal. El valor debe estar entre corchetes angulares (<>).	20	Entrada: `<13.6>` Patrón: `%{SYSLOGFACILITY:syslog}` Salida: `{"syslog":"<13.6>","facility":"13","priority":"6"}`

Patrones de caída de troncos comunes

Puede utilizar patrones grok personalizados y predefinidos para que coincidan con los formatos de registro de Apache, NGINX y Syslog Protocol (RFC 5424). Al usar estos patrones específicos, deben ser los primeros patrones de la configuración coincidente y ningún otro patrón puede precederlos. Además, solo puede seguirlos con exactamente un dato. Patrón GREEDYDATA o GREEDYDATA_MULTILINE.

Patrón de Grok	Descripción	Límite máximo de patrones
APACHE_ACCESS_LOG	Concuerda con los registros de acceso de Apache	1
NGINX_ACCESS_LOG	Coincide con los registros de acceso de NGINX	1
SYSLOG5424	Coincide con los registros del protocolo Syslog (RFC 5424)	1

A continuación se muestran ejemplos válidos y no válidos del uso de estos patrones de formato de registro comunes.


"%{NGINX_ACCESS_LOG} %{DATA}" // Valid
"%{SYSLOG5424}%{DATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{GREEDYDATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{SYSLOG5424}" // Invalid (multiple common log patterns used)
"%{NGINX_ACCESS_LOG} %{NUMBER:num}" // Invalid (Only GREEDYDATA and DATA patterns are supported with common log patterns)
"%{GREEDYDATA:logMsg} %{SYSLOG5424}" // Invalid (GREEDYDATA and DATA patterns are supported only after common log patterns)

Ejemplos de formatos de registro comunes

Ejemplo de registro de Apache

Ejemplo de registro:


127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234

Transformador:


[
     {
        "grok": {
            "match": "%{APACHE_ACCESS_LOG}"
        }
    }
]

Salida:


{
    "request": "/page.html",
    "http_method": "GET",
    "status_code": 200,
    "http_version": "1.1",
    "response_size": 1234,
    "remote_host": "127.0.0.1",
    "timestamp": "2023-08-03T12:34:56Z"
}

Ejemplo de registro de NGINX

Ejemplo de registro:


192.168.1.100 - Foo [03/Aug/2023:12:34:56 +0000] "GET /account/login.html HTTP/1.1" 200 42 "https://www.amazon.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36"

Transformador:


[
     {
        "grok": {
            "match": "%{NGINX_ACCESS_LOG}"
        }
    }
]

Salida:


{
    "request": "/account/login.html",
    "referrer": "https://www.amazon.com/",
    "agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
    "http_method": "GET",
    "status_code": 200,
    "auth_user": "Foo",
    "http_version": "1.1",
    "response_size": 42,
    "remote_host": "192.168.1.100",
    "timestamp": "2023-08-03T12:34:56Z"
}

Ejemplo de registro del protocolo Syslog (RFC 5424)

Ejemplo de registro:


<165>1 2003-10-11T22:14:15.003Z mymachine.example.com evntslog - ID47 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"][examplePriority@32473 class="high"]

Transformador:


[
     {
        "grok": {
            "match": "%{SYSLOG5424}"
        }
    }
]

Salida:


{
  "pri": 165,
  "version": 1,
  "timestamp": "2003-10-11T22:14:15.003Z",
  "hostname": "mymachine.example.com",
  "app": "evntslog",
  "msg_id": "ID47",
  "structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
  "message": "[examplePriority@32473 class=\"high\"]"
}

Analizar a OCSF

El procesador ParseToOCSF convierte los registros al formato Open Cybersecurity Schema Framework (OCSF).

El @message contenido original no se modifica, las nuevas claves se añaden al mensaje.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
eventSource	El servicio o proceso que produce el registro de eventos que se convertirán con este procesador. Los valores válidos son los siguientes: `CloudTrail`para CloudTrail registrar eventos de administración, eventos de datos de Lambda o eventos de datos de Amazon S3. CloudTrail CloudTrail `Route53Resolver`para los registros de consultas de Route 53 Resolver. `VPCFlow`para los registros de flujo de Amazon VPC. `EKSAudit`para los registros de auditoría de Amazon EKS. `AWSWAF`para AWS WAF registros.	Sí	-	-
Versión OCSF	La versión del esquema OCSF que se utilizará para los eventos de registro transformados. Actualmente, el único valor admitido es `V1.1`	Sí	`V1.1`	-

Ejemplo

El siguiente ejemplo transforma los registros de flujo de Amazon VPC al formato OCSF.


[
 "parseToOCSF": {
   eventSource: "VPCFlow",
   version: "V1.1" 
 }
]

csv

El procesador csv analiza los valores separados por comas (CSV) de los eventos del registro en columnas.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
origen	Ruta al campo del evento de registro que se analizará	No	`@message`	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
delimiter	El carácter utilizado para separar cada columna del evento de registro de valores original separado por comas	No	`,`	Longitud máxima: 1
Citar personaje	Carácter utilizado como calificador de texto para una sola columna de datos	No	`"`	Longitud máxima: 1
columns	Lista de nombres que se utilizarán en las columnas del evento de registro transformado.	No	`[column_1, column_2 ...]`	Número máximo de columnas CSV: 100 Longitud máxima: 128 Profundidad máxima de claves anidadas: 3

Ejemplo

Supongamos que parte de un evento de registro ingerido tiene este aspecto:


'Akua Mansa',28,'New York, USA'

Supongamos que utilizamos solo el procesador csv:


[
   "csv": {
      "delimiter": ",",
      "quoteCharacter": ":""
   }
]

El evento de registro transformado sería el siguiente.


{
  "column_1": "Akua Mansa",
  "column_2": "28",
  "column_3": "New York: USA"
}

parseKeyValue

Utilice el parseKeyValueprocesador para analizar un campo específico en pares clave-valor. Puede personalizar el procesador para analizar la información del campo con las siguientes opciones.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
origen	Ruta al campo del registro del evento que se analizará	No	`@message`	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
destination	El campo de destino en el que se van a colocar los pares clave-valor extraídos	No		Longitud máxima: 128
Delimitador de campo	La cadena delimitadora de campo que se utiliza entre los pares clave-valor en el registro de eventos original	No	`&`	Longitud máxima: 128
keyValueDelimiter	La cadena delimitadora que se utilizará entre la clave y el valor de cada par del evento de registro transformado	No	`=`	Longitud máxima: 128
nonMatchValue	Un valor para insertar en el campo de valores del resultado cuando un par clave-valor no se divide correctamente.	No		Longitud máxima: 128
keyPrefix	Si desea añadir un prefijo a todas las claves transformadas, especifíquelo aquí.	No		Longitud máxima: 128
overwriteIfExists	Si se debe sobrescribir el valor si la clave de destino ya existe	No	`false`

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


key1:value1!key2:value2!key3:value3!key4

Supongamos que utilizamos la siguiente configuración de procesador:


[
    {
        "parseKeyValue": {
            "destination": "new_key",
            "fieldDelimiter": "!",
            "keyValueDelimiter": ":",
            "nonMatchValue": "defaultValue",
            "keyPrefix": "parsed_"
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "new_key": {
    "parsed_key1": "value1",
    "parsed_key2": "value2",
    "parsed_key3": "value3",
    "parsed_key4": "defaultValue"
  }
}

Procesadores integrados para los AWS registros vendidos

ParseWAF

Utilice este procesador para analizar los registros AWS WAF vendidos. Toma el contenido httpRequest.headers y crea claves JSON a partir de cada nombre de encabezado, con el valor correspondiente. También hace lo mismo paralabels. Estas transformaciones pueden facilitar mucho la consulta de AWS WAF los registros. Para obtener más información sobre el formato de AWS WAF registro, consulte Ejemplos de registro para el tráfico de ACL web.

Este procesador solo acepta @message como entrada.

importante

Si utiliza este procesador, debe ser el primer procesador del transformador.

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": [],
  "httpRequest": {
    "clientIp": "1.1.1.1",
    "country": "AU",
    "headers": [
      { "name": "Host", "value": "localhost:1989" },
      { "name": "User-Agent", "value": "curl/7.61.1" },
      { "name": "Accept", "value": "*/*" },
      { "name": "x-stm-test", "value": "10 AND 1=1" }
    ],
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": [{ "name": "value" }]
}

La configuración del procesador es la siguiente:


[
    {
        "parseWAF": {}
    }
]

El evento de registro transformado sería el siguiente.


{
  "httpRequest": {
    "headers": {
      "Host": "localhost:1989",
      "User-Agent": "curl/7.61.1",
      "Accept": "*/*",
      "x-stm-test": "10 AND 1=1"
    },
    "clientIp": "1.1.1.1",
    "country": "AU",
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": { "name": "value" },
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": []
}

ParsePostgres

Utilice este procesador para analizar los registros Amazon RDS for PostgreSQL vendidos, extraer campos y convertirlos al formato JSON. Para obtener más información sobre el formato de registro de RDS para PostgreSQL, consulte Archivos de registro de bases de datos de RDS para PostgreSQL.

Este procesador solo acepta como entrada. @message

importante

Si utiliza este procesador, debe ser el primer procesador del transformador.

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8

La configuración del procesador es la siguiente:


[
    {
        "parsePostgres": {}
    }
]

El evento de registro transformado sería el siguiente.


{
  "logTime": "2019-03-10 03:54:59 UTC",
  "srcIp": "10.0.0.123(52834)",
  "userName": "postgres",
  "dbName": "logtestdb",
  "processId": "20175",
  "logLevel": "ERROR"
}

ParseCloudFront

Utilice este procesador para analizar los registros Amazon CloudFront vendidos, extraer campos y convertirlos al formato JSON. Los valores de los campos codificados se decodifican. Los valores enteros y dobles se tratan como tales. Para obtener más información sobre el formato de Amazon CloudFront registro, consulte Configurar y usar registros estándar (registros de acceso).

Este procesador solo acepta @message como entrada.

importante

Si utiliza este procesador, debe ser el primer procesador del transformador.

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


2019-12-04  21:02:31   LAX1   392    192.0.2.24    GET    d111111abcdef8.cloudfront.net  /index.html    200    -  Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36  -  -  Hit    SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==   d111111abcdef8.cloudfront.net  https  23 0.001  -  TLSv1.2    ECDHE-RSA-AES128-GCM-SHA256    Hit    HTTP/2.0   -  -  11040  0.001  Hit    text/html  78 -  -

La configuración del procesador es la siguiente:


[
    {
        "parseCloudfront": {}
    }
]

El evento de registro transformado sería el siguiente.


{
  "date": "2019-12-04",
  "time": "21:02:31",
  "x-edge-location": "LAX1",
  "sc-bytes": 392,
  "c-ip": "192.0.2.24",
  "cs-method": "GET",
  "cs(Host)": "d111111abcdef8.cloudfront.net",
  "cs-uri-stem": "/index.html",
  "sc-status": 200,
  "cs(Referer)": "-",
  "cs(User-Agent)": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36",
  "cs-uri-query": "-",
  "cs(Cookie)": "-",
  "x-edge-result-type": "Hit",
  "x-edge-request-id": "SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==",
  "x-host-header": "d111111abcdef8.cloudfront.net",
  "cs-protocol": "https",
  "cs-bytes": 23,
  "time-taken": 0.001,
  "x-forwarded-for": "-",
  "ssl-protocol": "TLSv1.2",
  "ssl-cipher": "ECDHE-RSA-AES128-GCM-SHA256",
  "x-edge-response-result-type": "Hit",
  "cs-protocol-version": "HTTP/2.0",
  "fle-status": "-",
  "fle-encrypted-fields": "-",
  "c-port": 11040,
  "time-to-first-byte": 0.001,
  "x-edge-detailed-result-type": "Hit",
  "sc-content-type": "text/html",
  "sc-content-len": 78,
  "sc-range-start": "-",
  "sc-range-end": "-"
}

ParseRoute53

Utilice este procesador para analizar los registros Amazon Route 53 Public Data Plane vendidos, extraer campos y convertirlos a formato JSON. Los valores de los campos codificados se decodifican. Este procesador no admite Amazon Route 53 Resolver registros.

Este procesador solo acepta @message como entrada.

importante

Si utiliza este procesador, debe ser el primer procesador del transformador.

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


1.0 2017-12-13T08:15:50.235Z Z123412341234 example.com AAAA NOERROR TCP IAD12 192.0.2.0 198.51.100.0/24

La configuración del procesador es la siguiente:


[
    {
        "parseRoute53": {}
    }
]

El evento de registro transformado sería el siguiente.


{
  "version": 1.0,
  "queryTimestamp": "2017-12-13T08:15:50.235Z",
  "hostZoneId": "Z123412341234",
  "queryName": "example.com",
  "queryType": "AAAA",
  "responseCode": "NOERROR",
  "protocol": "TCP",
  "edgeLocation": "IAD12",
  "resolverIp": "192.0.2.0",
  "ednsClientSubnet": "198.51.100.0/24"
}

ParseVPC

Utilice este procesador para analizar los registros vendidos de Amazon VPC, extraer campos y convertirlos a formato JSON. Los valores de los campos codificados se decodifican.

Este procesador solo los acepta @message como entrada.

importante

Si utiliza este procesador, debe ser el primer procesador del transformador.

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


2 123456789010 eni-abc123de 192.0.2.0 192.0.2.24 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK

La configuración del procesador es la siguiente:


[
    {
        "parseVPC": {}
    }
]

El evento de registro transformado sería el siguiente.


{
  "version": 2,
  "accountId": "123456789010",
  "interfaceId": "eni-abc123de",
  "srcAddr": "192.0.2.0",
  "dstAddr": "192.0.2.24",
  "srcPort": 20641,
  "dstPort": 22,
  "protocol": 6,
  "packets": 20,
  "bytes": 4249,
  "start": 1418530010,
  "end": 1418530070,
  "action": "ACCEPT",
  "logStatus": "OK"
}

Procesadores que mutan cadenas

lowerCaseString

El lowerCaseString procesador convierte una cadena a su versión en minúsculas.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
Con Keys	Una lista de claves para convertir a minúsculas	Sí		Número máximo de entradas: 10

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "INNER_VALUE"
    }
}

La configuración del transformador es la siguiente, que se usa lowerCaseString conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "lowerCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": "inner_value"
  }
}

upperCaseString

El upperCaseString procesador convierte una cadena a su versión en mayúsculas.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
Con Keys	Una lista de teclas para convertir a mayúsculas	Sí		Número máximo de entradas: 10

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

La configuración del transformador es la siguiente, que se usa upperCaseString conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "upperCaseString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": "INNER_VALUE"
  }
}

SplitString

El splitString procesador es un tipo de procesador de mutaciones de cadenas que divide un campo en una matriz utilizando un carácter delimitador.

Campo	Descripción	¿Obligatorio?	Límites
entries	Matriz de entradas. Cada elemento de la matriz debe contener `source` `delimiter` campos.	Sí	Número máximo de entradas: 10
origen	La clave del valor del campo que se va a dividir	Sí	Longitud máxima: 128
delimiter	La cadena delimitadora en la que se divide el valor del campo	Sí	Longitud máxima: 128

Ejemplo 1

Tomemos el siguiente ejemplo de registro de eventos:


[
    {
        "parseJSON": {}
    },
    {
        "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": "_"
                }
            ]
        }
    }
]

La configuración del transformador es la siguiente, que se usa splitString conparseJSON:


[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": "_"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": [
      "inner",
      "value"
    ]
  }
}

Ejemplo 2

El delimitador en el que se divide la cadena puede tener varios caracteres.

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "item1, item2, item3"
    }
}

La configuración del transformador es la siguiente:


[
     {
        "parseJSON": {}
    },
    {
         "splitString": {
            "entries": [
                {
                    "source": "outer_key.inner_key",
                    "delimiter": ", "
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": [
      "item1",
      "item2",
      "item3"
    ]
  }
}

SubstituteString

El substituteString procesador es un tipo de procesador de mutaciones de cadenas que compara el valor de una clave con el de una expresión regular y reemplaza todas las coincidencias por una cadena de reemplazo.

Campo	Descripción	¿Obligatorio?	Límites
entries	Matriz de entradas. Cada elemento de la matriz debe contener `sourcefrom`, y `to` campos.	Sí	Número máximo de entradas: 10
origen	La clave del campo que se va a modificar	Sí	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
desde	La cadena de expresión regular que se va a reemplazar. Los caracteres de expresiones regulares especiales, como [y], deben estar separados por\\ cuando se usan comillas dobles y con\ cuando se usan comillas simples o cuando se configuran desde. AWS Management Console Para obtener más información, consulte Class Pattern en el sitio web de Oracle. Puede incluir un patrón `(...)` para crear un grupo de captura numerado y crear grupos de captura con `(?P<group_name>...)` nombre a los que se pueda hacer referencia en el `to` campo.	Sí	Longitud máxima: 128
a	Se puede utilizar la cadena que se sustituirá por cada coincidencia de `from` referencias inversas con los grupos de captura. Use la forma $n para grupos numerados, como, por ejemplo, `$1` y `${group_name}` para grupos con nombre, como $. `{my_group}` >	Sí	Longitud máxima: 128 Número máximo de referencias inversas: 10 Número máximo de retroreferencias duplicadas: 2

Ejemplo 1

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key1": "[]",
        "inner_key2": "123-345-567",
        "inner_key3": "A cat takes a catnap."
    }
}

La configuración del transformador es la siguiente, que se usa substituteString conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "\\[\\]",
                    "to": "value1"
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "[0-9]{3}-[0-9]{3}-[0-9]{3}",
                    "to": "xxx-xxx-xxx"            
                },
                {
                    "source": "outer_key.inner_key3",
                    "from": "cat",
                    "to": "dog"            
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key1": "value1",
    "inner_key2": "xxx-xxx-xxx",
    "inner_key3": "A dog takes a dognap."
  }
}

Ejemplo 2

Tomemos el siguiente ejemplo de evento de registro:


{
    "outer_key": {
        "inner_key1": "Tom, Dick, and Harry",
        "inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
    }
}

La configuración del transformador es la siguiente, que se usa substituteString conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "substituteString": {
            "entries": [
                {
                    "source": "outer_key.inner_key1",
                    "from": "(\w+), (\w+), and (\w+)",
                    "to": "$1 and $3"            
                },
                {
                    "source": "outer_key.inner_key2",
                    "from": "^arn:aws:sts::(?P<account_id>\\d{12}):assumed-role/(?P<role_name>[\\w+=,.@-]+)/(?P<role_session_name>[\\w+=,.@-]+)$",
                    "to": "${account_id}:${role_name}:${role_session_name}"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key1": "Tom and Harry",
    "inner_key2": "123456789012:MyImportantRole:MySession"
  }
}

TrimString

El trimString procesador elimina los espacios en blanco del principio y del final de una clave.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
Con Keys	Una lista de teclas para recortar	Sí		Número máximo de entradas: 10

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "   inner_value  "
    }
}

La configuración del transformador es la siguiente, que se usa trimString conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "trimString": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": "inner_value"
  }
}

Procesadores JSON mutan

Añadir claves

Utilice el addKeys procesador para añadir nuevos pares clave-valor al evento de registro.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
entries	Matriz de entradas. Cada elemento de la matriz puede contener `keyvalue`, y `overwriteIfExists` campos.	Sí		Número máximo de entradas: 5
clave	La clave de la nueva entrada que se va a añadir	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
valor	El valor de la nueva entrada que se va a añadir	Sí		Longitud máxima: 256
overwriteIfExists	Si lo establece en`true`, el valor existente se sobrescribe si `key` ya existe en el evento. El valor predeterminado es `false`.	No	false	Sin límite

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

La configuración del transformador es la siguiente, que se usa addKeys conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "addKeys": {
            "entries": [
                {
                    "source": "outer_key.new_key",
                    "value": "new_value"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": "inner_value",
    "new_key": "new_value"
  }
}

DeleteKeys

Utilice el deleteKeys procesador para eliminar campos de un evento de registro. Estos campos pueden incluir pares clave-valor.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
Con claves	La lista de claves que se van a eliminar.	Sí	Sin límite	Número máximo de entradas: 5

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

La configuración del transformador es la siguiente, que se usa deleteKeys conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "deleteKeys": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {}
}

MoveKeys

Utilice el moveKeys procesador para mover una clave de un campo a otro.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
entries	Matriz de entradas. Cada elemento de la matriz puede contener `sourcetarget`, y `overwriteIfExists` campos.	Sí		Número máximo de entradas: 5
origen	La clave para moverse	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
destino	La clave para pasar a	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
overwriteIfExists	Si lo estableces en`true`, el valor existente se sobrescribe si `key` ya existe en el evento. El valor predeterminado es `false`.	No	false	Sin límite

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key1": {
        "inner_key1": "inner_value1"
    },
    "outer_key2": {
        "inner_key2": "inner_value2"
    }
}

La configuración del transformador es la siguiente, que se usa moveKeys conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "moveKeys": {
            "entries": [
                {
                    "source": "outer_key1.inner_key1",
                    "target": "outer_key2"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key1": {},
  "outer_key2": {
    "inner_key2": "inner_value2",
    "inner_key1": "inner_value1"
  }
}

Cambie el nombre de las claves

Utilice el renameKeys procesador para cambiar el nombre de las claves de un evento de registro.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
entries	Matriz de entradas. Cada elemento de la matriz puede contener `keytarget`, y `overwriteIfExists` campos.	Sí	Sin límite	Número máximo de entradas: 5
clave	La clave para cambiar el nombre	Sí	Sin límite	Longitud máxima: 128
destino	El nombre de la nueva clave	Sí	Sin límite	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
overwriteIfExists	Si lo estableces en`true`, el valor existente se sobrescribe si `key` ya existe en el evento. El valor predeterminado es `false`.	No	false	Sin límite

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

La configuración del transformador es la siguiente, que se usa renameKeys conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "renameKeys": {
            "entries": [
                {
                    "key": "outer_key",
                    "target": "new_key"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "new_key": {
    "inner_key": "inner_value"
  }
}

CopyValue

Utilice el copyValue procesador para copiar los valores de un evento de registro. También puede utilizar este procesador para añadir metadatos al registro de eventos, copiando los valores de las siguientes claves de metadatos en el registro de eventos:@logGroupName,@logGroupStream,@accountId,@regionName. Esto se ilustra en el siguiente ejemplo.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
entries	Matriz de entradas. Cada elemento de la matriz puede contener `sourcetarget`, y `overwriteIfExists` campos.	Sí		Número máximo de entradas: 5
origen	La clave para copiar	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
destino	La clave a la que se debe copiar el valor	Sí	Sin límite	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
overwriteIfExists	Si lo estableces en`true`, el valor existente se sobrescribe si `key` ya existe en el evento. El valor predeterminado es `false`.	No	false	Sin límite

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": {
        "inner_key": "inner_value"
    }
}

La configuración del transformador es la siguiente, que se usa copyValue conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "copyValue": {
            "entries": [
                {
                    "source": "outer_key.new_key",
                    "target": "new_key"
                },
                {
                    "source": "@logGroupName",
                    "target": "log_group_name"
                },
                {
                    "source": "@logGroupStream",
                    "target": "log_group_stream"
                },
                {
                    "source": "@accountId",
                    "target": "account_id"
                },
                {
                    "source": "@regionName",
                    "target": "region_name"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
  "outer_key": {
    "inner_key": "inner_value"
  },
  "new_key": "inner_value",
  "log_group_name": "myLogGroupName",
  "log_group_stream": "myLogStreamName",
  "account_id": "012345678912",
  "region_name": "us-east-1"
}

listToMap

El listToMap procesador toma una lista de objetos que contienen campos clave y los convierte en un mapa de claves de destino.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
origen	La clave es ProcessingEvent con una lista de objetos que se convertirán en un mapa	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
clave	La clave de los campos que se van a extraer como claves en el mapa generado	Sí		Longitud máxima: 128
Clave de valor	Si se especifica, los valores que especifique en este parámetro se extraerán de los `source` objetos y se colocarán en los valores del mapa generado. De lo contrario, los objetos originales de la lista de fuentes se incluirán en los valores del mapa generado.	No		Longitud máxima: 128
destino	La clave del campo que contendrá el mapa generado	No	Nodo Raíz	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
flatten	Un valor booleano para indicar si la lista se aplanará en elementos individuales o si los valores del mapa generado serán listas. De forma predeterminada, los valores de las claves coincidentes se representarán en una matriz. `flattentrue`Configúrelo en para convertir la matriz en un valor único en función del valor de`flattenedElement`.	No	false
Elemento aplanado	Si lo establece`true`, `flatten` utilícelo `flattenedElement` para especificar qué elemento, `first` o bien`last`, desea conservar.	Obligatorio cuando `flatten` está establecido en `true`		El valor solo puede ser `first` o `last`

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ]
}

Transformador para el caso de uso 1: flatten es false


[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": false
        }
    }
]

El evento de registro transformado sería el siguiente.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": [
        "val-a"
    ],
    "b": [
        "val-b1",
        "val-b2"
    ],
    "c": [
        "val-c"
    ]
}

Transformador para el caso de uso 2: flatten es true y flattenedElement es first


[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": true,
            "flattenedElement": "first"
        }
    }
]

El evento de registro transformado sería el siguiente.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b1",
    "c": "val-c"
}

Transformador para el caso de uso 3: flatten es true y flattenedElement es last


[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": true,
            "flattenedElement": "last"
        }
    }
]

El evento de registro transformado sería el siguiente.


{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b2",
    "c": "val-c"
}

Procesadores convertidores de tipos de datos

Convertidor de tipos

Utilice el typeConverter procesador para convertir un tipo de valor asociado a la clave especificada en el tipo especificado. Es un procesador de conversión que cambia los tipos de los campos especificados. Los valores se pueden convertir en uno de los siguientes tipos de datos:integer, ydouble. string boolean

Campo Descripción ¿Obligatorio? Predeterminado/a Límites

Campo	Descripción	¿Obligatorio?	Límites
entries	Matriz de entradas. Cada elemento de la matriz debe contener `key` `type` campos.	Sí	Número máximo de entradas: 10
clave	La clave con el valor que se va a convertir a un tipo diferente	Sí	Longitud máxima: 128 Profundidad máxima de clave anidada: 3
type	El tipo al que se va a convertir. Los valores válidos son `integer`, `double`, `string` y `boolean`.	Sí

entries

Matriz de entradas. Cada elemento de la matriz debe contener key type campos.

Sí

Número máximo de entradas: 10

clave

La clave con el valor que se va a convertir a un tipo diferente

Sí

Longitud máxima: 128

Profundidad máxima de clave anidada: 3

type

El tipo al que se va a convertir. Los valores válidos son integer, double, string y boolean.

Sí

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{
    "name": "value",
    "status": "200"
}

La configuración del transformador es la siguiente, que se usa typeConverter conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "typeConverter": {
            "entries": [
                {
                    "key": "status",
                    "type": "integer"
                }
            ]
        }
    }
]

El evento de registro transformado sería el siguiente.


{
    "name": "value",
    "status": 200
}

DateTimeConverter

Utilice el datetimeConverter procesador para convertir una cadena de fecha y hora en el formato que especifique.

Campo	Descripción	¿Obligatorio?	Predeterminado/a	Límites
origen	La clave a la que se aplica la conversión de fecha.	Sí		Número máximo de entradas: 10
Patrones de coincidencias	Una lista de patrones para compararlos con los del campo `source`	Sí		Número máximo de entradas: 5
destino	El campo JSON en el que se almacenará el resultado.	Sí		Longitud máxima: 128 Profundidad máxima de clave anidada: 3
Formato de destino	El formato de fecha y hora que se utilizará para los datos convertidos en el campo de destino.	No	`yyyy-MM-dd'T'HH:mm:ss.SSS'Z`	Longitud máxima: 64
Zona horaria de origen	La zona horaria del campo de origen. Para obtener una lista de los valores posibles, consulte los identificadores y compensaciones de zona compatibles con Java.	No	UTC	Longitud mínima: 1
Zona horaria objetivo	La zona horaria del campo de destino. Para obtener una lista de los valores posibles, consulte los identificadores y compensaciones de zona compatibles con Java.	No	UTC	Longitud mínima: 1
locale	La configuración regional del campo de origen. Para obtener una lista de valores posibles, consulte el método Locale getAvailableLocales () en Java con ejemplos.	Sí		Longitud mínima:1

Ejemplo

Tomemos el siguiente ejemplo de registro de eventos:


{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}

La configuración del transformador es la siguiente, que se usa dateTimeConverter conparseJSON:


[
    {
        "parseJSON": {}
    },
    {
        "dateTimeConverter": {
            "source": "german_datetime",
            "target": "target_1",
            "locale": "de",
            "matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
            "sourceTimezone": "Europe/Berlin",
            "targetTimezone": "America/New_York",
            "targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
        }
    }
]

El evento de registro transformado sería el siguiente.


{
    "german_datetime": "Samstag 05. Dezember 1998 11:00:00",
    "target_1": "1998-12-05T17:00:00 MEZ"
}

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Elimine un log-group-level transformador

Métricas y errores de transformación