AYUDA .NET

OpenTelemetry .NET (Cómo funciona para los desarrolladores)

Publicado en 1 de julio, 2024

Introducción

La creación de documentos PDF dinámicos, ricos y basados en datos es una demanda típica en muchos sectores del desarrollo de software moderno. Las empresas dependen en gran medida de su capacidad para generar PDF de alta calidad con rapidez, ya sea para crear facturas, informes o documentación. Sin embargo, el seguimiento y la comprensión de la eficacia de los procesos de producción de PDF resultan esenciales para preservar la salud de las aplicaciones y garantizar el placer de los usuarios a medida que se complican y se hacen más grandes.

El objetivo de este artículo es analizar cómo los desarrolladores pueden mejorar las operaciones de generación de PDF y proporcionar información importante sobre el rendimiento de las aplicaciones utilizando las funciones de IronPDF y OpenTelemetry.NET. Exploraremos las características y ventajas de ambas tecnologías y mostraremos cómo pueden trabajar juntas de forma armoniosa para optimizar la creación y supervisión de PDF en aplicaciones .NET.

¿Qué es OpenTelemetry?

OpenTelemetry es un marco de observabilidad independiente del proveedor creado especialmente para aplicaciones nativas de la nube. La instrumentación automática de OpenTelemetry proporciona una única API para recopilar información de telemetría, incluidos registros, rastreo y métricas. Con el uso de estos amplios datos, los desarrolladores pueden depurar eficazmente los problemas, localizar los cuellos de botella en el rendimiento y obtener una comprensión completa del comportamiento del programa. OpenTelemetry admite instrumentación automática y manual para una recogida de datos telemétricos completa y flexible.

Componentes clave de OpenTelemetry

API: Para instrumentar aplicaciones y generar datos de telemetría, OpenTelemetry especifica un conjunto estandarizado de APIs. Esto hace que el procedimiento de instrumentación más simple y garantiza la coherencia a través de diversos lenguajes de programación.
SDKs: Para instrumentar aplicaciones, OpenTelemetry ofrece SDKs adaptados a determinados lenguajes. Los desarrolladores pueden incorporar fácilmente la funcionalidad de OpenTelemetry en sus proyectos .NET con la ayuda del SDK .NET.
Exportadores: Estas partes se encargan de transmitir los datos de telemetría que se han recogido a los sistemas backend para que puedan ser almacenados y examinados. Muchos exportadores de sistemas backend muy utilizados, como Zipkin(rastreo)prometeo(métricas)y Jaeger(rastreo)son compatibles con OpenTelemetry.
Instrumentación automática: Este método simplifica el proceso para las aplicaciones .NET Core. Las bibliotecas OpenTelemetry pueden capturar automáticamente los datos para las operaciones comunes dentro de su aplicación web o servicio. Esto elimina las modificaciones manuales de código, agilizando el proceso de integración.
Instrumentación manual: Para un control granular sobre la recopilación de datos, OpenTelemetry proporciona una API robusta para la instrumentación manual. Este enfoque le permite capturar métricas y trazas específicas relacionadas con la lógica única de su aplicación. Es especialmente útil para aplicaciones .NET Framework o escenarios en los que la instrumentación automática no cubre sus necesidades específicas.

Ventajas de utilizar OpenTelemetry en .NET

La integración de OpenTelemetry en sus aplicaciones .NET ofrece varias ventajas:

Neutralidad de proveedor: OpenTelemetry ofrece flexibilidad y futuro a prueba de su aplicación mediante la integración sin esfuerzo con una variedad de sistemas back-end. No es necesario cambiar el código de instrumentación para cambiar de sistema backend.
Enfoque estandarizado: Instrumentar varias áreas de su aplicación es más fácil gracias a la API uniforme. Los desarrolladores pueden utilizar la misma API para recopilar registros, trazas y métricas, lo que facilita la lectura y el mantenimiento del código.
Análisis en profundidad del rendimiento: OpenTelemetry ofrece una gran cantidad de datos(métricas, trazas y registros) para un análisis exhaustivo del rendimiento. Puede localizar áreas de optimización y determinar el origen subyacente de los problemas con esta perspectiva global.
Mejor resolución de problemas: Los desarrolladores pueden detectar y solucionar problemas más fácilmente siguiendo la ruta de las solicitudes a través de su aplicación utilizando los ricos datos de rastreo que captura OpenTelemetry.
Escalabilidad Mejorada: La complejidad de su aplicación no obstaculizará la capacidad de OpenTelemetry para escalar. Las nuevas funciones o servicios pueden instrumentarse fácilmente sin necesidad de grandes modificaciones de código.

Crear y configurar OpenTelemetry

Configurar OpenTelemetry en la aplicación ASP.NET

OpenTelemetry necesita ser configurado en su aplicación; para aplicaciones ASP.NET Core, esto se hace normalmente en el método ConfigureServices de su archivo Startup.cs. Esta es una ilustración de la configuración de un exportador Jaeger:

using OpenTelemetry.Trace;
using OpenTelemetry.Exporter.Jaeger;
using OpenTelemetry.Resources;

public void ConfigureServices(IServiceCollection services)
{
    // Configure OpenTelemetry
    builder.Services.AddOpenTelemetry().WithTracing(options =>
    {
        // Configure Jaeger exporter
        // serviceName we can read from environment variables
        options
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService(serviceName))
            .AddAspNetCoreInstrumentation().AddJaegerExporter(opt =>
            {
                opt.AgentHost = "localhost"; // Jaeger agent host
                opt.AgentPort = 14250; // Jaeger agent port
            });
    });
    // Other service configurations...
}

using OpenTelemetry.Trace;
using OpenTelemetry.Exporter.Jaeger;
using OpenTelemetry.Resources;

public void ConfigureServices(IServiceCollection services)
{
    // Configure OpenTelemetry
    builder.Services.AddOpenTelemetry().WithTracing(options =>
    {
        // Configure Jaeger exporter
        // serviceName we can read from environment variables
        options
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService(serviceName))
            .AddAspNetCoreInstrumentation().AddJaegerExporter(opt =>
            {
                opt.AgentHost = "localhost"; // Jaeger agent host
                opt.AgentPort = 14250; // Jaeger agent port
            });
    });
    // Other service configurations...
}

Imports OpenTelemetry.Trace
Imports OpenTelemetry.Exporter.Jaeger
Imports OpenTelemetry.Resources

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure OpenTelemetry
	builder.Services.AddOpenTelemetry().WithTracing(Sub(options)
		' Configure Jaeger exporter
		' serviceName we can read from environment variables
		options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName)).AddAspNetCoreInstrumentation().AddJaegerExporter(Sub(opt)
				opt.AgentHost = "localhost" ' Jaeger agent host
				opt.AgentPort = 14250 ' Jaeger agent port
		End Sub)
	End Sub)
	' Other service configurations...
End Sub

VB C#

Ponga el nombre de su servicio en lugar de serviceName. Según sus opciones de configuración de Jaeger, cambie el host y el puerto del agente de Jaeger.

Añadir middleware OpenTelemetry

Debe incluir el middleware OpenTelemetry en las aplicaciones ASP.NET Core para obtener la instrumentación automática de las solicitudes HTTP entrantes. En el método Configure de tu fichero Startup.cs, añade el middleware:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Add OpenTelemetry middleware if we are using Prometheus
    app.UseHttpMetrics();
    // Other middleware configurations...
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Add OpenTelemetry middleware if we are using Prometheus
    app.UseHttpMetrics();
    // Other middleware configurations...
}

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	' Add OpenTelemetry middleware if we are using Prometheus
	app.UseHttpMetrics()
	' Other middleware configurations...
End Sub

VB C#

Iniciar rastreo

Después de configurar todo, OpenTelemetry comenzará el seguimiento de las solicitudes HTTP entrantes y el envío de información de telemetría al backend Jaeger configurado por su cuenta.

Verificar y controlar

Puede comprobar si hay rastros en su backend Jaeger para confirmar que OpenTelemetry está funcionando correctamente. Abrir la interfaz de usuario de Jaeger(normalmente disponible en http://localhost:16686 para Jaeger UI) y busque rastros asociados a su servicio.

Elija un sistema backend (opcional)

OpenTelemetry no es imprescindible para la instrumentación básica, pero se integra con otros sistemas operativos backend para almacenar y procesar datos de telemetría. Las opciones más populares son los sistemas operativos admitidos oficialmente:

Jaeger(rastreo)
Prometeo(métricas)
Zipkin(rastreo)

Primeros pasos

¿Qué es IronPDF?

El popular paquete .NETIronPDF permite crear, editar y renderizar documentos PDF dentro de programas .NET. Las funciones para trabajar con PDF son numerosas e incluyen: convertir páginas HTML en PDF; extraer texto e imágenes de PDF; añadir texto, imágenes y formas a documentos PDF preexistentes; y producir PDF a partir de contenidos HTML, fotos o datos sin procesar.

Dos de las principales ventajas de IronPDF son su facilidad de uso y su sencillez. Los desarrolladores pueden empezar a crear PDF sin esfuerzo en sus proyectos .NET gracias a su intuitiva API y a su completa documentación. La eficacia y velocidad de IronPDF son características adicionales que ayudan a los desarrolladores a crear documentos PDF de alta calidad de forma rápida y eficaz.

Algunas de las ventajas de IronPDF:

Producción de PDF a partir de HTML, imágenes y datos sin procesar
Extracción de texto e imágenes de archivos PDF
Incorporar marcas de agua, encabezados y pies de página en archivos PDF
Los archivos PDF están protegidos por encriptación y contraseña
Capacidad para firmar y cumplimentar formularios electrónicamente

Instalar el paquete NuGet

Múltiples paquetes NuGet están disponibles para diferentes componentes de OpenTelemetry. En función de sus necesidades, puede instalar los paquetes necesarios. Para enviar datos de telemetría a un backend de observabilidad(como Jaeger, Zipkin o Prometheus)como mínimo necesitará el paquete OpenTelemetry, paquetes de instrumentación para su marco de aplicación(como ASP.NET Core)y un paquete exportador. Asegúrese también de que el paquete IronPDF está instalado en su proyecto. Para instalarlo, utilice la consola del gestor de paquetes NuGet:

Install-Package OpenTelemetry
Install-Package OpenTelemetry.Instrumentation.AspNetCore
Install-Package OpenTelemetry.Exporter.Jaeger
Install-Package IronPdf

Utilización de OpenTelemetry con IronPDF

Abra el archivo Startup.cs de su aplicación ASP.NET Core para llegar a la función ConfigureServices. Para configurar IronPDF, incluya el código siguiente.

using IronPdf;

public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

using IronPdf;

public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

Imports IronPdf

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure IronPDF
	services.AddSingleton(Of HtmlToPdf)()
	' Other service configurations...
End Sub

VB C#

Este código asegura que una instancia de HtmlToPdf es creada y utilizada por la aplicación sólo configurando el servicio HtmlToPdf de IronPDF como un singleton.

Usted puede rastrear y observar los procesos de generación de PDF en sus aplicaciones .NET mediante la integración de OpenTelemetry.NET con IronPDF. Examinemos el código del ejemplo en profundidad, paso a paso:

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using System.Net;
using System.Net.Http.Headers;

namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<WeatherForecastController> _logger;
        private readonly Tracer _tracer;

        public WeatherForecastController(ILogger<WeatherForecastController> logger, HtmlToPdf htmlToPdf, TracerProvider tracerProvider)
        {
            _tracer = tracerProvider.GetTracer("Demo");
            _htmlToPdf = htmlToPdf;
        }

        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                var pdfBytes = pdfDocument.BinaryData;
                return pdfBytes;
            }
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using System.Net;
using System.Net.Http.Headers;

namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<WeatherForecastController> _logger;
        private readonly Tracer _tracer;

        public WeatherForecastController(ILogger<WeatherForecastController> logger, HtmlToPdf htmlToPdf, TracerProvider tracerProvider)
        {
            _tracer = tracerProvider.GetTracer("Demo");
            _htmlToPdf = htmlToPdf;
        }

        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                var pdfBytes = pdfDocument.BinaryData;
                return pdfBytes;
            }
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports OpenTelemetry.Trace
Imports System.Diagnostics
Imports System.Net
Imports System.Net.Http.Headers

Namespace DemoWebApplication.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class DemoController
		Inherits ControllerBase

		Private ReadOnly _htmlToPdf As HtmlToPdf
		Private ReadOnly _logger As ILogger(Of WeatherForecastController)
		Private ReadOnly _tracer As Tracer

		Private Function WeatherForecastController(ByVal logger As ILogger(Of WeatherForecastController), ByVal htmlToPdf As HtmlToPdf, ByVal tracerProvider As TracerProvider) As Public
			_tracer = tracerProvider.GetTracer("Demo")
			_htmlToPdf = htmlToPdf
		End Function

		<HttpGet>
		Public Function Generate() As FileContentResult
			Dim fileName As String = "Sample.pdf"
			Dim stream = GeneratePdf("Hello IronPDF")
			Return New FileContentResult(stream, "application/octet-stream") With {.FileDownloadName = fileName}
		End Function

		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
			Using activity = _tracer.StartActiveSpan("PDF Generation")
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)
				Dim pdfBytes = pdfDocument.BinaryData
				Return pdfBytes
			End Using
		End Function
	End Class
End Namespace

VB C#

Para generar una instancia de trazador para nuestra aplicación, inyectamos los servicios TracerProvider. Una actividad OpenTelemetry llamada "Generación PDF" es creada por el método Generar para simbolizar el trabajo que está en marcha. Imitamos algunos trabajos dentro de la actividad(sustituye tu propia lógica). Establecemos una métrica de histograma denominada duración_del_trabajo_ms para controlar la duración en milisegundos del trabajo. Añadimos un punto de datos a la métrica, etiquetándolo "Demo" con el valor "Generación PDF" y documentando la duración(1000 ms en este caso). Las etiquetas aportan al análisis una capa adicional de contexto.

Salida PDF generada a partir del código fuente anterior:

OpenTelemetry .NET(Cómo funciona para los desarrolladores): Figura 1 - Salida generada a partir del código anterior utilizando IronPDF y OpenTelemetry

A continuación se muestra la pantalla de la traza generada desde la interfaz de usuario de Jaeger:

OpenTelemetry .NET(Cómo funciona para los desarrolladores): Figura 2 - Traza de salida generada desde Jaeger UI

Conclusión

OpenTelemetry es un cambio de juego para la optimización del rendimiento de aplicaciones .NET y la supervisión de la salud. Proporciona a los desarrolladores un conocimiento profundo del funcionamiento interno de sus aplicaciones al ofrecer un método estandarizado e independiente del proveedor para recopilar, analizar y exportar datos de telemetría(métricas, trazas y registros).

Al integrar OpenTelemetry.NET con IronPDF, los desarrolladores pueden mejorar los flujos de trabajo para crear PDF y obtener información sobre el rendimiento de sus aplicaciones. Al aprovechar la implementación de OpenTelemetry.NET para instrumentar manualmente los procesos de generación de PDF, los desarrolladores pueden realizar un seguimiento de las rutas de ejecución, supervisar las métricas de rendimiento e identificar las regiones que requieren optimización. Además, la recopilación y el análisis centralizados de métricas de monitorización son posibles gracias a la exportación de datos de telemetría a plataformas de observabilidad, lo que ofrece a los desarrolladores la posibilidad de preservar la salud de sus aplicaciones y ofrecer una experiencia de usuario impecable.

La integración de la aplicación OpenTelemetry.NET y IronPDF puede mejorar los flujos de trabajo de los desarrolladores para la creación de archivos PDF y garantizar la escalabilidad, el rendimiento y la fiabilidad de las aplicaciones .NET. La integración de estas tecnologías ayuda a los desarrolladores a satisfacer las necesidades del desarrollo de software moderno y a producir resultados extraordinarios, ya se trate de crear facturas, informes o documentación.

Cuando se compra como paquete, IronPDF tiene un precio asequible e incluye una licencia de por vida. El paquete ofrece un gran valor por sólo 749 dólares, que es una tarifa única para muchos sistemas. Ofrece a los titulares de licencias asistencia técnica en línea las 24 horas del día. Visite la páginaSitio web de Iron Software para más detalles sobre la tasa. ExploreProductos de Iron Software para obtener más información sobre las soluciones que ofrecen.

< ANTERIOR
Dotnetopenauth .NET Core (Cómo funciona para los desarrolladores)

SIGUIENTE >
Autofac .NET 6 (Cómo funciona para desarrolladores)