SketchLog v1.2.5 - hosted product evaluation

Bounded-memory telemetry intelligence, proven before install.

See why teams use SketchLog, where it fits beside time-series databases, and how percentiles, cardinality, frequency, Streaming SQL, PostgreSQL durability, and OmniKV embedded storage work together.

Browser demo mode Local proof mode TSDB companion OmniKV optional
Start guided tour Open dashboard Star on GitHub
production / checkout / latency
SketchLog Live Dashboard bounded-memory telemetry cockpit
green / healthy
p99 latency 610 ms DDSketch, bounded memory
unique users 18.4k HyperLogLog-style estimate
SLO burn 2.1x canary risk elevated
top event timeout Count-Min-style counter
SELECT service, p99(latency_ms), approx_count_distinct(user_id)
FROM checkout_latency GROUP BY service
Memory demos PostgreSQL durable OmniKV embedded
Honest evaluation boundary

What runs here, and what needs your machine?

This page is intentionally static for GitHub Pages. It demonstrates product workflows with deterministic browser data and links to reproducible local proof commands for real services.

Browser demo mode

Runs fully in this page

DDSketch, stream simulation, dashboard scenarios, SQL examples, and exporter previews use local JavaScript only.

Local proof mode

Run Docker and storage proofs

Use the commands below to verify Docker smoke, PostgreSQL durability, and OmniKV embedded storage behavior locally.

Future live backend mode

Optional later endpoint

No private production service is implied here. A hosted backend can be added later with auth, rate limits, and isolation.

Guided product tour

Fourteen steps through the SketchLog workflow.

Use this as your launch-video spine: problem, sketches, streams, SQL, operations, proofs, then the call to action.

    Step 1 of 14

    Monster dashboard mode

    Explore realistic telemetry scenarios without sending data anywhere.

    Switch namespace and traffic mode to see percentiles, unique users, top events, SLO burn, canary risk, mesh status, and proof summaries update together.

    p50 latency - bounded-memory DDSketch
    p95 latency - tail latency signal
    p99 latency - incident-sensitive
    Unique users - HyperLogLog-style estimate
    Sessions - tenant-aware stream rollup
    Top event - Count-Min-style frequency
    Anomaly status - -
    SLO burn - 99.9% under 300 ms target
    Canary risk - before/after comparison

    Latency distribution

    live synthetic sample

    Sketch Mesh

    distributed aggregation view
    DDSketch quantile estimation

    Change the sample and watch p50, p95, and p99 update.

    Add positive values to a browser DDSketch implementation and inspect the bucket distribution plus relative-error guarantee.

    0.010
    Count-
    Min-
    Max-
    p50-
    p95-
    p99-
    Stream operations

    Stream Operations

    Write and read JSON records through the stream abstraction.

    This is an in-browser stream store so visitors can understand the API safely before running the real server.

    Records written: 0 Records read: 0
    Streaming SQL playground

    Run copyable SQL-style examples over deterministic sample telemetry.

    The results below are browser-side sample data. Use local proof mode for real Docker, PostgreSQL, and OmniKV-backed checks.

    Simulated result

    deterministic browser fixture
    Exporter payload preview

    Inspect payload shapes before connecting external systems.

    Preview Loki, Datadog, and New Relic request bodies. The page never sends these payloads anywhere.

    // Click Preview payload to generate
    // Click Preview payload to generate
    // Click Preview payload to generate
    Real proof section

    Reproduce the evidence locally instead of trusting marketing copy.

    These commands are the bridge from browser simulation to real service validation.

    Docker demo smoke

    End-to-end server stack

    docker compose -f demo/compose.yml up --build --wait
python demo/smoke.py
docker compose -f demo/compose.yml down -v
    PostgreSQL durability

    Crash/restart proof path

    python scripts/postgres_durability_proof.py --start --stop
    Unified storage proof

    Memory, PostgreSQL, OmniKV

    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
    Telemetry load proof

    Realistic API telemetry fixture

    python scripts/telemetry_load_proof.py --backend omnikv
    Demo guide PostgreSQL hardening Storage backends OmniKV storage
    Python API cheatsheet

    Python API Cheatsheet

    Move from the browser tour to local code quickly.

    Ready for the real run?

    Use this page for screenshots, then verify SketchLog locally.

    Start with the hosted playground, run the Docker smoke proof, inspect storage proofs, and star the project if the idea helps your telemetry work.

    Star SketchLog on GitHub Read documentation Run proof commands