Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Transformación de los registros durante la ingestión
Con la transformación y el enriquecimiento de los registros, puede normalizar todos sus registros en un formato coherente y rico en contexto al momento de incorporarlos a los registros. CloudWatch [Puede añadir estructura a sus registros mediante plantillas preconfiguradas para AWS servicios comunes, como AWS WAF Amazon Route 53, o crear transformadores personalizados con analizadores nativos, como Grok.](CloudWatch-Logs-Transformation-Configurable.md#CloudWatch-Logs-Transformation-Grok) También se puede cambiar el nombre de los atributos existentes y añadir metadatos adicionales a sus registros, como el ID de cuenta y la región.
La transformación de los registros ayuda a simplificar y acortar las consultas de registro en todas las aplicaciones y a simplificar la creación de alertas en los registros. Esta función proporciona la transformación de los tipos de registro más comunes con plantillas de out-of-the-box transformación para las principales fuentes de AWS registro, como los registros de flujo de VPC, Route 53 y. Amazon RDS for PostgreSQL Se pueden usar plantillas de transformación preconfiguradas o crear transformadores personalizados que se adapten a sus necesidades.
La transformación de registros ayuda a administrar los registros emitidos desde diversas fuentes, que varían considerablemente en cuanto al formato y los nombres de los atributos.
Tras crear un transformador, los eventos de registro ingeridos se convierten y almacenan en un formato estándar. Puede aprovechar estos registros transformados para acelerar su experiencia de análisis con las siguientes características:
+ [Índices de campo](CloudWatchLogs-Field-Indexing.md)
+ [CloudWatch Registra los campos detectados por Insights](CWL_AnalyzeLogData-discoverable-fields.md)
+ Flexibilidad con las alarmas mediante [filtros métricos](MonitoringLogData.md)
+ Reenvío mediante [filtros de suscripción](Subscriptions.md)
+ Creación de datos métricos a partir de eventos de registro con [Información de colaboradores](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContributorInsights.html), donde se puede elegir que la regla de Información de colaboradores evalúe los eventos de registro antes o después de su transformación.
Las transformaciones solo se producen durante la ingesta de registros. No se pueden transformar los eventos de registro que ya se hayan ingerido. Las transformaciones no son reversibles. Tanto los registros originales como los transformados se almacenan en CloudWatch registros con la misma política de retención. La capacidad de transformación y enriquecimiento de registros está incluida en el precio actual de adquisición de la clase de registro Estándar. Los costos de almacenamiento de registros se basarán en el tamaño del registro después de la transformación, que puede superar el volumen de registro original.
**importante**
Una vez transformados los eventos de registro, debe utilizar las consultas de CloudWatch Logs Insights para ver las versiones transformadas de los registros. [ FilterLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FilterLogEvents.html)Las acciones [ GetLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_GetLogEvents.html)y devuelven solo las versiones originales de los eventos del registro, antes de que se transformaran.
**importante**
A pesar de que un solo evento de registro PutLogEvents permite hasta 1 MB, la transformación de registros solo puede gestionar eventos de registro de un tamaño inferior a 512 KB. Cualquier evento de registro que supere los 512 kb fallará en la transformación y emitirá un error. El tamaño total de aún PutLogEvents puede superar los 512 kb.
Además de transformarlos en diferentes formatos, también se pueden enriquecer sus registros con un contexto adicional, como el ID de cuenta, la región y la palabra clave. Se extraen del nombre del grupo de registros y de las palabras clave estáticas.
La transformación de registros ayuda con los registros emitidos desde diversas fuentes, que varían considerablemente en cuanto al formato y los nombres de los atributos.
La transformación y el enriquecimiento de registro solo son compatibles con los grupos de registro de la clase de registro Estándar.
Se pueden crear transformadores para grupos de registro individuales y, también se pueden crear transformadores de cuenta que se apliquen a todos o a varios grupos de registro de su cuenta. Si un grupo de registros tiene un transformador a nivel de grupo de registros, ese transformador anula cualquier transformador a nivel de cuenta que, de otro modo, se aplicaría a ese grupo de registros.
**Topics**
+ [Creación y administración de transformadores de registro](CloudWatch-Logs-Transformation-Create.md)
+ [Procesadores configurables tipo analizador](CloudWatch-Logs-Transformation-Configurable.md)
+ [Procesadores integrados para registros vendidos AWS](CloudWatch-Logs-Transformation-BuiltIn.md)
+ [Procesadores de mutación de cadena](CloudWatch-Logs-Transformation-StringMutate.md)
+ [Procesadores de mutación JSON](CloudWatch-Logs-Transformation-JSONMutate.md)
+ [Procesadores convertidores de tipos de datos](CloudWatch-Logs-Transformation-Datatype.md)
+ [Métricas y errores de transformación](Transformation-Errors-Metrics.md)
# Creación y administración de transformadores de registro
Un transformador de registro incluye uno o más *procesadores* que están juntos en una canalización lógica. Cada procesador se aplica a un evento de registro, uno tras otro, en el orden en que aparecen en la configuración del transformador.
Algunos procesadores son del tipo *analizador*. Cada transformador debe tener al menos un analizador y el primer procesador de un transformador debe ser un analizador.
Algunos de los analizadores están integrados y configurados para un determinado tipo de registro ofrecido de AWS .
Otros tipos de procesadores son los mutadores de cadena, los mutadores JSON y los procesadores de datos.
Se pueden crear transformadores para grupos de registro individuales y, también, se pueden crear transformadores a nivel de cuenta que se apliquen a todos o a varios grupos de registro de su cuenta. Si un grupo de registros tiene un transformador a nivel de grupo de registros, ese transformador anula cualquier transformador a nivel de cuenta que, de otro modo, se aplicaría a ese grupo de registros. Puede tener hasta 20 transformadores a nivel de cuenta en una región de su cuenta.
Al crear un transformador, se deben seguir estas directrices:
+ Si incluye un analizador preconfigurado para un tipo de AWS registros vendidos, debe ser el primer procesador de la lista del transformador. Se puede incluir solo un procesador de este tipo en un transformador.
+ Se puede incluir solo un procesador `grok` en un transformador.
+ Se debe tener al menos un procesador de tipo analizador en un transformador. Se pueden incluir hasta cinco procesadores de tipo analizador. Este límite de cinco incluye tanto los analizadores integrados como los configurables.
+ Se pueden tener hasta 20 procesadores en un transformador.
+ Solo se puede incluir solo un procesador **addKeys** en un transformador.
+ Se puede incluir solo un procesador **copyValue** en un transformador.
+ Cada transformador puede extraer hasta 200 campos de un evento de registro.
+ Cada evento de registro **DEBE** ser inferior a 512 KB. El tamaño total del registro de eventos aún puede superar los 512 KB.
**Topics**
+ [Creación de una política de transformadores a nivel de cuenta](CloudWatchLogs-Transformer-CreateAccountLevel.md)
+ [Edición o eliminación de una política de transformador a nivel de cuenta](CloudWatchLogs-Transformer-EditAccountLevel.md)
+ [Cree un transformador de log-group-level registros desde cero](CloudWatch-Logs-Transformation-CreateNew.md)
+ [Cree un log-group-level transformador copiando uno existente](CloudWatch-Logs-Transformation-Copy.md)
+ [Edite un log-group-level transformador](CloudWatch-Logs-Transformation-Edit.md)
+ [Eliminar un log-group-level transformador](CloudWatch-Logs-Transformation-Delete.md)
# Creación de una política de transformadores a nivel de cuenta
Se utilizan los pasos de esta sección para crear una política de transformador que se aplique a todos los grupos de registros de la cuenta o a varios grupos de registros que tengan nombres de grupos de registros que comiencen por la misma cadena. Se pueden tener hasta 20 transformadores a nivel de cuenta en una región.
No se pueden crear dos políticas de transformadores en la misma región que usen el mismo prefijo o que contengan un prefijo dentro de otro. Por ejemplo, si se crea una política de transformador para el prefijo de cadena`/aws/lambda`, no se podrá crear otra con ese prefijo `/aws`. Pero se podría tener un transformador para `/aws/lambda` y otro para `/aws/waf`
**Creación de una política de transformadores a nivel de cuenta**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación izquierdo, elija **Configuración** y, a continuación, la pestaña **Registros**.
1. En la sección **Política de transformadores para cuentas**, seleccione **Creación de política de transformadores**.
1. En **Nombre de la política del transformador**, escriba un nombre para la política nueva.
1. En **Selección de grupos de registros**, realice una de las operaciones siguientes:
+ Seleccione **Todos los grupos de registros estándar** para que la política de transformador se aplique a todos los grupos de registros de clase Standard de la cuenta.
+ Elija **Grupos de registros por coincidencia de prefijos** para aplicar la política a un subconjunto de grupos de registros cuyos nombres comiencen por la misma cadena. A continuación, introduzca el prefijo de estos grupos de registros en los **criterios de selección.**
1. En el área **Seleccionar analizadores**, use **Analilzadores** para seleccionar un analizador e incluirlo en su transformador.
Si se trata de un analizador preconfigurado para un tipo de AWS registro vendido, no es necesario que especifique ninguna configuración para él.
Si es un analizador diferente, se debe especificar su configuración. Para obtener más información, consulte la información de ese procesador en [Procesadores configurables tipo analizador](CloudWatch-Logs-Transformation-Configurable.md).
1. Para añadir otro procesador, elija **Seleccionar procesador**. A continuación, seleccione el procesador que desee en el cuadro **Procesador** y rellene los parámetros de configuración.
Recuerde que los procesadores funcionan con los eventos de registro en el orden en que se agreguen al transformador.
1. (Opcional) Para añadir procesadores adicionales, elija **\$1 Procesador** y repita el paso anterior.
1. (Opcional) En cualquier momento, se puede probar el transformador que ha construido hasta ahora a partir de un ejemplo de evento de registro. Para ello, lleve a cabo una de las siguientes acciones en la sección **Vista previa de transformador**:
+ Seleccione hasta cinco grupos de registros en **Seleccionar grupos de registros** y, a continuación, elija **Cargar los últimos eventos de registro**. A continuación, elija **Probar transformador**.
+ Copie los eventos del registro directamente en **Registro de eventos de muestra** y, a continuación, elija **Probar transformador**.
A continuación, aparece la versión transformada del registro.
1. Cuando se hayan terminado de añadir procesadores y esté satisfecho con las pruebas realizadas en los registros de muestra, seleccione **Guardar**.
1. Cuando haya terminado, seleccione **Create (Crear)**.
# Edición o eliminación de una política de transformador a nivel de cuenta
Siga los pasos de esta sección para editar o eliminar una política de transformador a nivel de cuenta.
**Edición o eliminación de una política de transformador a nivel de cuenta**
1. Abra la consola en CloudWatch . [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación izquierdo, elija **Configuración** y, a continuación, la pestaña **Registros**.
1. En la sección **Política de cuenta de transformador**, elija **Administrar**.
1. Seleccione el botón situado junto a la política de transformadores que desee administrar y, a continuación, elija **Editar** o **Eliminar**.
Si se va a editar la política, consulte los pasos 5 a 11 en [Procesadores configurables tipo analizador](CloudWatch-Logs-Transformation-Configurable.md) para ver las opciones.
# Cree un transformador de log-group-level registros desde cero
Sigue estos pasos para crear un log-group-level transformador desde cero.
**Uso de la consola para crear un transformador de registros para un grupo de registro**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros), **Log groups** (Grupos de registro).
1. Seleccione el grupo de registro para el que desea crear un transformador.
1. Elija la pestaña **Transformador**. Es posible que tenga que desplazarse por la lista de pestañas hacia la derecha para verla.
1. Elija **Creación de transformador**.
1. En el cuadro **Elección de un analizador**, seleccione un analizador para incluirlo en su transformador.
Si se trata de un analizador preconfigurado para un tipo de AWS registro vendido, no es necesario que especifique ninguna configuración para él.
Si es un analizador diferente, se debe especificar su configuración. Para obtener más información, consulte la información de ese procesador en [Procesadores configurables tipo analizador](CloudWatch-Logs-Transformation-Configurable.md).
1. Para añadir otro procesador, seleccione **\$1 Añadir procesador**. A continuación, seleccione el procesador que desee en el cuadro **Elección de procesadores** y rellene los parámetros de configuración.
Recuerde que los procesadores funcionan con los eventos de registro en el orden en que se agreguen al transformador.
1. (Opcional) En cualquier momento, se puede probar el transformador que ha construido hasta ahora a partir de un ejemplo de evento de registro. Para ello, haga lo siguiente:
1. En la sección **Vista previa de la transformación**, elija **Carga de registro de muestra** para cargar un evento de registro de muestra del grupo de registros al que pertenece este transformador o pegue un evento de registro en el cuadro de texto.
Elija **Probar transformador**. Aparece la versión transformada del registro.
1. Cuando se hayan terminado de añadir procesadores y esté satisfecho con las pruebas realizadas en los registros de muestra, seleccione **Guardar**.
**Para usar el AWS CLI para crear un transformador de registro desde cero**
+ Utilice el comando `aws logs put-transformer`. Si se utiliza `parseJSON` como primer procesador, debe analizar todo el evento de registro con `@message` como el campo de origen. Tras el análisis inicial de JSON, se pueden manipular campos específicos en los procesadores posteriores. El siguiente es un ejemplo que crea un transformador que incluye los procesadores `parseJSON` y `addKeys`:
```
aws logs put-transformer \
--transformer-config '[{"parseJSON":{"source":"@message"}},{"addKeys":{"entries":[{"key":"metadata.transformed_in","value":"CloudWatchLogs"},{"key":"feature","value":"Transformation"}]}},{"trimString":{"withKeys":["status"]}}]' \
--log-group-identifier my-log-group-name
```
# Cree un log-group-level transformador copiando uno existente
Se puede utilizar la consola para copiar la configuración JSON de un transformador existente. Luego, puede usar ese código para crear un transformador idéntico utilizando el AWS CLI, o puede modificar primero la configuración.
**Creación de un transformador de registro copiando uno existente**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros), **Log groups** (Grupos de registro).
1. Elija el grupo de registro que contiene el transformador que se desea copiar.
1. Seleccione la pestaña **Transformaciones**. Es posible que tenga que desplazarse por la lista de pestañas hacia la derecha para verla.
1. Elija **Administración de transformador**.
1. Elija **Copia de transformador**. De esta forma se copiará el JSON del transformador en el portapeles.
1. Cree un archivo y péguelo en la configuración del transformador. En este ejemplo, llamaremos el archivo `CopiedTransformer.json`.
1. Utilice el AWS CLI para crear un nuevo transformador con esa configuración.
```
aws logs put-transformer --log-group-identifier my-log-group-name \
--transformer-config file://CopiedTransformer.json
```
# Edite un log-group-level transformador
Siga los siguientes pasos para editar un transformador de registro existente.
**Edición de un transformador de registro**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros), **Log groups** (Grupos de registro).
1. Elija el grupo de registro que contiene el transformador que desea editar.
1. Seleccione la pestaña **Transformaciones**. Es posible que tenga que desplazarse por la lista de pestañas hacia la derecha para verla.
1. Elija **Administración de transformador**.
1. En las secciones **Analizadores** y **Procesadores**, realice los cambios que desee.
1. Para añadir otro procesador, seleccione **\$1 Añadir procesador**. A continuación, seleccione el procesador que desee en el cuadro **Procesador** y rellene los parámetros de configuración.
Recuerde que los procesadores funcionan con los eventos de registro en el orden en que se agreguen al transformador.
1. (Opcional) En cualquier momento, se puede probar el transformador que ha construido hasta ahora a partir de un ejemplo de evento de registro. Para ello, haga lo siguiente:
1. En la sección **Vista previa de la transformación**, elija **Carga de registro de muestra** para cargar un evento de registro de muestra del grupo de registros al que pertenece este transformador o pegue un evento de registro en el cuadro de texto.
Elija **Probar transformación**. Aparece la versión transformada del registro.
1. Cuando se hayan terminado de añadir procesadores y esté satisfecho con las pruebas realizadas en los registros de muestra, seleccione **Guardar**.
# Eliminar un log-group-level transformador
Siga estos pasos para eliminar un transformador de registro.
**Eliminación de un transformador de registros**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros), **Log groups** (Grupos de registro).
1. Elija el grupo de registro que contiene el transformador que desea editar.
1. Seleccione la pestaña **Transformaciones**. Es posible que tenga que desplazarse por la lista de pestañas hacia la derecha para verla.
1. Elija **Eliminar**.
1. En el cuadro de confirmación, elija **Política de eliminación**.
# Procesadores configurables tipo analizador
Esta sección contiene información sobre los procesadores analizadores de datos configurables que puede usar en un transformador de eventos de registro.
**Contents**
+ [parseJSON](#CloudWatch-Logs-Transformation-parseJSON)
+ [grok](#CloudWatch-Logs-Transformation-Grok)
+ [Ejemplos de grok](#Grok-Examples)
+ [Ejemplo 1: Utilice grok para extraer un campo de registros no estructurados](#Grok-Example1)
+ [Ejemplo 2: Utilice grok en combinación con parseJSON para extraer campos de un evento de registro JSON](#Grok-Example3)
+ [Ejemplo 3: patrón grok con anotación punteada en FIELD\$1NAME](#Grok-Example4)
+ [Patrones grok admitidos](#Grok-Patterns)
+ [Ejemplos de formatos de registro](#Common-Log-Examples)
+ [Ejemplo de registro de Apache](#Apache-Log-Example)
+ [Ejemplo de registro de NGINX](#NGINX-Log-Example)
+ [Ejemplo de registro del protocolo Syslog (RFC 5424)](#syslog5424-Log-Example)
+ [csv](#CloudWatch-Logs-Transformation-csv)
+ [parseKeyValue](#CloudWatch-Logs-Transformation-parseKeyValue)
## parseJSON
El procesador **parseJSON** analiza los eventos del registro JSON e inserta los pares clave-valor JSON extraídos en el destino. Si no se especifica un destino, el procesador coloca el par clave-valor debajo del nodo raíz. Si se utiliza `parseJSON` como primer procesador, debe analizar todo el evento de registro con `@message` como el campo de origen. Tras el análisis inicial de JSON, se pueden manipular campos específicos en los procesadores posteriores.
El contenido `@message` original no se modifica, las nuevas claves se añaden al mensaje.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | 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 de JSON analizado | No | `Parent JSON node` | Longitud máxima: 128 Profundidad máxima de clave anidada: 3 |
**Ejemplo**
Supongamos que un evento de registro ingerido tiene un aspecto similar al siguiente:
```
{
"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 los datos no estructurados mediante la coincidencia de patrones. Este procesador también puede extraer campos de los mensajes de registro.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | 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 |
| emparejar | El patrón grok que coincide con el evento de registro | Sí | | Longitud máxima: 512 Patrones grok 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: \$1URI, URIPARAM, URIPATHPARAM, SPACE, DATA, GREEDYDATA, GREEDYDATA\$1MULTILINE\$1 Los patrones grok no admiten conversiones de tipos. Para los patrones de formato de registro comunes (APACHE\$1ACCESS\$1LOG, NGINX\$1ACCESS\$1LOG SYSLOG5424), solo se admite incluir los patrones DATA, GREEDYDATA o GREEDYDATA\$1MULTILINE después del patrón de registro común. | [Consulte todos los patrones grok compatibles](#Grok-Patterns) |
**Estructura de un patrón grok**
Esta es la estructura del patrón grok compatible:
```
%{PATTERN_NAME:FIELD_NAME}
```
+ **PATTERN\$1NAME**: hace referencia a una expresión regular predefinida para hacer coincidir un tipo específico de datos. [Solo se admiten los patrones grok predefinidos.](#Grok-Patterns) No se permite crear patrones personalizados.
+ **FIELD\$1NAME**: asigna un nombre al valor extraído. `FIELD_NAME` es 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](CloudWatch-Logs-Transformation-Datatype.md#CloudWatch-Logs-Transformation-typeConverter) 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 de registro. Por ejemplo, esta combinación de patrones `%{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data}` se 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
Registros de ejemplo:
```
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"
}
```
Registros de ejemplo:
```
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
Registros de ejemplo:
```
{
"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\$1NAME
Registros de ejemplo:
```
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 grok admitidos
En las siguientes tablas se enumeran los patrones que admite el procesador `grok`.
**Patrones grok generales**
| Patrón grok | Description (Descripción) | Límite 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 (\$1) o guiones medios (-) | 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"}` |
| BASE10NUM | 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 (\$1 o -) y un prefijo 0x opcional | 20 | Entrada: `+0xA1B2` Patrón: `%{BASE16NUM:num}` Salida: `{"num": "+0xA1B2"}` |
| POSINT | 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"}` |
| NONNEGINT | 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"}` |
| WORD | Coincide con palabras completas compuestas por uno o más caracteres verbales (\$1w), incluidas letras, dígitos y guiones bajos | 20 | Entrada: `user_123` Patrón: `%{WORD:user}` Salida: `{"user": "user_123"}` |
| NOTSPACE | Coincide con uno o más caracteres que no sean espacios en blanco. | 5 | Entrada: `hello_world123` Patrón: `%{NOTSPACE:msg}` Salida: `{"msg": "hello_world123"}` |
| SPACE | Coincide con 0 o más caracteres que son espacios 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"}` |
| GREEDYDATA | 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\$1MULTILINE | 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"}` |
| QUOTEDSTRING | Busca 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 medios. | 20 | Entrada: `550e8400-e29b-41d4-a716-446655440000` Patrón: `%{UUID:id}` Salida: `{"id": "550e8400-e29b-41d4-a716-446655440000"}` |
| URN | 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 | Description (Descripción) | Límite de patrones | Ejemplo |
| --- | --- | --- | --- |
| ARN | Hace coincidir los nombres de los recursos de AWS Amazon (ARNs) y captura la partición (`aws``aws-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"}` |
**Patrones de grok de redes**
| Patrón grok | Description (Descripción) | Límite 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 medios | 20 | Entrada: `01-23-45-67-89-AB` Patrón: `%{WINDOWSMAC:MacAddress}` Salida: `{"MacAddress": "01-23-45-67-89-AB"}` |
| COMMONMAC | Coincide con 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% \$1IPv6\$1 o con IPv4 las direcciones admitidas por% \$1IPv4\$1 | 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"}` |
| IPORHOST | 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 %\$1IPORHOST\$1 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 %\$1IPORHOST\$1, con opción de seguido de dos puntos y un número de puerto, y captura el puerto como “PORT” en el resultado. | 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 grok de rutas**
| Patrón grok | Description (Descripción) | Límite de patrones | Ejemplo |
| --- | --- | --- | --- |
| UNIXPATH | 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 las rutas URL o 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 (\$1) y letras adicionales o caracteres más (\$1) | 20 | Entrada: `web+transformer` Patrón: `%{URIPROTO:protocol}` Salida: `{"protocol":"web+transformer"}` |
| URIPATH | 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 parámetros de consulta de URL | 5 | Entrada: `?param1=value1¶m2=value2` Patrón: `%{URIPARAM:url}` Salida: `{"url":"?param1=value1¶m2=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¶m2=value2` Patrón: `%{URI:uri}` Salida: `{"path":"https://user:password@example.com/path/to/resource?param1=value1¶m2=value2"}` |
**Patrones grok de fecha y hora**
| Patrón grok | Description (Descripción) | Límite 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"}` |
| MONTHNUM | 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 | Coincide con los minutos (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 por una coma 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\$1US | Coincide con una fecha con el formato de (M)M/(d)d/(yy)yy or (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\$1EU | Coincide con la fecha en el formato de (d)d/(M)M/(yy)yy, (d)d-(M)M-(yy)yy, or (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\$1ZONA HORARIA | Coincide con el desplazamiento UTC “Z” o el desplazamiento de zona horaria con dos puntos opcionales en el formato [\$1-] (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\$1SEGUNDO | 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\$1 ISO8601 | Coincide con el formato de ISO8601 fecha y hora (yy) yy- (M) M- (d) dT (H) H:mm :mm :( (s) s) (Z\$1 [\$1-] (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 usando %\$1DATE\$1US\$1 o en formato UE usando %\$1DATE\$1EU\$1 | 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"}` |
| DATESTAMP | Coincide con el patrón %\$1DATE\$1 seguido del patrón %\$1TIME\$1, separado por un espacio o un guion medio. | 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\$1 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\$1 RFC2822 | RFC2822 Coincide con el formato de fecha y hora: Día, (d) d MonthName (yy) yy (H) H:mm :( s) s Z\$1 [\$1-] (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\$1OTHER | 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\$1EVENTLOG | Coincide con el formato compacto de fecha y hora sin separadores: (yy)yyMM(d)d(H)Hmm(s)s | 20 | Entrada: `20230515143000` Patrón: `%{DATESTAMP_EVENTLOG:dateTime}` Salida: `{"dateTime":"20230515143000"}` |
**Patrones grok de registro**
| Patrón grok | Description (Descripción) | Límite de patrones | Ejemplo |
| --- | --- | --- | --- |
| LOGLEVEL | Coincide con los niveles de registros estándar en distintas 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"}` |
| HTTPDATE | 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% \$1INT\$1 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 MonthName: Coincide con los nombres de los meses completos o abreviados en inglés (por ejemplo: «enero» o «enero») | 20 | Entrada: `Nov 29 14:30:00` Patrón: `%{SYSLOGTIMESTAMP:dateTime}` Salida: `{"dateTime":"Nov 29 14:30:00"}` |
| PROG | 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 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 %\$1HOST\$1 o %\$1IP\$1 | 5 | Entrada: `2001:db8:3333:4444:5555:6666:7777:8888` Patrón: `%{SYSLOGHOST:ip}` Salida: `{"ip": "2001:db8:3333:4444:5555:6666:7777:8888"}` |
| SYSLOGFACILITY | 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 grok de registros comunes**
Se pueden 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\$1MULTILINE**.
| Patrón de Grok | Description (Descripción) | Límite de patrones |
| --- | --- | --- |
| APACHE\$1ACCESS\$1LOG | Coincide con los registros de acceso de Apache | 1 |
| NGINX\$1ACCESS\$1LOG | 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
##### Ejemplo de registro de Apache
Registros de ejemplo:
```
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
Registros de ejemplo:
```
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)
Registros de ejemplo:
```
<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\"]"
}
```
## csv
El procesador de **csv** analiza los valores separados por comas (CSV) de los eventos del registro en columnas.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | 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, a menos que el valor sea `\t` o `\s` |
| quoteCharacter | 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 de CSV: 100 Longitud máxima: 128 Profundidad máxima de clave anidada: 3 |
| destination | El campo principal en el que colocar los pares de valores clave transformados | No | `Root node` | Longitud máxima: 128 Profundidad máxima de clave anidada: 3 |
Si `delimiter` se establece en `\t`, se separará cada columna en un carácter de tabulación y `\t` separará cada columna en un solo carácter de espacio.
**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"
}
```
**Ejemplo 2**
Supongamos que un evento de registro ingerido tiene un aspecto similar al siguiente:
```
{
"timestamp": "2024-11-23T16:03:12Z",
"type": "user_data",
"logMsg": "'Akua Mansa':28:'New York: USA'"
}
```
Supongamos que analizamos el evento como JSON, ellos analizan un campo JSON con el procesador **csv** y especifican los nombres de las columnas y el destino:
```
[
{
"parseJSON": {}
},
{
"csv": {
"source": "logMsg",
"delimiter": ":",
"quoteCharacter": "'",
"columns":["name","age","location"],
"destination": "msg"
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"timestamp": "2024-11-23T16:03:12Z",
"logMsg": "'Akua Mansa':28:'New York: USA'",
"type": "user_data",
"msg": {
"name": "Akua Mansa",
"age": "28",
"location": "New York: USA"
}
}
```
## parseKeyValue
Usa el **parseKeyValue**procesador 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 | Description (Descripción) | ¿Obligatorio? | Predeterminado | 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 |
| destination | El campo de destino en el que se van a colocar los pares clave-valor extraídos | No | | Longitud máxima: 128 |
| fieldDelimiter | La cadena delimitadora de campo que se utiliza entre los pares clave-valor en los eventos de registro originales | 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 se 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**
Ejemplo de evento de registro de muestra:
```
key1:value1!key2:value2!key3:value3!key4
```
Supongamos que se utiliza 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 registros vendidos AWS
Esta sección contiene información sobre los procesadores integrados que puede usar con AWS los servicios que venden registros.
**Contents**
+ [parseWAF](#CloudWatch-Logs-Transformation-parseWAF)
+ [parsePostgres](#CloudWatch-Logs-Transformation-parsePostGres)
+ [parseCloudfront](#CloudWatch-Logs-Transformation-parseCloudFront)
+ [parseRoute53](#CloudWatch-Logs-Transformation-parseRoute53)
+ [parseVPC](#CloudWatch-Logs-Transformation-parseVPC)
+ [parseToOCSF](CloudWatch-Logs-Transformation-parseToOCSF.md)
## parseWAF
Utilice este procesador para analizar los registros AWS WAF vendidos. Toma el contenido de cada nombre de encabezado `httpRequest.headers` y crea claves JSON a partir de él, con el valor correspondiente. También hace lo mismo para `labels`. 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](https://docs.aws.amazon.com/waf/latest/developerguide/logging-examples.html).
Este procesador solo acepta `@message` como entrada.
**importante**
Si utiliza este procesador, debe ser el primer procesador del transformador.
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"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 Amazon RDS for PostgreSQL los registros 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](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.Concepts.PostgreSQL.html#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix).
Este procesador solo acepta `@message` como entrada.
**importante**
Si utiliza este procesador, debe ser el primer procesador del transformador.
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
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 Amazon CloudFront registros 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).](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html)
Este procesador solo acepta `@message` como entrada.
**importante**
Si utiliza este procesador, debe ser el primer procesador del transformador.
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
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 Amazon Route 53 Public Data Plane los registros vendidos, extraer campos y convertirlos al 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**
Ejemplo de evento de registro de muestra:
```
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 ofrecidos de Amazon VPC, extraer campos y convertirlos a formato JSON. Los valores de los campos codificados se decodifican.
Este procesador solo acepta `@message` como entrada.
**importante**
Si utiliza este procesador, debe ser el primer procesador del transformador.
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
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"
}
```
# parseToOCSF
El procesador `parseToOCSF` convierte los registros en eventos Open Cybersecurity Schema Framework (OCSF). El OCSF es un estándar abierto que proporciona un esquema común para los datos de seguridad, lo que permite una mejor interoperabilidad y análisis entre diferentes herramientas y plataformas de seguridad.
Este procesador es especialmente útil para los flujos de trabajo de análisis de seguridad en los que es necesario estandarizar los formatos de registro de varios AWS servicios en un esquema coherente para el análisis posterior.
**Parámetros**
`eventSource` (obligatorio)
Especifica el AWS servicio o proceso que produce los eventos de registro que se van a convertir. Los valores válidos son:
+ `CloudTrail`- CloudTrail registros
+ `Route53Resolver`: registros de Route 53 Resolver
+ `VPCFlow`: registros de flujo de Amazon VPC
+ `EKSAudit`: registros de auditoría de Amazon EKS
+ `AWSWAF`- AWS WAF registros
`ocsfVersion` (obligatorio)
Especifica qué versión del esquema OCSF se debe utilizar para los eventos de registro transformados. Versiones compatibles actualmente: `V1.1, V1.5`
`mappingVersion` (opcional)
Especifica la versión del mapeo de transformación de OCSF. Controla la lógica de transformación que se aplica al convertir los registros al formato OCSF. Si no se especifica, utiliza la última versión disponible en el momento de la creación de la política. Las políticas existentes no se actualizan automáticamente cuando se publican nuevas versiones de mapeo. Última versión actual:`v1.5.0`.
**Nota:** No es compatible cuando `ocsfVersion` es`V1.1`.
`source` (opcional)
La ruta al campo del evento de registro que desea analizar. Si se omite, se analiza todo el mensaje de registro.
**Ejemplo**
En el siguiente ejemplo se muestra cómo utilizar `parseToOCSF` para convertir los registros de flujo de VPC al formato OCSF:
```
{
"parseToOCSF": {
"eventSource": "VPCFlow",
"ocsfVersion": "V1.1"
}
}
```
El siguiente ejemplo muestra cómo especificar una versión de mapeo concreta para lograr un comportamiento de transformación coherente:
```
{
"parseToOCSF": {
"eventSource": "CloudTrail",
"ocsfVersion": "V1.5",
"mappingVersion": "v1.5.0"
}
}
```
# Procesadores de mutación de cadena
Esta sección contiene información sobre los procesadores de mutación de cadenas que puede utilizar con un transformador de eventos de registro.
**Contents**
+ [lowerCaseString](#CloudWatch-Logs-Transformation-lowerCaseString)
+ [upperCaseString](#CloudWatch-Logs-Transformation-upperCaseString)
+ [splitString](#CloudWatch-Logs-Transformation-splitString)
+ [substituteString](#CloudWatch-Logs-Transformation-substituteString)
+ [trimString](#CloudWatch-Logs-Transformation-trimString)
## lowerCaseString
El procesador `lowerCaseString` convierte una cadena a su versión en minúsculas.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| withKeys | Una lista de claves para convertir a minúsculas | Sí | | Número máximo de entradas: 10 |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
La configuración del transformador es la siguiente, y utiliza `lowerCaseString` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"lowerCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
## upperCaseString
El procesador `upperCaseString` convierte una cadena a su versión en mayúsculas.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| withKeys | Una lista de claves para convertir a mayúsculas | Sí | | Número máximo de entradas: 10 |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `upperCaseString` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"upperCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
## splitString
El procesador `splitString` es un tipo de procesador de mutaciones de cadenas que divide un campo en una matriz con un carácter delimitador.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz debe contener los campos source y delimiter. | 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**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `splitString` con `parseJSON`:
```
[
{
"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.
Ejemplo de evento de registro de muestra:
```
{
"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 procesador `substituteString` 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 | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz debe contener los campos source, from y to. | 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 sustituirá. Los caracteres de expresiones regulares especiales, como [ y ], deben estar separados por \$1\$1 cuando se usan comillas dobles y con \$1 cuando se usan comillas simples o cuando se configuran desde la Consola de administración de AWS. Para obtener más información, consulte [Class Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html) en el sitio web de Oracle. Se puede concluir un patrón en `(...)` para crear un grupo de captura numerado y crear grupos de captura con el nombre `(?P...)` a los que se pueda hacer referencia en el campo `to`. | Sí | | Longitud máxima: 128 |
| a | Se puede utilizar la cadena que se sustituirá por cada coincidencia de las retroreferencias from con los grupos de captura. Use la forma \$1n para grupos numerados, como, por ejemplo, \$11, y use \$1\$1group\$1name\$1 para grupos con nombre, como \$1\$1my\$1group\$1.> | Sí | | Longitud máxima: 128 Número de retroreferencias: 10 Número máximo de retroreferencias duplicadas: 2 |
**Ejemplo 1**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key1": "[]",
"inner_key2": "123-345-567",
"inner_key3": "A cat takes a catnap."
}
}
```
La configuración del transformador es la siguiente, y utiliza `substituteString` con `parseJSON`:
```
[
{
"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**
Ejemplo de evento de registro de muestra:
```
{
"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, y utiliza `substituteString` con `parseJSON`:
```
[
{
"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\\d{12}):assumed-role/(?P[\\w+=,.@-]+)/(?P[\\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 procesador `trimString` elimina los espacios en blanco desde el principio y el final de una clave.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| withKeys | Una lista de claves que se recortarán | Sí | | Número máximo de entradas: 10 |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": " inner_value "
}
}
```
La configuración del transformador es la siguiente, y utiliza `trimString` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"trimString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
# Procesadores de mutación JSON
Esta sección contiene información sobre los procesadores de mutación JSON que puede usar con un transformador de eventos de registro.
**Contents**
+ [addKeys](#CloudWatch-Logs-Transformation-addKeys)
+ [deleteKeys](#CloudWatch-Logs-Transformation-deleteKeys)
+ [moveKeys](#CloudWatch-Logs-Transformation-moveKeys)
+ [renameKeys](#CloudWatch-Logs-Transformation-renameKeys)
+ [copyValue](#CloudWatch-Logs-Transformation-copyValue)
+ [listToMap](#CloudWatch-Logs-Transformation-listToMap)
## addKeys
Utilice el procesador `addKeys` para agregar nuevos pares clave-valor al evento de registro.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz puede contener los campos key, value y overwriteIfExists. | 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**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `addKeys` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"addKeys": {
"entries": [
{
"key": "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 procesador `deleteKeys` para eliminar los campos de un evento de registro. Estos campos pueden incluir pares clave-valor.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| withKeys | La lista de claves que se eliminarán. | Sí | Sin límite | Número máximo de entradas: 5 |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `deleteKeys` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"deleteKeys": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"outer_key": {}
}
```
## moveKeys
Utilice el procesador `moveKeys` para mover una clave de un campo a otro.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz puede contener los campos source, target y overwriteIfExists. | Sí | | Número máximo de entradas: 5 |
| origen | La clave para mover | Sí | | Longitud máxima: 128 Profundidad máxima de clave anidada: 3 |
| destino | La clave de destino | Sí | | Longitud máxima: 128 Profundidad máxima de clave anidada: 3 |
| 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**
Ejemplo de evento de registro de muestra:
```
{
"outer_key1": {
"inner_key1": "inner_value1"
},
"outer_key2": {
"inner_key2": "inner_value2"
}
}
```
La configuración del transformador es la siguiente, y utiliza `moveKeys` con `parseJSON`:
```
[
{
"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"
}
}
```
## renameKeys
Utilice el procesador `renameKeys` para cambiar el nombre de las claves de un evento de registro.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz puede contener los campos key, target y overwriteIfExists. | Sí | Sin límite | Número máximo de entradas: 5 |
| clave | La clave cuyo nombre debe cambiarse | 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 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**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `renameKeys` con `parseJSON`:
```
[
{
"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 procesador `copyValue` para copiar los valores de un evento de registro. También se puede utilizar este procesador para añadir metadatos a los eventos de registro, mediante la copia de los valores de las siguientes claves de metadatos en los eventos de registro: `@logGroupName`, `@logGroupStream`, `@accountId`, `@regionName`. Esto se ilustra con el siguiente ejemplo.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz puede contener los campos source, target y overwriteIfExists. | 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 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**
Ejemplo de evento de registro de muestra:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
La configuración del transformador es la siguiente, y utiliza `copyValue` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"copyValue": {
"entries": [
{
"key": "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 procesador `listToMap` toma una lista de objetos que contienen campos clave y los convierte en un mapa de claves de destino.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| origen | La clave es ProcessingEvent la 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 |
| valueKey | Si se especifica, los valores que se especifiquen en este parámetro se extraerán de los objetos source y se colocarán en los valores del mapa generado. De lo contrario, los objetos originales de la lista de origen 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. Configure `flatten` en `true` para convertir la matriz en un valor único en función del valor de `flattenedElement`. | No | false | |
| flattenedElement | Si se establece true en flatten, utilice flattenedElement para especificar qué elemento, first o bien last, se desea conservar. | Necesario cuando `flatten` se establece en `true`. | | El valor solo puede ser first o last. |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{
"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
Esta sección contiene información sobre los procesadores convertidores de tipos de datos que puede utilizar con un transformador de eventos de registro.
**Contents**
+ [typeConverter](#CloudWatch-Logs-Transformation-typeConverter)
+ [datetimeConverter](#CloudWatch-Logs-Transformation-datetimeConverter)
## typeConverter
Utilice el procesador `typeConverter` 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`, `double`, `string` y `boolean`.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| entries | Matriz de entradas. Cada elemento de la matriz debe contener los campos key y type. | 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**
Ejemplo de evento de registro de muestra:
```
{
"name": "value",
"status": "200"
}
```
La configuración del transformador es la siguiente, y utiliza `typeConverter` con `parseJSON`:
```
[
{
"parseJSON": {}
},
{
"typeConverter": {
"entries": [
{
"key": "status",
"type": "integer"
}
]
}
}
]
```
El evento de registro transformado sería el siguiente.
```
{
"name": "value",
"status": 200
}
```
## datetimeConverter
Utilice el procesador `datetimeConverter` para convertir una cadena de fecha y hora en el formato que especifique.
| Campo | Description (Descripción) | ¿Obligatorio? | Predeterminado | Límites |
| --- | --- | --- | --- | --- |
| origen | La clave donde aplicar la conversión de fechas. | Sí | | Número máximo de entradas: 10 |
| MatchPattern | Una lista de patrones que se pueden comparar 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 |
| targetFormat | 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 [Java Supported Zone Ids and Offsets](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets). | No | UTC | Longitud mínima: 1 |
| targetTimezone | La zona horaria del campo de destino. Para obtener una lista de los valores posibles, consulte [Java Supported Zone Ids and Offsets](https://howtodoinjava.com/java/date-time/supported-zone-ids-offsets/#3-java-supported-zone-ids-and-offsets). | No | UTC | Longitud mínima: 1 |
| locale | La región del campo de origen. Para obtener una lista de valores posibles, consulte el [método Locale getAvailableLocales () en](https://www.geeksforgeeks.org/locale-getavailablelocales-method-in-java-with-examples/) Java con ejemplos. | Sí | | Longitud mínima: 1 |
**Ejemplo**
Ejemplo de evento de registro de muestra:
```
{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}
```
La configuración del transformador es la siguiente, y utiliza `dateTimeConverter` con `parseJSON`:
```
[
{
"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"
}
```
# Métricas y errores de transformación
CloudWatch Logs publica las métricas de transformación en CloudWatch. Las métricas incluyen `TransformedLogEvents`, `TransformedBytes` y `TransformationErrors`. Para obtener más información, consulte [Métricas y dimensiones del transformador de registro](CloudWatch-Logs-Monitoring-CloudWatch-Metrics.md#CloudWatchLogs-Transformer-Metrics).
Cuando CloudWatch Logs intenta transformar un evento de registro y no lo logra, agrega un campo `@transformationError` del sistema a ese evento de registro. Cuando ejecute una consulta de CloudWatch Logs Insights, verá este campo en todos los eventos de registro en los que se haya producido un error de transformación. Se puede consultar este campo con una consulta como, por ejemplo, `filter ispresent(@transformationError)` para buscar todos los eventos de transformación fallidos.