telegraf 0.6.0

Minimal rust wrapper for the telegraf/influxdb protocol
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
128
129
130
131
132
133
134
135
136
137
138

/// Shorthand macro for generating
/// [crate::Point] structs.
///
/// Syntax is a measurement, followed by
/// (optional) space-delineated tag tuples, followed by
/// space-delineated field tuples, followed by
/// (optional) a semicolon and a timestamp.
///
/// Every tuple member except field values must be &str. Field values
/// must implement [crate::IntoFieldData].
///
/// `(<measurement>, [(<tagName>, <tagVal>)], [(<fieldName>, <fieldVal>)]; <timestamp>)`
///
/// Influx protocol requires every point to have at
/// least one field, but tags and the timestamp are optional.
///
/// # Examples
///
/// Creates a point with one tag and two fields:
///
/// ```
/// use telegraf::point;
///
/// let p = point!("measure", ("t1", "t1v"), ("f1", "f1v") ("f2", "f2v"));
/// ```
///
/// Creates a point with no tags and one field:
///
/// ```
/// use telegraf::point;
///
/// let p = point!("measure", ("f1", "f1v"));
/// ```
///
/// Creates a point with no tags, one field and a custom timestamp:
///
/// ```
/// use telegraf::point;
///
/// let p = point!("measure", ("f1", "f1v"); 100);
/// ```
#[macro_export]
macro_rules! point {
    ($measure:expr, $(($fname:expr, $fval:expr)) + $(; $ts:expr)?) => {
        {
            let mut fields: Vec<(String, Box<dyn $crate::IntoFieldData>)> = Vec::new();
            $(
                fields.push((String::from($fname), Box::new($fval)));
            )*

            #[allow(unused_mut)]
            let mut timestamp: Option<u64> = None;
            $(
                timestamp = timestamp.or(Some($ts));
            )?

            $crate::Point::new(
                String::from($measure),
                Vec::new(),
                fields,
                timestamp,
            )
        }
    };
    ($measure:expr, $(($tname:expr, $tval:expr)) +, $(($fname:expr, $fval:expr)) + $(; $ts:expr)?) => {
        {
            let mut tags: Vec<(String, String)> = Vec::new();
            let mut fields: Vec<(String, Box<dyn $crate::IntoFieldData>)> = Vec::new();
            $(
                tags.push((String::from($tname), format!("{}", $tval)));
            )*

            $(
                fields.push((String::from($fname), Box::new($fval)));
            )*

            #[allow(unused_mut)]
            let mut timestamp: Option<u64> = None;
            $(
                timestamp = timestamp.or(Some($ts));
            )?

            $crate::Point::new(
                String::from($measure),
                tags,
                fields,
                timestamp,
            )
        }
    };
}

#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn can_create_with_ts() {
        let p = point!("test", ("t", "v")("t2", "v2"), ("f", "v"); 10);
        let exp = Point::new(
            "test".to_string(),
            vec![
                ("t".to_string(), "v".to_string()),
                ("t2".to_string(), "v2".to_string()),
            ],
            vec![("f".to_string(), Box::new("v"))],
            Some(10),
        );
        assert_eq!(p, exp);
    }

    #[test]
    fn can_create_with_tag() {
        let p = point!("test", ("t", "v")("t2", "v2"), ("f", "v"));
        let exp = Point::new(
            "test".to_string(),
            vec![
                ("t".to_string(), "v".to_string()),
                ("t2".to_string(), "v2".to_string()),
            ],
            vec![("f".to_string(), Box::new("v"))],
            None,
        );
        assert_eq!(p, exp);
    }

    #[test]
    fn can_create_whtout_tag() {
        let p = point!("test", ("f", "v"));
        let exp = Point::new(
            "test".to_string(),
            Vec::new(),
            vec![("f".to_string(), Box::new("v"))],
            None,
        );
        assert_eq!(p, exp);
    }
}