Appmetrics C# (Wie es für Entwickler funktioniert)

AppMetrics C# ist ein leistungsfähiges Tool zur Optimierung der Anwendungsüberwachung und Leistungsanalyse. Mit App Metrics abstracts wird die Komplexität der Verfolgung verschiedener Aspekte Ihrer Anwendung vereinfacht. Unabhängig davon, ob Sie .NET Core oder das .NET-Framework verwenden, können Sie mit dieser .NET-Bibliothek Metrik-Typen effizient aufzeichnen. Sie können Metriken abrufen und die von App Metrics unterstützten Metrik-Typen für umfassende Einblicke nutzen.

Die .NET-Bibliothek unterstützt das Abrufen von Metriken und ermöglicht es Ihnen, Metriken in einem bestimmten Intervall zu flushen, um eine rechtzeitige Datenerfassung zu gewährleisten. Es bietet auch eine Erweiterungsmethode, die Erweiterungspunkte für mehr Flexibilität bietet. Als plattformübergreifende Lösung ist AppMetrics für unterschiedliche Umgebungen geeignet und gewährleistet eine konsistente Leistungsüberwachung.

IronPDF ist eine weitere unverzichtbare Bibliothek für C#-Entwickler, insbesondere bei der Arbeit mit PDF-Dokumenten. Es ermöglicht die Erstellung, Bearbeitung und Extraktion von PDF-Dateien direkt in .NET Core-Anwendungen. Dies kann besonders in Szenarien nützlich sein, in denen Sie Berichte, Rechnungen oder andere Dokumente im PDF-Format aus Ihrer Anwendung heraus erstellen müssen.

Erste Schritte mit AppMetrics

Um plattformübergreifende App Metrics in Ihr .NET-Projekt zu integrieren, installieren Sie zunächst die AppMetrics-Bibliothek. Sie können dazu NuGet-Pakete verwenden, den Paketmanager für .NET. Führen Sie in Ihrem Projekt den folgenden Befehl in der NuGet-Paketmanager-Konsole aus:

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

Dieser Befehl fügt alle erforderlichen Abhängigkeiten zu Ihrem Projekt hinzu, so dass Sie mit der Konfiguration von AppMetrics beginnen können.

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

Im Folgenden erfahren Sie, wie Sie mit AppMetrics eine grundlegende Überwachung für HTTP-Anfragen in Ihrer .NET-Anwendung einrichten können. Erstellen Sie zunächst die Metriken in Ihrer Datei Startup.cs. Fügen Sie den folgenden Code in die Methode ConfigureServices ein:

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

Als nächstes fügen Sie in der Configure-Methode derselben Datei die AppMetrics-Middleware für die Überwachung hinzu:

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

Mit dieser Einrichtung werden automatisch Metriken über die eingehenden HTTP-Anfragen an Ihre Anwendung erfasst, z. B. die Anzahl der Anfragen, die Dauer der Anfragen und die Fehlerraten.

Funktionen von App Metrics implementieren

Aufzeichnung benutzerdefinierter Metriken

Um benutzerdefinierte Metriken zu erstellen und aufzuzeichnen oder Dinge in Ihrer Anwendung zu messen, bietet AppMetrics eine flexible Möglichkeit zu definieren, was verfolgt werden muss. Hier ein Beispiel für die 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)
    {
        _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

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

Messung der Anwendungsleistung

AppMetrics kann auch zur Messung der App-Leistung verwendet werden. Sie können zum Beispiel die Dauer einer bestimmten Methode mit Hilfe von Timern verfolgen:

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

Dieser Timer zeichnet auf, wie lange die ProcessData-Methode für die Ausführung benötigt, und gibt so Aufschluss über die Leistung von Datenbankabfragen.

Berichterstattung von Metriken an ein Dashboard

Zur Visualisierung und Überwachung Ihrer verschiedenen Metrik-Typen kann AppMetrics Daten an verschiedene Dashboards melden. So konfigurieren Sie das Reporting für ein InfluxDB Dashboard:

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

Verfolgung der Speichernutzung

Die Überwachung der Systemspeichernutzung ist für die Leistungsoptimierung von entscheidender Bedeutung. Hier erfahren Sie, wie Sie den freien Speicherplatz ermitteln können:

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

Dieses Messgerät misst den freien Speicher, der Ihrer Anwendung zur Verfügung steht, und hilft Ihnen, die Speicherverbrauchsmuster zu verstehen.

Handhabung von Metriken in bestimmten Intervallen

AppMetrics kann so konfiguriert werden, dass die Erfassung von Metriken in bestimmten Intervallen erfolgt. Dies trägt dazu bei, die Leistung aufrechtzuerhalten, ohne zu häufig Daten zu protokollieren:

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

Bei dieser Konfiguration werden die Metriken alle 60 Sekunden gemeldet, so dass eine konsistente Leistungsüberwachung gewährleistet ist, ohne das System mit einer kontinuierlichen Datenprotokollierung zu überfordern.

Integration von AppMetrics in IronPDF

Bei der Arbeit mit Metriken und der PDF-Erzeugung in Ihren C#-Anwendungen kann die Kombination von AppMetrics C# mit IronPDF von großem Nutzen sein. Mit dieser Integration können Sie direkt aus Ihren Metrikdaten Berichte im PDF-Format erstellen, die für Leistungsüberprüfungen, Kundenpräsentationen oder sogar interne Audits nützlich sind.

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. IronPDF zeichnet sich durch seine Fähigkeit aus hTML in PDF konvertierendas macht es besonders wertvoll für die Erstellung von Berichten im Internet. Diese Funktion stellt sicher, dass die visuellen Aspekte Ihrer Berichte erhalten bleiben und bietet ein hohes Maß an Wiedergabetreue von der Web- zur Druckform.

Anwendungsfall der Zusammenführung von IronPDF mit AppMetrics C#

Stellen Sie sich ein Szenario vor, in dem Sie den Beteiligten monatliche Leistungsberichte über Ihre Anwendung vorlegen müssen. Diese Berichte enthalten Metriken wie Antwortzeiten, Fehlerraten, Benutzersitzungen und mehr. Mit dem Open-Source-Programm AppMetrics C# können Sie diese Metriken nahtlos erfassen. Durch die Zusammenführung dieser Funktionalität mit IronPDF können Sie diese Metriken automatisch generieren und in einem sauber formatierten PDF-Dokument verteilen.

Code-Beispiel für einen Anwendungsfall

Nachfolgend finden Sie ein vollständiges Beispiel für die Umsetzung dieses Verfahrens. In diesem Beispiel wird davon ausgegangen, 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");

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

Diese Integration automatisiert nicht nur den Prozess der Berichtserstellung, sondern sorgt auch dafür, dass die Berichte leicht lesbar und professionell formatiert sind - perfekt für alle Stakeholder-Meetings oder Archivierungszwecke.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Kombination von AppMetrics C# mit IronPDF in Ihren .NET-Projekten eine robuste Lösung sowohl für die Überwachung der Anwendungsleistung als auch für die Erstellung hochwertiger PDF-Berichte darstellt. Diese Integration ermöglicht Ihnen den nahtlosen Übergang von der Erfassung detaillierter Leistungsdaten mit AppMetrics zur Präsentation in einem klaren, professionellen Format mit IronPDF.

IronPDF ist vor allem für C#-Entwickler von Vorteil, die PDF-Dateien in ihren Anwendungen verarbeiten möchten. Es vereinfacht die Erstellung und Bearbeitung von PDF-Dokumenten und bietet die einzigartige Möglichkeit, HTML direkt in PDF zu konvertieren. Wenn Sie erwägen, IronPDF in Ihre Projekte einzubinden, bieten sie eine kostenloser Test die Lizenzen beginnen bei 749 $ und bieten eine kostengünstige Möglichkeit, Ihre Dokumentenverarbeitungsfunktionen zu verbessern.