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

AppMetrics C# est un outil puissant conçu pour rationaliser la surveillance des applications et l'analyse des performances. Les abstracts App Metrics simplifient la complexité du suivi des différents aspects de votre application. Que vous utilisiez .NET Core ou le Framework .NET, cette bibliothèque .NET vous permet d'enregistrer efficacement les types de métriques. Vous pouvez récupérer des métriques et utiliser les types de métriques pris en charge par App Metrics pour obtenir des informations complètes.

La bibliothèque .NET prend en charge l'extraction des métriques et vous permet d'extraire les métriques à un intervalle spécifié, garantissant ainsi une collecte de données en temps voulu. Il propose également une méthode d'extension, offrant des points d'extension pour une plus grande flexibilité. En tant que solution multiplateforme, AppMetrics convient à divers environnements et garantit un contrôle cohérent des performances.

IronPDF : Bibliothèque PDF avancée pour les développeurs C# est une autre bibliothèque essentielle pour les développeurs C#, en particulier lorsqu'ils travaillent avec des documents PDF. Il permet de créer, d'éditer et d'extraire des fichiers PDF directement au sein des applications .NET Core. Cela peut s'avérer particulièrement utile lorsque vous devez générer des rapports, des factures ou tout autre document au format PDF à partir de votre application.

Démarrer avec AppMetrics

Pour intégrer App Metrics multiplateforme dans votre projet .NET, commencez par installer la bibliothèque AppMetrics. Vous pouvez le faire en utilisant les paquets NuGet, le gestionnaire de paquets pour .NET. Dans votre projet, exécutez la commande suivante dans la console du gestionnaire de paquets NuGet :

Install-Package App.Metrics.AspNetCore

Install-Package App.Metrics.AspNetCore

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package App.Metrics.AspNetCore

Cette commande ajoute toutes les dépendances nécessaires à votre projet, ce qui vous permet de commencer à configurer AppMetrics.

Un exemple de code de base : Surveillance des requêtes HTTP

Voici comment mettre en place une surveillance de base des requêtes HTTP dans votre application .NET à l'aide d'AppMetrics. Tout d'abord, créez les métriques dans votre fichier Startup.cs. Ajoutez le code suivant à la méthode ConfigureServices :

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // metric type
    services.AddMetricsTrackingMiddleware();
    services.AddMetricsEndpoints();
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // metric type
    services.AddMetricsTrackingMiddleware();
    services.AddMetricsEndpoints();
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetrics() ' metric type
	services.AddMetricsTrackingMiddleware()
	services.AddMetricsEndpoints()
End Sub

Ensuite, dans la méthode Configure du même fichier, assurez-vous d'ajouter le middleware AppMetrics pour gérer la surveillance :

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware();
}

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseMetricsAllMiddleware()
End Sub

Cette configuration commence automatiquement à capturer des mesures sur les requêtes HTTP entrantes dans votre application, telles que le nombre de requêtes, la durée des requêtes et les taux d'erreur.

Mise en œuvre des fonctionnalités d'App Metrics

Enregistrement de mesures personnalisées

Pour créer et enregistrer des métriques personnalisées ou mesurer des éléments dans votre application, AppMetrics offre un moyen souple de définir ce qui doit être suivi. Voici un exemple d'enregistrement d'un simple compteur pour suivre les connexions des utilisateurs :

public class LoginTracker
{
    private readonly IMetrics _metrics;
    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }
    public void TrackLogin(string userId)
    {
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

public class LoginTracker
{
    private readonly IMetrics _metrics;
    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }
    public void TrackLogin(string userId)
    {
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

Public Class LoginTracker
	Private ReadOnly _metrics As IMetrics
	Public Sub New(ByVal metrics As IMetrics)
		_metrics = metrics
	End Sub
	Public Sub TrackLogin(ByVal userId As String)
		_metrics.Measure.Counter.Increment(MetricsRegistry.Logins, New MetricTags("UserId", userId))
	End Sub
End Class

Dans ce code, chaque fois que TrackLogin est appelé, le compteur de connexions augmente pour l'ID utilisateur spécifié.

Mesurer la performance des applications

AppMetrics peut également être utilisé pour mesurer la performance des applications. Par exemple, vous pouvez suivre la durée d'une méthode spécifique à l'aide de minuteries :

public void ProcessData()
{
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query
    }
}

public void ProcessData()
{
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query
    }
}

Public Sub ProcessData()
	Using _metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer)
		' Code to execute a database query
	End Using
End Sub

Ce minuteur enregistre le temps d'exécution de la méthode ProcessData, ce qui permet de mieux comprendre les performances des requêtes de la base de données.

Rapport sur les mesures dans un tableau de bord

Pour visualiser et surveiller vos différents types de mesures, AppMetrics peut rapporter des données dans différents tableaux de bord. Voici comment configurer l'envoi de rapports vers un tableau de bord InfluxDB :

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetricsBuild(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server");
            options.InfluxDb.Database = "appmetricsdb";
            options.InfluxDb.UserName = "user";
            options.InfluxDb.Password = "password";
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
            options.HttpPolicy.FailuresBeforeBackoff = 5;
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
            options.FlushInterval = TimeSpan.FromSeconds(5);
        });
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetricsBuild(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server");
            options.InfluxDb.Database = "appmetricsdb";
            options.InfluxDb.UserName = "user";
            options.InfluxDb.Password = "password";
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30);
            options.HttpPolicy.FailuresBeforeBackoff = 5;
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10);
            options.FlushInterval = TimeSpan.FromSeconds(5);
        });
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetricsReportingHostedService()
	services.AddMetricsBuild(Sub(builder)
		builder.Report.ToInfluxDb(Sub(options)
			options.InfluxDb.BaseUri = New Uri("http://your-influxdb-server")
			options.InfluxDb.Database = "appmetricsdb"
			options.InfluxDb.UserName = "user"
			options.InfluxDb.Password = "password"
			options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30)
			options.HttpPolicy.FailuresBeforeBackoff = 5
			options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10)
			options.FlushInterval = TimeSpan.FromSeconds(5)
		End Sub)
	End Sub)
End Sub

Suivi de l'utilisation de la mémoire

La surveillance de l'utilisation de la mémoire du système est cruciale pour l'optimisation des performances. Voici comment vous pouvez suivre l'évolution de la mémoire libre :

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false);
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory);
}

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false);
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory);
}

Public Sub CheckSystemMemory()
	Dim freeMemory = GC.GetTotalMemory(False)
	_metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory)
End Sub

Cette jauge mesure la mémoire libre disponible pour votre application, ce qui vous aide à comprendre les schémas de consommation de la mémoire.

Traitement des mesures à intervalles spécifiés

AppMetrics peut être configuré pour gérer la collecte des métriques à des intervalles spécifiés. Cela permet de maintenir les performances sans enregistrer les données trop fréquemment :

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>();
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60),
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // await task
        });
    scheduler.Start();
}

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>();
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60),
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // await task
        });
    scheduler.Start();
}

Public Sub ConfigureScheduledReporting(ByVal app As IApplicationBuilder)
	Dim metrics = app.ApplicationServices.GetService(Of IMetricsRoot)()
	Dim scheduler = New AppMetricsTaskScheduler(TimeSpan.FromSeconds(60), Async Sub()
			Await Task.WhenAll(metrics.ReportRunner.RunAllAsync()) ' await task
	End Sub)
	scheduler.Start()
End Sub

Cette configuration permet d'établir un rapport sur les mesures toutes les 60 secondes, ce qui garantit un contrôle cohérent des performances sans surcharger le système avec l'enregistrement continu des données.

Intégration d'AppMetrics à IronPDF

Lorsque vous travaillez avec des métriques et la génération de PDF dans vos applications C#, la combinaison d'AppMetrics C# et d'IronPDF peut s'avérer très bénéfique. Cette intégration vous permet de générer des rapports au format PDF directement à partir de vos données de mesure, ce qui est utile pour les évaluations de performance, les présentations aux clients ou même les audits internes.

Introduction à IronPDF

IronPDF est une bibliothèque complète qui permet aux développeurs de créer, lire et modifier des documents PDF à l'aide de C#. Ce qui distingue IronPDF, c'est sa capacité àconvertir HTML en PDF avec IronPDFce qui le rend particulièrement utile pour la génération de rapports sur le web. Cette capacité garantit que les aspects visuels de vos rapports sont préservés, offrant un haut degré de fidélité du web à l'impression.

Cas d'utilisation de la fusion d'IronPDF avec AppMetrics C&num ;

Prenons l'exemple d'un scénario dans lequel vous devez fournir aux parties prenantes des rapports mensuels sur les performances de votre application. Ces rapports comprennent des mesures telles que les temps de réponse, les taux d'erreur, les sessions d'utilisateurs, etc. Avec le logiciel libre AppMetrics C#, vous pouvez capturer ces mesures en toute transparence. En combinant cette fonctionnalité avec IronPDF, vous pouvez générer et distribuer automatiquement ces mesures dans un document PDF au format soigné.

Exemple de code pour un cas d'utilisation

Vous trouverez ci-dessous un exemple complet de mise en œuvre. Cet exemple suppose que vous avez déjà configuré IronPDF et AppMetrics C# dans votre projet.

using App.Metrics;
using App.Metrics.Formatters.Prometheus;
using IronPdf;
public class MetricsToPdfConverter
{
    private readonly IMetricsRoot _metrics;
    public MetricsToPdfConverter(IMetricsRoot metrics)
    {
        _metrics = metrics;
    }
    public void GeneratePdfReport(string outputPath)
    {
        // Step 1: Capture the metrics snapshot
        var metricsData = _metrics.Snapshot.Get();
        var formatter = new MetricsPrometheusTextOutputFormatter();
        using var stream = new MemoryStream();
        formatter.WriteAsync(stream, metricsData).Wait();
        // Step 2: Convert the metrics snapshot to string format
        stream.Position = 0;
        var reader = new StreamReader(stream);
        var metricsText = reader.ReadToEnd();
        // Step 3: Use IronPDF to convert the metrics text to a PDF document
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" + metricsText + "</pre>");
        // Step 4: Save the PDF document
        pdf.SaveAs(outputPath);
    }
}
// Usage
var metrics = new MetricsBuilder().Build();
var pdfConverter = new MetricsToPdfConverter(metrics);
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf");

using App.Metrics;
using App.Metrics.Formatters.Prometheus;
using IronPdf;
public class MetricsToPdfConverter
{
    private readonly IMetricsRoot _metrics;
    public MetricsToPdfConverter(IMetricsRoot metrics)
    {
        _metrics = metrics;
    }
    public void GeneratePdfReport(string outputPath)
    {
        // Step 1: Capture the metrics snapshot
        var metricsData = _metrics.Snapshot.Get();
        var formatter = new MetricsPrometheusTextOutputFormatter();
        using var stream = new MemoryStream();
        formatter.WriteAsync(stream, metricsData).Wait();
        // Step 2: Convert the metrics snapshot to string format
        stream.Position = 0;
        var reader = new StreamReader(stream);
        var metricsText = reader.ReadToEnd();
        // Step 3: Use IronPDF to convert the metrics text to a PDF document
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" + metricsText + "</pre>");
        // Step 4: Save the PDF document
        pdf.SaveAs(outputPath);
    }
}
// Usage
var metrics = new MetricsBuilder().Build();
var pdfConverter = new MetricsToPdfConverter(metrics);
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf");

Imports App.Metrics
Imports App.Metrics.Formatters.Prometheus
Imports IronPdf
Public Class MetricsToPdfConverter
	Private ReadOnly _metrics As IMetricsRoot
	Public Sub New(ByVal metrics As IMetricsRoot)
		_metrics = metrics
	End Sub
	Public Sub GeneratePdfReport(ByVal outputPath As String)
		' Step 1: Capture the metrics snapshot
		Dim metricsData = _metrics.Snapshot.Get()
		Dim formatter = New MetricsPrometheusTextOutputFormatter()
		Dim stream = New MemoryStream()
		formatter.WriteAsync(stream, metricsData).Wait()
		' Step 2: Convert the metrics snapshot to string format
		stream.Position = 0
		Dim reader = New StreamReader(stream)
		Dim metricsText = reader.ReadToEnd()
		' Step 3: Use IronPDF to convert the metrics text to a PDF document
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" & metricsText & "</pre>")
		' Step 4: Save the PDF document
		pdf.SaveAs(outputPath)
	End Sub
End Class
' Usage
Private metrics = (New MetricsBuilder()).Build()
Private pdfConverter = New MetricsToPdfConverter(metrics)
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf")

Cette intégration permet non seulement d'automatiser le processus de génération de rapports, mais aussi de s'assurer que les rapports sont facilement lisibles et formatés de manière professionnelle, ce qui est parfait pour les réunions avec les parties prenantes ou à des fins d'archivage.

Conclusion

En résumé, la combinaison d'AppMetrics C# et d'IronPDF dans vos projets .NET constitue une solution robuste pour surveiller les performances des applications et générer des rapports PDF de haute qualité. Cette intégration vous permet de passer en toute transparence de la capture de données de performance détaillées avec AppMetrics à la présentation de ces données dans un format clair et professionnel à l'aide d'IronPDF.

IronPDF est particulièrement utile pour les développeurs C# qui souhaitent gérer des fichiers PDF dans leurs applications. Il simplifie la création et la manipulation des documents PDF et offre la possibilité unique de convertir HTML directement en PDF. Si vous envisagez d'intégrer IronPDF à vos projets, l'entreprise propose un service d'aide à la création d'entrepriseessai gratuit d'IronPDFpour vous aider à démarrer, et les licences commencent à partir de $749, offrant une solution rentable pour améliorer vos capacités de gestion de documents.