本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# JSON 变异处理器
<a name="CloudWatch-Logs-Transformation-JSONMutate"></a>

本节包含有关可用于日志事件转换器的 JSON 变异处理器的信息。

**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>

使用 `addKeys` 处理器向日志事件添加新的键值对。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  entries | 条目数组。数组中的每个项目都可以包含 key、value 和 overwriteIfExists 字段。 |  是 |  |  最多条目数：5 | 
|  键 | 要添加的新条目的键 |  是 |  |  最大长度：128 最大嵌套键深度：3 | 
|  值 | 要添加的新条目的值 |  是 |  |  最大长度：256 | 
|  overwriteIfExists | 如果您将其设置为 true，而事件中已存在 key，则现有值会被覆盖。默认值为 false。 | 否 |  false | 无限制 | 

**示例**

以以下日志事件为例：

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

转换器配置如下，将 `addKeys` 和 `parseJSON` 结合使用：

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

转换后的日志事件将如下所示。

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

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

使用 `deleteKeys` 处理器从日志事件中删除字段。这些字段可以包含键值对。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  withKeys | 要删除的键列表。 |  是 | 无限制 |  最多条目数：5 | 

**示例**

以以下日志事件为例：

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

转换器配置如下，将 `deleteKeys` 和 `parseJSON` 结合使用：

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

转换后的日志事件将如下所示。

```
{
  "outer_key": {}
}
```

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

使用 `moveKeys` 处理器将键从一个字段移动到另一个字段。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  entries | 条目数组。数组中的每个项目都可以包含 source、target 和 overwriteIfExists 字段。 |  是 |  |  最多条目数：5 | 
|  source | 要移动的键 |  是 |  |  最大长度：128 最大嵌套键深度：3 | 
|  target | 要移动至的键 |  是 |  |  最大长度：128 最大嵌套键深度：3 | 
|  overwriteIfExists | 如果您将其设置为 true，而事件中已存在 key，则现有值会被覆盖。默认值为 false。 | 否 |  false | 无限制 | 

**示例**

以以下日志事件为例：

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

转换器配置如下，将 `moveKeys` 和 `parseJSON` 结合使用：

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

转换后的日志事件将如下所示。

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

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

使用 `renameKeys` 处理器重命名日志事件中的键。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  entries | 条目数组。数组中的每个项目都可以包含 key、target 和 overwriteIfExists 字段。 |  是 | 无限制 |  最多条目数：5 | 
|  键 | 要重命名的键 |  是 | 无限制 |  最大长度：128  | 
|  target | 新的键名称 |  是 | 无限制 |  最大长度：128 最大嵌套键深度：3 | 
|  overwriteIfExists | 如果您将其设置为 true，而事件中已存在 key，则现有值会被覆盖。默认值为 false。 | 否 |  false | 无限制 | 

**示例**

以以下日志事件为例：

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

转换器配置如下，将 `renameKeys` 和 `parseJSON` 结合使用：

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

转换后的日志事件将如下所示。

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

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

使用 `copyValue` 处理器复制日志事件中的值。您还可以通过将以下元数据键的值复制到日志事件中，来使用此处理器向日志事件添加元数据：`@logGroupName`、`@logGroupStream`、`@accountId`、`@regionName`。以下示例对此进行了说明。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  entries | 条目数组。数组中的每个项目都可以包含 source、target 和 overwriteIfExists 字段。 |  是 |  |  最多条目数：5 | 
|  source | 要复制的键 |  是 |  |  最大长度：128 最大嵌套键深度：3 | 
|  target | 将值复制到的键 |  是 | 无限制 |  最大长度：128 最大嵌套键深度：3 | 
|  overwriteIfExists | 如果您将其设置为 true，而事件中已存在 key，则现有值会被覆盖。默认值为 false。 | 否 |  false | 无限制 | 

**示例**

以以下日志事件为例：

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

转换器配置如下，将 `copyValue` 和 `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"
                }
            ]
        }
    }
]
```

转换后的日志事件将如下所示。

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

`listToMap` 处理器获取包含键字段的对象列表，并将其转换为目标键的映射。


| 字段 | 说明 | 必填？ | 默认 | 限制 | 
| --- | --- | --- | --- | --- | 
|  source | 中的密钥 ProcessingEvent 包含将要转换为地图的对象列表 |  是 |  |  最大长度：128 最大嵌套键深度：3 | 
|  键 | 要在生成的映射中提取为键的字段的键 |  是 |  |  最大长度：128  | 
|  valueKey | 如果指定此项，则将从 source 对象中提取您在此参数中指定的值，并将其放入生成的映射的值中。否则，源列表中的原始对象将放入生成的映射的值中。 |  否 |  |  最大长度：128  | 
|  target | 将保存生成的映射的字段的键  |  否 |  根节点 |  最大长度：128 最大嵌套键深度：3 | 
|  flatten | 一个布尔值，指示列表是扁平化为单个项目，还是生成的映射中的值将是列表。 默认情况下，匹配键的值将以数组表示。请将 `flatten` 设置为 `true`，以根据 `flattenedElement` 的值将数组转换为单个值。 |  否 |  false |  | 
|  flattenedElement | 如果将 flatten 设置为 true，则使用 flattenedElement 指定要保留哪个元素（first 或 last）。 |  在 `flatten` 设置为 `true` 时是必需的 |  |  值只能是 first 或 last | 

**示例**

以以下日志事件为例：

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

**使用案例 1 的转换器：**`flatten` 是 `false`

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

转换后的日志事件将如下所示。

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

**使用案例 2 的转换器：**`flatten` 是 `true`，`flattenedElement` 是 `first`

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

转换后的日志事件将如下所示。

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

**使用案例 3 的转换器：**`flatten` 是 `true`，`flattenedElement` 是 `last`

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

转换后的日志事件将如下所示。

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