metriki-core 1.8.0

A metrics library ported from dropwizard metrics
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

#[cfg(feature = "ser")]
use serde::Serialize;
use std::cmp;
use std::hash::{Hash, Hasher};

pub type KeyName = String;

#[derive(Debug, Clone)]
#[cfg_attr(feature = "ser", derive(Serialize))]
pub struct Key {
    pub(crate) name: KeyName,
    pub(crate) tags: Vec<Tag>,
}

#[derive(PartialEq, Eq, Hash, Clone, Debug, PartialOrd, Ord)]
#[cfg_attr(feature = "ser", derive(Serialize))]
pub struct Tag {
    key: String,
    value: String,
}

impl Key {
    pub fn from_name(name: &str) -> Self {
        Key {
            name: name.to_owned(),
            tags: Vec::with_capacity(0),
        }
    }

    pub fn from(name: &str, tags: Vec<Tag>) -> Self {
        Key {
            name: name.to_owned(),
            tags,
        }
    }

    pub fn key(&self) -> &str {
        self.name.as_str()
    }

    pub fn tags(&self) -> &[Tag] {
        self.tags.as_slice()
    }
}

impl PartialEq for Key {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.tags == other.tags
    }
}

impl Eq for Key {}

impl PartialOrd for Key {
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Key {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        (&self.name, &self.tags).cmp(&(&other.name, &other.tags))
    }
}

impl Hash for Key {
    fn hash<H: Hasher>(&self, state: &mut H) {
        key_hasher_impl(state, &self.name, &self.tags);
    }
}

impl Tag {
    pub fn new(key: &str, value: &str) -> Self {
        Self {
            key: key.to_owned(),
            value: value.to_owned(),
        }
    }
    pub fn key(&self) -> &str {
        self.key.as_str()
    }

    pub fn value(&self) -> &str {
        self.value.as_str()
    }
}

fn key_hasher_impl<H: Hasher>(state: &mut H, name: &KeyName, tags: &[Tag]) {
    name.hash(state);
    tags.hash(state);
}