relay_event_schema/processor/
traits.rs1#![allow(unused_variables)]
3
4use std::fmt::Debug;
5
6use relay_protocol::{FiniteF64, FromValue, IntoValue, Meta};
7
8use crate::processor::{ProcessingState, ValueType, process_value};
9
10#[must_use = "This `ProcessingAction` must be handled by `Annotated::apply`"]
12#[derive(Copy, Clone, Debug, PartialEq, Eq, thiserror::Error)]
13pub enum ProcessingAction {
14 #[error("value should be hard-deleted (unreachable, should not surface as error!)")]
16 DeleteValueHard,
17
18 #[error("value should be hard-deleted (unreachable, should not surface as error!)")]
20 DeleteValueSoft,
21
22 #[error("invalid transaction event: {0}")]
24 InvalidTransaction(&'static str),
25}
26
27pub type ProcessingResult = Result<(), ProcessingAction>;
29
30macro_rules! process_method {
31 ($name: ident, $ty:ident $(::$path:ident)*) => {
32 process_method!($name, $ty $(::$path)* <>);
33 };
34
35 ($name: ident, $ty:ident $(::$path:ident)* < $($param:ident),* > $(, $param_req_key:ident : $param_req_trait:path)*) => {
36 #[inline]
37 fn $name<$($param),*>(
38 &mut self,
39 value: &mut $ty $(::$path)* <$($param),*>,
40 meta: &mut Meta,
41 state: &ProcessingState<'_>,
42 ) -> ProcessingResult
43 where
44 $($param: ProcessValue),*
45 $(, $param_req_key : $param_req_trait)*
46 {
47 value.process_child_values(self, state)?;
48 Ok(())
49 }
50 };
51}
52
53pub trait Processor: Sized {
55 #[inline]
56 fn before_process<T: ProcessValue>(
57 &mut self,
58 value: Option<&T>,
59 meta: &mut Meta,
60 state: &ProcessingState<'_>,
61 ) -> ProcessingResult {
62 Ok(())
63 }
64
65 #[inline]
66 fn after_process<T: ProcessValue>(
67 &mut self,
68 value: Option<&T>,
69 meta: &mut Meta,
70 state: &ProcessingState<'_>,
71 ) -> ProcessingResult {
72 Ok(())
73 }
74
75 process_method!(process_string, String);
76 process_method!(process_u64, u64);
77 process_method!(process_i64, i64);
78 process_method!(process_f64, f64);
79 process_method!(process_finite_f64, FiniteF64);
80 process_method!(process_bool, bool);
81
82 process_method!(process_value, relay_protocol::Value);
83 process_method!(process_array, relay_protocol::Array<T>);
84 process_method!(process_object, relay_protocol::Object<T>);
85
86 process_method!(
87 process_pairlist,
88 crate::protocol::PairList<T>,
89 T: crate::protocol::AsPair
90 );
91 process_method!(process_values, crate::protocol::Values<T>);
92 process_method!(process_timestamp, crate::protocol::Timestamp);
93
94 process_method!(process_event, crate::protocol::Event);
95 process_method!(process_replay, crate::protocol::Replay);
96 process_method!(process_exception, crate::protocol::Exception);
97 process_method!(process_raw_stacktrace, crate::protocol::RawStacktrace);
98 process_method!(process_stacktrace, crate::protocol::Stacktrace);
99 process_method!(process_frame, crate::protocol::Frame);
100 process_method!(process_request, crate::protocol::Request);
101 process_method!(process_user, crate::protocol::User);
102 process_method!(process_client_sdk_info, crate::protocol::ClientSdkInfo);
103 process_method!(process_debug_meta, crate::protocol::DebugMeta);
104 process_method!(process_debug_image, crate::protocol::DebugImage);
105 process_method!(process_geo, crate::protocol::Geo);
106 process_method!(process_logentry, crate::protocol::LogEntry);
107 process_method!(process_thread, crate::protocol::Thread);
108 process_method!(process_context, crate::protocol::Context);
109 process_method!(process_breadcrumb, crate::protocol::Breadcrumb);
110 process_method!(process_template_info, crate::protocol::TemplateInfo);
111 process_method!(process_header_name, crate::protocol::HeaderName);
112 process_method!(process_ourlog, crate::protocol::OurLog);
113 process_method!(process_span, crate::protocol::Span);
114 process_method!(process_trace_context, crate::protocol::TraceContext);
115 process_method!(process_native_image_path, crate::protocol::NativeImagePath);
116 process_method!(process_contexts, crate::protocol::Contexts);
117 process_method!(process_attributes, crate::protocol::Attributes);
118
119 fn process_other(
120 &mut self,
121 other: &mut relay_protocol::Object<relay_protocol::Value>,
122 state: &ProcessingState<'_>,
123 ) -> ProcessingResult {
124 for (key, value) in other {
125 process_value(
126 value,
127 self,
128 &state.enter_borrowed(
129 key.as_str(),
130 state.inner_attrs(),
131 ValueType::for_field(value),
132 ),
133 )?;
134 }
135
136 Ok(())
137 }
138}
139
140#[doc(inline)]
141pub use enumset::{EnumSet, enum_set};
142
143pub trait ProcessValue: FromValue + IntoValue + Debug + Clone {
145 #[inline]
147 fn value_type(&self) -> EnumSet<ValueType> {
148 EnumSet::empty()
149 }
150
151 #[inline]
153 fn process_value<P>(
154 &mut self,
155 meta: &mut Meta,
156 processor: &mut P,
157 state: &ProcessingState<'_>,
158 ) -> ProcessingResult
159 where
160 P: Processor,
161 {
162 self.process_child_values(processor, state)
163 }
164
165 #[inline]
167 fn process_child_values<P>(
168 &mut self,
169 processor: &mut P,
170 state: &ProcessingState<'_>,
171 ) -> ProcessingResult
172 where
173 P: Processor,
174 {
175 Ok(())
176 }
177}
178
179pub use relay_event_derive::ProcessValue;