inlyne 0.5.1

Introducing Inlyne, a GPU powered yet browserless tool to help you quickly view markdown files in the blink of an eye.
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

use std::sync::Arc;

use super::{counter, gauge, hist, Unit};

use metrics::{Counter, Gauge, Histogram, Key, KeyName, Metadata, SharedString};
use metrics_util::registry::{Registry, Storage};

struct MetricStore;

impl Storage<Key> for MetricStore {
    type Counter = Arc<counter::Handle>;
    type Gauge = Arc<gauge::Handle>;
    type Histogram = Arc<hist::Handle>;

    fn counter(&self, key: &Key) -> Self::Counter {
        Arc::new(counter::Handle::new(key.to_owned(), None))
    }

    fn gauge(&self, key: &Key) -> Self::Gauge {
        Arc::new(gauge::Handle::new(key.to_owned(), None))
    }

    fn histogram(&self, key: &Key) -> Self::Histogram {
        Arc::new(hist::Handle::new(key.to_owned(), None))
    }
}

pub struct LogRecorder(Registry<Key, MetricStore>);

impl Default for LogRecorder {
    fn default() -> Self {
        Self(Registry::new(MetricStore))
    }
}

impl metrics::Recorder for LogRecorder {
    fn describe_gauge(&self, key: KeyName, unit: Option<Unit>, _desc: SharedString) {
        let key = Key::from_name(key);
        let gauge = self.0.get_or_create_histogram(&key, Arc::clone);
        gauge.0.lock().unit = unit.unwrap_or(Unit::Count);
    }

    fn register_gauge(&self, key: &Key, _: &Metadata<'_>) -> Gauge {
        let gauge = self.0.get_or_create_gauge(key, Arc::clone);
        Gauge::from_arc(gauge)
    }

    fn describe_counter(&self, key: KeyName, unit: Option<Unit>, _desc: SharedString) {
        let key = Key::from_name(key);
        let counter = self.0.get_or_create_histogram(&key, Arc::clone);
        counter.0.lock().unit = unit.unwrap_or(Unit::Count);
    }

    fn register_counter(&self, key: &Key, _: &Metadata<'_>) -> Counter {
        let counter = self.0.get_or_create_counter(key, Arc::clone);
        Counter::from_arc(counter)
    }

    fn describe_histogram(&self, key: KeyName, unit: Option<Unit>, _desc: SharedString) {
        let key = Key::from_name(key);
        let hist = self.0.get_or_create_histogram(&key, Arc::clone);
        hist.0.lock().unit = unit.unwrap_or(Unit::Count);
    }

    fn register_histogram(&self, key: &Key, _: &Metadata<'_>) -> Histogram {
        let hist = self.0.get_or_create_histogram(key, Arc::clone);
        Histogram::from_arc(hist)
    }
}