Send .NET logs and traces to Bronto via OpenTelemetry

This page covers instrumenting a .NET application with the OpenTelemetry SDK to send logs and traces to Bronto over OTLP/HTTP via a local OTel Collector. Both signals are co-equal: logs are bridged from ILogger — no log statement changes needed — and traces are emitted via a tracer provider.

If you don’t have a Collector and want to export directly from your application to Bronto, see Direct export to Bronto at the bottom of this page.

Prerequisites

.NET 6 or later
NuGet
A running OTel Collector configured to forward logs and traces to Bronto — see Connect Open Telemetry to Bronto
OpenTelemetry .NET SDK documentation

Install dependencies

dotnet add package OpenTelemetry
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Package	Purpose
`OpenTelemetry`	Core OTel SDK
`OpenTelemetry.Extensions.Hosting`	`ILogger` bridge and hosted service integration
`OpenTelemetry.Exporter.OpenTelemetryProtocol`	OTLP/HTTP exporter

Configure the log bridge

The OTel .NET SDK integrates with Microsoft.Extensions.Logging via AddOpenTelemetry(). Every log record emitted through ILogger is forwarded to the OTel pipeline automatically. For ASP.NET Core or any host using Microsoft.Extensions.Hosting, configure logging in Program.cs:

Program.cs

builder.Logging.AddOpenTelemetry(logging =>
{
    logging.IncludeFormattedMessage = true;
    logging.IncludeScopes = true;
});

IncludeFormattedMessage attaches the rendered log message as the OTel record body. IncludeScopes propagates any active ILogger scope values as structured attributes.

Configure the OTLP exporter

Wire the OTLP exporter into the logging pipeline. By default the OTel Collector listens for OTLP/HTTP on port 4318.

Program.cs

builder.Services.AddOpenTelemetry()
    .WithLogging(logs =>
    {
        logs.AddOtlpExporter(otlp =>
        {
            otlp.Endpoint = new Uri("http://localhost:4318/v1/logs");
            otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        });
    });

If your Collector runs on a different host or port, update the endpoint accordingly.

Set resource attributes

Resource attributes are attached to every log record exported from this process. Two attributes drive how Bronto organises incoming logs:

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

Set them via ConfigureResource on the OpenTelemetryBuilder:

Program.cs

builder.Services.AddOpenTelemetry()
    .ConfigureResource(resource => resource
        .AddService(
            serviceName: "my-service",
            serviceNamespace: "my-team")
        .AddAttributes(new Dictionary<string, object>
        {
            ["deployment.environment"] = "production",
        }))
    .WithLogging(logs =>
    {
        logs.AddOtlpExporter(otlp =>
        {
            otlp.Endpoint = new Uri("http://localhost:4318/v1/logs");
            otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        });
    });

Complete example

The snippet below shows the full Program.cs setup for an ASP.NET Core application.

Program.cs

using OpenTelemetry.Exporter;
using OpenTelemetry.Logs;
using OpenTelemetry.Resources;

var builder = WebApplication.CreateBuilder(args);

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",
        }))
    .WithLogging(logs =>
    {
        logs.AddOtlpExporter(otlp =>
        {
            otlp.Endpoint = new Uri("http://localhost:4318/v1/logs");
            otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        });
    });

var app = builder.Build();

// ILogger usage — no changes needed to existing code
var logger = app.Services.GetRequiredService<ILogger<Program>>();
logger.LogInformation("Application started");
logger.LogWarning("Low disk space {DiskFreeGb}", 2.1);

app.Run();

For non-hosted applications (console apps, workers), use LoggerFactory.Create with the same AddOpenTelemetry and AddOtlpExporter calls instead of builder.Logging.

Verify delivery

After running your application, check both signals in Bronto:

Logs: open the Search page and filter by the dataset name you set in service.name — your log records should appear within a few seconds.
Traces: open the Explore Traces page and filter by the same service.name — your spans should appear within a few seconds.

If no logs appear, check:

The OTel Collector is running and reachable at the configured endpoint.
The Collector’s pipeline includes a logs pipeline with an otlp receiver and the Bronto exporter — see Connect Open Telemetry to Bronto.
The OtlpExportProtocol.HttpProtobuf protocol matches the Collector’s configured receiver.

Traces

For ASP.NET Core, HTTP clients, and Entity Framework Core, add the corresponding NuGet instrumentation packages — OpenTelemetry.Instrumentation.AspNetCore, OpenTelemetry.Instrumentation.Http, OpenTelemetry.Instrumentation.EntityFrameworkCore — then call .AddAspNetCoreInstrumentation(), .AddHttpClientInstrumentation(), etc. inside WithTracing. See .NET instrumentation libraries for the full list.

Configure the tracer provider

No additional packages are needed — OpenTelemetry.Extensions.Hosting and OpenTelemetry.Exporter.OpenTelemetryProtocol already include tracing support. Add WithTracing to the same AddOpenTelemetry call you used for logging:

Program.cs

builder.Services.AddOpenTelemetry()
    .ConfigureResource(resource => resource
        .AddService(
            serviceName: "my-service",
            serviceNamespace: "my-team")
        .AddAttributes(new Dictionary<string, object>
        {
            ["deployment.environment"] = "production",
        }))
    .WithLogging(logs =>
    {
        logs.AddOtlpExporter(otlp =>
        {
            otlp.Endpoint = new Uri("http://localhost:4318/v1/logs");
            otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        });
    })
    .WithTracing(tracing =>
    {
        tracing
            .AddSource("my-service")
            .AddOtlpExporter(otlp =>
            {
                otlp.Endpoint = new Uri("http://localhost:4318/v1/traces");
                otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
            });
    });

ConfigureResource applies to both logs and traces — service.name and service.namespace are shared automatically.

Creating spans

Inject ActivitySource and use it to create spans around operations you want to trace:

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

public async Task<IActionResult> ProcessPayment(PaymentRequest request)
{
    using var activity = ActivitySource.StartActivity("process-payment");
    activity?.SetTag("payment.amount", request.Amount);
    activity?.SetTag("payment.currency", request.Currency);

    _logger.LogInformation("Processing payment");  // trace_id injected automatically
    // your code here
    return Ok();
}

Any ILogger call made inside an active Activity span will have trace_id and span_id injected automatically.

GenAI semantic conventions

If your application calls an LLM, OpenTelemetry defines GenAI semantic conventions for model, token usage, and prompt/response content.

This page was verified on July 17, 2026. GenAI libraries and semantic conventions are evolving rapidly, so package configuration and emitted attributes can change between releases. Keep your instrumentation current and verify the fields emitted by the version you deploy.

Auto-instrumentation

Several .NET AI libraries provide GenAI telemetry, but each has its own opt-in:

Semantic Kernel: enable SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS=true, then add its activity source:

tracing.AddSource("Microsoft.SemanticKernel*")

OpenAI .NET SDK: enable its experimental OpenTelemetry switch with AppContext.SetSwitch("OpenAI.Experimental.EnableOpenTelemetry", true), then add OpenAI.* as a source.
Microsoft.Extensions.AI: wrap an IChatClient with UseOpenTelemetry(); set EnableSensitiveData when you intentionally want message content recorded.
AWS SDK: OpenTelemetry.Instrumentation.AWS covers Bedrock Runtime and Agent Runtime clients.

Check each library’s current documentation because these APIs are experimental and version-sensitive.

Experimental: capturing prompt and response content

Content capture is configured by the .NET library rather than the cross-language OTel environment variables. For Semantic Kernel, use the sensitive diagnostics opt-in:

export SEMANTICKERNEL_EXPERIMENTAL_GENAI_ENABLE_OTEL_DIAGNOSTICS_SENSITIVE=true

Prompt and response content can contain sensitive data. Microsoft.Extensions.AI uses its EnableSensitiveData option instead; the OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT variable used by some JavaScript, Java, and Python instrumentations is not a .NET-wide switch.

Manual spans

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);
activity?.SetTag("gen_ai.response.finish_reasons", new[] { "stop" });

See LLM Observability for the full recommended attribute set, including gen_ai.input.messages / gen_ai.output.messages, and how to search and aggregate GenAI fields in Bronto.

Direct export to Bronto

If you are not using an OTel Collector, export directly to Bronto by replacing the exporter endpoints and adding your API key:

.WithLogging(logs =>
{
    logs.AddOtlpExporter(otlp =>
    {
        otlp.Endpoint = new Uri("https://ingestion.eu.bronto.io/v1/logs"); // or ingestion.us.bronto.io
        otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        otlp.Headers = "x-bronto-api-key=<YOUR_API_KEY>";
    });
})
.WithTracing(tracing =>
{
    tracing.AddSource("my-service").AddOtlpExporter(otlp =>
    {
        otlp.Endpoint = new Uri("https://ingestion.eu.bronto.io/v1/traces"); // or ingestion.us.bronto.io
        otlp.Protocol = OtlpExportProtocol.HttpProtobuf;
        otlp.Headers = "x-bronto-api-key=<YOUR_API_KEY>";
    });
});

Region	Logs endpoint	Traces endpoint
EU	`https://ingestion.eu.bronto.io/v1/logs`	`https://ingestion.eu.bronto.io/v1/traces`
US	`https://ingestion.us.bronto.io/v1/logs`	`https://ingestion.us.bronto.io/v1/traces`

See API Keys for how to create a key with ingestion permissions. No other changes to the rest of the setup are required.

Overview

Ingest with agents

Ingest from AWS

Ingest from Azure

Ingest from CDN and edge

Ingest from apps and platforms

Ingest from infrastructure and databases

Ingest OpenTelemetry data

Send .NET logs and traces to Bronto via OpenTelemetry

Prerequisites

Install dependencies

Configure the log bridge

Configure the OTLP exporter

Set resource attributes

Complete example

Verify delivery

Traces

Configure the tracer provider

Creating spans

GenAI semantic conventions

Auto-instrumentation

Experimental: capturing prompt and response content

Manual spans

Direct export to Bronto

​Prerequisites

​Install dependencies

​Configure the log bridge

​Configure the OTLP exporter

​Set resource attributes

​Complete example

​Verify delivery

​Traces

​Configure the tracer provider

​Creating spans

​GenAI semantic conventions

​Auto-instrumentation

​Experimental: capturing prompt and response content

​Manual spans

​Direct export to Bronto

Prerequisites

Install dependencies

Configure the log bridge

Configure the OTLP exporter

Set resource attributes

Complete example

Verify delivery

Traces

Configure the tracer provider

Creating spans

GenAI semantic conventions

Auto-instrumentation

Experimental: capturing prompt and response content

Manual spans

Direct export to Bronto