Struct tracing_layer_discord::BackgroundWorker

pub struct BackgroundWorker { /* private fields */ }

This worker manages a background async task that schedules the network requests to send traces to the Discord on the running tokio runtime.

Ensure to invoke .startup() before, and .teardown() after, your application code runs. This is required to ensure proper initialization and shutdown.

tracing-layer-discord synchronously generates payloads to send to the Discord API using the tracing events from the global subscriber. However, all network requests are offloaded onto an unbuffered channel and processed by a provided future acting as an asynchronous worker.

Implementations

impl BackgroundWorker

pub async fn shutdown(self)

Initiate the worker’s shutdown sequence.

Without invoking.teardown(), your application may exit before all Discord messages can be sent.

Examples found in repository

examples/simple.rs (line 35)

async fn main() {
    let (discord_layer, background_worker) = DiscordLayer::builder("test-app".to_string(), Default::default()).build();
    let subscriber = Registry::default().with(discord_layer);
    tracing::subscriber::set_global_default(subscriber).unwrap();
    controller().await;
    background_worker.shutdown().await;
}

examples/exclude_messages_below_level.rs (line 22)

async fn main() {
    let targets_to_filter: EventFilters = Regex::new("exclude_messages_below_level").unwrap().into();
    let (discord_layer, background_worker) = DiscordLayer::builder("test-app".to_string(), targets_to_filter)
        .level_filters("info".to_string())
        .build();
    let subscriber = Registry::default().with(discord_layer);
    tracing::subscriber::set_global_default(subscriber).unwrap();
    handler().await;
    background_worker.shutdown().await;
}

examples/exclude_messages_by_content.rs (line 23)

async fn main() {
    let targets_to_filter: EventFilters = (None, None).into();
    let messages_to_exclude = vec![Regex::new("the message we want to exclude").unwrap()];
    let (discord_layer, background_worker) = DiscordLayer::builder("test-app".to_string(), targets_to_filter)
        .message_filters((Vec::new(), messages_to_exclude).into())
        .build();
    let subscriber = Registry::default().with(discord_layer);
    tracing::subscriber::set_global_default(subscriber).unwrap();
    handler().await;
    background_worker.shutdown().await;
}

examples/filter_records_by_fields.rs (line 27)

async fn main() {
    let targets_to_filter: EventFilters = Regex::new("filter_records_by_fields").unwrap().into();
    let event_fields_to_filter: EventFilters = Regex::new("password").unwrap().into();
    let (discord_layer, background_worker) = DiscordLayer::builder("test-app".to_string(), targets_to_filter)
        .event_by_field_filters(event_fields_to_filter)
        .build();
    let subscriber = Registry::default().with(discord_layer);
    tracing::subscriber::set_global_default(subscriber).unwrap();
    handler().await;
    background_worker.shutdown().await;
}

examples/exclude_fields_from_messages.rs (line 31)

async fn main() {
    let targets_to_filter: EventFilters = Regex::new("exclude_fields_from_messages").unwrap().into();
    let fields_to_exclude = vec![
        Regex::new(".*token.*").unwrap(),
        Regex::new(".*password.*").unwrap(),
        Regex::new("command").unwrap(),
    ];
    let (discord_layer, background_worker) = DiscordLayer::builder("test-app".to_string(), targets_to_filter)
        .field_exclusion_filters(fields_to_exclude)
        .build();
    let subscriber = Registry::default().with(discord_layer);
    tracing::subscriber::set_global_default(subscriber).unwrap();
    handler().await;
    background_worker.shutdown().await;
}

Trait Implementations

impl Clone for BackgroundWorker

fn clone(&self) -> BackgroundWorker

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BackgroundWorker

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

Formats the value using the given formatter.