您可以使用的处理器

本节包含有关可以在日志事件转换器中使用的每个处理器的信息。处理器可分为解析器、字符串变异器、JSON 变异器和日期处理器。

可配置的解析器类型处理器

parseJSON

parseJSON 处理器解析 JSON 日志事件，并将提取的 JSON 键值对插入到目标位置。如果没有指定目标位置，则处理器会将键值对放置在根节点下。当使用 parseJSON 作为第一个处理器时，您必须使用 @message 作为源字段来解析整个日志事件。在初始 JSON 解析后，您可以在后续处理器中操作特定字段。

原始 @message 内容不变，新键会添加到消息中。

示例：

假设摄取的日志事件如下所示：

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

如果我们有此 parseJSON 处理器：

[
   {
        "parseJSON": {
            "destination": "new_key"
        }
   }
]

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

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

grok

使用 grok 处理器通过模式匹配来解析和构造非结构化数据。此处理器还可以从日志消息中提取字段。

Grok 模式的结构

下面是支持的 grok 模式结构：

%{PATTERN_NAME:FIELD_NAME}

要创建更复杂的匹配表达式，您可以组合多个 grok 模式。最多可以组合 20 个 grok 模式来匹配一个日志事件。例如，可以使用此模式组合 %{NUMBER:timestamp} [%{NUMBER:db} %{IP:client_ip}:%{NUMBER:client_port}] %{GREEDYDATA:data} 从 Redis 慢日志条目中提取字段，如下所示：

1629860738.123456 [0 127.0.0.1:6379] "SET" "key1" "value1"

Grok 示例

示例 1：使用 grok 从非结构化日志中提取字段

日志示例：

293750 server-01.internal-network.local OK "[Thread-000] token generated"

使用的转换器：

[
     {
         "grok": {
             "match": "%{NUMBER:version} %{HOSTNAME:hostname} %{NOTSPACE:status} %{QUOTEDSTRING:logMsg}"
         }
    }
]

输出：

{
  "version": "293750",
  "hostname": "server-01.internal-network.local",
  "status": "OK",
  "logMsg": "[Thread-000] token generated"
}

日志示例：

23/Nov/2024:10:25:15 -0900 172.16.0.1 200

使用的转换器：

[
    {
        "grok": {
            "match": "%{HTTPDATE:timestamp} %{IPORHOST:clientip} %{NUMBER:response_status}"
        }
    }
]

输出：

{
  "timestamp": "23/Nov/2024:10:25:15 -0900",
  "clientip": "172.16.0.1",
  "response_status": "200"
}

示例 2：搭配使用 grok 和 parseJSON 从 JSON 日志事件中提取字段

日志示例：

{
    "timestamp": "2024-11-23T16:03:12Z",
    "level": "ERROR",
    "logMsg": "GET /page.html HTTP/1.1"
}

使用的转换器：

[
     {
        "parseJSON": {}
    },
    {
         "grok": {
            "source": "logMsg",
             "match": "%{WORD:http_method} %{NOTSPACE:request} HTTP/%{NUMBER:http_version}"
         }
    }
]

输出：

{
  "timestamp": "2024-11-23T16:03:12Z",
  "level": "ERROR",
  "logMsg": "GET /page.html HTTP/1.1",
  "http_method": "GET",
  "request": "/page.html",
  "http_version": "1.1"
}

示例 3：FIELD_NAME 中带有点注释的 Grok 模式

日志示例：

192.168.1.1 GET /index.html?param=value 200 1234

使用的转换器：

[
    {
        "grok": {
            "match": "%{IP:client.ip} %{WORD:method} %{URIPATHPARAM:request.uri} %{NUMBER:response.status} %{NUMBER:response.bytes}"
        }
    }
]

输出：

{
  "client": {
    "ip": "192.168.1.1"
  },
  "method": "GET",
  "request": {
    "uri": "/index.html?param=value"
  },
  "response": {
    "status": "200",
    "bytes": "1234"
  }
}

支持的 Grok 模式

下表列出了 grok 处理器支持的模式。

常规 grok 模式

AWS grok 模式

联网 grok 模式

Path grok 模式

日期和时间 grok 模式

日志 grok 模式

常见的 log grok 模式

您可以使用预定义的自定义 grok 模式来匹配 Apache、NGINX 和 Syslog 协议 (RFC 5424) 日志格式。使用这些特定模式时，它们必须是匹配配置中的第一个模式，并且不能有其他模式位于它们之前。此外，后面只有跟有一个 DATA。GREEDYDATA 或 GREEDYDATA_MULTILINE 模式。

下面展示了使用这些常见日志格式模式的有效和无效示例。

"%{NGINX_ACCESS_LOG} %{DATA}" // Valid
"%{SYSLOG5424}%{DATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{GREEDYDATA:logMsg}" // Valid
"%{APACHE_ACCESS_LOG} %{SYSLOG5424}" // Invalid (multiple common log patterns used)
"%{NGINX_ACCESS_LOG} %{NUMBER:num}" // Invalid (Only GREEDYDATA and DATA patterns are supported with common log patterns)
"%{GREEDYDATA:logMsg} %{SYSLOG5424}" // Invalid (GREEDYDATA and DATA patterns are supported only after common log patterns)

常见日志格式示例

Apache 日志示例

日志示例：

127.0.0.1 - - [03/Aug/2023:12:34:56 +0000] "GET /page.html HTTP/1.1" 200 1234

转换器：

[
     {
        "grok": {
            "match": "%{APACHE_ACCESS_LOG}"
        }
    }
]

输出：

{
    "request": "/page.html",
    "http_method": "GET",
    "status_code": 200,
    "http_version": "1.1",
    "response_size": 1234,
    "remote_host": "127.0.0.1",
    "timestamp": "2023-08-03T12:34:56Z"
}

NGINX 日志示例

日志示例：

192.168.1.100 - Foo [03/Aug/2023:12:34:56 +0000] "GET /account/login.html HTTP/1.1" 200 42 "https://www.amazon.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36"

转换器：

[
     {
        "grok": {
            "match": "%{NGINX_ACCESS_LOG}"
        }
    }
]

输出：

{
    "request": "/account/login.html",
    "referrer": "https://www.amazon.com/",
    "agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36",
    "http_method": "GET",
    "status_code": 200,
    "auth_user": "Foo",
    "http_version": "1.1",
    "response_size": 42,
    "remote_host": "192.168.1.100",
    "timestamp": "2023-08-03T12:34:56Z"
}

Syslog 协议 (RFC 5424) 日志示例

日志示例：

<165>1 2003-10-11T22:14:15.003Z mymachine.example.com evntslog - ID47 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"][examplePriority@32473 class="high"]

转换器：

[
     {
        "grok": {
            "match": "%{SYSLOG5424}"
        }
    }
]

输出：

{
  "pri": 165,
  "version": 1,
  "timestamp": "2003-10-11T22:14:15.003Z",
  "hostname": "mymachine.example.com",
  "app": "evntslog",
  "msg_id": "ID47",
  "structured_data": "exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"",
  "message": "[examplePriority@32473 class=\"high\"]"
}

csv

csv 处理器将日志事件中的逗号分隔值 (CSV) 解析为列。

将 delimiter 设置为 \t 将使用制表符分隔每列，\t 将使用单个空格字符分隔每列。

示例：

假设摄取的部分日志事件如下所示：

'Akua Mansa':28:'New York: USA'

假设我们仅使用 csv 处理器：

[
     {
        "csv": {
            "delimiter": ":",
            "quoteCharacter": "'"
        }
    }
]

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

{
  "column_1": "Akua Mansa",
  "column_2": "28",
  "column_3": "New York: USA"
}

parseKeyValue

使用 parseKeyValue 处理器将指定的字段解析为键值对。您可以使用以下选项自定义处理器以解析字段信息。

示例：

以以下日志事件为例：

key1:value1!key2:value2!key3:value3!key4

假设我们使用下面的处理器配置：

[
    {
        "parseKeyValue": {
            "destination": "new_key",
            "fieldDelimiter": "!",
            "keyValueDelimiter": ":",
            "nonMatchValue": "defaultValue",
            "keyPrefix": "parsed_"
        }
    }
]

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

{
  "new_key": {
    "parsed_key1": "value1",
    "parsed_key2": "value2",
    "parsed_key3": "value3",
    "parsed_key4": "defaultValue"
  }
}

用于 AWS 公开发布的日志的内置处理器

parseWAF

使用此处理器来解析 AWS WAF 公开发布的日志，它获取 httpRequest.headers 的内容，并根据每个标头名称创建 JSON 键及其对应的值。它还会对 labels 执行相同的操作。这些转换可以使查询 AWS WAF 日志更加容易。有关 AWS WAF 日志格式的更多信息，请参阅 Web ACL 流量的日志示例。

此处理器仅接受 @message 作为输入。

示例：

以以下日志事件为例：

{
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": [],
  "httpRequest": {
    "clientIp": "1.1.1.1",
    "country": "AU",
    "headers": [
      { "name": "Host", "value": "localhost:1989" },
      { "name": "User-Agent", "value": "curl/7.61.1" },
      { "name": "Accept", "value": "*/*" },
      { "name": "x-stm-test", "value": "10 AND 1=1" }
    ],
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": [{ "name": "value" }]
}

处理器配置如下所示：

[
    {
        "parseWAF": {}
    }
]

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

{
  "httpRequest": {
    "headers": {
      "Host": "localhost:1989",
      "User-Agent": "curl/7.61.1",
      "Accept": "*/*",
      "x-stm-test": "10 AND 1=1"
    },
    "clientIp": "1.1.1.1",
    "country": "AU",
    "uri": "/myUri",
    "args": "",
    "httpVersion": "HTTP/1.1",
    "httpMethod": "GET",
    "requestId": "rid"
  },
  "labels": { "name": "value" },
  "timestamp": 1576280412771,
  "formatVersion": 1,
  "webaclId": "arn:aws:wafv2:ap-southeast-2:111122223333:regional/webacl/STMTest/1EXAMPLE-2ARN-3ARN-4ARN-123456EXAMPLE",
  "terminatingRuleId": "STMTest_SQLi_XSS",
  "terminatingRuleType": "REGULAR",
  "action": "BLOCK",
  "terminatingRuleMatchDetails": [
    {
      "conditionType": "SQL_INJECTION",
      "sensitivityLevel": "HIGH",
      "location": "HEADER",
      "matchedData": ["10", "AND", "1"]
    }
  ],
  "httpSourceName": "-",
  "httpSourceId": "-",
  "ruleGroupList": [],
  "rateBasedRuleList": [],
  "nonTerminatingMatchingRules": []
}

parsePostgres

使用此处理器来解析 Amazon RDS for PostgreSQL 公开发布的日志、提取字段并将其转换为 JSON 格式。有关 RDS for PostgreSQL 日志格式的更多信息，请参阅 RDS for PostgreSQL 据库日志文件。

此处理器仅接受 @message 作为输入。

示例：

以以下日志事件为例：

2019-03-10 03:54:59 UTC:10.0.0.123(52834):postgres@logtestdb:[20175]:ERROR: column "wrong_column_name" does not exist at character 8

处理器配置如下所示：

[
    {
        "parsePostgres": {}
    }
]

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

{
  "logTime": "2019-03-10 03:54:59 UTC",
  "srcIp": "10.0.0.123(52834)",
  "userName": "postgres",
  "dbName": "logtestdb",
  "processId": "20175",
  "logLevel": "ERROR"
}

parseCloudfront

使用此处理器来解析 Amazon CloudFront 公开发布的日志、提取字段并将其转换为 JSON 格式。对编码的字段值进行解码。整数和双精度值按此方法处理。有关 Amazon CloudFront 日志格式的更多信息，请参阅配置和使用标准日志（访问日志）。

此处理器仅接受 @message 作为输入。

示例：

以以下日志事件为例：

2019-12-04  21:02:31   LAX1   392    192.0.2.24    GET    d111111abcdef8.cloudfront.net  /index.html    200    -  Mozilla/5.0%20(Windows%20NT%2010.0;%20Win64;%20x64)%20AppleWebKit/537.36%20(KHTML,%20like%20Gecko)%20Chrome/78.0.3904.108%20Safari/537.36  -  -  Hit    SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==   d111111abcdef8.cloudfront.net  https  23 0.001  -  TLSv1.2    ECDHE-RSA-AES128-GCM-SHA256    Hit    HTTP/2.0   -  -  11040  0.001  Hit    text/html  78 -  -

处理器配置如下所示：

[
    {
        "parseCloudfront": {}
    }
]

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

{
  "date": "2019-12-04",
  "time": "21:02:31",
  "x-edge-location": "LAX1",
  "sc-bytes": 392,
  "c-ip": "192.0.2.24",
  "cs-method": "GET",
  "cs(Host)": "d111111abcdef8.cloudfront.net",
  "cs-uri-stem": "/index.html",
  "sc-status": 200,
  "cs(Referer)": "-",
  "cs(User-Agent)": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36",
  "cs-uri-query": "-",
  "cs(Cookie)": "-",
  "x-edge-result-type": "Hit",
  "x-edge-request-id": "SOX4xwn4XV6Q4rgb7XiVGOHms_BGlTAC4KyHmureZmBNrjGdRLiNIQ==",
  "x-host-header": "d111111abcdef8.cloudfront.net",
  "cs-protocol": "https",
  "cs-bytes": 23,
  "time-taken": 0.001,
  "x-forwarded-for": "-",
  "ssl-protocol": "TLSv1.2",
  "ssl-cipher": "ECDHE-RSA-AES128-GCM-SHA256",
  "x-edge-response-result-type": "Hit",
  "cs-protocol-version": "HTTP/2.0",
  "fle-status": "-",
  "fle-encrypted-fields": "-",
  "c-port": 11040,
  "time-to-first-byte": 0.001,
  "x-edge-detailed-result-type": "Hit",
  "sc-content-type": "text/html",
  "sc-content-len": 78,
  "sc-range-start": "-",
  "sc-range-end": "-"
}

parseRoute53

使用此处理器来解析 Amazon Route 53 Public Data Plane 公开发布的日志、提取字段并将其转换为 JSON 格式。对编码的字段值进行解码。此处理器不支持 Amazon Route 53 Resolver 日志。

此处理器仅接受 @message 作为输入。

示例：

以以下日志事件为例：

1.0 2017-12-13T08:15:50.235Z Z123412341234 example.com AAAA NOERROR TCP IAD12 192.0.2.0 198.51.100.0/24

处理器配置如下所示：

[
    {
        "parseRoute53": {}
    }
]

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

{
  "version": 1.0,
  "queryTimestamp": "2017-12-13T08:15:50.235Z",
  "hostZoneId": "Z123412341234",
  "queryName": "example.com",
  "queryType": "AAAA",
  "responseCode": "NOERROR",
  "protocol": "TCP",
  "edgeLocation": "IAD12",
  "resolverIp": "192.0.2.0",
  "ednsClientSubnet": "198.51.100.0/24"
}

parseVPC

使用此处理器来解析 Amazon VPC 公开发布的日志、提取字段并将其转换为 JSON 格式。对编码的字段值进行解码。

此处理器仅接受 @message 作为输入。

示例：

以以下日志事件为例：

2 123456789010 eni-abc123de 192.0.2.0 192.0.2.24 20641 22 6 20 4249 1418530010 1418530070 ACCEPT OK

处理器配置如下所示：

[
    {
        "parseVPC": {}
    }
]

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

{
  "version": 2,
  "accountId": "123456789010",
  "interfaceId": "eni-abc123de",
  "srcAddr": "192.0.2.0",
  "dstAddr": "192.0.2.24",
  "srcPort": 20641,
  "dstPort": 22,
  "protocol": 6,
  "packets": 20,
  "bytes": 4249,
  "start": 1418530010,
  "end": 1418530070,
  "action": "ACCEPT",
  "logStatus": "OK"
}

字符串变异处理器

lowerCaseString

lowerCaseString 处理器会将字符串转换为其小写版本。

示例：

以以下日志事件为例：

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

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

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

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

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

upperCaseString

upperCaseString 处理器会将字符串转换为其大写版本。

示例：

以以下日志事件为例：

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

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

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

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

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

splitString

splitString 处理器是一种字符串变异处理器，它使用分隔字符将字段拆分为数组。

示例 1：

以以下日志事件为例：

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

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

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

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

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

示例 2：

用于拆分字符串的分隔符可以包含多个字符。

以以下日志事件为例：

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

转换器配置如下：

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

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

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

substituteString

substituteString 处理器是一种字符串变异处理器，它将键的值与正则表达式进行匹配，并将所有匹配项替换为替换字符串。

示例 1：

以以下日志事件为例：

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

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

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

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

示例 2：

以以下日志事件为例：

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

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

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

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

trimString

trimString 处理器会移除键开头和结尾的空格。

示例：

以以下日志事件为例：

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

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

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

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

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

JSON 变异处理器

addKeys

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

示例：

以以下日志事件为例：

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

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

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

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

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

deleteKeys

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

示例：

以以下日志事件为例：

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

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

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

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

{
  "outer_key": {}
}

moveKeys

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

示例：

以以下日志事件为例：

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

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

示例：

以以下日志事件为例：

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

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

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

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

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

copyValue

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

示例：

以以下日志事件为例：

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

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

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

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

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

示例：

以以下日志事件为例：

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

数据类型转换器处理器

typeConverter

使用 typeConverter 处理器可以将与指定的键关联的值类型转换为指定的类型。它是一个转换处理器，可以更改指定字段的类型。值可以转换为以下数据类型之一：integer、double、string 和 boolean。

示例：

以以下日志事件为例：

{
    "name": "value",
    "status": "200"
}

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

[
    {
        "parseJSON": {}
    },
    {
        "typeConverter": {
            "entries": [
                {
                    "key": "status",
                    "type": "integer"
                }
            ]
        }
    }
]

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

{
    "name": "value",
    "status": 200
}

datetimeConverter

使用 datetimeConverter 处理器可以将日期时间字符串转换为您指定的格式。

示例：

以以下日志事件为例：

{"german_datetime": "Samstag 05. Dezember 1998 11:00:00"}

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

[
    {
        "parseJSON": {}
    },
    {
        "dateTimeConverter": {
            "source": "german_datetime",
            "target": "target_1",
            "locale": "de",
            "matchPatterns": ["EEEE dd. MMMM yyyy HH:mm:ss"],
            "sourceTimezone": "Europe/Berlin",
            "targetTimezone": "America/New_York",
            "targetFormat": "yyyy-MM-dd'T'HH:mm:ss z"
        }
    }
]

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

{
    "german_datetime": "Samstag 05. Dezember 1998 11:00:00",
    "target_1": "1998-12-05T17:00:00 MEZ"
}