Cómo Autoalojar Traceway como Alternativa Gratuita a Datadog

Las facturas de observabilidad aparecen sin avisar. Un día estás registrando unos pocos servicios, al siguiente estás mirando una factura de Datadog que compite con tu gasto en la nube. Traceway le da la vuelta a ese modelo: tiene licencia MIT, es nativo de OpenTelemetry y puedes tener el stack completo funcionando en tu propio hardware en unos dos minutos.

¿Qué es Traceway?

Traceway es una plataforma de observabilidad de código abierto que maneja logs, trazas, métricas, session replay, excepciones y trazado de IA bajo un mismo techo. Ingiera datos directamente mediante OTLP/HTTP, así que te saltas el collector, los SDKs de proveedor y el código de unión. Apunta cualquier SDK de OpenTelemetry hacia él y los datos empiezan a fluir.

El proyecto tiene unas 290 estrellas en GitHub y se distribuye bajo una licencia MIT limpia. Sin BSL, sin un tier “open core” que reserve funciones para planes de pago. Todas las funcionalidades están incluidas.

Qué incluye

Funcionalidad	Qué hace
Logs	Búsqueda estructurada y vinculada a trazas con rendimiento inferior a un segundo
Trazas	Cascadas de spans de extremo a extremo en todos los servicios
Métricas	Métricas de host, runtime y personalizadas con widgets de dashboard configurables
Excepciones	Stack traces normalizadas con SHA-256 agrupadas en incidencias clasificadas, con source maps para bundles JS
Session Replay	Reproduce sesiones de usuario previas a errores en web (cualquier framework JS) y Flutter
Observabilidad de IA	Seguimiento de coste, tokens, latencia y conversaciones completas de LLMs entre proveedores

Por qué Traceway frente a las alternativas

	Empresarial (Datadog/New Relic)	OSS DIY (Prometheus + Loki + Tempo)	Traceway
Precio	Por evento, por host, por usuario	Gratis pero mucho tiempo de operación	Autoalojado gratis, cloud con tarifa fija
Configuración	SDK de proveedor por lenguaje	Unir 6 herramientas	docker compose up -d
Licencia	Propietaria	Mixta, algunas BSL/open-core	MIT, sin asteriscos
OTel	Envuelto en SDK de proveedor	Requiere Collector	Ingesta nativa OTLP/HTTP
Replay + trazas + IA	Tres productos separados	Conéctalos tú mismo	Un sistema, un trace ID

Arquitectura

Traceway se compone de tres servicios principales cuando se despliega de forma independiente:

Servicio	Tecnología	Función
Backend	Go 1.25, Gin	Ingesta OTLP, API REST, alertas, migraciones
Frontend	SvelteKit 2, Svelte 5, Tailwind CSS v4	Dashboard SPA
Base de datos	ClickHouse + PostgreSQL	Almacenamiento de telemetría (ClickHouse) y datos relacionales (PostgreSQL)

Todo se comunica a través de la red interna de Docker. El backend expone endpoints OTLP/HTTP para trazas, métricas y logs en /api/otel/v1/traces, /api/otel/v1/metrics y /api/otel/v1/logs.

Requisitos previos

Prueba Hetzner Cloud Prueba Hostinger VPS

Desplegar Traceway con Docker Compose

Esta es la parte esencial. Clonar, compose up, listo.

Paso 1: Clonar el repositorio

git clone https://github.com/tracewayapp/traceway
cd traceway

Paso 2: Iniciar el stack

docker compose up -d

El dashboard aparece en http://ip-de-tu-servidor. Así de simple.

Entre bastidores, Docker Compose descarga las imágenes de Traceway, arranca ClickHouse y PostgreSQL, ejecuta las migraciones pendientes e inicia la API y el frontend. El primer arranque tarda unos 90 segundos mientras las bases de datos se inicializan.

Paso 3: Crear tu primer proyecto

Abre el dashboard, inicia sesión con las credenciales predeterminadas y crea un proyecto. La interfaz te guía. Obtendrás un endpoint de ingesta y un token de acceso para cada proyecto.

Ejemplo práctico: Instrumentar una app Node.js

Vamos a conectar una aplicación real. Así es como se pasa de “he desplegado Traceway” a “veo los datos de mi app”.

Configurar una app Express básica

Si no tienes una app a mano, crea una:

mkdir traceway-demo && cd traceway-demo
npm init -y
npm install express @opentelemetry/api @opentelemetry/sdk-node \
  @opentelemetry/auto-instrumentations-node \
  @opentelemetry/exporter-trace-otlp-http

Conectar OpenTelemetry

Crea un archivo llamado tracing.js:

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://ip-de-tu-servidor/api/otel/v1/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start();

Crear el servidor

Crea index.js:

require('./tracing');

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.json({ message: 'Traceway está observando' });
});

app.get('/lento', async (req, res) => {
  await new Promise(resolve => setTimeout(resolve, 2000));
  res.json({ message: 'Este tardó un poco' });
});

app.listen(3000, () => console.log('App ejecutándose en el puerto 3000'));

Ejecútalo con node index.js y luego haz curl a ambos endpoints varias veces:

curl http://localhost:3000/
curl http://localhost:3000/lento

Vuelve al dashboard de Traceway. Las trazas aparecen en segundos. Los spans desglosan cada petición, el endpoint /lento visiblemente tarda más, y puedes navegar por la cascada para ver exactamente dónde se va el tiempo.

Ejemplo práctico: Instrumentar una app Python

Python funciona igual. Aquí tienes una configuración mínima con Flask:

mkdir traceway-python && cd traceway-python
python3 -m venv venv && source venv/bin/activate
pip install flask opentelemetry-distro opentelemetry-exporter-otlp-proto-http

Crea app.py:

from flask import Flask
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.flask import FlaskInstrumentor

# Apunta el exporter a tu instancia de Traceway
exporter = OTLPSpanExporter(
    endpoint="http://ip-de-tu-servidor/api/otel/v1/traces"
)

provider = TracerProvider()
provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)

app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)

@app.route("/")
def home():
    return {"message": "Traceway también ve esto"}

@app.route("/error")
def error():
    1 / 0  # Intencionado — aparece en excepciones
    return "nunca se alcanza"

if __name__ == "__main__":
    app.run(port=5000)

Ejecútalo y visita ambos endpoints. De vuelta en Traceway, verás spans para cada ruta de Flask más una incidencia de excepción agrupada para la división por cero.

Ejemplo práctico: Session replay en el frontend

Traceway incluye session replay de serie. Para cualquier frontend JavaScript, añade el SDK de navegador de Traceway:

<script src="https://cdn.jsdelivr.net/npm/@tracewayapp/browser@latest/dist/traceway.min.js"></script>
<script>
  Traceway.init({
    projectToken: 'token-de-tu-proyecto',
    endpoint: 'http://ip-de-tu-servidor/api/otel/v1/traces',
    sessionReplay: true,
  });
</script>

Ese fragmento captura sesiones de usuario, logs de consola, peticiones de red y errores. Cuando salta una excepción, la página de detalle del error incluye una reproducción de la sesión del usuario previa al error. Ves exactamente qué hizo clic, qué escribió y qué vio.

El SDK de navegador funciona con React, Vue, Svelte, Next.js y HTML plano. También hay un paquete Flutter para apps móviles.

Endurecimiento para producción

Una vez que hayas confirmado que todo funciona, asegúralo:

Actualizar Traceway

cd traceway
git pull
docker compose pull && docker compose up -d

Las migraciones se ejecutan automáticamente cuando el nuevo backend se inicia. Revisa las notas de versión en GitHub antes de hacer pull; los cambios que rompen compatibilidad se indican explícitamente.

FAQ

¿Cómo se compara Traceway con Grafana + Loki + Tempo?

El stack de Grafana está muy probado pero requiere configurar y mantener Loki para logs, Tempo para trazas, Prometheus para métricas y Grafana para dashboards. Cada pieza tiene su propio lenguaje de configuración, backend de almacenamiento y ruta de actualización. Traceway te da las mismas capacidades — logs, trazas, métricas — en un solo stack de Docker Compose con una única superficie de configuración. Si ya usas el stack de Grafana y te funciona, probablemente no merezca la pena migrar. Si estás empezando desde cero o cansado de unir piezas, vale la pena echarle un vistazo.

¿Puedo usar Traceway con instrumentación OpenTelemetry existente?

Sí. Ese es el objetivo. Si tus servicios ya exportan OTLP, simplemente redirige la URL del exporter a tu instancia de Traceway. No necesitas cambios de código más allá de la URL del endpoint.

¿Cuál es la huella de almacenamiento?

Depende mucho de tu tráfico. ClickHouse comprime bien — espera aproximadamente 1-3 GB por millón de spans para datos típicos de servicios HTTP. PostgreSQL almacena configuración de proyectos y datos de usuario, que es insignificante en comparación. Planea al menos 20 GB de disco si ejecutas en producción con un puñado de servicios, y monitoriza el crecimiento durante las primeras semanas.

¿Traceway soporta alertas?

Sí. Puedes configurar alertas para umbrales de tasa de error, picos de latencia o condiciones de métricas personalizadas. Las notificaciones van a Slack, incidencias de GitHub, correo electrónico o cualquier endpoint webhook.

¿Hay una opción cloud gestionada?

Traceway Cloud existe en cloud.tracewayapp.com si prefieres no autoalojar. Ejecuta el mismo código MIT. El precio es de tarifa fija en lugar de por evento, así que tu factura se mantiene predecible.

Conclusión

Traceway resuelve un problema real. La observabilidad no debería requerir un proceso de compras y un compromiso mensual de cuatro cifras solo para saber por qué tu API va lenta. El proyecto te da logs, trazas, métricas, seguimiento de excepciones y session replay en un stack que controlas, con una licencia MIT que no te la juega más adelante.

El compromiso es la madurez. Datadog tiene una década de pulido a sus espaldas. Traceway es joven y avanza rápido. Pero para equipos pequeños, proyectos paralelos y cualquiera que prefiera gastar dinero en servidores en lugar de dashboards, vale la pena probarlo una tarde.

Ver Traceway en GitHub Documentación de Traceway