Observe every stream without storing every event.
SketchLog turns high-volume telemetry into compact, mergeable sketches for latency percentiles, unique counts, event frequencies, anomalies, SLOs, canary analysis, and distributed monitoring.
Built for teams that cannot afford to keep every raw event.
Modern systems generate more telemetry than teams can store, query, and pay for. SketchLog keeps the operational signal: distributions, cardinality, frequencies, drift, and release risk.
Compress the signal, not the story.
Turn millions of latency samples, user IDs, and events into compact sketches that remain useful for real-time decisions.
Ask production questions directly.
Track p95, p99, unique users, top events, SLO burn rate, anomaly signals, and canary risk without replaying raw logs.
Merge views across services and regions.
Sketches are compact and mergeable, making them practical for federation, namespaces, edge workloads, and multi-tenant systems.
A complete sketch-based observability layer.
SketchLog combines streaming data structures with production workflows, APIs, dashboards, and integrations for real systems.
Try SketchLog in the browser before installing anything.
The hosted playground is a zero-dependency static demo. It works offline, uses no external CDN, stores no secrets, and shows the same sketch concepts behind the production package.
Start with a simple local demo. Grow into production pipelines.
SketchLog is designed to be easy to try and credible to operate. Run it locally with Docker, send telemetry through SDKs or OpenTelemetry Collector, query it from APIs, and visualize results in Grafana or the live dashboard.
# run the local SketchLog demo stack git clone https://github.com/SBALAVIGNESH123/sketchlog cd sketchlog/demo docker compose up -d # verify the stack python smoke.py Launch demo smoke verification passed. # query SketchLog directly curl http://localhost:8000/v1/streams/api.latency curl http://localhost:8000/metrics
One engine for real-time stream intelligence.
SketchLog is not a log warehouse or a full APM replacement. It is a lightweight observability layer for the high-cardinality, high-volume questions that become expensive with raw event storage.
Measure production latency
Capture p50, p95, p99, and tail shifts for APIs, workers, queues, RPC systems, and edge services.
Understand release risk
Use canary analysis, sketch diffing, SLO burn-rate signals, and anomaly scores to decide whether a rollout is safe.
Control telemetry cost
Store compact sketches for operational decisions instead of retaining every raw event forever.
Choose the right backend and reproduce the evidence.
SketchLog stores compact stream summaries instead of raw telemetry rows. The proof suite shows how each backend behaves across write, query, restart, and recovery paths.
These are deterministic proof-fixture numbers, not a universal benchmark. They demonstrate bounded-memory behavior, Streaming SQL aggregates, cardinality, top counters, and durable recovery where configured.
# backend correctness proof python scripts/storage_proof.py --backend memory python scripts/storage_proof.py --backend postgres --postgres-start --postgres-stop python scripts/storage_proof.py --backend omnikv # realistic telemetry load proof python scripts/telemetry_load_proof.py --backend omnikv PASS SketchLog telemetry load proof
Designed to complement your observability stack.
Use SketchLog alongside logs, metrics, traces, Prometheus, Grafana, and OpenTelemetry when you need compact distribution-aware analytics over high-volume streams.
| Need | Traditional approach | SketchLog approach |
|---|---|---|
| Tail latency | Store raw events or pre-aggregate fixed histograms. | Use mergeable DDSketch distributions with configurable accuracy. |
| Unique users | Deduplicate raw IDs or maintain large sets. | Track cardinality with compact probabilistic sketches. |
| Event frequency | Count every key and pay for high cardinality. | Estimate frequent events with bounded-memory Count-Min structures. |
| Release safety | Manually compare dashboards after deployment. | Run canary analysis with distribution drift, SLO risk, and event deltas. |
| Distributed views | Centralize raw telemetry before querying. | Merge compact peer snapshots across services, tenants, and regions. |
Fits into standard engineering workflows.
SketchLog ships with practical integration points so teams can adopt it without rebuilding their telemetry stack.
# example: canary analysis curl -X POST http://localhost:8000/v1/canary/analyze \ -H 'content-type: application/json' \ -d '{ "baseline_stream": "production.checkout.latency", "candidate_stream": "canary.checkout.latency", "error_event_name": "checkout_failed" }' { "verdict": "warning", "p99_shift_percent": 18.4, "slo_burn_rate_increase": 1.8, "summary": "Candidate shows elevated rollout risk." }
Turn sketches into decisions, not just charts.
The value is not only compact storage. SketchLog connects stream summaries to operational workflows: anomaly detection, SLO burn-rate evaluation, canary release analysis, namespace isolation, and distributed sketch federation.
For platform teams
Use namespaces, quotas, mesh federation, production checks, and storage backends to operate telemetry as shared infrastructure.
For product engineers
Answer practical questions about latency, user impact, event spikes, and release safety without building custom analytics.
Try SketchLog locally, then bring it into your stack.
Run the demo, inspect the APIs, connect Grafana or OpenTelemetry Collector, and decide if sketch-based observability fits your workload.
git clone https://github.com/SBALAVIGNESH123/sketchlog
cd sketchlog/demo
docker compose up -d
The demo includes the server, telemetry generator, dashboard, metrics endpoint, and smoke verifier.