Logging avancé avec Prometheus pour microservices

Dans l'univers des microservices, la capacité à observer et comprendre le comportement de nos applications est cruciale. Prometheus s'est imposé comme un standard de facto pour la collecte et l'analyse des métriques dans les architectures distribuées. Cet article explore les techniques avancées de logging avec Prometheus dans un contexte .NET, en se concentrant sur les besoins spécifiques des microservices.

Fondamentaux de Prometheus pour .NET

Prometheus utilise un modèle de pull pour collecter les métriques, où le serveur Prometheus interroge régulièrement les endpoints exposés par nos applications. Dans l'écosystème .NET, nous utilisons principalement le package prometheus-net.

// Installation via NuGet
dotnet add package prometheus-net.AspNetCore

Configuration de base dans ASP.NET Core

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        
        // Configuration du middleware Prometheus
        builder.Services.AddMetrics();
        
        var app = builder.Build();
        
        // Exposition du endpoint /metrics
        app.UseMetricServer();
        app.UseHttpMetrics();
        
        app.Run();
    }
}

Types de métriques essentiels

Prometheus propose quatre types de métriques fondamentaux :

• Counter : Valeur qui ne peut qu'augmenter
• Gauge : Valeur qui peut augmenter ou diminuer
• Histogram : Distribution des valeurs
• Summary : Similar à Histogram avec des calculs côté client

Implémentation des métriques personnalisées

public class OrderMetrics
{
    private readonly Counter _orderProcessedTotal;
    private readonly Gauge _orderBacklog;
    private readonly Histogram _orderProcessingDuration;

    public OrderMetrics()
    {
        _orderProcessedTotal = Metrics.CreateCounter(
            "orders_processed_total", 
            "Total number of processed orders");
            
        _orderBacklog = Metrics.CreateGauge(
            "orders_backlog", 
            "Current number of orders in backlog");
            
        _orderProcessingDuration = Metrics.CreateHistogram(
            "order_processing_duration_seconds",
            "Time spent processing orders",
            new HistogramConfiguration
            {
                Buckets = new[] { .005, .01, .025, .05, .075, .1, .25, .5, 1, 2.5, 5, 7.5, 10 }
            });
    }
}

Labels et dimensions

Les labels permettent d'ajouter du contexte aux métriques, essentiels pour le debugging et l'analyse :

public class OrderMetricsWithLabels
{
    private readonly Counter _orderProcessedTotal;

    public OrderMetricsWithLabels()
    {
        _orderProcessedTotal = Metrics.CreateCounter(
            "orders_processed_total", 
            "Total number of processed orders",
            new CounterConfiguration
            {
                LabelNames = new[] { "status", "region" }
            });
    }
    public void RecordOrderProcessed(string status, string region)
    {
        _orderProcessedTotal.WithLabels(status, region).Inc();
    }
}

Intégration avec le Health Checking

Prometheus peut être utilisé avec le système de health checks d'ASP.NET Core :

public class PrometheusHealthCheck : IHealthCheck
{
    private readonly Gauge _healthStatus;

    public PrometheusHealthCheck()
    {
        _healthStatus = Metrics.CreateGauge(
            "app_health_status",
            "Application health status (1 = healthy, 0 = unhealthy)");
    }
    public Task CheckHealthAsync(
        HealthCheckContext context, 
        CancellationToken cancellationToken = default)
    {
        try
        {
            // Vérification de la santé de l'application
            _healthStatus.Set(1);
            return Task.FromResult(HealthCheckResult.Healthy());
        }
        catch (Exception ex)
        {
            _healthStatus.Set(0);
            return Task.FromResult(
                HealthCheckResult.Unhealthy(ex.Message));
        }
    }
}

Bonnes pratiques pour le logging avec Prometheus

• Nommez vos métriques de manière cohérente et descriptive
• Utilisez des labels avec parcimonie pour éviter l'explosion cardinale
• Documentez vos métriques avec des descriptions claires
• Implémentez des alertes basées sur des seuils significatifs
• Gardez vos endpoints /metrics sécurisés

Configuration des alertes

Exemple de règle d'alerte dans Prometheus :

groups:
- name: example
  rules:
  - alert: HighOrderBacklog
    expr: orders_backlog > 1000
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: High order backlog ({{ $value }})
      description: Order backlog has been above 1000 for 5 minutes.

Tests et validation

public class MetricsTests
{
    [Fact]
    public void OrderMetrics_ShouldIncrementCounter()
    {
        // Arrange
        var metrics = new OrderMetrics();
        var collector = new CollectorRegistry();
        
        // Act
        metrics.RecordOrderProcessed();
        
        // Assert
        var samples = collector
            .GetMetricFamily("orders_processed_total")
            .metric[0]
            .counter.value;
        Assert.Equal(1, samples);
    }
}

Considérations de performance

Pour optimiser les performances du logging avec Prometheus :

• Utilisez des métriques custom avec parcimonie
• Optimisez l'intervalle de scraping
• Implémentez du caching pour les métriques coûteuses
• Surveillez la consommation mémoire des métriques

Conclusion

Le logging avancé avec Prometheus est essentiel pour maintenir et monitorer des architectures microservices robustes. En suivant les bonnes pratiques et en utilisant les patterns appropriés, vous pouvez construire un système d'observabilité complet et performant. N'oubliez pas de toujours équilibrer la granularité des métriques avec leur impact sur les performances.