sonda 1.9.0

CLI for Sonda — synthetic telemetry generator for testing observability pipelines
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Minimal interactive prompts for `sonda new`.

use anyhow::Result;
use dialoguer::theme::ColorfulTheme;
use dialoguer::{Input, Select};

#[derive(Debug, Clone, Copy)]
pub enum SignalKind {
    Metrics,
    Logs,
    Histogram,
    Summary,
}

impl SignalKind {
    pub fn as_str(self) -> &'static str {
        match self {
            SignalKind::Metrics => "metrics",
            SignalKind::Logs => "logs",
            SignalKind::Histogram => "histogram",
            SignalKind::Summary => "summary",
        }
    }
}

#[derive(Debug, Clone)]
pub enum SinkKind {
    Stdout,
    File { path: String },
    HttpPush { endpoint: String },
}

pub struct Answers {
    pub id: String,
    pub signal: SignalKind,
    pub generator_type: String,
    pub rate: f64,
    pub duration: String,
    pub sink: SinkKind,
}

pub fn collect_answers() -> Result<Answers> {
    let theme = ColorfulTheme::default();

    let signal_choices = ["metrics", "logs", "histogram", "summary"];
    let signal_idx = Select::with_theme(&theme)
        .with_prompt("Signal type")
        .items(signal_choices)
        .default(0)
        .interact()?;
    let signal = match signal_idx {
        0 => SignalKind::Metrics,
        1 => SignalKind::Logs,
        2 => SignalKind::Histogram,
        _ => SignalKind::Summary,
    };

    let id: String = Input::with_theme(&theme)
        .with_prompt("Scenario id")
        .default("example".to_string())
        .interact_text()?;

    let generator_type = match signal {
        SignalKind::Metrics => {
            let gen_choices = ["constant", "sine", "sawtooth", "uniform", "steady"];
            let idx = Select::with_theme(&theme)
                .with_prompt("Generator")
                .items(gen_choices)
                .default(0)
                .interact()?;
            gen_choices[idx].to_string()
        }
        _ => String::new(),
    };

    let rate_str: String = Input::with_theme(&theme)
        .with_prompt("Events per second")
        .default("1".to_string())
        .validate_with(|input: &String| -> Result<(), String> {
            input
                .parse::<f64>()
                .map_err(|_| "must be a number".to_string())
                .and_then(|v| {
                    if v > 0.0 {
                        Ok(())
                    } else {
                        Err("must be positive".to_string())
                    }
                })
        })
        .interact_text()?;
    let rate: f64 = rate_str.parse().expect("validated above");

    let duration: String = Input::with_theme(&theme)
        .with_prompt("Duration (e.g. 60s, 5m)")
        .default("60s".to_string())
        .interact_text()?;

    let sink_choices = ["stdout", "file", "http_push"];
    let sink_idx = Select::with_theme(&theme)
        .with_prompt("Sink")
        .items(sink_choices)
        .default(0)
        .interact()?;
    let sink = match sink_idx {
        0 => SinkKind::Stdout,
        1 => {
            let path: String = Input::with_theme(&theme)
                .with_prompt("File path")
                .default("./out.txt".to_string())
                .interact_text()?;
            SinkKind::File { path }
        }
        _ => {
            let endpoint: String = Input::with_theme(&theme)
                .with_prompt("HTTP endpoint URL")
                .interact_text()?;
            SinkKind::HttpPush { endpoint }
        }
    };

    Ok(Answers {
        id,
        signal,
        generator_type,
        rate,
        duration,
        sink,
    })
}