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

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

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

O processador `lowerCaseString` converte uma string em sua versão em minúsculas.


| Campo | Description | Obrigatório? | Padrão | Limites | 
| --- | --- | --- | --- | --- | 
| withKeys | Uma lista de chaves a serem convertidas em letras minúsculas | Sim |  | Máximo de entradas: 10 | 

**Exemplo**

Observe o seguinte exemplo de evento de logs:

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

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

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

O evento de logs transformado seria o seguinte.

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

## upperCaseString
<a name="CloudWatch-Logs-Transformation-upperCaseString"></a>

O processador `upperCaseString` converte uma string em sua versão em maiúsculas.


| Campo | Description | Obrigatório? | Padrão | Limites | 
| --- | --- | --- | --- | --- | 
| withKeys | Uma lista de chaves a serem convertidas em maiúsculas | Sim |  | Máximo de entradas: 10 | 

**Exemplo**

Observe o seguinte exemplo de evento de logs:

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

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

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

O evento de logs transformado seria o seguinte.

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

## splitString
<a name="CloudWatch-Logs-Transformation-splitString"></a>

O processador `splitString` é um tipo de processador de mutação de string que divide um campo em uma matriz usando um caractere delimitador.


| Campo | Description | Obrigatório? | Padrão | Limites | 
| --- | --- | --- | --- | --- | 
| entries | Matriz de entradas. Cada item na matriz deve conter os campos source e delimiter. | Sim |  | Máximo de entradas: 10 | 
| origem | A chave do valor do campo a ser dividido | Sim |  | Tamanho máximo: 128 | 
| delimitador | A string delimitadora onde dividir o valor do campo | Sim |  | Tamanho máximo: 128 | 

**Exemplo 1**

Observe o seguinte exemplo de evento de logs:

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

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

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

O evento de logs transformado seria o seguinte.

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

**Exemplo 2**

O delimitador para dividir a string pode ter vários caracteres.

Observe o seguinte exemplo de evento de logs:

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

A configuração do transformador é a seguinte:

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

O evento de logs transformado seria o seguinte.

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

## substituteString
<a name="CloudWatch-Logs-Transformation-substituteString"></a>

O processador `substituteString` é um tipo de processador de mutação de string que combina o valor de uma chave com uma expressão regular e substitui todas as correspondências por uma string de substituição.


| Campo | Description | Obrigatório? | Padrão | Limites | 
| --- | --- | --- | --- | --- | 
| entries | Matriz de entradas. Cada item na matriz deve conter os campos source, from e to. | Sim |  | Máximo de entradas: 10 | 
| origem | A chave do campo a ser modificado | Sim |  | Tamanho máximo: 128<br />Profundidade máxima de chave aninhada: 3 | 
| from | A string de expressão regular a ser substituída. Caracteres regex especiais, como [ e ], devem ser escapados usando \\\\ ao usar aspas duplas e com \\ ao usar aspas simples ou quando configurados a partir do Console de gerenciamento da AWS. Para obter mais informações, consulte o [ Padrão de classe](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html) no site da Oracle.<br />Você pode agrupar um padrão em `(...)` para criar um grupo de captura numerado e criar grupos de captura denominados `(?P<group_name>...)` que possam ser referenciados no campo `to`. | Sim |  | Tamanho máximo: 128 | 
| para | A string a ser substituída para cada correspondência de from. Podem ser usadas referências anteriores para os grupos de captura. Use o formulário $n para grupos numerados como $1, e use ${group\_name} para grupos nomeados, como ${my\_group}.> | Sim |  | Tamanho máximo: 128<br />Número máximo de referências anteriores: 10<br />Número máximo de referências anteriores duplicadas: 2 | 

**Exemplo 1**

Observe o seguinte exemplo de evento de logs:

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

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

O evento de logs transformado seria o seguinte.

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

**Exemplo 2**

Observe o seguinte exemplo de evento de logs:

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

A configuração do transformador é esta, usando `substituteString` com `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<account_id>\\d{12}):assumed-role/(?P<role_name>[\\w+=,.@-]+)/(?P<role_session_name>[\\w+=,.@-]+)$",
                    "to": "${account_id}:${role_name}:${role_session_name}"
                }
            ]
        }
    }
]
```

O evento de logs transformado seria o seguinte.

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

## trimString
<a name="CloudWatch-Logs-Transformation-trimString"></a>

O processador `trimString` remove o espaço em branco do início e do fim de uma chave.


| Campo | Description | Obrigatório? | Padrão | Limites | 
| --- | --- | --- | --- | --- | 
| withKeys | Uma lista de chaves a serem tratadas | Sim |  | Máximo de entradas: 10 | 

**Exemplo**

Observe o seguinte exemplo de evento de logs:

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

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

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

O evento de logs transformado seria o seguinte.

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