¿Cuál es el propósito de OpenTelemetry en el desarrollo de C#?

OpenTelemetry proporciona un enfoque unificado para recopilar, procesar y exportar datos de telemetría como trazas, métricas y registros, permitiendo a los desarrolladores monitorear y entender el rendimiento de las aplicaciones en tiempo real.

¿Cómo puedo comenzar a integrar OpenTelemetry en mi aplicación C#?

Comience instalando los paquetes necesarios de OpenTelemetry a través de NuGet, luego configure su aplicación modificando el método 'ConfigureServices' en 'Startup.cs' para incluir trazas y métricas de OpenTelemetry.

¿Qué pasos son necesarios para configurar el entorno para OpenTelemetry en C#?

Asegúrese de que el SDK de .NET esté instalado en su máquina. Puede verificar la instalación ejecutando dotnet --version en su línea de comandos.

¿Cómo genero un PDF en C# usando contenido HTML?

Puede usar la clase ChromePdfRenderer de la biblioteca IronPDF para renderizar HTML como un documento PDF, luego usar el método SaveAs para guardar el PDF generado.

¿Cómo puedo monitorear el proceso de generación de PDF en una aplicación C#?

Use el Tracer de OpenTelemetry para crear una actividad para la generación de PDF, añadiendo etiquetas personalizadas para registrar información relevante sobre el proceso con fines de monitoreo.

¿Qué son las métricas personalizadas y cómo pueden utilizarse en OpenTelemetry con C#?

Las métricas personalizadas son puntos de datos específicos de la aplicación que se pueden recopilar instrumentando manualmente su código con las clases Meter y Counter de OpenTelemetry.

¿Cómo puedo asegurar la generación confiable de PDF en C#?

Utilice la biblioteca IronPDF para generar, manipular y renderizar documentos PDF de forma confiable. IronPDF proporciona características robustas para asegurar salidas de PDF de alta calidad en sus aplicaciones.

¿Existen opciones de licencia disponibles para bibliotecas que ayudan a generar PDFs en C#?

IronPDF ofrece una prueba gratuita para pruebas de producción, con licencias a partir de $399, lo que la hace accesible para que los desarrolladores exploren sus capacidades completas.

¿Cómo puedo probar mi integración de OpenTelemetry en una aplicación C#?

Ejecute su aplicación y realice solicitudes usando un navegador web o herramientas como curl, luego observe los datos de telemetría como trazas y métricas en la consola.

Where can IronPDF and OpenTelemetry documentation be accessed for further learning?

IronPDF documentation can be accessed on the Iron Software website, while OpenTelemetry documentation is available on the official OpenTelemetry organization website and relevant GitHub repositories for in-depth learning and exploration.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos de Código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ACTUALIZACIONES PARA DESARROLLADORES

Opentelemetry C# (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 21 de abril de 2026

OpenTelemetry es un conjunto de herramientas, API y SDK que trabajan juntos 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, enfocándose en la colección de métricas incorporadas para monitorear aplicaciones .NET de manera efectiva. También aprenderemos sobre la biblioteca IronPDF para la generación de PDFs en C#.

Introducción a OpenTelemetry

Opentelemetry C# (Cómo funciona para desarrolladores): Figura 1 - OpenTelemetry

OpenTelemetry proporciona una forma unificada de recopilar todo tipo de datos de sus aplicaciones. Para los desarrolladores de .NET, integrar OpenTelemetry significa que puede monitorear sus aplicaciones más de cerca, entender cómo se desempeñan en tiempo real e identificar problemas rápidamente. La biblioteca de instrumentación de OpenTelemetry habilita automáticamente la recolección de trazas y métricas para aplicaciones .NET.

Con las métricas recopiladas por el marco OpenTelemetry, los desarrolladores obtienen conocimientos valiosos sobre el entorno de ejecución de .NET. La implementación de OpenTelemetry .NET soporta el tiempo de ejecución .NET, incluyendo .NET Core y .NET Framework. Adhiere al protocolo OpenTelemetry para la recolección de datos de telemetría estandarizada.

Configuración de su entorno

Para comenzar, necesitará tener instalado el SDK de .NET en su máquina. Si está utilizando Visual Studio, probablemente venga con el SDK de .NET. Puede verificar su versión actual del SDK de .NET abriendo una línea de comandos y ejecutando:

> dotnet --version

dotnet --version

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

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

SHELL

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

Integración de OpenTelemetry

Añadir paquetes necesarios

Primero, agregue los paquetes de OpenTelemetry necesarios a su proyecto. Abra su terminal y navegue a su directorio del proyecto. Luego, instale los siguientes paquetes usando el CLI del Administrador de Paquetes NuGet:

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>

SHELL

Reemplace <version> con la última versión de cada paquete.

Configurar OpenTelemetry en su aplicación

Después de agregar los paquetes necesarios, debe configurar OpenTelemetry en su aplicación. Esto involucra configurar el SDK de OpenTelemetry y especificar qué datos de telemetría recopilar. OpenTelemetry ofrece bibliotecas de instrumentación para una integración fluida 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 fragmento de código a continuación:

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

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 al cliente HTTP, y luego exportar estos datos a la consola. El método AddAspNetCoreInstrumentation habilita automáticamente la instrumentación para las solicitudes HTTP entrantes a las aplicaciones ASP.NET Core.

Recopilación de métricas

Para recopilar métricas, también necesitará configurar la API de Métricas de OpenTelemetry, enfocándose en métricas en lugar de trazas.

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

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 recolección de métricas incorporadas de ASP.NET Core e instrumentación del cliente HTTP, exportándolas a la consola para fácil visualización.

Creación de métricas personalizadas

Mientras OpenTelemetry recopila automáticamente muchas métricas útiles, podría desear recopilar métricas personalizadas específicas para su aplicación. Utilizar un método de extensión proporcionado por la biblioteca de instrumentación no solo recopila telemetría automáticamente, sino que también ofrece a los desarrolladores un control más granular sobre las métricas emitidas. Esto se puede lograr instrumentando manualmente su 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)

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 demuestra cómo crear una métrica personalizada que cuenta las solicitudes a su aplicación, etiquetando cada métrica con la ruta de la solicitud. Al aprovechar 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.

Pruebas de integración

Ejecute su aplicación utilizando la línea de comandos o Visual Studio. Haga algunas solicitudes a su aplicación, ya sea navegando a su URL en un navegador web o utilizando una herramienta como curl. Debería ver datos de telemetría, incluyendo trazas y métricas, siendo impresos en su salida de consola.

curl http://localhost:5000

curl http://localhost:5000

SHELL

Presentación de IronPDF

Opentelemetry C# (Cómo funciona para desarrolladores): Figura 2 - IronPDF

IronPDF es una poderosa biblioteca para desarrolladores C#, permitiendo la generación, manipulación y renderización de documentos PDF directamente dentro de aplicaciones .NET. Esta capacidad es especialmente útil para generar informes, facturas o cualquier resultado basado en documentos de aplicaciones web usando HTML, servicios o aplicaciones de escritorio. Combinar IronPDF con OpenTelemetry permite a los desarrolladores monitorear el rendimiento y la confiabilidad de los procesos de generación de PDF dentro de sus aplicaciones, asegurando una experiencia de usuario fluida.

IronPDF se destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Configuración de IronPDF

Primero, necesita agregar IronPDF a su proyecto .NET. Puede hacer esto utilizando el Administrador de Paquetes NuGet. Abra su terminal y navegue a su directorio del proyecto. Luego, ejecute el siguiente comando para instalar IronPDF:

dotnet add package IronPDF

dotnet add package IronPDF

SHELL

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

A continuación se muestra un ejemplo de cómo generar un documento PDF sencillo y monitorear la operación utilizando OpenTelemetry. El siguiente ejemplo asume que 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(tracer As Tracer)
        _tracer = tracer
    End Sub

    Public Sub GeneratePdf()
        ' Create a new activity for this operation
        Using 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
                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
                activity?.SetTag("pdf.status", "Success")
                activity?.SetTag("pdf.outputPath", outputPath)
            Catch ex As Exception
                ' Log any exceptions that occur during PDF generation
                activity?.SetTag("pdf.status", "Error")
                activity?.SetTag("pdf.error", ex.Message)
                Throw
            End Try
        End Using
    End Sub
End Class

Imports IronPdf
Imports OpenTelemetry.Trace

Public Class PdfService
    Private ReadOnly _tracer As Tracer

    Public Sub New(tracer As Tracer)
        _tracer = tracer
    End Sub

    Public Sub GeneratePdf()
        ' Create a new activity for this operation
        Using 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
                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
                activity?.SetTag("pdf.status", "Success")
                activity?.SetTag("pdf.outputPath", outputPath)
            Catch ex As Exception
                ' Log any exceptions that occur during PDF generation
                activity?.SetTag("pdf.status", "Error")
                activity?.SetTag("pdf.error", ex.Message)
                Throw
            End Try
        End Using
    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. Usamos la clase ChromePdfRenderer de IronPDF para renderizar HTML como documento PDF. Con OpenTelemetry, iniciamos una nueva actividad llamada "Generate PDF" para monitorear esta operación. Agregamos 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 errores de manera apropiada dentro de la misma actividad.

Conclusión

Integrar OpenTelemetry en sus aplicaciones .NET le permite recopilar datos de telemetría valiosos, ofreciendo información sobre el rendimiento y comportamiento de su aplicación. Siguiendo los pasos descritos en este tutorial, ha configurado una recolección básica de trazas y métricas para una aplicación web .NET. Experimente más explorando características avanzadas de OpenTelemetry, como exportar datos de telemetría a herramientas de monitoreo externas o recolectar registros junto con trazas y métricas.

IronPDF ofrece una prueba gratuita de IronPDF para producción para probar sus capacidades completas. Las licencias comienzan desde tan solo $399.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...