Send Python logs, metrics, and traces to Bronto

Instrument a Python application with the OpenTelemetry Python SDK to send logs, metrics, and traces to Bronto over OTLP/HTTP, via an OTel Collector or directly.

One initialisation block sends logs, metrics, and traces from your Python application to Bronto. Logs are bridged from the standard logging module, metrics flow through a meter provider, and traces through a tracer provider — all three sharing one resource identity and one OTLP/HTTP exporter configuration.

The application exports to an OpenTelemetry Collector, which forwards to Bronto. If you don’t run a Collector, export directly to Bronto instead — the code is identical, only two environment variables change.

Prerequisites

• Python 3.9 or later, and pip
• An OTel Collector reachable from your application, with logs, metrics, and traces pipelines forwarding to Bronto — see Connect OpenTelemetry Collector to Bronto

Install the SDK

pip install \
  opentelemetry-api \
  opentelemetry-sdk \
  opentelemetry-exporter-otlp-proto-http

Configure the environment

The SDK reads its endpoint and identity from environment variables, so nothing in the code below is environment-specific.

export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_SERVICE_NAME="my-service"
export OTEL_RESOURCE_ATTRIBUTES="service.namespace=my-team,deployment.environment=production"

The SDK appends the signal path (/v1/logs, /v1/metrics, /v1/traces) to OTEL_EXPORTER_OTLP_ENDPOINT automatically.

Two resource attributes determine how Bronto organises your data:

OTel attribute	Bronto concept	Set with
service.name	Dataset	OTEL_SERVICE_NAME
service.namespace	Collection	OTEL_RESOURCE_ATTRIBUTES

http://localhost:4318 is the standard OTLP/HTTP address for a Collector on the same host. Use the address reachable from your application if the Collector runs in another container, pod, or host. No authentication is needed between the application and the Collector — the Collector holds the Bronto API key.

Initialise the SDK

Add this module to your project and call configure_otel() once, before your first log statement or span.

otel.py

import logging

from opentelemetry import metrics, trace
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor


def configure_otel():
    # Picks up OTEL_SERVICE_NAME and OTEL_RESOURCE_ATTRIBUTES.
    resource = Resource.create()

    # Logs — bridges the standard logging module into OTel.
    logger_provider = LoggerProvider(resource=resource)
    logger_provider.add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter()))
    logging.getLogger().addHandler(LoggingHandler(logger_provider=logger_provider))
    logging.getLogger().setLevel(logging.INFO)

    # Metrics
    reader = PeriodicExportingMetricReader(OTLPMetricExporter())
    metrics.set_meter_provider(MeterProvider(resource=resource, metric_readers=[reader]))

    # Traces
    tracer_provider = TracerProvider(resource=resource)
    tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
    trace.set_tracer_provider(tracer_provider)

The handler is attached to the root logger, so every logger in the process inherits it and existing log statements are unchanged. Pass a name to logging.getLogger("my_app") to instrument only part of your application.

Instrument your application

app.py

import logging

from opentelemetry import metrics, trace

from otel import configure_otel

configure_otel()

logger = logging.getLogger(__name__)
tracer = trace.get_tracer("my-service")
request_counter = metrics.get_meter("my-service").create_counter("app.requests")

with tracer.start_as_current_span("handle-request") as span:
    span.set_attribute("http.request.method", "GET")
    request_counter.add(1, {"http.request.method": "GET"})
    logger.info("Handling request")  # trace_id and span_id attached automatically

Any log emitted inside an active span automatically carries that span’s trace_id and span_id, so you can jump from a log line to its trace in Bronto with no manual context propagation.

Framework spans without code changes. Install opentelemetry-instrumentation-<framework> (for example opentelemetry-instrumentation-flask, -django, -fastapi, -sqlalchemy, -requests) and run your app with opentelemetry-instrument python app.py. The CLI configures the providers itself from the same OTEL_* variables above, so use it instead of otel.py — and add opentelemetry-instrumentation-logging so standard-library logs are still bridged. See Python zero-code instrumentation.

Using structlog or loguru? See Python: structlog / loguru to route them through the same pipeline.

Verify

Run your application, then check each signal in Bronto, filtering by the service.name you set:

• Logs — the Search page, in the dataset named after your service
• Metrics — the Metric Explorer
• Traces — the Explore Traces page

If nothing arrives:

• Confirm the Collector is running and reachable at OTEL_EXPORTER_OTLP_ENDPOINT, and that its pipelines include an otlp receiver and the Bronto exporters.
• The batch processors export on a background thread. Short-lived scripts can exit before the first flush — for those, swap in SimpleLogRecordProcessor and SimpleSpanProcessor, or call logger_provider.shutdown() and tracer_provider.shutdown() before exit.

For signal-specific reference material, see Send Metrics to Bronto and Send Traces to Bronto.

Direct export to Bronto

Without a Collector, the application exports straight to Bronto over OTLP/HTTP. The code in otel.py is unchanged — point the endpoint at your Bronto region and add your API key:

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingestion.eu.bronto.io"   # or ingestion.us.bronto.io
export OTEL_EXPORTER_OTLP_HEADERS="x-bronto-api-key=<YOUR_API_KEY>"

Region	Base endpoint
EU	https://ingestion.eu.bronto.io
US	https://ingestion.us.bronto.io

See API Keys for how to create a key with ingestion permissions.

Prefer the Collector for multi-service environments — it batches, filters, and enriches telemetry, and keeps the API key out of every application. Direct export suits single services and simple architectures.

GenAI semantic conventions

If your application calls an LLM, OpenTelemetry’s GenAI semantic conventions define gen_ai.* span attributes for model, token usage, and prompt and response content. Python has the richest GenAI auto-instrumentation of any OTel SDK.

Install the instrumentation for your provider and run under the zero-code wrapper:

pip install opentelemetry-instrumentation-openai-v2   # or -botocore for Amazon Bedrock via boto3
opentelemetry-instrument python app.py

Each model call then produces a span such as chat gpt-4o-mini in place of a plain HTTP client span:

Attribute	Example
gen_ai.provider.name	openai
gen_ai.request.model	gpt-4o-mini
gen_ai.usage.input_tokens	33
gen_ai.usage.output_tokens	74
gen_ai.response.finish_reasons	["stop"]

Capture prompts and responses

Content capture is off by default. Two environment variables enable it:

export OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=span_only
export OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental

span_only writes content to gen_ai.input.messages and gen_ai.output.messages on the span, which Bronto surfaces as searchable trace fields. The legacy true setting emits it as separate log records correlated by trace_id, where it is not queryable on the span itself — prefer span_only where your instrumentation supports it. These conventions are still experimental, so verify the attributes emitted by the version you deploy.

Manual spans

Where no instrumentation package exists for your provider, set the same attributes yourself:

with tracer.start_as_current_span("chat gpt-4o-mini") as span:
    span.set_attribute("gen_ai.provider.name", "openai")
    span.set_attribute("gen_ai.request.model", "gpt-4o-mini")
    span.set_attribute("gen_ai.usage.input_tokens", 33)
    span.set_attribute("gen_ai.usage.output_tokens", 74)
    # Bronto flattens array attributes — this is searchable as finish_reasons.0
    span.set_attribute("gen_ai.response.finish_reasons", ["stop"])

See the GenAI span conventions for the full attribute list.

For the recommended attribute set and Bronto search queries, see LLM Observability. For Anthropic and LangChain instrumentation, see OpenLLMetry and LangChain.