Struct AppInsights

pub struct AppInsights<S = Base, C = Client, R = Tokio, U = Registry, P = (), E = ()> { /* private fields */ }

The main telemetry struct.

Refer to the top-level documentation for usage information.

Implementations

impl<C, R, U, P, E> AppInsights<Base, C, R, U, P, E>

pub fn with_connection_string( self, connection_string: impl Into<Option<String>>, ) -> AppInsights<WithConnectionString, C, R, U, P, E>

Sets the connection string to use for telemetry.

If this is not set, then no telemetry will be sent.

use axum_insights::{AppInsights, WithConnectionString};
 
let i: AppInsights<WithConnectionString> = AppInsights::default()
    .with_connection_string(None);

impl<C, R, U, P, E> AppInsights<WithConnectionString, C, R, U, P, E>

pub fn with_service_config( self, namespace: impl AsRef<str>, name: impl AsRef<str>, servername: impl AsRef<str>, ) -> AppInsights<Ready, C, R, U, P>

Sets the service namespace and name.

use axum_insights::{AppInsights, Ready};
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername");

This is a convenience method for AppInsights::with_trace_config.

pub fn with_trace_config(self, config: Config) -> AppInsights<Ready, C, R, U, P>

Sets the trace config to use for telemetry.

use axum_insights::{AppInsights, Ready};
use opentelemetry_sdk::trace::Config;
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_trace_config(Config::default());

impl<C, R, U, P, E> AppInsights<Ready, C, R, U, P, E>

pub fn with_client(self, client: C) -> AppInsights<Ready, C, R, U, P, E>

Sets the HTTP client to use for sending telemetry. The default is reqwest async client.

use axum_insights::{AppInsights, Ready};
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_client(reqwest::Client::new());

pub fn with_live_metrics( self, should_collect_live_metrics: bool, ) -> AppInsights<Ready, C, R, U, P, E>

Sets whether or not live metrics should be collected. The default is false.

use axum_insights::{AppInsights, Ready};
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_client(reqwest::Client::new())
    .with_live_metrics(true);

pub fn with_sample_rate( self, sample_rate: f64, ) -> AppInsights<Ready, C, R, U, P, E>

Sets the sample rate for telemetry. The default is 1.0.

use axum_insights::{AppInsights, Ready};
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_sample_rate(1.0);

pub fn with_minimum_level( self, minimum_level: LevelFilter, ) -> AppInsights<Ready, C, R, U, P, E>

Sets the minimum level for telemetry. The default is INFO.

use axum_insights::{AppInsights, Ready};
use tracing_subscriber::filter::LevelFilter;
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_minimum_level(LevelFilter::INFO);

pub fn with_subscriber<T>( self, subscriber: T, ) -> AppInsights<Ready, C, R, T, P, E>

Sets the subscriber to use for telemetry. The default is a new subscriber.

use axum_insights::{AppInsights, Ready};
use tracing_subscriber::Registry;
 
let i = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_subscriber(tracing_subscriber::registry());

pub fn with_runtime<T>(self, runtime: T) -> AppInsights<Ready, C, T, U, P, E>

where T: RuntimeChannel,

Sets the runtime to use for the telemetry batch exporter. The default is Tokio.

use axum_insights::{AppInsights, Ready};
use opentelemetry_sdk::runtime::Tokio;
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_runtime(Tokio);

pub fn with_catch_panic( self, should_catch_panic: bool, ) -> AppInsights<Ready, C, R, U, P, E>

Sets whether or not to catch panics, and emit a trace for them. The default is false.

use axum_insights::{AppInsights, Ready};
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_catch_panic(true);

pub fn with_noop(self, should_noop: bool) -> AppInsights<Ready, C, R, U, P, E>

Sets whether or not to make this telemetry layer a noop. The default is false.

This is useful whenever you are running axum tests, as the global subscriber cannot be set in a multiple times. Effectively, this causes the telemetry layer to be a no-op.

use axum_insights::{AppInsights, Ready};
 
let i = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_noop(true);

pub fn with_field_mapper<F>( self, field_mapper: F, ) -> AppInsights<Ready, C, R, U, P, E>

where F: Fn(&Parts) -> HashMap<String, String> + Send + Sync + 'static,

Sets a function to extract extra fields from the request. The default is no extra fields.

use axum_insights::{AppInsights, Ready};
use std::collections::HashMap;
 
let i: AppInsights<Ready> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_field_mapper(|parts| {
        let mut map = HashMap::new();
        map.insert("extra_field".to_owned(), "extra_value".to_owned());
        map
    });

pub fn with_panic_mapper<F, T>( self, panic_mapper: F, ) -> AppInsights<Ready, C, R, U, T, E>

where F: Fn(String) -> (u16, T) + Send + Sync + 'static,

Sets a function to extract extra fields from a panic. The default is a default error.

use axum_insights::{AppInsights, Ready};
 
struct WebError {
    message: String,
}
 
let i = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_panic_mapper(|panic| {
        (500, WebError { message: panic })
    });

pub fn with_success_filter<F>( self, success_filter: F, ) -> AppInsights<Ready, C, R, U, P, E>

where F: Fn(StatusCode) -> bool + Send + Sync + 'static,

Sets a function to determine the success-iness of a status. The default is (100 - 399 => true).

This allows you to fine-tune which statuses are considered successful, and which are not. If you have lots of spurious 404s, for example, you can add that to the success statuses.

use axum_insights::{AppInsights, Ready};
use http::StatusCode;
 
let i = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_success_filter(|status| {
        status.is_success() || status.is_redirection() || status.is_informational() || status == StatusCode::NOT_FOUND
    });

pub fn with_error_type<T>(self) -> AppInsights<Ready, C, R, U, P, T>

Sets the error type to use for telemetry. The default is ().

use axum_insights::{AppInsights, AppInsightsError, Ready};
 
struct WebError {
    message: String,
}
 
impl AppInsightsError for WebError {
    fn message(&self) -> Option<String> {
        Some(self.message.clone())
    }
 
    fn backtrace(&self) -> Option<String> {
        None
    }
}
 
let i = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .with_error_type::<WebError>();

pub fn build_and_set_global_default( self, ) -> Result<AppInsightsComplete<P, E>, Box<dyn Error + Send + Sync + 'static>>

where C: HttpClient + 'static, R: RuntimeChannel, U: SubscriberExt + for<'span> LookupSpan<'span> + Send + Sync + 'static,

Builds the telemetry layer, and sets it as the global default.

use axum_insights::{AppInsights, AppInsightsComplete};
 
let i: AppInsightsComplete<_, _> = AppInsights::default()
    .with_connection_string(None)
    .with_service_config("namespace", "name", "servername")
    .build_and_set_global_default()
    .unwrap();

The global default currently has to be set by this library. If you want to use other subscribers, then you need to use AppInsights::with_subscriber to inject that subscriber, and then allow this call to set the global default.

Trait Implementations

impl Default for AppInsights<Base>

fn default() -> Self

Returns the “default value” for a type.