Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# std.experimental.logger.core

Source std/experimental/logger/core.d

template `isLoggingActiveAt`(LogLevel ll)
  This template evaluates if the passed LogLevel is active. The previously described version statements are used to decide if the LogLevel is active. The version statements only influence the compile unit they are used with, therefore this function can only disable logging this specific compile unit.
enum bool `isLoggingActive`;
  This compile-time flag is `true` if logging is not statically disabled.
@safe bool `isLoggingEnabled`()(LogLevel `ll`, LogLevel `loggerLL`, LogLevel `globalLL`, lazy bool `condition` = true);
  This functions is used at runtime to determine if a LogLevel is active. The same previously defined version statements are used to disable certain levels. Again the version statements are associated with a compile unit and can therefore not disable logging in other compile units. pure bool `isLoggingEnabled`()(LogLevel `ll`) @safe nothrow @nogc
template `moduleLogLevel`(string moduleName) if (!moduleName.length)
template `moduleLogLevel`(string moduleName) if (moduleName.length)
  This template returns the LogLevel named "logLevel" of type LogLevel defined in a user defined module where the filename has the suffix "loggerconfig.d". This LogLevel sets the minimal LogLevel of the module.
  A minimal LogLevel can be defined on a per module basis. In order to define a module LogLevel a file with a modulename "MODULENAME_loggerconfig" must be found. If no such module exists and the module is a nested module, it is checked if there exists a "PARENT_MODULE_loggerconfig" module with such a symbol. If this module exists and it contains a LogLevel called logLevel this LogLevel will be used. This parent lookup is continued until there is no parent module. Then the `moduleLogLevel` is LogLevel.all.
  Examples:

      static assert(moduleLogLevel!"" == LogLevel.all);

  Examples:

      static assert(moduleLogLevel!"not.amodule.path" == LogLevel.all);

void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy bool `condition`, lazy A `args`)
if (`args`.length != 1);
void `log`(T, string moduleName = __MODULE__)(const LogLevel `ll`, lazy bool `condition`, lazy T `arg`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__);
  This function logs data.
  In order for the data to be processed, the LogLevel of the `log` call must be greater or equal to the LogLevel of the sharedLog and the defaultLogLevel; additionally the `condition` passed must be `true`.
  Parameters:

  LogLevel `ll` | The LogLevel used by this `log` call.
  bool `condition` | The `condition` must be `true` for the data to be logged.
  A `args` | The data that should be logged.

  Example

      log(LogLevel.warning, true, "Hello World", 3.1415);

void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy A `args`)
if (`args`.length > 1 && !is(Unqual!(A[0]) : bool));
void `log`(T, string moduleName = __MODULE__)(const LogLevel `ll`, lazy T `arg`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__);
  This function logs data.
  In order for the data to be processed the LogLevel of the `log` call must be greater or equal to the LogLevel of the sharedLog.
  Parameters:

  LogLevel `ll` | The LogLevel used by this `log` call.
  A `args` | The data that should be logged.

  Example

      log(LogLevel.warning, "Hello World", 3.1415);

void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy A `args`)
if (`args`.length != 1);
void `log`(T, string moduleName = __MODULE__)(lazy bool `condition`, lazy T `arg`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__);
  This function logs data.
  In order for the data to be processed the LogLevel of the sharedLog must be greater or equal to the defaultLogLevel add the `condition` passed must be `true`.
  Parameters:

  bool `condition` | The `condition` must be `true` for the data to be logged.
  A `args` | The data that should be logged.

  Example

      log(true, "Hello World", 3.1415);

void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A `args`)
if (`args`.length > 1 && !is(Unqual!(A[0]) : bool) && !is(Unqual!(A[0]) == LogLevel) || `args`.length == 0);
  This function logs data.
  In order for the data to be processed the LogLevel of the sharedLog must be greater or equal to the defaultLogLevel.
  Parameters:

  A `args` | The data that should be logged.

  Example

      log("Hello World", 3.1415);

void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy bool `condition`, lazy string `msg`, lazy A `args`);
  This function logs data in a printf-style manner.
  In order for the data to be processed the LogLevel of the log call must be greater or equal to the LogLevel of the sharedLog and the defaultLogLevel additionally the `condition` passed must be `true`.
  Parameters:

  LogLevel `ll` | The LogLevel used by this log call.
  bool `condition` | The `condition` must be `true` for the data to be logged.
  string `msg` | The printf-style string.
  A `args` | The data that should be logged.

  Example

      logf(LogLevel.warning, true, "Hello World %f", 3.1415);

void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy string `msg`, lazy A `args`);
  This function logs data in a printf-style manner.
  In order for the data to be processed the LogLevel of the log call must be greater or equal to the LogLevel of the sharedLog and the defaultLogLevel.
  Parameters:

  LogLevel `ll` | The LogLevel used by this log call.
  string `msg` | The printf-style string.
  A `args` | The data that should be logged.

  Example

      logf(LogLevel.warning, "Hello World %f", 3.1415);

void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy string `msg`, lazy A `args`);
  This function logs data in a printf-style manner.
  In order for the data to be processed the LogLevel of the log call must be greater or equal to the defaultLogLevel additionally the `condition` passed must be `true`.
  Parameters:

  bool `condition` | The `condition` must be `true` for the data to be logged.
  string `msg` | The printf-style string.
  A `args` | The data that should be logged.

  Example

      logf(true, "Hello World %f", 3.1415);

void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string `msg`, lazy A `args`);
  This function logs data in a printf-style manner.
  In order for the data to be processed the LogLevel of the log call must be greater or equal to the defaultLogLevel.
  Parameters:

  string `msg` | The printf-style string.
  A `args` | The data that should be logged.

  Example

      logf("Hello World %f", 3.1415);

template `defaultLogFunction`(LogLevel ll)
  This template provides the global log functions with the LogLevel is encoded in the function name.
  The aliases following this template create the public names of these log functions.
alias `trace` = defaultLogFunction!cast(LogLevel)cast(ubyte)32u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
alias `info` = defaultLogFunction!cast(LogLevel)cast(ubyte)64u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
alias `warning` = defaultLogFunction!cast(LogLevel)cast(ubyte)96u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
alias `error` = defaultLogFunction!cast(LogLevel)cast(ubyte)128u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
alias `critical` = defaultLogFunction!cast(LogLevel)cast(ubyte)160u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
alias `fatal` = defaultLogFunction!cast(LogLevel)cast(ubyte)192u.defaultLogFunction(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length > 0 && !is(Unqual!(A[0]) : bool) || args.length == 0);
  This function logs data to the stdThreadLocalLog, optionally depending on a condition.
  In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the stdThreadLocalLog and must be greater or equal than the global LogLevel. Additionally the LogLevel must be greater or equal than the LogLevel of the stdSharedLogger. If a condition is given, it must evaluate to `true`.
  Parameters:

  bool condition | The condition must be `true` for the data to be logged.
  A args | The data that should be logged.

  Example

      trace(1337, "is number");
      info(1337, "is number");
      error(1337, "is number");
      critical(1337, "is number");
      fatal(1337, "is number");
      trace(true, 1337, "is number");
      info(false, 1337, "is number");
      error(true, 1337, "is number");
      critical(false, 1337, "is number");
      fatal(true, 1337, "is number");

template `defaultLogFunctionf`(LogLevel ll)
  This template provides the global printf-style log functions with the LogLevel is encoded in the function name.
  The aliases following this template create the public names of the log functions.
alias `tracef` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)32u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
alias `infof` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)64u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
alias `warningf` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)96u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
alias `errorf` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)128u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
alias `criticalf` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)160u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
alias `fatalf` = defaultLogFunctionf!cast(LogLevel)cast(ubyte)192u.defaultLogFunctionf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string msg, lazy A args);
  This function logs data to the sharedLog in a printf-style manner.
  In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the sharedLog and must be greater or equal than the global LogLevel. Additionally the LogLevel must be greater or equal than the LogLevel of the stdSharedLogger.
  Parameters:

  string msg | The printf-style string.
  A args | The data that should be logged.

  Example

      tracef("is number %d", 1);
      infof("is number %d", 2);
      errorf("is number %d", 3);
      criticalf("is number %d", 4);
      fatalf("is number %d", 5);

  The second version of the function logs data to the sharedLog in a printf-style manner.
  In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the sharedLog and must be greater or equal than the global LogLevel. Additionally the LogLevel must be greater or equal than the LogLevel of the stdSharedLogger.
  Parameters:

  bool condition | The condition must be `true` for the data to be logged.
  string msg | The printf-style string.
  A args | The data that should be logged.

  Example

      tracef(false, "is number %d", 1);
      infof(false, "is number %d", 2);
      errorf(true, "is number %d", 3);
      criticalf(true, "is number %d", 4);
      fatalf(someFunct(), "is number %d", 5);

enum `LogLevel`: ubyte;
  There are eight usable logging level. These level are all, trace, info, warning, error, critical, fatal, and off. If a log function with `LogLevel`.fatal is called the shutdown handler of that logger is called.
  `all`
    Lowest possible assignable LogLevel.
  `trace`
    LogLevel for tracing the execution of the program.
  `info`
    This level is used to display information about the program.
  `warning`
    warnings about the program should be displayed with this level.
  `error`
    Information about errors should be logged with this level.
  `critical`
    Messages that inform about `critical` errors should be logged with this level.
  `fatal`
    Log messages that describe `fatal` errors should use this level.
  `off`
    Highest possible LogLevel.
abstract class `Logger`;
  This class is the base of every logger. In order to create a new kind of logger a deriving class needs to implement the writeLogMsg method. By default this is not thread-safe.
  It is also possible to override the three methods beginLogMsg, logMsgPart and finishLogMsg together, this option gives more flexibility.
  struct `LogEntry`;
    `LogEntry` is a aggregation combining all information associated with a log message. This aggregation will be passed to the method writeLogMsg.
    string `file`;
      the filename the log function was called from
    int `line`;
      the `line` number the log function was called from
    string `funcName`;
      the name of the function the log function was called from
    string `prettyFuncName`;
      the pretty formatted name of the function the log function was called from
    string `moduleName`;
      the name of the module the log message is coming from
    LogLevel `logLevel`;
      the LogLevel associated with the log message
    Tid `threadId`;
      thread id of the log message
    SysTime `timestamp`;
      the time the message was logged
    string `msg`;
      the message of the log message
    Logger `logger`;
      A refernce to the Logger used to create this LogEntry
  @safe this(LogLevel `lv`);
    Every subclass of Logger has to call this constructor from their constructor. It sets the LogLevel, and creates a fatal handler. The fatal handler will throw an Error if a log call is made with level LogLevel.fatal.
    Parameters:

    LogLevel `lv` | LogLevel to use for this Logger instance.

  protected abstract @safe void `writeLogMsg`(ref LogEntry `payload`);
    A custom logger must implement this method in order to work in a MultiLogger and ArrayLogger.
    Parameters:

    LogEntry `payload` | All information associated with call to log function.

    See Also:
    beginLogMsg, logMsgPart, finishLogMsg
  protected @safe void `logMsgPart`(const(char)[] `msg`);
    Logs a part of the log message.
  protected @safe void `finishLogMsg`();
    Signals that the message has been written and no more calls to logMsgPart follow.
  final const pure @nogc @property @safe LogLevel `logLevel`();
  final @nogc @property @safe void `logLevel`(const LogLevel `lv`);
    The LogLevel determines if the log call are processed or dropped by the Logger. In order for the log call to be processed the LogLevel of the log call must be greater or equal to the LogLevel of the logger.
    These two methods set and get the LogLevel of the used Logger.

    Example

        auto f = new FileLogger(stdout);
        f.logLevel = LogLevel.info;
        assert(f.logLevel == LogLevel.info);

  final @nogc @property @safe void delegate() `fatalHandler`();
  final @nogc @property @safe void `fatalHandler`(void delegate() @safe `fh`);
    This delegate is called in case a log message with LogLevel.fatal gets logged.
    By default an Error will be thrown.
  @trusted void `forwardMsg`(ref LogEntry `payload`);
    This method allows forwarding log entries from one logger to another.
    `forwardMsg` will ensure proper synchronization and then call writeLogMsg. This is an API for implementing your own loggers and should not be called by normal user code. A notable difference from other logging functions is that the globalLogLevel wont be evaluated again since it is assumed that the caller already checked that.
  template `memLogFunctions`(LogLevel ll)
  alias `trace` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)32u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `tracef` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)32u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
  alias `info` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)64u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `infof` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)64u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
  alias `warning` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)96u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `warningf` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)96u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
  alias `error` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)128u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `errorf` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)128u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
  alias `critical` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)160u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `criticalf` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)160u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
  alias `fatal` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)192u.logImpl(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A args) if (args.length == 0 || args.length > 0 && !is(A[0] : bool));
  alias `fatalf` = .Logger.memLogFunctions!cast(LogLevel)cast(ubyte)192u.logImplf(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool condition, lazy string msg, lazy A args);
    This template provides the log functions for the Logger class with the LogLevel encoded in the function name.
    For further information see the the two functions defined inside of this template.
    The aliases following this template create the public names of these log functions.
    void `logImpl`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A `args`)
    if (`args`.length == 0 || `args`.length > 0 && !is(A[0] : bool));
      This function logs data to the used Logger.
      In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel.
      Parameters:

      A `args` | The data that should be logged.

      Example

          auto s = new FileLogger(stdout);
          s.trace(1337, "is number");
          s.info(1337, "is number");
          s.error(1337, "is number");
          s.critical(1337, "is number");
          s.fatal(1337, "is number");

    void `logImpl`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy A `args`);
      This function logs data to the used Logger depending on a `condition`.
      In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel additionally the `condition` passed must be `true`.
      Parameters:

      bool `condition` | The `condition` must be `true` for the data to be logged.
      A `args` | The data that should be logged.

      Example

          auto s = new FileLogger(stdout);
          s.trace(true, 1337, "is number");
          s.info(false, 1337, "is number");
          s.error(true, 1337, "is number");
          s.critical(false, 1337, "is number");
          s.fatal(true, 1337, "is number");

    void `logImplf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy string `msg`, lazy A `args`);
      This function logs data to the used Logger in a printf-style manner.
      In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel additionally the passed `condition` must be `true`.
      Parameters:

      bool `condition` | The `condition` must be `true` for the data to be logged.
      string `msg` | The printf-style string.
      A `args` | The data that should be logged.

      Example

          auto s = new FileLogger(stderr);
          s.tracef(true, "is number %d", 1);
          s.infof(true, "is number %d", 2);
          s.errorf(false, "is number %d", 3);
          s.criticalf(someFunc(), "is number %d", 4);
          s.fatalf(true, "is number %d", 5);

    void `logImplf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string `msg`, lazy A `args`);
      This function logs data to the used Logger in a printf-style manner.
      In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel.
      Parameters:

      string `msg` | The printf-style string.
      A `args` | The data that should be logged.

      Example

          auto s = new FileLogger(stderr);
          s.tracef("is number %d", 1);
          s.infof("is number %d", 2);
          s.errorf("is number %d", 3);
          s.criticalf("is number %d", 4);
          s.fatalf("is number %d", 5);

  void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy bool `condition`, lazy A `args`)
  if (`args`.length != 1);
  void `log`(T, string moduleName = __MODULE__)(const LogLevel `ll`, lazy bool `condition`, lazy T `args`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__);
    This method logs data with the LogLevel of the used Logger.
    This method takes a bool as first argument. In order for the data to be processed the bool must be `true` and the LogLevel of the Logger must be greater or equal to the global LogLevel.
    Parameters:

    A `args` | The data that should be logged.
    bool `condition` | The `condition` must be `true` for the data to be logged.
    A `args` | The data that is to be logged.

    Returns:
    The logger used by the logging function as reference.

    Example

        auto l = new StdioLogger();
        l.log(1337);

  void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy A `args`)
  if (`args`.length > 1 && !is(Unqual!(A[0]) : bool) || `args`.length == 0);
  void `log`(T)(const LogLevel `ll`, lazy T `args`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__, string `moduleName` = __MODULE__);
    This function logs data to the used Logger with a specific LogLevel.
    In order for the resulting `log` message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel.
    Parameters:

    LogLevel `ll` | The specific LogLevel used for logging the `log` message.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.log(LogLevel.trace, 1337, "is number");
        s.log(LogLevel.info, 1337, "is number");
        s.log(LogLevel.warning, 1337, "is number");
        s.log(LogLevel.error, 1337, "is number");
        s.log(LogLevel.fatal, 1337, "is number");

  void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy A `args`)
  if (`args`.length != 1);
  void `log`(T)(lazy bool `condition`, lazy T `args`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__, string `moduleName` = __MODULE__);
    This function logs data to the used Logger depending on a explicitly passed `condition` with the LogLevel of the used Logger.
    In order for the resulting `log` message to be logged the LogLevel of the used Logger must be greater or equal than the global LogLevel and the `condition` must be `true`.
    Parameters:

    bool `condition` | The `condition` must be `true` for the data to be logged.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.log(true, 1337, "is number");
        s.log(true, 1337, "is number");
        s.log(true, 1337, "is number");
        s.log(false, 1337, "is number");
        s.log(false, 1337, "is number");

  void `log`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy A `args`)
  if (`args`.length > 1 && !is(Unqual!(A[0]) : bool) && !is(Unqual!(A[0]) == LogLevel) || `args`.length == 0);
  void `log`(T)(lazy T `arg`, int `line` = __LINE__, string `file` = __FILE__, string `funcName` = __FUNCTION__, string `prettyFuncName` = __PRETTY_FUNCTION__, string `moduleName` = __MODULE__);
    This function logs data to the used Logger with the LogLevel of the used Logger.
    In order for the resulting `log` message to be logged the LogLevel of the used Logger must be greater or equal than the global LogLevel.
    Parameters:

    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.log(1337, "is number");
        s.log(info, 1337, "is number");
        s.log(1337, "is number");
        s.log(1337, "is number");
        s.log(1337, "is number");

  void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy bool `condition`, lazy string `msg`, lazy A `args`);
    This function logs data to the used Logger with a specific LogLevel and depending on a `condition` in a printf-style manner.
    In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel and the `condition` must be `true`.
    Parameters:

    LogLevel `ll` | The specific LogLevel used for logging the log message.
    bool `condition` | The `condition` must be `true` for the data to be logged.
    string `msg` | The format string used for this log call.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.logf(LogLevel.trace, true ,"%d %s", 1337, "is number");
        s.logf(LogLevel.info, true ,"%d %s", 1337, "is number");
        s.logf(LogLevel.warning, true ,"%d %s", 1337, "is number");
        s.logf(LogLevel.error, false ,"%d %s", 1337, "is number");
        s.logf(LogLevel.fatal, true ,"%d %s", 1337, "is number");

  void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(const LogLevel `ll`, lazy string `msg`, lazy A `args`);
    This function logs data to the used Logger with a specific LogLevel in a printf-style manner.
    In order for the resulting log message to be logged the LogLevel must be greater or equal than the LogLevel of the used Logger and must be greater or equal than the global LogLevel.
    Parameters:

    LogLevel `ll` | The specific LogLevel used for logging the log message.
    string `msg` | The format string used for this log call.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.logf(LogLevel.trace, "%d %s", 1337, "is number");
        s.logf(LogLevel.info, "%d %s", 1337, "is number");
        s.logf(LogLevel.warning, "%d %s", 1337, "is number");
        s.logf(LogLevel.error, "%d %s", 1337, "is number");
        s.logf(LogLevel.fatal, "%d %s", 1337, "is number");

  void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy bool `condition`, lazy string `msg`, lazy A `args`);
    This function logs data to the used Logger depending on a `condition` with the LogLevel of the used Logger in a printf-style manner.
    In order for the resulting log message to be logged the LogLevel of the used Logger must be greater or equal than the global LogLevel and the `condition` must be `true`.
    Parameters:

    bool `condition` | The `condition` must be `true` for the data to be logged.
    string `msg` | The format string used for this log call.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.logf(true ,"%d %s", 1337, "is number");
        s.logf(true ,"%d %s", 1337, "is number");
        s.logf(true ,"%d %s", 1337, "is number");
        s.logf(false ,"%d %s", 1337, "is number");
        s.logf(true ,"%d %s", 1337, "is number");

  void `logf`(int line = __LINE__, string file = __FILE__, string funcName = __FUNCTION__, string prettyFuncName = __PRETTY_FUNCTION__, string moduleName = __MODULE__, A...)(lazy string `msg`, lazy A `args`);
    This method logs data to the used Logger with the LogLevel of the this Logger in a printf-style manner.
    In order for the data to be processed the LogLevel of the Logger must be greater or equal to the global LogLevel.
    Parameters:

    string `msg` | The format string used for this log call.
    A `args` | The data that should be logged.

    Example

        auto s = new FileLogger(stdout);
        s.logf("%d %s", 1337, "is number");
        s.logf("%d %s", 1337, "is number");
        s.logf("%d %s", 1337, "is number");
        s.logf("%d %s", 1337, "is number");
        s.logf("%d %s", 1337, "is number");

@property @safe Logger `sharedLog`();
@property @trusted void `sharedLog`(Logger `logger`);
  This property sets and gets the default Logger.

  Example

      sharedLog = new FileLogger(yourFile);

  The example sets a new FileLogger as new `sharedLog`.
  If at some point you want to use the original default `logger` again, you can use `sharedLog` = `null`;. This will put back the original.

  Note While getting and setting `sharedLog` is thread-safe, it has to be considered that the returned reference is only a current snapshot and in the following code, you must make sure no other thread reassigns to it between reading and writing `sharedLog`.

  `sharedLog` is only thread-safe if the the used Logger is thread-safe. The default Logger is thread-safe.

      if (sharedLog !is myLogger)
          sharedLog = new myLogger;

@nogc @property @safe LogLevel `globalLogLevel`();
@property @safe void `globalLogLevel`(LogLevel `ll`);
  This methods get and set the global LogLevel.
  Every log message with a LogLevel lower as the global LogLevel will be discarded before it reaches writeLogMessage method of any Logger.
class `StdForwardLogger`: std.experimental.logger.core.Logger;
  The `StdForwardLogger` will always forward anything to the sharedLog.
  The `StdForwardLogger` will not throw if data is logged with LogLevel.fatal.
  Examples:

      auto nl1 = new StdForwardLogger(LogLevel.all);

  @safe this(const LogLevel `lv` = LogLevel.all);
    The default constructor for the StdForwardLogger.
    Parameters:

    LogLevel `lv` | The LogLevel for the MultiLogger. By default the LogLevel is all.

@property @safe Logger `stdThreadLocalLog`();
@property @safe void `stdThreadLocalLog`(Logger `logger`);
  This function returns a thread unique Logger, that by default propergates all data logged to it to the sharedLog.
  These properties can be used to set and get this Logger. Every modification to this Logger will only be visible in the thread the modification has been done from.
  This Logger is called by the free standing log functions. This allows to create thread local redirections and still use the free standing log functions.
  Examples:
  Ditto

      import std.experimental.logger.filelogger : FileLogger;
      import std.file : deleteme, remove;
      Logger l = stdThreadLocalLog;
      stdThreadLocalLog = new FileLogger(deleteme ~ "-someFile.log");
      scope(exit) remove(deleteme ~ "-someFile.log");

      auto tempLog = stdThreadLocalLog;
      stdThreadLocalLog = l;
      destroy(tempLog);

Copyright © 1999-2018 by the D Language Foundation | Page generated by Ddoc on Sat Apr 14 16:39:39 2018