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

# Instalação do OpenTelemetry no Python

Para enviar dados do OpenTelemetry da sua aplicação Python ao AppSignal, você pode usar o [pacote AppSignal para Python](/python/installation) ou instalar e configurar o OpenTelemetry manualmente.

## Usando o pacote AppSignal para Python

O pacote AppSignal para Python pode configurar automaticamente o OpenTelemetry para enviar dados ao AppSignal collector. Ele também pode habilitar automaticamente instrumentações do OpenTelemetry para bibliotecas e frameworks populares.

Siga as instruções na [documentação de instalação do AppSignal para Python](/python/installation) para instalar o pacote e configurar o arquivo de configuração, e depois siga as instruções na [página de configuração do collector do AppSignal para Python](/python/configuration/collector) para usá-lo com o AppSignal Collector.

## Instalando o OpenTelemetry manualmente

Certifique-se de [instalar o AppSignal collector](/opentelemetry/installation) antes de prosseguir com estas instruções.

### Instale os pacotes do OpenTelemetry

Adicione o SDK do OpenTelemetry, o exporter OTLP e os pacotes de instrumentação ao `requirements.txt` da sua aplicação:

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

Adicione também os pacotes de instrumentação do OpenTelemetry para as bibliotecas e frameworks que sua aplicação usa. Por exemplo, se você está usando Django e Celery:

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

Confira [o registro do OpenTelemetry para pacotes de instrumentação](https://opentelemetry.io/ecosystem/registry/?s=\&component=instrumentation\&language=python\&flag=all) para a maioria das bibliotecas e frameworks.

### Configure o OpenTelemetry na sua aplicação

Adicione este arquivo `appsignal.py` à sua aplicação com o exporter do OpenTelemetry e a configuração do AppSignal. Em seguida, importe esse arquivo antes que sua aplicação inicie.

Certifique-se de atualizar os valores abaixo com o nome da sua aplicação no AppSignal, ambiente e push API key, e de substituir o endpoint do exporter pelo endereço do seu AppSignal collector se necessário.

<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):
      # Substitua estes valores pelo nome da sua aplicação no AppSignal, ambiente
      # e push API key. Estes são usados pela configuração de atributos de recurso abaixo.
      name = "My app"
      push_api_key = "0000-0000-0000-0000"
      environment = "development"

      # Substitua `http://localhost:8099` pelo endereço do seu AppSignal collector
      # caso ele esteja rodando em outro 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(),
          # Personalize o nome do serviço
          "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>

Em seguida, no mesmo arquivo, após a configuração do OpenTelemetry, inicialize as instrumentações do OpenTelemetry para as bibliotecas e frameworks que sua aplicação usa. Por exemplo, se você está usando as instrumentações do Django e do Celery:

<CodeGroup>
  ```python Python theme={null}
  # Adicione isto abaixo da inicialização do OpenTelemetry

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

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

Por fim, chame a função `initialize_opentelemetry` com o nome do serviço que está sendo monitorado, o mais cedo possível no ponto de entrada da sua aplicação. Uma escolha comum para o nome do serviço é o nome do framework usado.

#### Uso com Django

No arquivo `settings.py` da sua aplicação Django, importe o módulo `appsignal.py` no início do arquivo e chame a função `initialize_opentelemetry`:

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

  # Defina o nome do serviço que está sendo monitorado. Uma escolha comum é o
  # nome do framework usado. Isso é usado para agrupar traces e métricas no AppSignal.
  service_name = "Django"

  initialize_opentelemetry(service_name)
  ```
</CodeGroup>

#### Uso com Celery

No arquivo `tasks.py` da sua aplicação Celery, adicione um callback de conexão para os processos worker e importe o módulo `appsignal.py` dentro dele.

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

      # Defina o nome do serviço que está sendo monitorado. Uma escolha comum é o
      # nome do framework usado. Isso é usado para agrupar traces e métricas no AppSignal.
      service_name = "Celery"

      initialize_opentelemetry(service_name)
  ```
</CodeGroup>

### Teste o app!

Agora que todos os componentes estão conectados, inicie seu app e teste se você vê os dados chegando no AppSignal. Verifique especificamente as páginas ["Errors > Issue list"](https://appsignal.com/redirect-to/app?to=exceptions) e ["Performance > Traces"](https://appsignal.com/redirect-to/app?to=performance/traces).

Se, depois de seguir nossas instruções de instalação, você ainda não vir dados no AppSignal, [avise-nos](mailto:support@appsignal.com?subject=OpenTelemetry%20issue) e te ajudaremos a finalizar a instalação do OpenTelemetry!