> ## Documentation Index
> Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Request-Parameter filtern

Jedes Mal, wenn in Ihrer Anwendung eine Anfrage gestellt wird, erfasst AppSignal die mit dieser Anfrage gesendeten Parameter.
Dazu gehören Formulardaten (POST), Query-Parameter und Schlüssel in Routen (z. B. /user/:id/) in einigen Frameworks.

Diese Daten könnten benutzeridentifizierbare Informationen wie Namen, E-Mail-Adressen, Passwörter, Zwei-Faktor-Authentifizierungs-Codes, API-Tokens usw. enthalten.
Um die sensiblen Daten Ihrer Anwendung zu schützen, müssen Sie sicherstellen, dass diese Daten herausgefiltert werden, bevor sie an die AppSignal-Server gesendet werden. Auf diese Weise gibt Ihre Anwendung keine sensiblen Daten preis.

<Tip>
  Lesen Sie mehr über die Parameter-Filterung in unserer [Parameter-Filterung][parameter
      filtering]-Dokumentation.
</Tip>

<Warning>
  Ihre Anwendung sollte keine personenidentifizierbaren Informationen (wie
  Personennamen, E-Mail-Adressen, Passwörter usw.) sammeln. Verwenden Sie die in
  diesem Leitfaden beschriebenen Tools, um diese Daten zu begrenzen und herauszufiltern.
</Warning>

## Parameter-Filterung

Die grundlegende Parameter-Filterung in den AppSignal-Integrationen funktioniert mit einer Denylist, einer Liste von Schlüsseln, die herausgefiltert und nicht gesendet werden sollen.
Sie können in der AppSignal-Konfiguration eine Option "Parameter filtern" mit einer Liste der zu filternden Parameter-Schlüssel setzen.

Werte von Parametern, die Sie zum Herausfiltern konfiguriert haben, werden durch einen `[FILTERED]`-Wert ersetzt. Auf diese Weise enthält die Liste der Parameter in den App-Daten auf AppSignal.com weiterhin den Parameter-Schlüssel, aber nicht den Wert, sodass Sie immer noch die Sichtbarkeit haben, dass ein Wert mit potenziell sensiblen Daten gefiltert wurde, bevor er an AppSignal gesendet wurde.

<Tip>
  Einige [Parameter-Schlüssel werden auch durch unseren
  Prozessor entfernt](/application/parameter-filtering#processor-parameter-filtering)
  auf unseren Servern.
</Tip>

### Beispiel

Zum Beispiel führt eine Anwendung mit dieser AppSignal-Konfiguration:

<CodeGroup>
  ```yaml YAML theme={null}
  filter_parameters: ["password"]
  ```
</CodeGroup>

Zu dieser Ansicht für die Parameter einer Web-Anfrage auf AppSignal.com:

<CodeGroup>
  ```json JSON theme={null}
  {
    "password": "[FILTERED]"
  }
  ```
</CodeGroup>

Dieser Leitfaden zeigt Ihnen, wie Sie die Parameter-Filterungs-Denylist Ihrer Anwendung basierend auf der von Ihrer Anwendung verwendeten Sprache konfigurieren:

* [Ruby](#ruby)
* [Elixir](#elixir)
* [Node.js](#nodejs)
* [Python](#python)
* [Go](#go)
* [Java](#java)
* [PHP](#php)

## Ruby

Das [AppSignal-for-Ruby](/ruby)-Gem hat zwei Methoden zur Parameter-Filterung:

* Wenn Ihre App Rails verwendet, können Sie die [Rails-Konfiguration direkt](/guides/filter-data/filter-parameters#rails-parameter-filtering) verwenden.
* Wenn Ihre App ein anderes Framework wie Sinatra oder Padrino verwendet, können Sie stattdessen die [eingebaute Filterung von AppSignal](#rails-parameter-filtering) verwenden.

### AppSignal-Parameter-Filterung {/* id: appsignal-parameter-filtering */}

Verwenden Sie die Denylist für die grundlegende Parameter-Filterung. Diese Parameter-Filterung wird auf alle Query-Parameter in einer HTTP-Anfrage und alle Argumente für Background-Jobs angewendet.

Diese Filterung unterstützt schlüsselbasierte Filterung für Hashes, deren Werte durch `[FILTERED]` ersetzt werden. Es gibt Unterstützung für verschachtelte Hashes und verschachtelte Hashes in Arrays. Jeder Hash, dem wir in Ihren Parametern begegnen, wird gefiltert.

Um diese Filterung zu verwenden, fügen Sie Folgendes zu Ihrer `config/appsignal.yml`-Datei in der Umgebungsgruppe hinzu, in der sie gelten soll. Der [`filter_parameters`](/ruby/configuration/options#option-filter_parameters)-Wert ist ein Array von Strings.

<CodeGroup>
  ```ruby Ruby theme={null}
  Appsignal.configure do |config|
    config.filter_parameters << "password"
  end
  ```

  ```yaml YAML theme={null}
  production:
    filter_parameters:
      - password
      - confirm_password
  ```
</CodeGroup>

### Rails-Parameter-Filterung

Glücklicherweise bietet Rails einen Mechanismus zur Filterung von Request-Parametern, um Daten aus Log-Dateien zu entfernen.

AppSignal nutzt diesen Mechanismus zur Request-Parameter-Filterung, sodass sowohl Ihre Request-Logs als auch die an AppSignal gesendeten Request-Daten durch eine Konfiguration gefiltert werden. Angenommen, die Anwendung sollte dieselben Schlüssel für Request-Parameter und Job-Argumente filtern, die für verschiedene Ruby-Gems wie Sidekiq-Job-Argumente gemeldet werden. In diesem Fall ist es notwendig, die Parameter-Filterung in AppSignal mit der [`filter_parameters`-Option](/ruby/configuration/options#option-filter_parameters) zu konfigurieren, um auch die in der Rails-Konfiguration gesetzten Schlüssel einzubeziehen, da die Rails-Parameter-Filterungs-Konfiguration für diese Gems nicht wiederverwendet wird.

#### Denylist: Bestimmte Schlüssel filtern

Es gibt zwei Möglichkeiten zu bestimmen, welche Schlüssel gefiltert werden. Die erste besteht darin, bestimmte Schlüssel zur Denylist hinzuzufügen. Im folgenden Beispiel wird der Wert von `:secret` in jedem Post in der App durch `[FILTERED]` ersetzt.

<CodeGroup>
  ```ruby Ruby theme={null}
  module Blog
    class Application < Rails::Application
      config.filter_parameters << :secrets
    end
  end
  ```
</CodeGroup>

Der Nachteil dieses Ansatzes ist, dass er bei größeren, komplexeren Anwendungen komplizierter ist, insbesondere bei der Verwendung von Funktionen wie `accepts_nested_attributes_for`. Wenn wir vergessen, Schlüssel explizit hinzuzufügen, werden sie nicht gefiltert.

#### Allowlist: Bestimmte Schlüssel zulassen

Die Verwendung einer Lambda anstelle einer Liste von Schlüsseln bietet mehr Flexibilität. Im folgenden Beispiel verwenden wir eine Lambda, um eine Allowlist anstelle einer Denylist einzurichten.

<CodeGroup>
  ```ruby Ruby theme={null}
  ALLOWED_KEYS_MATCHER = /((^|_)ids?|action|controller|code$)/.freeze
  SANITIZED_VALUE = '[FILTERED]'.freeze

  Rails.application.config.filter_parameters << lambda do |key, value|
    unless key.match(ALLOWED_KEYS_MATCHER)
      value.replace(SANITIZED_VALUE) if value.is_a?(String)
    end
  end
  ```
</CodeGroup>

Sie können die Lambda jeden beliebigen Schlüssel prüfen lassen, sodass Sie eine Filtermethode bestimmen und verwenden können, die am besten zu den Anforderungen Ihrer Anwendung passt.

Weitere Informationen zur Filterung von Parametern finden Sie in den Rails-Leitfäden zu [ActionController](http://guides.rubyonrails.org/action_controller_overview.html#parameters-filtering).

## Elixir

Wenn Ihre App Phoenix verwendet, können Sie die [Phoenix-Parameter-Filterung](/guides/filter-data/filter-parameters#phoenix-filter_parameters-configuration) verwenden. Sie können die eingebaute Filterung von AppSignal verwenden, wenn Ihre App ein anderes Elixir-Framework verwendet.

### AppSignal-Parameter-Filterung {/* id: elixir-appsignal-parameter-filtering */}

Verwenden Sie die Denylist für die grundlegende Parameter-Filterung. Diese Parameter-Filterung wird auf alle Query-Parameter in einer HTTP-Anfrage angewendet.

Richten Sie die Parameter-Filterung mit der [`filter_parameters`-Konfigurationsoption](/elixir/configuration/options#option-filter_parameters) ein. Der filter\_parameters-Wert ist eine Liste von Strings.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :appsignal, :config,
    filter_parameters: ["password", "secret"]
  ```
</CodeGroup>

### Phoenix-Konfiguration filter\_parameters

Verwenden Sie die Parameter-Filterung von Phoenix, um Ihre Konfiguration zentral zu halten, die verwendet wird, um sensible Informationen aus den Logs herauszuhalten. AppSignal folgt diesen Filterregeln.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :phoenix,
    :filter_parameters, ["password", "secret"]
  ```
</CodeGroup>

Wenn die Konfigurationsoption `filter_parameters` nicht gesetzt ist, verwendet Phoenix standardmäßig `["password"]` als Konfiguration. Dies bedeutet, dass eine Phoenix-App ohne Konfiguration keine Passwörter an AppSignal sendet.

## Node.js

Verwenden Sie die `filterParameters`-Denylist für die grundlegende Parameter-Filterung. Diese Filterung wird auf alle Parameter einer HTTP-Anfrage angewendet.

Sie können die Parameter-Filterung mit der [`filterParameters`-Konfigurationsoption](/nodejs/3.x/configuration/options#option-filterparameters) einrichten. Der `filterParameters`-Wert ist ein Array von Strings.

<CodeGroup>
  ```javascript Node.js theme={null}
  const { Appsignal } = require("@appsignal/nodejs");

  new Appsignal({
    // Andere Konfigurationsoptionen
    filterParameters: ["password", "secret"],
  });
  ```
</CodeGroup>

## Python

Verwenden Sie die `filter_parameters`-Denylist für die grundlegende Parameter-Filterung. Diese Filterung wird auf alle Parameter einer HTTP-Anfrage angewendet.

Sie können die Parameter-Filterung mit der [`filter_parameters`-Konfigurationsoption](/python/configuration/options#option-filter_parameters) einrichten. Der `filter_parameters`-Wert ist ein Array von Strings.

<CodeGroup>
  ```python Python theme={null}
  from appsignal import Appsignal

  appsignal = Appsignal(
      # Andere Konfiguration
      filter_parameters: ["password", "secret"]
  )
  ```
</CodeGroup>

## Go

Für Go melden wir die Request-Parameter als Query-Parameter (`?query=text`) und Payload-Daten (POST-Request-Payload).

Verwenden Sie die [`filter_request_query_parameters`-Denylist](/go/configuration/options#option-filter_request_query_parameters) für die Filterung von Request-Query-Parametern. Setzen Sie die [`send_request_query_parameters`-Option](/go/configuration/options#option-send_request_query_parameters) auf `false`, um überhaupt keine Request-Query-Parameter zu senden.

Verwenden Sie die [`filter_request_payload`-Denylist](/go/configuration/options#option-filter_request_payload) für die Filterung von Request-Payload-Daten. Setzen Sie die [`send_request_payload`-Option](/go/configuration/options#option-send_request_payload) auf `false`, um überhaupt keine Request-Payload-Daten zu senden.

Weitere Informationen zur Konfiguration von OpenTelemetry für Go-Apps finden Sie auf der [Go-Konfigurationsseite](/go/configuration/options).

<CodeGroup>
  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	attribute.StringSlice("appsignal.config.filter_request_query_parameters", []string{"password", "cvv"}),
  	attribute.StringSlice("appsignal.config.filter_request_payload", []string{"password", "cvv"}),
  )
  ```
</CodeGroup>

## Java

Für Java melden wir die Request-Parameter als Query-Parameter (`?query=text`) und Payload-Daten (POST-Request-Payload).

Verwenden Sie die [`filter_request_query_parameters`-Denylist](/java/configuration/options#option-filter_request_query_parameters) für die Filterung von Request-Query-Parametern. Setzen Sie die [`send_request_query_parameters`-Option](/java/configuration/options#option-send_request_query_parameters) auf `false`, um überhaupt keine Request-Query-Parameter zu senden.

Verwenden Sie die [`filter_request_payload`-Denylist](/java/configuration/options#option-filter_request_payload) für die Filterung von Request-Payload-Daten. Setzen Sie die [`send_request_payload`-Option](/java/configuration/options#option-send_request_payload) auf `false`, um überhaupt keine Request-Payload-Daten zu senden.

Weitere Informationen zur Konfiguration von OpenTelemetry für Java-Apps finden Sie auf der [Java-Konfigurationsseite](/java/configuration/options).

<CodeGroup>
  ```bash Bash theme={null}
  function encode() {
    echo -n "$@" | sed 's/,/%2C/g'
  }

  export OTEL_RESOURCE_ATTRIBUTES="\
    appsignal.config.filter_request_query_parameters=$(encode "password,cvv"),\
    appsignal.config.filter_request_payload=$(encode "password,cvv"),\
    ..."
  ```
</CodeGroup>

## PHP

Für PHP melden wir die Request-Parameter als Query-Parameter (`?query=text`) und Payload-Daten (POST-Request-Payload).

Verwenden Sie die [`filter_request_query_parameters`-Denylist](/php/configuration/options#option-filter_request_query_parameters) für die Filterung von Request-Query-Parametern. Setzen Sie die [`send_request_query_parameters`-Option](/php/configuration/options#option-send_request_query_parameters) auf `false`, um überhaupt keine Request-Query-Parameter zu senden.

Verwenden Sie die [`filter_request_payload`-Denylist](/php/configuration/options#option-filter_request_payload) für die Filterung von Request-Payload-Daten. Setzen Sie die [`send_request_payload`-Option](/php/configuration/options#option-send_request_payload) auf `false`, um überhaupt keine Request-Payload-Daten zu senden.

Weitere Informationen zur Konfiguration von AppSignal für PHP finden Sie auf der [PHP-Konfigurationsseite](/php/configuration/options).

<CodeGroup>
  ```php PHP theme={null}
  return [
      'filter_request_query_parameters' => ['password', 'cvv'],
      'filter_request_payload' => ['password', 'cvv'],
      // ... andere Optionen
  ];
  ```
</CodeGroup>

[parameter filtering]: /application/parameter-filtering.html