Enum LogFormat 

pub enum LogFormat {
    Auto,
    Pretty,
    Compact,
    Json,
}

The shape of a log line.

use rainier_support::Setting;
use rainier_telemetry::LogFormat;

assert_eq!(LogFormat::parse("json").unwrap(), LogFormat::Json);
assert!(LogFormat::parse("jsn").is_err());

Variants

Auto

JSON in production and staging, pretty everywhere else.

The default, because it is right far more often than either fixed answer, and because the failure it prevents — a production deployment logging prose into an aggregator that wanted objects — is one nobody notices until they are searching for something.

Pretty

The human format: coloured, aligned, one event per line.

tracing_subscriber’s default, which is what a Rainier application has always printed — so this is the format nobody asked for and everybody recognises.

Compact

Denser than pretty and still readable. For docker logs and CI, where the terminal is narrow and nothing is colouring anything.

Json

One JSON object per line. For anything that indexes fields.

Implementations

impl LogFormat

pub fn as_str(&self) -> &'static str

The wire spelling — what appears in .env and in the config tree.

Inherent as well as on the trait, so callers do not have to import Setting to print one.

impl LogFormat

pub fn resolve(self, environment: &str) -> LogFormat

What Auto means in this environment.

Production and staging get JSON; everything else gets pretty. Staging is included deliberately — it exists to be production-shaped, and a staging deployment whose logs are not searchable the same way is one that cannot rehearse an incident.

use rainier_telemetry::LogFormat;

assert_eq!(LogFormat::Auto.resolve("production"), LogFormat::Json);
assert_eq!(LogFormat::Auto.resolve("local"), LogFormat::Pretty);
// Anything explicit is left alone.
assert_eq!(LogFormat::Compact.resolve("production"), LogFormat::Compact);

pub fn is_structured(self) -> bool

Whether lines in this format are meant to be parsed rather than read.

Trait Implementations

impl AsRef<str> for LogFormat

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for LogFormat

fn clone(&self) -> LogFormat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LogFormat

impl Debug for LogFormat

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

Formats the value using the given formatter.

impl Default for LogFormat

fn default() -> LogFormat

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LogFormat

fn deserialize<D>( deserializer: D, ) -> Result<LogFormat, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LogFormat

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

Formats the value using the given formatter.

impl Eq for LogFormat

impl FromStr for LogFormat

type Err = Error

The associated error which can be returned from parsing.

fn from_str(raw: &str) -> Result<LogFormat, <LogFormat as FromStr>::Err>

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

impl Hash for LogFormat

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

where __H: Hasher,

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 PartialEq for LogFormat

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LogFormat

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Setting for LogFormat

const SETTING: &'static str = "log format"

What this setting is called in an error message — "cache driver".

const ALL: &'static [LogFormat]

Every variant, in the order they should be listed to a human.

fn as_str(&self) -> &'static str

The wire spelling — what appears in .env, in the config tree, and in serialised output.

fn parse(raw: &str) -> Result<Self, Error>

Parse a wire spelling.

fn options() -> String

The valid spellings, backtick-quoted and comma-separated.

impl StructuralPartialEq for LogFormat