Counter Metrics: Introducción a las Métricas con Dinaup.Logs en C#
Las Counter Metrics son métricas de tipo contador que representan un valor que solo puede incrementarse. Son ideales para contar eventos como solicitudes API, archivos procesados, errores ocurridos, entre otros. A diferencia de otras métricas, los contadores no decrecen, lo que facilita el seguimiento de la acumulación de eventos a lo largo del tiempo.
Ventajas de Utilizar Counter Metrics
Simplicidad: Fácil de implementar y entender.
Eficiencia: Baja sobrecarga en el rendimiento de la aplicación.
Visibilidad: Proporciona una visión clara de la cantidad de eventos específicos.
Escalabilidad: Adecuado para aplicaciones que manejan grandes volúmenes de eventos.
Configuración Inicial
Antes de comenzar, asegúrate de tener la librería Dinaup.Logs instalada en tu proyecto. Puedes agregarla mediante NuGet:
Install-Package Dinaup.Logs
Implementación de Counter Metrics
A continuación, se muestra cómo implementar y utilizar las Counter Metrics en una aplicación C#.
1. Importar el Espacio de Nombres
Primero, incluye el espacio de nombres necesario para acceder a las funcionalidades de Dinaup.Logs.
using Dinaup.Logs;
2. Crear y Utilizar una Counter Metric
Supongamos que queremos contar la cantidad de archivos subidos a nuestro sistema. Podemos implementar una Counter Metric de la siguiente manera:
public class FileUploadService
{
// Se recomienda declarar la métrica como estática si se reutiliza continuamente
private static readonly CounterMetric FilesUploadedCounter = new CounterMetric("FilesUploaded");
public void UploadFile(string filePath)
{
// Lógica para subir el archivo
// ...
// Incrementar el contador cada vez que se sube un archivo
FilesUploadedCounter.Increment();
}
}
3. Counter Metrics con Etiquetas (Tags)
Las etiquetas permiten segmentar las métricas, proporcionando mayor granularidad en el análisis. Por ejemplo, contar las llamadas a una API por usuario:
public class ApiService
{
public void CallApi(string user)
{
// Lógica para llamar a la API
// ...
// Crear una métrica con etiquetas
using var apiCallCounter = new CounterMetric(
name: "ApiCalls",
metricType: "request",
initialValue: 0,
tags: new Dictionary<string, string> { { "user", user } }
);
// Incrementar el contador
apiCallCounter.Increment();
// Enviar las métricas
MetricExporter.Flush();
}
}
MetricsManager
Para administrar las métricas de manera eficiente y evitar la creación y destrucción frecuente de instancias, se puede utilizar un MetricsManager. A continuación, se presenta un ejemplo de implementación:
using Dinaup.Logs;
using System.Collections.Concurrent;
public static class MetricsManager
{
// Diccionario concurrente para métricas por usuario
private static readonly ConcurrentDictionary<string, CounterMetric> ApiCallCounters = new ConcurrentDictionary<string, CounterMetric>();
// Métrica estática global
public static readonly CounterMetric FilesUploaded = new CounterMetric("FilesUploaded");
/// <summary>
/// Obtiene la métrica de llamadas API para un usuario específico.
/// </summary>
public static CounterMetric GetApiCallCounter(string user)
{
return ApiCallCounters.GetOrAdd(user, u => new CounterMetric(
name: "ApiCalls",
metricType: "request",
initialValue: 0,
tags: new Dictionary<string, string> { { "user", u } }
));
}
/// <summary>
/// Libera todos los recursos de las métricas.
/// </summary>
public static void DisposeAll()
{
foreach (var counter in ApiCallCounters.Values)
{
counter.Dispose();
}
FilesUploaded.Dispose();
}
}