levelops-sdk 0.1.0

use levelops_sdk::{Client, Config, Event, MeasureOpts};
use std::collections::HashMap;
use std::time::Duration;
use tokio::time::sleep;

const API_KEY: &str = "your-tenant-key";
const SLI_ID: &str = "your-sli-id";
const BASE_URL: &str = "http://localhost:8081";

#[tokio::main]
async fn main() {
    let dimensions: HashMap<String, String> = [
        ("service".into(), "api".into()),
        ("region".into(), "eu".into()),
    ]
    .into();

    let client = Client::new(Config {
        api_key: API_KEY.into(),
        sli_id: SLI_ID.into(),
        base_url: BASE_URL.into(),
        ..Default::default()
    })
    .unwrap();

    println!("LevelOps SDK test — boucle toutes les secondes. Ctrl+C pour arrêter.");
    let mut i = 0u64;
    loop {
        i += 1;
        let latency = rand_range(20, 500);

        // Usage direct
        let mut fields = HashMap::new();
        fields.insert("result".into(), serde_json::Value::String("ok".into()));
        fields.insert("latency_ms".into(), serde_json::Value::Number(latency.into()));

        client
            .record(Event {
                fields,
                dimensions: dimensions.clone(),
                ..Default::default()
            })
            .await
            .unwrap();
        println!("[{i}] record() envoyé");

        // Usage measure (simulation latence)
        let extra_fields: HashMap<String, serde_json::Value> =
            [("service_version".into(), serde_json::Value::String("1.0".into()))].into();
        client
            .measure(
                |ctx| async move {
                    sleep(Duration::from_millis(rand_range(50, 300))).await;
                    ctx.set_result(if rand_bool(0.9) { "ok" } else { "error" });
                    Ok(())
                },
                MeasureOpts::new(dimensions.clone()).fields(extra_fields),
            )
            .await
            .unwrap();
        println!("[{i}] measure() terminé");

        sleep(Duration::from_secs(1)).await;
    }
}

fn rand_range(min: u64, max: u64) -> u64 {
    use std::time::{SystemTime, UNIX_EPOCH};
    let seed = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .subsec_nanos() as u64;
    min + seed % (max - min)
}

fn rand_bool(probability: f64) -> bool {
    use std::time::{SystemTime, UNIX_EPOCH};
    let seed = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .subsec_nanos() as f64;
    (seed / 1_000_000_000.0) < probability
}