Appmetrics C# (Cómo funciona para desarrolladores)

AppMetrics C# es una potente herramienta diseñada para agilizar la supervisión y el análisis del rendimiento de las aplicaciones. Con App Metrics abstracts, simplifica la complejidad que implica el seguimiento de diversos aspectos de su aplicación. Tanto si utiliza .NET Core como .NET Framework, esta biblioteca .NET le permite registrar tipos de métricas de forma eficaz. Puede recuperar métricas y utilizar los tipos de métricas admitidos por App Metrics para obtener información exhaustiva.

La biblioteca .NET admite la recuperación de métricas y permite vaciar las métricas en un intervalo especificado, lo que garantiza la recopilación puntual de los datos. También ofrece un método de ampliación, que proporciona puntos de extensibilidad para una mayor flexibilidad. Como solución multiplataforma, AppMetrics es adecuada para diversos entornos y garantiza una supervisión coherente del rendimiento.

IronPDF: Librería PDF avanzada para desarrolladores C# es otra biblioteca esencial para los desarrolladores de C#, especialmente cuando trabajan con documentos PDF. Permite crear, editar y extraer archivos PDF directamente dentro de aplicaciones .NET Core. Esto puede ser especialmente útil en situaciones en las que necesite generar informes, facturas o cualquier otro documento en formato PDF desde su aplicación.

Primeros pasos con AppMetrics

Para integrar App Metrics multiplataforma en su proyecto .NET, comience por instalar la biblioteca AppMetrics. Puede hacerlo utilizando los paquetes NuGet, el gestor de paquetes para .NET. En su proyecto, ejecute el siguiente comando en la consola del gestor de paquetes 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

Este comando añade todas las dependencias necesarias a su proyecto, permitiéndole empezar a configurar AppMetrics.

Un ejemplo de código básico: Monitorización de peticiones HTTP

A continuación le mostramos cómo puede configurar la monitorización básica de peticiones HTTP en su aplicación .NET utilizando AppMetrics. Primero, construye las métricas en tu archivo Startup.cs. Añade el siguiente código al método 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

A continuación, en el método Configure del mismo archivo, asegúrese de añadir el middleware AppMetrics para gestionar la monitorización:

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

Esta configuración inicia automáticamente la captura de métricas sobre las peticiones HTTP entrantes a su aplicación, como el recuento de peticiones, la duración de las peticiones y las tasas de error.

Implementar funciones de App Metrics

Grabación de métricas personalizadas

Para crear y registrar métricas personalizadas o medir cosas en su aplicación, AppMetrics proporciona una forma flexible de definir lo que necesita seguimiento. A continuación se muestra un ejemplo de grabación de un contador sencillo para realizar un seguimiento de los inicios de sesión de los usuarios:

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

En este código, cada vez que se llama a TrackLogin, el contador de inicios de sesión aumenta para el ID de usuario especificado.

Medición del rendimiento de las aplicaciones

AppMetrics también puede utilizarse para medir el rendimiento de las aplicaciones. Por ejemplo, puede controlar la duración de un método específico utilizando temporizadores:

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

Este temporizador registra el tiempo que tarda en ejecutarse el método ProcessData, proporcionando información sobre el rendimiento de las consultas a la base de datos.

Informes de métricas en un cuadro de mando

Para visualizar y monitorizar sus diferentes tipos de métricas, AppMetrics puede reportar datos a diferentes cuadros de mando. A continuación se explica cómo configurar la generación de informes para un cuadro de mando de 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

Seguimiento del uso de la memoria

Supervisar el uso de la memoria del sistema es crucial para ajustar el rendimiento. A continuación te explicamos cómo puedes hacer un seguimiento de la memoria 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

Este indicador mide la memoria libre disponible para su aplicación, ayudándole a comprender los patrones de consumo de memoria.

Manejo de métricas en intervalos especificados

AppMetrics puede configurarse para gestionar la recopilación de métricas a intervalos especificados. Esto ayuda a mantener el rendimiento sin registrar datos con demasiada frecuencia:

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

Esta configuración establece que las métricas se notifiquen cada 60 segundos, lo que garantiza una supervisión coherente del rendimiento sin abrumar al sistema con un registro continuo de datos.

Integración de AppMetrics con IronPDF

Cuando trabaje con métricas y generación de PDF en sus aplicaciones C#, combinar AppMetrics C# con IronPDF puede ser muy beneficioso. Esta integración le permite generar informes en formato PDF directamente a partir de los datos de sus métricas, lo que resulta útil para revisiones de rendimiento, presentaciones a clientes o incluso auditorías internas.

Introducción a IronPDF

IronPDF es una completa biblioteca que permite a los desarrolladores crear, leer y editar documentos PDF utilizando C#. Lo que diferencia a IronPDF es su capacidad paraconvertir HTML a PDF con IronPDFpor lo que resulta especialmente útil para generar informes a través de Internet. Esta capacidad garantiza la conservación de los aspectos visuales de sus informes, ofreciendo un alto grado de fidelidad de la web a la forma impresa.

Caso práctico de fusión de IronPDF con AppMetrics C#

Considere un escenario en el que necesita proporcionar informes mensuales de rendimiento de su aplicación a las partes interesadas. Estos informes incluyen métricas como tiempos de respuesta, tasas de error, sesiones de usuario, etc. Con AppMetrics C# de código abierto, puede capturar estas métricas sin problemas. Al fusionar esta funcionalidad con IronPDF, puede generar y distribuir automáticamente estas métricas en un documento PDF con un formato ordenado.

Ejemplo de código del caso de uso

A continuación se muestra un ejemplo completo de cómo ponerlo en práctica. Este ejemplo asume que usted ya ha configurado tanto IronPDF como AppMetrics C# en su proyecto.

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

Esta integración no sólo automatiza el proceso de generación de informes, sino que también garantiza que los informes sean fácilmente legibles y tengan un formato profesional, perfecto para cualquier reunión con las partes interesadas o con fines de archivo.

Conclusión

En resumen, combinar AppMetrics C# con IronPDF en sus proyectos .NET proporciona una solución robusta tanto para monitorizar el rendimiento de las aplicaciones como para generar informes PDF de alta calidad. Esta integración le permite pasar sin problemas de capturar datos detallados de rendimiento con AppMetrics a presentarlos en un formato claro y profesional mediante IronPDF.

IronPDF es especialmente beneficioso para los desarrolladores de C# que deseen manejar archivos PDF en sus aplicaciones. Simplifica la creación y manipulación de documentos PDF y ofrece una capacidad única para convertir HTML directamente a PDF. Si está pensando en incorporar IronPDF a sus proyectos, ofrecen unaprueba gratuita de IronPDFpara comenzar, y las licencias comienzan en $749, proporcionando una forma rentable de mejorar tus capacidades de manejo de documentos.