Send Traces to Bronto

Send OpenTelemetry traces to Bronto using OTLP over HTTP or gRPC, exported directly from the OTel SDK or routed through an OpenTelemetry Collector.

Bronto accepts OpenTelemetry traces over OTLP. You can export traces directly from an OpenTelemetry SDK, or route them through an OpenTelemetry Collector before forwarding them to Bronto.

Bronto recommends enabling logs, metrics, and traces together. If you only need traces, OpenTelemetry lets you enable the trace exporter and pipeline independently. For the combined setup, see Connect OpenTelemetry Collector to Bronto.

For complete runtime setup and working examples, use the language guides: Python and Node.js / JavaScript.

Prerequisites

Before you begin, make sure you have:

• a Bronto API key
• an application instrumented with an OpenTelemetry SDK, or an OpenTelemetry Collector receiving traces
• network access to the Bronto ingestion endpoint for your region

Endpoint and authentication

Use the trace endpoint that matches your Bronto region:

Region	Trace endpoint
EU	https://ingestion.eu.bronto.io/v1/traces
US	https://ingestion.us.bronto.io/v1/traces

Both endpoints accept OTLP/HTTP over HTTPS on port 443, in either protobuf (Content-Type: application/x-protobuf) or JSON (Content-Type: application/json) encoding. Every request must include this header:

x-bronto-api-key: <BRONTO_API_KEY>

Send traces through an OpenTelemetry Collector

If you are using an OpenTelemetry Collector, configure an OTLP receiver and an OTLP/HTTP exporter that targets the Bronto trace endpoint.

The example uses the standard Collector receiver ports: 4317 for OTLP/gRPC and 4318 for OTLP/HTTP. A same-host application typically exports OTLP/HTTP traces to http://localhost:4318/v1/traces; replace the host, port, protocol, and TLS settings when your deployment differs.

otel-config.yaml

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  otlphttp/brontotraces:
    traces_endpoint: https://ingestion.eu.bronto.io/v1/traces
    compression: none
    headers:
      x-bronto-api-key: <BRONTO_API_KEY>

service:
  pipelines:
    traces/bronto:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/brontotraces]

Replace the endpoint with your region and replace <BRONTO_API_KEY> with your Bronto API key.

If your Collector also sends logs and metrics, keep a pipeline for each signal. Traces use traces_endpoint, metrics use metrics_endpoint, and logs use logs_endpoint.

Send traces directly from an SDK

If you do not need a Collector, configure your application’s OpenTelemetry SDK to export traces directly to Bronto over OTLP/HTTP.

For direct trace export, point your SDK at the regional traces endpoint and include the Bronto API key header:

export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT="https://ingestion.<region>.bronto.io/v1/traces"
export OTEL_EXPORTER_OTLP_TRACES_HEADERS="x-bronto-api-key=<BRONTO_API_KEY>"
export OTEL_TRACES_EXPORTER="otlp"

Minimal working examples

Bronto has OpenTelemetry setup guides for several languages. If you want a quick starting point, the Python and Node.js guides include SDK setup, resource attributes, exporter configuration, and direct export to Bronto.

Python

Configure the OpenTelemetry Python SDK, create spans, and export traces to Bronto.

Node.js / JavaScript

Configure the OpenTelemetry JS SDK, create spans, and export traces to Bronto.

Verify trace delivery

After configuration, verify trace delivery with these checks:

1. Confirm that you are sending traces to the correct regional endpoint.
2. Confirm every request includes x-bronto-api-key.
3. Run your application and trigger an operation that creates a span.
4. Check Bronto for the expected service.name.
5. Confirm new traces are visible and spans include the attributes you expect.

Troubleshooting

If you do not see traces:

• verify the ingestion URL matches your region
• verify the x-bronto-api-key header is present and valid
• confirm your process flushes spans before exit
• confirm your exporter is configured for traces, not logs or metrics
• check network egress rules allow outbound HTTPS on port 443

Next steps

Once trace ingestion is working, you can:

• add auto-instrumentation for your framework or runtime
• capture traces from services you cannot rebuild with zero-code eBPF instrumentation
• route telemetry through a shared OpenTelemetry Collector
• add metrics through the same SDK and Collector
• enrich spans with standard resource attributes
• standardize exporter configuration across services

To inspect incoming trace data, see Explore Traces.