Struct sentry::Client

pub struct Client { /* private fields */ }

The Sentry Client.

The Client is responsible for event processing and sending events to the sentry server via the configured Transport. It can be created from a ClientOptions.

See the Unified API document for more details.

Examples

sentry::Client::from(sentry::ClientOptions::default());

Implementations

impl Client

This impl block contains no items.

Determine whether the new transaction should be sampled.

impl Client

pub fn from_config<O>(opts: O) -> Client

where O: Into<ClientOptions>,

Creates a new Sentry client from a config.

Supported Configs

The following common values are supported for the client config:

• ClientOptions: configure the client with the given client options.
• () or empty string: Disable the client.
• &str / String / &OsStr / String: configure the client with the given DSN.
• Dsn / &Dsn: configure the client with a given DSN.
• (Dsn, ClientOptions): configure the client from the given DSN and optional options.

The Default implementation of ClientOptions pulls in the DSN from the SENTRY_DSN environment variable.

Panics

The Into<ClientOptions> implementations can panic for the forms where a DSN needs to be parsed. If you want to handle invalid DSNs you need to parse them manually by calling parse on it and handle the error.

pub fn with_options(options: ClientOptions) -> Client

Creates a new sentry client for the given options.

If the DSN on the options is set to None the client will be entirely disabled.

pub fn options(&self) -> &ClientOptions

Returns the options of this client.

pub fn dsn(&self) -> Option<&Dsn>

Returns the DSN that constructed this client.

pub fn is_enabled(&self) -> bool

Quick check to see if the client is enabled.

The Client is enabled if it has a valid DSN and Transport configured.

Examples

use std::sync::Arc;

let client = sentry::Client::from(sentry::ClientOptions::default());
assert!(!client.is_enabled());

let dsn = "https://public@example.com/1";
let transport = sentry::test::TestTransport::new();
let client = sentry::Client::from((
    dsn,
    sentry::ClientOptions {
        transport: Some(Arc::new(transport)),
        ..Default::default()
    },
));
assert!(client.is_enabled());

pub fn capture_event( &self, event: Event<'static>, scope: Option<&Scope>, ) -> Uuid

Captures an event and sends it to sentry.

pub fn send_envelope(&self, envelope: Envelope)

Sends the specified Envelope to sentry.

pub fn flush(&self, timeout: Option<Duration>) -> bool

Drains all pending events without shutting down.

pub fn close(&self, timeout: Option<Duration>) -> bool

Drains all pending events and shuts down the transport behind the client. After shutting down the transport is removed.

This returns true if the queue was successfully drained in the given time or false if not (for instance because of a timeout). If no timeout is provided the client will wait for as long a shutdown_timeout in the client options.

pub fn sample_should_send(&self, rate: f32) -> bool

Returns a random boolean with a probability defined by rate

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.

impl<T> From<T> for Client

where T: Into<ClientOptions>,

fn from(o: T) -> Client

Converts to this type from the input type.

impl RefUnwindSafe for Client