What is OpenTelemetry?

OpenTelemetry is a vendor-neutral observability framework created especially for cloud-native apps. OpenTelemetry automatic instrumentation provides a single API for gathering telemetry information, including logs, tracing, and metrics. With the use of this extensive data, developers may effectively debug problems, pinpoint performance bottlenecks, and obtain a full understanding of program behavior. OpenTelemetry supports both automatic and manual instrumentation for comprehensive and flexible telemetry data collection.

Create and Configure OpenTelemetry

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

public void ConfigureServices(IServiceCollection services)
{
    // Configure OpenTelemetry
    services.AddOpenTelemetry().WithTracing(builder =>
    {
        // Configure Jaeger exporter. The 'serviceName' can be read from environment variables
        builder
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService("YourServiceName"))
            .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
    services.AddOpenTelemetry().WithTracing(builder =>
    {
        // Configure Jaeger exporter. The 'serviceName' can be read from environment variables
        builder
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService("YourServiceName"))
            .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
	services.AddOpenTelemetry().WithTracing(Sub(builder)
		' Configure Jaeger exporter. The 'serviceName' can be read from environment variables
		builder.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("YourServiceName")).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

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

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

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

Getting Started

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

Using OpenTelemetry with IronPDF

Open your ASP.NET Core application's Startup.cs file to access the ConfigureServices method. To set up IronPDF, include the subsequent code.

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

This code ensures that an instance of HtmlToPdf is created and used by the application only by configuring IronPDF's HtmlToPdf service as a singleton.

You may track and observe PDF generation processes in your .NET applications by integrating OpenTelemetry.NET with IronPDF. Let's examine the code example in depth, going over each step step-by-step:

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using IronPdf;

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

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

        [HttpGet]
        public FileContentResult Generate()
        {
            // Define the PDF file name
            string fileName = "Sample.pdf";

            // Generate PDF from HTML content
            _logger.LogInformation("Generating PDF...");
            var pdfBytes = GeneratePdf("Hello, IronPDF!");

            // Return the PDF as a file result
            return new FileContentResult(pdfBytes, "application/pdf")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            // Start a tracing activity for PDF generation
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);

                // Log PDF generation
                _logger.LogInformation("PDF generated successfully.");

                return pdfDocument.BinaryData;
            }
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using IronPdf;

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

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

        [HttpGet]
        public FileContentResult Generate()
        {
            // Define the PDF file name
            string fileName = "Sample.pdf";

            // Generate PDF from HTML content
            _logger.LogInformation("Generating PDF...");
            var pdfBytes = GeneratePdf("Hello, IronPDF!");

            // Return the PDF as a file result
            return new FileContentResult(pdfBytes, "application/pdf")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            // Start a tracing activity for PDF generation
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);

                // Log PDF generation
                _logger.LogInformation("PDF generated successfully.");

                return pdfDocument.BinaryData;
            }
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports OpenTelemetry.Trace
Imports System.Diagnostics
Imports Microsoft.Extensions.Logging
Imports IronPdf

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

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

		Public Sub New(ByVal logger As ILogger(Of DemoController), ByVal htmlToPdf As HtmlToPdf, ByVal tracerProvider As TracerProvider)
			_tracer = tracerProvider.GetTracer("Demo")
			_htmlToPdf = htmlToPdf
			_logger = logger
		End Sub

		<HttpGet>
		Public Function Generate() As FileContentResult
			' Define the PDF file name
			Dim fileName As String = "Sample.pdf"

			' Generate PDF from HTML content
			_logger.LogInformation("Generating PDF...")
			Dim pdfBytes = GeneratePdf("Hello, IronPDF!")

			' Return the PDF as a file result
			Return New FileContentResult(pdfBytes, "application/pdf") With {.FileDownloadName = fileName}
		End Function

		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
			' Start a tracing activity for PDF generation
			Using activity = _tracer.StartActiveSpan("PDF Generation")
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)

				' Log PDF generation
				_logger.LogInformation("PDF generated successfully.")

				Return pdfDocument.BinaryData
			End Using
		End Function
	End Class
End Namespace

In this example:

• We inject the HtmlToPdf, ILogger, and TracerProvider into the DemoController.
• The Generate method starts a file download, returning a dynamically created PDF with the content "Hello, IronPDF!".
• The GeneratePdf method uses the HtmlToPdf.RenderHtmlAsPdf to render the PDF and outputs the binary data of the PDF.
• The code uses OpenTelemetry to trace the PDF generation process and logs the tracing data.

Generated PDF output from the above source code:

Below is the screen of the generated trace from the Jaeger UI:

Conclusion

OpenTelemetry is a game-changer for .NET application performance optimization and health monitoring. It gives developers a thorough understanding of the inner workings of their applications by offering a vendor-neutral and standardized method for gathering, analyzing, and exporting telemetry data (metrics, traces, and logs).

By integrating OpenTelemetry.NET with IronPDF, developers can improve workflows for creating PDFs and obtain insights into the performance of their applications. By leveraging the OpenTelemetry.NET implementation to manually instrument the PDF-generating processes, developers may track execution pathways, monitor performance metrics, and pinpoint regions that require optimization. Furthermore, centralized monitoring metrics collection and analysis are made possible by exporting telemetry data to observability platforms, giving developers the ability to preserve the health of their applications and provide a flawless user experience.

The integration of OpenTelemetry.NET implementation and IronPDF can enhance developers' workflows for creating PDFs and guarantee scalability, performance, and dependability in .NET applications. The integration of these technologies helps developers fulfill the needs of modern software development and produce outstanding results, whether it's creating invoices, reports, or documentation.

When bought as a package, IronPDF is fairly priced and includes a lifetime license. The package offers great value at only $799, which is a one-time fee for many systems. It offers license holders online engineering support around the clock. Please visit the Iron Software website for more details about the charge. Explore Iron Software's products to learn more about the solutions they offer.