Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Prozessoren mutieren durch Zeichenketten
Dieser Abschnitt enthält Informationen zu den Prozessoren für Zeichenkettenmutationen, die Sie mit einem Log-Event-Transformator verwenden können.
**Contents**
+ [lowerCaseString](#CloudWatch-Logs-Transformation-lowerCaseString)
+ [upperCaseString](#CloudWatch-Logs-Transformation-upperCaseString)
+ [SplitString](#CloudWatch-Logs-Transformation-splitString)
+ [SubstituteString](#CloudWatch-Logs-Transformation-substituteString)
+ [TrimString](#CloudWatch-Logs-Transformation-trimString)
## lowerCaseString
Der `lowerCaseString` Prozessor konvertiert eine Zeichenfolge in ihre kleingeschriebene Version.
| Feld | Description | Erforderlich? | Standard | Einschränkungen |
| --- | --- | --- | --- | --- |
| Mit Schlüsseln | Eine Liste von Schlüsseln, die in Kleinbuchstaben umgewandelt werden sollen | Ja | | Maximale Anzahl von Einträgen: 10 |
**Beispiel**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `lowerCaseString` mit`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"lowerCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
## upperCaseString
Der `upperCaseString` Prozessor konvertiert eine Zeichenfolge in ihre Großbuchstabenversion.
| Feld | Description | Erforderlich? | Standard | Einschränkungen |
| --- | --- | --- | --- | --- |
| Mit Schlüsseln | Eine Liste von Schlüsseln, die in Großbuchstaben umgewandelt werden sollen | Ja | | Maximale Anzahl von Einträgen: 10 |
**Beispiel**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `upperCaseString` mit`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"upperCaseString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key": "INNER_VALUE"
}
}
```
## SplitString
Der `splitString` Prozessor ist eine Art von String-Mutate-Prozessor, der ein Feld mithilfe eines Trennzeichens in ein Array aufteilt.
| Feld | Description | Erforderlich? | Standard | Einschränkungen |
| --- | --- | --- | --- | --- |
| Einträge | Array von Einträgen. Jedes Element im Array muss delimiter Felder enthaltensource. | Ja | | Maximale Anzahl von Einträgen: 10 |
| Quelle | Der Schlüssel des Feldwerts, der geteilt werden soll | Ja | | Höchstlänge: 128 |
| delimiter | Die Trennzeichenfolge, nach der der Feldwert aufgeteilt werden soll | Ja | | Höchstlänge: 128 |
**Beispiel 1**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `splitString` mit`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": "_"
}
]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key": [
"inner",
"value"
]
}
}
```
**Beispiel 2**
Das Trennzeichen, anhand dessen die Zeichenfolge aufgeteilt werden soll, kann mehrere Zeichen lang sein.
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key": "item1, item2, item3"
}
}
```
Die Konfiguration des Transformators sieht wie folgt aus:
```
[
{
"parseJSON": {}
},
{
"splitString": {
"entries": [
{
"source": "outer_key.inner_key",
"delimiter": ", "
}
]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key": [
"item1",
"item2",
"item3"
]
}
}
```
## SubstituteString
Der `substituteString` Prozessor ist ein Typ eines String-Mutationsprozessors, der den Wert eines Schlüssels mit einem regulären Ausdruck vergleicht und alle Treffer durch eine Ersatzzeichenfolge ersetzt.
| Feld | Description | Erforderlich? | Standard | Einschränkungen |
| --- | --- | --- | --- | --- |
| Einträge | Reihe von Einträgen. Jedes Element im Array muss to Felder sourcefrom, und enthalten. | Ja | | Maximale Anzahl von Einträgen: 10 |
| Quelle | Der Schlüssel des Feldes, das geändert werden soll | Ja | | Höchstlänge: 128
Maximale Tiefe verschachtelter Schlüssel: 3 |
| from | Die Zeichenfolge für reguläre Ausdrücke, die ersetzt werden soll. Spezielle reguläre Zeichen wie [und] müssen mit\\\\ maskiert werden, wenn doppelte Anführungszeichen verwendet werden, und mit\\, wenn einfache Anführungszeichen verwendet werden oder wenn sie über den konfiguriert wurden. AWS-Managementkonsole Weitere Informationen finden Sie unter [Class Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html) auf der Oracle-Website.
Sie können ein Muster einbinden`(...)`, um eine nummerierte Erfassungsgruppe und `(?P...)` benannte Erfassungsgruppen zu erstellen, auf die im `to` Feld verwiesen werden kann. | Ja | | Höchstlänge: 128 |
| to | Die Zeichenfolge, die für jede Übereinstimmung von from Rückverweisen auf Erfassungsgruppen ersetzt werden soll, kann verwendet werden. Verwenden Sie die Form $n für nummerierte Gruppen wie $1 und ${group\_name} für benannte Gruppen wie $. {my\_group} > | Ja | | Höchstlänge: 128
Maximale Anzahl von Rückverweisen: 10
Maximale Anzahl doppelter Rückverweise: 2 |
**Beispiel 1**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key1": "[]",
"inner_key2": "123-345-567",
"inner_key3": "A cat takes a catnap."
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `substituteString` mit`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"
}
]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key1": "value1",
"inner_key2": "xxx-xxx-xxx",
"inner_key3": "A dog takes a dognap."
}
}
```
**Beispiel 2**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key1": "Tom, Dick, and Harry",
"inner_key2": "arn:aws:sts::123456789012:assumed-role/MyImportantRole/MySession"
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `substituteString` mit`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\\d{12}):assumed-role/(?P[\\w+=,.@-]+)/(?P[\\w+=,.@-]+)$",
"to": "${account_id}:${role_name}:${role_session_name}"
}
]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key1": "Tom and Harry",
"inner_key2": "123456789012:MyImportantRole:MySession"
}
}
```
## TrimString
Der `trimString` Prozessor entfernt Leerzeichen am Anfang und Ende eines Schlüssels.
| Feld | Description | Erforderlich? | Standard | Einschränkungen |
| --- | --- | --- | --- | --- |
| Mit Schlüsseln | Eine Liste von Schlüsseln zum Trimmen | Ja | | Maximale Anzahl an Einträgen: 10 |
**Beispiel**
Nehmen wir das folgende Beispiel für ein Protokollereignis:
```
{
"outer_key": {
"inner_key": " inner_value "
}
}
```
Die Transformer-Konfiguration sieht wie folgt aus und verwendet `trimString` mit`parseJSON`:
```
[
{
"parseJSON": {}
},
{
"trimString": {
"withKeys":["outer_key.inner_key"]
}
}
]
```
Das transformierte Protokollereignis wäre das Folgende.
```
{
"outer_key": {
"inner_key": "inner_value"
}
}
```