> ## 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-Installation für Python

Um OpenTelemetry-Daten von Ihrer Python-Anwendung an AppSignal zu senden, können Sie entweder das [AppSignal for Python-Paket](/python/installation) verwenden oder OpenTelemetry manuell installieren und konfigurieren.

## Verwendung des AppSignal for Python-Pakets

Das AppSignal for Python-Paket kann OpenTelemetry automatisch so konfigurieren, dass es Daten an den AppSignal Collector sendet. Es kann auch automatisch OpenTelemetry-Instrumentierungen für gängige Bibliotheken und Frameworks aktivieren.

Befolgen Sie die Anweisungen in der [Installationsdokumentation für AppSignal for Python](/python/installation), um das Paket zu installieren und die Konfigurationsdatei einzurichten, und befolgen Sie dann die Anweisungen auf der [Seite zur Collector-Konfiguration von AppSignal for Python](/python/configuration/collector), um es mit dem AppSignal Collector zu verwenden.

## OpenTelemetry manuell installieren

Stellen Sie sicher, dass Sie [den AppSignal Collector installieren](/opentelemetry/installation), bevor Sie mit diesen Anweisungen fortfahren.

### Die OpenTelemetry-Pakete installieren

Fügen Sie das OpenTelemetry-SDK, den OTLP-Exporter und die Instrumentierungspakete zur `requirements.txt` Ihrer Anwendung hinzu:

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

Fügen Sie auch die OpenTelemetry-Instrumentierungspakete für die Bibliotheken und Frameworks hinzu, die Ihre Anwendung verwendet. Zum Beispiel, wenn Sie Django und Celery verwenden:

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

Sehen Sie sich [das OpenTelemetry-Registry nach Instrumentierungspaketen](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=python\&flag=all) für die meisten Bibliotheken und Frameworks an.

### OpenTelemetry in Ihrer Anwendung konfigurieren

Fügen Sie diese Datei `appsignal.py` mit der OpenTelemetry-Exporter- und AppSignal-Konfiguration zu Ihrer Anwendung hinzu. Importieren Sie diese Datei dann, bevor Ihre Anwendung gestartet wird.

Stellen Sie sicher, dass Sie die folgenden Werte mit Ihrem AppSignal-Anwendungsnamen, der Umgebung und dem Push API-Schlüssel aktualisieren und den Exporter-Endpunkt durch die Adresse Ihres AppSignal Collectors ersetzen, falls erforderlich.

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

Initialisieren Sie dann in derselben Datei nach der OpenTelemetry-Einrichtung die OpenTelemetry-Instrumentierungen für die Bibliotheken und Frameworks, die Ihre Anwendung verwendet. Zum Beispiel, wenn Sie die Django- und Celery-Instrumentierungen verwenden:

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

Rufen Sie schließlich die Funktion `initialize_opentelemetry` mit dem Namen des zu überwachenden Dienstes so früh wie möglich am Einstiegspunkt Ihrer Anwendung auf. Eine häufige Wahl für den Service-Namen ist der Name des verwendeten Frameworks.

#### Verwendung mit Django

Importieren Sie in der Datei `settings.py` Ihrer Django-Anwendung das Modul `appsignal.py` am Anfang der Datei und rufen Sie die Funktion `initialize_opentelemetry` auf:

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

#### Verwendung mit Celery

Fügen Sie in der Datei `tasks.py` Ihrer Celery-Anwendung einen Verbindungs-Callback für Worker-Prozesse hinzu und importieren Sie darin das Modul `appsignal.py`.

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

### Die App testen!

Nachdem nun alle Komponenten verbunden sind, starten Sie Ihre App und testen Sie, ob Daten in AppSignal eintreffen. Überprüfen Sie insbesondere die Seiten [„Errors > Issue list"](https://appsignal.com/redirect-to/app?to=exceptions) und [„Performance > Traces"](https://appsignal.com/redirect-to/app?to=performance/traces).

Wenn Sie nach dem Befolgen unserer Installationsanweisungen immer noch keine Daten in AppSignal sehen, [lassen Sie es uns wissen](mailto:support@appsignal.com?subject=OpenTelemetry%20issue), und wir helfen Ihnen, Ihre OpenTelemetry-Installation abzuschließen!