Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Opentelemetry C#
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

OpenTelemetry est un ensemble d'outils, d'API et de SDK qui travaillent ensemble pour collecter, traiter et exporter des données de télémétrie telles que les traces, 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# en utilisant la méthode d'extension, en se concentrant sur la collecte de métriques intégrées pour surveiller efficacement les applications .NET. Nous apprendrons également à propos de la bibliothèque IronPDF pour la génération de PDF en C#.

Introduction à OpenTelemetry

Opentelemetry C# (Comment cela fonctionne pour les développeurs) : Figure 1 - OpenTelemetry

OpenTelemetry fournit une manière unifiée de collecter toutes sortes de données de vos applications. Pour les développeurs .NET, intégrer OpenTelemetry signifie que vous pouvez surveiller vos applications de plus près, comprendre comment elles fonctionnent en temps réel et identifier rapidement les problèmes. La bibliothèque d'instrumentation d'OpenTelemetry permet automatiquement la traçabilité et la collecte de métriques pour les applications .NET.

Avec les métriques collectées par le cadre OpenTelemetry, les développeurs obtiennent des informations précieuses sur l'environnement d'exécution .NET. L'implémentation .NET d'OpenTelemetry prend en charge l'environnement d'exécution .NET, y compris .NET Core et .NET Framework. Elle se conforme au protocole OpenTelemetry pour une collecte normalisée des données de télémétrie.

Configuration de votre environnement

Pour commencer, vous devrez avoir le SDK .NET installé sur votre machine. Si vous utilisez Visual Studio, il est probable qu'il soit venu avec le SDK .NET. Vous pouvez vérifier la version actuelle de votre SDK .NET 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
dotnet new web -o MyTelemetryApp
cd MyTelemetryApp
SHELL

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

Intégration d'OpenTelemetry

Ajouter les packages requis

Tout d'abord, ajoutez les packages OpenTelemetry nécessaires à votre projet. Ouvrez votre terminal et naviguez jusqu'au répertoire de votre projet. Ensuite, installez les packages suivants en utilisant le gestionnaire de packages NuGet 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

Remplacez par la dernière version de chaque package.

Configurer OpenTelemetry dans votre application

Après avoir ajouté les packages nécessaires, vous devez configurer OpenTelemetry dans votre application. Cela consiste à mettre en place le SDK OpenTelemetry et à spécifier quelles données de télémétrie collecter. OpenTelemetry offre des bibliothèques d'instrumentation pour une intégration transparente avec les applications .NET.

Ouvrez le fichier Startup.cs de votre projet et modifiez la méthode ConfigureServices pour inclure OpenTelemetry comme indiqué dans 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
$vbLabelText   $csharpLabel

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

Collecte de métriques

Pour collecter des métriques, vous devrez également configurer l'API des métriques OpenTelemetry, en vous concentrant sur les métriques plutôt que sur la traçabilité.

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
$vbLabelText   $csharpLabel

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

Créer des métriques personnalisées

Alors qu'OpenTelemetry collecte automatiquement de nombreuses métriques utiles, vous pourriez vouloir collecter des métriques personnalisées spécifiques à votre application. Utiliser une méthode d'extension fournie par la bibliothèque d'instrumentation non seulement collecte automatiquement la télémétrie, mais donne également aux développeurs un contrôle plus granulé sur les métriques émises. Cela peut être réalisé en instrumentant manuellement votre code pour créer et enregistrer des métriques 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)
$vbLabelText   $csharpLabel

Cet extrait de code montre comment créer une métrique personnalisée comptant les requêtes vers votre application, étiquetant chaque métrique avec le chemin de la requête. En tirant parti des 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 de télémétrie.

Tester votre intégration

Exécutez votre application à l'aide de la ligne de commande ou de Visual Studio. Effectuez certaines requêtes vers votre application, soit en naviguant vers son URL dans un navigateur Web, soit en utilisant un outil comme curl. Vous devriez voir des données de télémétrie, y compris des traces et des métriques, s'imprimer dans votre sortie console.

curl http://localhost:5000
curl http://localhost:5000
SHELL

Introduction de IronPDF

Opentelemetry C# (Comment cela fonctionne pour les développeurs) : Figure 2 - IronPDF

IronPDF est une bibliothèque puissante pour les développeurs C#, permettant la génération, la manipulation et le rendu de documents PDF directement au sein des applications .NET. Cette capacité est particulièrement utile pour générer des rapports, des factures ou toute sortie basée sur des documents à partir d'applications Web utilisant HTML, de services ou d'applications de bureau. Associer IronPDF avec OpenTelemetry permet aux développeurs de surveiller la performance et la fiabilité des processus de génération de PDF au sein de leurs applications, assurant une expérience utilisateur fluide.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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
$vbLabelText   $csharpLabel

Installation de IronPDF

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

dotnet add package IronPDF
dotnet add package IronPDF
SHELL

Générer un PDF avec IronPDF et surveiller avec OpenTelemetry

Voici un exemple de génération d'un document PDF simple et de surveillance de l'opération à l'aide d'OpenTelemetry. L'exemple suivant suppose que vous avez déjà configuré OpenTelemetry dans votre application comme montré 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
$vbLabelText   $csharpLabel

Dans cet exemple, nous créons une nouvelle classe de service PdfService qui inclut une méthode GeneratePdf pour générer un document PDF. Nous utilisons la classe ChromePdfRenderer d'IronPDF pour rendre du HTML en tant que document PDF. Avec OpenTelemetry, nous commençons 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, tel que la taille du PDF, le type de contenu et le chemin de sortie. Nous attrapons également toutes les exceptions pour consigner les erreurs de manière appropriée dans la même activité.

Conclusion

Opentelemetry C# (Comment cela fonctionne pour les développeurs) : Figure 3 - Licensing

Intégrer OpenTelemetry dans vos applications .NET vous permet de collecter des données de télémétrie précieuses, offrant des informations sur les performances et le comportement de votre application. En suivant les étapes décrites dans ce tutoriel, vous avez configuré une collecte de traçage et de métriques de base pour une application Web .NET. Expérimentez davantage en explorant des fonctionnalités OpenTelemetry plus avancées, telles que l'exportation des données de télémétrie vers des outils de surveillance externes ou la collecte de journaux en plus des traces et des métriques.

IronPDF propose un essai gratuit d'IronPDF pour tester ses capacités complètes. Les licences commencent à partir de seulement 399 $.

Questions Fréquemment Posées

Quel est le but d'OpenTelemetry dans le développement C# ?

OpenTelemetry fournit une approche unifiée pour collecter, traiter et exporter des données de télémétrie telles que des traces, des métriques et des journaux, permettant aux développeurs de surveiller et de comprendre les performances de l'application en temps réel.

Comment puis-je commencer à intégrer OpenTelemetry dans mon application C# ?

Commencez par installer les packages OpenTelemetry nécessaires via NuGet, puis configurez votre application en modifiant la méthode 'ConfigureServices' dans 'Startup.cs' pour inclure le traçage et les métriques OpenTelemetry.

Quelles étapes sont nécessaires pour configurer l'environnement pour OpenTelemetry en C# ?

Assurez-vous que le SDK .NET est installé sur votre machine. Vous pouvez vérifier l'installation en exécutant dotnet --version dans votre ligne de commande.

Comment générer un PDF en C# en utilisant du contenu HTML ?

Vous pouvez utiliser la classe ChromePdfRenderer de la bibliothèque IronPDF pour rendre le HTML comme un document PDF, puis utiliser la méthode SaveAs pour enregistrer le PDF généré.

Comment puis-je surveiller le processus de génération de PDF dans une application C# ?

Utilisez le Tracer d'OpenTelemetry pour créer une activité pour la génération de PDF, en ajoutant des balises personnalisées pour enregistrer des informations pertinentes sur le processus à des fins de surveillance.

Qu'est-ce que les métriques personnalisées et comment peuvent-elles être utilisées dans OpenTelemetry avec C# ?

Les métriques personnalisées sont des points de données spécifiques à l'application que vous pouvez collecter en instrumentant manuellement votre code avec les classes Meter et Counter d'OpenTelemetry.

Comment puis-je garantir une génération fiable de PDF en C# ?

Utilisez la bibliothèque IronPDF pour générer, manipuler et rendre des documents PDF de manière fiable. IronPDF offre des fonctionnalités robustes pour garantir des sorties PDF de haute qualité dans vos applications.

Existe-t-il des options de licence disponibles pour les bibliothèques qui aident à générer des PDF en C# ?

IronPDF propose un essai gratuit pour le test en production, avec des licences à partir de 399 $, le rendant accessible aux développeurs pour explorer ses capacités complètes.

Comment puis-je tester mon intégration OpenTelemetry dans une application C# ?

Exécutez votre application et faites des requêtes en utilisant un navigateur Web ou des outils comme curl, puis observez les données de télémétrie telles que les traces et les métriques affichées sur la console.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit