Einführung

Die Erstellung dynamischer, datengesteuerter, umfangreicher PDF-Dokumente ist eine typische Anforderung in vielen Bereichen der modernen Softwareentwicklung. Unternehmen sind in hohem Maße davon abhängig, dass sie schnell qualitativ hochwertige PDF-Dateien erstellen können, sei es für die Erstellung von Rechnungen, Berichten oder Dokumentationen. Das Verfolgen und Verstehen der Effektivität von PDF-Produktionsprozessen ist jedoch unerlässlich, um die Gesundheit der Anwendungen zu bewahren und die Freude der Benutzer zu gewährleisten, wenn sie immer komplizierter und umfangreicher werden.

In diesem Artikel wird erörtert, wie Entwickler durch die Nutzung der Funktionen von IronPDF und OpenTelemetry.NET PDF-Erzeugungsvorgänge verbessern und wichtige Einblicke in die Anwendungsleistung gewinnen können. Wir werden die Eigenschaften und Vorteile beider Technologien untersuchen und zeigen, wie sie harmonisch zusammenarbeiten können, um die Erstellung und Überwachung von PDFs in .NET-Anwendungen zu optimieren.

Was ist OpenTelemetry?

OpenTelemetry ist ein herstellerunabhängiges Observability-Framework, das speziell für Cloud-native Anwendungen entwickelt wurde. Die automatische Instrumentierung von OpenTelemetry bietet eine einzige API zur Erfassung von Telemetriedaten, einschließlich Protokollen, Tracing und Metriken. Mithilfe dieser umfangreichen Daten können Entwickler Probleme effektiv beheben, Leistungsengpässe aufspüren und ein umfassendes Verständnis des Programmverhaltens erlangen. OpenTelemetry unterstützt sowohl die automatische als auch die manuelle Instrumentierung für eine umfassende und flexible Telemetrie-Datenerfassung.

Schlüsselkomponenten von OpenTelemetry

• API: Um Anwendungen zu instrumentieren und Telemetriedaten zu erzeugen, spezifiziert OpenTelemetry einen standardisierten Satz von APIs. Dies vereinfacht das Instrumentierungsverfahren und gewährleistet die Konsistenz zwischen verschiedenen Programmiersprachen.
• SDKs: Für die Instrumentierung von Anwendungen bietet OpenTelemetry SDKs an, die auf bestimmte Sprachen zugeschnitten sind. Entwickler können die OpenTelemetry-Funktionalität mit Hilfe des .NET SDKs einfach in ihre .NET-Projekte einbinden.
• Exporteure: Diese Teile sind für die Übermittlung der gesammelten Telemetriedaten an Backend-Systeme zuständig, damit sie gespeichert und untersucht werden können. Viele Exporteure von weit verbreiteten Backend-Systemen, wie z.B. Zipkin (rückverfolgung), Prometheus (metriken)und Jaeger (rückverfolgung)werden von OpenTelemetry unterstützt.
• Automatische Instrumentierung: Diese Methode vereinfacht den Prozess für .NET Core-Anwendungen. OpenTelemetry-Bibliotheken können automatisch Daten für gängige Vorgänge innerhalb Ihrer Webanwendung oder Ihres Dienstes erfassen. Dadurch werden manuelle Code-Änderungen überflüssig, was den Integrationsprozess vereinfacht.
• Manuelle Instrumentierung: Für eine detaillierte Kontrolle der Datenerfassung bietet OpenTelemetry eine robuste API für die manuelle Instrumentierung. Dieser Ansatz ermöglicht es Ihnen, spezifische Metriken und Traces zu erfassen, die sich auf Ihre spezielle Anwendungslogik beziehen. Es ist besonders nützlich für .NET-Framework-Anwendungen oder Szenarien, in denen die automatische Instrumentierung Ihre speziellen Anforderungen nicht abdeckt.

Vorteile der Verwendung von OpenTelemetry in .NET

Die Integration von OpenTelemetry in Ihre .NET-Anwendungen bietet mehrere Vorteile:

• Anbieterneutralität: OpenTelemetry bietet Flexibilität und Zukunftssicherheit für Ihre Anwendung durch mühelose Integration mit einer Vielzahl von Backend-Systemen. Ihr Instrumentierungscode muss nicht geändert werden, um das Backend-System zu wechseln.
• Standardisierter Ansatz: Die Instrumentierung verschiedener Bereiche Ihrer Anwendung wird durch die einheitliche API erleichtert. Dieselbe API kann von Entwicklern zum Sammeln von Protokollen, Traces und Metriken verwendet werden, wodurch der Code leichter zu lesen und zu warten ist.
• Eingehende Leistungsanalyse: OpenTelemetry bietet eine Fülle von Daten (metriken, Traces und Protokolle) für eine umfassende Leistungsanalyse. Mit dieser ganzheitlichen Sichtweise können Sie Optimierungsbereiche ausfindig machen und die Ursache von Problemen ermitteln.
• Bessere Fehlersuche: Entwickler können Probleme leichter erkennen und beheben, indem sie den Pfad der Anfragen durch Ihre Anwendung anhand der umfangreichen Tracing-Daten, die OpenTelemetry erfasst, verfolgen.
• Verbesserte Skalierbarkeit: Die Komplexität Ihrer Anwendung wird die Skalierbarkeit von OpenTelemetry nicht beeinträchtigen. Neue Funktionen oder Dienste lassen sich ohne große Code-Änderungen problemlos instrumentieren.

OpenTelemetry erstellen und konfigurieren

Konfigurieren von OpenTelemetry in der ASP.NET-Anwendung

OpenTelemetry muss in Ihrer Anwendung konfiguriert werden; bei ASP.NET Core-Anwendungen wird dies in der Regel in der Methode ConfigureServices der Datei Startup.cs vorgenommen. Dies ist eine Illustration einer Jaeger-Exporter-Konfiguration:

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

Setzen Sie den Namen Ihres Dienstes an die Stelle von serviceName. Ändern Sie entsprechend Ihrer Jaeger-Konfigurationsoptionen den Jaeger-Agenten-Host und -Port.

OpenTelemetry-Middleware hinzufügen

Sie müssen die OpenTelemetry-Middleware in ASP.NET Core-Anwendungen einbinden, um eine automatische Instrumentierung eingehender HTTP-Anforderungen zu erhalten. Fügen Sie in der Methode Configure Ihrer Datei Startup.cs die Middleware hinzu:

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

Startverfolgung

Nach der Einrichtung beginnt OpenTelemetry, eingehende HTTP-Anfragen zu verfolgen und Telemetriedaten an das konfigurierte Jaeger-Backend zu senden.

Überprüfen und überwachen

Sie können in Ihrem Jaeger-Backend nach Spuren suchen, um zu überprüfen, ob OpenTelemetry ordnungsgemäß funktioniert. Öffnen Sie die Jaeger-Benutzeroberfläche (normalerweise verfügbar unter http://localhost:16686 für Jaeger UI) und suchen Sie nach Spuren, die mit Ihrem Dienst verbunden sind.

Wählen Sie ein Backend-System (optional)

OpenTelemetry ist kein Muss für die grundlegende Instrumentierung, aber es lässt sich mit anderen Backend-Betriebssystemen integrieren, um Telemetriedaten zu speichern und zu verarbeiten. Beliebte Optionen sind die offiziell unterstützten Betriebssysteme:

• Jaeger (rückverfolgung)
• Prometheus (metriken)
• Zipkin (rückverfolgung)

Erste Schritte

Was ist IronPDF?

Mit dem beliebten .NET-Paket IronPDF können Sie PDF-Dokumente in .NET-Programmen erstellen, bearbeiten und rendern. Die Funktionen für die Arbeit mit PDFs sind zahlreich und umfassen: Konvertierung von HTML-Seiten in PDFs; extraktion von Text und Bildern aus PDF-Dateien; hinzufügen von Text, Bildern und Formen zu bereits vorhandenen PDF-Dokumenten; und die Erstellung von PDFs aus HTML-Inhalten, Fotos oder Rohdaten.

Zwei der wichtigsten Vorteile von IronPDF sind seine Benutzerfreundlichkeit und Einfachheit. Entwickler können dank der intuitiven API und der umfassenden Dokumentation mühelos mit der Erstellung von PDFs in ihren .NET-Projekten beginnen. Die Effizienz und Geschwindigkeit von IronPDF sind weitere Merkmale, die Entwicklern helfen, hochwertige PDF-Dokumente schnell und effizient zu erstellen.

Einige der Vorteile von IronPDF:

• Erstellung von PDFs aus HTML, Bildern und Rohdaten
• Text und Bilder aus PDF-Dateien herausnehmen
• Einfügen von Wasserzeichen, Kopf- und Fußzeilen in PDF-Dateien
• PDF-Dateien sind durch Verschlüsselung und ein Passwort geschützt
• Die Möglichkeit, Formulare elektronisch zu unterschreiben und auszufüllen

Installieren Sie das NuGet-Paket

Mehrere NuGet-Pakete sind für verschiedene Komponenten von OpenTelemetry verfügbar. Je nach Ihrem Bedarf können Sie die erforderlichen Pakete installieren. Senden von Telemetriedaten an ein Beobachtungs-Backend (wie Jaeger, Zipkin oder Prometheus)benötigen Sie zumindest das OpenTelemetry-Paket, Instrumentierungspakete für Ihren Anwendungsrahmen (wie zum Beispiel ASP.NET Core)und ein Exporteurpaket. Stellen Sie außerdem sicher, dass das IronPDF-Paket in Ihrem Projekt installiert ist. Zur Installation verwenden Sie die NuGet Package Manager Console:

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

Verwendung von OpenTelemetry mit IronPDF

Öffnen Sie die Datei "Startup.cs" Ihrer ASP.NET Core-Anwendung, um zur Funktion "ConfigureServices" zu gelangen. Um IronPDF einzurichten, geben Sie den folgenden Code ein.

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

Dieser Code stellt sicher, dass eine Instanz von HtmlToPdf erstellt und von der Anwendung nur verwendet wird, indem der HtmlToPdf-Dienst von IronPDF als Singleton konfiguriert wird.

Durch die Integration von OpenTelemetry.NET mit IronPDF können Sie PDF-Erzeugungsprozesse in Ihren .NET-Anwendungen verfolgen und beobachten. Schauen wir uns das Code-Beispiel genauer an, indem wir jeden Schritt Schritt für Schritt durchgehen:

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

Um eine Tracer-Instanz für unsere Anwendung zu erzeugen, injizieren wir die "TracerProvider"-Dienste. Eine OpenTelemetry-Aktivität namens "PDF Generation" wird mit der Methode "Generate" erstellt, um die laufenden Arbeiten zu symbolisieren. Wir ahmen einige Arbeiten im Rahmen der Aktivität nach (ersetzen Sie Ihre eigene Logik). Wir erstellen eine Histogramm-Metrik namens work_duration_ms, um die Dauer der Arbeit in Millisekunden zu überwachen. Wir fügen der Metrik einen Datenpunkt hinzu, markieren ihn als "Demo" mit dem Wert "PDF Generation" und dokumentieren die Dauer (1000 ms in diesem Fall). Tags geben der Analyse eine zusätzliche Kontextebene.

Generierte PDF-Ausgabe aus dem obigen Quellcode:

Nachfolgend sehen Sie den Bildschirm der von der Jaeger-Benutzeroberfläche erzeugten Ablaufverfolgung:

Schlussfolgerung

OpenTelemetry ist ein Meilenstein für die Leistungsoptimierung und Zustandsüberwachung von .NET-Anwendungen. Es bietet Entwicklern ein umfassendes Verständnis für das Innenleben ihrer Anwendungen, indem es eine herstellerneutrale und standardisierte Methode zum Sammeln, Analysieren und Exportieren von Telemetriedaten bietet (metriken, Traces und Protokolle).

Durch die Integration von OpenTelemetry.NET in IronPDF können Entwickler die Arbeitsabläufe bei der Erstellung von PDFs verbessern und Einblicke in die Leistung ihrer Anwendungen erhalten. Durch den Einsatz der OpenTelemetry.NET-Implementierung zur manuellen Instrumentierung der PDF-Erzeugungsprozesse können Entwickler Ausführungspfade und Leistungskennzahlen verfolgen und Bereiche mit Optimierungsbedarf ausfindig machen. Darüber hinaus wird durch den Export von Telemetriedaten an Observability-Plattformen eine zentralisierte Erfassung und Analyse von Überwachungsmetriken ermöglicht, die es Entwicklern erlaubt, den Zustand ihrer Anwendungen zu erhalten und eine einwandfreie Benutzererfahrung zu gewährleisten.

Die Integration der OpenTelemetry.NET-Implementierung und IronPDF kann die Arbeitsabläufe von Entwicklern bei der Erstellung von PDFs verbessern und Skalierbarkeit, Leistung und Zuverlässigkeit in .NET-Anwendungen gewährleisten. Die Integration dieser Technologien hilft Entwicklern, die Anforderungen der modernen Softwareentwicklung zu erfüllen und herausragende Ergebnisse zu erzielen, sei es bei der Erstellung von Rechnungen, Berichten oder Dokumentationen.

IronPDF ist im Paket zu einem fairen Preis erhältlich und beinhaltet eine lebenslange Lizenz. Das Paket bietet ein hervorragendes Preis-Leistungs-Verhältnis bei einem Preis von nur 749 $, der für viele Systeme eine einmalige Gebühr darstellt. Sie bietet den Lizenznehmern rund um die Uhr technischen Online-Support. Bitte besuchen Sie die website für weitere Informationen über die Gebühr. Besuchen Sie diese website um mehr über die Produkte zu erfahren, die Iron Software herstellt.