Enum LogLevel

pub enum LogLevel {
    Trace,
    Debug,
    Info,
    Warn,
    Error,
    Fatal,
}

Logging severity levels in ascending order of importance.

The levels follow the common convention:

• Trace: Very detailed information, typically only needed when debugging specific issues
• Debug: Detailed information useful for debugging
• Info: General information about application progress
• Warn: Potentially harmful situations that might need attention
• Error: Error events that might still allow the application to continue running

Variants

Trace

Very detailed information for debugging specific issues

Debug

Detailed information useful for debugging

Info

General information about application progress

Warn

Potentially harmful situations

Error

Error events, Could still allow the application to continue running

Fatal

Fatal error events that lead to application termination

Implementations

impl LogLevel

pub fn default_coloring(&self) -> String

Returns the level string with appropriate color formatting.

Each log level has an associated color:

• Trace: Cyan
• Debug: Blue
• Info: Green
• Warn: Yellow
• Error: Red

Returns

The formatted string with ANSI color codes applied

Examples found in repository

examples/custom-format.rs (line 9)

    fn format(&self, record: &traccia::Record) -> String {
        format!(
            "{}: {}",
            record.level.default_coloring().to_lowercase(),
            record.message
        )
    }

examples/threads.rs (line 12)

    fn format(&self, record: &Record) -> String {
        let id_str = format!("{:?}", record.thread_id);
        let id_str = id_str.replace("ThreadId(", "").replace(")", "");

        format!(
            "[{}] [thread:{}] {}",
            record.level.default_coloring(),
            id_str,
            record.message,
        )
    }

Trait Implementations

impl Clone for LogLevel

fn clone(&self) -> LogLevel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogLevel

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

Formats the value using the given formatter.

impl Default for LogLevel

The default log level is info

fn default() -> Self

Returns the “default value” for a type.

impl Display for LogLevel

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

Formats the log level as a string.

Returns

A capitalized string representation of the log level.

impl FromStr for LogLevel

Parse the log level from &str.

Useful for things like clap to parse the log level via command-line arguments.

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for LogLevel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for LogLevel

fn cmp(&self, other: &LogLevel) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for LogLevel

fn eq(&self, other: &LogLevel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for LogLevel

fn partial_cmp(&self, other: &LogLevel) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl TryFrom<LogLevel> for u8

TryFrom log level implementation for u8

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: LogLevel) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for LogLevel

Tryfrom u8 parsing implementation

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Error>

Performs the conversion.

impl ValueEnum for LogLevel

Implementation of the clap’s ValueEnum trait for LogLevel when the “clap” feature is enabled.

This allows using LogLevel directly with clap’s derive API and provides several ways to specify log levels on the command line:

Command-line examples:

myapp --log-level debug

myapp --log-level DEBUG

myapp --log-level Debug

This implementation provides the list of all possible log level variants and defines how they can be specified from command-line arguments, supporting case-insensitive matching.

fn value_variants<'a>() -> &'a [Self]

Returns an array slice containing all variants of LogLevel.

This is used by clap to validate and parse command-line arguments.

fn to_possible_value(&self) -> Option<PossibleValue>

Converts a LogLevel variant to its string representation with aliases.

For each log level, this provides:

• A lowercase default (e.g., “debug”)
• An uppercase alias (e.g., “DEBUG”)
• A title case alias (e.g., “Debug”)

This allows users to specify the log level in any case they prefer.

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

Parse an argument into Self.

impl Copy for LogLevel

impl Eq for LogLevel

impl StructuralPartialEq for LogLevel