Introduction

La création de documents PDF dynamiques, riches en données, est une demande typique dans de nombreux secteurs du développement logiciel moderne. Les entreprises dépendent fortement de leur capacité à générer rapidement des PDF de haute qualité, que ce soit pour créer des factures, des rapports ou de la documentation. Cependant, le suivi et la compréhension de l'efficacité des processus de production des PDF deviennent essentiels pour préserver la santé des applications et garantir le plaisir de l'utilisateur à mesure qu'elles deviennent plus complexes et à plus grande échelle.

Cet article explique comment les développeurs peuvent améliorer les opérations de génération de PDF et fournir des informations importantes sur les performances de l'application en utilisant les fonctionnalités d'IronPDF et d'OpenTelemetry.NET. Nous explorerons les caractéristiques et les avantages de ces deux technologies et montrerons comment elles peuvent collaborer harmonieusement pour optimiser la création et le suivi des PDF dans les applications .NET.

Qu'est-ce que OpenTelemetry ?

OpenTelemetry est un cadre d'observabilité neutre créé spécialement pour les applications cloud-natives. L'instrumentation automatique d'OpenTelemetry fournit une API unique pour collecter des informations de télémétrie, y compris les journaux, le traçage et les métriques. Grâce à ces nombreuses données, les développeurs peuvent déboguer efficacement les problèmes, repérer les goulets d'étranglement au niveau des performances et obtenir une compréhension complète du comportement du programme. OpenTelemetry prend en charge l'instrumentation automatique et manuelle pour une collecte de données télémétriques complète et flexible.

Composants clés d'OpenTelemetry

• API : Pour instrumenter les applications et générer des données de télémétrie, OpenTelemetry spécifie un ensemble normalisé d'API. Cela simplifie la procédure d'instrumentation et garantit la cohérence entre les différents langages de programmation.
• SDK : Pour les applications d'instrumentation, OpenTelemetry propose des SDK adaptés à certains langages. Les développeurs peuvent facilement incorporer la fonctionnalité OpenTelemetry dans leurs projets .NET à l'aide du SDK .NET.
• Les exportateurs : Ces éléments sont chargés de transmettre les données télémétriques recueillies aux systèmes dorsaux afin qu'elles puissent être stockées et examinées. De nombreux exportateurs de systèmes dorsaux largement utilisés, tels que Zipkin(traçage)prométhée(métriques)et Jaeger(traçage)sont prises en charge par OpenTelemetry.
• Instrumentation automatique : Cette méthode simplifie le processus pour les applications .NET Core. Les bibliothèques OpenTelemetry peuvent capturer automatiquement des données pour des opérations courantes au sein de votre application ou service web. Cela élimine les modifications manuelles du code et rationalise le processus d'intégration.
• Instrumentation manuelle : Pour un contrôle granulaire de la collecte de données, OpenTelemetry fournit une API robuste pour l'instrumentation manuelle. Cette approche vous permet de capturer des mesures et des traces spécifiques liées à votre logique d'application unique. Elle est particulièrement utile pour les applications du Framework .NET ou les scénarios dans lesquels l'instrumentation automatique ne répond pas à vos besoins spécifiques.

Avantages de l'utilisation d'OpenTelemetry dans .NET

L'intégration d'OpenTelemetry dans vos applications .NET offre plusieurs avantages :

• Neutralité vis-à-vis des fournisseurs : OpenTelemetry offre de la flexibilité et assure la pérennité de votre application en s'intégrant sans effort à une variété de systèmes dorsaux. Il n'est pas nécessaire de modifier votre code d'instrumentation pour changer de système de gestion.
• Approche standardisée : L'instrumentation des différentes parties de votre application est facilitée par l'uniformité de l'API. La même API peut être utilisée par les développeurs pour collecter des journaux, des traces et des mesures, ce qui facilite la lecture et la maintenance du code.
• Analyse approfondie des performances : OpenTelemetry offre une multitude de données(métriques, traces et journaux) pour une analyse complète des performances. Cette perspective globale vous permet de localiser les domaines à optimiser et de déterminer la source sous-jacente des problèmes.
• Meilleur dépannage : Les développeurs peuvent plus facilement détecter et corriger les problèmes en suivant le chemin des requêtes à travers votre application en utilisant les riches données de traçage capturées par OpenTelemetry.
• Une meilleure évolutivité : La complexité de votre application n'entravera pas la capacité d'OpenTelemetry à évoluer. Les nouvelles fonctionnalités ou les nouveaux services peuvent être facilement instrumentés sans nécessiter de modifications importantes du code.

Créer et configurer OpenTelemetry

Configurer OpenTelemetry dans l'application ASP.NET

OpenTelemetry doit être configuré dans votre application ; pour les applications ASP.NET Core, cela se fait généralement dans la méthode ConfigureServices de votre fichier Startup.cs. Voici une illustration de la configuration d'un exportateur 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

Mettez le nom de votre service à la place de serviceName. En fonction de vos options de configuration de Jaeger, modifiez l'hôte et le port de l'agent Jaeger.

Ajouter le middleware OpenTelemetry

Vous devez inclure le middleware OpenTelemetry dans les apps ASP.NET Core pour obtenir l'instrumentation automatique des requêtes HTTP entrantes. Dans la méthode Configure de votre fichier Startup.cs, ajoutez le 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

Démarrer le traçage

Après avoir tout configuré, OpenTelemetry commencera à suivre les requêtes HTTP entrantes et à envoyer les informations de télémétrie au backend Jaeger configuré.

Vérifier et contrôler

Vous pouvez vérifier les traces dans votre backend Jaeger pour confirmer que OpenTelemetry fonctionne correctement. Ouvrir l'interface utilisateur de Jaeger(généralement disponible sur http://localhost:16686 pour Jaeger UI) et recherchez les traces associées à votre service.

Choisir un système dorsal (facultatif)

OpenTelemetry n'est pas indispensable pour l'instrumentation de base, mais il s'intègre à d'autres systèmes d'exploitation dorsaux pour stocker et traiter les données de télémétrie. Les options les plus courantes sont les systèmes d'exploitation officiellement pris en charge :

• Jaeger(traçage)
• Prométhée(métriques)
• Zipkin(traçage)

Pour commencer

Qu'est-ce qu'IronPDF ?

Le célèbre paquet .NETIronPDF le logiciel .NET vous permet de créer, d'éditer et de rendre des documents PDF au sein de programmes .NET. Les fonctions permettant de travailler avec des PDF sont nombreuses et comprennent : la conversion de pages HTML en PDF ; l'extraction de texte et d'images à partir de PDF ; ajouter du texte, des images et des formes à des documents PDF préexistants ; et produire des PDF à partir de contenu HTML, de photos ou de données brutes.

Deux des principaux avantages d'IronPDF sont sa facilité d'utilisation et sa simplicité. Les développeurs peuvent commencer à créer des PDF sans effort dans leurs projets .NET grâce à son API intuitive et à sa documentation complète. L'efficacité et la rapidité d'IronPDF sont des caractéristiques supplémentaires qui aident les développeurs à créer rapidement et efficacement des documents PDF de haute qualité.

Quelques-uns des avantages d'IronPDF :

• Production de PDF à partir de HTML, d'images et de données brutes
• Extraction de texte et d'images à partir de fichiers PDF
• Incorporer des filigranes, des en-têtes et des pieds de page dans les fichiers PDF
• Les fichiers PDF sont protégés par un cryptage et un mot de passe
• La possibilité de signer et de remplir des formulaires par voie électronique

Installer le paquet NuGet

Plusieurs paquets NuGet sont disponibles pour différents composants d'OpenTelemetry. En fonction de vos besoins, vous pouvez installer les paquets nécessaires. Envoyer des données télémétriques à un backend d'observabilité(comme Jaeger, Zipkin ou Prometheus)vous aurez au moins besoin du paquet OpenTelemetry, des paquets d'instrumentation pour votre cadre d'application(tels que ASP.NET Core)et un paquet exportateur. Assurez-vous également que le paquetage IronPDF est installé dans votre projet. Pour l'installer, utilisez la console NuGet Package Manager :

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

Utilisation d'OpenTelemetry avec IronPDF

Ouvrez le fichier Startup.cs de votre application ASP.NET Core pour accéder à la fonction ConfigureServices. Pour configurer IronPDF, incluez le code suivant.

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

Ce code garantit qu'une instance de HtmlToPdf est créée et utilisée par l'application uniquement en configurant le service HtmlToPdf d'IronPDF comme un singleton.

Vous pouvez suivre et observer les processus de génération de PDF dans vos applications .NET en intégrant OpenTelemetry.NET à IronPDF for .NET. Examinons l'exemple de code en profondeur, en passant en revue chaque étape, pas à pas :

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

Pour générer une instance de traceur pour notre application, nous injectons les services TracerProvider. Une activité OpenTelemetry appelée "PDF Generation" est créée par la méthode Generate pour symboliser le travail en cours. Nous imitons certains travaux au sein de l'activité(substituez votre propre logique). Nous établissons un histogramme appelé work_duration_ms pour surveiller la durée du travail en millisecondes. Nous ajoutons un point de données à la métrique, en le marquant "Demo" avec la valeur "PDF Generation" et en documentant la durée(1000 ms dans ce cas). Les étiquettes donnent à l'analyse un contexte supplémentaire.

PDF généré à partir du code source ci-dessus :

Voici l'écran de la trace générée à partir de l'interface utilisateur de Jaeger :

Conclusion

OpenTelemetry change la donne en matière d'optimisation des performances et de surveillance de l'état des applications .NET. Il permet aux développeurs de bien comprendre le fonctionnement interne de leurs applications en offrant une méthode normalisée et neutre pour la collecte, l'analyse et l'exportation des données télémétriques(métriques, traces et journaux).

En intégrant OpenTelemetry.NET à IronPDF, les développeurs peuvent améliorer les flux de travail pour la création de PDF et obtenir des informations sur les performances de leurs applications. En tirant parti de l'implémentation d'OpenTelemetry.NET pour instrumenter manuellement les processus de génération de PDF, les développeurs peuvent suivre les chemins d'exécution, surveiller les mesures de performance et repérer les régions qui nécessitent une optimisation. En outre, la collecte et l'analyse centralisées des mesures de surveillance sont rendues possibles par l'exportation de données télémétriques vers des plateformes d'observabilité, ce qui permet aux développeurs de préserver la santé de leurs applications et d'offrir une expérience utilisateur sans faille.

L'intégration de la mise en œuvre d'OpenTelemetry.NET et d'IronPDF peut améliorer les flux de travail des développeurs pour la création de PDF et garantir l'évolutivité, les performances et la fiabilité des applications .NET. L'intégration de ces technologies aide les développeurs à répondre aux besoins du développement de logiciels modernes et à produire des résultats exceptionnels, qu'il s'agisse de créer des factures, des rapports ou de la documentation.

Lorsqu'il est acheté en tant que package, IronPDF est proposé à un prix raisonnable et comprend une licence à vie. Le package offre un excellent rapport qualité-prix à seulement $749, qui est un paiement unique pour de nombreux systèmes. Elle offre aux détenteurs de licences une assistance technique en ligne 24 heures sur 24. Veuillez consulter le siteSite web d'Iron Software pour plus de détails sur l'accusation. ExplorerProduits d'Iron Software pour en savoir plus sur les solutions qu'ils proposent, cliquez sur le lien suivant