Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - 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.logger.core

Source std/logger/core.d

@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
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!LogLevel.`trace`.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!LogLevel.`info`.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!LogLevel.`warning`.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!LogLevel.`error`.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!LogLevel.`critical`.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!LogLevel.`fatal`.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!LogLevel.trace.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!LogLevel.info.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!LogLevel.warning.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!LogLevel.error.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!LogLevel.critical.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!LogLevel.fatal.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
  this(this 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`(scope 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!LogLevel.`trace`.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!LogLevel.trace.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!LogLevel.`info`.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!LogLevel.info.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!LogLevel.`warning`.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!LogLevel.warning.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!LogLevel.`error`.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!LogLevel.error.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!LogLevel.`critical`.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!LogLevel.critical.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!LogLevel.`fatal`.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!LogLevel.fatal.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 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(immutable(A[0]) == immutable(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 shared(Logger) `sharedLog`();
@property @safe void `sharedLog`(shared(Logger) `logger`);
  This property sets and gets the default Logger. Unless set to another logger by the user, the default logger's log level is LogLevel.info.

  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 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.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 propagates 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.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-2023 by the D Language Foundation | Page generated by Ddoc on Sun Jan 1 02:21:02 2023