Opentelemetry C# (Comment ça marche pour les développeurs)

OpenTelemetry est un ensemble d'outils, d'API et de SDK qui fonctionnent ensemble pour collecter, traiter et exporter des données de télémétrie telles que des traces, toutes les métriques et les journaux de vos applications. Ce tutoriel vise à aider les débutants à comprendre comment intégrer OpenTelemetry dans les applications C# à l'aide de la méthode d'extension, en se concentrant sur la collecte de métriques intégrée pour surveiller efficacement les applications .NET. Nous apprendrons également IronPDF bibliothèque.

Introduction à OpenTelemetry

OpenTelemetry offre un moyen unifié de collecter toutes sortes de données à partir de vos applications. Pour les développeurs .NET, l'intégration d'OpenTelemetry signifie que vous pouvez surveiller vos applications de plus près, comprendre leurs performances en temps réel et identifier rapidement les problèmes. La bibliothèque d'instrumentation d'OpenTelemetry permet de tracer automatiquement les applications .NET et d'en collecter les mesures.

Grâce aux mesures collectées par le framework OpenTelemetry, les développeurs obtiennent des informations précieuses sur l'environnement d'exécution .NET. La mise en œuvre d'OpenTelemetry .NET prend en charge l'exécution .NET, notamment .NET Core et .NET Framework. Il adhère au protocole OpenTelemetry pour la collecte de données télémétriques normalisées.

Mise en place de l'environnement

Pour commencer, le SDK .NET doit être installé sur votre machine. Si vous utilisez Visual Studio, il est probablement fourni avec le SDK .NET. Vous pouvez vérifier la version actuelle de votre .NET SDK en ouvrant une ligne de commande et en exécutant :

dotnet --version

Ensuite, créez un nouveau projet Web .NET en exécutant :

dotnet new web -o MyTelemetryApp
cd MyTelemetryApp

Cette commande crée un nouveau projet ASP.NET Core dans un répertoire nommé MyTelemetryApp.

Intégration d'OpenTelemetry

Ajout des paquets requis

Tout d'abord, ajoutez les paquets OpenTelemetry nécessaires à votre projet. Ouvrez votre terminal et naviguez jusqu'au répertoire de votre projet. Ensuite, installez les paquets suivants à l'aide de l'interface CLI du gestionnaire de paquets NuGet :

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>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'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>

Remplacer avec la dernière version de chaque paquet.

Configurer OpenTelemetry dans votre application

Après avoir ajouté les paquets nécessaires, vous devez configurer OpenTelemetry dans votre application. Il s'agit de configurer le SDK OpenTelemetry et de spécifier les données télémétriques à collecter. OpenTelemetry propose des bibliothèques d'instrumentation pour une intégration transparente dans les applications .NET.

Ouvrez le fichier Startup.cs de votre projet et modifiez la méthode ConfigureServices pour inclure OpenTelemetry comme le montre l'extrait de code ci-dessous :

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

Cet extrait de code montre comment configurer OpenTelemetry pour collecter les données de télémétrie des applications ASP.NET Core et des appels clients HTTP, puis exporter ces données vers la console. La méthode AddAspNetCoreInstrumentation active automatiquement l'instrumentation des requêtes HTTP entrantes vers les apps ASP.NET Core.

Collecte de données

Pour collecter des métriques, vous devez également configurer l'API OpenTelemetry Metrics. Il s'agit d'une configuration similaire, mais qui met l'accent sur les mesures plutôt que sur le traçage.

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

Cette configuration permet de collecter des métriques intégrées à partir de l'instrumentation d'ASP.NET Core et du client HTTP, en les exportant vers la console pour une visualisation facile.

Création de mesures personnalisées

Bien qu'OpenTelemetry collecte automatiquement de nombreuses mesures utiles, vous pouvez souhaiter collecter des mesures personnalisées spécifiques à votre application. L'utilisation d'une méthode d'extension fournie par la bibliothèque d'instrumentation permet non seulement de collecter automatiquement des données télémétriques, mais aussi d'offrir aux développeurs un contrôle plus granulaire sur les mesures émises. Pour ce faire, vous pouvez instrumenter manuellement votre code afin de créer et d'enregistrer des mesures personnalisées.

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)

Cet extrait de code montre comment créer une métrique personnalisée qui comptabilise les demandes adressées à votre application, en marquant chaque métrique avec le chemin de la demande. En exploitant les méthodes d'extension fournies par OpenTelemetry, les développeurs peuvent exercer un contrôle plus granulaire sur le processus de collecte des données télémétriques.

Test de l'intégration

Exécutez votre application à l'aide de la ligne de commande ou de Visual Studio. Faites des demandes à votre application, soit en naviguant vers son URL dans un navigateur web, soit en utilisant un outil comme curl. Vous devriez voir les données de télémétrie, y compris les traces et les métriques, s'afficher sur votre console.

curl http://localhost:5000

curl http://localhost:5000

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'curl http: 'localhost:5000

Présentation d'IronPDF

IronPDF est une puissante bibliothèque pour les développeurs C#, permettant la génération, la manipulation et le rendu de documents PDF directement dans les applications .NET. Cette fonction est particulièrement utile pour générer des rapports, des factures ou tout autre type d'information les sorties d'applications web basées sur des documentsou des applications de bureau. La combinaison d'IronPDF et d'OpenTelemetry permet aux développeurs de surveiller les performances et la fiabilité des processus de génération de PDF au sein de leurs applications, garantissant ainsi une expérience utilisateur fluide.

Configuration d'IronPDF

Tout d'abord, vous devez ajouter IronPDF à votre projet .NET. Vous pouvez le faire en utilisant le gestionnaire de paquets NuGet. Ouvrez votre terminal et naviguez jusqu'au répertoire de votre projet. Ensuite, exécutez la commande suivante pour installer IronPDF :

Install-Package IronPdf

Génération d'un PDF avec IronPDF et surveillance avec OpenTelemetry

Vous trouverez ci-dessous un exemple de génération d'un simple document PDF et de contrôle du fonctionnement à l'aide d'OpenTelemetry. L'exemple suivant suppose que vous avez déjà configuré OpenTelemetry dans votre application comme indiqué précédemment.

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

Dans cet exemple, nous créons une nouvelle classe de service PdfService qui comprend une méthode GeneratePdf pour générer un document PDF. Nous utilisons la classe ChromePdfRenderer d'IronPDF pour rendre le HTML sous forme de document PDF. Avec OpenTelemetry, nous démarrons une nouvelle activité nommée "Generate PDF" pour surveiller cette opération. Nous ajoutons des balises personnalisées à l'activité pour fournir un contexte supplémentaire sur le processus de génération de PDF, comme la taille du PDF, le type de contenu et le chemin de sortie. Nous capturons également toutes les exceptions afin d'enregistrer les erreurs de manière appropriée au sein de la même activité.

Conclusion

L'intégration d'OpenTelemetry dans vos applications .NET vous permet de collecter des données télémétriques précieuses, offrant ainsi un aperçu des performances et du comportement de votre application. En suivant les étapes décrites dans ce didacticiel, vous avez mis en place un suivi de base et une collecte de métriques pour une application Web .NET. Expérimentez davantage en explorant des fonctionnalités plus avancées d'OpenTelemetry, telles que l'exportation de données de télémétrie vers des outils de surveillance externes ou la collecte de journaux avec les traces et les métriques.

IronPDF offre essai gratuit pour la production afin de tester toutes ses capacités à pleine puissance. La licence commence à partir de $749.