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

# Options de configuration OpenTelemetry

AppSignal peut être configuré via les attributs de ressource OpenTelemetry. Sur cette page, nous décrirons comment configurer les attributs de ressource et quels attributs peuvent être définis.

## Configuration des attributs de ressource OpenTelemetry

Vous pouvez configurer OpenTelemetry pour envoyer des données à AppSignal en utilisant des attributs de ressource.

Les attributs de ressource sont des attributs qui s'appliquent à chaque trace rapportée depuis l'application à l'aide d'OpenTelemetry.

Vous pouvez configurer les attributs de ressource dans votre fichier de configuration OpenTelemetry. C'est également là que vous devez configurer l'exportateur OpenTelemetry pour envoyer des données à l'[AppSignal collector](/opentelemetry/installation).

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

## Nom de l'application

* Nom de l'attribut : `appsignal.config.name`
* Ou en tant qu'en-tête de requête : `Appsignal-Config-Name`
* Type : String
* Requis : Oui

Nom de votre application tel qu'il doit être affiché sur AppSignal.com.

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

## Environnement de l'application

* Nom de l'attribut : `appsignal.config.environment`
* Ou en tant qu'en-tête de requête : `Appsignal-Config-Environment`
* Type : String
* Requis : Oui

L'environnement de l'application tel qu'il doit être affiché sur AppSignal.com.

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

## Clé Push API

* Nom de l'attribut : `appsignal.config.push_api_key`
* Ou en tant qu'en-tête de requête : `Appsignal-Config-PushApiKey`
* Type : String
* Requis : Oui

La clé d'authentification au niveau de l'organisation pour s'authentifier auprès de notre Push API.

Pour des informations détaillées sur la [clé Push API AppSignal](/appsignal/terminology#push-api-key), consultez notre documentation sur la terminologie.

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

## Révision de l'application

* Nom de l'attribut : `appsignal.config.revision`
* Ou en tant qu'en-tête de requête : `Appsignal-Config-Revision`
* Type : String
* Requis : Oui

Pour signaler les nouveaux déploiements des applications OpenTelemetry, vous pouvez utiliser les [Deploy Markers](/application/markers/deploy-markers).

Les deploy markers peuvent être configurés avec l'attribut de ressource revision. La valeur de cet attribut sera utilisée pour identifier les nouveaux déploiements. Elle doit être unique par déploiement pour détecter de nouveaux déploiements. Nous recommandons d'utiliser les SHA de commit Git ou un tag dans votre SCM. Cela peut être utilisé en combinaison avec nos [backtrace links](/application/backtrace-links) pour créer un lien direct depuis AppSignal vers le code source sur des plateformes comme GitHub et 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(
  	// Other resource attributes
  	resource.WithAttributes(attribute.String("appsignal.config.revision", revision)),
  )
  ```
</CodeGroup>

## Intégration de langage

* Nom de l'attribut : `appsignal.config.language_integration`
* Ou en tant qu'en-tête de requête : `Appsignal-Config-LanguageIntegration`
* Type : String
* Requis : Oui

AppSignal utilise l'attribut de ressource `language_integration` pour détecter le langage d'une trace et analyser correctement les traces d'exception.

Pour définir cette option, spécifiez le nom du langage en minuscules, par exemple « python », « rust », « ruby », « elixir », « go » et « 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>

## Nom de l'application OTP

* Nom de l'attribut : `appsignal.config.otp_app`
* Type : String
* Requis : Oui, pour les applications Elixir

AppSignal utilise l'attribut de ressource `appsignal.config.otp_app` pour détecter quelles lignes de trace d'erreur appartiennent à l'application.

Vous pouvez trouver le nom de l'application OTP pour votre application en appelant `IO.inspect(:application.get_application())` dans votre application et en vérifiant la sortie.

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

## Nom du service

* Nom de l'attribut : `service.name`
* Ou en tant qu'en-tête de requête : `OpenTelemetry-ServiceName`
* Type : String
* Requis : Oui

L'attribut de ressource `service.name` aide AppSignal à reconnaître différents services pour les traces et regroupe automatiquement les traces dans un namespace en fonction du nom du service.

Choisissez un nom qui convient à votre application, comme « Web server », « Background worker », « Email service », « Authentication service », etc.

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

## Nom d'hôte

* Nom de l'attribut : `host.name`
* Ou en tant qu'en-tête de requête : `OpenTelemetry-HostName`
* Type : String
* Requis : Oui

L'attribut de ressource `host.name` aide AppSignal à reconnaître les différents hôtes pour les traces et à étiqueter automatiquement les traces avec le nom d'hôte.

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

## Chemin de l'application

* Nom de l'attribut : `appsignal.config.app_path`
* Type : String
* Requis : Non

L'emplacement de l'application sur le système de fichiers de l'hôte.

L'attribut de ressource `app_path` aide AppSignal à nettoyer les traces en supprimant le chemin absolu de l'application des lignes de trace. Ainsi, seuls les chemins dans le contexte du répertoire du projet sont affichés. Cela rend possible notre fonctionnalité de [Backtrace links](/application/backtrace-links).

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

## Filtrer les attributs

* Nom de l'attribut : `appsignal.config.filter_attributes`
* Type : Array
* Requis : Non

L'attribut de ressource `filter_attributes` vous permet de filtrer certains attributs spécifiques pour qu'ils ne soient pas signalés à AppSignal. Cela peut être utile pour empêcher la transmission d'informations sensibles ou non pertinentes.

Si un attribut est filtré de cette manière, il n'apparaîtra pas du tout dans l'interface.

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

## Filtrer les paramètres de fonction

* Nom de l'attribut : `appsignal.config.filter_function_parameters`
* Type : Array
* Valeur par défaut : *Vide*
* Requis : Non

L'attribut de ressource `filter_function_parameters` vous permet de filtrer tous les paramètres de fonction définis dans l'[attribut de span `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters).

Dans l'exemple ci-dessous, les valeurs des clés répertoriées dans l'option de configuration `filter_function_parameters` sont remplacées par `[FILTERED]`.

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

## Filtrer les paramètres de requête de l'URL

* Nom de l'attribut : `appsignal.config.filter_request_query_parameters`
* Type : Array
* Valeur par défaut : *Vide*
* Requis : Non

L'attribut de ressource `filter_request_query_parameters` vous permet de filtrer les paramètres de requête de l'URL définis dans l'[attribut de span `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

Dans l'exemple ci-dessous, les valeurs des clés répertoriées dans l'option de configuration `filter_request_query_parameters` sont remplacées par `[FILTERED]`.

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

## Filtrer la charge utile de la requête

* Nom de l'attribut : `appsignal.config.filter_request_payload`
* Type : Array
* Valeur par défaut : *Vide*
* Requis : Non

L'attribut de ressource `filter_request_payload` vous permet de filtrer les données de charge utile de requête définies dans l'[attribut de span `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload).

Dans l'exemple ci-dessous, les valeurs des clés répertoriées dans l'option de configuration `filter_request_payload` sont remplacées par `[FILTERED]`.

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

## Filtrer les données de session de la requête

* Nom de l'attribut : `appsignal.config.filter_request_session_data`
* Type : Array
* Valeur par défaut : *Vide*
* Requis : Non

L'attribut de ressource `filter_request_session_data` vous permet de filtrer les données de session de requête définies dans l'[attribut de span `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data).

Dans l'exemple ci-dessous, les valeurs des clés répertoriées dans l'option de configuration `filter_request_session_data` sont remplacées par `[FILTERED]`.

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

## Ignorer les actions

* Nom de l'attribut : `appsignal.config.ignore_actions`
* Type : Array of Strings
* Requis : Non

L'attribut de ressource `ignore_actions` vous permet d'ignorer des actions spécifiques afin qu'elles ne soient pas signalées à AppSignal. Cela peut être utile pour ignorer les endpoints de health check ou d'autres actions que vous ne souhaitez pas surveiller.

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

## Ignorer les erreurs

* Nom de l'attribut : `appsignal.config.ignore_errors`
* Type : Array of Strings
* Requis : Non

L'attribut de ressource `ignore_errors` vous permet d'ignorer des erreurs spécifiques afin qu'elles ne soient pas signalées à AppSignal. Cela peut être utile pour ignorer les erreurs attendues ou les erreurs qui ne peuvent pas être résolues.

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

## Ignorer les namespaces

* Nom de l'attribut : `appsignal.config.ignore_namespaces`
* Type : Array of Strings
* Requis : Non

L'attribut de ressource `ignore_namespaces` vous permet d'ignorer des namespaces spécifiques afin qu'ils ne soient pas signalés à AppSignal. Cela peut être utile pour empêcher la surveillance de certaines parties spécifiques de votre application.

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

## En-têtes de réponse

* Nom de l'attribut : `appsignal.config.response_headers`
* Type : Array of Strings
* Valeur par défaut : `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Requis : Non

Configurez quels en-têtes de réponse inclure lorsqu'une requête est effectuée par un client HTTP. Cette option est une liste d'autorisation. Elle n'inclut que les en-têtes qui sont configurés. Si la liste est vide, aucun en-tête n'est inclus.

Les en-têtes de réponse sont lus à partir des [attributs de span OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.response.header.<key>`, où `<key>` est le nom d'en-tête normalisé (en minuscules).

Pour ne définir aucun en-tête, définissez explicitement la valeur de l'attribut de ressource à un tableau vide.

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

## En-têtes de requête

* Nom de l'attribut : `appsignal.config.request_headers`
* Type : Array of Strings
* Valeur par défaut : `["content-length", "accept", "accept-charset", "accept-encoding", "accept-language", "cache-control", "connection", "range", "host"]`
* Requis : Non

Configurez quels en-têtes de requête inclure lorsqu'une requête est effectuée vers un serveur HTTP. Cette option est une liste d'autorisation. Elle n'inclut que les en-têtes qui sont configurés. Si la liste est vide, aucun en-tête n'est inclus.

Les en-têtes de requête sont lus à partir des [attributs de span OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) `http.request.header.<key>`, où `<key>` est le nom d'en-tête normalisé (en minuscules).

Pour ne définir aucun en-tête, définissez explicitement la valeur de l'attribut de ressource à un tableau vide.

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

## Envoyer les paramètres de fonction

* Nom de l'attribut : `appsignal.config.send_function_parameters`
* Type : Boolean
* Valeur par défaut : `true`
* Requis : Non

Configurez s'il faut inclure les paramètres de fonction dans les traces. S'il est défini sur `false`, aucune de ces données n'est envoyée à nos serveurs.

Ces valeurs sont définies avec l'[attribut de span `appsignal.function.parameters`](/opentelemetry/custom-instrumentation/attributes#function-parameters).

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

## Envoyer les paramètres de requête de l'URL

* Nom de l'attribut : `appsignal.config.send_request_query_parameters`
* Type : Boolean
* Valeur par défaut : `true`
* Requis : Non

Configurez s'il faut inclure les paramètres de requête de l'URL dans les traces. S'il est défini sur `false`, aucune de ces données n'est envoyée à nos serveurs.

Ces valeurs sont définies avec l'[attribut de span `appsignal.request.query_parameters`](/opentelemetry/custom-instrumentation/attributes#request-query-parameters).

Pour plus d'informations, veuillez lire à propos du [filtrage des paramètres de requête](/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>

## Envoyer la charge utile de la requête

* Nom de l'attribut : `appsignal.config.send_request_payload`
* Type : Boolean
* Valeur par défaut : `true`
* Requis : Non

Configurez s'il faut envoyer les données de charge utile de requête dans les traces. S'il est défini sur `false`, aucune de ces données n'est envoyée à nos serveurs.

Ces valeurs sont définies avec l'[attribut de span `appsignal.request.payload`](/opentelemetry/custom-instrumentation/attributes#request-payload).

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

## Envoyer les données de session de la requête

* Nom de l'attribut : `appsignal.config.send_request_session_data`
* Type : Boolean
* Valeur par défaut : `true`
* Requis : Non

Configurez s'il faut envoyer les données de session de requête dans les traces. S'il est défini sur `false`, aucune de ces données n'est envoyée à nos serveurs.

Ces valeurs sont définies avec l'[attribut de span `appsignal.request.session_data`](/opentelemetry/custom-instrumentation/attributes#request-session-data).

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