As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Processadores de mutação do JSON
<a name="CloudWatch-Logs-Transformation-JSONMutate"></a>

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. 

**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
<a name="CloudWatch-Logs-Transformation-addKeys"></a>

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<br />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 seguinte exemplo de evento de logs:

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

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

```
[
    {
        "parseJSON": {}
    },
    {
        "addKeys": {
            "entries": [
                {
                    "key": "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
<a name="CloudWatch-Logs-Transformation-deleteKeys"></a>

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 seguinte exemplo de evento de logs:

```
{
    "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
<a name="CloudWatch-Logs-Transformation-moveKeys"></a>

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<br />Profundidade máxima de chave aninhada: 3 | 
| target | A chave a ser movida para | Sim |  | Tamanho máximo: 128<br />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 seguinte exemplo de evento de logs:

```
{
    "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
<a name="CloudWatch-Logs-Transformation-renameKeys"></a>

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<br />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 seguinte exemplo de evento de logs:

```
{
    "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
<a name="CloudWatch-Logs-Transformation-copyValue"></a>

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<br />Profundidade máxima de chave aninhada: 3 | 
| target | A chave cujo valor será copiado para | Sim | Sem limite | Tamanho máximo: 128<br />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 seguinte exemplo de evento de logs:

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

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

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
<a name="CloudWatch-Logs-Transformation-listToMap"></a>

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<br />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<br />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.<br />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 seguinte exemplo de evento de logs:

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