Struct Scope 

pub struct Scope { /* private fields */ }

Available on crate feature client only.

Holds contextual data for the current scope.

The scope is an object that can be cloned efficiently and stores data that is locally relevant to an event. For instance the scope will hold recorded breadcrumbs and similar information.

The scope can be interacted with in two ways:

1. the scope is routinely updated with information by functions such as add_breadcrumb which will modify the currently top-most scope.
2. the topmost scope can also be configured through the configure_scope method.

Note that the scope can only be modified but not inspected. Only the client can use the scope to extract information currently.

Implementations

impl Scope

pub fn clear(&mut self)

Clear the scope.

By default a scope will inherit all values from the higher scope. In some situations this might not be what a user wants. Calling this method will wipe all data contained within.

pub fn clear_breadcrumbs(&mut self)

Deletes current breadcrumbs from the scope.

pub fn set_level(&mut self, level: Option<Level>)

Sets a level override.

Examples found in repository

examples/send-with-extra.rs (line 12)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::with_scope(
        |scope| {
            scope.set_level(Some(sentry::Level::Warning));
            scope.set_fingerprint(Some(["a-message"].as_ref()));
            scope.set_tag("foo", "bar");
        },
        || {
            panic!("Shit's on fire yo. 🔥 🚒");
        },
    );
}

pub fn set_fingerprint(&mut self, fingerprint: Option<&[&str]>)

Sets the fingerprint.

Examples found in repository

examples/message-demo.rs (line 10)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );
    sentry::configure_scope(|scope| {
        scope.set_fingerprint(Some(["a-message"].as_ref()));
        scope.set_tag("foo", "bar");
    });

    sentry::capture_message("This is recorded as a warning now", sentry::Level::Warning);
}

examples/send-with-extra.rs (line 13)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::with_scope(
        |scope| {
            scope.set_level(Some(sentry::Level::Warning));
            scope.set_fingerprint(Some(["a-message"].as_ref()));
            scope.set_tag("foo", "bar");
        },
        || {
            panic!("Shit's on fire yo. 🔥 🚒");
        },
    );
}

examples/event-processors.rs (line 22)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::configure_scope(|scope| {
        scope.add_event_processor(|mut event| {
            event.request = Some(sentry::protocol::Request {
                url: Some("https://example.com/".parse().unwrap()),
                method: Some("GET".into()),
                ..Default::default()
            });
            Some(event)
        });
    });

    sentry::configure_scope(|scope| {
        scope.set_fingerprint(Some(["a-message"].as_ref()));
        scope.set_tag("foo", "bar");
    });

    let id = sentry::capture_message("An HTTP request failed.", sentry::Level::Error);
    println!("sent event {id}");
}

pub fn set_transaction(&mut self, transaction: Option<&str>)

Sets the transaction.

pub fn set_user(&mut self, user: Option<User>)

Sets the user for the current scope.

pub fn user(&self) -> Option<&User>

Retrieves the user of the current scope.

pub fn set_tag<V>(&mut self, key: &str, value: V)

where V: ToString,

Sets a tag to a specific value.

Examples found in repository

examples/panic-demo.rs (line 13)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    {
        let _guard = sentry::Hub::current().push_scope();
        sentry::configure_scope(|scope| {
            scope.set_tag("foo", "bar");
        });
        panic!("Holy shit everything is on fire!");
    }
}

examples/message-demo.rs (line 11)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );
    sentry::configure_scope(|scope| {
        scope.set_fingerprint(Some(["a-message"].as_ref()));
        scope.set_tag("foo", "bar");
    });

    sentry::capture_message("This is recorded as a warning now", sentry::Level::Warning);
}

examples/send-with-extra.rs (line 14)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::with_scope(
        |scope| {
            scope.set_level(Some(sentry::Level::Warning));
            scope.set_fingerprint(Some(["a-message"].as_ref()));
            scope.set_tag("foo", "bar");
        },
        || {
            panic!("Shit's on fire yo. 🔥 🚒");
        },
    );
}

examples/event-processors.rs (line 23)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::configure_scope(|scope| {
        scope.add_event_processor(|mut event| {
            event.request = Some(sentry::protocol::Request {
                url: Some("https://example.com/".parse().unwrap()),
                method: Some("GET".into()),
                ..Default::default()
            });
            Some(event)
        });
    });

    sentry::configure_scope(|scope| {
        scope.set_fingerprint(Some(["a-message"].as_ref()));
        scope.set_tag("foo", "bar");
    });

    let id = sentry::capture_message("An HTTP request failed.", sentry::Level::Error);
    println!("sent event {id}");
}

pub fn remove_tag(&mut self, key: &str)

Removes a tag.

If the tag is not set, does nothing.

pub fn set_context<C>(&mut self, key: &str, value: C)

where C: Into<Context>,

Sets a context for a key.

pub fn remove_context(&mut self, key: &str)

Removes a context for a key.

pub fn set_extra(&mut self, key: &str, value: Value)

Sets a extra to a specific value.

pub fn remove_extra(&mut self, key: &str)

Removes a extra.

pub fn add_event_processor<F>(&mut self, f: F)

where F: Fn(Event<'static>) -> Option<Event<'static>> + Send + Sync + RefUnwindSafe + 'static,

Add an event processor to the scope.

Examples found in repository

examples/event-processors.rs (lines 11-18)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .debug(true),
    );

    sentry::configure_scope(|scope| {
        scope.add_event_processor(|mut event| {
            event.request = Some(sentry::protocol::Request {
                url: Some("https://example.com/".parse().unwrap()),
                method: Some("GET".into()),
                ..Default::default()
            });
            Some(event)
        });
    });

    sentry::configure_scope(|scope| {
        scope.set_fingerprint(Some(["a-message"].as_ref()));
        scope.set_tag("foo", "bar");
    });

    let id = sentry::capture_message("An HTTP request failed.", sentry::Level::Error);
    println!("sent event {id}");
}

pub fn add_attachment(&mut self, attachment: Attachment)

Adds an attachment to the scope

pub fn clear_attachments(&mut self)

Clears attachments from the scope

pub fn apply_to_event(&self, event: Event<'static>) -> Option<Event<'static>>

Applies the contained scoped data to fill an event.

pub fn apply_to_transaction(&self, transaction: &mut Transaction<'static>)

Applies the contained scoped data to fill a transaction.

pub fn apply_to_log(&self, log: &mut Log)

Available on crate feature logs only.

Applies the contained scoped data to a log, setting the trace_id and certain default attributes.

pub fn set_span(&mut self, span: Option<TransactionOrSpan>)

Set the given TransactionOrSpan as the active span for this scope.

Examples found in repository

examples/performance-demo.rs (line 25)

fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            .maybe_release(sentry::release_name!())
            .traces_sample_rate(1.0)
            .debug(true),
    );

    let transaction =
        sentry::start_transaction(sentry::TransactionContext::new("transaction", "root span"));
    let tx_request = Request {
        url: Some("https://honk.beep".parse().unwrap()),
        method: Some("GET".to_string()),
        ..Request::default()
    };
    transaction.set_request(tx_request);
    sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));

    main_span1();

    thread::sleep(Duration::from_millis(100));

    transaction.finish();
    sentry::configure_scope(|scope| scope.set_span(None));
}

fn main_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(50));

        let transaction_ctx = sentry::TransactionContext::continue_from_span(
            "background transaction",
            "root span",
            sentry::configure_scope(|scope| scope.get_span()),
        );
        thread::spawn(move || {
            let transaction = sentry::start_transaction(transaction_ctx);
            sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));

            thread::sleep(Duration::from_millis(50));

            thread_span1();

            transaction.finish();
            sentry::configure_scope(|scope| scope.set_span(None));
        });
        thread::sleep(Duration::from_millis(100));

        main_span2()
    });
}

fn thread_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(200));
    })
}

fn main_span2() {
    wrap_in_span("span2", "", || {
        sentry::capture_message(
            "A message that should have a trace context",
            sentry::Level::Info,
        );
        thread::sleep(Duration::from_millis(200));
    })
}

fn wrap_in_span<F, R>(op: &str, description: &str, f: F) -> R
where
    F: FnOnce() -> R,
{
    let parent = sentry::configure_scope(|scope| scope.get_span());
    let span1: sentry::TransactionOrSpan = match &parent {
        Some(parent) => parent.start_child(op, description).into(),
        None => {
            let ctx = sentry::TransactionContext::new(description, op);
            sentry::start_transaction(ctx).into()
        }
    };
    let span_request = Request {
        url: Some("https://beep.beep".parse().unwrap()),
        method: Some("GET".to_string()),
        ..Request::default()
    };
    span1.set_request(span_request);
    sentry::configure_scope(|scope| scope.set_span(Some(span1.clone())));

    let rv = f();

    span1.finish();
    sentry::configure_scope(|scope| scope.set_span(parent));

    rv
}

pub fn get_span(&self) -> Option<TransactionOrSpan>

Returns the currently active span.

Examples found in repository

examples/performance-demo.rs (line 42)

fn main_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(50));

        let transaction_ctx = sentry::TransactionContext::continue_from_span(
            "background transaction",
            "root span",
            sentry::configure_scope(|scope| scope.get_span()),
        );
        thread::spawn(move || {
            let transaction = sentry::start_transaction(transaction_ctx);
            sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));

            thread::sleep(Duration::from_millis(50));

            thread_span1();

            transaction.finish();
            sentry::configure_scope(|scope| scope.set_span(None));
        });
        thread::sleep(Duration::from_millis(100));

        main_span2()
    });
}

fn thread_span1() {
    wrap_in_span("span1", "", || {
        thread::sleep(Duration::from_millis(200));
    })
}

fn main_span2() {
    wrap_in_span("span2", "", || {
        sentry::capture_message(
            "A message that should have a trace context",
            sentry::Level::Info,
        );
        thread::sleep(Duration::from_millis(200));
    })
}

fn wrap_in_span<F, R>(op: &str, description: &str, f: F) -> R
where
    F: FnOnce() -> R,
{
    let parent = sentry::configure_scope(|scope| scope.get_span());
    let span1: sentry::TransactionOrSpan = match &parent {
        Some(parent) => parent.start_child(op, description).into(),
        None => {
            let ctx = sentry::TransactionContext::new(description, op);
            sentry::start_transaction(ctx).into()
        }
    };
    let span_request = Request {
        url: Some("https://beep.beep".parse().unwrap()),
        method: Some("GET".to_string()),
        ..Request::default()
    };
    span1.set_request(span_request);
    sentry::configure_scope(|scope| scope.set_span(Some(span1.clone())));

    let rv = f();

    span1.finish();
    sentry::configure_scope(|scope| scope.set_span(parent));

    rv
}

pub fn iter_trace_propagation_headers( &self, ) -> impl Iterator<Item = (&'static str, String)>

Returns the headers needed for distributed tracing.

Trait Implementations

impl Clone for Scope

fn clone(&self) -> Scope

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scope

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Scope

fn default() -> Scope

Returns the “default value” for a type.