Appmetrics C# (Funktionsweise für Entwickler)

Ein einfaches Code-Beispiel: Überwachung von HTTP-Anfragen

So richten Sie die grundlegende Überwachung von HTTP-Anfragen in Ihrer .NET-Anwendung mit AppMetrics ein. Erstellen Sie zunächst die Metriken in Ihrer Startup.cs-Datei. Fügen Sie den folgenden Code zur Methode ConfigureServices hinzu:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // Add basic metrics services
    services.AddMetricsTrackingMiddleware(); // Enable middleware for tracking
    services.AddMetricsEndpoints(); // Add endpoints for metrics exposure
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // Add basic metrics services
    services.AddMetricsTrackingMiddleware(); // Enable middleware for tracking
    services.AddMetricsEndpoints(); // Add endpoints for metrics exposure
}

Stellen Sie als Nächstes sicher, dass Sie in der Methode Configure derselben Datei die AppMetrics-Middleware hinzufügen, um die Überwachung zu übernehmen:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware(); // Register the middleware to capture all metrics
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware(); // Register the middleware to capture all metrics
}

Diese Einrichtung beginnt automatisch mit der Erfassung von Metriken zu eingehenden HTTP-Anfragen an Ihre Anwendung, wie Anfragenanzahl, Anfragendauer und Fehlerraten.

Aufzeichnung benutzerdefinierter Metriken

Um benutzerdefinierte Metriken zu erstellen und aufzuzeichnen oder Dinge in Ihrer Anwendung zu messen, bietet AppMetrics eine flexible Möglichkeit, festzulegen, was verfolgt werden muss. Hier ist ein Beispiel zur Aufzeichnung eines einfachen Zählers zur Verfolgung von Benutzeranmeldungen:

public class LoginTracker
{
    private readonly IMetrics _metrics;

    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }

    public void TrackLogin(string userId)
    {
        // Increment login counter for the specified user ID
        _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)
    {
        // Increment login counter for the specified user ID
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

In diesem Code wird bei jedem Aufruf von TrackLogin der Anmeldezähler für die angegebene Benutzer-ID erhöht.

Messung der Anwendungsleistung

AppMetrics kann auch verwendet werden, um die Anwendungsleistung zu messen. So können Sie beispielsweise die Dauer einer bestimmten Methode mit Timern verfolgen:

public void ProcessData()
{
    // Measure time taken by the database query process
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query goes here
    }
}

public void ProcessData()
{
    // Measure time taken by the database query process
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query goes here
    }
}

Dieser Timer zeichnet auf, wie lange die Methode ProcessData für die Ausführung benötigt, und bietet Einblicke in die Leistung von Datenbankabfragen.

Berichterstattung von Metriken an ein Dashboard

Um Ihre verschiedenen Metriktypen zu visualisieren und zu überwachen, kann AppMetrics Daten an verschiedene Dashboards berichten. So können Sie die Berichterstattung an ein InfluxDB-Dashboard konfigurieren:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetrics(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server"); // Configure InfluxDB server URI
            options.InfluxDb.Database = "appmetricsdb"; // Specify the database name
            options.InfluxDb.UserName = "user"; // Set database username
            options.InfluxDb.Password = "password"; // Set database password
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30); // Set backoff period
            options.HttpPolicy.FailuresBeforeBackoff = 5; // Set failure count before backoff
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10); // Set HTTP timeout duration
            options.FlushInterval = TimeSpan.FromSeconds(5); // Set interval for reporting metrics
        });
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetrics(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server"); // Configure InfluxDB server URI
            options.InfluxDb.Database = "appmetricsdb"; // Specify the database name
            options.InfluxDb.UserName = "user"; // Set database username
            options.InfluxDb.Password = "password"; // Set database password
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30); // Set backoff period
            options.HttpPolicy.FailuresBeforeBackoff = 5; // Set failure count before backoff
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10); // Set HTTP timeout duration
            options.FlushInterval = TimeSpan.FromSeconds(5); // Set interval for reporting metrics
        });
    });
}

Speichernutzung verfolgen

Die \u00dcberwachung des Systemspeichers ist entscheidend f\u00fcr die Leistungstuning. Hier ist, wie Sie den freien Speicher verfolgen können:

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false); // Get total free memory
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory); // Set gauge to measure free memory
}

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false); // Get total free memory
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory); // Set gauge to measure free memory
}

Dieses Messgerät misst den Ihrem Anwendung zur Verfügung stehenden freien Speicher und hilft Ihnen, Speicherverbrauchsmuster zu verstehen.

Verarbeitung von Metriken in bestimmten Intervallen

AppMetrics kann so konfiguriert werden, dass die Metrikensammlung in festgelegten Intervallen erfolgt. Dies hilft, die Leistung aufrechtzuerhalten, ohne Daten zu häufig zu protokollieren:

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>(); // Retrieve the IMetricsRoot instance
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60), // Set the interval for metrics collection
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // Run all reports asynchronously
        });
    scheduler.Start(); // Start the scheduler
}

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>(); // Retrieve the IMetricsRoot instance
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60), // Set the interval for metrics collection
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // Run all reports asynchronously
        });
    scheduler.Start(); // Start the scheduler
}

Diese Konfiguration legt fest, dass die Metriken alle 60 Sekunden gemeldet werden, um eine konsistente Leistungsüberwachung ohne Überforderung des Systems durch kontinuierliche Protokollierung sicherzustellen.

Einführung in IronPDF

IronPDF ist eine umfassende Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente mit C# zu erstellen, zu lesen und zu bearbeiten. Was IronPDF auszeichnet, ist seine Fähigkeit, HTML mit IronPDF in PDF zu konvertieren, was es besonders wertvoll für die webbasierte Berichtserstellung macht. Diese Fähigkeit stellt sicher, dass die visuellen Aspekte Ihrer Berichte erhalten bleiben und eine hohe Wiedergabetreue von Web zu Druckform bieten.

Benutzungsfall der Zusammenführung von IronPDF mit AppMetrics C#

Stellen Sie sich ein Szenario vor, in dem Sie monatliche Leistungsberichte Ihrer Anwendung an Stakeholder bereitstellen müssen. Diese Berichte umfassen Metriken wie Antwortzeiten, Fehlerraten, Benutzersitzungen und mehr. Mit dem Open-Source-AppMetrics C# können Sie diese Metriken nahtlos erfassen. Durch die Zusammenführung dieser Funktionalität mit IronPDF können Sie diese Metriken automatisch im PDF-Format ausgeben und verteilen.

Code-Beispiel für Anwendungsfall

Unten ist ein komplettes Beispiel, wie man dies umsetzt. Dieses Beispiel geht davon aus, dass Sie sowohl IronPDF als auch AppMetrics C# bereits in Ihrem Projekt eingerichtet haben.

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");

Diese Integration automatisiert nicht nur den Prozess der Berichtserstellung, sondern stellt auch sicher, dass die Berichte leicht lesbar und professionell formatiert sind, perfekt für jede Sitzung mit Stakeholdern oder Archivierungszwecke.