> ## 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.

# OpenTelemetry-Konfigurationsoptionen

AppSignal kann über OpenTelemetry-Ressourcenattribute konfiguriert werden. Auf dieser Seite beschreiben wir, wie Ressourcenattribute konfiguriert werden und welche Attribute gesetzt werden können.

## OpenTelemetry-Ressourcenattribute konfigurieren

Sie können OpenTelemetry mithilfe von Ressourcenattributen so konfigurieren, dass es Daten an AppSignal sendet.

Ressourcenattribute sind Attribute, die für jeden Trace gelten, der von der Anwendung über OpenTelemetry gemeldet wird.

Sie können Ressourcenattribute in Ihrer OpenTelemetry-Konfigurationsdatei konfigurieren. Dort müssen Sie auch den OpenTelemetry-Exporter so einrichten, dass er Daten an den [AppSignal Collector](/opentelemetry/installation) sendet.

<CodeGroup>
  ```go Go theme={null}
  import (
  	// Other imports ....
  	"go.opentelemetry.io/otel/sdk/resource"
  	semconv "go.opentelemetry.io/otel/semconv/v1.27.0"
  	sdktrace "go.opentelemetry.io/otel/sdk/trace"
  )

  res := resource.NewSchemaless(
  	// Add resource attributes here
  	semconv.ServiceNameKey.String("My service name"),
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My app name")),
  )

  tp := sdktrace.NewTracerProvider(
  	// Other .With... calls
  	sdktrace.WithResource(res),
  )
  ```
</CodeGroup>

## App-Name

* Attributname: `appsignal.config.name`
* Oder als Anforderungsheader: `Appsignal-Config-Name`
* Typ: String
* Erforderlich: Ja

Name Ihrer Anwendung, wie er auf AppSignal.com angezeigt werden soll.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.name": "My awesome app",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My awesome app")),
  )
  ```
</CodeGroup>

## App-Umgebung

* Attributname: `appsignal.config.environment`
* Oder als Anforderungsheader: `Appsignal-Config-Environment`
* Typ: String
* Erforderlich: Ja

Die Umgebung der Anwendung, wie sie auf AppSignal.com angezeigt werden soll.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
  # Add this line to the resource attributes
  "appsignal.config.environment": "staging",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.environment", "production")),
  )
  ```
</CodeGroup>

## Push API-Schlüssel

* Attributname: `appsignal.config.push_api_key`
* Oder als Anforderungsheader: `Appsignal-Config-PushApiKey`
* Typ: String
* Erforderlich: Ja

Der Authentifizierungsschlüssel auf Organisationsebene zur Authentifizierung bei unserer Push-API.

Detaillierte Informationen zum [AppSignal Push API-Schlüssel](/appsignal/terminology#push-api-key) finden Sie in unserer Terminologie-Dokumentation.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.push_api_key": "00000000-0000-0000-0000-000000000000",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.push_api_key", "00000000-0000-0000-0000-000000000000")),
  )
  ```
</CodeGroup>

## App-Revision

* Attributname: `appsignal.config.revision`
* Oder als Anforderungsheader: `Appsignal-Config-Revision`
* Typ: String
* Erforderlich: Ja

Um neue Deployments von OpenTelemetry-Anwendungen zu melden, können Sie [Deploy Markers](/application/markers/deploy-markers) verwenden.

Deploy Markers können mit dem Revisions-Ressourcenattribut konfiguriert werden. Der Wert dieses Attributs wird verwendet, um neue Deployments zu identifizieren. Er muss pro Deployment eindeutig sein, damit neue Deployments erkannt werden. Wir empfehlen die Verwendung von Git-Commit-SHAs oder eines Tags in Ihrem SCM. Dies kann in Kombination mit unseren [Backtrace-Links](/application/backtrace-links) verwendet werden, um direkt von AppSignal zum Quellcode auf Plattformen wie GitHub und GitLab zu verlinken.

<CodeGroup>
  ```python Python theme={null}
  import subprocess

  attributes = {
      # ...
  }

  try:
    revision = subprocess.check_output("git rev-parse --short HEAD", shell=True, text=True).strip()
    attributes["appsignal.config.revision"] = revision
  except subprocess.CalledProcessError:
    pass

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os/exec"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  var revision string
  cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
  output, err := cmd.Output()
  if err != nil {
  	revision = "unknown"
  } else {
  	revision = strings.TrimSpace(string(output))
  }

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.revision", revision)),
  )
  ```
</CodeGroup>

## Sprachintegration

* Attributname: `appsignal.config.language_integration`
* Oder als Anforderungsheader: `Appsignal-Config-LanguageIntegration`
* Typ: String
* Erforderlich: Ja

AppSignal verwendet das Ressourcenattribut `language_integration`, um die Sprache eines Traces zu erkennen und Exception-Backtraces korrekt zu parsen.

Um diese Option festzulegen, geben Sie den Sprachnamen in Kleinbuchstaben an, z. B. "python", "rust", "ruby", "elixir", "go" und "nodejs".

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.language_integration": "python",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.language_integration", "go")),
  )
  ```
</CodeGroup>

## OTP-App-Name

* Attributname: `appsignal.config.otp_app`
* Typ: String
* Erforderlich: Ja, für Elixir-Apps

AppSignal verwendet das Ressourcenattribut `appsignal.config.otp_app`, um zu erkennen, welche Backtrace-Zeilen von Fehlern zur Anwendung gehören.

Sie finden den OTP-App-Namen für Ihre Anwendung, indem Sie `IO.inspect(:application.get_application())` in Ihrer Anwendung aufrufen und die Ausgabe überprüfen.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :opentelemetry,
    resource: [
      {"appsignal.config.otp_app", "OTP app name"},
      # And other resource attributes
    ]
  ```
</CodeGroup>

## Service-Name

* Attributname: `service.name`
* Oder als Anforderungsheader: `OpenTelemetry-ServiceName`
* Typ: String
* Erforderlich: Ja

Das Ressourcenattribut `service.name` hilft AppSignal, verschiedene Dienste für Traces zu erkennen und gruppiert die Traces automatisch in einem Namespace basierend auf dem Service-Namen.

Wählen Sie einen Namen, der zu Ihrer Anwendung passt, wie "Web server", "Background worker", "Email service", "Authentication service" usw.

<CodeGroup>
  ```python Python theme={null}
  import socket

  attributes = {
      # Add this line to the resource attributes
      "service.name": "My service name",
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("service.name", "My service name")),
  )
  ```
</CodeGroup>

## Hostname

* Attributname: `host.name`
* Oder als Anforderungsheader: `OpenTelemetry-HostName`
* Typ: String
* Erforderlich: Ja

Das Ressourcenattribut `host.name` hilft AppSignal, verschiedene Hosts für Traces zu erkennen und kennzeichnet die Traces automatisch mit dem Hostnamen.

<CodeGroup>
  ```python Python theme={null}
  import socket

  attributes = {
      # Add this line to the resource attributes
      "host.name": socket.gethostname(),
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  hostname, err := os.Hostname()
  if err != nil {
  	hostname = "unknown"
  }

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("host.name", hostname)),
  )
  ```
</CodeGroup>

## App-Pfad

* Attributname: `appsignal.config.app_path`
* Typ: String
* Erforderlich: Nein

Der Speicherort der App im Dateisystem des Hosts.

Das Ressourcenattribut `app_path` hilft AppSignal, Backtraces zu bereinigen, indem der absolute App-Pfad aus den Backtrace-Zeilen entfernt wird. Auf diese Weise werden nur Pfade innerhalb des Kontexts des Projektverzeichnisses angezeigt. Dies macht unsere Funktion [Backtrace-Links](/application/backtrace-links) möglich.

<CodeGroup>
  ```python Python theme={null}
  import os

  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.app_path": os.getcwd()
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"os"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.app_path", os.Getenv("PWD"))),
  )
  ```
</CodeGroup>

## Attribute filtern

* Attributname: `appsignal.config.filter_attributes`
* Typ: Array
* Erforderlich: Nein

Mit dem Ressourcenattribut `filter_attributes` können Sie bestimmte Attribute davon ausschließen, an AppSignal gemeldet zu werden. Dies kann nützlich sein, um sensible oder nicht relevante Informationen herauszufiltern.

Wenn ein Attribut auf diese Weise gefiltert wird, erscheint es überhaupt nicht in der Benutzeroberfläche.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.filter_attributes": ["my.secret.attribute", "some.opentelemetry.attribute"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.filter_attributes", []string{"my.secret.attribute", "some.opentelemetry.attribute"}),
  )
  ```
</CodeGroup>

## Funktionsparameter filtern

* Attributname: `appsignal.config.filter_function_parameters`
* Typ: Array
* Standardwert: *Leer*
* Erforderlich: Nein

Mit dem Ressourcenattribut `filter_function_parameters` können Sie alle Funktionsparameter herausfiltern, die im [Span-Attribut `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters) gesetzt sind.

Im Beispiel unten werden die Werte für die in der Konfigurationsoption `filter_function_parameters` aufgeführten Schlüssel durch `[FILTERED]` ersetzt.

<CodeGroup>
  ```python Python theme={null}
  # Configure the exporter's resource like so:
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.filter_function_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest of the exporter config...

  # Then in the trace, set the function parameters span attribute
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.function.parameters", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure the exporter's resource like so:
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.filter_function_parameters", []string{"password", "cvv"}),
  )
  // Rest of the exporter config...

  // Then in the trace, set the function parameters span attribute
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  // The context needs contain the active span you plan to extract
  // Like `c.Request.Context()` for gin apps
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.function.parameters", string(json)))
  ```
</CodeGroup>

## Request-Query-Parameter filtern

* Attributname: `appsignal.config.filter_request_query_parameters`
* Typ: Array
* Standardwert: *Leer*
* Erforderlich: Nein

Mit dem Ressourcenattribut `filter_request_query_parameters` können Sie alle Request-Query-Parameter herausfiltern, die im [Span-Attribut `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters) gesetzt sind.

Im Beispiel unten werden die Werte für die in der Konfigurationsoption `filter_request_query_parameters` aufgeführten Schlüssel durch `[FILTERED]` ersetzt.

<CodeGroup>
  ```python Python theme={null}
  # Configure the exporter's resource like so:
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.filter_request_query_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest of the exporter config...

  # Then in the trace, set the query parameters span attribute
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.query_parameters", json.dumps({
          "password": "super secret",
          "test_param": "test value"
      }))
  ```

  ```go Go theme={null}
  // Configure the exporter's resource like so:
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.filter_request_query_parameters", []string{"password", "cvv"}),
  )
  // Rest of the exporter config...

  // Then in the trace, set the query parameters span attribute
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  // The context needs contain the active span you plan to extract
  // Like `c.Request.Context()` for gin apps
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.query_parameters", string(json)))
  ```
</CodeGroup>

## Request-Payload filtern

* Attributname: `appsignal.config.filter_request_payload`
* Typ: Array
* Standardwert: *Leer*
* Erforderlich: Nein

Mit dem Ressourcenattribut `filter_request_payload` können Sie alle Request-Payload-Daten herausfiltern, die im [Span-Attribut `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload) gesetzt sind.

Im Beispiel unten werden die Werte für die in der Konfigurationsoption `filter_request_payload` aufgeführten Schlüssel durch `[FILTERED]` ersetzt.

<CodeGroup>
  ```python Python theme={null}
  # Configure the exporter's resource like so:
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.filter_request_payload": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest of the exporter config...

  # Then in the trace, set the request payload span attribute
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.payload", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure the exporter's resource like so:
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.filter_request_payload", []string{"password", "cvv"}),
  )
  // Rest of the exporter config...

  // Then in the trace, set the function parameters span attribute
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  // The context needs contain the active span you plan to extract
  // Like `c.Request.Context()` for gin apps
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  params := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.payload", string(json)))
  ```
</CodeGroup>

## Request-Session-Daten filtern

* Attributname: `appsignal.config.filter_request_session_data`
* Typ: Array
* Standardwert: *Leer*
* Erforderlich: Nein

Mit dem Ressourcenattribut `filter_request_session_data` können Sie alle Request-Session-Daten herausfiltern, die im [Span-Attribut `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data) gesetzt sind.

Im Beispiel unten werden die Werte für die in der Konfigurationsoption `filter_request_session_data` aufgeführten Schlüssel durch `[FILTERED]` ersetzt.

<CodeGroup>
  ```python Python theme={null}
  # Configure the exporter's resource like so:
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.filter_request_session_data": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest of the exporter config...

  # Then in the trace, set the session data span attribute
  import json
  from opentelemetry import trace

  tracer = trace.get_tracer(__name__)
  with tracer.start_as_current_span("something.custom") as span:
      span.set_attribute("appsignal.request.session_data", json.dumps({
          "password": "super secret",
          "test_param": "test value",
          "nested": {
              "password": "super secret nested",
              "test_param": "test value",
          }
      }))
  ```

  ```go Go theme={null}
  // Configure the exporter's resource like so:
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.filter_session_data", []string{"password", "cvv"}),
  )
  // Rest of the exporter config...

  // Then in the trace, set the session data parameters span attribute
  import (
  	"encoding/json"

  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  )

  // The context needs contain the active span you plan to extract
  // Like `c.Request.Context()` for gin apps
  ctx := context.TODO()
  span := trace.SpanFromContext(ctx)
  sessionData := map[string]interface{}{
  	"password": "super secret",
  	"test_param": "test value",
  	"nested": map[string]interface{}{
  		"password": "super secret",
  		"test_param": "test value",
  	},
  }
  json, _ := json.Marshal(sessionData)
  span.SetAttributes(attribute.String("appsignal.request.session_data", string(json)))
  ```
</CodeGroup>

## Aktionen ignorieren

* Attributname: `appsignal.config.ignore_actions`
* Typ: Array of Strings
* Erforderlich: Nein

Mit dem Ressourcenattribut `ignore_actions` können Sie bestimmte Aktionen davon ausschließen, an AppSignal gemeldet zu werden. Dies kann nützlich sein, um Health-Check-Endpunkte oder andere Aktionen zu ignorieren, die Sie nicht überwachen möchten.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.ignore_actions": ["GET /health_check", "POST /ping"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.ignore_actions", []string{"GET /heath_check", "POST /ping"}),
  )
  ```
</CodeGroup>

## Fehler ignorieren

* Attributname: `appsignal.config.ignore_errors`
* Typ: Array of Strings
* Erforderlich: Nein

Mit dem Ressourcenattribut `ignore_errors` können Sie bestimmte Fehler davon ausschließen, an AppSignal gemeldet zu werden. Dies kann nützlich sein, um erwartete Fehler oder Fehler zu ignorieren, die nicht behoben werden können.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.ignore_errors": ["MyCustomError", "ExpectedError"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.ignore_errors", []string{"MyCustomError", "ExpectedError"}),
  )
  ```
</CodeGroup>

## Namespaces ignorieren

* Attributname: `appsignal.config.ignore_namespaces`
* Typ: Array of Strings
* Erforderlich: Nein

Mit dem Ressourcenattribut `ignore_namespaces` können Sie bestimmte Namespaces davon ausschließen, an AppSignal gemeldet zu werden. Dies kann nützlich sein, um bestimmte Teile Ihrer Anwendung von der Überwachung auszuschließen.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.ignore_namespaces": ["admin" ,"secret"],
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Other resource attributes
  	attribute.StringSlice("appsignal.config.ignore_namespaces", []string{"admin", "secret"}),
  )
  ```
</CodeGroup>

## Response-Header

* Attributname: `appsignal.config.response_headers`
* Typ: Array of Strings
* Standardwert: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Erforderlich: Nein

Konfigurieren Sie, welche Response-Header einbezogen werden sollen, wenn eine Anfrage von einem HTTP-Client gestellt wird. Diese Option ist eine Zulassungsliste. Sie schließt nur die konfigurierten Header ein. Wenn die Liste leer ist, werden keine Header einbezogen.

Die Response-Header werden aus den [OpenTelemetry-Span-Attributen](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.response.header.<key>` gelesen, wobei `<key>` der normalisierte Header-Name (in Kleinbuchstaben) ist.

Um keine Header zu setzen, setzen Sie den Wert des Ressourcenattributs explizit auf ein leeres Array.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Only send these specific headers
      "appsignal.config.response_headers": ["accept", "request_method", "content_length"]

      # Do not send any headers
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Only send these specific headers
  	attribute.StringSlice("appsignal.config.response_headers", []string{"accept", "request_method", "content_length"}),

  	// Do not send any headers
  	attribute.StringSlice("appsignal.config.response_headers", []string{}),
  )
  ```
</CodeGroup>

## Request-Header

* Attributname: `appsignal.config.request_headers`
* Typ: Array of Strings
* Standardwert: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Erforderlich: Nein

Konfigurieren Sie, welche Request-Header einbezogen werden sollen, wenn eine Anfrage an einen HTTP-Server gestellt wird. Diese Option ist eine Zulassungsliste. Sie schließt nur die konfigurierten Header ein. Wenn die Liste leer ist, werden keine Header einbezogen.

Die Request-Header werden aus den [OpenTelemetry-Span-Attributen](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.request.header.<key>` gelesen, wobei `<key>` der normalisierte Header-Name (in Kleinbuchstaben) ist.

Um keine Header zu setzen, setzen Sie den Wert des Ressourcenattributs explizit auf ein leeres Array.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Only send these specific headers
      "appsignal.config.request_headers": ["accept", "request_method", "content_length"]

      # Do not send any headers
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Only send these specific headers
  	attribute.StringSlice("appsignal.config.request_headers", []string{"accept", "request_method", "content_length"}),

  	// Do not send any headers
  	attribute.StringSlice("appsignal.config.request_headers", []string{}),
  )
  ```
</CodeGroup>

## Funktionsparameter senden

* Attributname: `appsignal.config.send_function_parameters`
* Typ: Boolean
* Standardwert: `true`
* Erforderlich: Nein

Konfigurieren Sie, ob Funktionsparameter in Traces einbezogen werden sollen. Wenn auf `false` gesetzt, werden keine solchen Daten an unsere Server gesendet.

Diese Werte werden mit dem [Span-Attribut `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters) gesetzt.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.send_function_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Add this line to the resource attributes
  	attribute.Bool("appsignal.config.send_function_parameters", false),
  )
  ```
</CodeGroup>

## Request-Query-Parameter senden

* Attributname: `appsignal.config.send_request_query_parameters`
* Typ: Boolean
* Standardwert: `true`
* Erforderlich: Nein

Konfigurieren Sie, ob Request-Query-Parameter in Traces einbezogen werden sollen. Wenn auf `false` gesetzt, werden keine solchen Daten an unsere Server gesendet.

Diese Werte werden mit dem [Span-Attribut `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters) gesetzt.

Weitere Informationen finden Sie unter [Filterung von Request-Parametern](/application/parameter-filtering).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.send_request_query_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Add this line to the resource attributes
  	attribute.Bool("appsignal.config.send_request_query_parameters", false),
  )
  ```
</CodeGroup>

## Request-Payload senden

* Attributname: `appsignal.config.send_request_payload`
* Typ: Boolean
* Standardwert: `true`
* Erforderlich: Nein

Konfigurieren Sie, ob Request-Payload-Daten in Traces gesendet werden sollen. Wenn auf `false` gesetzt, werden keine solchen Daten an unsere Server gesendet.

Diese Werte werden mit dem [Span-Attribut `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload) gesetzt.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.send_request_payload": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Add this line to the resource attributes
  	attribute.Bool("appsignal.config.send_request_payload", false),
  )
  ```
</CodeGroup>

## Request-Session-Daten senden

* Attributname: `appsignal.config.send_request_session_data`
* Typ: Boolean
* Standardwert: `true`
* Erforderlich: Nein

Konfigurieren Sie, ob Request-Session-Daten in Traces gesendet werden sollen. Wenn auf `false` gesetzt, werden keine solchen Daten an unsere Server gesendet.

Diese Werte werden mit dem [Span-Attribut `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data) gesetzt.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Add this line to the resource attributes
      "appsignal.config.send_request_session_data": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Add this line to the resource attributes
  	attribute.Bool("appsignal.config.send_session_data", false),
  )
  ```
</CodeGroup>