OTLP

Adding the exporter

AddOtlpExporter takes the base endpoint, or a callback for everything else, or both. Any number of exporters can be added; each record goes to all of them. The browser script exports with the same settings unless IncludeInBrowser is off.

builder.Services.AddBitBelemetryServices(options =>
{
    options.ServiceName = "MyApp";

    // The base endpoint: /v1/traces, /v1/logs and /v1/metrics are appended.
    options.AddOtlpExporter("http://localhost:4318");

    // Or everything at once.
    options.AddOtlpExporter(otlp =>
    {
        otlp.Endpoint = new Uri("https://otel.example.com");
        otlp.Protocol = BelemetryOtlpProtocol.HttpProtobuf;
        otlp.Compression = BelemetryCompression.Gzip;
    });
});

Protobuf, JSON or gRPC

Protocol picks the encoding. HttpProtobuf (the default, application/x-protobuf) is the most widely supported and the smallest on the wire. HttpJson (application/json) is the OTLP JSON mapping - ids as hex, 64-bit integers as strings, enums as numbers - and is easier to inspect and to receive without generated code. Grpc is OTLP/gRPC over HTTP/2, spoken without a gRPC library: a unary call is an HTTP/2 POST with the 5-byte message prefix, and the status comes back in the trailers. It is what the OpenTelemetry SDKs default to and what the Aspire AppHost hands a resource (OTEL_EXPORTER_OTLP_PROTOCOL=grpc, port 4317); Compression becomes the gRPC message compression (grpc-encoding: gzip).

A browser cannot speak gRPC - fetch has no HTTP/2 trailers - so a gRPC exporter reaches the page only through an OTLP/HTTP BrowserEndpoint; in a WebAssembly app the .NET pipeline cannot either, so there the whole exporter becomes OTLP/HTTP to that endpoint (which must be absolute), and one without is skipped with a startup warning in the Bit.Belemetry log category. On Android and iOS gRPC goes through a SocketsHttpHandler of its own, since the native handlers cannot do HTTP/2 without TLS.

Endpoints

Endpoint is the base URL; /v1/traces, /v1/logs and /v1/metrics are appended to it, exactly as OTEL_EXPORTER_OTLP_ENDPOINT works. TracesEndpoint, LogsEndpoint and MetricsEndpoint are full URLs, used as they are - for backends whose routes do not follow the convention (with gRPC they are base addresses the service method is appended to, as the specification defines the variables). Without any endpoint, the exporter posts to http://localhost:4318 (4317 for gRPC).

BrowserEndpoint is the base URL the browser script uses instead of Endpoint: a public, CORS-enabled route to the collector while the server talks to it over an internal address. The per-signal endpoints apply to the browser only when it shares Endpoint. Signals restricts what is sent - a traces-only backend such as Jaeger gets BelemetrySignals.Traces.

Headers, compression and timeout

Headers are added to every request - typically the vendor's API key. Compression = BelemetryCompression.Gzip sends Content-Encoding: gzip (in the browser through CompressionStream, except for the final batch sent while the page unloads, which cannot wait for it). Timeout bounds one export request (10 s, the OTLP default). Failed requests are retried with backoff, honoring Retry-After, and kept for later with the offline persistence. MinimumLogLevel is the per-exporter counterpart of a logging provider's level: this exporter gets the plain log records at or above it while the others get everything - one backend for errors, another for the full picture, from one pipeline. Events (page views, interactions, web vitals, custom events, exceptions), spans and metrics are not logs to a log level and always pass.

Environment variables

Outside the browser, with options.UseEnvironmentVariables (on by default), the standard OTLP variables are read - which is how the Aspire AppHost and most container platforms wire telemetry into an app without code changes. OTEL_EXPORTER_OTLP_ENDPOINT alone adds an OTLP exporter when none is configured, and fills Endpoint on those that have none - as does any of the per-signal endpoint variables. Headers from the variable are added unless the code set the same name. A protocol of http/protobuf, http/json or grpc sets Protocol; any other value is reported at startup and ignored.

.NET Aspire dashboard

The dashboard is an OTLP receiver with a UI - the quickest way to see traces, logs and metrics locally. Use its OTLP/HTTP endpoint with protobuf. The browser posts to it from your app's origin, so allow that origin with DASHBOARD__OTLP__CORS__ALLOWEDORIGINS (and DASHBOARD__OTLP__CORS__ALLOWEDHEADERS if you send headers). If the dashboard requires an OTLP API key, the browser would have to carry it - keep the browser on the Relay transport or on an unsecured local endpoint.

Under an Aspire AppHost, WithOtlpExporter() sets OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_PROTOCOL=grpc for the projects it runs, and Belemetry follows them: leave the protocol unset in code and the .NET side speaks gRPC to the dashboard. An exporter whose protocol is fixed to HTTP in code would post HTTP to the gRPC port and fail quietly - give the AppHost WithOtlpExporter(OtlpProtocol.HttpProtobuf) in that case. The browser still needs the dashboard's HTTP endpoint (as BrowserEndpoint) and its CORS origin.

OpenTelemetry Collector

The Collector is the usual production setup: the app sends to a collector you control, and the collector holds the vendor credentials, batches, samples and fans out. The browser posts to it cross-origin, so the http receiver needs a cors section; traceparent does not need to be allowed there - it is sent to your API, not to the collector.

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318
        cors:
          allowed_origins: ["https://myapp.example.com"]
          allowed_headers: ["*"]

processors:
  batch: {}

exporters:
  otlphttp:
    endpoint: https://otlp.vendor.example
    headers:
      x-api-key: ${env:VENDOR_API_KEY}

service:
  pipelines:
    traces:  { receivers: [otlp], processors: [batch], exporters: [otlphttp] }
    logs:    { receivers: [otlp], processors: [batch], exporters: [otlphttp] }
    metrics: { receivers: [otlp], processors: [batch], exporters: [otlphttp] }

Grafana

Grafana Alloy is a Collector distribution: its otelcol.receiver.otlp component takes the same http endpoint and cors block, then forwards to Tempo, Loki and Mimir. Grafana Cloud also exposes an OTLP gateway directly; it authenticates with Basic auth (instance id and access token), which is a credential - so the browser should go through Alloy or a collector rather than to the gateway itself.

Jaeger

Jaeger receives OTLP natively on port 4318 - traces only, so restrict the exporter to BelemetrySignals.Traces or its logs and metrics requests are rejected. For the browser, allow the app's origin: Jaeger v2 is built on the Collector and takes the same cors block as above; Jaeger v1 uses --collector.otlp.http.cors.allowed-origins.

Honeycomb

Honeycomb accepts OTLP/HTTP at https://api.honeycomb.io (https://api.eu1.honeycomb.io in the EU) with the API key in the x-honeycomb-team header; metrics also need x-honeycomb-dataset. That key is a credential: keep this exporter out of the browser and route browser telemetry through a collector, or use the Relay transport on Blazor Server and Hybrid.

API