Saltar al contenido principal

📊 Guía Completa de Dashboards en OpenObserve

Esta guía te ayudará a configurar dashboards y alertas en OpenObserve basándote en los streams y métricas que ya están implementados en Floutic.

📋 Índice​

Para Principiantes​

  1. Tutorial Paso a Paso
  2. Verificación Previa
  3. ¿Por qué no hay nada en "Métricas"?

Guía Completa​

  1. Métricas de Negocio Disponibles
  2. Streams Disponibles
  3. Dashboard de Métricas de API
  4. Dashboard de Métricas de Negocio
  5. Dashboard de Infraestructura
  6. Dashboard de Seguridad
  7. Dashboard de Errores
  8. Configuración de Alertas
  9. Queries Útiles
  10. Dashboards Recomendados por Rol
  11. Tips y Mejores Prácticas

🎯 Tutorial Paso a Paso: Crear tu Primer Dashboard​

Objetivo​

Crear un dashboard simple que muestre:

  1. Requests por minuto (gráfico de línea)
  2. Tiempo de respuesta promedio (número grande)
  3. Distribución de status codes (gráfico de pastel)

⚡ Inicio Rápido (5 minutos)​

Si solo quieres verificar que puedes crear un dashboard básico:

  1. Accede a OpenObserve: https://oo.haorp.es
  2. Inicia sesión: root@example.com / openobserve_pass123
  3. Ve a Dashboards → "New Dashboard"
  4. Nombre: Test Dashboard
  5. Añade un panel → "Line Chart"
  6. Query simple: SELECT * FROM "api-metrics-stream" LIMIT 10
  7. Stream: api-metrics-stream
  8. Guarda el panel

Si esto funciona, continúa con el tutorial completo. Si no, revisa la sección de "Solución de Problemas".

✅ Verificación Previa (Antes de Empezar)​

Antes de crear el dashboard, verifica que todo está funcionando:

Verificar que OpenObserve está corriendo​

# Verificar que el contenedor está corriendo
docker-compose ps | grep openobserve

# Deberías ver algo como:
# openobserve    Up X minutes   0.0.0.0:5080->5080/tcp

Verificar que hay datos en los streams​

  1. Accede a OpenObserve: https://oo.haorp.es
  2. Inicia sesión
  3. Ve a "Logs" (en el menú lateral)
  4. Selecciona el stream: api-metrics-stream
  5. Haz clic en "Run" o "Search"
  6. Si ves resultados: ✅ Perfecto, puedes continuar
  7. Si no ves resultados:
    • Genera tráfico en la aplicación (haz algunas peticiones HTTP a la API)
    • Espera 1-2 minutos (las métricas se agregan cada minuto)
    • O verifica que el backend está enviando métricas

Generar Datos de Prueba (si no hay datos)​

Si no hay datos, puedes generar algunos haciendo peticiones a la API:

# Desde tu máquina local o servidor
# Hacer algunas peticiones a la API para generar métricas
curl https://api.tu-dominio.com/api/v1/health
curl https://api.tu-dominio.com/api/v1/projects
# etc.

O simplemente navega por la aplicación web, lo que generará métricas automáticamente.

❓ ¿Por qué no hay nada en "Métricas"?​

Es completamente normal ✅​

Si ves que tienes streams en "Logs" pero no hay nada en "Métricas", esto es completamente normal y esperado. Aquí te explicamos por qué:

¿Qué estás viendo?​

En OpenObserve, cuando accedes a "Streams" o "Transmisiones", verás algo como:

📊 Registros (Logs):
  01  _rumdata                  logs  7        0.01 MB
  02  _rumlog                   logs  1129     1.38 MB
  03  api_metrics_stream        logs  404      0.13 MB
  04  backend_stream            logs  120      0.03 MB
  05  frontend_logs             logs  26.922   6.75 MB
  06  frontend_stream           logs  69       0.02 MB

📈 Métricas (Metrics):
  (vacío)

¿Por qué está vacío "Métricas"?​

En Floutic, todas las métricas se almacenan como logs estructurados (JSON), no como el tipo "metrics" de OpenObserve. Esto es una práctica válida y común.

Razones técnicas:​

  1. Formato flexible: Los logs JSON permiten estructuras complejas y campos personalizados
  2. SQL completo: Puedes usar todas las funciones SQL de OpenObserve sobre los logs
  3. Mismo rendimiento: Para queries y dashboards, el rendimiento es similar
  4. Más fácil de implementar: No requiere conversión a formato Prometheus-like

Cómo funciona en Floutic:​

  • api-metrics-stream: Métricas de API almacenadas como logs JSON
  • business-metrics-stream: Métricas de negocio almacenadas como logs JSON
  • infrastructure-stream: Métricas de infraestructura almacenadas como logs JSON
  • Todos usan el endpoint: /api/default/{stream}/_json (endpoint de logs)

¿Es esto un problema?​

No, no es un problema. Las métricas funcionan perfectamente:

✅ Puedes crear dashboards igual que con métricas tradicionales
✅ Puedes hacer queries SQL complejas
✅ Puedes crear alertas
✅ El rendimiento es excelente para tu volumen de datos

Diferencias entre Logs y Metrics en OpenObserve​

AspectoLogs (lo que usas)Metrics (no usado)
FormatoJSON estructuradoSerie temporal compacta
Flexibilidad✅ Alta (campos dinámicos)⚠️ Limitada (estructura fija)
Queries SQL✅ Completo✅ Completo
Dashboards✅ Funciona perfecto✅ Funciona perfecto
VolumenMejor para datos estructuradosMejor para series temporales simples

¿Cuándo usar "Metrics" en lugar de "Logs"?​

El tipo "Metrics" sería más apropiado si:

  • Tuvieras millones de puntos de datos simples por segundo
  • Solo necesitaras valores numéricos simples (sin campos adicionales)
  • Quisieras compatibilidad directa con Prometheus

En tu caso, como necesitas:

  • Campos personalizados (endpoint, user_id, tags, metadata, etc.)
  • Estructura flexible
  • Queries SQL complejas

Los logs estructurados son la mejor opción.

Conclusión​

✅ No necesitas cambiar nada
✅ Es normal que "Métricas" esté vacío
✅ Tus métricas están funcionando correctamente en "Logs"
✅ Puedes crear dashboards y alertas normalmente

Sigue trabajando con tus streams en "Logs" como lo has estado haciendo. Todo está bien configurado. 🎉

📋 Pasos Detallados para Crear tu Primer Dashboard​

Paso 1: Acceder a OpenObserve​

1.1. Determinar la URL de OpenObserve​

La URL de OpenObserve depende de tu configuración:

Opción A: Si usas Docker Compose localmente

  • URL: http://localhost:5080

Opción B: Si está en un servidor (tu caso)

  • URL: https://oo.haorp.es (según la configuración encontrada en el código)

Opción C: Verificar en variables de entorno

# Verificar la URL configurada
docker-compose exec backend env | grep OPENOBSERVE_URL
# O revisar docker-compose.yml (línea 94 y 101)

1.2. Abrir OpenObserve en el navegador​

  1. Abre tu navegador web (Chrome, Firefox, etc.)
  2. Navega a la URL de OpenObserve (ej: http://localhost:5080 o https://oo.haorp.es)
  3. Deberías ver la pantalla de login de OpenObserve

1.3. Iniciar sesión​

Credenciales por defecto (según docker-compose.yml):

  • Email/Usuario: root@example.com
  • Contraseña: openobserve_pass123

O verificar en variables de entorno:

# Verificar credenciales configuradas
docker-compose exec openobserve env | grep ZO_ROOT_USER

Si las credenciales no funcionan:

  1. Revisa el archivo .env en el directorio del proyecto (busca OPENOBSERVE_USER y OPENOBSERVE_PASSWORD)
  2. O verifica docker-compose.yml líneas 139-140 para ver las variables configuradas
  3. Si cambiaste las credenciales, reinicia el contenedor: docker-compose restart openobserve

Paso 2: Verificar que hay Datos​

Antes de crear dashboards, necesitas verificar que hay datos en los streams.

2.1. Navegar a Logs​

  1. En el menú lateral izquierdo, busca "Logs" o "Query"
  2. Haz clic en "Logs"

2.2. Seleccionar un Stream​

  1. En la parte superior, verás un selector de "Stream" o "Index"
  2. Haz clic y selecciona: api-metrics-stream
  3. Haz clic en "Run" o "Search"

2.3. Verificar que hay resultados​

  • Si ves resultados: ✅ Perfecto, puedes continuar
  • Si no ves resultados:
    • Espera unos minutos (las métricas se envían cada minuto)
    • O genera tráfico en la aplicación (haz algunas peticiones a la API)
    • O verifica que OpenObserve está recibiendo datos

Nota: Si no hay datos, los streams pueden no existir aún. Los streams se crean automáticamente cuando se envía el primer log.

Paso 3: Crear tu Primer Dashboard​

3.1. Navegar a Dashboards​

  1. Después de iniciar sesión, deberías estar en la página principal de OpenObserve
  2. En el menú lateral izquierdo, busca una opción que diga:
    • "Dashboards" (más común)
    • "Dashboard" (singular)
    • O un icono que parezca un gráfico o tabla 📊
  3. Haz clic en esa opción

Si no encuentras el menú:

  • Busca un icono de "☰" (hamburguesa) en la esquina superior izquierda para abrir/cerrar el menú
  • O busca en la barra superior opciones como "Dashboards", "Logs", "Metrics", etc.

3.2. Crear Nuevo Dashboard​

  1. Una vez en la página de Dashboards, deberías ver:
    • Una lista de dashboards existentes (si hay alguno)
    • O una página vacía con un mensaje como "No dashboards yet"
  2. Busca un botón que diga:
    • "New Dashboard" (más común)
    • "Create Dashboard"
    • "Add Dashboard"
    • O un botón "+" (icono de más)
    • O un botón "Create" o "New"
  3. Este botón generalmente está en:
    • La esquina superior derecha
    • O en el centro de la página si no hay dashboards
  4. Haz clic en ese botón

Si no encuentras el botón:

  • Verifica que tienes permisos de administrador (deberías tenerlos con root@example.com)
  • Intenta refrescar la página (F5)
  • O busca un menú desplegable con opciones como "New", "Create", etc.

3.3. Configurar el Dashboard​

  1. Deberías ver un formulario o modal con campos para configurar el dashboard

  2. Nombre del Dashboard:

    • Busca un campo que diga "Name" o "Dashboard Name"
    • Escribe: Floutic - Métricas de API

  3. Descripción (opcional):

    • Busca un campo que diga "Description" o "Descripción"
    • Escribe: Dashboard de métricas de rendimiento de la API

  4. Otros campos (si aparecen):

    • Puede haber campos como "Tags", "Folder", etc. - déjalos en blanco o con valores por defecto

  5. Haz clic en el botón "Create", "Save", o "Submit"

Después de crear:

  • Deberías ser redirigido al dashboard recién creado (probablemente vacío)
  • O verás el dashboard con un mensaje como "No panels yet" o "Add your first panel"

Paso 4: Añadir tu Primer Panel - Requests por Minuto​

4.1. Añadir Panel​

  1. En el dashboard recién creado, deberías ver:

    • Un dashboard vacío con un mensaje como "No panels yet" o "Add your first panel"
    • O un botón grande que dice "Add Panel" o "Add Widget"
    • O un icono "+" (más) en alguna parte del dashboard

  2. Si ves un botón grande "Add Panel":

    • Haz clic directamente en ese botón

  3. Si no ves un botón obvio:

    • Busca en la parte superior del dashboard:
      • Un botón "Edit" o "⚙️" (engranaje) - haz clic para entrar en modo edición
      • Un botón "Add Panel", "Add Widget", o "+"
    • O busca en la esquina superior derecha del dashboard

  4. Si estás en modo visualización (no edición):

    • Busca un botón "Edit" o "⚙️" en la parte superior
    • Haz clic para entrar en modo edición
    • Luego busca "Add Panel" o "+"

  5. Haz clic en "Add Panel" o el botón equivalente

4.2. Configurar el Panel​

Paso 4.2.1: Seleccionar Tipo de Visualización

  1. Deberías ver un formulario o panel lateral para configurar el nuevo panel
  2. Busca un campo o selector que diga:
    • "Visualization Type"
    • "Chart Type"
    • "Type"
    • O un selector desplegable con iconos de gráficos
  3. Haz clic en ese selector y busca:
    • "Line Chart" (gráfico de líneas) ⭐ RECOMENDADO
    • "Time Series" (serie temporal)
    • "Area Chart" (gráfico de área)
  4. Selecciona "Line Chart" o "Time Series"

Paso 4.2.2: Configurar la Query

  1. Busca el campo "Query" o "SQL Query"
  2. Pega esta query SQL (versión simple primero para verificar que funciona):
SELECT * 
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
LIMIT 10
  1. Haz clic en "Run" o "Search" para verificar que hay datos
  2. Si ves resultados, ahora usa esta query para el gráfico:
SELECT 
  DATE_TRUNC('minute', timestamp) as minute,
  COUNT(*) as requests_per_minute
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
  AND type = 'api_metric'
GROUP BY minute
ORDER BY minute

Nota: Si DATE_TRUNC no funciona, prueba con:

SELECT 
  date_trunc('minute', timestamp) as minute,
  COUNT(*) as requests_per_minute
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
  AND type = 'api_metric'
GROUP BY minute
ORDER BY minute

Paso 4.2.3: Configurar el Stream

  1. Busca un campo o selector que diga:
    • "Stream"
    • "Index"
    • "Data Source"
    • O un selector desplegable cerca de la query
  2. Haz clic en ese selector
  3. Busca en la lista: api-metrics-stream
  4. Si no aparece en la lista:
    • Escribe api-metrics-stream en el campo (si es un campo de texto)
    • O espera unos segundos mientras se carga la lista
    • O verifica que el stream existe (ve a "Logs" y busca el stream)
  5. Selecciona: api-metrics-stream

Paso 4.2.4: Configurar Título

  1. Busca un campo que diga:
    • "Panel Title"
    • "Name"
    • "Title"
    • O simplemente un campo de texto en la parte superior del formulario
  2. Escribe: Requests por Minuto

Paso 4.2.5: Guardar el Panel

  1. Busca un botón que diga:
    • "Save"
    • "Apply"
    • "Create"
    • "Add"
    • O un icono de "✓" (check)
  2. Haz clic en ese botón
  3. El panel debería aparecer en tu dashboard
  4. Si no aparece, verifica que:
    • La query se ejecutó correctamente (no hay errores en rojo)
    • El stream tiene datos (ve a "Logs" y verifica)

Paso 5: Añadir Segundo Panel - Tiempo de Respuesta Promedio​

5.1. Añadir Otro Panel​

  1. Haz clic en "Add Panel" nuevamente

5.2. Configurar el Panel​

Tipo de Visualización: "Stat" o "Big Number" o "Single Stat"

Query:

SELECT 
  ROUND(AVG(response_time_ms), 2) as avg_response_time_ms
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
  AND type = 'api_metric'

Stream: api-metrics-stream

Título: Tiempo de Respuesta Promedio (ms)

Guardar el panel

Paso 6: Añadir Tercer Panel - Distribución de Status Codes​

6.1. Añadir Panel​

  1. Haz clic en "Add Panel"

6.2. Configurar el Panel​

Tipo de Visualización: "Pie Chart" o "Donut Chart"

Query:

SELECT 
  status_code,
  COUNT(*) as count
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '24 hours'
  AND type = 'api_metric'
GROUP BY status_code
ORDER BY status_code

Stream: api-metrics-stream

Título: Distribución de Status Codes (24h)

Guardar el panel

Paso 7: Organizar y Guardar el Dashboard​

7.1. Organizar Paneles​

  1. Arrastra los paneles para organizarlos como prefieras
  2. Ajusta el tamaño de cada panel (generalmente hay un icono de redimensionar en la esquina)

7.2. Guardar el Dashboard​

  1. Busca el botón "Save" o "Save Dashboard" (generalmente en la parte superior)
  2. Haz clic en "Save"

🎉 ¡Listo!​

Ahora deberías tener tu primer dashboard funcionando con 3 paneles:

  1. ✅ Requests por minuto (gráfico de línea)
  2. ✅ Tiempo de respuesta promedio (número grande)
  3. ✅ Distribución de status codes (gráfico de pastel)

🎯 Métricas de Negocio Disponibles​

Las siguientes métricas de negocio se envían automáticamente desde el código:

  • user_registered: Se envía cuando un usuario se registra

    • Campos: value (1.0), tags (opcional)
    • Ubicación: backend/app/api/v1/endpoints/auth.py

  • project_created: Se envía cuando se crea un proyecto

    • Campos: value (1.0), tags.project_type, tags.status, tags.company_id, budget
    • Ubicación: backend/app/api/v1/endpoints/projects.py

  • payment_released: Se envía cuando se libera un pago

    • Campos: value (monto del pago), tags.expert_level, tags.project_id, tags.milestone_id, commission_amount, expert_amount
    • Ubicación: backend/app/api/v1/endpoints/payments.py

📡 Streams Disponibles​

Floutic envía datos a los siguientes streams en OpenObserve:

StreamNombre CompletoDescripción
backendbackend-streamLogs generales del backend (Python logs)
frontendfrontend-streamLogs del frontend (React/Astro)
api_metricsapi-metrics-streamMétricas de endpoints API (tiempo de respuesta, status codes)
business_metricsbusiness-metrics-streamMétricas de negocio (eventos, contadores)
securitysecurity-streamEventos de seguridad (login, rate limits, accesos)
jobsjobs-streamLogs de jobs y tareas en background
infrastructureinfrastructure-streamMétricas de PostgreSQL, Redis, sistema
performanceperformance-streamMétricas de rendimiento (queries, cache)
client_errorsclient-errors-streamErrores 4xx (client errors)
server_errorsserver-errors-streamErrores 5xx (server errors)
integrationintegration-streamLogs de integraciones externas (GHL, Stripe)

📈 Dashboard de Métricas de API​

Objetivo​

Monitorear el rendimiento y salud de los endpoints de la API.

Paneles Recomendados​

1. Requests por Segundo (RPS)​

SELECT 
  DATE_TRUNC('minute', timestamp) as minute,
  COUNT(*) as requests_per_minute
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
GROUP BY minute
ORDER BY minute

Stream: api-metrics-stream
Visualización: Line chart con intervalo de 1 minuto

2. Tiempo de Respuesta Promedio por Endpoint​

SELECT 
  endpoint,
  AVG(response_time_ms) as avg_response_time_ms,
  PERCENTILE(response_time_ms, 0.95) as p95_ms
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '24 hours'
  AND type = 'api_metric'
GROUP BY endpoint
ORDER BY avg_response_time_ms DESC
LIMIT 20

Stream: api-metrics-stream
Visualización: Bar chart horizontal

3. Distribución de Status Codes​

SELECT 
  status_code,
  COUNT(*) as count,
  COUNT(*) * 100.0 / SUM(COUNT(*)) OVER() as percentage
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '24 hours'
  AND type = 'api_metric'
GROUP BY status_code
ORDER BY status_code

Stream: api-metrics-stream
Visualización: Pie chart o bar chart

4. Top 10 Endpoints Más Lentos​

SELECT 
  endpoint,
  method,
  AVG(response_time_ms) as avg_response_time_ms,
  PERCENTILE(response_time_ms, 0.95) as p95_response_time_ms,
  COUNT(*) as request_count
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '24 hours'
  AND type = 'api_metric'
GROUP BY endpoint, method
ORDER BY p95_response_time_ms DESC
LIMIT 10

Stream: api-metrics-stream
Visualización: Table con columnas: endpoint, method, p95, promedio, count

5. Tasa de Éxito por Endpoint​

SELECT 
  endpoint,
  COUNT(*) as total_requests,
  SUM(CASE WHEN success = true THEN 1 ELSE 0 END) as successful_requests,
  (SUM(CASE WHEN success = true THEN 1 ELSE 0 END) * 100.0 / COUNT(*)) as success_rate
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '24 hours'
  AND type = 'api_metric'
GROUP BY endpoint
ORDER BY success_rate DESC

Stream: api-metrics-stream
Visualización: Bar chart con porcentajes

6. Métricas de Tiempo de Respuesta (P50, P95, P99)​

SELECT 
  DATE_TRUNC('minute', timestamp) as minute,
  PERCENTILE(response_time_ms, 0.5) as p50_ms,
  PERCENTILE(response_time_ms, 0.95) as p95_ms,
  PERCENTILE(response_time_ms, 0.99) as p99_ms
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
  AND type = 'api_metric'
GROUP BY minute
ORDER BY minute

Stream: api-metrics-stream
Visualización: Line chart con 3 líneas (P50, P95, P99)

💼 Dashboard de Métricas de Negocio​

Objetivo​

Monitorear métricas clave del negocio (usuarios, proyectos, pagos).

Paneles Recomendados​

1. Usuarios Registrados (Últimos 30 días)​

SELECT 
  DATE_TRUNC('day', timestamp) as day,
  COUNT(*) as users_registered
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '30 days'
  AND metric_name = 'user_registered'
GROUP BY day
ORDER BY day

Stream: business-metrics-stream
Visualización: Line chart diario

Nota: Esta métrica se envía automáticamente cuando un usuario se registra (auth.py)

2. Proyectos Creados​

SELECT 
  DATE_TRUNC('day', timestamp) as day,
  COUNT(*) as projects_created
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '30 days'
  AND metric_name = 'project_created'
GROUP BY day
ORDER BY day

Stream: business-metrics-stream
Visualización: Line chart diario

Nota: Esta métrica se envía automáticamente cuando se crea un proyecto (projects.py)

3. Proyectos por Tipo​

SELECT 
  tags->>'project_type' as project_type,
  COUNT(*) as count
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '7 days'
  AND metric_name = 'project_created'
  AND tags->>'project_type' IS NOT NULL
GROUP BY project_type
ORDER BY count DESC

Stream: business-metrics-stream
Visualización: Pie chart o bar chart

4. Pagos Liberados (Últimos 30 días)​

SELECT 
  DATE_TRUNC('day', timestamp) as day,
  SUM(value) as total_payments,
  COUNT(*) as payment_count
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '30 days'
  AND metric_name = 'payment_released'
GROUP BY day
ORDER BY day

Stream: business-metrics-stream
Visualización: Line chart con 2 líneas (total pagos, cantidad de pagos)

Nota: Esta métrica se envía automáticamente cuando se libera un pago (payments.py). El value contiene el monto del pago.

5. Monto Total de Pagos por Nivel de Experto​

SELECT 
  tags->>'expert_level' as expert_level,
  SUM(value) as total_payments
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '30 days'
  AND metric_name = 'payment_released'
  AND tags->>'expert_level' IS NOT NULL
GROUP BY expert_level
ORDER BY total_payments DESC

Stream: business-metrics-stream
Visualización: Bar chart

6. Proyectos Creados con Presupuesto​

SELECT 
  DATE_TRUNC('day', timestamp) as day,
  AVG(budget) as avg_budget,
  SUM(budget) as total_budget
FROM "business-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '30 days'
  AND metric_name = 'project_created'
  AND budget IS NOT NULL
GROUP BY day
ORDER BY day

Stream: business-metrics-stream
Visualización: Line chart con 2 líneas (presupuesto promedio, presupuesto total)

Nota: El campo budget está disponible en la métrica project_created

🖥️ Dashboard de Infraestructura​

Objetivo​

Monitorear la salud de la infraestructura (PostgreSQL, Redis, sistema).

Paneles Recomendados​

1. Conexiones de PostgreSQL​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 1h
  service = "postgres"
  connections EXISTS
  | stats max(connections.total) as max_connections, max(connections.active) as max_active by _timestamp
  | timechart span=5m

Visualización: Line chart con 2 líneas (total, active)

2. Uso de Memoria de Redis​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 1h
  service = "redis"
  memory EXISTS
  | stats max(memory.used_mb) as used_mb, max(memory.max_mb) as max_mb by _timestamp
  | timechart span=5m

Visualización: Line chart con área sombreada

3. CPU y Memoria del Sistema​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 1h
  service = "system"
  cpu EXISTS
  | stats max(cpu.percent) as cpu_percent, max(memory.percent) as memory_percent by _timestamp
  | timechart span=5m

Visualización: Line chart con 2 líneas (CPU %, Memoria %)

4. Tamaño de Base de Datos​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 24h
  service = "postgres"
  database_size EXISTS
  | stats max(database_size.size_bytes) as size_bytes by _timestamp
  | timechart span=1h

Visualización: Line chart

5. Queries Lentas de PostgreSQL​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 24h
  service = "postgres"
  slow_queries EXISTS
  | stats max(slow_queries.count_last_hour) as slow_queries_count by _timestamp
  | timechart span=1h

Visualización: Line chart

🔒 Dashboard de Seguridad​

Objetivo​

Monitorear eventos de seguridad y accesos.

Paneles Recomendados​

1. Intentos de Login Fallidos​

Stream: security-stream
Query:
  _timestamp >= now() - 24h
  operation_type = "login_failed"
  | stats count() by _timestamp
  | timechart span=1h

Visualización: Line chart

2. Rate Limits Excedidos​

Stream: security-stream
Query:
  _timestamp >= now() - 24h
  operation_type = "rate_limit_exceeded"
  | stats count() by _timestamp
  | timechart span=1h

Visualización: Line chart

3. Accesos No Autorizados​

Stream: security-stream
Query:
  _timestamp >= now() - 24h
  operation_type = "unauthorized_access"
  | stats count() by path
  | sort -count
  | head 10

Visualización: Bar chart

4. Logins Exitosos por Rol​

Stream: security-stream
Query:
  _timestamp >= now() - 24h
  operation_type = "login_success"
  | stats count() by metadata.user_role

Visualización: Pie chart

5. IPs con Más Intentos Fallidos​

Stream: security-stream
Query:
  _timestamp >= now() - 24h
  operation_type = "login_failed"
  | stats count() by metadata.ip_address
  | sort -count
  | head 10

Visualización: Table o bar chart

❌ Dashboard de Errores​

Objetivo​

Monitorear y analizar errores de la aplicación.

Paneles Recomendados​

1. Errores por Tipo (4xx vs 5xx)​

Stream: client-errors-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  | stats count() by stream

Visualización: Pie chart

2. Top 10 Errores Más Frecuentes​

Stream: client-errors-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  | stats count() by error
  | sort -count
  | head 10

Visualización: Bar chart horizontal

3. Errores por Endpoint​

Stream: client-errors-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  path EXISTS
  | stats count() by path
  | sort -count
  | head 10

Visualización: Bar chart

4. Tasa de Errores (Últimas 24h)​

Stream: client-errors-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  | stats count() as error_count by _timestamp
  | timechart span=1h

Visualización: Line chart

5. Errores por Usuario (Top 10)​

Stream: client-errors-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  user_id EXISTS
  | stats count() by user_id
  | sort -count
  | head 10

Visualización: Table

🚨 Configuración de Alertas​

Alertas Críticas (Alta Prioridad)​

1. Error Rate Alto (> 5% en 5 minutos)​

Stream: api-metrics-stream
Query:
  _timestamp >= now() - 5m
  type = "api_metric"
  | stats count() as total, sum(if(success = false, 1, 0)) as errors
  | eval error_rate = (errors / total) * 100
  | where error_rate > 5

Acción: Notificar inmediatamente (email, Slack, etc.)

2. Tiempo de Respuesta P95 > 2 segundos​

Stream: api-metrics-stream
Query:
  _timestamp >= now() - 5m
  type = "api_metric"
  | stats p95(response_time_ms) as p95_response_time
  | where p95_response_time > 2000

Acción: Notificar al equipo de desarrollo

3. Errores 5xx (Server Errors)​

Stream: server-errors-stream
Query:
  _timestamp >= now() - 5m
  | stats count() as error_count
  | where error_count > 0

Acción: Notificar inmediatamente

4. PostgreSQL Conexiones > 80%​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 5m
  service = "postgres"
  connections.usage_percent > 80

Acción: Notificar al equipo de infraestructura

5. Redis Memoria > 90%​

Stream: infrastructure-stream
Query:
  _timestamp >= now() - 5m
  service = "redis"
  memory.usage_percent > 90

Acción: Notificar al equipo de infraestructura

Alertas de Advertencia (Media Prioridad)​

6. Rate Limits Excedidos (Múltiples IPs)​

Stream: security-stream
Query:
  _timestamp >= now() - 15m
  operation_type = "rate_limit_exceeded"
  | stats count() as rate_limit_count
  | where rate_limit_count > 50

Acción: Revisar y posible bloqueo de IPs

7. Login Fallidos (Posible Ataque)​

Stream: security-stream
Query:
  _timestamp >= now() - 15m
  operation_type = "login_failed"
  | stats count() by metadata.ip_address
  | where count > 10

Acción: Revisar IPs sospechosas

🔍 Queries Útiles​

Búsqueda de Errores Específicos​

Stream: backend-stream, server-errors-stream
Query:
  _timestamp >= now() - 24h
  message LIKE "%error_message%"
  | sort -_timestamp

Análisis de Usuario Específico​

Stream: api-metrics-stream, business-metrics-stream
Query:
  _timestamp >= now() - 7d
  user_id = 123
  | sort -_timestamp

Análisis de Proyecto Específico​

Stream: api-metrics-stream, business-metrics-stream
Query:
  _timestamp >= now() - 7d
  project_id = 456
  | sort -_timestamp

Correlación de Errores con Métricas​

Stream: server-errors-stream, api-metrics-stream
Query:
  _timestamp >= now() - 1h
  | stats count() as error_count by _timestamp
  | timechart span=5m

🎯 Dashboards Recomendados por Rol​

Para DevOps/Infraestructura​

  • Dashboard de Infraestructura
  • Dashboard de Errores
  • Alertas críticas de infraestructura

Para Desarrollo​

  • Dashboard de Métricas de API
  • Dashboard de Errores
  • Alertas de performance

Para Negocio/Producto​

  • Dashboard de Métricas de Negocio
  • Dashboard de Métricas de API (solo tasas de éxito)
  • Métricas de conversión

Para Seguridad​

  • Dashboard de Seguridad
  • Alertas de seguridad
  • Análisis de accesos

💡 Tips y Mejores Prácticas​

  1. Intervalos de Tiempo

    • Dashboards operacionales: Últimas 1-24 horas
    • Dashboards de negocio: Últimos 7-30 días
    • Dashboards de análisis: Últimos 90 días

  2. Actualización Automática

    • Configurar refresh automático (cada 1-5 minutos para dashboards operacionales)
    • Dashboards de negocio pueden actualizarse cada 15-30 minutos

  3. Filtros Comunes

    • Añadir filtros por entorno (production, staging, development)
    • Filtros por servicio/componente
    • Filtros por usuario/rol

  4. Documentación

    • Añadir descripciones a cada panel
    • Documentar qué significa cada métrica
    • Incluir links a runbooks o documentación

  5. Optimización de Queries

    • Usar índices en campos frecuentemente consultados
    • Limitar rangos de tiempo apropiados
    • Usar agregaciones cuando sea posible

🔍 Solución de Problemas​

Problema: "No se encuentra el stream api-metrics-stream"​

Solución:

  1. Verifica que el stream existe:

    • Ve a "Streams" o "Indexes" en el menú
    • Busca api-metrics-stream en la lista
    • Si no existe, genera tráfico en la aplicación (haz algunas peticiones HTTP)

  2. Verifica que hay datos:

    • Ve a "Logs" → Selecciona api-metrics-stream → Haz clic en "Run"
    • Si no hay resultados, espera unos minutos o genera más tráfico

Problema: "La query SQL da error"​

Solución:

  1. Verifica la sintaxis SQL:

    • Asegúrate de usar comillas dobles para el nombre del stream: "api-metrics-stream"
    • Verifica que los nombres de campos son correctos (pueden variar según la versión)

  2. Prueba una query más simple primero:

SELECT * 
FROM "api-metrics-stream"
WHERE timestamp >= NOW() - INTERVAL '1 hour'
LIMIT 10
  1. Verifica los campos disponibles:
    • Ejecuta la query simple de arriba
    • Revisa qué campos están disponibles en los resultados
    • Ajusta la query según los campos reales

Problema: "No veo el botón 'Add Panel'"​

Solución:

  1. Verifica que estás en modo edición:

    • Busca un botón "Edit" o "⚙️" (engranaje) en la parte superior del dashboard
    • Haz clic para entrar en modo edición
    • En modo edición, deberías ver más opciones y botones

  2. Busca alternativas:

    • Busca "Add Widget", "Add Chart", "New Panel", o "+" (icono de más)
    • Puede estar en la esquina superior derecha, o en el centro si el dashboard está vacío

  3. Verifica permisos:

    • Asegúrate de estar logueado como administrador (root@example.com)
    • Si no tienes permisos, contacta al administrador del sistema

  4. Intenta refrescar:

    • Refresca la página (F5)
    • O cierra y vuelve a abrir el dashboard

  5. Versión de OpenObserve:

    • Algunas versiones tienen la opción en lugares diferentes
    • Busca en la documentación de tu versión específica de OpenObserve

Problema: "Los datos no se actualizan"​

Solución:

  1. Verifica el intervalo de tiempo:

    • Asegúrate de que el rango de tiempo en la query incluye datos recientes
    • Prueba con NOW() - INTERVAL '1 hour' para datos más recientes

  2. Configura auto-refresh:

    • Busca "Auto Refresh" o "Refresh Interval" en el dashboard
    • Configura para que se actualice cada 1-5 minutos

📝 Notas Importantes​

  1. Nombres de Streams: Los nombres de streams deben coincidir exactamente. Usa:

    • api-metrics-stream (con guiones)
    • business-metrics-stream
    • backend-stream
    • etc.

  2. Sintaxis SQL: OpenObserve usa SQL estándar, pero algunos campos pueden requerir acceso especial:

    • Para campos JSON anidados: tags->>'project_type'
    • Para timestamps: timestamp o _timestamp (depende de la versión)

  3. Intervalos de Tiempo:

    • NOW() - INTERVAL '1 hour' = última hora
    • NOW() - INTERVAL '24 hours' = últimas 24 horas
    • NOW() - INTERVAL '7 days' = últimos 7 días

Última actualización: Enero 2026
Versión de OpenObserve: Compatible con v0.5+