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

# Installation OpenTelemetry pour Python

Pour envoyer des données OpenTelemetry depuis votre application Python vers AppSignal, vous pouvez soit utiliser le [paquet AppSignal pour Python](/python/installation), soit installer et configurer OpenTelemetry manuellement.

## Utilisation du paquet AppSignal pour Python

Le paquet AppSignal pour Python peut configurer automatiquement OpenTelemetry pour envoyer des données à l'AppSignal collector. Il peut également activer automatiquement les instrumentations OpenTelemetry pour les bibliothèques et frameworks populaires.

Suivez les instructions de la [documentation d'installation d'AppSignal pour Python](/python/installation) pour installer le paquet et configurer le fichier de configuration, puis suivez les instructions de la [page de configuration du collector pour AppSignal pour Python](/python/configuration/collector) pour l'utiliser avec l'AppSignal Collector.

## Installer OpenTelemetry manuellement

Assurez-vous d'[installer l'AppSignal collector](/opentelemetry/installation) avant de poursuivre avec ces instructions.

### Installer les paquets OpenTelemetry

Ajoutez le SDK OpenTelemetry, l'exportateur OTLP et les paquets d'instrumentation au fichier `requirements.txt` de votre application :

<CodeGroup>
  ```txt Text theme={null}
  opentelemetry-api
  opentelemetry-sdk
  opentelemetry-exporter-otlp-proto-http
  ```
</CodeGroup>

Ajoutez également les paquets d'instrumentation OpenTelemetry pour les bibliothèques et frameworks utilisés par votre application. Par exemple, si vous utilisez Django et Celery :

<CodeGroup>
  ```txt Text theme={null}
  opentelemetry-instrumentation-celery
  opentelemetry-instrumentation-django
  ```
</CodeGroup>

Consultez [le registre OpenTelemetry pour les paquets d'instrumentation](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=python\&flag=all) pour la plupart des bibliothèques et frameworks.

### Configurer OpenTelemetry dans votre application

Ajoutez ce fichier `appsignal.py` à votre application avec l'exportateur OpenTelemetry et la configuration AppSignal. Ensuite, importez ce fichier avant le démarrage de votre application.

Veillez à mettre à jour les valeurs ci-dessous avec le nom de votre application AppSignal, l'environnement et la clé Push API, et à remplacer l'endpoint de l'exportateur par l'adresse de votre AppSignal collector si nécessaire.

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

  from opentelemetry import trace, metrics
  from opentelemetry.sdk.resources import Resource
  from opentelemetry.sdk.trace import TracerProvider
  from opentelemetry.sdk.trace.export import BatchSpanProcessor
  from opentelemetry.sdk.metrics.export import (
      AggregationTemporality,
      PeriodicExportingMetricReader,
  )
  from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
      OTLPSpanExporter
  )
  from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
      OTLPMetricExporter
  )

  def initialize_opentelemetry(service_name):
      # Replace these values with your AppSignal application name, environment
      # and push API key. These are used by the resource attributes configuration below.
      name = "My app"
      push_api_key = "0000-0000-0000-0000"
      environment = "development"

      # Replace `http://localhost:8099` with the address of your AppSignal collector
      # if it's running on another host.
      endpoint = "http://localhost:8099"

      revision = subprocess.check_output(
          "git rev-parse --short HEAD", shell=True, text=True
      ).strip()

      resource = Resource(attributes={
          "appsignal.config.name": name,
          "appsignal.config.environment": environment,
          "appsignal.config.push_api_key": push_api_key,
          "appsignal.config.revision": revision,
          "appsignal.config.language_integration": "python",
          "appsignal.config.app_path": os.getcwd()
          "host.name": socket.gethostname(),
          # Customize the service name
          "service.name": service_name,
      })

      trace_provider = TracerProvider(resource=resource)
      span_processor = BatchSpanProcessor(
          OTLPSpanExporter(endpoint=f"{collector_host}/v1/traces")
      )
      trace_provider.add_span_processor(span_processor)
      trace.set_tracer_provider(trace_provider)

      metric_exporter = OTLPMetricExporter(
          endpoint=f"{collector_host}/v1/metrics",
      )
      metric_reader = PeriodicExportingMetricReader(
          metric_exporter,
          export_interval_millis=10000
      )
      metric_provider = MeterProvider(
          resource=resource,
          metric_readers=[metric_reader]
      )
      metrics.set_meter_provider(metric_provider)
  ```
</CodeGroup>

Ensuite, dans le même fichier, après la configuration d'OpenTelemetry, initialisez les instrumentations OpenTelemetry pour les bibliothèques et frameworks utilisés par votre application. Par exemple, si vous utilisez les instrumentations Django et Celery :

<CodeGroup>
  ```python Python theme={null}
  # Add this below the OpenTelemetry initialization

  from opentelemetry.instrumentation.django import DjangoInstrumentor
  from opentelemetry.instrumentation.celery import CeleryInstrumentor

  DjangoInstrumentor().instrument()
  CeleryInstrumentor().instrument()
  ```
</CodeGroup>

Enfin, appelez la fonction `initialize_opentelemetry` avec le nom du service surveillé, le plus tôt possible dans le point d'entrée de votre application. Un choix courant pour le nom du service est le nom du framework utilisé.

#### Utilisation avec Django

Dans le fichier `settings.py` de votre application Django, importez le module `appsignal.py` au début du fichier et appelez la fonction `initialize_opentelemetry` :

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

  # Set the name of the service that is being monitored. A common choice is the
  # name of the framework used. This is used to group traces and metrics in AppSignal.
  service_name = "Django"

  initialize_opentelemetry(service_name)
  ```
</CodeGroup>

#### Utilisation avec Celery

Dans le fichier `tasks.py` de votre application Celery, ajoutez un callback de connexion pour les processus worker et importez le module `appsignal.py` à l'intérieur.

<CodeGroup>
  ```python Python theme={null}
  @worker_process_init.connect(weak=False)
  def init_celery_tracing(*args, **kwargs):
      from .appsignal import initialize_opentelemetry

      # Set the name of the service that is being monitored. A common choice is the
      # name of the framework used. This is used to group traces and metrics in AppSignal.
      service_name = "Celery"

      initialize_opentelemetry(service_name)
  ```
</CodeGroup>

### Testez l'application !

Maintenant que tous les composants sont connectés, démarrez votre application et vérifiez si des données arrivent dans AppSignal. Consultez en particulier les pages [« Errors > Issue list »](https://appsignal.com/redirect-to/app?to=exceptions) et [« Performance > Traces »](https://appsignal.com/redirect-to/app?to=performance/traces).

Si après avoir suivi nos instructions d'installation vous ne voyez toujours pas de données dans AppSignal, [faites-le-nous savoir](mailto:support@appsignal.com?subject=OpenTelemetry%20issue) et nous vous aiderons à finaliser votre installation OpenTelemetry !