Opentelemetry C# (Wie es für Entwickler funktioniert)

OpenTelemetry ist eine Sammlung von Tools, APIs und SDKs, die zusammenarbeiten, um Telemetriedaten wie Traces, Metriken und Logs von Ihren Anwendungen zu sammeln, zu verarbeiten und zu exportieren. Dieses Tutorial soll Anfängern helfen zu verstehen, wie man OpenTelemetry in C#-Anwendungen mit Hilfe der Erweiterungsmethode integriert. Der Schwerpunkt liegt dabei auf der eingebauten Metriksammlung, um .NET-Anwendungen effektiv zu überwachen. Wir werden auch die IronPDF-Bibliothek zur PDF-Erstellung in C# kennenlernen.

Einführung in 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, deren Leistung in Echtzeit nachvollziehen und Probleme schnell erkennen können. Die Instrumentierungsbibliothek von OpenTelemetry ermöglicht automatisch das Tracing und die Erfassung von Metriken für .NET-Anwendungen.

Mit den vom OpenTelemetry-Framework gesammelten Metriken erhalten die Entwickler wertvolle Einblicke in die .NET-Laufzeitumgebung. Die OpenTelemetry .NET-Implementierung unterstützt die .NET-Laufzeit, einschließlich .NET Core und .NET-Framework. Es folgt dem OpenTelemetry-Protokoll für standardisierte Telemetriedatenerfassung.

Einrichten Ihrer Umgebung

Zunächst muss das .NET SDK auf Ihrem Computer installiert sein. Wenn Sie Visual Studio verwenden, wird es wahrscheinlich mit dem .NET SDK geliefert. Sie können Ihre aktuelle .NET SDK-Version überprüfen, indem Sie eine Befehlszeile öffnen und ausführen:

dotnet --version

dotnet --version

Als nächstes erstellen Sie ein neues .NET-Webprojekt, indem Sie es ausführen:

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

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

Einbindung von OpenTelemetry

Hinzufügen erforderlicher Pakete

Fügen Sie zunächst die erforderlichen 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 Package Manager 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>

Ersetzen Sie durch die neueste Version jedes Pakets.

Konfigurieren von OpenTelemetry in Ihrer Anwendung

Nachdem Sie die erforderlichen Pakete hinzugefügt haben, müssen Sie OpenTelemetry in Ihrer Anwendung konfigurieren. Dazu müssen Sie das OpenTelemetry SDK einrichten und angeben, welche Telemetriedaten gesammelt werden sollen. OpenTelemetry bietet Instrumentierungsbibliotheken für die nahtlose Integration in .NET-Anwendungen.

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

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

Dieses Codeschnipsel zeigt, wie OpenTelemetry konfiguriert wird, um Telemetriedaten von ASP.NET Core-Anwendungen und HTTP-Client-Aufrufen zu sammeln und diese Daten dann in 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 auf Metriken und nicht 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

Dieses Setup ermöglicht die Erfassung integrierter Metriken von ASP.NET Core und HTTP-Client-Instrumentierung und exportiert sie zur einfachen Anzeige in die Konsole.

Benutzerdefinierte Metriken erstellen

OpenTelemetry sammelt zwar automatisch viele nützliche Metriken, aber vielleicht möchten Sie auch benutzerdefinierte Metriken speziell für Ihre Anwendung sammeln. Die Verwendung einer Erweiterungsmethode, die von der Instrumentierungsbibliothek bereitgestellt wird, sammelt nicht nur automatisch Telemetriedaten, sondern gibt Entwicklern auch eine genauere Kontrolle über die ausgegebenen Metriken. Dies kann durch manuelle Instrumentierung Ihres Codes erreicht werden, 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)

Dieses Codeschnipsel zeigt, wie man eine benutzerdefinierte Metrik erstellt, die Anfragen an die Anwendung zählt und jede Metrik mit dem Anfragepfad kennzeichnet. Durch den Einsatz von Erweiterungsmethoden, die von OpenTelemetry bereitgestellt werden, können Entwickler den Prozess der Telemetriedatenerfassung detaillierter steuern.

Testen Ihrer Integration

Führen Sie Ihre Anwendung über die Befehlszeile oder Visual Studio aus. Führen Sie einige Anfragen an Ihre Anwendung durch, entweder indem Sie deren URL in einem Webbrowser aufrufen oder ein Tool wie curl verwenden. Sie sollten sehen, dass Telemetriedaten, einschließlich Traces und Metriken, auf Ihrer Konsole ausgegeben werden.

curl http://localhost:5000

curl http://localhost:5000

Einführung von IronPDF

IronPDF ist eine leistungsstarke Bibliothek für C#-Entwickler, die die Erzeugung, Bearbeitung und Darstellung von PDF-Dokumenten direkt in .NET-Anwendungen ermöglicht. Diese Funktion ist besonders nützlich zur Erstellung von Berichten, Rechnungen oder beliebigen dokumentbasierten Ausgaben aus Webanwendungen mithilfe von HTML, Dienstleistungen oder Desktop-Anwendungen. Die Kombination von IronPDF mit OpenTelemetry ermöglicht es Entwicklern, die Leistung und Zuverlässigkeit der PDF-Generierungsprozesse innerhalb ihrer Anwendungen zu überwachen, um ein reibungsloses Benutzererlebnis sicherzustellen.

IronPDF zeichnet sich durch die HTML-zu-PDF-Konvertierung aus und gewährleistet eine präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist perfekt geeignet, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. Mit Unterstützung von HTML-Dateien, URLs und rohen HTML-Zeichenfolgen produziert IronPDF mühelos 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

IronPDF einrichten

Zunächst müssen Sie IronPDF zu Ihrem .NET-Projekt hinzufügen. Sie können dies 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

Erzeugen einer PDF-Datei mit IronPDF und Überwachung mit OpenTelemetry

Nachfolgend ein Beispiel für die Erstellung eines einfachen PDF-Dokuments und die Überwachung des Vorgangs mit OpenTelemetry. Das folgende Beispiel geht davon aus, dass Sie OpenTelemetry in Ihrer Anwendung bereits wie oben 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(ByVal tracer As Tracer)
		_tracer = tracer
	End Sub
	Public Sub GeneratePdf()
		' Create a new activity for this operation
		Dim activity = _tracer.StartActivity("Generate PDF")
		' Simulate adding some attributes related to the operation
		If activity IsNot Nothing Then
			activity.SetTag("pdf.size", "A4")
		End If
		If activity IsNot Nothing Then
			activity.SetTag("pdf.content", "Hello World")
		End If
		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
			If activity IsNot Nothing Then
				activity.SetTag("pdf.status", "Success")
			End If
			If activity IsNot Nothing Then
				activity.SetTag("pdf.outputPath", outputPath)
			End If
		Catch ex As Exception
			' Log any exceptions that occur during PDF generation
			If activity IsNot Nothing Then
				activity.SetTag("pdf.status", "Error")
			End If
			If activity IsNot Nothing Then
				activity.SetTag("pdf.error", ex.Message)
			End If
			Throw
		End Try
	End Sub
End Class

In diesem Beispiel erstellen wir eine neue Service-Klasse 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ätzlichen Kontext über den PDF-Generierungsprozess zu liefern, z. B. die Größe der PDF-Datei, den Inhaltstyp und den Ausgabepfad. Wir fangen auch alle Ausnahmen ab, um Fehler innerhalb derselben Aktivität entsprechend zu protokollieren.

Schlussfolgerung

Durch die Integration von OpenTelemetry in Ihre .NET-Anwendungen können Sie wertvolle Telemetriedaten sammeln, die Ihnen Einblicke in die Leistung und das Verhalten Ihrer Anwendung geben. Wenn Sie die in diesem Tutorial beschriebenen Schritte befolgt haben, haben Sie eine grundlegende Ablaufverfolgung und Metrikenerfassung für eine .NET-Webanwendung eingerichtet. Experimentieren Sie weiter, indem Sie erweiterte OpenTelemetry-Funktionen ausprobieren, z. B. den Export von Telemetriedaten an externe Überwachungstools oder die Erfassung von Protokollen neben Traces und Metriken.

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