# Exporters > Processar e exportar seus dados de telemetria --- LLMS index: [llms.txt](/llms.txt) --- Envie dados de telemetria para o [OpenTelemetry Collector](/docs/collector/) para garantir que estes dados sejam exportados corretamente. A utilização de um Collector em ambientes de produção é a melhor prática. Para visualizar os dados de telemetria que foram gerados, exporte-os para um _backend_ como [Jaeger](https://jaegertracing.io/), [Zipkin](https://zipkin.io/), [Prometheus](https://prometheus.io/), ou um _backend_ [específico de um fornecedor](/ecosystem/vendors/). ## Exportadores disponíveis {#available-exporters} O registro oferece uma [lista de exportadores para Python][reg]. Entre os exportadores, os exportadores do [OpenTelemetry Protocol (OTLP)][OTLP] são projetados tendo em mente o modelo de dados do OpenTelemetry, emitindo dados OTel sem qualquer perda de informação. Além disso, muitas ferramentas que operam com dados de telemetria suportam o formato OTLP (como [Prometheus][], [Jaeger][] e a maioria dos [fornecedores][]), proporcionando um alto grau de flexibilidade quando necessário. Para saber mais sobre o OTLP, consulte a [Especificação do OTLP][OTLP]. [Jaeger]: /blog/2022/jaeger-native-otlp/ [OTLP]: /docs/specs/otlp/ [Prometheus]: https://prometheus.io/docs/prometheus/2.55/feature_flags/#otlp-receiver [reg]: [fornecedores]: /ecosystem/vendors/ Esta página reúne informações sobre os principais exportadores do OpenTelemetry Python e como configurá-los.

Nota

Caso você esteja utilizando [instrumentação sem código](), você poderá aprender a configurar os exporters através do [Guia de Configurações]().

## OTLP ### Configuração do Collector {#collector-setup}

Nota

Caso já possua um coletor ou _backend_ OTLP configurado, poderá pular para [configurar as dependências do exportador OTLP](#otlp-dependencies) para a sua aplicação.

Para testar e validar os seus exportadores OTLP, é possível executar o Collector em um contêiner Docker que escreve os dados diretamente no console. Em uma pasta vazia, crie um arquivo chamado `collector-config.yaml` e adicione o seguinte conteúdo: ```yaml receivers: otlp: protocols: grpc: endpoint: 0.0.0.0:4317 http: endpoint: 0.0.0.0:4318 exporters: debug: verbosity: detailed service: pipelines: traces: receivers: [otlp] exporters: [debug] metrics: receivers: [otlp] exporters: [debug] logs: receivers: [otlp] exporters: [debug] ``` Em seguida, execute o Collector em um contêiner Docker através do seguinte comando: ```shell docker run -p 4317:4317 -p 4318:4318 --rm -v $(pwd)/collector-config.yaml:/etc/otelcol/config.yaml otel/opentelemetry-collector ``` Este Collector agora é capaz receber dados de telemetria via OTLP. Mais tarde, você também poderá [configurar o Collector](/docs/collector/configuration) para enviar os seus dados de telemetria para o seu _backend_ de observabilidade. {{__hugo_ctx/}} ## Dependências {#otlp-dependencies} Se você deseja enviar dados de telemetria para um endpoint OTLP (como o [OpenTelemetry Collector](#collector-setup), [Jaeger](#jaeger) ou [Prometheus](#prometheus)), você pode escolher entre dois protocolos diferentes para transportar seus dados: - [HTTP/protobuf](https://pypi.org/project/opentelemetry-exporter-otlp-proto-http/) - [gRPC](https://pypi.org/project/opentelemetry-exporter-otlp-proto-grpc/) Comece instalando os pacotes do exporter necessários como dependências do seu projeto antes de prosseguir.

pip install opentelemetry-exporter-otlp-proto-http

pip install opentelemetry-exporter-otlp-proto-grpc

## Uso {#usage} Em seguida, configure o exporter para apontar para um endpoint OTLP no seu código.

from opentelemetry.sdk.resources import SERVICE_NAME, Resource

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from opentelemetry import metrics
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

# Nome do serviço é necessário para a maioria dos backends
resource = Resource.create(attributes={
    SERVICE_NAME: "nome-do-seu-serviço"
})

tracerProvider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="<traces-endpoint>/v1/traces"))
tracerProvider.add_span_processor(processor)
trace.set_tracer_provider(tracerProvider)

reader = PeriodicExportingMetricReader(
    OTLPMetricExporter(endpoint="<traces-endpoint>/v1/metrics")
)
meterProvider = MeterProvider(resource=resource, metric_readers=[reader])
metrics.set_meter_provider(meterProvider)

from opentelemetry.sdk.resources import SERVICE_NAME, Resource

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

from opentelemetry import metrics
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader

# Nome do serviço é necessário para a maioria dos backends
resource = Resource.create(attributes={
    SERVICE_NAME: "nome-do-seu-serviço"
})

tracerProvider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="seu-endpoint-aqui"))
tracerProvider.add_span_processor(processor)
trace.set_tracer_provider(tracerProvider)

reader = PeriodicExportingMetricReader(
    OTLPMetricExporter(endpoint="localhost:5555")
)
meterProvider = MeterProvider(resource=resource, metric_readers=[reader])
metrics.set_meter_provider(meterProvider)

## Console {#console} Para depurar sua instrumentação ou ver os valores localmente em desenvolvimento, você pode usar exporters que escrevem dados de telemetria no console (_stdout_). O `ConsoleSpanExporter` e o `ConsoleMetricExporter` estão inclusos no pacote `opentelemetry-sdk`. ```python from opentelemetry.sdk.resources import SERVICE_NAME, Resource from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter from opentelemetry import metrics from opentelemetry.sdk.metrics import MeterProvider from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader, ConsoleMetricExporter # Nome do serviço é necessário para a maioria dos backends, # e embora não seja necessário para exportação no console, # é bom definir o nome do serviço de qualquer maneira. resource = Resource.create(attributes={ SERVICE_NAME: "nome-do-seu-serviço" }) tracerProvider = TracerProvider(resource=resource) processor = BatchSpanProcessor(ConsoleSpanExporter()) tracerProvider.add_span_processor(processor) trace.set_tracer_provider(tracerProvider) reader = PeriodicExportingMetricReader(ConsoleMetricExporter()) meterProvider = MeterProvider(resource=resource, metric_readers=[reader]) metrics.set_meter_provider(meterProvider) ```

Nota

Existem predefinições de temporalidade para cada tipo de instrumentação. Essas predefinições podem ser definidas com a variável de ambiente `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE`, por exemplo: ```sh export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE="DELTA" ``` O valor padrão para `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` é `"CUMULATIVE"`. Os valores disponíveis e suas configurações correspondentes para esta variável de ambiente são: - `CUMULATIVE` - `Counter`: `CUMULATIVE` - `UpDownCounter`: `CUMULATIVE` - `Histogram`: `CUMULATIVE` - `ObservableCounter`: `CUMULATIVE` - `ObservableUpDownCounter`: `CUMULATIVE` - `ObservableGauge`: `CUMULATIVE` - `DELTA` - `Counter`: `DELTA` - `UpDownCounter`: `CUMULATIVE` - `Histogram`: `DELTA` - `ObservableCounter`: `DELTA` - `ObservableUpDownCounter`: `CUMULATIVE` - `ObservableGauge`: `CUMULATIVE` - `LOWMEMORY` - `Counter`: `DELTA` - `UpDownCounter`: `CUMULATIVE` - `Histogram`: `DELTA` - `ObservableCounter`: `CUMULATIVE` - `ObservableUpDownCounter`: `CUMULATIVE` - `ObservableGauge`: `CUMULATIVE` Definir `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` para qualquer valor diferente de `CUMULATIVE`, `DELTA` ou `LOWMEMORY` registrará um aviso e definirá esta variável de ambiente como `CUMULATIVE`.

## Jaeger ### Configuração do Backend {#jaeger-backend-setup} O [Jaeger](https://www.jaegertracing.io/) suporta nativamente o OTLP para receber dados de rastros. O Jaeger pode ser executado através de um contêiner Docker com uma UI acessível através da porta 16686 e OTLP habilitados nas portas 4317 e 4318: ```shell docker run --rm \ -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \ -p 16686:16686 \ -p 4317:4317 \ -p 4318:4318 \ -p 9411:9411 \ jaegertracing/all-in-one:latest ``` ### Uso {#jaeger-usage} Siga as instruções para configurar os [exportadores OTLP](#otlp-dependencies). {{__hugo_ctx/}} ## Prometheus Para enviar dados de métricas para o [Prometheus](https://prometheus.io/), você pode [ativar o OTLP Receiver do Prometheus](https://prometheus.io/docs/guides/opentelemetry/#enable-the-otlp-receiver) e utilizar o [exportador OTLP](#otlp) ou você pode utilizar o exportador do Prometheus, um `MetricReader` que inicia um servidor HTTP e coleta métricas, serializando para o formato de texto do Prometheus sob demanda. ### Configuração do Backend {#prometheus-setup}

Nota

Caso já possua o Prometheus ou um _backend_ compatível com Prometheus configurado, poderá pular esta seção e configurar as dependências do exportador [Prometheus](#prometheus-dependencies) ou [OTLP](#otlp-dependencies) para a sua aplicação.

É possível executar o [Prometheus](https://prometheus.io) em um contêiner Docker acessível na porta `9090` através das seguintes instruções: Em uma pasta vazia, crie um arquivo chamado `prometheus.yml` e adicione o seguinte conteúdo: ```yaml scrape_configs: - job_name: dice-service scrape_interval: 5s static_configs: - targets: [host.docker.internal:9464] ``` Em seguida, execute o Prometheus em um contêiner Docker que ficará acessível na porta `9090` através do seguinte comando: ```shell docker run --rm -v ${PWD}/prometheus.yml:/prometheus/prometheus.yml -p 9090:9090 prom/prometheus --web.enable-otlp-receiver ```

Nota

Ao utilizar o OTLP Receiver do Prometheus, certifique-se de definir o endpoint OTLP das métricas em sua aplicação para `http://localhost:9090/api/v1/otlp`. Nem todos os ambientes Docker suportam `host.docker.internal`. Em alguns casos, será necessário alterar o valor `host.docker.internal` para `localhost` ou o endereço de IP de sua máquina.

{{__hugo_ctx/}} ## Dependências {#prometheus-dependencies} Instale o [pacote de exporter](https://pypi.org/project/opentelemetry-exporter-prometheus/) como uma dependência para sua aplicação: ```sh pip install opentelemetry-exporter-prometheus ``` Atualize sua configuração do OpenTelemetry para usar o exporter e enviar dados para seu backend Prometheus: ```python from prometheus_client import start_http_server from opentelemetry import metrics from opentelemetry.exporter.prometheus import PrometheusMetricReader from opentelemetry.sdk.metrics import MeterProvider from opentelemetry.sdk.resources import SERVICE_NAME, Resource # Nome do serviço é necessário para a maioria dos backends resource = Resource.create(attributes={ SERVICE_NAME: "nome-do-seu-serviço" }) # Iniciar cliente Prometheus start_http_server(port=9464, addr="localhost") # Inicializar PrometheusMetricReader que puxa métricas do SDK # sob demanda para responder a solicitações de extração reader = PrometheusMetricReader() provider = MeterProvider(resource=resource, metric_readers=[reader]) metrics.set_meter_provider(provider) ``` Com o código acima, você pode acessar suas métricas em . O Prometheus ou um OpenTelemetry Collector com o receptor Prometheus pode extrair as métricas deste endpoint. ## Zipkin ### Configuração do Backend {#zipkin-setup}

Nota

Caso já possua o Zipkin ou um _backend_ compatível com Zipkin configurado, poderá pular esta seção e configurar as [dependências do exportador Zipkin](#zipkin-dependencies) para a sua aplicação.

É possível executar o [Zipkin](https://zipkin.io/) em um contêiner Docker através do seguinte comando: ```shell docker run --rm -d -p 9411:9411 --name zipkin openzipkin/zipkin ``` {{__hugo_ctx/}} ## Dependências {#zipkin-dependencies} Para enviar seus dados de rastro para o [Zipkin](https://zipkin.io/), você pode escolher entre dois protocolos diferentes para transportar seus dados: - [HTTP/protobuf](https://pypi.org/project/opentelemetry-exporter-zipkin-proto-http/) - [Thrift](https://pypi.org/project/opentelemetry-exporter-zipkin-json/) Instale o pacote de exporter como uma dependência para sua aplicação:

pip install opentelemetry-exporter-zipkin-proto-http

pip install opentelemetry-exporter-zipkin-json

Atualize sua configuração do OpenTelemetry para usar o exporter e enviar dados para seu backend Zipkin:

from opentelemetry import trace
from opentelemetry.exporter.zipkin.proto.http import ZipkinExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

resource = Resource.create(attributes={
    SERVICE_NAME: "nome-do-seu-serviço"
})

zipkin_exporter = ZipkinExporter(endpoint="http://localhost:9411/api/v2/spans")

provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(zipkin_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

from opentelemetry import trace
from opentelemetry.exporter.zipkin.json import ZipkinExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

resource = Resource.create(attributes={
    SERVICE_NAME: "nome-do-seu-serviço"
})

zipkin_exporter = ZipkinExporter(endpoint="http://localhost:9411/api/v2/spans")

provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(zipkin_exporter)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

## Exportadores personalizados {#custom-exporters} Por fim, também é possível escrever o seu próprio exportador. Para mais informações, consulte [SpanExporter Interface na documentação da API](https://opentelemetry-python.readthedocs.io/en/latest/sdk/trace.export.html#opentelemetry.sdk.trace.export.SpanExporter). ## Agrupamento de trechos e registros de log {#batching-span-and-log-records} O SDK do OpenTelemetry fornece um conjunto de processadores padrão de trechos e registros de log, que permitem emitir trechos um-a-um ("simples") ou em lotes. O uso de agrupamentos é recomendado, mas caso não deseje agrupar seus trechos ou registros de log, é possível utilizar um processador simples da seguinte forma: {{__hugo_ctx/}} ```python from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter from opentelemetry.sdk.trace.export import SimpleSpanProcessor processor = SimpleSpanProcessor(OTLPSpanExporter(endpoint="seu-endpoint-aqui")) ```