本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

您可以使用的處理器

本節包含您可以在日誌事件轉換器中使用的每個處理器的相關資訊。處理器可以分類為剖析器、字串變動器、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 模式

路徑grok 模式

日期和時間 grok 模式

日誌 grok 模式

常見日誌 grok 模式

您可以使用預先定義的自訂 grok 模式來比對 Apache、NGINX 和 Syslog Protocol (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\"]"
}

parseToOCSF

parseToOCSF 處理器會將日誌轉換為開放網路安全結構描述架構 (OCSF) 格式。

原始@message內容不會變更，新的金鑰會新增至訊息。

範例

下列範例會將 Amazon VPC 流程日誌轉換為 OCSF 格式。

[
 "parseToOCSF": {
   eventSource: "VPCFlow",
   version: "V1.1" 
 }
]

csv

csv 處理器會將逗號分隔值 (CSV) 從日誌事件剖析為資料欄。

範例

假設擷取日誌事件的一部分如下所示：

'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、 doublestring和 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"
}