tracers 0.1.0

Generates very low overhead native trace points using stable Rust
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
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

use nom::*;
use std::io::prelude::*;
use tracers_macros::{init_provider, probe, tracer};

/// This is a probe provider which is used to exercise the probing infrastructure with a few
/// different combinations of arguments.
#[tracer]
pub trait TestFireProbes {
    fn probe0();
    fn probe1(text: &str);
    fn probe2(text: &str, number: usize);
    fn probe3(text: &str, number: usize, opt: &Option<&String>);
}

#[derive(Debug, PartialEq)]
enum ProbeType {
    Probe0,
    Probe1 {
        text: String,
    },
    Probe2 {
        text: String,
        number: usize,
    },
    Probe3 {
        text: String,
        number: usize,
        opt: Option<String>,
    },
}

named!(
    quoted_string<&str, String>,
    map!(
        delimited!(tag!("\""), take_until!("\""), tag!("\"")),
        |s| String::from(s)
    )
);
named!(number<&str, usize>, map_res!(take_while!(|c: char| c.is_ascii_digit()), |num: &str| num.parse::<usize>()));
named!(optional_string<&str, Option<String>>, opt!(complete!(quoted_string)));
named!(eol<&str, &str>, tag!(";"));

named!(
    probe0<&str, ProbeType>,
    do_parse!(tag!("probe0") >> eol >> (ProbeType::Probe0))
);

named!(
    probe1<&str, ProbeType>,
    do_parse!(
        tag!("probe1") >>
        sp >>
        text: quoted_string >>
        eol >> (
            ProbeType::Probe1 { text }
            )
        )
    );

named!(
    probe2<&str, ProbeType>,
    do_parse!(
        tag!("probe2") >>
        sp >>
        text: quoted_string >>
        sp >>
        number: number >>
        eol >> (
            ProbeType::Probe2 { text, number }
            )
        )
    );

named!(
    probe3<&str, ProbeType>,
    do_parse!(
        tag!("probe3") >>
        sp >>
        text: quoted_string >>
        sp >>
        number: number >>
        sp >>
        opt: optional_string >>
        eol >> (
            ProbeType::Probe3 { text, number, opt }
            )
        )
    );

named!(
    probe_command<&str, ProbeType>,
    complete! (
    alt! (
        probe0 | probe1 | probe2 | probe3
        )
    )
    );

fn fire_probe(pt: ProbeType) {
    match pt {
        ProbeType::Probe0 => probe!(TestFireProbes::probe0()),
        ProbeType::Probe1 { text } => probe!(TestFireProbes::probe1(&text)),
        ProbeType::Probe2 { text, number } => probe!(TestFireProbes::probe2(&text, number)),
        ProbeType::Probe3 { text, number, opt } => {
            probe!(TestFireProbes::probe3(&text, number, &opt.as_ref()))
        }
    }
}

fn main() {
    println!("Initializing the probe provider");
    match init_provider!(TestFireProbes) {
        Ok(ver) => println!("Provider initialized: {}", ver),
        Err(err) => panic!("Probe provider initialization failed: {}", err),
    }
    println!("Probe provider initialized");

    for line in std::io::stdin().lock().lines() {
        let line = line.expect("Error reading line from stdin");
        //Implement a primitive parser to parse commands.  Each command is the name of a probe to
        //fire and then its arguments.
        match probe_command(&line) {
            Ok((_, pt)) => fire_probe(pt),
            Err(e) => panic!("Invalid input '{}': {}", line, e),
        }
    }
}