Introduction

Creating dynamic, data-driven, rich PDF documents is a typical demand in many sectors of modern software development. Businesses greatly depend on their capacity to generate high-quality PDFs quickly, whether it's for creating bills, reports, or documentation. However, tracking and comprehending the effectiveness of PDF production processes becomes essential for preserving the health of apps and ensuring user satisfaction as they get more complicated and large-scale.

This article aims to discuss how developers can improve PDF-generating operations and provide important insights into application performance by utilizing the features of IronPDF and OpenTelemetry.NET. We will explore the characteristics and advantages of both technologies and show how they may work together harmoniously to optimize the creation and monitoring of PDFs in .NET applications.

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.

Key Components of OpenTelemetry

• API: To instrument applications and generate telemetry data, OpenTelemetry specifies a standardized set of APIs. This makes the instrumentation procedure simpler and guarantees consistency across various programming languages.
• SDKs: For instrumenting applications, OpenTelemetry offers SDKs tailored to certain languages. Developers can easily incorporate OpenTelemetry functionality into their .NET projects with the help of the .NET SDK.
• Exporters: These parts are in charge of transmitting the telemetry data that has been gathered to backend systems so that it can be stored and examined. Many exporters of widely used backend systems, such as Zipkin (tracing), Prometheus (metrics), and Jaeger (tracing), are supported by OpenTelemetry.
• Automatic Instrumentation: This method simplifies the process for .NET Core applications. OpenTelemetry libraries can automatically capture data for common operations within your web application or service. This eliminates manual code modifications, streamlining the integration process.
• Manual Instrumentation: For granular control over data collection, OpenTelemetry provides a robust API for manual instrumentation. This approach allows you to capture specific metrics and traces related to your unique application logic. It's particularly useful for .NET Framework applications or scenarios where automatic instrumentation doesn't cover your specific needs.

Benefits of Using OpenTelemetry in .NET

Integrating OpenTelemetry into your .NET applications offers several advantages:

• Vendor Neutrality: OpenTelemetry offers flexibility and future-proofs your application by integrating effortlessly with a variety of backend systems. Your instrumentation code does not need to be changed to switch backend systems.
• Standardized Approach: Instrumenting various areas of your application is made easier by the uniform API. The same API may be used by developers to collect logs, traces, and metrics, resulting in code that is easier to read and maintain.
• In-depth Performance Analysis: OpenTelemetry offers a wealth of data (metrics, traces, and logs) for comprehensive performance analysis. You can locate areas for optimization and determine the underlying source of problems with this all-inclusive perspective.
• Better Troubleshooting: Developers can more easily detect and fix issues by following the path of requests through your application using the rich tracing data that OpenTelemetry captures.
• Improved Scalability: The intricacy of your application won't hinder OpenTelemetry's capacity to scale. New features or services can be readily instrumented without requiring large code modifications.

Create and Configure OpenTelemetry

Configure OpenTelemetry in the ASP.NET Application

OpenTelemetry needs to be configured in your application; for ASP.NET Core applications, this is usually done in the ConfigureServices method of your Startup.cs file. This is an illustration of a Jaeger exporter configuration:

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

Replace "YourServiceName" with the actual name of your service. Adjust the Jaeger agent host and port according to your Jaeger configuration options.

Add OpenTelemetry Middleware

You must include the OpenTelemetry middleware in ASP.NET Core apps to get automatic instrumentation of incoming HTTP requests. In your Startup.cs file's Configure method, add the middleware:

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

Start Tracing

After setting everything up, OpenTelemetry will begin tracking incoming HTTP requests and sending telemetry information to the configured Jaeger backend automatically.

Verify and Monitor

You can check for traces in your Jaeger backend to confirm that OpenTelemetry is functioning properly. Open the Jaeger user interface (usually available at http://localhost:16686 for Jaeger UI) and look for traces associated with your service.

Choose a Backend System (Optional)

OpenTelemetry is not a must for basic instrumentation, but it integrates with other backend operating systems to store and process telemetry data. Popular options consist of the officially supported operating systems:

• Jaeger (tracing)
• Prometheus (metrics)
• Zipkin (tracing)

Getting Started

What is IronPDF?

The popular .NET package IronPDF allows you to create, edit, and render PDF documents within .NET programs. The functions for working with PDFs are numerous and include converting HTML pages to PDFs, extracting text and images from PDFs, adding text, images, and shapes to pre-existing PDF documents, and producing PDFs from HTML content, photos, or raw data.

Two of IronPDF's key advantages are its ease of use and simplicity. Developers may effortlessly start creating PDFs within their .NET projects because of its intuitive API and comprehensive documentation. IronPDF's efficiency and speed are additional characteristics that help developers create high-quality PDF documents quickly and efficiently.

Some of the benefits of IronPDF:

• Production of PDFs from HTML, pictures, and raw data
• Extracting text and pictures from PDF files
• Incorporate watermarks, headers, and footers into PDF files
• PDF files are protected by encryption and a password
• The ability to electronically sign and complete forms

Install the NuGet Package

Multiple NuGet packages are available for different components from OpenTelemetry. Depending on your needs, you can install the required packages. To send telemetry data to an observability backend (such as Jaeger, Zipkin, or Prometheus), you will at the very least need the OpenTelemetry package, instrumentation packages for your application framework (such as ASP.NET Core), and an exporter package. Also, ensure that the IronPDF package is installed in your project. To install it, use the NuGet Package Manager Console:

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 $749, 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.