Orbtrace is the self-hosted observability platform built for SRE teams. It unifies logs, traces, and metrics with Causal RCA and Time-Travel Replay — powered by the LLM you pick: Claude, OpenAI, Azure OpenAI, Google Gemini, or a local Ollama. Runs entirely inside your network. OpenTelemetry-native. Air-gapped friendly. Docker Compose, Helm, or Ansible — your platform team's call.
Custom quote— unlimited hosts, no metering
$ orbtrace pilot init --license pilot-aug26.lic
→ docker compose up -d
✓ doris-fe started in 6.2s
✓ otelcol up · ports 4317, 4318
✓ orbtrace-server ready · http://localhost:8080
▸ Point your OTLP exporters at otel://localhost:4317
$ orbtrace query 'level:Error AND duration:>500'Root cause: deploy svc-payments@a91c2 introduced a long-running ledger.acct_lock tx. p99 across the checkout path increased by +412 ms. Rolling back resolves the incident.
Built on the open standards your platform team already runs
Logs, traces, and metrics live in the same OLAP store (Apache Doris). One query language. One UI. No more 'wait, which tab had this trace?'
Native inverted indexes (Apache Doris) deliver 3–10× faster full-text search than ClickHouse in our benchmarks. Drain-style template clustering surfaces anomalies (NEW · SPIKE · DROP) so you stop scrolling raw lines. Lucene-style key:value syntax — the same shape Kibana, Datadog, and Loki use.
Learn moreAsync/queue context reconstruction across Kafka, RabbitMQ, SQS, Redis Streams, NATS. Stitched parents shown with confidence scores you can trust.
Learn moreCardinality is a feature, not a billing line. Add as many tags as you need. Per-cluster license, predictable spend, no surprises at renewal.
Learn moreEight workflows where Orbtrace meaningfully changes how SRE teams operate. Pick the ones that hurt today.
Page-to-cause in minutes, not hours. Causal RCA names the suspect deploy, the upstream lock, the canary that tipped over — with span citations the on-call can verify.
Every service ships with multi-window, multi-burn-rate alerting (Google SRE handbook style). Burn-rate panels live next to the trace waterfall — no tool-switching.
Time-Travel Replay generates a counterfactual narrative: what would have happened without the deploy. Drop the result straight into your blameless post-mortem doc.
Aggregate p95/p99 latency and ingest-rate budgets per service. Cost-aware sampling exposes a real-dollar figure — not events/sec — so finance can sign off.
Point your existing OpenTelemetry SDKs at Orbtrace's OTel Collector. Keep your dashboards and alerts. We import Datadog metrics names where it makes sense.
Synchronous deletes, immutable audit log, RBAC, and per-tenant data partitioning. GDPR Art. 17 erasure and SOC 2 evidence collection are built in, not bolted on.
Hook Orbtrace into your CI: every PR gets a synthetic replay against last week's traffic. Reject deploys that would have spiked p99 — before they reach prod.
Stitch context across Kafka, RabbitMQ, SQS, Redis Streams, NATS. Confidence-scored stitched parents tell you which spans likely belong to the same business transaction.
Datadog, HyperDX-Cloud, New Relic — beautiful products that solved visibility for the public-cloud era. They're also a non-starter the moment your auditor reads the data-flow diagram.
Telemetry — every span, every log line, every metric — is ingested and stored on infrastructure you control. orbtrace.com hosts only this marketing site. There is no telemetry beacon, no usage call-home, no 'product analytics'.
Runs in environments with zero outbound internet. The Causal RCA engine can call the Claude API or a fully local model (Llama 3.3, Mistral Large, vLLM) — same grounded-RAG pipeline, same citation contract.
Fintech, healthcare, public sector, defence. Synchronous deletes, append-only audit log, GDPR Art. 17 erasure, SOC 2 Type II evidence collection, SSO/SAML, RBAC. Bring it into your compliance perimeter on day one.
One docker compose file for SMB teams. A Helm chart for Kubernetes shops. An Ansible playbook for bare-metal fleets. Three install paths, one product — because your platform team has opinions, and they're right.
No per-host, per-user, per-GB, per-metric, per-anything billing. Your invoice does not change because someone added a new tag. Ever. Renewal is identical to last year, plus or minus the cluster-tier delta.
We will not host your telemetry. That is not a product gap — it is a product principle. We exist because the cloud option is a non-starter for our customers, and we are not going to undermine that with a hosted tier.
Causal RCA gives you the answer. Time-Travel Replay lets you test the fix against history before you ship it.
Anomaly detection picks the incident window. Orbtrace retrieves the relevant spans, builds the service topology, and asks Claude to reason over your data. Every conclusion cites specific span IDs — if a citation doesn't hold, the conclusion is rejected.
# incident: i-9f3 — checkout p99 spike
cause: deploy svc-payments@a91c2
evidence: 312 spans · trace 7c91… · 12 deadlocks
impact: p99 +412ms · err 0.05 → 4.2%
fix: rollback · or release ledger.acct_lock contentionPick any moment and ask 'what if this deploy hadn't happened?' Orbtrace shows actual vs hypothesized timelines side-by-side, citing comparable past incidents and probabilistic confidence intervals.
The Causal RCA pipeline does not call an LLM and hope. It treats whichever model you pick (Claude, OpenAI, Azure OpenAI, Google Gemini, or a local Ollama instance) as a search-and-summarize layer over your spans — and rejects anything it can't cite back. The same engine powers the inline Explain action on any span, log line, or anomaly card.
STL decomposition + isolation forest run continuously over Doris aggregations. The moment a service's p99, error rate, or SLO burn drifts outside the seasonal envelope, an anomaly window opens.
anomaly.detect(
series = "checkout.p99",
window = "5m",
baseline = "trailing 4 weeks",
)
→ window opened: 12:34..12:39
→ anomaly_score = 0.94Orbtrace pulls the relevant spans, the service-topology graph, and recent timeline events (deploys, config changes, feature flags) for the anomaly window — straight out of Apache Doris.
retrieve.context(window = anomaly.window)
→ 312 spans fetched
→ topology: 14 services, 28 edges
→ timeline:
• 12:32 deploy svc-payments@a91c2
• 12:30 flag.checkout.fastpath = trueOrbtrace's AI router sends a grounded prompt to your configured provider — Claude by default, or OpenAI / Azure OpenAI / Google Gemini / a local Ollama model if you've switched in /admin/ai. The contract is strict: every claim must reference span IDs, otherwise it's rejected and the model is asked again.
llm.complete({
provider: env.ORBTRACE_AI_PROVIDER, // claude | openai | azure | ollama
system: orbtrace.rca.systemPrompt,
context: { spans, topology, timeline },
contract: "cite span_ids; no hallucination",
})
→ 3 candidate hypotheses
→ best hypothesis cites 312 spansCitations are checked: every cited span ID must resolve in Doris and match the claim. Hypotheses without verified citations are dropped — what reaches the on-call is grounded by construction.
verify.cite(hypothesis, citations = 312)
→ 312/312 spans resolve
→ hypothesis confidence = 0.91
→ stored in postgres + pgvector
→ similar incident lookup readyVerified hypotheses are embedded into pgvector and indexed alongside the incident timeline. The next time a similar pattern appears, on-call sees the past matches with their resolutions — institutional memory that survives team rotations.
recall.similar(
embedding = hypothesis.embedding,
k = 5,
threshold = 0.82,
)
→ 3 prior incidents matched
→ inc-2026-04-09 · resolved by deploy rollback
→ inc-2026-02-27 · resolved by ledger.acct_lock fix
→ on-call notified with playbook hintsCausal RCA and Time-Travel Replay route through Orbtrace's AI router over a provider you choose at deploy time. Switch any time from /admin/ai — no migration, no vendor lock-in, no compliance review on a model your security team didn't approve.
Default provider. Strongest behaviour on the grounded-citation contract — every hypothesis comes back with span IDs that resolve.
GPT-4o family. The model your security team has probably already approved; drop in an API key and you're running.
The enterprise Microsoft Copilot path — same OpenAI models, Azure compliance wrappers, your tenant, your region, your audit trail.
The Gemini family via Vertex AI. Opt into context caching to cut grounded-RCA input-token cost ~70% on long prompts.
Local-only models (Llama 3.3, Mistral, Qwen — whichever you pull). The required option for air-gapped deploys; works equally well for cost-sensitive teams.
Point Orbtrace at any OpenAI-compatible server — vLLM, TGI, LocalAI, or LM Studio — with optional custom-CA or skip-verify TLS.
One active provider per deployment so RCA citations stay consistent over time. The operator picks at deploy time and hot-switches via /admin/ai; existing incident records keep their original provider attribution.
No internet? Pick Ollama, pull your model of choice, point Orbtrace at the local endpoint. The entire AI surface — RCA, Replay, similar-incident embeddings — runs inside your network with zero outbound traffic.
Rules, channels, escalation, routing, schedules, silences and audit — all built in. Same data plane as RCA, so the alert that pages you links straight to the spans, traces, and topology behind it.
Metric thresholds, multi-window SLO burn rate, log-volume spikes, trace-rate anomalies, anomaly-score gates, heartbeat misses, and composite (any/all) rules. Every rule is YAML-as-code or UI-edited; both round-trip.
Slack, Microsoft Teams, PagerDuty, Opsgenie, Discord, Twilio SMS / Voice, Email (SMTP), Zoom and a generic JSON webhook (which also covers Mattermost and custom systems). Every channel ships a Test action so the on-call rota verifies delivery before they need it.
Multi-step escalation with explicit ACK tracking. If the primary on-call doesn't acknowledge in N minutes, the policy escalates to secondary, then to manager — with full audit of who saw what, when.
Route by service tag, severity, environment, or business hours. Same alert can page on-call out-of-hours and post to a #observability-low channel during the day. No duplicated rules.
Cron-based recurring maintenance windows for planned deploys, plus ad-hoc silences with explicit owner + reason + expiry. Nothing pages during a known maintenance — and nothing gets silently muted forever.
Every alert event (fire, ACK, escalate, resolve, silence) is logged to PostgreSQL with append-only semantics. Built-in analytics surface noisy rules, slow ACK channels, and policies that never fire — so you tune the system instead of it tuning you.
No external admin app, no second login, no glue dashboards. Every operator workflow — from drag-drop dashboards to per-service sampling budgets to air-gapped license activation — ships with the JAR.
/dashboardsDrag-drop panel composer with templated variables, multi-pillar panels (logs · traces · metrics in one widget), Visx-rendered charts, and a starter gallery. Share, fork, or pin to the home view.
/servicesAuto-discovered from span relationships — no manifest. Per-service health, dependency graph, traffic share, p50/p95/p99 baselines, and SLO burn — one click drills into spans + logs for that service.
/admin/slosPin per-service p95/p99 SLO targets. Latency baseline overrides feed the trace waterfall colouring; burn-rate alerts wire into the alerting platform automatically. Multi-window, multi-burn-rate — Google SRE workbook style.
/admin/samplingPer-service monthly $ budget with real-time burn. YAML editor, hot-reload to the OTel Collector tail_sampling processor. Errors, novel paths, SLO violations and p99 spans are always kept — only well-behaved background traffic is sampled.
/admin/healthOrbtrace observes Orbtrace. The server emits OTLP spans, logs, and metrics into its own pipeline — every deployment, every incident gets caught by the platform itself. The strongest possible product warranty.
/admin/licenseAir-gapped activation via offline token (no internet call, ever). RBAC with role inheritance, OIDC / SAML SSO, per-tenant data partitioning, and short-lived JWT with refresh-token rotation.
Tempo gives you traces. Loki gives you logs. Prometheus gives you metrics. Orbtrace gives you all three plus the diagnosis story on top — without sending a byte to a third party, and powered by the LLM you already trust.
Adaptive buffers preserve every error and SLO-violating trace during incidents — exactly when you need them.
Automatic async/queue context reconstruction across Kafka, RabbitMQ, SQS, Redis Streams, NATS. No more orphan spans.
Per-service monthly budgets in real dollars. Sampling never touches the error path. Predictable spend, no custom-metric tax.
Grounded RAG over retrieved spans and topology. Every conclusion cites specific span IDs — no hallucination, no matter which provider you pick.
Claude, OpenAI, Azure OpenAI, Google Gemini, local Ollama, or any OpenAI-compatible server — operator picks at deploy time. Hot-switch via /admin/ai. No vendor lock-in, no model your security team didn't approve.
Counterfactual queries on history: what if this deploy hadn't happened? Side-by-side actual vs hypothesized timelines.
STL decomposition + isolation forest run continuously over Doris aggregations. Detects p99, error-rate, and SLO-burn drift outside the seasonal envelope — feeds RCA and the alerting platform without any model tuning.
Each span coloured against its own service's recent p50/p95/p99 — not a one-size-fits-all 50ms/1s/5s scale. A 1.2s span is fast on a batch service, alarming on auth. Orbtrace knows the difference.
Pin per-service p95/p99 contracts. The waterfall paints every span against the promise you made — green when within target, rose when over. The accountability story SREs actually want.
Service graph built from span relationships — no manifest, no manual map. Per-service health, dependency direction, and traffic share are first-class. Click any node to drill into spans, logs, and SLO burn for that service.
Logs, traces, metrics in a single OLAP store (Apache Doris). One query language. No more pivot-tab fatigue.
Orbtrace ingests through the OpenTelemetry Collector and stores in Apache Doris — the same composable pattern HyperDX, SigNoz, and Uptrace chose. The product layer is where Orbtrace earns its keep: Causal RCA, Time-Travel Replay, async stitching, cost-aware sampling.
OpenTelemetry SDK · auto-instrument
Doris exporter · tail sampling · async stitching
logs · traces · metrics · OLAP
query · RCA · replay · alerting
search · dashboards · alerts · admin
services:
otelcol:
image: otel/opentelemetry-collector-contrib:latest
command: ["--config=/etc/otel/config.yaml"]
volumes: ["./otelcol-config.yaml:/etc/otel/config.yaml"]
ports: ["4317:4317", "4318:4318"]
doris-fe:
image: apache/doris:fe-3.0.x
environment: [DORIS_USER, DORIS_PASSWORD]
orbtrace:
image: nivorbit/orbtrace:0.1
depends_on: [doris-fe, postgres, valkey]
ports: ["8080:8080"]
environment:
ORBTRACE_DORIS_URL: jdbc:mysql://doris-fe:9030/orbtrace
ORBTRACE_PG_URL: jdbc:postgresql://postgres:5432/orbtrace
ORBTRACE_AI_PROVIDER: anthropicreceivers:
otlp: { protocols: { grpc: { endpoint: 0.0.0.0:4317 },
http: { endpoint: 0.0.0.0:4318 } } }
processors:
batch: { send_batch_size: 100000, timeout: 10s }
exporters:
doris:
endpoint: http://doris-fe:8030
mysql_endpoint: doris-fe:9030
database: orbtrace
create_schema: false # Orbtrace owns the schema
service:
pipelines:
traces: { receivers: [otlp], processors: [batch], exporters: [doris] }
logs: { receivers: [otlp], processors: [batch], exporters: [doris] }
metrics: { receivers: [otlp], processors: [batch], exporters: [doris] }Orbtrace is OpenTelemetry-native. Keep your existing SDK choices — JVM, Node, Go, Python, Rust, .NET, Ruby, PHP, or any other OpenTelemetry SDK. Point the OTLP exporter at the bundled Collector and you're ingesting in seconds.
// build.gradle.kts
implementation("io.opentelemetry.instrumentation:opentelemetry-spring-boot-starter")
# application.yml
otel:
exporter:
otlp:
endpoint: http://orbtrace-otelcol:4317
protocol: grpc
service:
name: checkout-api
resource:
attributes:
deployment.environment: prod// Program.cs
builder.Services.AddOpenTelemetry()
.ConfigureResource(r => r.AddService("checkout-api"))
.WithTracing(t => t
.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddOtlpExporter(o =>
{
o.Endpoint = new Uri("http://orbtrace-otelcol:4317");
o.Protocol = OtlpExportProtocol.Grpc;
}));// main.go
import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
)
exp, _ := otlptracegrpc.New(ctx,
otlptracegrpc.WithEndpoint("orbtrace-otelcol:4317"),
otlptracegrpc.WithInsecure())
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(exp),
sdktrace.WithResource(resource.Default()))
otel.SetTracerProvider(tp)// instrumentation.ts
import { NodeSDK } from "@opentelemetry/sdk-node";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
new NodeSDK({
serviceName: "checkout-api",
traceExporter: new OTLPTraceExporter({
url: "http://orbtrace-otelcol:4317",
}),
instrumentations: [getNodeAutoInstrumentations()],
}).start();# bootstrap.py
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
provider = TracerProvider()
provider.add_span_processor(
BatchSpanProcessor(
OTLPSpanExporter(endpoint="orbtrace-otelcol:4317", insecure=True)
)
)
trace.set_tracer_provider(provider)# No SDK? Any language that can POST JSON works.
curl -X POST http://orbtrace-otelcol:4318/v1/traces \
-H 'Content-Type: application/json' \
-d '{
"resourceSpans": [{
"resource": { "attributes": [
{ "key": "service.name", "value": { "stringValue": "checkout-api" } }
]},
"scopeSpans": [{ "spans": [{
"name": "POST /checkout",
"traceId": "5b8aa5a2d2c872e8321cf37308d69df2",
"spanId": "051581bf3cb55c13",
"kind": 2,
"startTimeUnixNano": "1714000000000000000",
"endTimeUnixNano": "1714000000231000000"
}]}]
}]
}'# values.yaml — Helm
otelCollector:
endpoint: orbtrace-otelcol.observability.svc.cluster.local:4317
sampling:
policyEndpoint: http://orbtrace.observability.svc:8080/api/sampling/decision
budget: { service: checkout-api, monthly: $400 }
auth:
oidc:
issuer: https://keycloak.your-company.internal
audience: orbtrace-- Find every span that touched the deadlock during the incident.
SELECT trace_id, span_id, service_name, duration_ms, status_code
FROM otel_traces
WHERE timestamp BETWEEN '2026-04-29 12:32:00' AND '2026-04-29 12:39:00'
AND span_attributes['db.statement'] LIKE '%acct_lock%'
AND status_code = 'ERROR'
ORDER BY duration_ms DESC
LIMIT 312;Whole-word match by default, wildcards with *, booleans (AND / OR / -), properties, ranges, existence, quoted exact match, and natural-language time. The same query shape Kibana, Datadog, Loki, and HyperDX use — your engineers are productive on day one.
level:Error AND service:checkout-apiAll errors from one service
"connection refused" AND -region:eu-westQuoted exact match, exclude a region
duration:>1000 AND http.status:>=500Slow server-error spans only
trace.id:7c91* OR span.parent:*Wildcards on IDs and existence
deploy:svc-payments@a91c2 in last 1 hourNatural-language time windows
anomaly_score:>0.8 AND rca_correlation_id:*Filter on Orbtrace-only enrichment
No proprietary protocols. No bespoke storage engine. Just well-known building blocks composed into a self-hosted product.
Ingestion is the OTel Collector's job — we don't reinvent it. Orbtrace earns its keep on what comes after: Causal RCA, Time-Travel Replay, async stitching, cost-aware sampling, alerting.
No proprietary protocol. No agent rewrite. If it speaks OpenTelemetry, OIDC, SAML, or a webhook, it works with Orbtrace today — on your servers.
Don't see what you need? The OpenTelemetry exporter, webhook alerter, and OIDC adapter cover >90% of the long tail. Webhook translators map deploy + feature-flag events from GitHub, GitLab, LaunchDarkly and a generic JSON shape onto the incident timeline — auto-correlation with no glue code. See the full integration catalogue →
Self-hosting alone is not compliance. We've sat across the table from enough auditors to know what evidence they ask for — and built it in from day one.
Telemetry stays inside your perimeter — full stop. Orbtrace ships as a single docker compose, a Helm chart, or an Ansible playbook for bare-metal. No call-home, no telemetry of telemetry.
OIDC and SAML 2.0 out of the box. RBAC with role inheritance and per-service data filtering — managed in /admin/users with audit on every grant. Per-tenant partitioning, short-lived JWTs with refresh-token rotation. Zero-trust by default.
Every authentication event, query, deletion, and config change is logged to PostgreSQL with append-only semantics. Export to your SIEM via webhook or Kafka.
Synchronous deletes in Apache Doris mean a GDPR Art. 17 erasure request actually erases — not eventually, but by the time the API returns 204.
TLS 1.3 in transit, AES-256-GCM at rest, FIPS-140-2 mode for regulated workloads. Bring your own KMS — HashiCorp Vault, AWS KMS, GCP KMS, or PKCS#11 HSM.
Built to support SOC 2 Type II, ISO 27001, and HIPAA evidence collection. Pre-built control mappings for your auditor — we've done the spreadsheet.
Want our security packet (architecture diagrams, threat model, control mappings)? Email security@nivorbit.com →
We use the same OpenTelemetry primitives as everyone else. The difference is what we build on top — and the fact that we will never ask you to ship telemetry off-prem.
Comparison reflects publicly available capabilities as of June 2026. We are not affiliated with these projects.
Datadog wanted us to ship customer PII through a public-cloud SaaS. That was a non-starter for our compliance team. Orbtrace runs in our DMZ and the RCA quality has significantly improved our mean-time-to-understanding.
We replaced a Tempo + Loki + Grafana stack and the on-call experience changed overnight. The incident page links to relevant spans and citations. We're not going back.
Time-Travel Replay let me prove to leadership that the rollback was the right call without re-running the broken deploy. That was the moment I sold the team on Orbtrace.
Quotes are from design partners under NDA. Logos available on request.
Commercial on-prem software with a single annual licence — quoted per deployment so procurement gets one clean number, not a calculator. No tiers, no per-user / per-host / per-GB billing — capacity scales with your hardware, not your contract. Optional services (pilot, hourly support, implementation) are quoted separately so you only pay for what you actually use.
Single annual fee. Unlimited Doris BE nodes, unlimited services, unlimited users. Renewal years are maintenance + support only.
Full product in your environment, real workloads, sales-led onboarding. Convert or walk away.
Slack channel, 8h response SLA, troubleshooting + custom dashboard help. Pay only for hours actually used — no retainer.
2-4 week fixed-bid engagement — cluster sizing, hardening, observability standup, custom dashboard portfolio.
Shift from metered SaaS to predictable on-premise observability — your data stays in your network.
Sales-led. No download portal, no shared installer. Every deployment goes through onboarding so the cluster is sized, hardened, and observable from the first hour.
Yes. There is no Orbtrace SaaS — we deploy as a single docker compose (or Helm chart, or Ansible playbook) inside your network. Our cloud only hosts the marketing site. Your telemetry never leaves your infrastructure.
Doris speaks the MySQL wire protocol — zero learning curve for Java teams and any tool that talks SQL. It also ships native inverted indexes that beat ClickHouse on full-text log search by 3–10× in our benchmarks, has synchronous deletes (important for GDPR), and simpler cluster management.
Doris stores every span with full attribute history — immutable. Replay builds a timeline of deploys, config changes, and feature-flag toggles, then asks the RCA engine to reason about a counterfactual using past comparable incidents. The output is a probabilistic timeline with confidence intervals, never a deterministic claim.
Sales-led, on-prem only. One annual licence covers unlimited hosts, services, and users — no tiers, no per-user / per-host / per-GB metering anywhere. Pricing is quoted per deployment so customers with strict procurement or compliance constraints get a clean number rather than a calculator. Optional services (30-day pilot, $200-300/hr premium support, $15K+ fixed-bid implementation projects) are quoted separately so you only pay for what you actually consume.
Native senders for all three, plus Microsoft Teams, Discord, Zoom, Twilio SMS/Voice and email — and a generic signed JSON webhook that covers Mattermost or any custom system. Alert rules are defined as code (YAML / Terraform provider) and stored in PostgreSQL. Multi-window, multi-burn-rate SLO alerts are first-class — same model as Google's SRE workbook.
Two primitives. Maintenance Windows (cron-based) suppress matching alerts on a recurring schedule — perfect for nightly batch jobs or weekly deploys. Ad-hoc Silences are one-off, with required owner + reason + auto-expiry so nothing gets muted forever. Both are managed in /admin/alerts and audited like every other policy change.
We dogfood it. Every Orbtrace server emits OTLP spans, logs, and metrics into its own pipeline, and our engineering team's incident response uses this exact product. /admin/health surfaces the self-monitoring view so operators can verify the platform is observing itself before they trust it with their workloads.
Only if you pick a hosted provider. Causal RCA defaults to Anthropic Claude, but at deploy time you can switch to OpenAI, Azure OpenAI, Google Gemini, or a local Ollama endpoint via /admin/ai. Air-gapped customers run Ollama (Llama 3.3, Mistral, Qwen — whichever they pull) with zero outbound traffic. The grounded-RAG pipeline is identical across providers — citations to span IDs are mandatory either way.
No — Orbtrace is OpenTelemetry-native. Point your existing OTLP exporters at the bundled OTel Collector and you're done. We do not require any proprietary SDK or agent.
Sampling never touches the error path or anomalies. The policy endpoint Orbtrace exposes to the OTel Collector's tail_sampling processor enforces hard rules: errors, novel paths, SLO violations, and p99-latency spans are always kept. Only well-behaved background traffic is sampled when budget pressure is high.
Plan for 8 GB RAM as the realistic floor — the default Compose stack runs three Doris storage nodes, so 4 GB only works if you trim Doris to a single node. Production starts around 2 vCPU / 8 GB RAM for the orbtrace-server JAR plus a single-node Doris (4 vCPU / 16 GB); for real production traffic plan for 16–32 GB RAM and SSD storage. A 3-node Doris cluster comfortably ingests 100K+ events/sec on modest hardware.
Yes. Set ORBTRACE_AI_PROVIDER=ollama and point Orbtrace at a local Ollama endpoint. We've benchmarked Llama 3.3 70B and Mistral Large for grounded-RAG quality and ship recommended prompts for both. Connected deploys can equally well stay on Anthropic Claude (default), OpenAI, Azure OpenAI, or Google Gemini — same /admin/ai surface, same RCA contract.
Upload an offline license token at /admin/license. The server validates the signature locally and unlocks features — no internet call, no phone-home, ever. Renewal works the same: a fresh token from sales, dropped into the same screen. The only network egress Orbtrace makes is the OTLP / SMTP / webhook traffic you explicitly configure.
Pilot Orbtrace inside your network for 30 days. Bring real telemetry, watch Causal RCA hypotheses land during the first incident.
On-prem only. No telemetry beacon, no usage call-home. Your data never leaves your network — including during the pilot.