Time-series

Code

Write it. Read it. Same engine.

INSERT INTO cpu_metrics (metric, value, tags) VALUES ('cpu.idle', 95.2, {"host":"srv1"});

SELECT time_bucket('5m', timestamp) AS bucket, AVG(value)
FROM cpu_metrics
WHERE metric = 'cpu.idle'
GROUP BY bucket ORDER BY bucket DESC LIMIT 12;

Build it

End-to-end walkthrough.

Four steps from empty database to a real time-series workload — each step shows the exact code and explains what the engine is doing.

1. Step 1

   1. Declare the time-series

   Retention is engine-managed — the storage drops chunks older than 90 days automatically, no cron job. CHUNK INTERVAL is the partition granularity; 1 day is sane for typical metric workloads.

   CREATE TIMESERIES metrics
     RETENTION 90 d
     CHUNK INTERVAL 1 d;

2. Step 2

   2. Insert points

   Tags are JSONB so you can store arbitrary dimensions without schema changes. The engine indexes the high-cardinality metric + tags axis automatically — queries filtering by host, region, etc, are sub-linear in row count.

   INSERT INTO metrics (timestamp, metric, value, tags) VALUES
     (now(), 'cpu.idle',     95.2, '{"host":"srv1","region":"gru"}'),
     (now(), 'cpu.user',      3.1, '{"host":"srv1","region":"gru"}'),
     (now(), 'memory.used', 4096,  '{"host":"srv1","region":"gru"}');

3. Step 3

   3. Aggregate with time_bucket

   time_bucket is a window function over the timestamp axis — the dashboarding workhorse. Combine with standard aggregates (AVG, percentile, MAX) and grouping by tags to get the chart-ready shape in one query.

   SELECT
     time_bucket('5 minutes', timestamp) AS bucket,
     tags->>'host'                      AS host,
     AVG(value)                         AS avg_idle,
     PERCENTILE_CONT(0.99)
       WITHIN GROUP (ORDER BY value)    AS p99_idle
   FROM metrics
   WHERE metric = 'cpu.idle'
     AND timestamp > now() - INTERVAL '6 hours'
   GROUP BY bucket, host
   ORDER BY bucket DESC;

4. Step 4

   4. Materialise a continuous aggregate

   Materialised views collapse millions of points into pre-aggregated rows the engine refreshes incrementally. The dashboard hits the view, not the raw collection — KPI queries resolve in milliseconds even after months of accumulated data.

   CREATE MATERIALIZED VIEW mv_metrics_kpi_1d AS
     SELECT
       time_bucket('1 day', timestamp) AS bucket,
       metric,
       AVG(value) AS avg_value
     FROM metrics
     WHERE metric IN ('cpu.idle','memory.used','storage.used','connections.active')
     GROUP BY bucket, metric;
   
   -- Daily KPI dashboard reads from the view, not from raw points.
   SELECT * FROM mv_metrics_kpi_1d
   WHERE bucket > now() - INTERVAL '30 days'
   ORDER BY bucket;

Showcases

What time-series can do once you bring the rest of the engine in.

Cross-model correlation, algorithm flex, multi-model patterns — things that take a stack of services elsewhere.

WITH latency_5m AS (
  SELECT
    time_bucket('5 minutes', timestamp) AS bucket,
    tags->>'tenant_id'                  AS tenant_id,
    PERCENTILE_CONT(0.99)
      WITHIN GROUP (ORDER BY value)     AS p99
  FROM metrics
  WHERE metric = 'request.latency'
    AND timestamp > now() - INTERVAL '15 minutes'
  GROUP BY bucket, tenant_id
)
SELECT t.name, l.bucket, l.p99, t.sla_p99_ms
FROM latency_5m l
JOIN tenants t ON t.id::text = l.tenant_id
WHERE l.p99 > t.sla_p99_ms
ORDER BY l.bucket DESC, l.p99 DESC;

CREATE MATERIALIZED VIEW mv_billing_daily AS
  SELECT
    time_bucket('1 day', timestamp) AS day,
    tags->>'org_id'                 AS org_id,
    metric_kind,
    SUM(quantity)                   AS total
  FROM billing_usage
  GROUP BY day, org_id, metric_kind;

-- Monthly invoice query (sub-millisecond — reads from the view).
SELECT org_id, metric_kind, SUM(total) AS month_total
FROM mv_billing_daily
WHERE day >= date_trunc('month', now())
GROUP BY org_id, metric_kind;

Recipes

Common patterns, real driver code.

CREATE MATERIALIZED VIEW mv_request_latency_5m AS
  SELECT
    time_bucket('5 minutes', timestamp) AS bucket,
    tags->>'route' AS route,
    PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY value) AS p99_ms
  FROM metrics
  WHERE metric = 'request.latency'
  GROUP BY bucket, route;

SELECT
  tags->>'org_id' AS org,
  metric,
  SUM(value) AS total
FROM billing_usage
WHERE timestamp >= date_trunc('month', now())
  AND timestamp <  date_trunc('month', now()) + INTERVAL '1 month'
GROUP BY org, metric
ORDER BY org, metric;

from reddb import connect
import time

db = connect("reds://admin@.../my-db:5050")
batch = []
for reading in sensor.stream():
    batch.append({
        "timestamp": time.time_ns() // 1_000_000,
        "metric": "temperature.celsius",
        "value": reading.value,
        "tags": {"device": reading.device_id, "site": reading.site}
    })
    if len(batch) >= 5000:
        db.timeseries.insert("metrics", batch)
        batch.clear()

vs

How RedDB time-series compare.

Pairs with

Time-series earns more next to these.

The data models time-series compose with — a click away.

• relational

  Tables →

  Join time-series points to the relational tables that name the entities — `users`, `services`, `tenants`. Enrichment in one query.

• sketches

  Probabilistic →

  Pipe a stream into a HyperLogLog for unique-cardinality summaries in fixed memory; pair with Count-Min for top-K.

• workflows

  Queues →

  Workers emit consume telemetry into the time-series — queue depth + p99 processing time visible in your existing dashboards.

Explore

Every other data model on RedDB.

One engine, 9 first-class data models. Mix as needed.

• relational

  Tables →

  Postgres-wire SQL with indexes, joins, transactions.

• json

  Documents →

  Schemaless JSON when structure is partial — query by path.

• edges

  Graphs →

  Native edges and traversals — multi-hop without a side-car.

• semantic

  Vectors →

  Auto-embed on insert, similarity search, no vector DB to sync.

• fast state

  Key-Value →

  Configuration, feature flags, hot keys — millisecond reads.

• tiered TTL

  Cache →

  Tiered blob cache built into the engine: L1 memory + L2 durable.

• workflows

  Queues →

  FIFO, priority, consumer groups — durable workflow primitives.

• sketches

  Probabilistic →

  HyperLogLog, Count-Min Sketch, Cuckoo Filter — bounded-memory analytics.