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

你可以使用的处理器

本节包含有关可用于 LOG Event Transformers 的每个处理器的信息。处理器可以分为解析器、字符串变异器、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 模式

Log grok 模式

常见的 log grok 模式

你可以使用预定义的自定义 grok 模式来匹配 Apache、NGINX 和 Syslog 协议 (RFC 5424) 日志格式。当你使用这些特定的模式时，它们必须是匹配配置中的第一个模式，并且没有其他模式可以排在它们之前。此外，您只能使用一个数据来关注他们。GREEDYDATA 或 GREEDYDATA_MULTILIN E 模式。

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

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

系统日志协议 (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 格式。有关适用于 PostgreSQL 的 RDS 日志格式的更多信息，请参阅适用于 PostgreSQL 的 RDS 数据库日志文件。

此处理器仅接受@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处理器是一种字符串变异处理器，它将键的值与正则表达式进行匹配，并将所有匹配项替换为替换字符串。

示例 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处理器移除密钥开头和结尾的空格。

示例

请参见以下示例：

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

变压器配置是这样的，trimString使用的是parseJSON：

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

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

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

JSON 转换处理器

添加密钥

使用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"
  }
}

DeleteKey

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

示例

请参见以下示例：

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

变压器配置是这样的，deleteKeys使用的是parseJSON：

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

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

{
  "outer_key": {}
}

移动键

使用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处理器重命名日志事件中的密钥。

示例

请参见以下示例：

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

变压器配置是这样的，renameKeys使用的是parseJSON：

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

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

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

复制价值

使用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处理器将与指定键关联的值类型转换为指定类型。它是一个转换处理器，可以更改指定字段的类型。值可以转换为以下数据类型之一：integerdouble、string和。boolean

示例

请参见以下示例：

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

变压器配置是这样的，typeConverter使用的是parseJSON：

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

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

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

日期时间转换器

使用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"
}