relay_event_schema/processor/
traits.rs

1// This module only defines traits, every parameter is used by definition
2#![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/// Used to indicate how to handle an annotated value in a callback.
11#[must_use = "This `ProcessingAction` must be handled by `Annotated::apply`"]
12#[derive(Copy, Clone, Debug, PartialEq, Eq, thiserror::Error)]
13pub enum ProcessingAction {
14    /// Discards the value entirely.
15    #[error("value should be hard-deleted (unreachable, should not surface as error!)")]
16    DeleteValueHard,
17
18    /// Discards the value and moves it into meta's `original_value`.
19    #[error("value should be hard-deleted (unreachable, should not surface as error!)")]
20    DeleteValueSoft,
21
22    /// The event is invalid (needs to bubble up)
23    #[error("invalid transaction event: {0}")]
24    InvalidTransaction(&'static str),
25}
26
27/// The result of running a processor on a value implementing `ProcessValue`.
28pub 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
53/// A trait for processing processable values.
54pub 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
118    fn process_other(
119        &mut self,
120        other: &mut relay_protocol::Object<relay_protocol::Value>,
121        state: &ProcessingState<'_>,
122    ) -> ProcessingResult {
123        for (key, value) in other {
124            process_value(
125                value,
126                self,
127                &state.enter_borrowed(
128                    key.as_str(),
129                    state.inner_attrs(),
130                    ValueType::for_field(value),
131                ),
132            )?;
133        }
134
135        Ok(())
136    }
137}
138
139#[doc(inline)]
140pub use enumset::{EnumSet, enum_set};
141
142/// A recursively processable value.
143pub trait ProcessValue: FromValue + IntoValue + Debug + Clone {
144    /// Returns the type of the value.
145    #[inline]
146    fn value_type(&self) -> EnumSet<ValueType> {
147        EnumSet::empty()
148    }
149
150    /// Executes a processor on this value.
151    #[inline]
152    fn process_value<P>(
153        &mut self,
154        meta: &mut Meta,
155        processor: &mut P,
156        state: &ProcessingState<'_>,
157    ) -> ProcessingResult
158    where
159        P: Processor,
160    {
161        self.process_child_values(processor, state)
162    }
163
164    /// Recurses into children of this value.
165    #[inline]
166    fn process_child_values<P>(
167        &mut self,
168        processor: &mut P,
169        state: &ProcessingState<'_>,
170    ) -> ProcessingResult
171    where
172        P: Processor,
173    {
174        Ok(())
175    }
176}
177
178pub use relay_event_derive::ProcessValue;
relay_event_schema/processor/traits.rs

relay_event_schema/processor/
traits.rs
