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

OpenTelemetry ist eine Reihe von Tools, APIs und SDKs, die zusammenarbeiten, um Telemetriedaten wie Traces, Metriken und Protokolle aus 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 etwas über dieIronPDF-Bibliothek für die PDF-Erzeugung in C#.

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

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

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>

Ersetzen mit der neuesten Version des jeweiligen 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 so, dass sie OpenTelemetry einschließt, wie im folgenden Codeschnipsel 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 Methode AddAspNetCoreInstrumentation aktiviert automatisch die Instrumentierung für eingehende HTTP-Anforderungen 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. Rufen Sie Ihre Anwendung auf, indem Sie in einem Webbrowser zu ihrer URL navigieren 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

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 für die Erstellung von Berichten, Rechnungen oder anderendokumentenbasierte Ausgaben von Webanwendungen mit HTML, Dienste oder Desktop-Anwendungen. Die Kombination von IronPDF mit OpenTelemetry ermöglicht es Entwicklern, die Leistung und Zuverlässigkeit von PDF-Erzeugungsprozessen innerhalb ihrer Anwendungen zu überwachen und so eine reibungslose Benutzererfahrung zu gewährleisten.

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

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 Dienstklasse PdfService, die eine Methode GeneratePdf zur Erzeugung eines PDF-Dokuments enthält. Wir verwenden die Klasse ChromePdfRenderer 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 einekostenlose Testversion von IronPDF für die Produktion, um die volle Leistungsfähigkeit zu testen. Lizenzen gibt es bereits ab 399 $.