Schlüssel hinzufügen Schlüssel löschen MoveKeys Schlüssel umbenennen Wert kopieren listToMap

JSON-Prozessoren mutieren

Dieser Abschnitt enthält Informationen zu den mutierten JSON-Prozessoren, die Sie mit einem Log-Event-Transformer verwenden können.

Inhalt

Schlüssel hinzufügen

Verwenden Sie den addKeys Prozessor, um dem Protokollereignis neue Schlüssel-Wert-Paare hinzuzufügen.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Einträge	Reihe von Einträgen. Jedes Element im Array kann `overwriteIfExists` Felder `keyvalue`, und enthalten.	Ja		Maximale Anzahl von Einträgen: 5
Schlüssel	Der Schlüssel des neuen Eintrags, der hinzugefügt werden soll	Ja		Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
value	Der Wert des neuen Eintrags, der hinzugefügt werden soll	Ja		Maximale Länge: 256
overwriteIfExists	Wenn Sie dies auf setzen`true`, wird der bestehende Wert überschrieben, falls er im Ereignis `key` bereits vorhanden ist. Der Standardwert ist `false`.	Nein	false	Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Die Transformer-Konfiguration sieht wie folgt addKeys ausparseJSON:


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

Das transformierte Protokollereignis wäre das Folgende.


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

Schlüssel löschen

Verwenden Sie den deleteKeys Prozessor, um Felder aus einem Protokollereignis zu löschen. Diese Felder können Schlüssel-Wert-Paare enthalten.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Mit Schlüsseln	Die Liste der zu löschenden Schlüssel.	Ja	Kein Limit	Maximale Anzahl an Einträgen: 5

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Die Transformer-Konfiguration sieht wie folgt deleteKeys ausparseJSON:


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

Das transformierte Protokollereignis wäre das Folgende.


{
  "outer_key": {}
}

MoveKeys

Verwenden Sie den moveKeys Prozessor, um eine Taste von einem Feld in ein anderes zu verschieben.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Einträge	Reihe von Einträgen. Jedes Element im Array kann `overwriteIfExists` Felder `sourcetarget`, und enthalten.	Ja		Maximale Anzahl von Einträgen: 5
Quelle	Der Schlüssel zum Bewegen	Ja		Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
Ziel	Der Schlüssel, zu dem gewechselt werden soll	Ja		Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
overwriteIfExists	Wenn Sie dies auf setzen`true`, wird der vorhandene Wert überschrieben, falls er im `key` Ereignis bereits vorhanden ist. Der Standardwert ist `false`.	Nein	false	Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Die Transformer-Konfiguration sieht wie folgt moveKeys ausparseJSON:


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

Das transformierte Protokollereignis wäre das Folgende.


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

Schlüssel umbenennen

Verwenden Sie den renameKeys Prozessor, um Schlüssel in einem Protokollereignis umzubenennen.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Einträge	Reihe von Einträgen. Jedes Element im Array kann `overwriteIfExists` Felder `keytarget`, und enthalten.	Ja	Kein Limit	Maximale Anzahl von Einträgen: 5
Schlüssel	Der Schlüssel zum Umbenennen	Ja	Kein Limit	Höchstlänge: 128
Ziel	Der neue Schlüsselname	Ja	Kein Limit	Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
overwriteIfExists	Wenn Sie dies auf setzen`true`, wird der vorhandene Wert überschrieben, falls er im `key` Ereignis bereits vorhanden ist. Der Standardwert ist `false`.	Nein	false	Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Die Transformer-Konfiguration sieht wie folgt renameKeys ausparseJSON:


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

Das transformierte Protokollereignis wäre das Folgende.


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

Wert kopieren

Verwenden Sie den copyValue Prozessor, um Werte innerhalb eines Protokollereignisses zu kopieren. Sie können diesen Prozessor auch verwenden, um Metadaten zu Protokollereignissen hinzuzufügen, indem Sie die Werte der folgenden Metadatenschlüssel in die Protokollereignisse kopieren:@logGroupName,@logGroupStream,@accountId,@regionName. Dies wird im folgenden Beispiel veranschaulicht.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Einträge	Reihe von Einträgen. Jedes Element im Array kann `overwriteIfExists` Felder `sourcetarget`, und enthalten.	Ja		Maximale Anzahl von Einträgen: 5
Quelle	Der Schlüssel zum Kopieren	Ja		Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
Ziel	Der Schlüssel, in den der Wert kopiert werden soll	Ja	Kein Limit	Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
overwriteIfExists	Wenn Sie dies auf setzen`true`, wird der vorhandene Wert überschrieben, falls er im `key` Ereignis bereits vorhanden ist. Der Standardwert ist `false`.	Nein	false	Kein Limit

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Die Transformer-Konfiguration sieht wie folgt copyValue ausparseJSON:


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

Das transformierte Protokollereignis wäre das Folgende.


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

Der listToMap Prozessor nimmt eine Liste von Objekten, die Schlüsselfelder enthalten, und konvertiert sie in eine Zuordnung von Zielschlüsseln.

Feld	Description	Erforderlich?	Standard	Einschränkungen
Quelle	Der Schlüssel in der ProcessingEvent mit einer Liste von Objekten, die in eine Map konvertiert werden	Ja		Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
Schlüssel	Der Schlüssel der Felder, die als Schlüssel in der generierten Map extrahiert werden sollen	Ja		Höchstlänge: 128
WertSchlüssel	Wenn dies angegeben ist, werden die Werte, die Sie in diesem Parameter angeben, aus den `source` Objekten extrahiert und in die Werte der generierten Map eingefügt. Andernfalls werden die Originalobjekte in der Quellliste in die Werte der generierten Map aufgenommen.	Nein		Höchstlänge: 128
Ziel	Der Schlüssel des Feldes, das die generierte Map enthalten soll	Nein	Stammknoten	Höchstlänge: 128 Maximale Tiefe verschachtelter Schlüssel: 3
flatten	Ein boolescher Wert, der angibt, ob die Liste in einzelne Elemente reduziert wird oder ob es sich bei den Werten in der generierten Map um Listen handelt. Standardmäßig werden die Werte für die passenden Schlüssel in einem Array dargestellt. Auf einstellen`true`, `flatten` um das Array basierend auf dem Wert von in einen einzelnen Wert umzuwandeln`flattenedElement`.	Nein	false
flattenedElement	Wenn Sie `flatten` auf einstellen`true`, geben Sie hier `flattenedElement` an, welches Element `first` oder `last` beibehalten werden soll.	Erforderlich, wenn auf gesetzt `flatten` ist `true`		Der Wert kann nur `first` oder sein `last`

Beispiel

Nehmen wir das folgende Beispiel für ein Protokollereignis:


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

Transformator für Anwendungsfall 1: flatten ist false


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

Das transformierte Protokollereignis wäre das Folgende.


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

Transformator für Anwendungsfall 2: flatten ist true und flattenedElement ist first


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

Das transformierte Protokollereignis wäre das Folgende.


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

Transformator für Anwendungsfall 3: flatten ist true und flattenedElement ist last


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

Das transformierte Protokollereignis wäre das Folgende.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Prozessoren, die Zeichenketten mutieren

Prozessoren für Datentypkonverter