gts-logger 0.1.6

Gts logger
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

use crate::error::GtsLoggerError;
use crate::logbackend::LogBackend;
use serde::{Deserialize, Serialize};
use std::cell::Cell;
use std::marker::PhantomData;

#[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq)]
pub struct LogEventTs<T> {
    pub timestamp: u64,
    pub seqid: u32,
    pub data: T,
}

impl<T> LogEventTs<T> {
    pub fn new(timestamp: u64, seqid: u32, data: T) -> Self {
        LogEventTs {
            timestamp,
            seqid,
            data,
        }
    }
}

/// LogClient is simple client with timestamp.
pub struct LogClient<BackendT: LogBackend<LogEventTs<EventT>>, EventT> {
    backend: BackendT,
    _data: PhantomData<EventT>,
    anc: minstant::Anchor,
    last_ts: Cell<(u64, u32)>,
}

impl<BackendT: LogBackend<LogEventTs<EventT>>, EventT> LogClient<BackendT, EventT> {
    pub fn new(backend: BackendT) -> Self {
        Self {
            backend: backend,
            _data: PhantomData {},
            anc: minstant::Anchor::new(),
            last_ts: (0, 0).into(),
        }
    }

    pub fn log_same(&self, event: EventT) -> Result<(), GtsLoggerError> {
        let (timestamp, mut seqid) = self.last_ts.get();
        seqid += 1;
        self.last_ts.set((timestamp, seqid));

        self.backend.log(LogEventTs {
            timestamp,
            seqid,
            data: event,
        })
    }

    pub fn log(&self, event: EventT) -> Result<(), GtsLoggerError> {
        let ts = minstant::Instant::now();
        let timestamp = ts.as_unix_nanos(&self.anc);
        self.last_ts.set((timestamp, 0));

        self.backend.log(LogEventTs {
            timestamp,
            seqid: 0,
            data: event,
        })
    }

    pub fn backend(&self) -> &BackendT {
        &self.backend
    }
}