Application Real-Time Monitoring Service:Report .NET trace data with OpenTelemetry

Step 1: Create a sample web application

1. Create a new ASP.NET Core project and build it:

      mkdir dotnet-simple-demo
      cd dotnet-simple-demo
      dotnet new web
      dotnet build

2. Replace the contents of Properties/launchSettings.json with the following configuration:

      {
        "$schema": "http://json.schemastore.org/launchsettings.json",
        "profiles": {
          "http": {
            "commandName": "Project",
            "dotnetRunMessages": true,
            "launchBrowser": true,
            "applicationUrl": "http://localhost:8080",
            "environmentVariables": {
              "ASPNETCORE_ENVIRONMENT": "Development"
            }
          }
        }
      }

Step 2: Install the automatic instrumentation agent

Download and run the installation script:

curl -L -O https://github.com/open-telemetry/opentelemetry-dotnet-instrumentation/releases/latest/download/otel-dotnet-auto-install.sh
./otel-dotnet-auto-install.sh

Step 3: Configure environment variables and run the application

Set the required environment variables, source the instrumentation script, and start the application.

Replace the following placeholders with your actual values:

export OTEL_TRACES_EXPORTER=otlp \
  OTEL_METRICS_EXPORTER=none \
  OTEL_LOGS_EXPORTER=none \
  OTEL_SERVICE_NAME=<service-name> \
  OTEL_EXPORTER_OTLP_PROTOCOL=grpc \
  OTEL_EXPORTER_OTLP_ENDPOINT=<endpoint> \
  OTEL_EXPORTER_OTLP_HEADERS="Authentication=<token>"

. $HOME/.otel-dotnet-auto/instrument.sh
dotnet run

Step 4: Verify trace reporting

Send a request to the application to generate traces:

curl localhost:8080/

The automatic instrumentation agent captures the request and reports the trace to Managed Service for OpenTelemetry. To verify that traces arrived, see View monitoring data.

For additional configuration options such as resource attributes, sampler settings, and propagation, see Configuration and settings in the OpenTelemetry documentation.

Step 1: Add OpenTelemetry packages

Navigate to the dotnet-demo/opentelemetry-demo/manual-demo directory and add the required NuGet packages:

dotnet add package OpenTelemetry
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
dotnet add package OpenTelemetry.Exporter.Console       # Optional: export to console for debugging
dotnet add package OpenTelemetry.Extensions.Hosting

Step 2: Create the tracing configuration

Create OpentelemetryExporterDemo.cs with a TracerProvider that exports spans over HTTP to your Managed Service for OpenTelemetry endpoint.

Replace <endpoint> with the HTTP endpoint from the Prerequisites section.

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;
using OpenTelemetry.Resources;
using OpenTelemetry.Exporter;

namespace Demo
{
    internal static class OpentelemetryExporterDemo
    {
        internal static void Run()
        {
            Console.WriteLine("otlp running");
            // Specify the service name that appears in ARMS.
            var serviceName = "otlp-test";
            using var tracerProvider = Sdk.CreateTracerProviderBuilder()
                .AddSource(serviceName)
                .SetResourceBuilder(
                ResourceBuilder.CreateDefault().AddService(serviceName))
                .AddOtlpExporter(opt =>
                                 {
                                     // Set the HTTP endpoint for trace export.
                                     opt.Endpoint = new Uri("<endpoint>");
                                     opt.Protocol = OtlpExportProtocol.HttpProtobuf;
                                 })
                .AddConsoleExporter() // Optional: prints spans to console for debugging.
                .Build();
            for(int i = 0; i<10; i++)
            {
                var MyActivitySource = new ActivitySource(serviceName);
                using var activity = MyActivitySource.StartActivity("SayHello");
                activity?.SetTag("bar", "Hello World");
            }
        }
    }
}

Step 3: Update the entry point

Modify Program.cs to call the tracing demo:

using System.Diagnostics;
using System.Net.Http;
using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;


namespace Demo
{
    public class Otlp
    {
        public static void Main(string[] args)
        {
            OpentelemetryExporterDemo.Run();
        }
    }
}

Step 4: Run and verify

dotnet run

The application creates 10 sample spans and exports them to Managed Service for OpenTelemetry. To verify that traces arrived, see View monitoring data.

Step 1: Create an ASP.NET Core MVC application

Navigate to the dotnet-demo/opentelemetry-demo/auto-demo directory. Replace <your-project-name> with your application name:

mkdir <your-project-name>
cd <your-project-name>
dotnet new mvc

Step 2: Add OpenTelemetry packages

Install the core OpenTelemetry packages and the ASP.NET Core instrumentation library:

dotnet add package OpenTelemetry.Exporter.Console               # Optional: export to console for debugging
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol  # Export over OTLP
dotnet add package OpenTelemetry.Instrumentation.AspNetCore      # Auto-instrument ASP.NET Core

To instrument additional frameworks (such as HttpClient, gRPC, or SQL), add the corresponding OpenTelemetry.Instrumentation.* package. See Traces instrumentations for the full list.

Step 3: Configure OpenTelemetry in Program.cs

Add the following imports at the top of Program.cs:

using System.Diagnostics;
using OpenTelemetry.Exporter;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

Add the DiagnosticsConfig class at the end of the file. Replace <your-service-name> and <your-host-name> with your actual values:

public static class DiagnosticsConfig
{
    public const string ServiceName = "<your-service-name>";
    public const string HostName = "<your-host-name>";
    public static ActivitySource ActivitySource = new ActivitySource(ServiceName);
}

Add the OpenTelemetry initialization code between builder.Services.AddControllersWithViews() and var app = builder.Build(). Choose one of the following export protocols:

Option A: Export over HTTP

Replace <http_endpoint> with the HTTP endpoint from the Prerequisites section:

// ...
builder.Services.AddOpenTelemetry()
    .WithTracing(tracerProviderBuilder =>
        tracerProviderBuilder
            .AddSource(DiagnosticsConfig.ActivitySource.Name)
            .SetResourceBuilder(OpenTelemetry.Resources.ResourceBuilder.CreateDefault()
                .AddAttributes(new Dictionary<string, object> {
                    {"service.name", DiagnosticsConfig.ServiceName},
                    {"host.name",DiagnosticsConfig.HostName}
                }))
            .AddAspNetCoreInstrumentation()
            .AddConsoleExporter() // Optional: prints spans to console for debugging.
            .AddOtlpExporter(opt =>
            {
                opt.Endpoint = new Uri("<http_endpoint>");
                opt.Protocol = OtlpExportProtocol.HttpProtobuf;
            })
     );
// ...

Option B: Export over gRPC

Replace <grpc_endpoint> and <token> with the gRPC endpoint and authentication token from the Prerequisites section:

// ...
builder.Services.AddOpenTelemetry()
    .WithTracing(tracerProviderBuilder =>
        tracerProviderBuilder
            .AddSource(DiagnosticsConfig.ActivitySource.Name)
            .SetResourceBuilder(OpenTelemetry.Resources.ResourceBuilder.CreateDefault()
                .AddAttributes(new Dictionary<string, object> {
                    {"service.name", DiagnosticsConfig.ServiceName},
                    {"host.name",DiagnosticsConfig.HostName}
                }))
            .AddAspNetCoreInstrumentation()
            .AddConsoleExporter() // Optional: prints spans to console for debugging.
            .AddOtlpExporter(opt =>
            {
                opt.Endpoint = new Uri("<grpc_endpoint>");
                opt.Headers = "Authentication=<token>";
                opt.Protocol = OtlpExportProtocol.Grpc;
            })
     );
// ...

// Import required packages.
using System.Diagnostics;
using OpenTelemetry.Exporter;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

var builder = WebApplication.CreateBuilder(args);


builder.Services.AddControllersWithViews();

// Initialize OpenTelemetry.
builder.Services.AddOpenTelemetry()
    .WithTracing(tracerProviderBuilder =>
        tracerProviderBuilder
            .AddSource(DiagnosticsConfig.ActivitySource.Name)
            .SetResourceBuilder(OpenTelemetry.Resources.ResourceBuilder.CreateDefault()
                .AddAttributes(new Dictionary<string, object> {
                    {"service.name", DiagnosticsConfig.ServiceName},
                    {"host.name",DiagnosticsConfig.HostName}
                }))
            .AddAspNetCoreInstrumentation()
            .AddConsoleExporter() // Optional: prints spans to console for debugging.
            .AddOtlpExporter(opt =>
            {
                // Export over HTTP.
                opt.Endpoint = new Uri("<http_endpoint>");
                opt.Protocol = OtlpExportProtocol.HttpProtobuf;

                // To export over gRPC instead, uncomment the following lines
                // and comment out the HTTP lines above:
                // opt.Endpoint = new Uri("<grpc_endpoint>");
                // opt.Headers = "Authentication=<token>";
                // opt.Protocol = OtlpExportProtocol.Grpc;
            })
     );


var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

// DiagnosticsConfig: replace with your actual service and host names.
public static class DiagnosticsConfig
{
    public const string ServiceName = "<your-service-name>";
    public const string HostName = "<your-host-name>";
    public static ActivitySource ActivitySource = new ActivitySource(ServiceName);
}

Step 4: Run the application

dotnet run

Sample output:

Building...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5107
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: /path/to/<your-project-name>

Step 5: Verify trace reporting

Open the URL from the output (for example, http://localhost:5107) in a browser. If the default ASP.NET Core MVC page loads, the application is running and traces are being reported to Managed Service for OpenTelemetry.

To verify that traces arrived, see View monitoring data.