meta-logger

    1.0.4 • Public • Published

    meta-logger

    Lightweight logging library for NodeJS with support of facilities and multiple transports.

    Usage

    var logger = require("meta-logger");
     
    //Setup targets
    logger.toConsole({
        level: "debug",
        timestamp: true,
        colorize: true
    }).toFile("demo.log", {
        level: "info",
        timestamp: true,
        facilities: [ "test" ]
    }).toJsonFile("demo.json", {
        level: "warn"
    });
     
    //Logging without specifying facility
    logger.log("info", "Hello %s", "world");
    logger.debug("Hello %s", "debug");
    logger.info("Hello %s", "info");
    logger.warn("Hello %s", "warn");
    logger.error("Hello %s", "error");
     
    //Create facility shorthand
    var facilityLogger = logger.facility("test");
     
    //Log with facility prefix
    facilityLogger.log("info", "Hello %s", "world");
    facilityLogger.debug("Hello %s", "debug");
    facilityLogger.info("Hello %s", "info");
    facilityLogger.warn("Hello %s", "warn");
    facilityLogger.error("Hello %s", "error");

    Note: console target is set by default.

    Configuring logging targets

    Console

    Prints log messages to stdout (console).

    logger.toConsole({
        level: "debug",
        facilities: [...], //or null to accept all facilities
        timestamp: true,
        colorize: true,
        colors: {
            debug:  logger.colors.cyan,
            info:  logger.colors.white,
            warn:  logger.colors.yellow,
            error:  logger.colors.red
        }
    });

    Method toConsole overrides previous console target settings. You can use more console targets (for multiple configurations):

    logger.to(new Logger.ConsoleTarget({
        ///... options ...
    }));
    

    File

    Append log messages to specified file.

    Message is formatted same way as to console.

    File target can be set for multiple files with different configurations.

    logger.toFile(filename, {
        level: "debug",
        facilities: [...], //or null to accept all facilities
        timestamp: true
    }).toFile(anotherFilename, {
        level: "error",
        timestamp: true,
        //...
    });

    JSON file

    Append log messages to specified file in JSON format.

    logger.toJsonFile(filename, {
        level: "debug",
        facilities: [...], //or null to accept all facilities
        timestamp: true
    });

    Log file has following format:

    {},
    {"timestamp":"2015-06-04T21:20:54.627Z","level":"warn","facility":null,"msg":["Hello %s","warn"]},
    {"timestamp":"2015-06-04T21:20:54.629Z","level":"error","facility":"test","msg":["Hello %s","error"]}
    ...
    

    Custom logging target

    Custom target is defined by instance of simple object which implements log method and registered to logger via to method.

    Following example shows how to define custom target:

    var util = require("util");
     
    var MyTarget = function(options){
     
        options = options || {};
        this.prefix = options.prefix || "";
     
    };
     
    MyTarget.prototype.log = function(level, facility, args){
     
        console.log(level, facility, this.prefix, util.format.apply(this, args));
     
    };
     
    logger.to(new MyTarget({
        prefix: "my-target"
    }));

    Following example shows how to inherit BaseTarget:

    var MyTarget = function(options){
     
        options = options || {};
        this.prefix = options.prefix || "";
     
        logger.BaseTarget.call(this, options);
     
    };
     
    util.inherits(MyTarget, logger.BaseTarget);
     
    MyLogger.prototype.write = function(level, facility, msg){
     
        console.log(level, facility, this.prefix, msg.join(" "));
     
    };

    Custom logging levels

    Logging levels can be set by modifying logger.levels property.

    logger.levels = {
        custom: 4,
        debug:  3,
        info:  2,
        warn:  1,
        error:  0
    };

    Logger object reference

    logger = {
     
        //Colors library for console coloring
        colors: require("colors"),
     
        //Logging levels
        levels: {
            debug:  3,
            info:  2,
            warn:  1,
            error:  0
        },
     
        //Object contains registered targets
        targets: {},
     
        //Logging functions
        log: function(level, args...),
        debug: function(args...),
        info: function(args...),
        warn: function(args...),
        error: function(args...),
     
        //Facility shorthand
        facility: function(name){
     
            return {
     
                log: function(level, args...),
                debug: function(args...),
                info: function(args...),
                warn: function(args...),
                error: function(args...)
     
            };
     
        },
     
        //Target shorthands
        to: function(name, targetObject),
        toConsole: function(options),
        toFile: function(filename, options),
        toJsonFile: function(filename, options),
     
        //Target constructors
        BaseTarget: function(options),
        ConsoleTarget: function(options),
        FileTarget: function(filename, options),
        JsonFileTarget: function(filename, options)
     
    };

    License

    This library is published under MIT license.

    Copyright (c) 2015 Jiri Hybek, jiri.hybek@cryonix.cz

    Install

    npm i meta-logger

    DownloadsWeekly Downloads

    0

    Version

    1.0.4

    License

    MIT

    Unpacked Size

    20.7 kB

    Total Files

    14

    Last publish

    Collaborators

    • metaplatform