Struct spirit_log::CfgAndOpts

pub struct CfgAndOpts {
    pub cfg: Cfg,
    pub opts: Opts,
}

A combination of Cfg and Opts.

This is a composed Fragment ‒ the purpose is the caller can combine configuration both from command line options and configuration inside the same Pipeline ‒ see the crate examples.

The Fragment will then combine the options to create the relevant loggers.

Interaction on stderr

There’s a little twist around stderr and the interaction between the -L option and loggers set up in configuration. This is to act in a way that makes some sense ‒ in particular, we don’t want to log to stderr twice. Therefore:

• If the user specifies -l (or -L) on the command line, any stderr logger from configuration is skipped (the -l takes precedence).
• If there are no loggers in configuration but there’s no -l, errors are logged to stderr. This is the case before configuration is loaded or if it contains no loggers. We want to report errors somewhere.

Fields

cfg: Cfg

The configuration options.

opts: Opts

The command line options.

Trait Implementations

impl Clone for CfgAndOpts

fn clone(&self) -> CfgAndOpts

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CfgAndOpts

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

Formats the value using the given formatter.

impl Fragment for CfgAndOpts

type Driver = TrivialDriver

The default driver to be used by the fragment.

type Seed = ()

The intermediate product if the fragment supports two-stage creation of Resources. If not, it can be set to ().

type Resource = Dispatch

The actual product this Fragment creates.

type Installer = LogInstaller

The default installer to be used unless a transformation or the user doesn’t provide one.

const RUN_BEFORE_CONFIG: bool

Configuration if the pipeline should be run once even before the config is loaded.

fn make_seed(&self, _name: &str) -> Result<(), AnyError>

Runs the first stage of creation.

fn make_resource(&self, _: &mut (), _name: &str) -> Result<Dispatch, AnyError>

Runs the second stage of creation.

fn create(
    &self,
    name: &'static str
) -> Result<Self::Resource, Box<dyn Error + Sync + Send + 'static, Global>>

Runs both stages of creation at once.

fn init<B>(
    builder: B,
    &'static str
) -> Result<B, Box<dyn Error + Sync + Send + 'static, Global>> where
    B: Extensible<Ok = B>,
    <B as Extensible>::Config: DeserializeOwned,
    <B as Extensible>::Config: Send,
    <B as Extensible>::Config: Sync,
    <B as Extensible>::Config: 'static,
    <B as Extensible>::Opts: StructOpt,
    <B as Extensible>::Opts: Send,
    <B as Extensible>::Opts: Sync,
    <B as Extensible>::Opts: 'static, 

An initialization routine.