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

# Attributs d'instrumentation OpenTelemetry

AppSignal prend en charge plusieurs intégrations de langages OpenTelemetry. Cependant, le modèle de données peut ne pas toujours s'aligner parfaitement, ce qui peut affecter la façon dont les données OpenTelemetry sont affichées dans l'interface AppSignal. En utilisant les attributs répertoriés sur cette page, vous pouvez personnaliser l'apparence des données de trace et de span.

<Warning>
  🔐 N'envoyez pas d'<strong>informations personnelles identifiables (PII)</strong> à AppSignal. Filtrez les PII (par exemple, noms, e-mails) et utilisez un identifiant, un hash ou un identifiant pseudonymisé à la place. <br /> <br /> Pour les <strong>entités couvertes par la HIPAA</strong>, plus d'informations sur la signature d'un Business Associate Agreement (BAA) sont disponibles dans notre <a href="/support/business-add-ons">documentation Business Add-Ons</a>.
</Warning>

## Accéder à un span

<Tabs>
  <Tab title="Python">
    Lors de la personnalisation de la trace ou du span, importez d'abord le module trace OpenTelemetry dans le fichier où vous souhaitez personnaliser les données de trace rapportées.

    <CodeGroup>
      ```python Python theme={null}
      from opentelemetry import trace
      ```
    </CodeGroup>

    À l'aide de ce module trace, créez un nouveau span :

    <CodeGroup>
      ```python Python theme={null}
      tracer = trace.get_tracer(__name__)
      with tracer.start_as_current_span("Span name") as span:
          # Set attribute values
          span.set_attribute("attribute name", "attribute value")
      ```
    </CodeGroup>

    Ou récupérez celui actuellement actif :

    <CodeGroup>
      ```python Python theme={null}
      span = trace.get_current_span()
      # Set attribute values
      span.set_attribute("attribute name", "attribute value")
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Go (golang)">
    Lors de la personnalisation de la trace ou du span, importez d'abord le module trace OpenTelemetry dans le fichier où vous souhaitez personnaliser les données de trace rapportées.

    <CodeGroup>
      ```go Go theme={null}
      import (
      	"go.opentelemetry.io/otel"
      	"go.opentelemetry.io/otel/attribute"
      	"go.opentelemetry.io/otel/trace"
      )
      ```
    </CodeGroup>

    À l'aide de ce module trace, créez un nouveau span :

    <CodeGroup>
      ```go Go theme={null}
      var tracer = otel.Tracer("my-tracer-name")

      func httpHandler(w http.ResponseWriter, r *http.Request) {
      	ctx, span := tracer.Start(r.Context(), "hello-span")
      	defer span.End()

      	// Set attributes
      }
      ```
    </CodeGroup>

    *Remarque : dans ces exemples, nous nous appuyons sur le contexte de la requête HTTP, fourni par `r.Context()`.*
    *La récupération du contexte peut être différente dans votre application.*

    Ou récupérez celui actuellement actif :

    <CodeGroup>
      ```go Go theme={null}
      func httpHandler(w http.ResponseWriter, r *http.Request) {
      	ctx := r.Context()
          span := trace.SpanFromContext(ctx)

      	// Set attributes
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Attributs AppSignal

### Namespace

<Tip>
  Cet attribut s'applique à l'ensemble de la trace. Il peut être défini sur un span enfant et n'a pas besoin d'être défini sur le span parent le plus haut. Cet attribut ne peut être défini qu'une seule fois par trace. S'il est défini plusieurs fois, seul l'attribut d'un seul span de la trace est appliqué.
</Tip>

* Nom de l'attribut : `appsignal.namespace`
* Type de valeur : `String`

[Regroupez les traces par namespace](/application/namespaces) pour une meilleure organisation dans l'interface AppSignal.

Les namespaces sont regroupés par nom de service OpenTelemetry au format `<Service name>/<Namespace>`, par exemple « Web server/admin » ou « Background worker/billing ». Cet attribut vous permet de configurer uniquement la partie namespace. Le namespace par défaut pour toutes les traces est `<Service name>/default`.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.namespace", "admin")
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.namespace", "admin"))
  ```
</CodeGroup>

### Nom d'action racine

<Tip>
  Cet attribut s'applique à l'ensemble de la trace. Il peut être défini sur un span enfant et n'a pas besoin d'être défini sur le span parent le plus haut. Cet attribut ne peut être défini qu'une seule fois par trace. S'il est défini plusieurs fois, seul l'attribut d'un seul span de la trace est appliqué.
</Tip>

* Nom de l'attribut : `appsignal.action_name`
* Type de valeur : `String`

Définissez le nom d'action de la trace qui sera utilisé pour créer des incidents et regrouper le tracing sur AppSignal.com. Cela écrasera tout mappage automatisé effectué par le support AppSignal pour une instrumentation spécifique. Cela est utile pour les traces qui ne sont pas créées par des bibliothèques prises en charge. Si votre trace est regroupée avec d'autres traces non nommées ou mal regroupées, il se peut que cet attribut soit manquant.

Nous visons à améliorer notre regroupement automatique au fil du temps, donc [veuillez nous le faire savoir](mailto:support@appsignal.com?subject=OpenTelemetry%20feedback) si vous constatez que cet attribut est nécessaire.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.action_name", "ControllerName#action")
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.action_name", "ControllerName#action"))
  ```
</CodeGroup>

### Tags

* Nom de l'attribut : `appsignal.tag.<tag_name>`
* Type de valeur : `String`

[Taguez les traces](/application/tagging) pour les faire ressortir sur les pages de détails de trace et filtrer les traces dans l'interface AppSignal. Plusieurs tags peuvent être définis sur les spans d'une trace. Des tags peuvent être ajoutés à n'importe quel span d'une trace à n'importe quel niveau de la trace.

Vous pouvez utiliser des [link templates](https://docs.appsignal.com/application/link-templates.html) pour lier les tags à une URL spécifique, comme un profil utilisateur ou une page d'administration.

La clé de l'attribut de tag est composée de deux parties : le préfixe `appsignal.tag` et la clé du tag. Pour le tag `user_id`, cela devient `appsignal.tag.user_id` en tant que clé d'attribut.

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.tag.<tag_name>", "string") # Example format
  span.set_attribute("appsignal.tag.user_id", user.id)
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.String("appsignal.tag.<tag_name>", "string")) // Example format
  span.SetAttributes(attribute.String("appsignal.tag.user_id", user.id))
  ```
</CodeGroup>

### Paramètres de fonction

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `appsignal.function.parameters`
* Type de valeur : Objet sérialisé en JSON

Signalez les paramètres d'un appel de fonction à l'aide de cet attribut.
Utilisez-le pour définir les paramètres transmis à un background job, à une tâche ou à un appel de fonction que vous souhaitez suivre.

Les valeurs définies dans cet attribut de span peuvent être filtrées à l'aide de l'[option de configuration `appsignal.config.filter_function_parameters`](/opentelemetry/configuration/options#filter-function-parameters).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.function.parameters", json.dumps({
      "param1": "value1",
      "param2": "value2"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"
  )

  params := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.function.parameters", string(json)))
  ```
</CodeGroup>

### En-têtes de réponse

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `http.response.header.<key>`
* Type de valeur : Array of Strings

Signalez les en-têtes de la réponse à l'aide d'un attribut de span OpenTelemetry.
Cet attribut de span est également documenté dans la [spécification OpenTelemetry des spans HTTP](https://opentelemetry.io/docs/specs/semconv/http/http-spans/).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("http.response.header.content-type", ["application/json"])
  span.set_attribute("http.response.header.custom-header", ["abc", "def"])
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.StringSlice("http.response.header.content-type", []string{"application/json"}))
  span.SetAttributes(attribute.StringSlice("http.response.header.custom-header", []string{"abc", "def"}))
  ```
</CodeGroup>

### En-têtes de requête

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `http.request.header.<key>`
* Type de valeur : Array of Strings

Signalez les en-têtes de la requête à l'aide d'un attribut de span OpenTelemetry.
Cet attribut de span est également documenté dans la [spécification OpenTelemetry des spans HTTP](https://opentelemetry.io/docs/specs/semconv/http/http-spans/).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("http.request.header.content-type", ["application/json"])
  span.set_attribute("http.request.header.custom-header", ["abc", "def"])
  ```

  ```go Go theme={null}
  span.SetAttributes(attribute.StringSlice("http.request.header.content-type", []string{"application/json"}))
  span.SetAttributes(attribute.StringSlice("http.request.header.custom-header"), []string{"abc", "def"})
  ```
</CodeGroup>

### Paramètres de requête de l'URL

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `appsignal.request.query_parameters`
* Type de valeur : Objet sérialisé en JSON

Signalez les paramètres de requête d'une URL d'une requête HTTP entrante à l'aide de cet attribut.

Les valeurs définies dans cet attribut de span peuvent être filtrées à l'aide de l'[option de configuration `appsignal.config.filter_request_query_parameters`](/opentelemetry/configuration/options#filter-request-query-parameters).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.query_parameters", json.dumps({
      "category": "shoes",
      "filter": "color:blue"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

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

  params := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(params)
  span.SetAttributes(attribute.String("appsignal.request.query_parameters", string(json)))
  ```
</CodeGroup>

### Charge utile de la requête

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `appsignal.request.payload`
* Type de valeur : Objet sérialisé en JSON

Signalez la charge utile d'une requête HTTP entrante à l'aide de cet attribut.

Les valeurs définies dans cet attribut de span peuvent être filtrées à l'aide de l'[option de configuration `appsignal.config.filter_request_payload`](/opentelemetry/configuration/options#filter-request-payload).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.payload", json.dumps({
      "title": "My new blog post"
      "body": "Lorem ipsum"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

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

  payload := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(payload)
  span.SetAttributes(attribute.String("appsignal.request.payload", string(json)))
  ```
</CodeGroup>

### Données de session de la requête

<Tip>
  La valeur de cet attribut doit être sérialisée en chaîne JSON. Il ne prend pas en charge directement un Hash ou un objet du langage d'intégration et sera silencieusement ignoré.
</Tip>

* Nom de l'attribut : `appsignal.request.session_data`
* Type de valeur : Objet sérialisé en JSON

Signalez les données de session d'une requête HTTP entrante à l'aide de cet attribut.

Les valeurs définies dans cet attribut de span peuvent être filtrées à l'aide de l'[option de configuration `appsignal.config.filter_request_session_data`](/opentelemetry/configuration/options#filter-request-session-data).

<CodeGroup>
  ```python Python theme={null}
  span.set_attribute("appsignal.request.session_data", json.dumps({
      "user_id": 123
      "theme": "dark"
  }))
  ```

  ```go Go theme={null}
  import (
  	"encoding/json"

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

  session_data := map[string]interface{}{
  	"param1": "value1",
  	"param2": "value2",
  	"nested": map[string]interface{}{
  		"param3": "value3",
  		"param4": "value4",
  	},
  }
  json, _ := json.Marshal(session_data)
  span.SetAttributes(attribute.String("appsignal.request.session_data", string(json)))
  ```
</CodeGroup>