This crate provides the core of the [Sentry] SDK, which can be used to log events and errors.
sentry-core is meant for integration authors and third-party library authors
that want to instrument their code for sentry.
Regular users who wish to integrate sentry into their applications should
instead use the [sentry] crate, which comes with a default transport and
a large set of integrations for various third-party libraries.
This crate follows the [Unified API] guidelines and is centered around
the concepts of [Client], [Hub] and [Scope], as well as the extension
points via the [Integration], [Transport] and [TransportFactory] traits.
The main concurrency primitive is the [Hub]. In general, all concurrent
code, no matter if multithreaded parallelism or futures concurrency, needs
to run with its own copy of a [Hub]. Even though the [Hub] is internally
synchronized, using it concurrently may lead to unexpected results up to
panics.
For threads or tasks that are running concurrently or outlive the current
execution context, a new [Hub] needs to be created and bound for the computation.
```rust use rayon::prelude::*; use sentry::{Hub, SentryFutureExt}; use std::sync::Arc;
// Parallel multithreaded code: let outerhub = Hub::current(); let results: Vec<_> = [1u32, 2, 3] .intopariter() .map(|num| { let threadhub = Arc::new(Hub::newfromtop(&outerhub)); Hub::run(thread_hub, || num * num) }) .collect();
assert_eq!(&results, &[1, 4, 9]);
// Concurrent futures code: let futures = [1u32, 2, 3] .intoiter() .map(|num| async move { num * num }.bindhub(Hub::newfromtop(Hub::current()))); let results = futures::future::joinall(futures).await;
assert_eq!(&results, &[1, 4, 9]); ```
For tasks that are not concurrent and do not outlive the current execution
context, no new [Hub] needs to be created, but the current [Hub] has
to be bound.
```rust use sentry::{Hub, SentryFutureExt};
// Spawned thread that is being joined: let hub = Hub::current(); let result = std::thread::spawn(|| Hub::run(hub, || 1_u32)).join();
assert_eq!(result.unwrap(), 1);
// Spawned future that is being awaited: let result = tokio::spawn(async { 1u32 }.bindhub(Hub::current())).await;
assert_eq!(result.unwrap(), 1); ```
By default, this crate comes with a so-called "minimal" mode. This mode will provide all the APIs needed to instrument code with sentry, and to write sentry integrations, but it will blackhole a lot of operations.
In minimal mode some types are restricted in functionality. For instance
the [Client] is not available and the [Hub] does not retain all API
functionality.
feature = "client": Activates the [Client] type and certain
[Hub] functionality.feature = "test": Activates the [test] module, which can be used to
write integration tests. It comes with a test transport which can capture
all sent events for inspection.feature = "debug-logs": Uses the log crate for debug output, instead
of printing to stderr. This feature is deprecated and will be
replaced by a dedicated log callback in the future.License: Apache-2.0