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
package main
import (
"context"
"crypto/subtle"
"encoding/json"
"errors"
"log"
"net/http"
"os"
"os/signal"
"regexp"
"strconv"
"strings"
"sync/atomic"
"syscall"
"time"
"github.com/nats-io/nats.go"
"github.com/nats-io/nats.go/jetstream"
"github.com/openlit/openlit/engine/internal/api"
"github.com/openlit/openlit/engine/internal/config"
"github.com/openlit/openlit/engine/internal/engine"
sig "github.com/openlit/openlit/engine/internal/signal"
)
const (
subjectFilter = "openlit.signal.>"
// inboxPrefix gives the engine its own reply subjects so NATS permissions
// can keep it from reading the receiver's publish acknowledgements.
inboxPrefix = "_INBOX_ENGINE"
)
func main() {
cfg := config.Load()
if cfg.EngineSecret == "" {
log.Fatal("openlit-engine: OPENLIT_ENGINE_SECRET is required. Set the same value for the engine and the OpenLIT server (the Docker image generates one per install).")
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
client := api.New(cfg.OpenLITURL, cfg.EngineSecret)
defer client.Close()
eng := engine.New(client)
eng.SetLimits(engine.Limits{
MaxWindows: cfg.Limits.MaxWindows,
MaxWindowsPerTenant: cfg.Limits.MaxWindowsPerTenant,
MaxWindowsPerRule: cfg.Limits.MaxWindowsPerRule,
MaxSamplesPerWindow: cfg.Limits.MaxSamplesPerWindow,
FindingsPerMinute: cfg.Limits.FindingsPerMinute,
})
var rejected atomic.Uint64
go refreshRules(ctx, client, eng, cfg.RulesInterval)
go tick(ctx, eng, cfg.TickInterval)
go serveHTTP(ctx, cfg.HTTPAddr, cfg.EngineSecret, eng, func() any {
return map[string]any{"engine": eng.Stats(), "delivery": client.Stats(), "rejected": rejected.Load()}
})
opts, err := natsOptions(cfg)
if err != nil {
log.Fatalf("nats: %v", err)
}
nc, err := nats.Connect(cfg.NATSURL, opts...)
if err != nil {
log.Fatalf("nats: %v", err)
}
defer nc.Drain()
js, err := jetstream.New(nc)
if err != nil {
log.Fatalf("jetstream: %v", err)
}
consumeCtx, err := consume(ctx, js, cfg, func(msg jetstream.Msg) {
var s sig.Signal
if err := json.Unmarshal(msg.Data(), &s); err != nil || !subjectMatches(msg.Subject(), s) {
rejected.Add(1)
return
}
at := time.Now()
if md, err := msg.Metadata(); err == nil {
at = md.Timestamp
}
eng.Observe(s, at)
})
if err != nil {
log.Fatalf("consume: %v", err)
}
log.Printf("openlit-engine consuming %s from stream %s", subjectFilter, cfg.Stream)
<-ctx.Done()
consumeCtx.Stop()
}
func natsOptions(cfg config.Config) ([]nats.Option, error) {
opts := []nats.Option{
nats.Name("openlit-engine"),
nats.RetryOnFailedConnect(true),
nats.MaxReconnects(-1),
nats.ReconnectWait(2 * time.Second),
nats.CustomInboxPrefix(inboxPrefix),
}
switch {
case cfg.NATSCreds != "":
opts = append(opts, nats.UserCredentials(cfg.NATSCreds))
case cfg.NATSToken != "":
opts = append(opts, nats.Token(cfg.NATSToken))
case cfg.NATSUser != "":
opts = append(opts, nats.UserInfo(cfg.NATSUser, cfg.NATSPassword))
default:
log.Printf("nats: no credentials configured; production NATS must require auth")
}
tls := cfg.NATSTLS
if (tls.CertFile == "") != (tls.KeyFile == "") {
return nil, errors.New("NATS_TLS_CERT and NATS_TLS_KEY must be set together")
}
if tls.CAFile != "" {
opts = append(opts, nats.RootCAs(tls.CAFile))
}
if tls.CertFile != "" {
opts = append(opts, nats.ClientCert(tls.CertFile, tls.KeyFile))
}
if tls.Required {
opts = append(opts, nats.Secure())
}
return opts, nil
}
// consume waits for the stream to exist, then replays the last cfg.Replay of
// signals through an ordered consumer so windows are rebuilt after restarts.
func consume(ctx context.Context, js jetstream.JetStream, cfg config.Config, handle func(jetstream.Msg)) (jetstream.ConsumeContext, error) {
var lastErr string
for {
start := time.Now().Add(-cfg.Replay)
cons, err := js.OrderedConsumer(ctx, cfg.Stream, jetstream.OrderedConsumerConfig{
FilterSubjects: []string{subjectFilter},
DeliverPolicy: jetstream.DeliverByStartTimePolicy,
OptStartTime: &start,
})
if err == nil {
log.Printf("engine: consuming stream %s", cfg.Stream)
return cons.Consume(handle)
}
if err.Error() != lastErr {
lastErr = err.Error()
log.Printf("engine: waiting for stream %s: %v", cfg.Stream, err)
}
select {
case <-ctx.Done():
return nil, ctx.Err()
case <-time.After(5 * time.Second):
}
}
}
func refreshRules(ctx context.Context, client *api.Client, eng *engine.Engine, every time.Duration) {
load := func() {
reqCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
rs, err := client.FetchRules(reqCtx)
if err != nil {
log.Printf("engine: fetch rules: %v", err)
return
}
log.Printf("engine: %d active rules", eng.SetRules(rs))
}
load()
t := time.NewTicker(every)
defer t.Stop()
fast := time.NewTicker(5 * time.Second)
defer fast.Stop()
for {
select {
case <-ctx.Done():
return
case <-fast.C:
if eng.Stats().Rules == 0 {
load()
}
case <-t.C:
load()
}
}
}
func tick(ctx context.Context, eng *engine.Engine, every time.Duration) {
t := time.NewTicker(every)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
eng.Tick()
}
}
}
func serveHTTP(ctx context.Context, addr, secret string, eng *engine.Engine, stats func() any) {
mux := http.NewServeMux()
mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
_, _ = w.Write([]byte("ok"))
})
mux.HandleFunc("/stats", func(w http.ResponseWriter, r *http.Request) {
if !secretEqual(r.Header.Get(api.SecretHeader), secret) {
w.WriteHeader(http.StatusUnauthorized)
return
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(stats())
})
mux.HandleFunc("/signals", func(w http.ResponseWriter, r *http.Request) {
signalsHandler(w, r, secret, eng)
})
srv := &http.Server{Addr: addr, Handler: mux, ReadHeaderTimeout: 5 * time.Second}
go func() {
<-ctx.Done()
_ = srv.Close()
}()
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Printf("engine http: %v", err)
}
}
var tenantToken = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$`)
func secretEqual(got, want string) bool {
if got == "" || want == "" || len(got) != len(want) {
return false
}
return subtle.ConstantTimeCompare([]byte(got), []byte(want)) == 1
}
// signalsHandler lists recent signals for one tenant. The caller must send the
// engine secret; the response never includes another tenant's spans.
func signalsHandler(w http.ResponseWriter, r *http.Request, secret string, eng *engine.Engine) {
if r.Method != http.MethodGet {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
if !secretEqual(r.Header.Get(api.SecretHeader), secret) {
w.WriteHeader(http.StatusUnauthorized)
return
}
q := r.URL.Query()
org, project, env := q.Get("organisation_id"), q.Get("project_id"), strings.ToLower(q.Get("environment"))
if !tenantToken.MatchString(org) || !tenantToken.MatchString(project) || !tenantToken.MatchString(env) {
w.WriteHeader(http.StatusBadRequest)
return
}
limit := 100
if raw := q.Get("limit"); raw != "" {
n, err := strconv.Atoi(raw)
if err != nil || n < 1 || n > 200 {
w.WriteHeader(http.StatusBadRequest)
return
}
limit = n
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{
"signals": eng.Recent(org, project, env, limit),
})
}
// subjectMatches rejects messages whose payload tenant differs from the
// subject tenant, so a misrouted or forged payload cannot be evaluated under
// another tenant's identity.
func subjectMatches(subject string, s sig.Signal) bool {
parts := strings.Split(subject, ".")
if len(parts) != 5 || parts[0] != "openlit" || parts[1] != "signal" {
return false
}
return parts[2] == s.OrganisationID && parts[3] == s.ProjectID && parts[4] == envToken(s.Environment) && parts[4] != ""
}
func envToken(env string) string {
var b strings.Builder
for _, r := range strings.TrimSpace(env) {
switch {
case r == '_':
b.WriteString("__")
case r == '.':
b.WriteString("_d")
case r == '-' || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9'):
b.WriteRune(r)
default:
return ""
}
}
return b.String()
}