emit_file 1.19.0

Emit diagnostic events to rolling files.
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
139
140
141
142
143
144
145
146

use std::sync::{
    atomic::{AtomicUsize, Ordering},
    Arc,
};

macro_rules! metrics {
    (
        $pub_container:ty {
            $field:ident: $internal_container:ident {
                $(
                    $(#[$meta:meta])*
                    $metric:ident: $ty:ident -> $pub_ty:ident,
                )*
            }
        }
    ) => {
        #[derive(Default)]
        pub(crate) struct $internal_container {
            $(
                $(#[$meta])*
                pub(crate) $metric: $ty,
            )*
        }

        impl $internal_container {
            pub fn sample(&self) -> impl Iterator<Item = emit::metric::Metric<'static, emit::empty::Empty>> + 'static {
                let $internal_container { $($metric),* } = self;

                [$(
                    emit::metric::Metric::new(
                        emit::pkg!(),
                        stringify!($metric),
                        <$ty>::AGG,
                        emit::empty::Empty,
                        $metric.sample(),
                        emit::empty::Empty,
                    ),
                )*]
                .into_iter()
            }
        }

        impl $pub_container {
            $(
                $(#[$meta])*
                pub fn $metric(&self) -> $pub_ty {
                    self.$field.$metric.sample()
                }
            )*
        }
    };
}

#[derive(Default)]
pub(crate) struct Counter(AtomicUsize);

impl Counter {
    const AGG: &'static str = emit::well_known::METRIC_AGG_COUNT;

    pub fn increment(&self) {
        self.increment_by(1);
    }

    pub fn increment_by(&self, by: usize) {
        self.0.fetch_add(by, Ordering::Relaxed);
    }

    pub fn sample(&self) -> usize {
        self.0.load(Ordering::Relaxed)
    }
}

metrics!(
    FileSetMetrics {
        metrics: InternalMetrics {
            /**
            Attempting to read the set of log files failed.
            */
            file_set_read_failed: Counter -> usize,
            /**
            Attempting to open a log file failed.
            */
            file_open_failed: Counter -> usize,
            /**
            A new log file was created.
            */
            file_create: Counter -> usize,
            /**
            Attempting to create a new log file failed.
            */
            file_create_failed: Counter -> usize,
            /**
            Attempting to write to a log file failed.
            */
            file_write_failed: Counter -> usize,
            /**
            A log file was deleted.
            */
            file_delete: Counter -> usize,
            /**
            Attempting to delete a log file failed.
            */
            file_delete_failed: Counter -> usize,
            /**
            Attempting to format an event into a batch failed and was discarded.

            This happens before the event is written to any log files.
            */
            event_format_failed: Counter -> usize,
            /**
            Attempting to configure the emitter failed.

            This happens when file paths or other configuration properties are malformed. The emitter won't write any events until configuration is fixed and the process is restarted.
            */
            configuration_failed: Counter -> usize,
        }
    }
);

/**
Metrics produced by the file writer.

You can enumerate the metrics using the [`emit::metric::Source`] implementation. See [`emit::metric`] for details.
*/
pub struct FileSetMetrics {
    pub(crate) channel_metrics: Option<emit_batcher::ChannelMetrics<crate::EventBatch>>,
    pub(crate) metrics: Arc<InternalMetrics>,
}

impl emit::metric::Source for FileSetMetrics {
    fn sample_metrics<S: emit::metric::sampler::Sampler>(&self, sampler: S) {
        self.channel_metrics
            .sample_metrics(emit::metric::sampler::from_fn(|metric| {
                sampler.metric(
                    metric
                        .by_ref()
                        .with_name(&format!("file_{}", metric.name()))
                        .with_mdl(emit::pkg!()),
                );
            }));

        for metric in self.metrics.sample() {
            sampler.metric(metric);
        }
    }
}