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#.
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.
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 :
Ensuite, créez un nouveau projet Web .NET en exécutant :
dotnet new web -o MyTelemetryApp
cd MyTelemetryAppCette commande crée un nouveau projet ASP.NET Core dans un répertoire nommé MyTelemetryApp.
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>Remplacez <version> par la dernière version de chaque package.
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 Sub ConfigureServices(ByVal services As IServiceCollection)
services.AddControllers()
services.AddOpenTelemetryTracing(Sub(builder)
builder.AddAspNetCoreInstrumentation().AddHttpClientInstrumentation().AddConsoleExporter()
End Sub)
End SubCet 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.
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 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 SubCette 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.
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();
});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 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.
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
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");
}
}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 ClassTout 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 IronPDFVoici 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;
}
}
}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 ClassDans 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é.
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 $.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
