sentry_core/integration.rs
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
use std::any::{type_name, Any};
use crate::protocol::Event;
use crate::ClientOptions;
/// Integration abstraction.
///
/// An Integration in sentry has two primary purposes.
/// It can act as an *Event Source*, which will capture new events;
/// or as an *Event Processor*, which can modify every `Event` flowing through
/// the pipeline.
///
/// # Examples
///
/// ```
/// use sentry::protocol::{Event, Level};
/// use sentry::ClientOptions;
///
/// struct MyProcessorIntegration {
/// override_environment: &'static str,
/// override_level: Level,
/// }
///
/// impl sentry::Integration for MyProcessorIntegration {
/// fn setup(&self, options: &mut ClientOptions) {
/// options.environment = Some(self.override_environment.into());
/// }
/// fn process_event(
/// &self,
/// mut event: Event<'static>,
/// _options: &ClientOptions,
/// ) -> Option<Event<'static>> {
/// event.level = self.override_level;
/// Some(event)
/// }
/// }
///
/// let options = ClientOptions::new().add_integration(MyProcessorIntegration {
/// override_environment: "my_env",
/// override_level: Level::Error,
/// });
///
/// let events = sentry::test::with_captured_events_options(
/// || {
/// sentry::capture_message("some message", Level::Info);
/// },
/// options,
/// );
/// let captured_event = events.into_iter().next().unwrap();
///
/// assert_eq!(captured_event.level, Level::Error);
/// assert_eq!(captured_event.environment, Some("my_env".into()));
/// ```
// NOTE: we need `Any` here so that the `TypeId` machinery works correctly.
pub trait Integration: Sync + Send + Any + AsAny {
/// Name of this integration.
///
/// This will be added to the SDK information sent to sentry.
fn name(&self) -> &'static str {
type_name::<Self>()
}
/// Called whenever the integration is attached to a Client.
fn setup(&self, options: &mut ClientOptions) {
let _ = options;
}
/// The Integrations Event Processor Hook.
///
/// An integration can process, or even completely drop an `Event`.
/// Examples include adding or processing a backtrace, obfuscate some
/// personal information, or add additional information.
fn process_event(
&self,
event: Event<'static>,
options: &ClientOptions,
) -> Option<Event<'static>> {
let _ = options;
Some(event)
}
}
// This is needed as a workaround to be able to safely downcast integrations
#[doc(hidden)]
pub trait AsAny {
fn as_any(&self) -> &dyn Any;
}
impl<T: Any> AsAny for T {
fn as_any(&self) -> &dyn Any {
self
}
}