Was ist der Zweck von OpenTelemetry in der C#-Entwicklung?

OpenTelemetry bietet einen einheitlichen Ansatz, um Telemetriedaten wie Spuren, Metriken und Logs zu sammeln, zu verarbeiten und zu exportieren, wodurch Entwickler die Leistung von Anwendungen in Echtzeit überwachen und verstehen können.

Wie kann ich mit der Integration von OpenTelemetry in meine C#-Anwendung beginnen?

Beginnen Sie damit, die erforderlichen OpenTelemetry-Pakete über NuGet zu installieren, und konfigurieren Sie dann Ihre Anwendung, indem Sie die Methode 'ConfigureServices' in 'Startup.cs' ändern, um OpenTelemetry-Tracing und -Metriken einzubinden.

Welche Schritte sind erforderlich, um die Umgebung für OpenTelemetry in C# einzurichten?

Stellen Sie sicher, dass das .NET SDK auf Ihrem Computer installiert ist. Sie können die Installation überprüfen, indem Sie dotnet --version in Ihrer Befehlszeile ausführen.

Wie erstelle ich ein PDF in C# mit HTML-Inhalten?

Sie können die Klasse ChromePdfRenderer der IronPDF-Bibliothek verwenden, um HTML als PDF-Dokument zu rendern, und dann die Methode SaveAs verwenden, um das erzeugte PDF zu speichern.

Wie kann ich den PDF-Erstellungsprozess in einer C#-Anwendung überwachen?

Verwenden Sie OpenTelemetrys Tracer , um eine Aktivität zur PDF-Erstellung zu erstellen und benutzerdefinierte Tags hinzuzufügen, um relevante Informationen über den Prozess zu Überwachungszwecken zu protokollieren.

Was sind benutzerdefinierte Metriken und wie können sie in OpenTelemetry mit C# verwendet werden?

Benutzerdefinierte Metriken sind anwendungsspezifische Datenpunkte, die Sie durch manuelle Instrumentierung Ihres Codes mit den Klassen Meter und Counter von OpenTelemetry sammeln können.

Wie kann ich eine zuverlässige PDF-Generierung in C# gewährleisten?

Verwenden Sie die IronPDF-Bibliothek, um PDF-Dokumente zuverlässig zu erstellen, zu bearbeiten und darzustellen. IronPDF bietet robuste Funktionen, um qualitativ hochwertige PDF-Ausgaben in Ihren Anwendungen sicherzustellen.

Gibt es Lizenzoptionen für Bibliotheken, die bei der Erstellung von PDFs in C# helfen?

IronPDF bietet eine kostenlose Testversion für Produktionstests, mit Lizenzen, die ab 399 USD beginnen, wodurch es Entwicklern ermöglicht wird, alle Funktionen zu erkunden.

Wie kann ich meine OpenTelemetry-Integration in einer C#-Anwendung testen?

Führen Sie Ihre Anwendung aus und tätigen Sie Anfragen über einen Webbrowser oder Tools wie curl, und beobachten Sie die Telemetriedaten wie Traces und Metriken, die auf der Konsole ausgegeben werden.

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.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

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

ENTWICKLER-UPDATES

Opentelemetry C# (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 21. April 2026

OpenTelemetry ist eine Sammlung von Werkzeugen, APIs und SDKs, die zusammenarbeiten, um Telemetriedaten wie Traces, Metriken und Logs aus Ihren Anwendungen zu sammeln, zu verarbeiten und zu exportieren. Dieses Tutorial soll Anfängern helfen zu verstehen, wie OpenTelemetry in C#-Anwendungen unter Verwendung der Erweiterungsmethode integriert werden kann, wobei der Schwerpunkt auf integrierter Metrikenerfassung liegt, um .NET-Anwendungen effektiv zu überwachen. Wir werden auch über die IronPDF-Bibliothek zur PDF-Erstellung in C# lernen.

Einführung in OpenTelemetry

Opentelemetry C# (Wie es für Entwickler funktioniert): Abbildung 1 - OpenTelemetry

OpenTelemetry bietet eine einheitliche Möglichkeit, alle Arten von Daten aus Ihren Anwendungen zu sammeln. Für .NET-Entwickler bedeutet die Integration von OpenTelemetry, dass Sie Ihre Anwendungen genauer überwachen, ihre Leistung in Echtzeit verstehen und Probleme schnell identifizieren können. Die Instrumentenbibliothek von OpenTelemetry aktiviert automatisch Tracing und Metrikenerfassung for .NET-Anwendungen.

Mit den vom OpenTelemetry-Framework gesammelten Metriken gewinnen Entwickler wertvolle Einblicke in die .NET-Laufzeitumgebung. Die .NET-Implementierung von OpenTelemetry unterstützt die .NET-Laufzeit, einschließlich .NET Core und .NET Framework. Es hält sich an das OpenTelemetry-Protokoll zur standardisierten Telemetriedatenerfassung.

Einrichten Ihrer Umgebung

Um zu beginnen, müssen Sie das .NET SDK auf Ihrem Computer installiert haben. Wenn Sie Visual Studio verwenden, ist das .NET SDK wahrscheinlich bereits enthalten. Sie können Ihre aktuelle .NET SDK-Version überprüfen, indem Sie eine Befehlszeile öffnen und ausführen:

> dotnet --version

dotnet --version

Erstellen Sie ein neues .NET-Webprojekt mit:

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

SHELL

Dieser Befehl erstellt ein neues ASP.NET Core-Projekt in einem Verzeichnis namens MyTelemetryApp.

Einbindung von OpenTelemetry

Erforderliche Pakete hinzufügen

Fügen Sie zuerst die notwendigen OpenTelemetry-Pakete zu Ihrem Projekt hinzu. Öffnen Sie Ihr Terminal und navigieren Sie zu Ihrem Projektverzeichnis. Installieren Sie dann die folgenden Pakete mit dem NuGet-Paketverwaltung-CLI:

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

Ersetzen Sie <version> durch die neueste Version jedes Pakets.

Konfiguration von OpenTelemetry in Ihrer Anwendung

Nach dem Hinzufügen der notwendigen Pakete müssen Sie OpenTelemetry in Ihrer Anwendung konfigurieren. Dies umfasst die Einrichtung des OpenTelemetry SDK und die Angabe, welche Telemetriedaten gesammelt werden sollen. OpenTelemetry bietet Instrumentenbibliotheken für eine nahtlose Integration mit .NET-Anwendungen.

Öffnen Sie die Startup.cs-Datei in Ihrem Projekt und ändern Sie die ConfigureServices-Methode, um OpenTelemetry wie im folgenden Codeausschnitt einzuschließen:

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

Dieser Codeausschnitt zeigt, wie OpenTelemetry konfiguriert wird, um Telemetriedaten von ASP.NET Core-Anwendungen und HTTP-Client-Aufrufen zu sammeln und diese dann auf die Konsole zu exportieren. Die AddAspNetCoreInstrumentation-Methode aktiviert automatisch die Instrumentierung für eingehende HTTP-Anfragen an ASP.NET Core-Anwendungen.

Sammeln von Metriken

Um Metriken zu sammeln, müssen Sie auch die OpenTelemetry Metrics API konfigurieren, wobei der Schwerpunkt eher auf Metriken als auf Tracing liegt.

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

Diese Einrichtung ermöglicht die Erfassung integrierter Metriken von ASP.NET Core- und HTTP-Client-Instrumenten und deren Export auf die Konsole zur einfachen Ansicht.

Eigene Metriken erstellen

Obwohl OpenTelemetry automatisch viele nützliche Metriken sammelt, möchten Sie möglicherweise benutzerdefinierte Metriken sammeln, die spezifisch für Ihre Anwendung sind. Die Verwendung einer von der Instrumentenbibliothek bereitgestellten Erweiterungsmethode sammelt nicht nur automatisch Telemetrie, sondern gibt Entwicklern auch mehr granulare Kontrolle über die ausgegebenen Metriken. Dies kann erreicht werden, indem Sie Ihren Code manuell instrumentieren, um benutzerdefinierte Metriken zu erstellen und aufzuzeichnen.

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)

Dieser Codeausschnitt zeigt, wie eine benutzerdefinierte Metrik erstellt wird, die Anfragen an Ihre Anwendung zählt und jede Metrik mit dem Anforderungspfad markiert. Indem Entwickler auf Erweiterungsmethoden von OpenTelemetry zurückgreifen, können sie die Telemetriedatenerfassungsprozesse granulare steuern.

Testen Sie Ihre Integration

Führen Sie Ihre Anwendung mit der Befehlszeile oder Visual Studio aus. Stellen Sie einige Anfragen an Ihre Anwendung, entweder indem Sie mit einem Webbrowser zu ihrer URL navigieren oder ein Werkzeug wie curl verwenden. Sie sollten Telemetriedaten, einschließlich Traces und Metriken, in Ihrer Konsolenausgabe sehen.

curl http://localhost:5000

curl http://localhost:5000

SHELL

Einführung in IronPDF

Opentelemetry C# (Wie es für Entwickler funktioniert): Abbildung 2 - IronPDF

IronPDF ist eine leistungsstarke Bibliothek für C#-Entwickler, die die Erstellung, Manipulation und das Rendern von PDF-Dokumenten direkt innerhalb von .NET-Anwendungen ermöglicht. Diese Funktionalität ist besonders nützlich zum Generieren von Berichten, Rechnungen oder anderen dokumentbasierten Ausgaben aus Webanwendungen mit HTML, Diensten oder Desktop-Apps. Die Kombination von IronPDF mit OpenTelemetry ermöglicht es Entwicklern, die Leistung und Zuverlässigkeit von PDF-Erstellungsprozessen innerhalb ihrer Anwendungen zu überwachen und somit ein nahtloses Benutzererlebnis zu gewährleisten.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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

Einrichten von IronPDF

Zuerst müssen Sie IronPDF zu Ihrem .NET-Projekt hinzufügen. Dies können Sie mit dem NuGet Package Manager tun. Öffnen Sie Ihr Terminal und navigieren Sie zu Ihrem Projektverzeichnis. Führen Sie dann den folgenden Befehl aus, um IronPDF zu installieren:

dotnet add package IronPDF

dotnet add package IronPDF

SHELL

PDF-Erstellung mit IronPDF und Überwachung mit OpenTelemetry

Nachfolgend finden Sie ein Beispiel, wie ein einfaches PDF-Dokument erstellt und die Operation mit OpenTelemetry überwacht wird. Das folgende Beispiel geht davon aus, dass Sie OpenTelemetry in Ihrer Anwendung bereits wie zuvor gezeigt konfiguriert haben.

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

In diesem Beispiel erstellen wir eine neue Dienstklasse PdfService, die eine Methode GeneratePdf zum Erstellen eines PDF-Dokuments enthält. Wir verwenden die ChromePdfRenderer-Klasse von IronPDF, um HTML als PDF-Dokument zu rendern. Mit OpenTelemetry starten wir eine neue Aktivität namens "Generate PDF", um diesen Vorgang zu überwachen. Wir fügen der Aktivität benutzerdefinierte Tags hinzu, um zusätzliche Informationen über den PDF-Erstellungsprozess bereitzustellen, wie die Größe des PDFs, den Inhaltstyp und den Ausgabepfad. Wir fangen auch alle Ausnahmen ab, um Fehler innerhalb derselben Aktivität angemessen zu protokollieren.

Abschluss

OpenTelemetry in Ihre .NET-Anwendungen zu integrieren, ermöglicht es Ihnen, wertvolle Telemetriedaten zu sammeln, die Einblicke in die Leistung und das Verhalten Ihrer Anwendungen bieten. Indem Sie die in diesem Tutorial beschriebenen Schritte befolgen, haben Sie die grundlegende Tracing- und Metrikenerfassung für eine .NET-Webanwendung eingerichtet. Experimentieren Sie weiter, indem Sie erweiterte OpenTelemetry-Funktionen erkunden, wie das Exportieren von Telemetriedaten an externe Überwachungswerkzeuge oder das Sammeln von Logs neben Traces und Metriken.

IronPDF bietet eine kostenlose Testversion von IronPDF für die Produktion an, um seine vollständigen Fähigkeiten auszuprobieren. Lizenzen beginnen bereits ab 399 $.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...