vector_common/internal_event/
mod.rs

1mod bytes_received;
2mod bytes_sent;
3pub mod cached_event;
4pub mod component_events_dropped;
5pub mod component_events_timed_out;
6mod events_received;
7mod events_sent;
8pub mod metric_name;
9pub mod metric_tags;
10mod optional_tag;
11mod prelude;
12pub mod service;
13
14use std::ops::{Add, AddAssign};
15
16pub use bytes_received::{BytesReceived, BytesReceivedHandle};
17pub use bytes_sent::BytesSent;
18#[allow(clippy::module_name_repetitions)]
19pub use cached_event::{RegisterTaggedInternalEvent, RegisteredEventCache};
20pub use component_events_dropped::{ComponentEventsDropped, INTENTIONAL, UNINTENTIONAL};
21pub use component_events_timed_out::ComponentEventsTimedOut;
22pub use events_received::{EventsReceived, EventsReceivedHandle};
23pub use events_sent::{DEFAULT_OUTPUT, EventsSent, TaggedEventsSent};
24pub use metric_name::{CounterName, GaugeName, HistogramName};
25pub use metrics::SharedString;
26pub use optional_tag::OptionalTag;
27pub use prelude::{error_stage, error_type};
28pub use service::{CallError, PollReadyError};
29
30use crate::json_size::JsonSize;
31
32pub trait NamedInternalEvent {
33    fn name(&self) -> &'static str;
34}
35
36pub trait InternalEvent: NamedInternalEvent + Sized {
37    fn emit(self);
38}
39
40#[allow(clippy::module_name_repetitions)]
41pub trait RegisterInternalEvent: NamedInternalEvent + Sized {
42    type Handle: InternalEventHandle;
43
44    fn register(self) -> Self::Handle;
45}
46
47#[allow(clippy::module_name_repetitions)]
48pub trait InternalEventHandle: Sized {
49    type Data: Sized;
50    fn emit(&self, data: Self::Data);
51}
52
53#[cfg(any(test, feature = "test"))]
54pub fn emit(event: impl InternalEvent) {
55    super::event_test_util::record_internal_event(event.name());
56    event.emit();
57}
58
59#[cfg(not(any(test, feature = "test")))]
60pub fn emit(event: impl InternalEvent) {
61    event.emit();
62}
63
64#[cfg(any(test, feature = "test"))]
65pub fn register<E: RegisterInternalEvent>(event: E) -> E::Handle {
66    super::event_test_util::record_internal_event(event.name());
67    event.register()
68}
69
70#[cfg(not(any(test, feature = "test")))]
71pub fn register<E: RegisterInternalEvent>(event: E) -> E::Handle {
72    event.register()
73}
74
75pub type Registered<T> = <T as RegisterInternalEvent>::Handle;
76
77// Wrapper types used to hold data emitted by registered events
78
79#[derive(Clone, Copy)]
80pub struct ByteSize(pub usize);
81
82#[derive(Clone, Copy)]
83pub struct Count(pub usize);
84
85/// Holds the tuple `(count_of_events, estimated_json_size_of_events)`.
86#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
87pub struct CountByteSize(pub usize, pub JsonSize);
88
89impl AddAssign for CountByteSize {
90    fn add_assign(&mut self, rhs: Self) {
91        self.0 += rhs.0;
92        self.1 += rhs.1;
93    }
94}
95
96impl Add<CountByteSize> for CountByteSize {
97    type Output = CountByteSize;
98
99    fn add(self, rhs: CountByteSize) -> Self::Output {
100        CountByteSize(self.0 + rhs.0, self.1 + rhs.1)
101    }
102}
103
104// Wrapper types used to hold parameters for registering events
105
106pub struct Output(pub Option<SharedString>);
107
108pub struct Protocol(pub SharedString);
109
110impl Protocol {
111    pub const HTTP: Protocol = Protocol(SharedString::const_str("http"));
112    pub const HTTPS: Protocol = Protocol(SharedString::const_str("https"));
113    pub const NONE: Protocol = Protocol(SharedString::const_str("none"));
114    pub const TCP: Protocol = Protocol(SharedString::const_str("tcp"));
115    pub const UDP: Protocol = Protocol(SharedString::const_str("udp"));
116    pub const UNIX: Protocol = Protocol(SharedString::const_str("unix"));
117    pub const INTERNAL: Protocol = Protocol(SharedString::const_str("internal"));
118    pub const STATIC: Protocol = Protocol(SharedString::const_str("static"));
119}
120
121impl From<&'static str> for Protocol {
122    fn from(s: &'static str) -> Self {
123        Self(SharedString::const_str(s))
124    }
125}
126
127impl From<Protocol> for SharedString {
128    fn from(value: Protocol) -> Self {
129        value.0
130    }
131}
132
133/// Macro to take care of some of the repetitive boilerplate in implementing a registered event. See
134/// the other events in this module for examples of how to use this.
135///
136/// ## Usage
137///
138/// ```ignore
139/// registered_event!(
140///     Event {
141///         event_field: &'static str,
142///     } => {
143///         handle_field: Counter = counter!("name", "tag" => self.event_field),
144///     }
145///     fn emit(&self, data: DataType) {
146///         self.handle_field.increment(data.0);
147///     }
148/// );
149///
150/// let handle = register!(Event { event_field: "message" });
151///
152/// handle.emit(DataType(123));
153/// ```
154///
155/// In this example, the first set of fields describes the data required to register the event. This
156/// is what would be used by the `register!` macro. For example, `register!(Event { event_field:
157/// "something" })`. The second set of fields describes the data required to store the registered
158/// handle, namely the `Counter`s and `Gauge`s that record the handle from `metrics` as well as any
159/// associated data for emitting traces or debug messages, followed by an initialization assignment
160/// value. The `emit` function is the code required to update the metrics and generate any log
161/// messages.
162#[macro_export]
163macro_rules! registered_event {
164    // A registered event struct with no fields (zero-sized type).
165    ($event:ident => $($tail:tt)*) => {
166        #[derive(Debug, Clone, Eq, Hash, $crate::NamedInternalEvent, Ord, PartialEq, PartialOrd)]
167        pub struct $event;
168
169        $crate::registered_event!(=> $event $($tail)*);
170    };
171
172    // A normal registered event struct.
173    ($event:ident { $( $field:ident: $type:ty, )* } => $($tail:tt)*) => {
174        #[derive(Debug, Clone, Eq, Hash, $crate::NamedInternalEvent, Ord, PartialEq, PartialOrd)]
175        pub struct $event {
176            $( pub $field: $type, )*
177        }
178
179        $crate::registered_event!(=> $event $($tail)*);
180    };
181
182    // Sub-matcher to implement the common bits in the above two cases.
183    (
184        => $event:ident {
185            $( $field:ident: $type:ty = $value:expr, )*
186        }
187
188        fn emit(&$slf:ident, $data_name:ident: $data:ident)
189            $emit_body:block
190
191        $(fn register($fixed_name:ident: $fixed_tags:ty, $tags_name:ident: $tags:ty)
192            $register_body:block)?
193    ) => {
194        pastey::paste!{
195            #[derive(Clone)]
196            pub struct [<$event Handle>] {
197                $( $field: $type, )*
198            }
199
200            impl $crate::internal_event::RegisterInternalEvent for $event {
201                type Handle = [<$event Handle>];
202
203                fn register($slf) -> Self::Handle {
204                    Self::Handle {
205                        $( $field: $value, )*
206                    }
207                }
208            }
209
210            impl $crate::internal_event::InternalEventHandle for [<$event Handle>] {
211                type Data = $data;
212
213                fn emit(&$slf, $data_name: $data)
214                    $emit_body
215            }
216
217            $(impl $crate::internal_event::cached_event::RegisterTaggedInternalEvent for $event {
218                type Tags = $tags;
219                type Fixed = $fixed_tags;
220
221                fn register(
222                    $fixed_name: $fixed_tags,
223                    $tags_name: $tags,
224                ) -> <Self as $crate::internal_event::RegisterInternalEvent>::Handle {
225                    $register_body
226                }
227            })?
228
229        }
230    };
231}
vector_common/internal_event/mod.rs

vector_common/internal_event/
mod.rs
