Opentelemetry C# (Cómo funciona para desarrolladores)

OpenTelemetry es un conjunto de herramientas, API y SDK que funcionan conjuntamente para recopilar, procesar y exportar datos de telemetría como trazas, métricas y registros de sus aplicaciones. Este tutorial tiene como objetivo ayudar a los principiantes a entender cómo integrar OpenTelemetry en aplicaciones C # utilizando el método de extensión, centrándose en la recogida de métricas incorporadas para supervisar las aplicaciones .NET con eficacia. También conoceremos laBiblioteca IronPDF para la generación de PDF en C#.

Introducción a OpenTelemetry

OpenTelemetry proporciona una forma unificada de recopilar todo tipo de datos de sus aplicaciones. Para los desarrolladores .NET, la integración de OpenTelemetry significa que usted puede monitorear sus aplicaciones más de cerca, entender cómo funcionan en tiempo real, e identificar problemas rápidamente. La biblioteca de instrumentación de OpenTelemetry permite automáticamente el seguimiento y la recopilación de métricas para aplicaciones .NET.

Con las métricas recopiladas por el marco OpenTelemetry, los desarrolladores obtienen información valiosa sobre el entorno de ejecución de .NET. La aplicación OpenTelemetry .NET es compatible con el tiempo de ejecución .NET, incluidos .NET Core y .NET Framework. Se adhiere al protocolo OpenTelemetry para la recogida normalizada de datos telemétricos.

Configuración del entorno

Para empezar, necesitará tener instalado el SDK .NET en su equipo. Si utilizas Visual Studio, es probable que venga con el SDK de .NET. Puede comprobar su versión actual del SDK de .NET abriendo una línea de comandos y ejecutando:

dotnet --version

A continuación, cree un nuevo proyecto Web .NET ejecutando:

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

Este comando crea un nuevo proyecto ASP.NET Core en un directorio llamado MyTelemetryApp.

Integración de OpenTelemetry

Añadir paquetes necesarios

En primer lugar, añada los paquetes OpenTelemetry necesarios a su proyecto. Abra su terminal y navegue hasta el directorio de su proyecto. A continuación, instale los siguientes paquetes mediante la CLI de NuGet Package Manager:

dotnet add package OpenTelemetry -Version <version>
dotnet add package OpenTelemetry.Extensions.Hosting -Version <version>
dotnet add package OpenTelemetry.Instrumentation.AspNetCore -Version <version>
dotnet add package OpenTelemetry.Exporter.Console -Version <version>

Reemplazar con la última versión de cada paquete.

Configuración de OpenTelemetry en su aplicación

Después de añadir los paquetes necesarios, es necesario configurar OpenTelemetry en su aplicación. Esto implica configurar el SDK OpenTelemetry y especificar qué datos de telemetría recopilar. OpenTelemetry ofrece bibliotecas de instrumentación para una perfecta integración con aplicaciones .NET.

Abra el archivo Startup.cs en su proyecto y modifique el método ConfigureServices para incluir OpenTelemetry como se muestra en el siguiente fragmento de código:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddOpenTelemetryTracing(builder =>
    {
        builder.AddAspNetCoreInstrumentation()
               .AddHttpClientInstrumentation()
               .AddConsoleExporter();
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddOpenTelemetryTracing(builder =>
    {
        builder.AddAspNetCoreInstrumentation()
               .AddHttpClientInstrumentation()
               .AddConsoleExporter();
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddControllers()
	services.AddOpenTelemetryTracing(Sub(builder)
		builder.AddAspNetCoreInstrumentation().AddHttpClientInstrumentation().AddConsoleExporter()
	End Sub)
End Sub

Este fragmento de código muestra cómo configurar OpenTelemetry para recopilar datos de telemetría de aplicaciones ASP.NET Core y llamadas de clientes HTTP y, a continuación, exportar estos datos a la consola. El método AddAspNetCoreInstrumentation habilita automáticamente la instrumentación de las solicitudes HTTP entrantes a las aplicaciones ASP.NET Core.

Recopilación de métricas

Para recopilar métricas, también tendrá que configurar la API de métricas OpenTelemetry, centrándose en las métricas en lugar de rastreo.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddOpenTelemetryMetrics(builder =>
    {
        builder.AddAspNetCoreInstrumentation()
               .AddHttpClientInstrumentation()
               .AddConsoleExporter(options => options.Targets = ConsoleExporterOutputTargets.Console);
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddOpenTelemetryMetrics(builder =>
    {
        builder.AddAspNetCoreInstrumentation()
               .AddHttpClientInstrumentation()
               .AddConsoleExporter(options => options.Targets = ConsoleExporterOutputTargets.Console);
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddControllers()
	services.AddOpenTelemetryMetrics(Sub(builder)
		builder.AddAspNetCoreInstrumentation().AddHttpClientInstrumentation().AddConsoleExporter(Sub(options) options.Targets = ConsoleExporterOutputTargets.Console)
	End Sub)
End Sub

Esta configuración permite la recopilación de métricas integradas de ASP.NET Core e instrumentación de cliente HTTP, exportándolas a la consola para facilitar su visualización.

Creación de métricas personalizadas

Mientras OpenTelemetry recoge automáticamente muchas métricas útiles, es posible que desee recopilar métricas personalizadas específicas para su aplicación. La utilización de un método de extensión proporcionado por la biblioteca de instrumentación no sólo recopila telemetría automáticamente, sino que también ofrece a los desarrolladores un control más granular sobre las métricas emitidas. Esto puede lograrse instrumentando manualmente el código para crear y registrar métricas personalizadas.

var meter = new Meter("MyCustomMetrics", "1.0");
var counter = meter.CreateCounter<int>("custom_request_count", description: "Counts custom requests");
app.Use((context, next) =>
{
    counter.Add(1, new KeyValuePair<string, object>("path", context.Request.Path));
    return next();
});

var meter = new Meter("MyCustomMetrics", "1.0");
var counter = meter.CreateCounter<int>("custom_request_count", description: "Counts custom requests");
app.Use((context, next) =>
{
    counter.Add(1, new KeyValuePair<string, object>("path", context.Request.Path));
    return next();
});

Dim meter As New Meter("MyCustomMetrics", "1.0")
Dim counter = meter.CreateCounter(Of Integer)("custom_request_count", description:= "Counts custom requests")
app.Use(Function(context, [next])
	counter.Add(1, New KeyValuePair(Of String, Object)("path", context.Request.Path))
	Return [next]()
End Function)

Este fragmento de código muestra cómo crear una métrica personalizada que cuente las peticiones a su aplicación, etiquetando cada métrica con la ruta de petición. Aprovechando los métodos de extensión proporcionados por OpenTelemetry, los desarrolladores pueden ejercer un control más granular sobre el proceso de recopilación de datos de telemetría.

Probar la integración

Ejecute su aplicación utilizando la línea de comandos o Visual Studio. Realice algunas peticiones a su aplicación, ya sea navegando a su URL en un navegador web o utilizando una herramienta como curl. Deberías ver los datos de telemetría, incluyendo trazas y métricas, imprimiéndose en la salida de tu consola.

curl http://localhost:5000

Presentación de IronPDF

IronPDF es una potente biblioteca para desarrolladores C# que permite generar, manipular y renderizar documentos PDF directamente en aplicaciones .NET. Esta función es especialmente útil para generar informes, facturas o cualquier otro tipo de documentos.resultados basados en documentos de aplicaciones web que utilizan HTMLo aplicaciones de escritorio. La combinación de IronPDF con OpenTelemetry permite a los desarrolladores supervisar el rendimiento y la fiabilidad de los procesos de generación de PDF dentro de sus aplicaciones, garantizando una experiencia de usuario sin problemas.

Configuración de IronPDF

En primer lugar, debe añadir IronPDF a su proyecto .NET. Puede hacerlo utilizando el gestor de paquetes NuGet. Abra su terminal y navegue hasta el directorio de su proyecto. A continuación, ejecute el siguiente comando para instalar IronPDF:

dotnet add package IronPDF

Generación de un PDF con IronPDF y supervisión con OpenTelemetry

A continuación se muestra un ejemplo de cómo generar un simple documento PDF y supervisar el funcionamiento utilizando OpenTelemetry. El siguiente ejemplo asume que usted ya ha configurado OpenTelemetry en su aplicación como se mostró anteriormente.

using IronPdf;
using OpenTelemetry.Trace;
public class PdfService
{
    private readonly Tracer _tracer;
    public PdfService(Tracer tracer)
    {
        _tracer = tracer;
    }
    public void GeneratePdf()
    {
        // Create a new activity for this operation
        using var activity = _tracer.StartActivity("Generate PDF");
        // Simulate adding some attributes related to the operation
        activity?.SetTag("pdf.size", "A4");
        activity?.SetTag("pdf.content", "Hello World");
        try
        {
            // Initialize the PDF generator
            var renderer = new ChromePdfRenderer();
            // Generate a PDF from HTML
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
            // Save the PDF to a file
            var outputPath = "output.pdf";
            pdf.SaveAs(outputPath);
            // Log success
            activity?.SetTag("pdf.status", "Success");
            activity?.SetTag("pdf.outputPath", outputPath);
        }
        catch (Exception ex)
        {
            // Log any exceptions that occur during PDF generation
            activity?.SetTag("pdf.status", "Error");
            activity?.SetTag("pdf.error", ex.Message);
            throw;
        }
    }
}

using IronPdf;
using OpenTelemetry.Trace;
public class PdfService
{
    private readonly Tracer _tracer;
    public PdfService(Tracer tracer)
    {
        _tracer = tracer;
    }
    public void GeneratePdf()
    {
        // Create a new activity for this operation
        using var activity = _tracer.StartActivity("Generate PDF");
        // Simulate adding some attributes related to the operation
        activity?.SetTag("pdf.size", "A4");
        activity?.SetTag("pdf.content", "Hello World");
        try
        {
            // Initialize the PDF generator
            var renderer = new ChromePdfRenderer();
            // Generate a PDF from HTML
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
            // Save the PDF to a file
            var outputPath = "output.pdf";
            pdf.SaveAs(outputPath);
            // Log success
            activity?.SetTag("pdf.status", "Success");
            activity?.SetTag("pdf.outputPath", outputPath);
        }
        catch (Exception ex)
        {
            // Log any exceptions that occur during PDF generation
            activity?.SetTag("pdf.status", "Error");
            activity?.SetTag("pdf.error", ex.Message);
            throw;
        }
    }
}

Imports IronPdf
Imports OpenTelemetry.Trace
Public Class PdfService
	Private ReadOnly _tracer As Tracer
	Public Sub New(ByVal tracer As Tracer)
		_tracer = tracer
	End Sub
	Public Sub GeneratePdf()
		' Create a new activity for this operation
		Dim activity = _tracer.StartActivity("Generate PDF")
		' Simulate adding some attributes related to the operation
		If activity IsNot Nothing Then
			activity.SetTag("pdf.size", "A4")
		End If
		If activity IsNot Nothing Then
			activity.SetTag("pdf.content", "Hello World")
		End If
		Try
			' Initialize the PDF generator
			Dim renderer = New ChromePdfRenderer()
			' Generate a PDF from HTML
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
			' Save the PDF to a file
			Dim outputPath = "output.pdf"
			pdf.SaveAs(outputPath)
			' Log success
			If activity IsNot Nothing Then
				activity.SetTag("pdf.status", "Success")
			End If
			If activity IsNot Nothing Then
				activity.SetTag("pdf.outputPath", outputPath)
			End If
		Catch ex As Exception
			' Log any exceptions that occur during PDF generation
			If activity IsNot Nothing Then
				activity.SetTag("pdf.status", "Error")
			End If
			If activity IsNot Nothing Then
				activity.SetTag("pdf.error", ex.Message)
			End If
			Throw
		End Try
	End Sub
End Class

En este ejemplo, creamos una nueva clase de servicio PdfService que incluye un método GeneratePdf para generar un documento PDF. Utilizamos la clase ChromePdfRenderer de IronPDF para renderizar HTML como un documento PDF. Con OpenTelemetry, iniciamos una nueva actividad llamada "Generar PDF" para supervisar esta operación. Añadimos etiquetas personalizadas a la actividad para proporcionar contexto adicional sobre el proceso de generación de PDF, como el tamaño del PDF, el tipo de contenido y la ruta de salida. También capturamos cualquier excepción para registrar los errores adecuadamente dentro de la misma actividad.

Conclusión

La integración de OpenTelemetry en sus aplicaciones .NET le permite recopilar valiosos datos de telemetría, ofreciendo información sobre el rendimiento y el comportamiento de su aplicación. Siguiendo los pasos descritos en este tutorial, habrá configurado el rastreo básico y la recopilación de métricas para una aplicación web .NET. Experimente más a fondo explorando funciones más avanzadas de OpenTelemetry, como la exportación de datos telemétricos a herramientas de supervisión externas o la recopilación de registros junto con trazas y métricas.

IronPDF ofrece unprueba gratuita de IronPDF de producción para probar todas sus capacidades. Las licencias cuestan a partir de 399 dólares.