Send .NET logs, metrics, and traces to Bronto

Instrument .NET and ASP.NET Core applications with the OpenTelemetry .NET SDK to send logs, metrics, and traces to Bronto over OTLP/HTTP, via an OTel Collector or directly.

One AddOpenTelemetry() block sends logs, metrics, and traces from your .NET application to Bronto. Existing ILogger calls feed the log pipeline, instruments feed the meter provider, and activities feed the tracer provider — all three sharing one resource identity and one OTLP exporter.

The application exports to an OpenTelemetry Collector, which forwards to Bronto. If you don’t run a Collector, export directly to Bronto instead — only the endpoint and an API key header change.

Prerequisites

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

Install dependencies

dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
dotnet add package OpenTelemetry.Instrumentation.Http

The two instrumentation packages produce request and HTTP client spans and metrics automatically. See .NET instrumentation libraries for the full list, including Entity Framework Core and gRPC.

Initialise the SDK

Configure all three signals in Program.cs:

Program.cs

using OpenTelemetry.Exporter;
using OpenTelemetry.Logs;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);

// Bridge ILogger into the OTel pipeline.
builder.Logging.AddOpenTelemetry(logging =>
{
    logging.IncludeFormattedMessage = true;
    logging.IncludeScopes = true;
});

builder.Services.AddOpenTelemetry()
    .ConfigureResource(resource => resource
        .AddService(serviceName: "my-service", serviceNamespace: "my-team")
        .AddAttributes(new Dictionary<string, object>
        {
            ["deployment.environment"] = "production",
        }))
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddMeter("my-service"))
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSource("my-service"))
    .UseOtlpExporter(OtlpExportProtocol.HttpProtobuf, new Uri("http://localhost:4318/"));

var app = builder.Build();
app.Run();

UseOtlpExporter enables the exporter for logs, metrics, and traces in one call, appending the signal path (/v1/logs, /v1/metrics, /v1/traces) to the base URL. ConfigureResource applies across all three signals, so service.name and service.namespace are shared automatically.

Two resource attributes determine how Bronto organises your data:

OTel attribute	Bronto concept	Description
service.name	Dataset	Groups telemetry from one service
service.namespace	Collection	Groups related services or a team’s services

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.

For console applications and workers, use Host.CreateApplicationBuilder(args) in place of WebApplication.CreateBuilder(args). The AddOpenTelemetry() block is identical.

Instrument your application

ILogger calls need no changes. Add a Meter and an ActivitySource for your own measurements and spans:

using System.Diagnostics;
using System.Diagnostics.Metrics;

public class PaymentService
{
    private static readonly ActivitySource ActivitySource = new("my-service");
    private static readonly Meter Meter = new("my-service");
    private static readonly Counter<long> Payments = Meter.CreateCounter<long>("app.payments");

    private readonly ILogger<PaymentService> _logger;

    public PaymentService(ILogger<PaymentService> logger) => _logger = logger;

    public void ProcessPayment(decimal amount)
    {
        using var activity = ActivitySource.StartActivity("process-payment");
        activity?.SetTag("payment.amount", amount);
        Payments.Add(1);

        _logger.LogInformation("Processing payment");  // trace_id and span_id attached automatically
    }
}

The AddSource and AddMeter names in Program.cs must match the ActivitySource and Meter names here, or their telemetry is dropped.

Any ILogger call made inside an active Activity 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.

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 the configured endpoint, and that its pipelines include an otlp receiver and the Bronto exporters.
• Confirm OtlpExportProtocol.HttpProtobuf matches the Collector receiver you are pointing at — port 4318 is HTTP, 4317 is gRPC.
• Check that every ActivitySource and Meter name is registered with AddSource / AddMeter.

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. Point the base URL at your Bronto region:

Program.cs

    .UseOtlpExporter(
        OtlpExportProtocol.HttpProtobuf,
        new Uri("https://ingestion.eu.bronto.io/"));   // or ingestion.us.bronto.io

and supply your API key through the standard OTLP header variable, which UseOtlpExporter reads:

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.

.NET GenAI telemetry is library-specific — each has its own opt-in, and each emits from its own activity source, which you register with AddSource:

Library	Enable with	Activity source
Semantic Kernel	SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS=true	Microsoft.SemanticKernel*
OpenAI .NET SDK	AppContext.SetSwitch("OpenAI.Experimental.EnableOpenTelemetry", true)	OpenAI.*
Microsoft.Extensions.AI	Wrap the IChatClient with UseOpenTelemetry()	Experimental.Microsoft.Extensions.AI
AWS SDK (Bedrock)	OpenTelemetry.Instrumentation.AWS package	added by AddAWSInstrumentation()

These APIs are experimental and version-sensitive, so verify the attributes emitted by the version you deploy against each library’s current documentation.

Capture prompts and responses

Content capture is controlled by the .NET library rather than the cross-language OTel variables — OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, used by the Python, JavaScript, and Java instrumentations, is not a .NET-wide switch. Semantic Kernel uses its own sensitive-diagnostics opt-in:

export SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE=true

Microsoft.Extensions.AI uses the EnableSensitiveData option on UseOpenTelemetry() instead. Prompt and response content can contain sensitive data, so enable it deliberately.

Manual spans

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

private static readonly ActivitySource ActivitySource = new("my-service");

using var activity = ActivitySource.StartActivity("chat gpt-4o-mini");
activity?.SetTag("gen_ai.provider.name", "openai");
activity?.SetTag("gen_ai.request.model", "gpt-4o-mini");
activity?.SetTag("gen_ai.usage.input_tokens", 33);
activity?.SetTag("gen_ai.usage.output_tokens", 74);
// Bronto flattens array attributes — this is searchable as finish_reasons.0
activity?.SetTag("gen_ai.response.finish_reasons", new[] { "stop" });

See the GenAI span conventions for the full attribute list.

For the recommended attribute set and Bronto search queries, see LLM Observability.