Appmetrics C# (Cómo Funciona para Desarrolladores)

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

Aquí tienes cómo configurar el monitoreo básico para solicitudes HTTP en tu aplicación .NET usando 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(); // 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
}

A continuación, en el método Configure del mismo archivo, asegúrate de añadir el middleware AppMetrics para manejar el monitoreo:

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
}

Esta configuración comienza automáticamente a capturar métricas sobre las solicitudes HTTP entrantes a tu aplicación, como la cantidad de solicitudes, la duración de las solicitudes y las tasas de error.

Grabación de métricas personalizadas

Para crear y registrar métricas personalizadas o medir elementos en tu aplicación, AppMetrics ofrece una forma flexible de definir lo que necesita seguimiento. Ejemplo de registrar un contador para inicios de sesión:

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

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

Medición del rendimiento de las aplicaciones

AppMetrics también se puede usar para medir el rendimiento de la aplicación. Por ejemplo, puedes seguir la duración de un método específico usando temporizadores:

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
    }
}

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

Información de métricas en un panel de control

Para visualizar y monitorear tus varios tipos de métricas, AppMetrics puede informar datos a diferentes tableros. Aquí te mostramos cómo puedes configurar la información a un tablero de InfluxDB:

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

Seguimiento del uso de memoria

Monitorear el uso de memoria del sistema es crucial para ajustar el rendimiento. Así puedes rastrear la memoria libre:

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
}

Este medidor mide la memoria libre disponible para tu aplicación, ayudándote a entender los patrones de consumo de memoria.

Manejo de métricas en intervalos especificados

AppMetrics se puede configurar para manejar la recopilación de métricas en 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>(); // 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
}

Esta configuración establece que las métricas se informen cada 60 segundos, asegurando un monitoreo de rendimiento consistente sin abrumar al sistema con un registro continuo de datos.

Introducción a IronPDF

IronPDF es una biblioteca integral que permite a los desarrolladores crear, leer y editar documentos PDF usando C#. Lo que distingue a IronPDF es su capacidad para convertir HTML a PDF con IronPDF, lo que lo hace particularmente valioso para la generación de informes basados en la web. Esta capacidad asegura que los aspectos visuales de tus informes se preserven, ofreciendo un alto grado de fidelidad del formato web al de impresión.

Caso de uso de la fusión de IronPDF con AppMetrics C#

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

Ejemplo de código del caso de uso

A continuación se muestra un ejemplo completo de cómo implementar esto. Este ejemplo asume que ya has configurado tanto IronPDF como AppMetrics C# en tu 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");

Esta integración no solo automatiza el proceso de generación de informes, sino que también asegura que los informes sean fácilmente legibles y profesionalmente formateados, perfectos para cualquier reunión de partes interesadas o propósitos de archivo.