Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
#!/usr/bin/env bash
# Run the OpenLIT UI (next dev), OTLP receiver, realtime engine and a NATS
# JetStream server together for local development. Ctrl+C stops everything.
#
# Usage: scripts/dev-realtime.sh
#
# Overrides (all optional):
# UI_PORT Next.js port (default: port of NEXTAUTH_URL in src/client/.env, else 3000)
# OTLP_HTTP_PORT Receiver OTLP/HTTP port (default 4318, falls back to 14318 if busy)
# OTLP_GRPC_PORT Receiver OTLP/gRPC port (default 4317, falls back to 14317 if busy)
# NATS_PORT NATS client port (default 4222)
# NATS_MONITOR_PORT NATS monitoring port (default 8222)
# ENGINE_HTTP_ADDR Engine health/stats address (default 127.0.0.1:4330)
# SQLITE_DATABASE_URL Defaults to the value in src/client/.env
# INIT_DB_HOST/PORT/USERNAME/PASSWORD/DATABASE ClickHouse (default 127.0.0.1:8123 default/OPENLIT openlit)
# NATS_USE_DOCKER=1 Run NATS in docker even when a local nats-server binary exists
# KEEP_NATS=1 Leave the NATS container running on exit
# SKIP_MIGRATE=1 Skip `prisma migrate deploy`
# SEED=1 Run `prisma db seed` (default user, org, project, DB config) after migrating
# OPENLIT_REALTIME_* Built-in trigger thresholds, passed through to the UI server
# OPENLIT_SIGNAL_ATTRIBUTES Personal span attributes rules may match (comma-separated)
# NATS_RECEIVER_PASSWORD / NATS_ENGINE_PASSWORD NATS user passwords (random per session)
# OPENLIT_ENGINE_SECRET Engine <-> UI secret (random per session)
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
CLIENT_DIR="$ROOT/src/client"
RECEIVER_DIR="$ROOT/src/otlp-receiver"
ENGINE_DIR="$ROOT/src/engine"
NATS_CONTAINER="${NATS_CONTAINER:-openlit-dev-nats}"
NATS_IMAGE="${NATS_IMAGE:-nats:2.10-alpine}"
log() { printf '\033[1;36m[dev]\033[0m %s\n' "$*"; }
die() { printf '\033[1;31m[dev]\033[0m %s\n' "$*" >&2; exit 1; }
need() { command -v "$1" >/dev/null 2>&1 || die "'$1' is required but not installed"; }
need docker
need go
need npm
need curl
need openssl
need lsof
dotenv_value() {
local file="$CLIENT_DIR/.env"
[ -f "$file" ] || return 0
grep -E "^[[:space:]]*$1=" "$file" | tail -n 1 | sed -E "s/^[[:space:]]*$1=//; s/^[\"']//; s/[\"']$//"
}
port_busy() { lsof -nP -iTCP:"$1" -sTCP:LISTEN >/dev/null 2>&1; }
pick_port() {
local name="$1" preferred="$2" fallback="$3" explicit="$4"
if port_busy "$preferred"; then
[ -n "$explicit" ] && die "$name port $preferred is already in use"
port_busy "$fallback" && die "$name ports $preferred and $fallback are both in use; set ${name}_PORT"
log "$name port $preferred is busy, using $fallback" >&2
echo "$fallback"
else
echo "$preferred"
fi
}
wait_for() {
local what="$1" url="$2" tries="${3:-60}"
for _ in $(seq 1 "$tries"); do
curl -fsS -o /dev/null "$url" 2>/dev/null && return 0
sleep 1
done
die "timed out waiting for $what ($url)"
}
# ---- configuration ---------------------------------------------------------
export SQLITE_DATABASE_URL="${SQLITE_DATABASE_URL:-$(dotenv_value SQLITE_DATABASE_URL)}"
[ -n "$SQLITE_DATABASE_URL" ] || die "SQLITE_DATABASE_URL is not set (env or src/client/.env)"
# Prisma resolves a relative file: URL against src/client/prisma, but the
# receiver and engine run from their own directories. Make it absolute so
# every service opens the same database.
case "$SQLITE_DATABASE_URL" in
file:/*) ;;
file:*)
sqlite_rel="${SQLITE_DATABASE_URL#file:}"
export SQLITE_DATABASE_URL="file:$CLIENT_DIR/prisma/${sqlite_rel#./}"
;;
esac
if [ -z "${UI_PORT:-}" ]; then
nextauth_url="$(dotenv_value NEXTAUTH_URL)"
UI_PORT="$(printf '%s' "$nextauth_url" | sed -nE 's#^https?://[^/:]+:([0-9]+).*#\1#p')"
UI_PORT="${UI_PORT:-3000}"
fi
port_busy "$UI_PORT" && die "UI port $UI_PORT is already in use; set UI_PORT"
OTLP_HTTP_PORT="$(pick_port OTLP_HTTP "${OTLP_HTTP_PORT:-4318}" 14318 "${OTLP_HTTP_PORT:-}")"
OTLP_GRPC_PORT="$(pick_port OTLP_GRPC "${OTLP_GRPC_PORT:-4317}" 14317 "${OTLP_GRPC_PORT:-}")"
NATS_PORT="${NATS_PORT:-4222}"
NATS_MONITOR_PORT="${NATS_MONITOR_PORT:-8222}"
ENGINE_HTTP_ADDR="${ENGINE_HTTP_ADDR:-127.0.0.1:4330}"
export INIT_DB_HOST="${INIT_DB_HOST:-127.0.0.1}"
export INIT_DB_PORT="${INIT_DB_PORT:-8123}"
export INIT_DB_USERNAME="${INIT_DB_USERNAME:-default}"
export INIT_DB_PASSWORD="${INIT_DB_PASSWORD:-OPENLIT}"
export INIT_DB_DATABASE="${INIT_DB_DATABASE:-openlit}"
# Per-session secrets. The engine secret is shared by the UI server and the
# engine; the cron secret keeps cron routes off the "true" fallback.
export CRON_JOB_SECRET="${CRON_JOB_SECRET:-$(openssl rand -hex 24)}"
export OPENLIT_ENGINE_SECRET="${OPENLIT_ENGINE_SECRET:-$(openssl rand -hex 24)}"
export NATS_URL="nats://127.0.0.1:${NATS_PORT}"
# NATS runs with assets/nats.conf, so dev exercises the production permissions.
NATS_CONF="$ROOT/assets/nats.conf"
export NATS_RECEIVER_PASSWORD="${NATS_RECEIVER_PASSWORD:-$(openssl rand -hex 16)}"
export NATS_ENGINE_PASSWORD="${NATS_ENGINE_PASSWORD:-$(openssl rand -hex 16)}"
# ---- process supervision ---------------------------------------------------
PIDS=()
STARTED_NATS=0
cleanup() {
trap - INT TERM EXIT
log "stopping..."
for pid in "${PIDS[@]:-}"; do
[ -n "$pid" ] && kill -TERM -- "-$pid" 2>/dev/null || true
done
sleep 1
for pid in "${PIDS[@]:-}"; do
[ -n "$pid" ] && kill -KILL -- "-$pid" 2>/dev/null || true
done
if [ "$STARTED_NATS" = 1 ] && [ "${KEEP_NATS:-0}" != 1 ]; then
docker rm -f "$NATS_CONTAINER" >/dev/null 2>&1 || true
fi
}
trap cleanup INT TERM EXIT
# Each service runs in its own process group so `go run` children and the
# Next.js worker tree are torn down together.
set -m
run() {
local name="$1" color="$2" dir="$3"
shift 3
(
cd "$dir"
exec "$@" 2>&1 | awk -v p="$(printf '\033[%sm[%s]\033[0m ' "$color" "$name")" '{ print p $0; fflush() }'
) &
PIDS+=("$!")
}
# ---- dependencies ----------------------------------------------------------
if ! curl -fsS -o /dev/null "http://${INIT_DB_HOST}:${INIT_DB_PORT}/ping" 2>/dev/null; then
log "ClickHouse not reachable on ${INIT_DB_HOST}:${INIT_DB_PORT}, starting it with docker compose"
# dev-docker-compose.yml uses `env_file: [{path, required}]`, added in Compose v2.24.
compose_version="$(docker compose version --short 2>/dev/null | sed 's/^v//')"
if [ -n "$compose_version" ] && [ "$(printf '%s\n' 2.24.0 "$compose_version" | sort -V | head -n 1)" != 2.24.0 ]; then
die "Docker Compose $compose_version is too old for src/dev-docker-compose.yml (needs v2.24+).
Upgrade Docker Compose, or start ClickHouse yourself and set INIT_DB_HOST/INIT_DB_PORT."
fi
OPENLIT_DB_USER="$INIT_DB_USERNAME" OPENLIT_DB_PASSWORD="$INIT_DB_PASSWORD" OPENLIT_DB_NAME="$INIT_DB_DATABASE" \
docker compose -f "$ROOT/src/dev-docker-compose.yml" up -d clickhouse
wait_for ClickHouse "http://${INIT_DB_HOST}:${INIT_DB_PORT}/ping" 180
fi
log "ClickHouse ready on ${INIT_DB_HOST}:${INIT_DB_PORT}"
NATS_BIN="$(command -v nats-server 2>/dev/null || true)"
[ -z "$NATS_BIN" ] && [ -x "$(go env GOPATH)/bin/nats-server" ] && NATS_BIN="$(go env GOPATH)/bin/nats-server"
if [ -n "$NATS_BIN" ] && [ "${NATS_USE_DOCKER:-0}" != 1 ]; then
port_busy "$NATS_PORT" && die "NATS port $NATS_PORT is already in use; set NATS_PORT"
NATS_STORE="${NATS_STORE:-${TMPDIR:-/tmp}/openlit-dev-nats}"
mkdir -p "$NATS_STORE"
log "starting $NATS_BIN (store: $NATS_STORE)"
run nats 34 "$ROOT" "$NATS_BIN" -c "$NATS_CONF" -sd "$NATS_STORE" \
-a 127.0.0.1 -p "$NATS_PORT" -m "$NATS_MONITOR_PORT"
wait_for "NATS JetStream" "http://127.0.0.1:${NATS_MONITOR_PORT}/healthz?js-enabled-only=true"
else
docker rm -f "$NATS_CONTAINER" >/dev/null 2>&1 || true
port_busy "$NATS_PORT" && die "NATS port $NATS_PORT is already in use; set NATS_PORT"
log "starting NATS in docker ($NATS_IMAGE); install nats-server locally to skip docker:"
log " go install github.com/nats-io/nats-server/[email protected]"
# Monitoring stays on loopback inside the container (see nats.conf).
docker run -d --name "$NATS_CONTAINER" \
-e NATS_RECEIVER_PASSWORD -e NATS_ENGINE_PASSWORD \
-v "$NATS_CONF:/etc/nats/nats.conf:ro" \
-p "127.0.0.1:${NATS_PORT}:4222" \
"$NATS_IMAGE" -c /etc/nats/nats.conf >/dev/null
STARTED_NATS=1
for _ in $(seq 1 60); do
docker exec "$NATS_CONTAINER" wget -qO- "http://127.0.0.1:8222/healthz?js-enabled-only=true" >/dev/null 2>&1 && break
sleep 1
done
if ! docker exec "$NATS_CONTAINER" wget -qO- "http://127.0.0.1:8222/healthz?js-enabled-only=true" >/dev/null 2>&1; then
# The container is removed on exit, so show its logs now.
docker logs --tail 30 "$NATS_CONTAINER" >&2 || true
die "timed out waiting for NATS JetStream; rerun, or install nats-server locally to skip docker"
fi
fi
log "NATS ready on $NATS_URL"
if [ "${SKIP_MIGRATE:-0}" != 1 ]; then
log "applying Prisma migrations"
(cd "$CLIENT_DIR" && npx prisma migrate deploy >/dev/null) || die "prisma migrate deploy failed for $SQLITE_DATABASE_URL.
Resolve it (https://pris.ly/d/migrate-resolve), point SQLITE_DATABASE_URL at another file, or rerun with SKIP_MIGRATE=1."
(cd "$CLIENT_DIR" && npx prisma generate >/dev/null)
if [ -n "${SEED:-}" ]; then
(cd "$CLIENT_DIR" && npx prisma db seed >/dev/null) || die "prisma db seed failed"
fi
fi
# ---- services --------------------------------------------------------------
run ui 35 "$CLIENT_DIR" env \
PORT="$UI_PORT" \
OPENLIT_ENGINE_URL="http://${ENGINE_HTTP_ADDR}" \
npm run dev -- --port "$UI_PORT"
run receiver 33 "$RECEIVER_DIR" env \
OTLP_HTTP_ADDR="127.0.0.1:${OTLP_HTTP_PORT}" \
OTLP_GRPC_ADDR="127.0.0.1:${OTLP_GRPC_PORT}" \
OTLP_STATS_ADDR="${OTLP_STATS_ADDR:-127.0.0.1:4319}" \
NATS_RECEIVER_USER=openlit-receiver \
go run ./cmd/otlp-receiver
run engine 32 "$ENGINE_DIR" env \
OPENLIT_URL="http://127.0.0.1:${UI_PORT}" \
ENGINE_HTTP_ADDR="$ENGINE_HTTP_ADDR" \
NATS_ENGINE_USER=openlit-engine \
go run ./cmd/openlit-engine
log "UI: http://localhost:${UI_PORT}"
log "OTLP HTTP: http://127.0.0.1:${OTLP_HTTP_PORT}"
log "OTLP gRPC: 127.0.0.1:${OTLP_GRPC_PORT}"
log "OTLP stats: http://${OTLP_STATS_ADDR:-127.0.0.1:4319}/stats"
log "Engine stats: curl -H \"X-OpenLIT-Engine-Secret: \$OPENLIT_ENGINE_SECRET\" http://${ENGINE_HTTP_ADDR}/stats"
log "press Ctrl+C to stop"
# bash 3.2 (macOS) has no `wait -n`; poll so one crashed service stops all.
while :; do
for pid in "${PIDS[@]}"; do
if ! kill -0 "$pid" 2>/dev/null; then
log "a service exited (pid $pid); shutting down"
exit 1
fi
done
sleep 1
done