Sistemas de Logs e Monitoramento para .NET Senior

📋 Visão Geral

Sistemas de logs e monitoramento são fundamentais para observabilidade em aplicações modernas. Eles permitem coletar, analisar e visualizar dados de performance, logs e métricas para garantir a saúde e performance dos sistemas.

🏗️ Tipos de Sistemas

1. Sistemas de Monitoramento de Infraestrutura

Zabbix

O que é: Sistema de monitoramento de infraestrutura open-source.

Características:

• Monitoramento: Servidores, redes, aplicações
• Coleta: SNMP, agentes, HTTP checks
• Alertas: Email, SMS, webhooks
• Dashboards: Personalizáveis
• Escalabilidade: Alta com proxy

Funcionalidades:

• Auto-discovery: Descoberta automática de dispositivos
• Templates: Configurações reutilizáveis
• Triggers: Condições para alertas
• Actions: Ações automáticas
• Reports: Relatórios detalhados

Quando usar:

• Monitoramento de infraestrutura on-premise
• Quando precisa de controle total
• Sistemas com orçamento limitado
• Monitoramento de redes complexas

// Exemplo: Integração com Zabbix via API
public class ZabbixClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiUrl;
    private readonly string _authToken;
    
    public ZabbixClient(string apiUrl, string username, string password)
    {
        _httpClient = new HttpClient();
        _apiUrl = apiUrl;
        _authToken = Authenticate(username, password);
    }
    
    public async Task SendMetricAsync(string host, string key, string value)
    {
        var request = new
        {
            jsonrpc = "2.0",
            method = "item.create",
            params = new
            {
                name = key,
                key_ = key,
                hostid = await GetHostIdAsync(host),
                type = 2, // Zabbix agent
                value_type = 3, // Numeric unsigned
                interfaceid = await GetInterfaceIdAsync(host)
            },
            auth = _authToken,
            id = 1
        };
        
        var response = await _httpClient.PostAsJsonAsync($"{_apiUrl}/api_jsonrpc.php", request);
        response.EnsureSuccessStatusCode();
    }
}

Nagios

O que é: Sistema de monitoramento de infraestrutura clássico.

Características:

• Plugin-based: Extensível via plugins
• Configuração: Baseada em arquivos
• Alertas: Flexíveis e customizáveis
• Escalabilidade: Média

Quando usar:

• Sistemas legacy
• Quando precisa de controle granular
• Monitoramento simples

2. Sistemas de Visualização e Dashboards

Grafana

O que é: Plataforma de visualização e analytics de dados.

Características:

• Data Sources: Múltiplas fontes de dados
• Dashboards: Altamente customizáveis
• Alerting: Sistema de alertas integrado
• Plugins: Extensível via plugins
• Templates: Dashboards reutilizáveis

Funcionalidades:

• Queries: Linguagem de consulta por data source
• Variables: Variáveis dinâmicas
• Annotations: Marcações temporais
• Export: Exportação de dashboards
• Sharing: Compartilhamento de dashboards

Quando usar:

• Visualização de métricas de qualquer fonte
• Dashboards operacionais
• Analytics de dados temporais
• Monitoramento de aplicações

// Exemplo: Enviando métricas para Grafana via Prometheus
public class PrometheusMetrics
{
    private readonly Counter _requestCounter;
    private readonly Histogram _responseTimeHistogram;
    private readonly Gauge _activeConnections;
    
    public PrometheusMetrics()
    {
        _requestCounter = Metrics.CreateCounter("http_requests_total", "Total HTTP requests", 
            new CounterConfiguration
            {
                LabelNames = new[] { "method", "endpoint", "status" }
            });
            
        _responseTimeHistogram = Metrics.CreateHistogram("http_request_duration_seconds", 
            "HTTP request duration", new HistogramConfiguration
            {
                LabelNames = new[] { "method", "endpoint" }
            });
            
        _activeConnections = Metrics.CreateGauge("active_connections", "Active connections");
    }
    
    public void RecordRequest(string method, string endpoint, int statusCode)
    {
        _requestCounter.WithLabels(method, endpoint, statusCode.ToString()).Inc();
    }
    
    public IDisposable MeasureRequestDuration(string method, string endpoint)
    {
        return _responseTimeHistogram.WithLabels(method, endpoint).NewTimer();
    }
    
    public void SetActiveConnections(int count)
    {
        _activeConnections.Set(count);
    }
}

3. APM (Application Performance Monitoring)

Datadog

O que é: Plataforma de observabilidade em nuvem.

Características:

• APM: Distributed tracing automático
• Infrastructure: Monitoramento de infraestrutura
• Logs: Centralização e análise de logs
• Synthetic: Testes sintéticos
• Real User Monitoring: Performance do usuário final

Funcionalidades:

• Auto-instrumentation: Instrumentação automática
• Service Map: Mapa de serviços
• Anomaly Detection: Detecção de anomalias
• Correlation: Correlação entre logs, traces e métricas
• Machine Learning: Insights automáticos

Quando usar:

• Aplicações em nuvem
• Microservices complexos
• Quando precisa de observabilidade completa
• Sistemas distribuídos

// Exemplo: Integração com Datadog APM
public class DatadogTracing
{
    private readonly IDatadogTracer _tracer;
    
    public DatadogTracing(IDatadogTracer tracer)
    {
        _tracer = tracer;
    }
    
    public async Task<Order> CreateOrderAsync(CreateOrderRequest request)
    {
        using var scope = _tracer.StartActiveSpan("order.create");
        
        try
        {
            scope.Span.SetTag("customer.id", request.CustomerId);
            scope.Span.SetTag("order.total", request.Total);
            
            var order = await _orderService.CreateAsync(request);
            
            scope.Span.SetTag("order.id", order.Id);
            return order;
        }
        catch (Exception ex)
        {
            scope.Span.SetTag("error", true);
            scope.Span.SetTag("error.message", ex.Message);
            throw;
        }
    }
}

Dynatrace

O que é: Plataforma de observabilidade enterprise.

Características:

• AI-powered: Inteligência artificial integrada
• Full-stack: Monitoramento completo da stack
• Auto-discovery: Descoberta automática de dependências
• Root Cause Analysis: Análise automática de causa raiz
• Cloud-native: Otimizado para cloud

Funcionalidades:

• OneAgent: Agente único para toda a stack
• Davis AI: IA para análise de problemas
• Service Flow: Visualização de fluxo de serviços
• Smartscape: Mapa dinâmico da infraestrutura
• Session Replay: Reprodução de sessões

Quando usar:

• Aplicações enterprise
• Quando precisa de análise automática
• Sistemas complexos
• Quando orçamento não é limitante

// Exemplo: Custom metrics com Dynatrace
public class DynatraceMetrics
{
    private readonly IDynatraceClient _dynatraceClient;
    
    public DynatraceMetrics(IDynatraceClient dynatraceClient)
    {
        _dynatraceClient = dynatraceClient;
    }
    
    public async Task SendCustomMetricAsync(string metricName, double value, Dictionary<string, string> dimensions = null)
    {
        var metric = new CustomMetric
        {
            Name = metricName,
            Value = value,
            Timestamp = DateTimeOffset.UtcNow,
            Dimensions = dimensions ?? new Dictionary<string, string>()
        };
        
        await _dynatraceClient.SendCustomMetricAsync(metric);
    }
    
    public async Task RecordBusinessTransactionAsync(string transactionName, TimeSpan duration)
    {
        await SendCustomMetricAsync("business.transaction.duration", duration.TotalMilliseconds, 
            new Dictionary<string, string> { ["transaction"] = transactionName });
    }
}

4. Sistemas de Logs

ELK Stack (Elasticsearch, Logstash, Kibana)

O que é: Stack completo para coleta, processamento e visualização de logs.

Componentes:

• Elasticsearch: Motor de busca e armazenamento
• Logstash: Processamento e transformação de logs
• Kibana: Visualização e análise
• Beats: Agentes de coleta de dados

Características:

• Scalability: Altamente escalável
• Search: Busca poderosa
• Analytics: Análise avançada de logs
• Visualization: Dashboards ricos
• Alerting: Sistema de alertas

Quando usar:

• Logs de alta volume
• Análise complexa de logs
• Quando precisa de busca avançada
• Centralização de logs

// Exemplo: Structured logging para ELK
public class ElasticsearchLogger
{
    private readonly ILogger<ElasticsearchLogger> _logger;
    
    public ElasticsearchLogger(ILogger<ElasticsearchLogger> logger)
    {
        _logger = logger;
    }
    
    public void LogOrderCreated(Order order)
    {
        _logger.LogInformation("Order created {@Order}", new
        {
            order.Id,
            order.CustomerId,
            order.Total,
            order.Status,
            order.CreatedAt,
            Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"),
            Service = "OrderService"
        });
    }
    
    public void LogError(Exception ex, string operation, object context = null)
    {
        _logger.LogError(ex, "Error in {Operation} {@Context}", operation, context);
    }
}

Seq

O que é: Sistema de logs estruturados para .NET.

Características:

• Structured Logging: Logs estruturados nativos
• .NET Native: Otimizado para .NET
• Query Language: Linguagem de consulta SQL-like
• Real-time: Visualização em tempo real
• Alerts: Sistema de alertas integrado

Funcionalidades:

• Live Tail: Visualização em tempo real
• Dashboards: Dashboards customizáveis
• API: API REST para integração
• Plugins: Extensível via plugins
• Multi-tenancy: Suporte a múltiplos tenants

Quando usar:

• Aplicações .NET
• Quando precisa de logs estruturados
• Desenvolvimento local
• Sistemas pequenos a médios

// Exemplo: Structured logging com Seq
public class SeqLogger
{
    private readonly ILogger<SeqLogger> _logger;
    
    public SeqLogger(ILogger<SeqLogger> logger)
    {
        _logger = logger;
    }
    
    public void LogUserAction(string userId, string action, object data)
    {
        _logger.LogInformation("User {UserId} performed {Action} {@Data}", 
            userId, action, data);
    }
    
    public void LogPerformance(string operation, TimeSpan duration, object context = null)
    {
        _logger.LogInformation("Performance: {Operation} took {Duration}ms {@Context}", 
            operation, duration.TotalMilliseconds, context);
    }
}

5. Sistemas de Métricas

Prometheus

O que é: Sistema de coleta e armazenamento de métricas.

Características:

• Pull-based: Coleta por pull
• Time Series: Banco de dados de séries temporais
• PromQL: Linguagem de consulta
• Alertmanager: Sistema de alertas
• Service Discovery: Descoberta automática de serviços

Funcionalidades:

• Scraping: Coleta automática de métricas
• Recording Rules: Regras de agregação
• Grafana Integration: Integração com Grafana
• Exporters: Exportadores para diversos sistemas
• High Availability: Alta disponibilidade

Quando usar:

• Monitoramento de containers
• Kubernetes
• Microservices
• Métricas de infraestrutura

// Exemplo: Métricas customizadas com Prometheus
public class PrometheusMetrics
{
    private readonly Counter _orderCounter;
    private readonly Histogram _orderValueHistogram;
    private readonly Gauge _activeUsers;
    
    public PrometheusMetrics()
    {
        _orderCounter = Metrics.CreateCounter("orders_total", "Total orders", 
            new CounterConfiguration
            {
                LabelNames = new[] { "status", "customer_type" }
            });
            
        _orderValueHistogram = Metrics.CreateHistogram("order_value", "Order values", 
            new HistogramConfiguration
            {
                LabelNames = new[] { "customer_type" }
            });
            
        _activeUsers = Metrics.CreateGauge("active_users", "Active users");
    }
    
    public void RecordOrder(Order order)
    {
        _orderCounter.WithLabels(order.Status, order.CustomerType).Inc();
        _orderValueHistogram.WithLabels(order.CustomerType).Observe(order.Total);
    }
    
    public void SetActiveUsers(int count)
    {
        _activeUsers.Set(count);
    }
}

📊 Comparação de Sistemas

Sistema	Tipo	Escalabilidade	Complexidade	Custo	Melhor Para
Zabbix	Infrastructure Monitoring	Alta	Média	Baixo	Infraestrutura on-premise
Grafana	Visualization	Alta	Baixa	Baixo	Dashboards e visualização
Datadog	APM	Muito Alta	Baixa	Alto	Cloud e microservices
Dynatrace	APM	Muito Alta	Baixa	Muito Alto	Enterprise
ELK Stack	Logging	Muito Alta	Alta	Médio	Logs complexos
Seq	Logging	Média	Baixa	Baixo	Aplicações .NET
Prometheus	Metrics	Alta	Média	Baixo	Containers e microservices

🔧 Implementação em .NET

Configuração de Logging Estruturado

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging(builder =>
        {
            builder.AddSeq(Configuration.GetSection("Seq"));
            builder.AddElasticsearch(Configuration.GetSection("Elasticsearch"));
            builder.AddConsole();
        });
    }
}

Middleware de Logging

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;
    
    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        
        try
        {
            await _next(context);
        }
        finally
        {
            sw.Stop();
            
            _logger.LogInformation(
                "Request {Method} {Path} => {StatusCode} in {Elapsed}ms",
                context.Request.Method,
                context.Request.Path,
                context.Response.StatusCode,
                sw.ElapsedMilliseconds);
        }
    }
}

Health Checks

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHealthChecks()
            .AddCheck("database", () => CheckDatabase())
            .AddCheck("external-api", () => CheckExternalApi())
            .AddPrometheusGatewayPublisher();
    }
    
    private HealthCheckResult CheckDatabase()
    {
        try
        {
            // Verificar conexão com banco
            return HealthCheckResult.Healthy();
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    }
}

⚠️ Considerações Importantes

Performance

• Sampling: Use sampling para logs de alta frequência
• Buffering: Implemente buffering para métricas
• Compression: Comprima logs para economizar espaço
• Retention: Configure políticas de retenção

Segurança

• Encryption: Criptografe dados sensíveis
• Authentication: Implemente autenticação
• Authorization: Controle de acesso granular
• Audit: Logs de auditoria

Operacional

• Alerting: Configure alertas adequados
• Escalation: Políticas de escalação
• Documentation: Documente dashboards e alertas
• Training: Treine equipe no uso das ferramentas

📚 Recursos Adicionais

Ferramentas

• Jaeger: Distributed tracing
• Zipkin: Distributed tracing
• Fluentd: Coleta de logs
• Telegraf: Coleta de métricas
• Alertmanager: Gerenciamento de alertas

Libraries .NET

• Serilog: Structured logging
• NLog: Logging framework
• OpenTelemetry: Observability
• Prometheus.NET: Métricas Prometheus
• Datadog.Trace: APM Datadog

Livros Recomendados

• "Observability Engineering"
• "The Site Reliability Workbook"
• "Monitoring Distributed Systems"
• "Effective Monitoring and Alerting"