addKeys deleteKeys moveKeys renameKeys copyValue listToMap

Processadores de mutação do JSON

Esta seção contém informações sobre os processadores de mutação JSON que você pode usar com um transformador de eventos de log.

Sumário

addKeys

Use o processador addKeys para adicionar novos pares de chave-valor ao evento de logs.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter os campos `key`, `value` e `overwriteIfExists`.	Sim		Máximo de entradas: 5
key	A chave da nova entrada a ser adicionada	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
valor	O valor da nova entrada a ser adicionada	Sim		Tamanho máximo = 256
overwriteIfExists	Se você definir isso como `true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false	Sem limite

Exemplo

Observe o exemplo de evento de logs a seguir:


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

A configuração do transformador é esta, usando addKeys com parseJSON:


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

O evento de logs transformado seria o seguinte.


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

deleteKeys

Use o processador deleteKeys para excluir campos de um evento de logs. Esses campos podem incluir pares de chave-valor.

Campo	Description	Obrigatório?	Padrão	Limites
withKeys	Uma lista de chaves a serem excluídas.	Sim	Sem limite	Máximo de entradas: 5

Exemplo

Observe o exemplo de evento de logs a seguir:


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

A configuração do transformador é esta, usando deleteKeys com parseJSON:


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

O evento de logs transformado seria o seguinte.


{
  "outer_key": {}
}

moveKeys

Use o processador moveKeys para mover uma chave de um campo para outro.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter os campos `source`, `target` e `overwriteIfExists`.	Sim		Máximo de entradas: 5
origem	A chave a ser movida	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
target	A chave a ser movida para	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como `true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false	Sem limite

Exemplo

Observe o exemplo de evento de logs a seguir:


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

A configuração do transformador é esta, usando moveKeys com parseJSON:


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

O evento de logs transformado seria o seguinte.


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

renameKeys

Use o processador renameKeys para renomear as chaves em um evento de logs.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter os campos `key`, `target` e `overwriteIfExists`.	Sim	Sem limite	Máximo de entradas: 5
key	A chave a ser renomeada	Sim	Sem limite	Tamanho máximo: 128
target	O novo nome da chave	Sim	Sem limite	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como `true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false	Sem limite

Exemplo

Observe o exemplo de evento de logs a seguir:


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

A configuração do transformador é esta, usando renameKeys com parseJSON:


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

O evento de logs transformado seria o seguinte.


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

copyValue

Use o processador copyValue para copiar valores em um evento de logs. Você também pode usar esse processador para adicionar metadados aos eventos de logs, copiando os valores das seguintes chaves de metadados nos eventos de logs:@logGroupName, @logGroupStream, @accountId, @regionName. Isso é ilustrado no exemplo a seguir.

Campo	Description	Obrigatório?	Padrão	Limites
entries	Matriz de entradas. Cada item na matriz pode conter os campos `source`, `target` e `overwriteIfExists`.	Sim		Máximo de entradas: 5
origem	A chave a ser copiada	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
target	A chave cujo valor será copiado para	Sim	Sem limite	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
overwriteIfExists	Se você definir isso como `true`, o valor existente será substituído se `key` já existir no evento. O valor padrão é `false`.	Não	false	Sem limite

Exemplo

Observe o exemplo de evento de logs a seguir:


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

A configuração do transformador é esta, usando copyValue com 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"
                }
            ]
        }
    }
]

O evento de logs transformado seria o seguinte.


{
  "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

O processador listToMap pega uma lista de objetos que contêm campos-chave e os converte em um mapa das chaves de destino.

Campo	Description	Obrigatório?	Padrão	Limites
origem	A chave no ProcessingEvent com uma lista de objetos que serão convertidos em um mapa	Sim		Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
key	A chave dos campos a serem extraídos como chaves no mapa gerado	Sim		Tamanho máximo: 128
valueKey	Se isso for especificado, os valores especificados nesse parâmetro serão extraídos dos objetos `source` e colocados nos valores do mapa gerado. Caso contrário, os objetos originais na lista da origem serão colocados nos valores do mapa gerado.	Não		Tamanho máximo: 128
target	A chave do campo que conterá o mapa gerado	Não	Nó raiz	Tamanho máximo: 128 Profundidade máxima de chave aninhada: 3
nivelamento	Um valor booleano para indicar se a lista será nivelada em itens únicos ou se os valores no mapa gerado serão listas. Por padrão, os valores das chaves correspondentes serão representados em uma matriz. Defina `flatten` como `true` para converter a matriz em um único valor com base no valor de `flattenedElement`.	Não	false
flattenedElement	Se você definir `flatten` como `true`, use `flattenedElement` para especificar qual elemento manter, `first` ou `last`.	Obrigatório quando `flatten` estiver definido como `true`		O valor pode ser somente `first` ou `last`

Exemplo

Observe o exemplo de evento de logs a seguir:


{
    "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 caso de uso 1: flatten é false


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

O evento de logs transformado seria o seguinte.


{
    "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 o caso de uso 2: flatten é true e flattenedElement é first


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

O evento de logs transformado seria o seguinte.


{
    "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 o caso de uso 3: flatten é true e flattenedElement é last


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

O evento de logs transformado seria o seguinte.


{
    "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"
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Processadores de mutação de string

Processadores de conversão de tipos de dados