Struct bitbazaar::log::GlobalLog

pub struct GlobalLog { /* private fields */ }

The global logger/tracer for stdout, file and full open telemetry. Works with the tracing crates (info!, debug!, warn!, error!) and span funcs and decorators.

GlobalLog::meter is also provided to create metrics, these aren’t native to the tracing crate.

Unlike my other lang implementations, for file and stdout this uses a separate flow, they won’t use metrics and only receive basic span information. Simply because I did it first, plus the rust opentelemetry sdk is very new, so difficult to use and the benefit of handling file and stdout through otlp is minimal.

Open telemetry support is opinionated: unencrypted/uncompressed output to a local grpc port, the intention is this is a otpl collector sidecar.

Examples:

Kitchen sink:

use bitbazaar::logging::GlobalLog;
use tracing_subscriber::prelude::*;
use tracing::Level;

let temp_dir = tempfile::tempdir().unwrap();
let log = GlobalLog::builder()
            .stdout(true, false)
            .level_from(Level::DEBUG) // Debug and up for stdout, each defaults to INFO
            .file("my_program.log", temp_dir)
            .otlp(4317, "service-name", "0.1.0").level_from(Level::INFO)
            .build().unwrap();
log.register_global()?; // Register it as the global sub, this can only be done once

Implementations

impl GlobalLog

pub fn builder() -> GlobalLogBuilder

Create a builder to configure the global logger.

pub fn setup_quick_stdout_global_logging( level_from: Level, ) -> RResult<(), AnyErr>

A managed wrapper on creation of the GlobalLog and registering it as the global logger.

Sets up console logging only. Should only be used for quick logging, as an example and testing.

pub fn register_global(self) -> RResult<(), AnyErr>

Register the logger as the global logger/tracer/metric manager, can only be done once during the lifetime of the program.

If you need temporary globality, use the GlobalLog::with_tmp_global method.

pub fn meter( &self, name: impl Into<Cow<'static, str>>, ) -> RResult<Meter, AnyErr>

See super::global_fns::meter`

pub fn set_span_parent_from_http_headers( &self, span: &Span, headers: &HeaderMap, ) -> RResult<(), AnyErr>

See super::global_fns::set_span_parent_from_http_headers`

pub fn set_response_headers_from_ctx<B>( &self, response: &mut Response<B>, ) -> RResult<(), AnyErr>

See super::global_fns::set_response_headers_from_ctx`

pub fn with_tmp_global<T>(&self, f: impl FnOnce() -> T) -> RResult<T, AnyErr>

Temporarily make the logger global, for the duration of the given closure.

If you want to make the logger global permanently, use the GlobalLog::register_global method.

pub fn flush(&self) -> RResult<(), AnyErr>

See super::global_fns::flush`

pub fn shutdown(&mut self) -> RResult<(), AnyErr>

See super::global_fns::shutdown`