zelos 0.0.2

A distributed tracing system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::time::Duration;

use tokio_util::sync::CancellationToken;
use zelos_trace::TraceRouter;
use zelos_trace::TraceSource;
use zelos_trace_grpc::publish::{TracePublishClient, TracePublishClientConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing
    tracing_subscriber::fmt::init();

    // Configuration
    let url = std::env::var("ZELOS_URL").unwrap_or_else(|_| "grpc://127.0.0.1:2300".to_string());
    println!("Connecting to Zelos agent at: {}", url);

    // Set up the router and cancellation token (using Arc like the working example)
    let cancellation_token = CancellationToken::new();
    let (router, router_task) = TraceRouter::new(cancellation_token.clone());
    tokio::spawn(router_task);

    // Set up the publish client to connect to the agent
    let config = TracePublishClientConfig {
        url: url.clone(),
        ..Default::default()
    };
    let (client, client_task) = TracePublishClient::new(router.clone(), config);
    tokio::spawn(client_task);

    // Wait for the client to connect
    client
        .wait_until_connected(Duration::from_secs(5))
        .await
        .expect("Failed to connect to agent");
    println!("Connected to agent at {}", url);

    // Create a TraceSource and register a 'hello' event with a 'message' field
    // Using u64 field like the working example
    let source = TraceSource::new("hello-world-example", router.sender());
    let hello_event = source
        .build_event("hello")
        .add_u64_field("count", None)
        .add_u64_field("timestamp", Some("ns".to_string()))
        .build()
        .expect("Failed to register hello event");

    // Publish a single hello message
    println!("Publishing hello message...");
    if let Err(e) = hello_event
        .build()
        .try_insert_u64("count", 1)
        .and_then(|b| b.try_insert_u64("timestamp", zelos_trace::time::now_time_ns() as u64))
        .and_then(|b| b.emit())
    {
        eprintln!("Failed to emit hello event: {e}");
        return Err(e.into());
    }

    println!("Successfully published hello message!");
    println!("Check your Zelos agent/collector to see the data.");

    // Give a moment for the message to be sent
    tokio::time::sleep(Duration::from_millis(1000)).await;

    Ok(())
}