使用できるプロセッサ

このセクションでは、ログイベントトランスフォーマーで使用できる各プロセッサについて説明します。プロセッサは、パーサー、文字列ミューテーター、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) のログ形式を一致させることができます。これらの特定のパターンを使用する場合、それらは一致する設定の最初のパターンである必要があり、他のパターンの前に配置することはできません。また、1 つの 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 Protocol (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 に設定すると 1 つの空白文字の各列が区切られます。

例

取り込まれたログイベントの一部は次のようになります。

'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 ログ形式の詳細については、「ウェブ 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"
}