loglevel

  • Version 1.7.1
  • Published
  • 136 kB
  • No dependencies
  • MIT license

Install

npm i loglevel
yarn add loglevel
pnpm add loglevel

Overview

Minimal lightweight logging for JavaScript, adding reliable log level methods to any available console.log methods

Index

Variables

variable log

const log: log.RootLogger;

    Interfaces

    interface Logger

    interface Logger {}

      property levels

      readonly levels: LogLevel;
      • Available log levels.

      property methodFactory

      methodFactory: MethodFactory;
      • Plugin API entry point. This will be called for each enabled method each time the level is set (including initially), and should return a MethodFactory to be used for the given log method, at the given level, for a logger with the given name. If you'd like to retain all the reliability and features of loglevel, it's recommended that this wraps the initially provided value of log.methodFactory

      method debug

      debug: (...msg: any[]) => void;
      • Output debug message to console including appropriate icons

        Parameter msg

        any data to log to the console

      method disableAll

      disableAll: (persist?: boolean) => void;
      • This disables all log messages, and is equivalent to log.setLevel("silent").

        Parameter persist

        Where possible the log level will be persisted. LocalStorage will be used if available, falling back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass false as the optional 'persist' second argument, persistence will be skipped.

      method enableAll

      enableAll: (persist?: boolean) => void;
      • This enables all log messages, and is equivalent to log.setLevel("trace").

        Parameter persist

        Where possible the log level will be persisted. LocalStorage will be used if available, falling back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass false as the optional 'persist' second argument, persistence will be skipped.

      method error

      error: (...msg: any[]) => void;
      • Output error message to console including appropriate icons

        Parameter msg

        any data to log to the console

      method getLevel

      getLevel: () => LogLevel[keyof LogLevel];
      • Returns the current logging level, as a value from LogLevel. It's very unlikely you'll need to use this for normal application logging; it's provided partly to help plugin development, and partly to let you optimize logging code as below, where debug data is only generated if the level is set such that it'll actually be logged. This probably doesn't affect you, unless you've run profiling on your code and you have hard numbers telling you that your log data generation is a real performance problem.

      method info

      info: (...msg: any[]) => void;
      • Output info message to console including appropriate icons

        Parameter msg

        any data to log to the console

      method log

      log: (...msg: any[]) => void;
      • Output debug message to console including appropriate icons

        Parameter msg

        any data to log to the console

      method setDefaultLevel

      setDefaultLevel: (level: LogLevelDesc) => void;
      • This sets the current log level only if one has not been persisted and can’t be loaded. This is useful when initializing scripts; if a developer or user has previously called setLevel(), this won’t alter their settings. For example, your application might set the log level to error in a production environment, but when debugging an issue, you might call setLevel("trace") on the console to see all the logs. If that error setting was set using setDefaultLevel(), it will still say as trace on subsequent page loads and refreshes instead of resetting to error.

        The level argument takes is the same values that you might pass to setLevel(). Levels set using setDefaultLevel() never persist to subsequent page loads.

        Parameter level

        as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)

      method setLevel

      setLevel: (level: LogLevelDesc, persist?: boolean) => void;
      • This disables all logging below the given level, so that after a log.setLevel("warn") call log.warn("something") or log.error("something") will output messages, but log.info("something") will not.

        Parameter level

        as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)

        Parameter persist

        Where possible the log level will be persisted. LocalStorage will be used if available, falling back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass false as the optional 'persist' second argument, persistence will be skipped.

      method trace

      trace: (...msg: any[]) => void;
      • Output trace message to console. This will also include a full stack trace

        Parameter msg

        any data to log to the console

      method warn

      warn: (...msg: any[]) => void;
      • Output warn message to console including appropriate icons

        Parameter msg

        any data to log to the console

      interface LogLevel

      interface LogLevel {}
      • Log levels

      property DEBUG

      DEBUG: 1;

        property ERROR

        ERROR: 4;

          property INFO

          INFO: 2;

            property SILENT

            SILENT: 5;

              property TRACE

              TRACE: 0;

                property WARN

                WARN: 3;

                  interface RootLogger

                  interface RootLogger extends Logger {}

                    property default

                    default: RootLogger;
                    • A .default property for ES6 default import compatibility

                    method getLogger

                    getLogger: (name: string | symbol) => Logger;
                    • This gets you a new logger object that works exactly like the root log object, but can have its level and logging methods set independently. All loggers must have a name (which is a non-empty string or a symbol) Calling * getLogger() multiple times with the same name will return an identical logger object. In large applications, it can be incredibly useful to turn logging on and off for particular modules as you are working with them. Using the getLogger() method lets you create a separate logger for each part of your application with its own logging level. Likewise, for small, independent modules, using a named logger instead of the default root logger allows developers using your module to selectively turn on deep, trace-level logging when trying to debug problems, while logging only errors or silencing logging altogether under normal circumstances.

                      Parameter name

                      The name of the produced logger

                    method getLoggers

                    getLoggers: () => { [name: string]: Logger };
                    • This will return you the dictionary of all loggers created with getLogger, keyed off of their names.

                    method noConflict

                    noConflict: () => any;
                    • If you're using another JavaScript library that exposes a 'log' global, you can run into conflicts with loglevel. Similarly to jQuery, you can solve this by putting loglevel into no-conflict mode immediately after it is loaded onto the page. This resets to 'log' global to its value before loglevel was loaded (typically undefined), and returns the loglevel object, which you can then bind to another name yourself.

                    Type Aliases

                    type LoggingMethod

                    type LoggingMethod = (...message: any[]) => void;

                      type LogLevelDesc

                      type LogLevelDesc =
                      | LogLevelNumbers
                      | 'trace'
                      | 'debug'
                      | 'info'
                      | 'warn'
                      | 'error'
                      | 'silent'
                      | keyof LogLevel;
                      • Possible log level descriptors, may be string, lower or upper case, or number.

                      type LogLevelNumbers

                      type LogLevelNumbers = LogLevel[keyof LogLevel];
                      • Possible log level numbers.

                      type MethodFactory

                      type MethodFactory = (
                      methodName: string,
                      level: LogLevelNumbers,
                      loggerName: string | symbol
                      ) => LoggingMethod;

                        Package Files (1)

                        Dependencies (0)

                        No dependencies.

                        Dev Dependencies (21)

                        Peer Dependencies (0)

                        No peer dependencies.

                        Badge

                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/loglevel.

                        • Markdown
                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/loglevel)
                        • HTML
                          <a href="https://www.jsdocs.io/package/loglevel"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>