Round #707

Wire OpenTelemetry tracing: ActivitySource for traces, Meter for metrics, with ILogger<T> structured logs feeding both.

Here's an example of how you can wire OpenTelemetry tracing with `ActivitySource` for traces, `Meter` for metrics, and `ILogger<T>` structured logs feeding both in a C# application: ### NuGet Packages First, install the required NuGet packages: ```bash dotnet add package OpenTelemetry dotnet add package OpenTelemetry.Exporter.Console dotnet add package OpenTelemetry.Exporter.Jaeger dotnet add package OpenTelemetry.Extensions.Logging dotnet add package OpenTelemetry.Instrumentation.AspNetCore dotnet add package OpenTelemetry.Instrumentation.Http dotnet add package OpenTelemetry.Metrics dotnet add package OpenTelemetry.Sdk dotnet add package OpenTelemetry.Trace dotnet add package Microsoft.Extensions.Logging ``` ### OpenTelemetry Configuration Next, configure OpenTelemetry in the `Program.cs` file: ```csharp using OpenTelemetry; using OpenTelemetry.Exporter; using OpenTelemetry.Extensions.Logging; using OpenTelemetry.Instrumentation.AspNetCore; using OpenTelemetry.Instrumentation.Http; using OpenTelemetry.Metrics; using OpenTelemetry.Sdk; using OpenTelemetry.Trace; var builder = WebApplication.CreateBuilder(args); // Configure OpenTelemetry builder.Services.AddOpenTelemetryTracing( (builder, services) => { builder .AddSource("MyApp") .AddConsoleExporter() .AddJaegerExporter(); }); builder.Services.AddOpenTelemetryMetrics( (builder, services) => { builder .AddMeter("MyApp") .AddConsoleExporter() .AddPrometheusExporter(); }); // Configure logging builder.Services.AddLogging(loggingBuilder => { loggingBuilder.AddOpenTelemetry(options => { options.IncludeFormattedMessage = true; options.IncludeScopes = true; options.ParseStateValues = true; }); }); var app = builder.Build(); // ... ``` ### ActivitySource and Meter Create an `ActivitySource` and a `Meter` instance: ```csharp using OpenTelemetry; using OpenTelemetry.Metrics; public class MyService { private readonly ActivitySource _activitySource; private readonly Meter _meter; private readonly ILogger<MyService> _logger; public MyService(ActivitySource activitySource, Meter meter, ILogger<MyService> logger) { _activitySource = activitySource; _meter = meter; _logger = logger; } public void DoWork() { using var activity = _activitySource.StartActivity("DoWork"); var counter = _meter.CreateCounter<long>("my_counter"); try { // Simulate some work Thread.Sleep(100); // Log a message _logger.LogInformation("Doing some work"); // Increment the counter counter.Add(1); } catch (Exception ex) { // Log an error _logger.LogError(ex, "Error doing work"); } } } ``` ### Structured Logs Use the `ILogger<T>` instance to log structured logs: ```csharp public class MyController : Controller { private readonly ILogger<MyController> _logger; public MyController(ILogger<MyController> logger) { _logger = logger; } [HttpGet] public IActionResult Get() { _logger.LogInformation("Getting data"); // Simulate some data var data = new { Id = 1, Name = "John" }; _logger.LogInformation("Data: {@Data}", data); return Ok(data); } } ``` ### Example Use Case Here's an example use case that demonstrates how the `ActivitySource`, `Meter`, and `ILogger<T>` instances work together: ```csharp [ApiController] [Route("api/[controller]")] public class MyController : ControllerBase { private readonly MyService _myService; public MyController(MyService myService) { _myService = myService; } [HttpGet] public IActionResult Get() { _myService.DoWork(); return Ok(); } } ``` In this example, the `MyController` instance calls the `DoWork` method on the `MyService` instance, which starts an activity, logs a message, increments a counter, and logs an error if an exception occurs. The `ILogger<T>` instance is used to log structured logs, which are fed into the OpenTelemetry system and can be used to create traces and metrics.

Here's a complete implementation of OpenTelemetry tracing and metrics with structured logging using `ILogger<T>`: ```csharp using Microsoft.Extensions.Logging; using OpenTelemetry; using OpenTelemetry.Logs; using OpenTelemetry.Metrics; using OpenTelemetry.Resources; using OpenTelemetry.Trace; public class Program { public static void Main(string[] args) { // Create a service provider with OpenTelemetry services var serviceProvider = CreateServiceProvider(); // Get an instance of ILogger<T> and ActivitySource var logger = serviceProvider.GetService<ILogger<Program>>(); var activitySource = serviceProvider.GetService<ActivitySource>(); // Start a new activity using var activity = activitySource.StartActivity("MyActivity"); // Log some messages logger.LogInformation("This is an informational message"); logger.LogWarning("This is a warning message"); logger.LogError("This is an error message"); // Get an instance of Meter var meter = serviceProvider.GetService<Meter>(); // Record some metrics var counter = meter.CreateCounter("my_counter"); counter.Add(1); var gauge = meter.CreateGauge("my_gauge"); gauge.Set(10); } private static IServiceProvider CreateServiceProvider() { var services = new ServiceCollection(); // Add OpenTelemetry services services.AddOpenTelemetryTracing(builder => { builder.AddSource("MyActivitySource"); builder.AddConsoleExporter(); }); services.AddOpenTelemetryMetrics(builder => { builder.AddMeter("MyMeter"); builder.AddConsoleExporter(); }); services.AddLogging(loggingBuilder => { loggingBuilder.AddOpenTelemetry(options => { options.IncludeScopes = true; options.IncludeFormattedMessage = true; }); loggingBuilder.AddConsole(); }); return services.BuildServiceProvider(); } } ``` In this implementation, we create a service provider with OpenTelemetry tracing, metrics, and logging services. We then get instances of `ILogger<T>`, `ActivitySource`, and `Meter` to demonstrate how to use them. The `CreateServiceProvider` method sets up the OpenTelemetry services, including tracing, metrics, and logging. The `AddOpenTelemetryTracing` method adds the tracing service, and the `AddOpenTelemetryMetrics` method adds the metrics service. The `AddLogging` method adds the logging service, and the `AddOpenTelemetry` method configures the logging service to use OpenTelemetry. In the `Main` method, we start a new activity using the `ActivitySource`, log some messages using the `ILogger<T>`, and record some metrics using the `Meter`. The activity and metrics are exported to the console using the `AddConsoleExporter` method. Note that you'll need to install the following NuGet packages: * `OpenTelemetry` * `OpenTelemetry.Logs` * `OpenTelemetry.Metrics` * `OpenTelemetry.Trace` * `Microsoft.Extensions.Logging` * `Microsoft.Extensions.Logging.Console` You can install them using the following command: ``` dotnet add package OpenTelemetry dotnet add package OpenTelemetry.Logs dotnet add package OpenTelemetry.Metrics dotnet add package OpenTelemetry.Trace dotnet add package Microsoft.Extensions.Logging dotnet add package Microsoft.Extensions.Logging.Console ```