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, todas las 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 aprenderemos sobre IronPDF biblioteca.

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 de 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>

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>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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 muestra 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 de OpenTelemetry. Esto implica una configuración similar, pero se centra 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. Utilizando 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

curl http://localhost:5000

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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 o 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:

Install-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()
    {
        //  Crear una nueva actividad para esta operación
        using var activity = _tracer.StartActivity("Generate PDF");
        //  Simular la adición de algunos atributos relacionados con la operación
        activity?.SetTag("pdf.size", "A4");
        activity?.SetTag("pdf.content", "Hello World");
        try
        {
            //  Inicializar el generador de PDF
            var renderer = new ChromePdfRenderer();
            //  Generar un PDF a partir de HTML
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
            //  Guardar el PDF en un archivo
            var outputPath = "output.pdf";
            pdf.SaveAs(outputPath);
            //  Éxito del registro
            activity?.SetTag("pdf.status", "Success");
            activity?.SetTag("pdf.outputPath", outputPath);
        }
        catch (Exception ex)
        {
            //  Registrar todas las excepciones que se produzcan durante la generación de PDF
            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()
    {
        //  Crear una nueva actividad para esta operación
        using var activity = _tracer.StartActivity("Generate PDF");
        //  Simular la adición de algunos atributos relacionados con la operación
        activity?.SetTag("pdf.size", "A4");
        activity?.SetTag("pdf.content", "Hello World");
        try
        {
            //  Inicializar el generador de PDF
            var renderer = new ChromePdfRenderer();
            //  Generar un PDF a partir de HTML
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
            //  Guardar el PDF en un archivo
            var outputPath = "output.pdf";
            pdf.SaveAs(outputPath);
            //  Éxito del registro
            activity?.SetTag("pdf.status", "Success");
            activity?.SetTag("pdf.outputPath", outputPath);
        }
        catch (Exception ex)
        {
            //  Registrar todas las excepciones que se produzcan durante la generación de PDF
            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()
		'  Crear una nueva actividad para esta operación
		Dim activity = _tracer.StartActivity("Generate PDF")
		'  Simular la adición de algunos atributos relacionados con la operación
		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
			'  Inicializar el generador de PDF
			Dim renderer = New ChromePdfRenderer()
			'  Generar un PDF a partir de HTML
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
			'  Guardar el PDF en un archivo
			Dim outputPath = "output.pdf"
			pdf.SaveAs(outputPath)
			'  Éxito del registro
			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
			'  Registrar todas las excepciones que se produzcan durante la generación de PDF
			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 prueba gratuita de producción para poner a prueba todas sus capacidades con toda su fuerza. La licencia comienza a partir de $749.