Getting Started with the SDK

cargo add nerve-sdk

# With compression support:
cargo add nerve-sdk --features full

use nerve_sdk::{NerveClient, NerveConfig, SchemaId};
use std::time::Duration;

let config = NerveConfig::new("127.0.0.1:4433")
    .with_queue_capacity(10_000)       // in-memory buffer
    .with_batch_size(1_400)            // MTU-sized batches
    .with_flush_interval(Duration::from_millis(10));  // 100 Hz max flush

let client = NerveClient::connect(config).await?;
// Connection probe: full TLS 1.3 handshake + teardown
// Background SendWorker spawned automatically

// From a FlatBuffers schema file:
let schema = SchemaId::from_file("schemas/fleet_gps_v2.fbs")?;

// Or from raw bytes:
let schema = SchemaId::from_bytes(b"my_sensor_schema_v1");

// Or a known constant:
let schema = SchemaId::new(0x00000002);

loop {
    let payload = read_sensor_data();

    // Non-blocking: ~50 ns, pushes to in-memory queue
    client.send_raw(schema, &payload)?;

    // Or with explicit priority:
    // client.send_priority(schema, &payload, Priority::Critical)?;

    tokio::time::sleep(Duration::from_millis(100)).await; // 10 Hz
}

// Check queue pressure
println!("Queue: {}", client.queue_depth());
println!("Spilled: {}", client.spill_depth());

// Access atomic counters
let m = client.metrics();
println!("Sent: {}, Bytes: {}", m.messages_sent(), m.bytes_sent());

// All counters as (name, value) pairs — for Prometheus/StatsD
for (name, value) in m.snapshot() {
    println!("{}: {}", name, value);
}

// Drain remaining messages with a 5-second timeout
let unflushed = client.shutdown(Duration::from_secs(5)).await?;
if unflushed > 0 {
    eprintln!("{} messages were not flushed", unflushed);
}

use nerve_sdk::{NerveClient, NerveConfig, SchemaId};
use std::time::Duration;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = NerveConfig::new("127.0.0.1:4433")
        .with_queue_capacity(50_000)
        .with_batch_size(1_400)
        .with_flush_interval(Duration::from_millis(10));

    let client = NerveClient::connect(config).await?;
    let schema = SchemaId::from_bytes(b"temperature_v1");

    for i in 0..1000 {
        let temp: f32 = 20.0 + (i as f32 * 0.01).sin() * 5.0;
        client.send_raw(schema, &temp.to_le_bytes())?;
        tokio::time::sleep(Duration::from_millis(10)).await;
    }

    let unflushed = client.shutdown(Duration::from_secs(5)).await?;
    println!("Done. Unflushed: {}", unflushed);
    Ok(())
}