Struct spirit_log::Cfg

pub struct Cfg(_);

A configuration fragment to set up logging.

By flattening this into the configuration structure, the program can load options for configuring logging. It adds a new top-level array logging. Each item describes one logger, with separate log levels and destination.

See the crate examples for the use.

Logger options

These are valid for all loggers:

• level: The log level to use. Valid options are OFF, ERROR, WARN, INFO, DEBUG and TRACE.
• per-module: A map, setting log level overrides for specific modules (logging targets). This one is optional.
• type: Specifies the type of logger destination. Some of them allow specifying other options.
• clock: Either LOCAL or UTC. Defaults to LOCAL if not present.
• time_format: Time format string. Defaults to %+ (which is ISO 8601/RFC 3339). Note that the command line logger (one produced by -l) uses a more human-friendly format.
• format: The format to use. There are few presets (and a custom may come in future).
  • message-only: The line contains only the message itself.
  • short: This is the default. <timestamp> <level> <target> <message>. Padded to form columns.
  • extended: `. Padded to form columns.
  • full: <timestamp> <level> <thread-name> <file>:<line> <target> <message>. Padded to form columns.
  • machine: Like full, but columns are not padded by spaces, they are separated by a single \t character, for more convenient processing by tools like cut.
  • json: The fields of full are encoded into a json format, for convenient processing of more modern tools like logstash.
  • logstash: json format with fields named and formatted according to Logback JSON encoder

The allowed types are:

• stdout: The logs are sent to standard output. There are no additional options.
• stderr: The logs are sent to standard error output. There are no additional options.
• file: Logs are written to a file. The file is reopened every time a configuration is re-read (therefore every time the application gets SIGHUP), which makes it work with logrotate.
  • filename: The path to the file where to put the logs.
• network: The application connects to a given host and port over TCP and sends logs there.
  • host: The hostname (or IP address) to connect to.
  • port: The port to use.
• syslog: Sends the logs to syslog. This ignores all the formatting and time options, as syslog handles this itself. This depends on the to-syslog feature.

Implementations

impl Cfg

pub fn init_extension<E: Extensible>() -> impl Extension<E>

This provides an Extension to initialize logging.

It calls init and sets up a basic logger (WARN and more serious going to stderr).

This is seldom used directly (but can be), the LogInstaller makes sure it is called.

pub fn is_empty(&self) -> bool

Checks if the logging configuration is empty.

Can be used for skipping serialization of the config array if empty.

Trait Implementations

impl Clone for Cfg

fn clone(&self) -> Cfg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cfg

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

Formats the value using the given formatter.

impl Default for Cfg

fn default() -> Cfg

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Cfg

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Fragment for Cfg

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.

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.

const RUN_BEFORE_CONFIG: bool

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

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

Runs both stages of creation at once.

fn init<B>(
    builder: B,
    &'static str
) -> Result<B, Box<dyn Error + 'static + Sync + Send>> 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.

impl Serialize for Cfg

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructDoc for Cfg

fn document() -> Documentation

Returns the documentation for the type.