Exporters
Você está visualizando a versão em versão em inglês desta página porque ela ainda não foi traduzida. Possui interesse em ajudar? Veja como contribuir.
Envie dados de telemetria para o OpenTelemetry 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, Zipkin, Prometheus, ou um backend específico de um fornecedor.
Exportadores disponíveis
O registro oferece uma lista de exportadores para .NET.
Entre os exportadores, os exportadores do OpenTelemetry Protocol (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.
Esta página reúne informações sobre os principais exportadores do OpenTelemetry .NET 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
Nota
Caso já possua um coletor ou backend OTLP configurado, poderá pular para configurar as dependências do exportador OTLP 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:
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:
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 para enviar os seus dados de telemetria para o seu backend de observabilidade.
Dependencies
If you want to send telemetry data to an OTLP endpoint (like the OpenTelemetry Collector, Jaeger or Prometheus), you can choose between two different protocols to transport your data:
- HTTP/protobuf
- gRPC
Start by installing the
OpenTelemetry.Exporter.OpenTelemetryProtocol
package as a dependency for your project:
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
If you’re using ASP.NET Core install the
OpenTelemetry.Extensions.Hosting
package as well:
dotnet add package OpenTelemetry.Extensions.Hosting
Usage
ASP.NET Core
Configure the exporters in your ASP.NET Core services:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
// The rest of your setup code goes here
.AddOtlpExporter())
.WithMetrics(metrics => metrics
// The rest of your setup code goes here
.AddOtlpExporter());
builder.Logging.AddOpenTelemetry(logging => {
// The rest of your setup code goes here
logging.AddOtlpExporter();
});
This will, by default, send telemetry using gRPC to http://localhost:4317, to customize this to use HTTP and the protobuf format, you can add options like this:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
// The rest of your setup code goes here
.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/traces");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
}))
.WithMetrics(metrics => metrics
// The rest of your setup code goes here
.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/metrics");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
}));
builder.Logging.AddOpenTelemetry(logging => {
// The rest of your setup code goes here
logging.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/logs");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
});
});
Non-ASP.NET Core
Configure the exporter when creating a TracerProvider
, MeterProvider
or
LoggerFactory
:
var tracerProvider = Sdk.CreateTracerProviderBuilder()
// Other setup code, like setting a resource goes here too
.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/traces");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
})
.Build();
var meterProvider = Sdk.CreateMeterProviderBuilder()
// Other setup code, like setting a resource goes here too
.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/metrics");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
})
.Build();
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
logging.AddOtlpExporter(options =>
{
options.Endpoint = new Uri("your-endpoint-here/v1/logs");
options.Protocol = OtlpExportProtocol.HttpProtobuf;
})
});
});
Use environment variables to set values like headers and an endpoint URL for production.
Console
Dependencies
The console exporter is useful for development and debugging tasks, and is the
simplest to set up. Start by installing the
OpenTelemetry.Exporter.Console
package as a dependency for your project:
dotnet add package OpenTelemetry.Exporter.Console
If you’re using ASP.NET Core install the
OpenTelemetry.Extensions.Hosting
package as well:
dotnet add package OpenTelemetry.Extensions.Hosting
Usage
ASP.NET Core
Configure the exporter in your ASP.NET Core services:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
// The rest of your setup code goes here
.AddConsoleExporter()
)
.WithMetrics(metrics => metrics
// The rest of your setup code goes here
.AddConsoleExporter()
);
builder.Logging.AddOpenTelemetry(logging => {
// The rest of your setup code goes here
logging.AddConsoleExporter();
});
Non-ASP.NET Core
Configure the exporter when creating a TracerProvider
, MeterProvider
or
LoggerFactory
:
var tracerProvider = Sdk.CreateTracerProviderBuilder()
// The rest of your setup code goes here
.AddConsoleExporter()
.Build();
var meterProvider = Sdk.CreateMeterProviderBuilder()
// The rest of your setup code goes here
.AddConsoleExporter()
.Build();
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(logging =>
{
logging.AddConsoleExporter();
});
});
Jaeger
Configuração do Backend
O Jaeger 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:
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
Siga as instruções para configurar os exportadores OTLP.
Prometheus
Para enviar dados de métricas para o Prometheus, você
pode
ativar o OTLP Receiver do Prometheus
e utilizar o exportador 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
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 ou OTLP para a sua aplicação.
É possível executar o Prometheus 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:
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:
docker run --rm -v ${PWD}/prometheus.yml:/prometheus/prometheus.yml -p 9090:9090 prom/prometheus --enable-feature=otlp-write-receive
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.
Dependencies
Install the exporter package as a dependency for your application:
dotnet add package OpenTelemetry.Exporter.Prometheus.AspNetCore --version 1.12.0-beta.1
If you’re using ASP.NET Core install the
OpenTelemetry.Extensions.Hosting
package as well:
dotnet add package OpenTelemetry.Extensions.Hosting
Usage
ASP.NET Core
Configure the exporter in your ASP.NET Core services:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithMetrics(metrics => metrics.AddPrometheusExporter());
You’ll then need to add the endpoint so that Prometheus can scrape your site.
You can do this using the IAppBuilder
extension like this:
var builder = WebApplication.CreateBuilder(args);
// .. Setup
var app = builder.Build();
app.UseOpenTelemetryPrometheusScrapingEndpoint();
await app.RunAsync();
Non-ASP.NET Core
Warning
This component is intended for dev inner-loop, there is no plan to make it production ready. Production environments should useOpenTelemetry.Exporter.Prometheus.AspNetCore
,
or a combination of
OpenTelemetry.Exporter.OpenTelemetryProtocol
and
OpenTelemetry Collector.For applications not using ASP.NET Core, you can use the HttpListener
version
which is available in a
different package:
dotnet add package OpenTelemetry.Exporter.Prometheus.HttpListener --version 1.12.0-beta.1
Then this is setup directly on the MeterProviderBuilder
:
var meterProvider = Sdk.CreateMeterProviderBuilder()
.AddMeter(MyMeter.Name)
.AddPrometheusHttpListener(
options => options.UriPrefixes = new string[] { "http://localhost:9464/" })
.Build();
Finally, register the Prometheus scraping middleware using the
UseOpenTelemetryPrometheusScrapingEndpoint
extension method on
IApplicationBuilder
:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.UseOpenTelemetryPrometheusScrapingEndpoint();
Further details on configuring the Prometheus exporter can be found here.
Zipkin
Configuração do Backend
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 para a sua aplicação.
É possível executar o [Zipkin]Zipkin em um contêiner Docker através do seguinte comando:
docker run --rm -d -p 9411:9411 --name zipkin openzipkin/zipkin
Dependencies
To send your trace data to Zipkin, install the exporter package as a dependency for your application:
dotnet add package OpenTelemetry.Exporter.Zipkin
If you’re using ASP.NET Core install the
OpenTelemetry.Extensions.Hosting
package as well:
dotnet add package OpenTelemetry.Extensions.Hosting
Usage
ASP.NET Core
Configure the exporter in your ASP.NET Core services:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
// The rest of your setup code goes here
.AddZipkinExporter(options =>
{
options.Endpoint = new Uri("your-zipkin-uri-here");
}));
Non-ASP.NET Core
Configure the exporter when creating a tracer provider:
var tracerProvider = Sdk.CreateTracerProviderBuilder()
// The rest of your setup code goes here
.AddZipkinExporter(options =>
{
options.Endpoint = new Uri("your-zipkin-uri-here");
})
.Build();
Feedback
Was this page helpful?
Thank you. Your feedback is appreciated!
Please let us know how we can improve this page. Your feedback is appreciated!