Visualizando Logs de Microservicios en Grafana

En este tutorial, aprenderemos cómo visualizar los logs generados por los microservicios de CodeDesignPlus utilizando Grafana. Explicaremos el flujo de datos desde los microservicios, a través de OpenTelemetry y Loki, hasta la visualización final en Grafana. Esto nos permitirá monitorear y analizar el comportamiento de nuestros microservicios de forma eficiente.

¿Por qué Visualizar Logs en Grafana?

La visualización de logs es fundamental para el monitoreo y la observabilidad de los microservicios. Permite:

• Detectar errores y problemas: Identificar fallos en el código, errores de configuración o problemas en la infraestructura.
• Analizar el comportamiento: Entender cómo interactúan los microservicios y cómo responden a diferentes cargas de trabajo.
• Depurar problemas: Investigar el origen de problemas y diagnosticar errores.
• Monitorear la salud: Tener una visión clara del estado y el rendimiento de los microservicios en tiempo real.

Grafana, con su capacidad para crear dashboards y visualizar datos de diferentes fuentes, es una excelente herramienta para analizar los logs de nuestros microservicios.

¿Qué Aprenderás?

1. Cómo se exportan los logs de los microservicios mediante gRPC a OpenTelemetry.
2. Cómo OpenTelemetry direcciona los logs a Loki.
3. Cómo visualizar los logs de los microservicios en Grafana.
4. Cómo realizar consultas en Loki para filtrar y analizar logs específicos.

Arquitectura de Monitoreo de Logs

El flujo de logs en nuestro entorno de microservicios sigue esta arquitectura:

1. Microservicios: Los microservicios, construidos con el framework de CodeDesignPlus, generan logs que son enviados a través de gRPC al OpenTelemetry Collector.
2. OpenTelemetry Collector: Recibe los logs de los microservicios y los direcciona a Loki. El OpenTelemetry Collector implementa el protocolo OTLP (OpenTelemetry Protocol).
3. Loki: Recibe y almacena los logs del OpenTelemetry Collector de forma eficiente.
4. Grafana: Consulta los logs almacenados en Loki y los visualiza en dashboards.

Configuración

CodeDesignPlus ya incluye la configuración necesaria para el monitoreo de logs. La librería CodeDesignPlus.Net.Logger se encarga de exportar los logs de los microservicios a OpenTelemetry, que a su vez los envía a Loki.

using Serilog.Events;

namespace CodeDesignPlus.Net.Logger.Extensions;

/// <summary>
/// Provides extension methods for adding and configuring logging services.
/// </summary>
public static class ServiceCollectionExtension
{
    /// <summary>
    /// Adds logging services to the specified IServiceCollection.
    /// </summary>
    /// <param name="services">The IServiceCollection to add the services to.</param>
    /// <param name="configuration">The configuration being bound.</param>
    /// <returns>The IServiceCollection so that additional calls can be chained.</returns>
    /// <exception cref="ArgumentNullException">Thrown when services or configuration is null.</exception>
    /// <exception cref="Exceptions.LoggerException">Thrown when the LoggerOptions section is missing.</exception>
    public static IServiceCollection AddLogger(this IServiceCollection services, IConfiguration configuration)
    {
        ArgumentNullException.ThrowIfNull(services);
        ArgumentNullException.ThrowIfNull(configuration);

        var section = configuration.GetSection(LoggerOptions.Section);

        if (!section.Exists())
            throw new Exceptions.LoggerException($"The section {LoggerOptions.Section} is required.");

        services
            .AddOptions<LoggerOptions>()
            .Bind(section)
            .ValidateDataAnnotations();

        services.AddCore(configuration);

        return services;
    }

    /// <summary>
    /// Configures Serilog for the specified IHostBuilder.
    /// </summary>
    /// <param name="builder">The IHostBuilder to configure.</param>
    /// <param name="configureLogger">An optional action to configure the LoggerConfiguration.</param>
    /// <returns>The IHostBuilder so that additional calls can be chained.</returns>
    /// <exception cref="ArgumentNullException">Thrown when builder is null.</exception>
    public static IHostBuilder UseSerilog(this IHostBuilder builder, Action<LoggerConfiguration> configureLogger = null)
    {
        builder.UseSerilog((context, services, configuration) =>
        {
            var coreOptions = services.GetRequiredService<IOptions<CoreOptions>>();
            var environment = services.GetRequiredService<IHostEnvironment>();
            var loggerOptions = context.Configuration.GetRequiredSection(LoggerOptions.Section).Get<LoggerOptions>();

            var levelLogger = ConvertToSerilogLevel(loggerOptions.Level);

            configuration
                .ReadFrom.Configuration(context.Configuration)
                .ReadFrom.Services(services)
                .Enrich.FromLogContext()
                .Enrich.WithMachineName()
                .Enrich.WithThreadId()
                .Enrich.WithThreadName()
                .Enrich.WithProcessId()
                .Enrich.WithProcessName()
                .Enrich.WithEnvironmentUserName()
                .Enrich.WithProperty("AppName", $"{coreOptions.Value.AppName}-{coreOptions.Value.TypeEntryPoint}")
                .Enrich.WithExceptionDetails(new DestructuringOptionsBuilder()
                    .WithDefaultDestructurers()
                    .WithDestructurers([new DbUpdateExceptionDestructurer()])
                )
                .Enrich.With(new ExceptionEnricher())
                .MinimumLevel.Is(levelLogger);

            if(environment.IsDevelopment())
                configuration.WriteTo.Console(restrictedToMinimumLevel: levelLogger);

            if (loggerOptions.Enable)
            {
                configuration.WriteTo.OpenTelemetry(options =>
                {
                    options.Endpoint = loggerOptions.OTelEndpoint;
                    options.Protocol = OtlpProtocol.Grpc;

                    options.IncludedData =
                        IncludedData.SpanIdField
                        | IncludedData.TraceIdField
                        | IncludedData.MessageTemplateTextAttribute
                        | IncludedData.MessageTemplateMD5HashAttribute;

                    options.BatchingOptions.BatchSizeLimit = 10;
                    options.BatchingOptions.QueueLimit = 10;

                    options.ResourceAttributes = new Dictionary<string, object>
                    {
                        { "service.name", coreOptions.Value.AppName },
                        { "service.version", coreOptions.Value.Version },
                        { "service.description", coreOptions.Value.Description },
                        { "service.business", coreOptions.Value.Business },
                        { "service.contact.name", coreOptions.Value.Contact.Name },
                        { "service.contact.email", coreOptions.Value.Contact.Email }
                    };
                });
            }

            configureLogger?.Invoke(configuration);
        });

        return builder;
    }

    /// <summary>
    /// Converts a string log level to a Serilog LogEventLevel.
    /// </summary>
    /// <param name="logLevel">The string representation of the log level.</param>
    /// <returns>The corresponding Serilog LogEventLevel.</returns>
    private static LogEventLevel ConvertToSerilogLevel(string logLevel)
    {
        if(string.IsNullOrEmpty(logLevel))
            return LogEventLevel.Error;

        return Enum.Parse<LogEventLevel>(logLevel);
    }
}

Pasos para la Visualización de Logs en Grafana

1. Asegúrate de que los Microservicios estén en Ejecución: Verifica que los microservicios, OpenTelemetry Collector, Loki y Grafana estén en ejecución. El microservicio puede ser ejecutado de forma local o en un contenedor Docker.

   

2. Accede a Grafana: Abre un navegador y ve a la URL http://localhost:3000 (o la dirección donde se está ejecutando Grafana).

   

3. Explora los Logs: En la barra de navegación de Grafana, haz clic en Explore (icono de la brújula) y selecciona la fuente de datos de Loki. Esto te llevará al editor de consultas de Loki, donde puedes escribir queries para filtrar y analizar los logs.

   

4. Realiza Consultas en Loki: En el editor de consultas, puedes escribir queries de LogQL para filtrar y analizar los logs. Algunos ejemplos incluyen:

   • Para ver logs de un microservicio específico (por ejemplo, ms-clients): {service_name="ms-clients"}.
   • Para filtrar logs por nivel (por ejemplo, Error): {level="Error"}.
   • Para ver logs que contengan una palabra clave específica (por ejemplo, “excepción”): {message=~"excepción"}.
   

5. Visualiza los Logs: Una vez que tienes la consulta configurada, puedes visualizar los logs en la parte inferior de la pantalla. Grafana muestra los logs en un formato de texto y proporciona herramientas para filtrar, organizar y analizar los datos.

   

6. Crea Dashboards: Para un monitoreo continuo, puedes crear paneles en Grafana que muestren los logs de forma permanente. Crea un nuevo dashboard y añade un panel con la fuente de datos de Loki y las queries que necesites.

   

   Note

   Para obtener más información sobre cómo crear dashboards en Grafana, consulta la documentación oficial.

Conclusiones

En este tutorial, hemos aprendido cómo visualizar los logs de los microservicios de CodeDesignPlus utilizando Grafana. Hemos comprendido el flujo de datos desde los microservicios, a través de OpenTelemetry y Loki, hasta la visualización final en Grafana. Ahora, puedes utilizar Grafana para monitorear y analizar los logs de tus microservicios, lo que te permitirá detectar problemas, diagnosticar errores y optimizar el rendimiento.

Esta configuración proporciona una base sólida para la observabilidad de tus microservicios y facilita la gestión de la salud de tu sistema.