Type Members

1.  trait EntryFormatter extends Formatter[Entry]

   Converts an Entry into text.

2.  trait Formatter[-T] extends AnyRef

   Converts something into text.

   Converts something into text. Implementations of this trait must be thread-safe.

   T

   the type of object that this formatter can turn into text.

3.  class ProgrammableEntryFormatter extends EntryFormatter

   Formats entries using the specified metadata providers to create a header.

   Formats entries using the specified metadata providers to create a header. The metadata providers can be specified using the mini-DSL on the entry object:

   • threadName - the name of the thread that created the entry
   • timestamp - the timestamp at which the entry was created
   • level - the level at which the entry was created (if available)
   • loggingClass - the class from which the log method was called (if available)
   • loggingMethod - the method from which the log method was called (if available)
   • sourceLocation - the location in source (file name and line number) from which the log method was called (if available)
   • tags - the tags associated with the entry
   • loggerAttributes - the logger attributes associated with the entry
   • threadAttributes - the thread attributes associated with the entry
   • loggerAttribute(name) - the logger attribute with the specified name associated with the entry (if available)
   • threadAttribute(name) - the thread attribute with the specified name associated with the entry (if available)

   new ProgrammableEntryFormatter(Seq(entry.threadName,entry.loggingClass))

   You can also specify Strings to be included literally.

   new ProgrammableEntryFormatter(Seq("literal",entry.loggingClass))

   In addition to the providers above, you can specify some modifiers to tweak them before their inclusion:

   • formattedWith - allows you to choose how the metadata is formatted, must match the type of the metadata
   • map - allows you to apply an arbitrary mapping function to the metadata before inclusion
   • without - allows you to remove keys from a map before inclusion (e.g., if you already included on of the keys specifically)

   If you don't specify a formatter, the toString method of the object will be used. There are some built-in formatters for timestamps and levels that you can use. There are also some built-in formatters for any Iterables that may be more appealing than the default toString implementation.

   • Commas - formats Iterables as strings with commas separating the items
   • Spaces - formats Iterables as strings with spaces separating the items
   • Delimiter(str) - formats Iterables as strings with the specified delimiter separating the items
   • CommasAndEquals - formats Maps as equals-separated pairs separated by commas (e.g., k1=v1,k2=v2)

   entry.timestamp formattedWith HumanReadableTimestampFormatter
   entry.timestamp formattedWith SimpleDateFormatTimestampFormatter("yyyy/MM/dd")
   entry.threadName map { name => name.length }
   entry.loggerAttributes without "name" formattedWith CommasAndEquals

   For the metadata that may not be present (indicated with "if available" above), you can specify a fallback to use when it's absent with orElse. You can't use orElse after a metadata provider that will definitely return something.

   entry.loggingClass orElse entry.loggerAttribute("name") orElse "unknown"

   With certain combinations of modifiers, you may have to include parentheses if the scala compiler can't figure out the operator precedence. You can also specify the modifiers without utilizing the infix call style, if you prefer.