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

AppSignal kan worden geconfigureerd via OpenTelemetry resource-attributen. Op deze pagina beschrijven wij hoe u resource-attributen kunt configureren en welke attributen kunnen worden ingesteld.

## OpenTelemetry resource-attributen configureren

U kunt OpenTelemetry configureren om gegevens naar AppSignal te sturen met behulp van resource-attributen.

Resource-attributen zijn attributen die van toepassing zijn op elke trace die door de applicatie via OpenTelemetry wordt gerapporteerd.

U kunt resource-attributen configureren in uw OpenTelemetry-configuratiebestand; dit is ook waar u de OpenTelemetry-exporter moet instellen om gegevens naar de [AppSignal collector](/opentelemetry/installation) te sturen.

<CodeGroup>
  ```go Go theme={null}
  import (
  	// Andere 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(
  	// Voeg hier resource-attributen toe
  	semconv.ServiceNameKey.String("My service name"),
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My app name")),
  )

  tp := sdktrace.NewTracerProvider(
  	// Andere .With...-aanroepen
  	sdktrace.WithResource(res),
  )
  ```
</CodeGroup>

## App-naam

* Attribuutnaam: `appsignal.config.name`
* Of als request-header: `Appsignal-Config-Name`
* Type: String
* Vereist: Ja

Naam van uw applicatie zoals deze op AppSignal.com moet worden weergegeven.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.name", "My awesome app")),
  )
  ```
</CodeGroup>

## App-omgeving

* Attribuutnaam: `appsignal.config.environment`
* Of als request-header: `Appsignal-Config-Environment`
* Type: String
* Vereist: Ja

De omgeving van de applicatie zoals deze op AppSignal.com moet worden weergegeven.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
  # Voeg deze regel toe aan de resource-attributen
  "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.environment", "production")),
  )
  ```
</CodeGroup>

## Push API-sleutel

* Attribuutnaam: `appsignal.config.push_api_key`
* Of als request-header: `Appsignal-Config-PushApiKey`
* Type: String
* Vereist: Ja

De authenticatiesleutel op organisatieniveau om te authenticeren bij onze Push API.

Voor gedetailleerde informatie over de [AppSignal Push API-sleutel](/appsignal/terminology#push-api-key), raadpleeg onze terminologiedocumentatie.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.push_api_key", "00000000-0000-0000-0000-000000000000")),
  )
  ```
</CodeGroup>

## App-revisie

* Attribuutnaam: `appsignal.config.revision`
* Of als request-header: `Appsignal-Config-Revision`
* Type: String
* Vereist: Ja

Om nieuwe deploys van OpenTelemetry-applicaties te rapporteren, kunt u [Deploy Markers](/application/markers/deploy-markers) gebruiken.

Deploy markers kunnen worden geconfigureerd met het revisie-resource-attribuut. De waarde van dit attribuut wordt gebruikt om nieuwe deploys te identificeren. De waarde moet uniek zijn per deploy om nieuwe deploys op te pikken. Wij raden aan om Git commit-SHA's of een tag in uw SCM te gebruiken. Dit kan in combinatie met onze [backtrace links](/application/backtrace-links) worden gebruikt om vanuit AppSignal rechtstreeks terug te linken naar de broncode op platforms zoals GitHub en GitLab.

<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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.revision", revision)),
  )
  ```
</CodeGroup>

## Taalintegratie

* Attribuutnaam: `appsignal.config.language_integration`
* Of als request-header: `Appsignal-Config-LanguageIntegration`
* Type: String
* Vereist: Ja

AppSignal gebruikt het resource-attribuut `language_integration` om de taal van een trace te detecteren en exception-backtraces correct te ontleden.

Om deze optie in te stellen, geeft u de naam van de taal in kleine letters op, bijv. "python", "rust", "ruby", "elixir", "go" en "nodejs".

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.language_integration", "go")),
  )
  ```
</CodeGroup>

## OTP-appnaam

* Attribuutnaam: `appsignal.config.otp_app`
* Type: String
* Vereist: Ja, voor Elixir-apps

AppSignal gebruikt het resource-attribuut `appsignal.config.otp_app` om te detecteren welke backtrace-regels uit fouten bij de applicatie horen.

U kunt de OTP-appnaam voor uw applicatie vinden door `IO.inspect(:application.get_application())` in uw applicatie aan te roepen en de uitvoer te controleren.

<CodeGroup>
  ```elixir Elixir theme={null}
  config :opentelemetry,
    resource: [
      {"appsignal.config.otp_app", "OTP app name"},
      # En andere resource-attributen
    ]
  ```
</CodeGroup>

## Servicenaam

* Attribuutnaam: `service.name`
* Of als request-header: `OpenTelemetry-ServiceName`
* Type: String
* Vereist: Ja

Het resource-attribuut `service.name` helpt AppSignal verschillende services voor traces te herkennen en groepeert de traces automatisch in een namespace op basis van de servicenaam.

Kies een naam die past bij uw applicatie, zoals "Web server", "Background worker", "Email service", "Authentication service", enz.

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

  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("service.name", "My service name")),
  )
  ```
</CodeGroup>

## Hostname

* Attribuutnaam: `host.name`
* Of als request-header: `OpenTelemetry-HostName`
* Type: String
* Vereist: Ja

Het resource-attribuut `host.name` helpt AppSignal verschillende hosts voor traces te herkennen en tagt de traces automatisch met de hostname.

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

  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("host.name", hostname)),
  )
  ```
</CodeGroup>

## App-pad

* Attribuutnaam: `appsignal.config.app_path`
* Type: String
* Vereist: Nee

De locatie van de app op het bestandssysteem van de host.

Het resource-attribuut `app_path` helpt AppSignal backtraces op te schonen door het absolute app-pad uit backtrace-regels te verwijderen. Op deze manier worden alleen paden binnen de context van de projectdirectory getoond. Dit maakt onze functie [Backtrace links](/application/backtrace-links) mogelijk.

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

  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	resource.WithAttributes(attribute.String("appsignal.config.app_path", os.Getenv("PWD"))),
  )
  ```
</CodeGroup>

## Attributen filteren

* Attribuutnaam: `appsignal.config.filter_attributes`
* Type: Array
* Vereist: Nee

Het resource-attribuut `filter_attributes` stelt u in staat om specifieke attributen uit te filteren zodat deze niet aan AppSignal worden gerapporteerd. Dit kan handig zijn om gevoelige of niet-relevante informatie eruit te filteren.

Als een attribuut op deze manier wordt uitgefilterd, verschijnt het helemaal niet in de interface.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.filter_attributes", []string{"my.secret.attribute", "some.opentelemetry.attribute"}),
  )
  ```
</CodeGroup>

## Functieparameters filteren

* Attribuutnaam: `appsignal.config.filter_function_parameters`
* Type: Array
* Standaardwaarde: *Leeg*
* Vereist: Nee

Het resource-attribuut `filter_function_parameters` stelt u in staat om functieparameters uit te filteren die zijn ingesteld in het [`appsignal.function.parameters` span-attribuut](/opentelemetry/custom-instrumentation/attributes#function-parameters).

In het onderstaande voorbeeld worden waarden voor de sleutels die in de configuratieoptie `filter_function_parameters` worden vermeld, vervangen door `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configureer de resource van de exporter als volgt:
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.filter_function_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest van de exporter-configuratie...

  # Stel vervolgens in de trace het span-attribuut voor functieparameters in
  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}
  // Configureer de resource van de exporter als volgt:
  import (
  	"go.opentelemetry.io/otel/attribute"
  	"go.opentelemetry.io/otel/trace"
  	"go.opentelemetry.io/otel/sdk/resource"
  )

  res := resource.NewWithAttributes(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.filter_function_parameters", []string{"password", "cvv"}),
  )
  // Rest van de exporter-configuratie...

  // Stel vervolgens in de trace het span-attribuut voor functieparameters in
  import (
  	"encoding/json"

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

  // De context moet de actieve span bevatten die u wilt extraheren
  // Zoals `c.Request.Context()` voor 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-parameters filteren

* Attribuutnaam: `appsignal.config.filter_request_query_parameters`
* Type: Array
* Standaardwaarde: *Leeg*
* Vereist: Nee

Het resource-attribuut `filter_request_query_parameters` stelt u in staat om query-parameters van requests uit te filteren die zijn ingesteld in het [`appsignal.request.query_parameters` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

In het onderstaande voorbeeld worden waarden voor de sleutels die in de configuratieoptie `filter_request_query_parameters` worden vermeld, vervangen door `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configureer de resource van de exporter als volgt:
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.filter_request_query_parameters": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest van de exporter-configuratie...

  # Stel vervolgens in de trace het span-attribuut voor query-parameters in
  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}
  // Configureer de resource van de exporter als volgt:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.filter_request_query_parameters", []string{"password", "cvv"}),
  )
  // Rest van de exporter-configuratie...

  // Stel vervolgens in de trace het span-attribuut voor query-parameters in
  import (
  	"encoding/json"

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

  // De context moet de actieve span bevatten die u wilt extraheren
  // Zoals `c.Request.Context()` voor 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 filteren

* Attribuutnaam: `appsignal.config.filter_request_payload`
* Type: Array
* Standaardwaarde: *Leeg*
* Vereist: Nee

Het resource-attribuut `filter_request_payload` stelt u in staat om payload-gegevens van requests uit te filteren die zijn ingesteld in het [`appsignal.request.payload` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-payload).

In het onderstaande voorbeeld worden waarden voor de sleutels die in de configuratieoptie `filter_request_payload` worden vermeld, vervangen door `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configureer de resource van de exporter als volgt:
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.filter_request_payload": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest van de exporter-configuratie...

  # Stel vervolgens in de trace het span-attribuut voor de request-payload in
  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}
  // Configureer de resource van de exporter als volgt:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.filter_request_payload", []string{"password", "cvv"}),
  )
  // Rest van de exporter-configuratie...

  // Stel vervolgens in de trace het span-attribuut voor functieparameters in
  import (
  	"encoding/json"

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

  // De context moet de actieve span bevatten die u wilt extraheren
  // Zoals `c.Request.Context()` voor 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-sessiegegevens filteren

* Attribuutnaam: `appsignal.config.filter_request_session_data`
* Type: Array
* Standaardwaarde: *Leeg*
* Vereist: Nee

Het resource-attribuut `filter_request_session_data` stelt u in staat om sessiegegevens van requests uit te filteren die zijn ingesteld in het [`appsignal.request.session_data` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-session-data).

In het onderstaande voorbeeld worden waarden voor de sleutels die in de configuratieoptie `filter_request_session_data` worden vermeld, vervangen door `[FILTERED]`.

<CodeGroup>
  ```python Python theme={null}
  # Configureer de resource van de exporter als volgt:
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.filter_request_session_data": ["password", "cvv"],
  }

  resource = Resource(attributes=attributes)

  # Rest van de exporter-configuratie...

  # Stel vervolgens in de trace het span-attribuut voor sessiegegevens in
  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}
  // Configureer de resource van de exporter als volgt:
  import (
  	"encoding/json"

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

  res := resource.NewWithAttributes(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.filter_session_data", []string{"password", "cvv"}),
  )
  // Rest van de exporter-configuratie...

  // Stel vervolgens in de trace het span-attribuut voor sessiegegevensparameters in
  import (
  	"encoding/json"

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

  // De context moet de actieve span bevatten die u wilt extraheren
  // Zoals `c.Request.Context()` voor 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>

## Acties negeren

* Attribuutnaam: `appsignal.config.ignore_actions`
* Type: Array van Strings
* Vereist: Nee

Het resource-attribuut `ignore_actions` stelt u in staat om specifieke acties te negeren zodat deze niet aan AppSignal worden gerapporteerd. Dit kan handig zijn om health check-endpoints of andere acties die u niet wilt monitoren, te negeren.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.ignore_actions", []string{"GET /heath_check", "POST /ping"}),
  )
  ```
</CodeGroup>

## Fouten negeren

* Attribuutnaam: `appsignal.config.ignore_errors`
* Type: Array van Strings
* Vereist: Nee

Het resource-attribuut `ignore_errors` stelt u in staat om specifieke fouten te negeren zodat deze niet aan AppSignal worden gerapporteerd. Dit kan handig zijn om verwachte fouten of fouten die niet kunnen worden opgelost, te negeren.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.ignore_errors", []string{"MyCustomError", "ExpectedError"}),
  )
  ```
</CodeGroup>

## Namespaces negeren

* Attribuutnaam: `appsignal.config.ignore_namespaces`
* Type: Array van Strings
* Vereist: Nee

Het resource-attribuut `ignore_namespaces` stelt u in staat om specifieke namespaces te negeren zodat deze niet aan AppSignal worden gerapporteerd. Dit kan handig zijn om specifieke onderdelen van uw applicatie niet te monitoren.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "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(
  	// Andere resource-attributen
  	attribute.StringSlice("appsignal.config.ignore_namespaces", []string{"admin", "secret"}),
  )
  ```
</CodeGroup>

## Response-headers

* Attribuutnaam: `appsignal.config.response_headers`
* Type: Array van Strings
* Standaardwaarde: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Vereist: Nee

Configureer welke response-headers moeten worden opgenomen wanneer een request door een HTTP-client wordt gedaan. Deze optie is een allowlist. Alleen de geconfigureerde headers worden opgenomen. Als de lijst leeg is, worden er geen headers opgenomen.

De response-headers worden gelezen uit de [OpenTelemetry span-attributen](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.response.header.<key>`, waarbij `<key>` de genormaliseerde headernaam is (kleine letters).

Om geen headers in te stellen, stelt u de waarde van het resource-attribuut expliciet in op een lege array.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Stuur alleen deze specifieke headers
      "appsignal.config.response_headers": ["accept", "request_method", "content_length"]

      # Stuur geen headers
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Stuur alleen deze specifieke headers
  	attribute.StringSlice("appsignal.config.response_headers", []string{"accept", "request_method", "content_length"}),

  	// Stuur geen headers
  	attribute.StringSlice("appsignal.config.response_headers", []string{}),
  )
  ```
</CodeGroup>

## Request-headers

* Attribuutnaam: `appsignal.config.request_headers`
* Type: Array van Strings
* Standaardwaarde: `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Vereist: Nee

Configureer welke request-headers moeten worden opgenomen wanneer een request naar een HTTP-server wordt gedaan. Deze optie is een allowlist. Alleen de geconfigureerde headers worden opgenomen. Als de lijst leeg is, worden er geen headers opgenomen.

De request-headers worden gelezen uit de [OpenTelemetry span-attributen](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.request.header.<key>`, waarbij `<key>` de genormaliseerde headernaam is (kleine letters).

Om geen headers in te stellen, stelt u de waarde van het resource-attribuut expliciet in op een lege array.

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Stuur alleen deze specifieke headers
      "appsignal.config.request_headers": ["accept", "request_method", "content_length"]

      # Stuur geen headers
      "appsignal.config.response_headers": []
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Stuur alleen deze specifieke headers
  	attribute.StringSlice("appsignal.config.request_headers", []string{"accept", "request_method", "content_length"}),

  	// Stuur geen headers
  	attribute.StringSlice("appsignal.config.request_headers", []string{}),
  )
  ```
</CodeGroup>

## Functieparameters verzenden

* Attribuutnaam: `appsignal.config.send_function_parameters`
* Type: Boolean
* Standaardwaarde: `true`
* Vereist: Nee

Configureer of functieparameters in traces moeten worden opgenomen. Als deze is ingesteld op `false`, worden dergelijke gegevens niet naar onze servers gestuurd.

Deze waarden worden ingesteld met het [`appsignal.function.parameters` span-attribuut](/opentelemetry/custom-instrumentation/attributes#function-parameters).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.send_function_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Voeg deze regel toe aan de resource-attributen
  	attribute.Bool("appsignal.config.send_function_parameters", false),
  )
  ```
</CodeGroup>

## Request query-parameters verzenden

* Attribuutnaam: `appsignal.config.send_request_query_parameters`
* Type: Boolean
* Standaardwaarde: `true`
* Vereist: Nee

Configureer of query-parameters van requests in traces moeten worden opgenomen. Als deze is ingesteld op `false`, worden dergelijke gegevens niet naar onze servers gestuurd.

Deze waarden worden ingesteld met het [`appsignal.request.query_parameters` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

Voor meer informatie kunt u lezen over [request parameter-filtering](/application/parameter-filtering).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.send_request_query_parameters": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
      // Voeg deze regel toe aan de resource-attributen
  	attribute.Bool("appsignal.config.send_request_query_parameters", false),
  )
  ```
</CodeGroup>

## Request-payload verzenden

* Attribuutnaam: `appsignal.config.send_request_payload`
* Type: Boolean
* Standaardwaarde: `true`
* Vereist: Nee

Configureer of payload-gegevens van requests in traces moeten worden verzonden. Als deze is ingesteld op `false`, worden dergelijke gegevens niet naar onze servers gestuurd.

Deze waarden worden ingesteld met het [`appsignal.request.payload` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-payload).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.send_request_payload": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Voeg deze regel toe aan de resource-attributen
  	attribute.Bool("appsignal.config.send_request_payload", false),
  )
  ```
</CodeGroup>

## Request-sessiegegevens verzenden

* Attribuutnaam: `appsignal.config.send_request_session_data`
* Type: Boolean
* Standaardwaarde: `true`
* Vereist: Nee

Configureer of sessiegegevens van requests in traces moeten worden verzonden. Als deze is ingesteld op `false`, worden dergelijke gegevens niet naar onze servers gestuurd.

Deze waarden worden ingesteld met het [`appsignal.request.session_data` span-attribuut](/opentelemetry/custom-instrumentation/attributes#request-session-data).

<CodeGroup>
  ```python Python theme={null}
  attributes = {
      # Voeg deze regel toe aan de resource-attributen
      "appsignal.config.send_request_session_data": false
  }

  resource = Resource(attributes=attributes)
  ```

  ```go Go theme={null}
  res := resource.NewWithAttributes(
  	// Voeg deze regel toe aan de resource-attributen
  	attribute.Bool("appsignal.config.send_session_data", false),
  )
  ```
</CodeGroup>