Sentry

https://docs.rs/sentry/latest/sentry/
Admin
Sentry is a Rust crate that provides support for logging events, errors, and panics to the Sentry...
Tokens:1,220,544
Snippets:11,783
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### get() example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.OccupiedEntry.html

Demonstrates getting a reference to the value in the entry.

```rust
use std::collections::BTreeMap;
use std::collections::btree_map::Entry;

let mut map: BTreeMap<&str, usize> = BTreeMap::new();
map.entry("poneyland").or_insert(12);

if let Entry::Occupied(o) = map.entry("poneyland") {
    assert_eq!(o.get(), &12);
}
```

--------------------------------

### Continue from span example (examples/performance-demo.rs)

Source: https://docs.rs/sentry/latest/sentry/struct.TransactionContext.html

Shows how to create a TransactionContext from the current span and start a background transaction on another thread. The example is from the repository's performance-demo.rs file.

```rust
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()
    });
}
```

--------------------------------

### key() example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.OccupiedEntry.html

Demonstrates getting a reference to the key in the entry.

```rust
use std::collections::BTreeMap;

let mut map: BTreeMap<&str, usize> = BTreeMap::new();
map.entry("poneyland").or_insert(12);
assert_eq!(map.entry("poneyland").key(), &"poneyland");
```

--------------------------------

### get example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Demonstrates get with a position or range index. Returns Some for valid indices and None for out-of-bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Example: using with_integration to get the first integration

Source: https://docs.rs/sentry/latest/sentry/fn.with_integration.html?search=std%3A%3Avec

Shows how to add two integrations with different values and use with_integration to retrieve the value from the first one. The example asserts the result is 10.

```rust
use sentry::{ClientOptions, Integration};

struct MyIntegration(usize);
impl Integration for MyIntegration {}

let options = ClientOptions::default()
    .add_integration(MyIntegration(10))
    .add_integration(MyIntegration(20));

let _sentry = sentry::init(options);

let value = sentry::with_integration(|integration: &MyIntegration, _| integration.0);
assert_eq!(value, 10);

```

--------------------------------

### continue_from_span example from examples/performance-demo.rs

Source: https://docs.rs/sentry/latest/sentry/struct.TransactionContext.html?search=

Shows how to create a TransactionContext from an existing span using sentry::TransactionContext::continue_from_span, then start a transaction and set it on the scope in a spawned thread. The example is from lines 39-43 of examples/performance-demo.rs.

```rust
let transaction_ctx = sentry::TransactionContext::continue_from_span(
    "background transaction",
    "root span",
    sentry::configure_scope(|scope| scope.get_span()),
);
```

--------------------------------

### BTreeMap::range example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a double-ended iterator over a sub-range of elements. The example uses the range syntax (Included(&4), Included(&8)) to iterate from 4 to 8 inclusive, and also shows the range 4.. to get the next element. Panics if start > end or if start == end with both bounds Excluded.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());

```

--------------------------------

### set_port example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Url.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to set the port number of a URL. The example demonstrates setting a port, clearing it, and handling errors for cannot-be-a-base URLs.

```rust
use url::Url;


let mut url = Url::parse("ssh://example.net:2048/")?;

url.set_port(Some(4096)).map_err(|_| "cannot be base")?;
assert_eq!(url.as_str(), "ssh://example.net:4096/");

url.set_port(None).map_err(|_| "cannot be base")?;
assert_eq!(url.as_str(), "ssh://example.net/");
```

```rust
use url::Url;


let mut url = Url::parse("https://example.org/")?;

url.set_port(Some(443)).map_err(|_| "cannot be base")?;
assert!(url.port().is_none());
```

```rust
use url::Url;

let mut url = Url::parse("mailto:rms@example.net")?;

let result = url.set_port(Some(80));
assert!(result.is_err());

let result = url.set_port(None);
assert!(result.is_err());
```

--------------------------------

### capture_error in health example

Source: https://docs.rs/sentry/latest/sentry/fn.capture_error.html

Example from examples/health.rs (line 30) showing how to use capture_error within a session tracking setup. It initializes Sentry with release and debug options, starts sessions, captures a message and an error, and ends the session.

```rust
fn main() {
    let _sentry = sentry::init(
        sentry::ClientOptions::new()
            // release health requires a release to be set
            .maybe_release(sentry::release_name!())
            .debug(true)
            // session tracking is enabled by default, but we want to explicitly
            // create the session
            .auto_session_tracking(false),
    );

    let handle = std::thread::spawn(|| {
        // this session will be set to crashed
        sentry::start_session();
        std::thread::sleep(std::time::Duration::from_secs(3));
        panic!("oh no!");
    });

    sentry::start_session();

    sentry::capture_message(
        "anything with a level >= Error will increase the error count",
        sentry::Level::Error,
    );

    // or any error that has an explicit exception attached
    let err = "NaN".parse::<usize>().unwrap_err();
    sentry::capture_error(&err);

    std::thread::sleep(std::time::Duration::from_secs(2));

    // this session will have an error count of 2, but otherwise have
    // a clean exit.
    sentry::end_session();

    handle.join().ok();
}
```

--------------------------------

### Get URL path with percent-encoding

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Url.html

Returns the path of a URL as a percent-encoded ASCII string. For cannot-be-a-base URLs, the path is an arbitrary string that does not start with '/'. The examples show paths for URLs with query strings, root paths, and non-ASCII characters.

```rust
use url::{Url, ParseError};

let url = Url::parse("https://example.com/api/versions?page=2")?;
assert_eq!(url.path(), "/api/versions");

let url = Url::parse("https://example.com")?;
assert_eq!(url.path(), "/");

let url = Url::parse("https://example.com/countries/việt nam")?;
assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
```

--------------------------------

### Performance demo: start transaction with tracing

Source: https://docs.rs/sentry/latest/sentry/fn.init.html

Initializes Sentry with traces_sample_rate and starts a transaction, adds a request, sets it as the current span, performs work, sleeps, then finishes the transaction.

```rust
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));
}
```

--------------------------------

### partition_point example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Example for partition_point showing the returned index i such that all elements before i satisfy the predicate and all elements after do not.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

--------------------------------

### wrap_in_span function example

Source: https://docs.rs/sentry/latest/sentry/enum.TransactionOrSpan.html

Example from examples/performance-demo.rs (line 94) showing how to wrap a function in a span. It starts a child span if a parent exists, otherwise starts a new transaction, sets a request, and finishes the span after the function runs.

```rust
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
}
```

--------------------------------

### windows example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html?search=u32+-%3E+bool

Demonstrates the windows iterator, which yields overlapping windows of a given size. The first example shows windows of size 3 on a 5-element slice; the second shows that a window larger than the slice yields no items.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());
```

```rust
let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());
```

--------------------------------

### start_session

Source: https://docs.rs/sentry/latest/sentry/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Start a new session for Release Health.

```APIDOC
## start_session

### Description
Start a new session for Release Health.

### Function Signature
`start_session()`

### Parameters
None.

### Returns
`()`

```

--------------------------------

### BTreeMap::range_mut example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a mutable double-ended iterator over a sub-range of elements. The example uses the range syntax "B".."Cheryl" to modify balances for keys in that range, then prints the map. Panics if start > end or if start == end with both bounds Excluded.

```rust
use std::collections::BTreeMap;

let mut map: BTreeMap<&str, i32> =
    [("Alice", 0), ("Bob", 0), ("Carol", 0), ("Cheryl", 0)].into();
for (_, balance) in map.range_mut("B".."Cheryl") {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{name} => {balance}");
}

```

--------------------------------

### insert example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.BTreeMap.html

Demonstrates using insert to add or update a key-value pair, showing the return value behavior.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map[&37], "c");
```

--------------------------------

### Finish a Sentry transaction in Rust

Source: https://docs.rs/sentry/latest/sentry/struct.Transaction.html

Example from examples/performance-demo.rs (line 31) showing how to finish a transaction with `transaction.finish()`. It initializes Sentry with a 1.0 traces sample rate, starts a root transaction, sets a request, and finishes it after a delay. The example also demonstrates starting a background transaction from a span and finishing it in a spawned thread.

```rust
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()
    });
}
```

--------------------------------

### Function `init`

Source: https://docs.rs/sentry/latest/sentry/fn.init.html?search=

Documentation for the `sentry::init` function, which initializes the Sentry client and returns a guard.

```APIDOC
## Function `init`

### Description
Creates the Sentry client for a given client config and binds it. Returns a client init guard that must be kept in scope to send events before the application closes. When the guard is dropped, the transport shuts down and no further events can be sent.

### Signature
```rust
pub fn init<C>(opts: C) -> ClientInitGuard
where
    C: Into<ClientOptions>,
```

### Parameters
- **opts** (`C`) - Required - The client configuration, which can be anything that converts into `ClientOptions` (e.g., a DSN string or a `ClientOptions` instance).

### Returns
- **ClientInitGuard** - A guard that must be kept in scope. When dropped, the transport shuts down. Can be inspected with `is_enabled()` to check if a client was created.

### Examples

#### Basic usage
```rust
let _sentry = sentry::init("https://key@sentry.io/1234");
```

#### Ignoring drain on shutdown (not recommended)
```rust
std::mem::forget(sentry::init("https://key@sentry.io/1234"));
```

#### Inspecting the guard
```rust
let sentry = sentry::init(sentry::ClientOptions::new().release("foo-bar-baz@1.0.0"));
if sentry.is_enabled() {
    // some other initialization
}
```

### Notes
This behaves similarly to creating a client via `Client::from_config` and binding it to the hub, but also applies default integrations, a default transport, and options populated from environment variables. See `Client::from_config` and `ClientOptions` for more details.
```

--------------------------------

### split_off_mut from index 2

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Example for split_off_mut removing the subslice starting from index 2.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

--------------------------------

### Example for as_simd

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Example for the `as_simd` method (or a related SIMD function) showing how to compute a sum over a subslice of a `Vec<f32>` and assert the result equals 4949.0.

```rust
let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### split_off from index 2

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Example for split_off removing the subslice starting from index 2.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

--------------------------------

### Slice last() example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Shows how to get the last element of a slice, returning None if empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Slice first() example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Shows how to get the first element of a slice, returning None if empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

--------------------------------

### Setting Transaction Request Information

Source: https://docs.rs/sentry/latest/sentry/struct.Transaction.html?search=std%3A%3Avec

Example demonstrating how to initialize a transaction and set its associated HTTP request information.

```rust
9fn main() {
10    let _sentry = sentry::init(
11        sentry::ClientOptions::new()
12            .maybe_release(sentry::release_name!())
13            .traces_sample_rate(1.0)
14            .debug(true),
15    );
16
17    let transaction =
18        sentry::start_transaction(sentry::TransactionContext::new("transaction", "root span"));
19    let tx_request = Request {
20        url: Some("https://honk.beep".parse().unwrap()),
21        method: Some("GET".to_string()),
22        ..Request::default()
23    };
24    transaction.set_request(tx_request);
25    sentry::configure_scope(|scope| scope.set_span(Some(transaction.clone().into())));
26
27    main_span1();
28
29    thread::sleep(Duration::from_millis(100));
30
31    transaction.finish();
32    sentry::configure_scope(|scope| scope.set_span(None));
33}
```

--------------------------------

### Actix-web middleware setup with sentry_actix

Source: https://docs.rs/sentry/latest/sentry/integrations/actix/index.html?search=std%3A%3Avec

Shows how to configure Sentry and add the sentry_actix middleware to an actix-web app. The example defines a failing handler and runs an HTTP server on 127.0.0.1:3001. It sets RUST_BACKTRACE=1 and uses a multi-threaded Tokio runtime.

```rust
use std::io;

use actix_web::{get, App, Error, HttpRequest, HttpServer};

#[get("/")]
async fn failing(_req: HttpRequest) -> Result<String, Error> {
    Err(io::Error::new(io::ErrorKind::Other, "An error happens here").into())
}

fn main() -> io::Result<()> {
    let _guard = sentry::init(
        sentry::ClientOptions::new().maybe_release(sentry::release_name!()),
    );
    std::env::set_var("RUST_BACKTRACE", "1");

    let runtime = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()?;
    runtime.block_on(async move {
        HttpServer::new(|| {
            App::new()
                .wrap(sentry_actix::Sentry::new())
                .service(failing)
        })
        .bind("127.0.0.1:3001")?
        .run()
        .await
    })
}
```

--------------------------------

### Custom Integration example with event processing

Source: https://docs.rs/sentry/latest/sentry/trait.Integration.html

Shows a complete custom Integration implementation that overrides the environment and event level. It demonstrates setup and process_event hooks, then verifies the behavior using sentry::test::with_captured_events_options.

```rust
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()));
```

--------------------------------

### init

Source: https://docs.rs/sentry/latest/sentry/all.html?search=u32+-%3E+bool

Initializes the Sentry SDK with the given options. Must be called before using other SDK functions.

```APIDOC
## init

### Description
Initializes the Sentry SDK with the given options. Must be called before using other SDK functions.

### Function Signature
`pub fn init(options: ClientOptions) -> ClientInitGuard`

### Parameters
- **options** (ClientOptions) - Required - The client options for configuring the SDK.

### Returns
- **ClientInitGuard** - A guard that keeps the client alive until dropped.
```

--------------------------------

### last_entry example

Source: https://docs.rs/sentry/latest/sentry/protocol/map/struct.BTreeMap.html

Demonstrates using last_entry to get the last entry (maximum key) and modify its value.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
map.insert(2, "b");
if let Some(mut entry) = map.last_entry() {
    if *entry.key() > 0 {
        entry.insert("last");
    }
}
assert_eq!(*map.get(&1).unwrap(), "a");
assert_eq!(*map.get(&2).unwrap(), "last");
```

--------------------------------

### starts_with example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Checks if the slice starts with the given prefix. Returns `true` if the needle is a prefix or equal to the slice.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

--------------------------------

### Slice split_first() example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Shows how to split a slice into its first element and the rest.

```rust
let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}
```

--------------------------------

### start_session

Source: https://docs.rs/sentry/latest/sentry/fn.start_session.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for the `start_session` function from the Sentry Rust SDK, which starts a new session for Release Health.

```APIDOC
## Function: start_session

### Description
Starts a new session for Release Health. This is experimental and not recommended for high-volume session usage.

### Signature
```rust
pub fn start_session()
```

### Availability
- **Crate feature**: `release-health`

### Parameters
None.

### Return Value
None.

### Examples
```rust
sentry::start_session();

// capturing any event / error here will update the sessions `errors` count,
// up until we call `sentry::end_session`.

sentry::end_session();
```
```

--------------------------------

### Slice len() example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Shows how to use the len() method from Deref<Target=[T]> to get the number of elements in a slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Get version with get_version

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Uuid.html

Returns the version as an Option<Version>. The example parses a UUID and asserts the version is Md5.

```rust
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;

assert_eq!(Some(Version::Md5), my_uuid.get_version());
```

--------------------------------

### Example for slice::partition_point

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Values.html

Example for `slice::partition_point` showing how to find the index of the first element that does not satisfy the predicate, assuming the slice is partitioned.

```rust
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);
```

--------------------------------

### Get UUID as u128 with as_u128

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Uuid.html

Returns the UUID as a 128-bit value. The example parses a UUID and asserts the u128 representation.

```rust
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;

assert_eq!(
    uuid.as_u128(),
    0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8,
);
```

--------------------------------

### SentryFuture::new

Source: https://docs.rs/sentry/latest/sentry/struct.SentryFuture.html

Documentation for the `SentryFuture::new` constructor method.

```APIDOC
## `SentryFuture::new`

### Description
Creates a new bound future with a `Hub`. This is typically not used directly; prefer `FutureExt::bind_hub`.

### Signature
```rust
pub fn new(hub: Arc<Hub>, future: F) -> SentryFuture<F>
```

### Parameters
- `hub` (`Arc<Hub>`) - The hub to bind to the future's execution.
- `future` (`F`) - The inner future to wrap.

### Returns
- `SentryFuture<F>` - A new `SentryFuture` that activates the given hub during polling.
```

--------------------------------

### Url::options example

Source: https://docs.rs/sentry/latest/sentry/protocol/struct.Url.html

Returns a default `ParseOptions` that can fully configure the URL parser. This example changes the base URL before parsing.

```rust
use url::Url;
let options = Url::options();
let api = Url::parse("https://api.example.com")?;
let base_url = options.base_url(Some(&api));
let version_url = base_url.parse("version.json")?;
assert_eq!(version_url.as_str(), "https://api.example.com/version.json");
```
Tokens:
Raw