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.

Contenido

• addKeys

• deleteKeys

• moveKeys

• renameKeys

• copyValue

• listToMap

addKeys

Utilice el procesador addKeys para agregar nuevos pares clave-valor al evento de registro.

Campo	Description (Descripción)	¿Obligatorio?	Predeterminado	Límites de las s
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": [
                {
                    "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 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 de las s
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 de las s
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 de las s
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 de las s
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": [
                {
                    "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 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 de las s
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"
}