Observabilidad

​

¿Quién configura qué?

​

Lado del cliente

• Procesadores: agrupamiento, límites de memoria, filtrado, ofuscación, muestreo, etc.
• Exportadores: por ejemplo, enrutamiento dual a Prometheus
• Secretos de autenticación de clave API

​

Lado de Lerian

• Recolector Central
• Prometheus
• Loki
• Tempo
• Grafana

​

Cómo fluyen los datos

• Prometheus para métricas
• Loki para logs
• Tempo para trazas

​

Componentes del stack

​

Recolector del Cliente

​

Recolector Central

​

Prometheus

​

Loki

​

Tempo

​

Grafana

​

Recolector Integrado

otel-collector-lerian:
  enabled:true

​

Editando el Recolector del Cliente

1. Editar components/infra/grafana/otelcol-config.yaml.
2. Agregar o ajustar los bloques processors o exporters.
3. Reiniciar el stack:
   Copy

   Ask AI

   make down
   make up
   

​

Procesadores del Recolector del Cliente

• Qué es: Agrupa múltiples señales de telemetría (métricas, logs o trazas) en lotes antes de enviarlas a la siguiente etapa.
• Por qué importa: Mejora la eficiencia de compresión, reduce las solicitudes de red y mejora el rendimiento general del pipeline.
• Configuración:

processors:
  batch: {}

• Qué es: Monitorea el uso de memoria del recolector y descarta datos si se acerca a un umbral definido.
• Por qué importa: Previene que el recolector sea terminado por OOMKilled por Kubernetes.
• Configuración:

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 15

• Qué es: Genera métricas directamente de los datos de traza.
• Por qué importa: Produce métricas “RED” (Rate, Errors, Duration) automáticamente.
• Configuración:

processors:
  spanmetrics:
    metrics_exporter: prometheus
    dimensions:
      - name: http.method
      - name: http.status_code
      - name: service.name
      - name: client.id

• Qué es: Elimina atributos de span sensibles usando regex.
• Por qué importa: Mantiene identificadores, pero elimina encabezados, cuerpos u otros datos sensibles de solicitud.
• Configuración:

processors:
  transform/remove_sensitive_attributes:
    trace_statements:
      - context: span
        statements:
          - delete_matching_keys(attributes, "^app\\.request\\.(?!request_id$).*")

• Qué es: Una estrategia de muestreo aplicada después de que se reciben los spans.
• Por qué importa: Mantiene solo trazas de alto valor (errores, clientes específicos) y reduce los costos de almacenamiento.
• Configuración:

processors:
  tail_sampling:
    policies:
      - name: keep_firmino_traces_policy
      - name: http_server_errors_policy
      - name: drop_all_other_traces_policy

• Qué es: Filtra métricas a nivel de nodo.
• Por qué importa: Reduce el ruido y se enfoca en la telemetría a nivel de aplicación.
• Configuración:

processors:
  filter/drop_node_metrics:
    metrics:
      exclude:
        match_type: regexp
        metric_names:
          - ^k8s\\.node\\..*$

• Qué es: Mantiene solo métricas de midaz y midaz-plugins.
• Por qué importa: Elimina cargas de trabajo irrelevantes de Kubernetes.
• Configuración:

processors:
  filter/include_midaz_namespaces:
    metrics:
      include:
        match_type: regexp
        resource_attributes:
          - key: k8s.namespace.name
            value: '^(midaz|midaz-plugins)$'

• Qué es: Agrega metadatos de Kubernetes a la telemetría.
• Por qué importa: Habilita un contexto más rico en las consultas de Grafana.
• Configuración:

processors:
  k8sattributes:
    auth_type: "serviceAccount"
    passthrough: false
    extract:
      metadata:
        - k8s.pod.name
        - k8s.deployment.name
        - k8s.namespace.name
        - k8s.node.name

• Qué es: Inserta o actualiza client.id en la telemetría.
• Por qué importa: Crítico para multi-tenancy.
• Configuración:

processors:
  resource/add_client_id:
    attributes:
      - key: client.id
        value: "Firmino"
        action: upsert

• Qué es: Elimina el contenido del cuerpo del log.
• Por qué importa: Previene que datos sensibles o PII persistan en los logs.
• Configuración:

processors:
  transform/remove_log_body:
    log_statements:
      - context: log
        statements:
          - set(body, "")

• Qué es: Ofusca atributos seleccionados.
• Por qué importa: Protege valores sensibles (como legalDocument o accountAlias) antes de que los datos salgan de tu clúster.
• Configuración (otelcol-config.yaml):

processors:
  transform/obfuscate_attributes:
    trace_statements:
      - context: span
        statements:
          - replace_pattern(attributes["legalDocument"], ".*", "***")
          - replace_pattern(attributes["accountAlias"], ".*", "***")
    log_statements:
      - context: log
        statements:
          - replace_pattern(attributes["legalDocument"], ".*", "***")
          - replace_pattern(attributes["accountAlias"], ".*", "***")

• Personalizando los campos:
  • Por defecto: legalDocument, accountAlias
  • Agrega o elimina campos según sea necesario
  • Reinicio requerido: make down && make up

​

En resumen

​

Protegiendo datos sensibles

Responsabilidades del cliente vs Lerian en el pipeline de observabilidad

• Recolector del Cliente (tú configuras): Se ejecuta en tu clúster. Aplica procesadores como transform/remove_sensitive_attributes, transform/remove_log_body y transform/obfuscate_attributes.
• Recolector Central (administrado por Lerian): Recibe solo los flujos de telemetría filtrados y sanitizados y los enruta a Prometheus, Loki y Tempo.

​

Flujo de telemetría

1. La aplicación inicia y detecta la configuración de OpenTelemetry.
2. La telemetría se exporta al recolector del cliente local.
3. El Recolector del Cliente enriquece los datos con metadatos de Kubernetes y tu client_id.
4. Los procesadores enriquecen, filtran y transforman los datos.
5. Los datos se reenvían al recolector central.
6. El Recolector Central procesa y enruta los datos:
   • Métricas → Prometheus
   • Logs → Loki
   • Trazas → Tempo
7. Grafana te permite consultarlo todo, correlacionando entre señales.

sum(rate(http_server_duration_seconds_count{
  k8s_pod_name=~"checkout-.*",
  client_id="client-name"
}[5m]))

​

Autenticando solicitudes del recolector

​

Cómo configurarlo

1. Crea el Secret de Kubernetes para almacenar tu token API:

kubectl create secret generic otel-api-key \
  --from-literal=OTEL_API_KEY='YOUR_TOKEN_HERE' \
  -n midaz

2. Referencia el secret en tu archivo de valores de Helm para inyectarlo como una variable de entorno:

extraEnvs:
  - name: OTEL_API_KEY
    valueFrom:
      secretKeyRef:
        name: otel-api-key
        key: OTEL_API_KEY

3. La telemetría se envía de forma segura al endpoint de telemetría de Lerian sobre HTTPS, con la clave API incluida en los encabezados.

<https://telemetry.lerian.io:443>

​

Cifrado de datos en tránsito

• La comunicación entre el Recolector del Cliente y el Recolector Central está completamente cifrada.
• Los datos en tránsito están protegidos contra interceptación, manipulación o acceso no autorizado.
• Incluso si se inspecciona el tráfico de red, el contenido permanece ilegible sin las claves criptográficas apropiadas.

​

Enrutamiento dual

​

Ejemplo

exporters:
  otlphttp/server:
    endpoint: "<https://telemetry.lerian.io:443>"
    headers:
      x-api-key: "${OTEL_API_KEY}"
  prometheus/local:
    endpoint: prometheus-server-example:8889

​

Glosario