

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 zur Bearbeitung von Zeichenketten
<a name="string-processors"></a>

Zeichenkettenprozessoren ändern Textwerte innerhalb von Protokollereignissen durch Operationen wie Groß-/Kleinschreibung, Kürzen und Musterabgleich.

## Lowercase\$1String-Prozessor
<a name="lowercase-string-processor"></a>

Konvertiert angegebene Felder in Kleinbuchstaben.

**Konfiguration**  
Konfigurieren Sie den Lowercase\$1String-Prozessor mit den folgenden Parametern:

```
processor:
  - lowercase_string:
      with_keys: ["status", "method"]
```Parameters

`with_keys` (Erforderlich)  
Array von Feldnamen, die in Kleinbuchstaben umgewandelt werden sollen. Verarbeitet nur Zeichenkettenwerte.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Uppercase\$1String-Prozessor
<a name="uppercase-string-processor"></a>

Konvertiert angegebene Felder in Großbuchstaben.

**Konfiguration**  
Konfigurieren Sie den Prozessor uppercase\$1string mit den folgenden Parametern:

```
processor:
  - uppercase_string:
      with_keys: ["status_code", "method"]
```Parameters

`with_keys` (Erforderlich)  
Array von Feldnamen, die in Großbuchstaben umgewandelt werden sollen. Verarbeitet nur Zeichenkettenwerte.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## trim\$1string-Prozessor
<a name="trim-string-processor"></a>

Entfernt führende und abschließende Leerzeichen aus den angegebenen Feldern.

**Konfiguration**  
Konfigurieren Sie den Prozessor trim\$1string mit den folgenden Parametern:

```
processor:
  - trim_string:
      with_keys: ["message", "user_input"]
```Parameters

`with_keys` (Erforderlich)  
Array von Feldnamen, aus denen Leerzeichen entfernt werden sollen. Verarbeitet nur Zeichenkettenwerte.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor substitute\$1string
<a name="substitute-string-processor"></a>

Führt die Zeichenkettenersetzung mithilfe regulärer Ausdrücke durch.

**Konfiguration**  
Konfigurieren Sie den Prozessor substitute\$1string mit den folgenden Parametern:

```
processor:
  - substitute_string:
      entries:
        - source: "message"
          from: "ERROR"
          to: "WARN"
```Parameters

`entries` (Erforderlich)  
Array von Substitutionsoperationen, die für jedes Protokollereignis ausgeführt werden sollen.

`entries[].source` (Erforderlich)  
Das Feld, für das eine Zeichenkettenersetzung durchgeführt werden soll.

`entries[].from` (Erforderlich)  
Das Muster für reguläre Ausdrücke, das abgeglichen und ersetzt werden soll.

`entries[].to` (Erforderlich)  
Die Ersatzzeichenfolge für übereinstimmende Muster.

`when` (optional)  
Bedingter Ausdruck auf Prozessorebene. Wenn angegeben, wird der gesamte Prozessor übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when` (optional)  
Bedingter Ausdruck auf Einstiegsebene. Wenn angegeben, wird nur dieser Eintrag übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when_else` (optional)  
Ausweicheintrag, der nur ausgeführt wird, wenn keine der anderen `when` Bedingungen desselben Prozessors zutrifft. Der Ausdruckswert gibt an, welche `when` Bedingungen berücksichtigt werden sollen. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor kürzen
<a name="truncate-processor"></a>

Kürzt Feldwerte auf die angegebene Länge.

**Konfiguration**  
Konfigurieren Sie den Truncate-Prozessor mit den folgenden Parametern:

```
processor:
  - truncate:
      source_keys: ["message", "description"]
      length: 100
      start_at: 0
```Parameters

`source_keys` (Erforderlich)  
Array von Feldnamen, die gekürzt werden sollen. Jeder Feldname darf maximal 128 Zeichen enthalten.

`length` (optional)  
Maximale Länge nach der Kürzung. Bereich: 1-8192.

`start_at` (optional)  
Startposition für die Kürzung. Bereich: 0-8192. Der Standardwert ist 0.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor „extract\$1value“
<a name="extract-value-processor"></a>

Extrahiert Werte mithilfe regulärer Ausdrücke.

**Konfiguration**  
Konfigurieren Sie den Prozessor extract\$1value mit den folgenden Parametern:

```
processor:
  - extract_value:
      entries:
        - source: "message"
          target: "extracted_data"
          from: "user=(?<user>\\w+)"
          to: "${user}"
          target_type: "string"
```Parameters

`entries` (Erforderlich)  
Reihe von Extraktionsvorgängen. Maximal 20 Einträge.

`entries[].source` (Erforderlich)  
Feld, aus dem extrahiert werden soll. Maximal 128 Zeichen.

`entries[].target` (Erforderlich)  
Zielfeld für den extrahierten Wert. Maximal 128 Zeichen.

`entries[].from` (Erforderlich)  
Muster für reguläre Ausdrücke. Maximal 128 Zeichen.

`entries[].to` (Erforderlich)  
Ersatzmuster durch Capture-Gruppen. Maximal 128 Zeichen.

`entries[].target_type` (optional)  
Zieldatentyp („Integer“, „Double“, „Zeichenfolge“, „Boolean“).

`when` (optional)  
Bedingter Ausdruck auf Prozessorebene. Wenn angegeben, wird der gesamte Prozessor übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when` (optional)  
Bedingter Ausdruck auf Einstiegsebene. Wenn angegeben, wird nur dieser Eintrag übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when_else` (optional)  
Ausweicheintrag, der nur ausgeführt wird, wenn keine der anderen `when` Bedingungen desselben Prozessors zutrifft. Der Ausdruckswert gibt an, welche `when` Bedingungen berücksichtigt werden sollen. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## convert\$1entry\$1type-Prozessor
<a name="convert-entry-type-processor"></a>

Konvertiert Feldwerte zwischen verschiedenen Datentypen.

**Konfiguration**  
Konfigurieren Sie den Prozessor convert\$1entry\$1type mit den folgenden Parametern:

```
processor:
  - convert_entry_type:
      key: "count"
      type: "integer"
```Parameters

`key` (Erforderlich)  
Einzelner Feldname, der konvertiert werden soll.

`type` (Erforderlich)  
Zieldatentyp. Optionen: „Ganzzahl“, „Doppel“, „Zeichenfolge“, „Boolean“.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Datumsprozessor
<a name="date-processor"></a>

Analysiert und formatiert date/time Felder.

**Konfiguration**  
Konfigurieren Sie den Datumsprozessor mit den folgenden Parametern:

```
processor:
  - date:
      match:
        - key: "timestamp"
          patterns: ["yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'"]
      destination: "@timestamp"
      source_timezone: "UTC"
      destination_timezone: "America/New_York"
```Parameters

`match` (Erforderlich)  
Reihe von Konfigurationen für die Datumsübereinstimmung. Maximal 10 Einträge.

`match[].key` (Erforderlich)  
Feld, das die Datumszeichenfolge enthält. Maximal 128 Zeichen.

`match[].patterns` (Erforderlich)  
Eine Reihe von Datumsformatmustern zum Ausprobieren. Maximal 5 Muster mit jeweils bis zu 256 Zeichen.

`destination` (optional)  
Ein einzelnes Zielfeld für alle analysierten Daten. Maximal 128 Zeichen.

`source_timezone` (optional)  
Quellzeitzone für das Parsen.

`destination_timezone` (optional)  
Zielzeitzone für die Ausgabe.

`output_format` (optional)  
Format des Ausgabedatums. Maximal 64 Zeichen.

`destination_type` (optional)  
Ausgabetyp: „timestampz“, „long“ oder „string“.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor analysieren
<a name="dissect-processor"></a>

Extrahiert strukturierte Daten mithilfe von Musterabgleich.

**Konfiguration**  
Konfigurieren Sie den Dissect-Prozessor mit den folgenden Parametern:

```
processor:
  - dissect:
      map:
        message: "%{timestamp} %{level}"
```Parameters

`map` (Erforderlich)  
Feldzuordnung mit Sezierungsmustern.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## list\$1to\$1map-Prozessor
<a name="list-to-map-processor"></a>

Konvertiert Array-Felder in Map-Strukturen.

**Konfiguration**  
Konfigurieren Sie den Prozessor list\$1to\$1map mit den folgenden Parametern:

```
processor:
  - list_to_map:
      source: "tags"
      key: "name"
      value_key: "value"
      target: "tag_map"
```Parameters

`source` (Erforderlich)  
Feld, das Array-Daten enthält. Maximal 128 Zeichen.

`key` (Erforderlich)  
Feldname, der als Zuordnungsschlüssel verwendet werden soll. Maximal 128 Zeichen.

`value_key` (optional)  
Feldname, der als Kartenwert verwendet werden soll. Maximal 128 Zeichen.

`target` (optional)  
Zielfeld für die Kartenstruktur. Maximal 128 Zeichen.

`flatten` (optional)  
Ob die resultierende Map geglättet werden soll.

`flattened_element` (optional)  
Welches Element soll beim Reduzieren verwendet werden („erstes“ oder „letztes“).

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## rename\$1keys-Prozessor
<a name="rename-keys-processor"></a>

Benennt Felder in Protokollereignissen um.

**Konfiguration**  
Konfigurieren Sie den rename\$1keys-Prozessor mit den folgenden Parametern:

```
processor:
  - rename_keys:
      entries:
        - from_key: "old_name"
          to_key: "new_name"
          overwrite_if_to_key_exists: true
```Parameters

`entries` (Erforderlich)  
Reihe von Umbenennungsvorgängen. Maximal 5 Einträge.

`entries[].from_key` (Erforderlich)  
Aktueller Feldname. Maximal 128 Zeichen.

`entries[].to_key` (Erforderlich)  
Neuer Feldname. Maximal 128 Zeichen.

`entries[].overwrite_if_to_key_exists` (optional)  
Ob ein vorhandenes Zielfeld überschrieben werden soll.

`when` (optional)  
Bedingter Ausdruck auf Prozessorebene. Wenn angegeben, wird der gesamte Prozessor übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when` (optional)  
Bedingter Ausdruck auf Einstiegsebene. Wenn angegeben, wird nur dieser Eintrag übersprungen, wenn der Ausdruck als falsch ausgewertet wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

`entries[].when_else` (optional)  
Ausweicheintrag, der nur ausgeführt wird, wenn keine der anderen `when` Bedingungen desselben Prozessors zutrifft. Der Ausdruckswert gibt an, welche `when` Bedingungen berücksichtigt werden sollen. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor „select\$1entries“
<a name="select-entries-processor"></a>

Wählt nur bestimmte Felder aus Ereignissen aus.

**Konfiguration**  
Konfigurieren Sie den Prozessor select\$1entries mit den folgenden Parametern:

```
processor:
  - select_entries:
      include_keys: ["timestamp", "level", "message"]
```Parameters

`include_keys` (Erforderlich)  
Array von Feldnamen, die beibehalten werden sollen. Maximal 50 Schlüssel mit jeweils bis zu 128 Zeichen.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).

## Prozessor übersetzen
<a name="translate-processor"></a>

Übersetzt Feldwerte mithilfe von Nachschlagetabellen.

**Konfiguration**  
Konfigurieren Sie den Übersetzungsprozessor mit den folgenden Parametern:

```
processor:
  - translate:
      mappings:
        - source: "status_code"
          targets:
            - target: "status_text"
              map:
                "200": "OK"
                "404": "Not Found"
```Parameters

`mappings` (Erforderlich)  
Eine Reihe von Übersetzungskonfigurationen. Maximal 10 Zuordnungen.

`mappings[].source` (Erforderlich)  
Zu übersetzendes Feld. Maximal 128 Zeichen.

`mappings[].targets` (Erforderlich)  
Reihe von Zielkonfigurationen. Maximal 10 Ziele.

`mappings[].targets[].target` (Erforderlich)  
Name des Zielfeldes. Maximal 128 Zeichen.

`mappings[].targets[].map` (Erforderlich)  
Zuordnung der Übersetzungen. Maximal 100 Einträge, jeder Wert bis zu 512 Zeichen.

`when` (optional)  
Bedingter Ausdruck, der bestimmt, ob dieser Prozessor ausgeführt wird. Die maximale Länge beträgt 256 Zeichen. Siehe [Ausdruckssyntax für bedingte Verarbeitung](conditional-processing.md).