loglevel - npm Package Compare versions

Comparing version 1.3.1 to 1.4.0

bower.json

 {
   "name": "loglevel",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "main": "dist/loglevel.min.js",
@@ -5,0 +5,0 @@ "dependencies": {},

CONTRIBUTING.md

@@ -58,4 +58,4 @@ Filing tickets against loglevel
 5. Make your code changes in /lib/loglevel.js
-6. Check your code all passes (run `grunt`) - if you have any issues try running `grunt jasmine:src:build` and debugging the generated _SpecRunner.html in a browser
+6. Check your code all passes (run `grunt`) - if you have any issues try running `grunt jasmine:requirejs:src:build` (or a different test build instead of 'requirejs': see the jasmine config in Gruntfile.js) and debugging the generated _SpecRunner.html in a browser
 7. Commit your changes
 8. Open a pull request back to master in loglevel

dist/loglevel.js

@@ -1,3 +0,4 @@
-/*! loglevel - v1.3.1 - https://github.com/pimterry/loglevel - (c) 2015 Tim Perry - licensed MIT */
+/*! loglevel - v1.4.0 - https://github.com/pimterry/loglevel - (c) 2015 Tim Perry - licensed MIT */
 (function (root, definition) {
+    "use strict";
     if (typeof module === 'object' && module.exports && typeof require === 'function') {
@@ -11,3 +12,3 @@ module.exports = definition();
 }(this, function () {
-    var self = {};
+    "use strict";
     var noop = function() {};
@@ -44,7 +45,9 @@ var undefinedType = "undefined";
 
-    function enableLoggingWhenConsoleArrives(methodName, level) {
+    // these private functions always need `this` to be set properly
+
+    function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
         return function () {
             if (typeof console !== undefinedType) {
-                replaceLoggingMethods(level);
-                self[methodName].apply(self, arguments);
+                replaceLoggingMethods.call(this, level, loggerName);
+                this[methodName].apply(this, arguments);
             }
@@ -54,2 +57,18 @@ };
 
+    function replaceLoggingMethods(level, loggerName) {
+        /*jshint validthis:true */
+        for (var i = 0; i < logMethods.length; i++) {
+            var methodName = logMethods[i];
+            this[methodName] = (i < level) ?
+                noop :
+                this.methodFactory(methodName, level, loggerName);
+        }
+    }
+
+    function defaultMethodFactory(methodName, level, loggerName) {
+        /*jshint validthis:true */
+        return realMethod(methodName) ||
+               enableLoggingWhenConsoleArrives.apply(this, arguments);
+    }
+
     var logMethods = [
@@ -63,42 +82,105 @@ "trace",
 
-    function replaceLoggingMethods(level) {
-        for (var i = 0; i < logMethods.length; i++) {
-            var methodName = logMethods[i];
-            self[methodName] = (i < level) ? noop : self.methodFactory(methodName, level);
-        }
-    }
+    function Logger(name, defaultLevel, factory) {
+      var self = this;
+      var currentLevel;
+      var storageKey = "loglevel";
+      if (name) {
+        storageKey += ":" + name;
+      }
 
-    function persistLevelIfPossible(levelNum) {
-        var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+      function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
 
-        // Use localStorage if available
-        try {
-            window.localStorage['loglevel'] = levelName;
-            return;
-        } catch (ignore) {}
+          // Use localStorage if available
+          try {
+              window.localStorage[storageKey] = levelName;
+              return;
+          } catch (ignore) {}
 
-        // Use session cookie as fallback
-        try {
-            window.document.cookie = "loglevel=" + levelName + ";";
-        } catch (ignore) {}
-    }
+          // Use session cookie as fallback
+          try {
+              window.document.cookie =
+                encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {}
+      }
 
-    function loadPersistedLevel() {
-        var storedLevel;
+      function getPersistedLevel() {
+          var storedLevel;
 
-        try {
-            storedLevel = window.localStorage['loglevel'];
-        } catch (ignore) {}
+          try {
+              storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {}
 
-        if (typeof storedLevel === undefinedType) {
-            try {
-                storedLevel = /loglevel=([^;]+)/.exec(window.document.cookie)[1];
-            } catch (ignore) {}
-        }
-        
-        if (self.levels[storedLevel] === undefined) {
-            storedLevel = "WARN";
-        }
+          if (typeof storedLevel === undefinedType) {
+              try {
+                  var cookie = window.document.cookie;
+                  var location = cookie.indexOf(
+                      encodeURIComponent(storageKey) + "=");
+                  if (location) {
+                      storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+                  }
+              } catch (ignore) {}
+          }
 
-        self.setLevel(self.levels[storedLevel], false);
+          // If the stored level is not valid, treat it as if nothing was stored.
+          if (self.levels[storedLevel] === undefined) {
+              storedLevel = undefined;
+          }
+
+          return storedLevel;
+      }
+
+      /*
+       *
+       * Public API
+       *
+       */
+
+      self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
+          "ERROR": 4, "SILENT": 5};
+
+      self.methodFactory = factory || defaultMethodFactory;
+
+      self.getLevel = function () {
+          return currentLevel;
+      };
+
+      self.setLevel = function (level, persist) {
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+              level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+              currentLevel = level;
+              if (persist !== false) {  // defaults to true
+                  persistLevelIfPossible(level);
+              }
+              replaceLoggingMethods.call(self, level, name);
+              if (typeof console === undefinedType && level < self.levels.SILENT) {
+                  return "No console available for logging";
+              }
+          } else {
+              throw "log.setLevel() called with invalid level: " + level;
+          }
+      };
+
+      self.setDefaultLevel = function (level) {
+          if (!getPersistedLevel()) {
+              self.setLevel(level, false);
+          }
+      };
+
+      self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+      };
+
+      self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+      };
+
+      // Initialize with the right level
+      var initialLevel = getPersistedLevel();
+      if (initialLevel == null) {
+          initialLevel = defaultLevel == null ? "WARN" : defaultLevel;
+      }
+      self.setLevel(initialLevel, false);
     }
@@ -108,52 +190,34 @@
      *
-     * Public API
+     * Package-level API
      *
      */
 
-    self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
-        "ERROR": 4, "SILENT": 5};
+    var defaultLogger = new Logger();
 
-    self.methodFactory = function (methodName, level) {
-        return realMethod(methodName) ||
-               enableLoggingWhenConsoleArrives(methodName, level);
-    };
+    var _loggersByName = {};
+    defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
 
-    self.setLevel = function (level, persist) {
-        if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
-            level = self.levels[level.toUpperCase()];
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(
+            name, defaultLogger.getLevel(), defaultLogger.methodFactory);
         }
-        if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
-            if (persist !== false) {  // defaults to true
-                persistLevelIfPossible(level);
-            }
-            replaceLoggingMethods(level);
-            if (typeof console === undefinedType && level < self.levels.SILENT) {
-                return "No console available for logging";
-            }
-        } else {
-            throw "log.setLevel() called with invalid level: " + level;
-        }
+        return logger;
     };
 
-    self.enableAll = function(persist) {
-        self.setLevel(self.levels.TRACE, persist);
-    };
-
-    self.disableAll = function(persist) {
-        self.setLevel(self.levels.SILENT, persist);
-    };
-
     // Grab the current global log variable in case of overwrite
     var _log = (typeof window !== undefinedType) ? window.log : undefined;
-    self.noConflict = function() {
+    defaultLogger.noConflict = function() {
         if (typeof window !== undefinedType &&
-               window.log === self) {
+               window.log === defaultLogger) {
             window.log = _log;
         }
 
-        return self;
+        return defaultLogger;
     };
 
-    loadPersistedLevel();
-    return self;
+    return defaultLogger;
 }));

dist/loglevel.min.js

@@ -1,2 +0,2 @@
-/*! loglevel - v1.3.1 - https://github.com/pimterry/loglevel - (c) 2015 Tim Perry - licensed MIT */
-!function(a,b){"object"==typeof module&&module.exports&&"function"==typeof require?module.exports=b():"function"==typeof define&&"object"==typeof define.amd?define(b):a.log=b()}(this,function(){function a(a){return typeof console===i?!1:void 0!==console[a]?b(console,a):void 0!==console.log?b(console,"log"):h}function b(a,b){var c=a[b];if("function"==typeof c.bind)return c.bind(a);try{return Function.prototype.bind.call(c,a)}catch(d){return function(){return Function.prototype.apply.apply(c,[a,arguments])}}}function c(a,b){return function(){typeof console!==i&&(d(b),g[a].apply(g,arguments))}}function d(a){for(var b=0;b<j.length;b++){var c=j[b];g[c]=a>b?h:g.methodFactory(c,a)}}function e(a){var b=(j[a]||"silent").toUpperCase();try{return void(window.localStorage.loglevel=b)}catch(c){}try{window.document.cookie="loglevel="+b+";"}catch(c){}}function f(){var a;try{a=window.localStorage.loglevel}catch(b){}if(typeof a===i)try{a=/loglevel=([^;]+)/.exec(window.document.cookie)[1]}catch(b){}void 0===g.levels[a]&&(a="WARN"),g.setLevel(g.levels[a],!1)}var g={},h=function(){},i="undefined",j=["trace","debug","info","warn","error"];g.levels={TRACE:0,DEBUG:1,INFO:2,WARN:3,ERROR:4,SILENT:5},g.methodFactory=function(b,d){return a(b)||c(b,d)},g.setLevel=function(a,b){if("string"==typeof a&&void 0!==g.levels[a.toUpperCase()]&&(a=g.levels[a.toUpperCase()]),!("number"==typeof a&&a>=0&&a<=g.levels.SILENT))throw"log.setLevel() called with invalid level: "+a;return b!==!1&&e(a),d(a),typeof console===i&&a<g.levels.SILENT?"No console available for logging":void 0},g.enableAll=function(a){g.setLevel(g.levels.TRACE,a)},g.disableAll=function(a){g.setLevel(g.levels.SILENT,a)};var k=typeof window!==i?window.log:void 0;return g.noConflict=function(){return typeof window!==i&&window.log===g&&(window.log=k),g},f(),g});
+/*! loglevel - v1.4.0 - https://github.com/pimterry/loglevel - (c) 2015 Tim Perry - licensed MIT */
+!function(a,b){"use strict";"object"==typeof module&&module.exports&&"function"==typeof require?module.exports=b():"function"==typeof define&&"object"==typeof define.amd?define(b):a.log=b()}(this,function(){"use strict";function a(a){return typeof console===h?!1:void 0!==console[a]?b(console,a):void 0!==console.log?b(console,"log"):g}function b(a,b){var c=a[b];if("function"==typeof c.bind)return c.bind(a);try{return Function.prototype.bind.call(c,a)}catch(d){return function(){return Function.prototype.apply.apply(c,[a,arguments])}}}function c(a,b,c){return function(){typeof console!==h&&(d.call(this,b,c),this[a].apply(this,arguments))}}function d(a,b){for(var c=0;c<i.length;c++){var d=i[c];this[d]=a>c?g:this.methodFactory(d,a,b)}}function e(b,d,e){return a(b)||c.apply(this,arguments)}function f(a,b,c){function f(a){var b=(i[a]||"silent").toUpperCase();try{return void(window.localStorage[l]=b)}catch(c){}try{window.document.cookie=encodeURIComponent(l)+"="+b+";"}catch(c){}}function g(){var a;try{a=window.localStorage[l]}catch(b){}if(typeof a===h)try{var c=window.document.cookie,d=c.indexOf(encodeURIComponent(l)+"=");d&&(a=/^([^;]+)/.exec(c.slice(d))[1])}catch(b){}return void 0===k.levels[a]&&(a=void 0),a}var j,k=this,l="loglevel";a&&(l+=":"+a),k.levels={TRACE:0,DEBUG:1,INFO:2,WARN:3,ERROR:4,SILENT:5},k.methodFactory=c||e,k.getLevel=function(){return j},k.setLevel=function(b,c){if("string"==typeof b&&void 0!==k.levels[b.toUpperCase()]&&(b=k.levels[b.toUpperCase()]),!("number"==typeof b&&b>=0&&b<=k.levels.SILENT))throw"log.setLevel() called with invalid level: "+b;return j=b,c!==!1&&f(b),d.call(k,b,a),typeof console===h&&b<k.levels.SILENT?"No console available for logging":void 0},k.setDefaultLevel=function(a){g()||k.setLevel(a,!1)},k.enableAll=function(a){k.setLevel(k.levels.TRACE,a)},k.disableAll=function(a){k.setLevel(k.levels.SILENT,a)};var m=g();null==m&&(m=null==b?"WARN":b),k.setLevel(m,!1)}var g=function(){},h="undefined",i=["trace","debug","info","warn","error"],j=new f,k={};j.getLogger=function(a){if("string"!=typeof a||""===a)throw new TypeError("You must supply a name when creating a logger.");var b=k[a];return b||(b=k[a]=new f(a,j.getLevel(),j.methodFactory)),b};var l=typeof window!==h?window.log:void 0;return j.noConflict=function(){return typeof window!==h&&window.log===j&&(window.log=l),j},j});

Gruntfile.js

@@ -12,3 +12,3 @@ 'use strict';
                 ' - (c) <%= grunt.template.today("yyyy") %> <%= pkg.author.name %>' +
-                ' - licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n',
+                ' - licensed <%= pkg.license %> */\n',
         // Task configuration.
@@ -15,0 +15,0 @@ concat: {

lib/loglevel.js

@@ -8,2 +8,3 @@ /*
 (function (root, definition) {
+    "use strict";
     if (typeof module === 'object' && module.exports && typeof require === 'function') {
@@ -17,3 +18,3 @@ module.exports = definition();
 }(this, function () {
-    var self = {};
+    "use strict";
     var noop = function() {};
@@ -50,7 +51,9 @@ var undefinedType = "undefined";
 
-    function enableLoggingWhenConsoleArrives(methodName, level) {
+    // these private functions always need `this` to be set properly
+
+    function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
         return function () {
             if (typeof console !== undefinedType) {
-                replaceLoggingMethods(level);
-                self[methodName].apply(self, arguments);
+                replaceLoggingMethods.call(this, level, loggerName);
+                this[methodName].apply(this, arguments);
             }
@@ -60,2 +63,18 @@ };
 
+    function replaceLoggingMethods(level, loggerName) {
+        /*jshint validthis:true */
+        for (var i = 0; i < logMethods.length; i++) {
+            var methodName = logMethods[i];
+            this[methodName] = (i < level) ?
+                noop :
+                this.methodFactory(methodName, level, loggerName);
+        }
+    }
+
+    function defaultMethodFactory(methodName, level, loggerName) {
+        /*jshint validthis:true */
+        return realMethod(methodName) ||
+               enableLoggingWhenConsoleArrives.apply(this, arguments);
+    }
+
     var logMethods = [
@@ -69,42 +88,105 @@ "trace",
 
-    function replaceLoggingMethods(level) {
-        for (var i = 0; i < logMethods.length; i++) {
-            var methodName = logMethods[i];
-            self[methodName] = (i < level) ? noop : self.methodFactory(methodName, level);
-        }
-    }
+    function Logger(name, defaultLevel, factory) {
+      var self = this;
+      var currentLevel;
+      var storageKey = "loglevel";
+      if (name) {
+        storageKey += ":" + name;
+      }
 
-    function persistLevelIfPossible(levelNum) {
-        var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+      function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
 
-        // Use localStorage if available
-        try {
-            window.localStorage['loglevel'] = levelName;
-            return;
-        } catch (ignore) {}
+          // Use localStorage if available
+          try {
+              window.localStorage[storageKey] = levelName;
+              return;
+          } catch (ignore) {}
 
-        // Use session cookie as fallback
-        try {
-            window.document.cookie = "loglevel=" + levelName + ";";
-        } catch (ignore) {}
-    }
+          // Use session cookie as fallback
+          try {
+              window.document.cookie =
+                encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {}
+      }
 
-    function loadPersistedLevel() {
-        var storedLevel;
+      function getPersistedLevel() {
+          var storedLevel;
 
-        try {
-            storedLevel = window.localStorage['loglevel'];
-        } catch (ignore) {}
+          try {
+              storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {}
 
-        if (typeof storedLevel === undefinedType) {
-            try {
-                storedLevel = /loglevel=([^;]+)/.exec(window.document.cookie)[1];
-            } catch (ignore) {}
-        }
-        
-        if (self.levels[storedLevel] === undefined) {
-            storedLevel = "WARN";
-        }
+          if (typeof storedLevel === undefinedType) {
+              try {
+                  var cookie = window.document.cookie;
+                  var location = cookie.indexOf(
+                      encodeURIComponent(storageKey) + "=");
+                  if (location) {
+                      storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+                  }
+              } catch (ignore) {}
+          }
 
-        self.setLevel(self.levels[storedLevel], false);
+          // If the stored level is not valid, treat it as if nothing was stored.
+          if (self.levels[storedLevel] === undefined) {
+              storedLevel = undefined;
+          }
+
+          return storedLevel;
+      }
+
+      /*
+       *
+       * Public API
+       *
+       */
+
+      self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
+          "ERROR": 4, "SILENT": 5};
+
+      self.methodFactory = factory || defaultMethodFactory;
+
+      self.getLevel = function () {
+          return currentLevel;
+      };
+
+      self.setLevel = function (level, persist) {
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+              level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+              currentLevel = level;
+              if (persist !== false) {  // defaults to true
+                  persistLevelIfPossible(level);
+              }
+              replaceLoggingMethods.call(self, level, name);
+              if (typeof console === undefinedType && level < self.levels.SILENT) {
+                  return "No console available for logging";
+              }
+          } else {
+              throw "log.setLevel() called with invalid level: " + level;
+          }
+      };
+
+      self.setDefaultLevel = function (level) {
+          if (!getPersistedLevel()) {
+              self.setLevel(level, false);
+          }
+      };
+
+      self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+      };
+
+      self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+      };
+
+      // Initialize with the right level
+      var initialLevel = getPersistedLevel();
+      if (initialLevel == null) {
+          initialLevel = defaultLevel == null ? "WARN" : defaultLevel;
+      }
+      self.setLevel(initialLevel, false);
     }
@@ -114,52 +196,34 @@
      *
-     * Public API
+     * Package-level API
      *
      */
 
-    self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
-        "ERROR": 4, "SILENT": 5};
+    var defaultLogger = new Logger();
 
-    self.methodFactory = function (methodName, level) {
-        return realMethod(methodName) ||
-               enableLoggingWhenConsoleArrives(methodName, level);
-    };
+    var _loggersByName = {};
+    defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
 
-    self.setLevel = function (level, persist) {
-        if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
-            level = self.levels[level.toUpperCase()];
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger(
+            name, defaultLogger.getLevel(), defaultLogger.methodFactory);
         }
-        if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
-            if (persist !== false) {  // defaults to true
-                persistLevelIfPossible(level);
-            }
-            replaceLoggingMethods(level);
-            if (typeof console === undefinedType && level < self.levels.SILENT) {
-                return "No console available for logging";
-            }
-        } else {
-            throw "log.setLevel() called with invalid level: " + level;
-        }
+        return logger;
     };
 
-    self.enableAll = function(persist) {
-        self.setLevel(self.levels.TRACE, persist);
-    };
-
-    self.disableAll = function(persist) {
-        self.setLevel(self.levels.SILENT, persist);
-    };
-
     // Grab the current global log variable in case of overwrite
     var _log = (typeof window !== undefinedType) ? window.log : undefined;
-    self.noConflict = function() {
+    defaultLogger.noConflict = function() {
         if (typeof window !== undefinedType &&
-               window.log === self) {
+               window.log === defaultLogger) {
             window.log = _log;
         }
 
-        return self;
+        return defaultLogger;
     };
 
-    loadPersistedLevel();
-    return self;
+    return defaultLogger;
 }));

package.json

 {
   "name": "loglevel",
   "description": "Minimal lightweight logging for JavaScript, adding reliable log level methods to any available console.log methods",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "homepage": "https://github.com/pimterry/loglevel",
@@ -18,8 +18,3 @@ "author": {
   },
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "https://github.com/pimterry/loglevel/blob/master/LICENSE-MIT"
-    }
-  ],
+  "license": "MIT",
   "main": "lib/loglevel",
@@ -26,0 +21,0 @@ "engines": {

README.md

@@ -13,3 +13,3 @@
 ## Features
- 
+
 ### Simple
@@ -19,4 +19,4 @@
 * Filter logging by level (all the above or 'silent'), so you can disable all but error logging in production, and then run log.setLevel("trace") in your console to turn it all back on for a furious debugging session
-* Single file, no dependencies, weighs in at <1KB minified and gzipped
- 
+* Single file, no dependencies, weighs in at 1.1KB minified and gzipped
+
 ### Effective
@@ -42,3 +42,3 @@
 
-Alternatively if you just want to grab the file yourself, you can download either the current stable [production version][min] or the [development version][max] directly, or reference it remotely on CDNJS at `//cdnjs.cloudflare.com/ajax/libs/loglevel/1.2.0/loglevel.min.js`
+Alternatively if you just want to grab the file yourself, you can download either the current stable [production version][min] or the [development version][max] directly, or reference it remotely on CDNJS at `//cdnjs.cloudflare.com/ajax/libs/loglevel/1.3.0/loglevel.min.js`
 
@@ -116,7 +116,13 @@ Finally, if you want to tweak loglevel to your own needs or you immediately need the cutting-edge version, clone this repo and see [Developing & Contributing](#developing--contributing) below for build instructions.
   * As a numeric index from 0 (trace) to 5 (silent) ← _deliciously terse, and more easily programmable (...although, why?)_
-  
+
   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.
-  
+
   If log.setLevel() is called when a console object is not available (in IE 8 or 9 before the developer tools have been opened, for example) logging will remain silent until the console becomes available, and then begin logging at the requested level.
-  
+
+* A `log.setDefaultLevel(level)` method.
+
+  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.
+
 * `log.enableAll()` and `log.disableAll()` methods.
@@ -126,2 +132,64 @@
 
+* A `log.getLevel()` method.
+
+  Returns the current logging level, as a number from 0 (trace) to 5 (silent)
+
+  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.
+
+  ```javascript
+  if (log.getLevel() <= log.levels.DEBUG) {
+    var logData = runExpensiveDataGeneration();
+    log.debug(logData);
+  }
+  ```
+
+  This notably isn't the right solution to avoid the cost of string concatenation in your logging. Firstly, it's very unlikely that string concatenation in your logging is really an important performance problem. Even if you do genuinely have hard metrics showing that it is though, the better solution that wrapping your log statements in this is to use multiple arguments, as below. The underlying console API will automatically concatenate these for you if logging is enabled, and if it isn't then all log methods are no-ops, and no concatenation will be done at all.
+
+  ```javascript
+  // Prints 'My concatenated log message'
+  log.debug("My ", "concatenated ", "log message");
+  ```
+
+* A `log.getLogger(loggerName)` method.
+
+  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). 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.
+
+  Example usage *(using CommonJS modules, but you could do the same with any module system):*
+
+  ```javascript
+  // In module-one.js:
+  var log = require("loglevel").getLogger("module-one");
+  function doSomethingAmazing() {
+    log.debug("Amazing message from module one.");
+  }
+
+  // In module-two.js:
+  var log = require("loglevel").getLogger("module-two");
+  function doSomethingSpecial() {
+    log.debug("Special message from module two.");
+  }
+
+  // In your main application module:
+  var log = require("loglevel");
+  var moduleOne = require("module-one");
+  var moduleTwo = require("module-two");
+  log.getLogger("module-two").setLevel("TRACE");
+
+  moduleOne.doSomethingAmazing();
+  moduleTwo.doSomethingSpecial();
+  // logs "Special message from module two."
+  // (but nothing from module one.)
+  ```
+
+  Loggers returned by `getLogger()` support all the same properties and methods as the default root logger, excepting `noConflict()` and the `getLogger()` method itself.
+
+  Like the root logger, other loggers can have their logging level saved. If a logger’s level has not been saved, it will inherit the root logger’s level when it is first created. If the root logger’s level changes later, the new level will not affect other loggers that have already been created.
+
+  Likewise, loggers will inherit the root logger’s `methodFactory`. After creation, each logger can have its `methodFactory` independently set. See the *plugins* section below for more about `methodFactory`.
+
+
 ## Plugins
@@ -137,5 +205,5 @@
 
-Including that would increase the size and complexity of the library, but more importantly would remove stacktrace information. Currently log methods are either disabled, or enabled with directly bound versions of the console.log methods (where possible). This means your browser shows the log message as coming from your code at the call to `log.info("message!")` not from within loglevel, since it's really calls the bound console method directly, without indirection. The indirection required to dynamically format, further filter, or redirect log messages would stop this.
+Including that would increase the size and complexity of the library, but more importantly would remove stacktrace information. Currently log methods are either disabled, or enabled with directly bound versions of the console.log methods (where possible). This means your browser shows the log message as coming from your code at the call to `log.info("message!")` not from within loglevel, since it really calls the bound console method directly, without indirection. The indirection required to dynamically format, further filter, or redirect log messages would stop this.
 
-There's clearly enough enthusiasm for this even at that cost though that loglevel now includes a plugin API. To use it, redefine log.methodFactory(methodName, logLevel) with a function of your own. This will be called for each enabled method each time the level is set (including initially), and should return a function to be used for the given log method, at the given level. 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`
+There's clearly enough enthusiasm for this even at that cost though that loglevel now includes a plugin API. To use it, redefine log.methodFactory(methodName, logLevel, loggerName) with a function of your own. This will be called for each enabled method each time the level is set (including initially), and should return a function 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`
 
@@ -146,4 +214,4 @@ For example, a plugin to prefix all log messages with "Newsflash: " would look like:
 var originalFactory = log.methodFactory;
-log.methodFactory = function (methodName, logLevel) {
-    var rawMethod = originalFactory(methodName, logLevel);
+log.methodFactory = function (methodName, logLevel, loggerName) {
+    var rawMethod = originalFactory(methodName, logLevel, loggerName);
 
@@ -154,3 +222,3 @@ return function (message) {
 };
-log.setLevel("warn"); // Be sure to call setLevel method in order to apply plugin 
+log.setLevel("warn"); // Be sure to call setLevel method in order to apply plugin
 ```
@@ -206,6 +274,6 @@
 
+v1.4 - Add getLevel(), setDefaultLevel() and getLogger() functionality for more fine-grained log level control
+
 ## License
 Copyright (c) 2013 Tim Perry  
 Licensed under the MIT license.
-
-[![githalytics.com alpha](https://cruel-carlota.pagodabox.com/3393271900ddc6808ae1901f3760a59e)](http://githalytics.com/pimterry/loglevel)

test/test-helpers.js

@@ -16,2 +16,10 @@ "use strict";
 define(function () {
+    function getStorageKey(loggerName) {
+        var key = "loglevel";
+        if (loggerName) {
+            key += ":" + loggerName;
+        }
+        return key;
+    }
+
     var self = {};
@@ -24,2 +32,3 @@
         var realLogMethod = window.console.log;
+        var priorCalls = realLogMethod.calls.length;
 
@@ -31,3 +40,3 @@ for (var ii = 0; ii < logMethods.length; ii++) {
 
-        expect(realLogMethod.calls.length).toEqual(expectedWorkingCalls);
+        expect(realLogMethod.calls.length - priorCalls).toEqual(expectedWorkingCalls);
         return true;
@@ -63,6 +72,7 @@ };
 
-    self.toBeTheLevelStoredByCookie = function toBeTheLevelStoredByCookie() {
+    self.toBeTheLevelStoredByCookie = function toBeTheLevelStoredByCookie(name) {
         var level = this.actual.toUpperCase();
+        var storageKey = encodeURIComponent(getStorageKey(name));
 
-        if (window.document.cookie.indexOf("loglevel="+level) !== -1) {
+        if (window.document.cookie.indexOf(storageKey + "=" + level) !== -1) {
             return true;
@@ -74,6 +84,6 @@ } else {
 
-    self.toBeTheLevelStoredByLocalStorage = function toBeTheLevelStoredByLocalStorage() {
+    self.toBeTheLevelStoredByLocalStorage = function toBeTheLevelStoredByLocalStorage(name) {
         var level = this.actual.toUpperCase();
 
-        if (window.localStorage['loglevel'] === level) {
+        if (window.localStorage[getStorageKey(name)] === level) {
             return true;
@@ -86,21 +96,23 @@ }
     // Jasmine matcher to check whether a given string was saved by loglevel
-    self.toBeTheStoredLevel = function toBeTheStoredLevel() {
-        return self.toBeTheLevelStoredByLocalStorage.call(this) ||
-               self.toBeTheLevelStoredByCookie.call(this);
+    self.toBeTheStoredLevel = function toBeTheStoredLevel(name) {
+        return self.toBeTheLevelStoredByLocalStorage.call(this, name) ||
+               self.toBeTheLevelStoredByCookie.call(this, name);
     };
 
-    self.setCookieStoredLevel = function setCookieStoredLevel(level) {
-        window.document.cookie = "loglevel=" + level.toUpperCase();
+    self.setCookieStoredLevel = function setCookieStoredLevel(level, name) {
+        window.document.cookie =
+            encodeURIComponent(getStorageKey(name)) + "=" +
+            level.toUpperCase() + ";";
     };
 
-    self.setLocalStorageStoredLevel = function setLocalStorageStoredLevel(level) {
-        window.localStorage['loglevel'] = level.toUpperCase();
+    self.setLocalStorageStoredLevel = function setLocalStorageStoredLevel(level, name) {
+        window.localStorage[getStorageKey(name)] = level.toUpperCase();
     };
 
-    self.setStoredLevel = function setStoredLevel(level) {
+    self.setStoredLevel = function setStoredLevel(level, name) {
         if (self.isCookieStorageAvailable()) {
-            self.setCookieStoredLevel(level);
+            self.setCookieStoredLevel(level, name);
         }
         if (self.isLocalStorageAvailable()) {
-            self.setLocalStorageStoredLevel(level);
+            self.setLocalStorageStoredLevel(level, name);
         }
@@ -114,3 +126,8 @@ };
         if (self.isCookieStorageAvailable()) {
-            window.document.cookie = "loglevel=; expires=Thu, 01 Jan 1970 00:00:01 GMT;";
+            var storedKeys = window.document.cookie.match(/(?:^|;\s)(loglevel(\:\w+)?)(?=\=)/g);
+            if (storedKeys) {
+                for (var i = 0; i < storedKeys.length; i++) {
+                    window.document.cookie = storedKeys[i] + "=; expires=Thu, 01 Jan 1970 00:00:01 GMT;";
+                }
+            }
         }
@@ -117,0 +134,0 @@ };

test/test-qunit.js

@@ -33,5 +33,7 @@ "use strict";
     ok(typeof logging.setLevel === "function", "setLevel is a function");
+    ok(typeof logging.setDefaultLevel === "function", "setDefaultLevel is a function");
     ok(typeof logging.enableAll === "function", "enableAll is a function");
     ok(typeof logging.disableAll === "function", "disableAll is a function");
-   
+    ok(typeof logging.getLogger === "function", "getLogger is a function");
+
     // Use the API to make sure it doesn't blantantly fail with exceptions
@@ -43,2 +45,9 @@ logging.trace("a trace message");
     logging.error("an error message");
+
+    var newLogger = logging.getLogger("newLogger");
+    newLogger.trace("a trace message");
+    newLogger.debug("a debug message");
+    newLogger.info("an info message");
+    newLogger.warn("a warn message");
+    newLogger.error("an error message");
 });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

115506

increased by22.49%

Number of package files

33

increased by13.79%

Lines of code

2009

increased by20.95%

Number of lines in readme file

271

increased by33.5%

No dependency changes