import tango.util.log.Log;format

        It is considered good form to pass a logger instance as a function or
        class-ctor argument, or to assign a new logger instance during static
        class construction. For example: if it were considered appropriate to
        have one logger instance per class, each might be constructed like so:

        Messages passed to a Logger are assumed to be either self-contained
        or configured with "{}" notation a la Layout & Stdout:

        Note that an internal workspace is used to format the message, which
        is limited to 2000 bytes. Use "{.256}" truncation notation to limit
        the size of individual message components, or use explicit formatting:

        To avoid overhead when constructing argument passed to formatted
        messages, you should check to see whether a logger is active or not:

        The above will be handled implicitly by the logging system when
        macros are added to the language (used to be handled implicitly
        via lazy delegates, but usage of those turned out to be awkward).

        tango.log closely follows both the API and the behaviour as documented
        at the official Log4J site, where you'll find a good tutorial. Those
        pages are hosted over
        here.

interface Context ;

Context for a hierarchy, used for customizing behaviour of log hierarchies. You can use this to implement dynamic log-levels, based upon filtering or some other mechanism

abstract char[] label ();

return a label for this context

abstract bool enabled (Level setting, Level target);

first arg is the setting of the logger itself, and

the second arg is what kind of message we're being

asked to produce

final bool enabled (Level level = cast(Level)4);

Is this logger enabed for the specified Level?

final bool trace ();

Is trace enabled?

final void trace (char[] fmt,...);

Append a trace message

final bool info ();

Is info enabled?

final void info (char[] fmt,...);

Append an info message

final bool warn ();

Is warn enabled?

final void warn (char[] fmt,...);

Append a warning message

final bool error ();

Is error enabled?

final void error (char[] fmt,...);

Append an error message

final bool fatal ();

Is fatal enabled?

final void fatal (char[] fmt,...);

Append a fatal message

final char[] name ();

Return the name of this Logger (sans the appended dot).

final Level level ();

Return the Level this logger is set to

final Logger level (Level l);

Set the current level for this logger (and only this logger).

final Logger level (Level level , bool propagate);

Set the current level for this logger, and (optionally) all of its descendents.

final bool additive ();

Is this logger additive ? That is, should we walk ancestors looking for more appenders?

final Logger additive (bool enabled);

Set the additive status of this logger. See bool additive ().

final Logger add (Appender another);

Add (another) appender to this logger. Appenders are each invoked for log events as they are produced. At most, one instance of each appender will be invoked.

final Logger clear ();

Remove all appenders from this Logger

final TimeSpan runtime ();

Get time since this application started

final Logger append (Level level, lazy char[] exp);

Send a message to this logger via its appender list.

final char[] format (char[] buffer, char[] formatStr,...);

Format text using the formatter configured in the associated hierarchy

final Logger format (Level level, char[] fmt, TypeInfo[] types, void* args);

Format text using the formatter configured in the associated hierarchy.