Embedded Time-Series
Database for Rust

use std::time::Duration;
use tsink::{StorageBuilder, WalSyncMode, TimestampPrecision};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let storage = StorageBuilder::new()
        .with_data_path("./tsink-data")
        .with_timestamp_precision(TimestampPrecision::Milliseconds)
        .with_retention(Duration::from_secs(30 * 24 * 3600))          // 30 days
        .with_partition_duration(Duration::from_secs(6 * 3600))     // 6-hour partitions
        .with_chunk_points(4096)
        .with_max_writers(16)
        .with_write_timeout(Duration::from_secs(60))
        .with_memory_limit(1024 * 1024 * 1024)                   // 1 GB
        .with_cardinality_limit(500_000)
        .with_wal_sync_mode(WalSyncMode::Periodic(Duration::from_secs(1)))
        .with_wal_buffer_size(16384)
        .build()?;

    // Data survives restarts. WAL ensures durability on crash.
    // Retention auto-cleans data older than 30 days.
    // Memory budget prevents OOM with admission backpressure.

    storage.close()?;
    Ok(())
}

use tsink::{DataPoint, Label, Row, StorageBuilder};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let storage = StorageBuilder::new().build()?;

    // Insert with multi-dimensional labels
    storage.insert_rows(&[
        Row::with_labels(
            "http_requests",
            vec![
                Label::new("method", "GET"),
                Label::new("status", "200"),
                Label::new("endpoint", "/api/users"),
            ],
            DataPoint::new(1_700_000_000, 150.0),
        ),
        Row::with_labels(
            "http_requests",
            vec![
                Label::new("method", "POST"),
                Label::new("status", "201"),
            ],
            DataPoint::new(1_700_000_000, 25.0),
        ),
    ])?;

    // Query all label combinations for a metric
    let all = storage.select_all("http_requests", 1_700_000_000, 1_700_000_100)?;
    for (labels, points) in &all {
        println!("Labels: {:?}, Points: {}", labels, points.len());
    }

    storage.close()?;
    Ok(())
}

use tsink::{Aggregation, DataPoint, QueryOptions, Row, StorageBuilder};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let storage = StorageBuilder::new().build()?;

    storage.insert_rows(&[
        Row::new("cpu", DataPoint::new(1_000, 1.0)),
        Row::new("cpu", DataPoint::new(2_000, 2.0)),
        Row::new("cpu", DataPoint::new(3_000, 3.0)),
        Row::new("cpu", DataPoint::new(4_500, 1.5)),
    ])?;

    // Downsample: 2-second buckets with average aggregation
    let opts = QueryOptions::new(1_000, 5_000)
        .with_downsample(2_000, Aggregation::Avg)
        .with_pagination(0, Some(10));

    let buckets = storage.select_with_options("cpu", opts)?;
    assert_eq!(buckets.len(), 2);

    // 12 aggregation functions available:
    // Sum, Min, Max, Avg, First, Last, Count,
    // Median, Range, Variance, StdDev, None

    storage.close()?;
    Ok(())
}

// Enable with: tsink = { version = "0.8.0", features = ["promql"] }
use std::sync::Arc;
use tsink::{StorageBuilder, DataPoint, Row};
use tsink::promql::Engine;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let storage = StorageBuilder::new().build()?;

    storage.insert_rows(&[
        Row::new("http_requests_total", DataPoint::new(1_000, 10.0)),
        Row::new("http_requests_total", DataPoint::new(2_000, 25.0)),
        Row::new("http_requests_total", DataPoint::new(3_000, 50.0)),
    ])?;

    let engine = Engine::new(storage.clone());

    // Instant query — evaluates at a single point in time
    let result = engine.instant_query("http_requests_total", 3_000)?;

    // Range query — evaluates at each step across a time window
    let result = engine.range_query(
        "rate(http_requests_total[1m])",
        1_000, 3_000, 1_000,
    )?;

    // Supports: rate, irate, increase, avg_over_time, sum_over_time,
    // abs, ceil, floor, round, clamp, label_replace, label_join,
    // sort, sort_desc, scalar, vector, time, timestamp, and more

    storage.close()?;
    Ok(())
}

// Enable with: tsink = { version = "0.8.0", features = ["async-storage"] }
use tsink::{AsyncStorageBuilder, DataPoint, Row};

async fn run() -> tsink::Result<()> {
    let storage = AsyncStorageBuilder::new()
        .with_queue_capacity(1024)
        .with_read_workers(4)
        .build()?;

    // Async insert
    storage.insert_rows(vec![
        Row::new("cpu", DataPoint::new(1, 42.0)),
    ]).await?;

    // Async query
    let points = storage.select("cpu", vec![], 0, 10).await?;
    assert_eq!(points.len(), 1);

    // Synchronous introspection available too:
    // storage.memory_used(), storage.memory_budget(),
    // storage.inner(), storage.into_inner()

    storage.close().await?;
    Ok(())
}

use tsink::{SeriesSelection, SeriesMatcher, StorageBuilder};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let storage = StorageBuilder::new().build()?;
    // ... insert data ...

    // Matcher-based series discovery
    let selection = SeriesSelection::new()
        .with_metric("http_requests")
        .with_matcher(SeriesMatcher::equal("method", "GET"))
        .with_matcher(SeriesMatcher::regex_match("status", "2.."))
        .with_time_range(1_700_000_000, 1_700_100_000);

    let series = storage.select_series(&selection)?;

    // Matcher operators: = (equal), != (not_equal),
    //   =~ (regex_match), !~ (regex_no_match)

    // Also: list_metrics() and list_metrics_with_wal()
    let all_series = storage.list_metrics()?;
    for s in &all_series {
        println!("Metric: {}, Labels: {:?}", s.name, s.labels);
    }

    storage.close()?;
    Ok(())
}