# abstract struct Log::StaticFormatter

- Log::StaticFormatter
- Struct
- Value
- Object

##
Overview

Base implementation of `Log::Formatter` to convert log entries into text representation

This can be used to create efficient formatters:

    require "log"

    struct MyFormat < Log::StaticFormatter
      def run
        string "- "
        severity
        string ": "
        message
      end
    end

    Log.setup(:info, Log::IOBackend.new(formatter: MyFormat))
    Log.info { "Hello" }    # => -   INFO: Hello
    Log.error { "Oh, no!" } # => -  ERROR: Oh, no!

There is also a helper macro to generate these formatters. Here's an example that generates the same result:

    Log.define_formatter MyFormat, "- #{severity}: #{message}"

##
Extended Modules

- Log::Formatter

##
Direct Known Subclasses

- Log::ShortFormat

##
Defined in:

log/format.cr

##
Constructors

- .new(entry : Log::Entry, io : IO)

##
Class Method Summary

- .format(entry, io) : Nil

  Write the `Log::Entry` to the `IO` using this pattern

##
Instance Method Summary

- #context(*, before = nil, after = nil)

  Write all the values from the context

- #data(*, before = nil, after = nil) : Nil

  Write all the values from the entry data

- #exception(*, before = '\n', after = nil) : Nil

  Write the exception, including backtrace

- #message : Nil

  Write the message of the entry

- #pid(*, before = '#', after = nil)

  Write the current process identifier

- #progname : Nil

  Write the program name.

- #run

  Subclasses must implement this method to define the output pattern

- #severity : Nil

  Write the severity

- #source(*, before = nil, after = nil)

  Write the source for non-root entries

- #string(str) : Nil

  Write a fixed string

- #timestamp : Nil

  Write the entry timestamp in RFC3339 format

### Instance methods inherited from struct `Struct`

==(other) : Bool ==, hash(hasher) hash, inspect(io : IO) : Nil inspect, pretty_print(pp) : Nil pretty_print, to_s(io : IO) : Nil to_s

### Instance methods inherited from struct `Value`

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup

### Instance methods inherited from class `Object`

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

### Class methods inherited from class `Object`

from_json(string_or_io, root : String)
from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml

### Macros inherited from class `Object`

class_getter(*names, &block) class_getter, class_getter!(*names) class_getter!, class_getter?(*names, &block) class_getter?, class_property(*names, &block) class_property, class_property!(*names) class_property!, class_property?(*names, &block) class_property?, class_setter(*names) class_setter, def_clone def_clone, def_equals(*fields) def_equals, def_equals_and_hash(*fields) def_equals_and_hash, def_hash(*fields) def_hash, delegate(*methods, to object) delegate, forward_missing_to(delegate) forward_missing_to, getter(*names, &block) getter, getter!(*names) getter!, getter?(*names, &block) getter?, property(*names, &block) property, property!(*names) property!, property?(*names, &block) property?, setter(*names) setter

##
Constructor Detail

def self.new(entry : Log::Entry, io : IO) #

##
Class Method Detail

def self.format(entry, io) : Nil #

Write the `Log::Entry` to the `IO` using this pattern

##
Instance Method Detail

def context(*, before = nil, after = nil) #

Write all the values from the context

It doesn't write any output if the context is empty. Parameters `before` and `after` can be provided to be written around the value.

def data(*, before = nil, after = nil) : Nil #

Write all the values from the entry data

It doesn't write any output if the entry data is empty. Parameters `before` and `after` can be provided to be written around the value.

def exception(*, before = '\n', after = nil) : Nil #

Write the exception, including backtrace

It doesn't write any output unless there is an exception in the entry. Parameters `before` and `after` can be provided to be written around the value. `before` defaults to `'\n'` so the exception is written on a separate line

def message : Nil #

Write the message of the entry

def pid(*, before = '#', after = nil) #

Write the current process identifier

def progname : Nil #

Write the program name. See `Log.progname`.

abstract def run #

Subclasses must implement this method to define the output pattern

def severity : Nil #

Write the severity

This writes the severity in uppercase and left padded with enough space so all the severities fit

def source(*, before = nil, after = nil) #

Write the source for non-root entries

It doesn't write any output for entries generated from the root logger. Parameters `before` and `after` can be provided to be written around the value.

    Log.define_formatter TestFormatter, "#{source(before: '[', after: "] ")}#{message}"
    Log.setup(:info, Log::IOBackend.new(formatter: TestFormatter))
    Log.for("foo.bar").info { "Hello" } # => - [foo.bar] Hello

def string(str) : Nil #

Write a fixed string

def timestamp : Nil #

Write the entry timestamp in RFC3339 format