From 699751e057c0d2d70860bd044be0c476f30acf9c Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Wed, 15 Mar 2017 09:42:01 +0000 Subject: [PATCH 1/6] set prerelease version --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 684a3d1..c6ecf6d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "log-factory", - "version": "0.0.1-prerelease", + "version": "0.1.0-prerelease", "author": "", "main": "lib/index.js", "types": "lib/index.d.ts", From 9a7de3af52ac6f354ab4e82b2fb4a09897391696 Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Mon, 27 Mar 2017 12:24:24 +0100 Subject: [PATCH 2/6] feat(config): Allow logging to be redirected to a file BREAKING CHANGE: The `init` method now takes an options object `{console, file, log}` - see README.md --- README.md | 40 +++++++++++++++++++++++++++++ lib/index.d.ts | 6 ++++- lib/index.js | 54 +++++++++++++++++++++++++++------------ package.json | 2 +- src/index.ts | 69 ++++++++++++++++++++++++++++++++++++++------------ 5 files changed, 137 insertions(+), 34 deletions(-) diff --git a/README.md b/README.md index 23a1bcd..c8efd78 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,46 @@ let logger = buildLogger(); ``` +### Configuration + +```javascript + + import {init} from 'log-factory'; + + /** + * Calling init will only affect loggers after this call. + * So it is advisable to call this at the start of your app + */ + + init({ + console: false, + file: 'my-log.log', + log: 'INFO' + }); +``` + +The options for `init` are: + +* console - true/false, default: `true` +* file - direct logs to a file, default: `undefined` +* log - string|json-string|path-to-json-file, default: `'info'` + * string - error|warn|info|debug|verbose|silly + * json-string - a string that can be parsed as json + * path-to-json - a path to a json file + +If using json you can define levels for different categories. For example: + +```json +{ + "app": "info", + "item" : "debug" +} +``` + +`default` is a special category that will be applied if the category can't be found. + +To see the available categories, first run the log with level `silly`, the name in the square brackets is the category. + # test `npm test` diff --git a/lib/index.d.ts b/lib/index.d.ts index c90db75..23818c6 100644 --- a/lib/index.d.ts +++ b/lib/index.d.ts @@ -1,7 +1,11 @@ /// import * as winston from 'winston'; export declare const setDefaultLevel: (l: any) => void; -export declare const init: (log: any) => void; +export declare const init: (opts: { + console: boolean; + file?: string; + log?: any; +}) => void; export declare const getLogger: (id: string) => winston.LoggerInstance; export declare const fileLogger: (filename: any) => winston.LoggerInstance; export declare function buildLogger(): winston.LoggerInstance; diff --git a/lib/index.js b/lib/index.js index 0c10e2a..637db30 100644 --- a/lib/index.js +++ b/lib/index.js @@ -5,23 +5,41 @@ const fs = require("fs"); const path = require("path"); const stackTrace = require("stack-trace"); const winston = require("winston"); +const moduleOpts = { + console: true, + file: null, + log: 'INFO' +}; let config = { 'default': 'info' }; +const timestamp = () => { + var now = new Date(); + return dateFormat(now, 'HH:MM:ss.l'); +}; +const consoleTransport = (label) => { + return new (winston.transports.Console)({ + colorize: true, + label: label, + timestamp + }); +}; +const fileTransport = (label) => { + return new winston.transports.File({ + colorize: false, + json: false, + filename: moduleOpts.file, + label, + timestamp + }); +}; const mkLogConfig = (label, level) => { - return { - level: level, - transports: [ - new (winston.transports.Console)({ - colorize: true, - label: label, - timestamp: () => { - var now = new Date(); - return dateFormat(now, 'HH:MM:ss.l'); - } - }) - ] - }; + const addConsole = !moduleOpts.file && moduleOpts.console; + const transports = [ + addConsole ? consoleTransport(label) : null, + moduleOpts.file ? fileTransport(label) : null + ].filter(t => t !== null); + return { level, transports }; }; const logger = addLogger('LOG_FACTORY'); const setConfig = (cfg) => { @@ -40,8 +58,12 @@ exports.setDefaultLevel = (l) => { logger.configure(cfg); }); }; -exports.init = (log) => { - logger.debug('init: ', log); +exports.init = (opts) => { + logger.debug('init: ', opts); + moduleOpts.console = opts.console; + moduleOpts.file = opts.file; + moduleOpts.log = opts.log; + const { log } = moduleOpts; if (!log) { return; } @@ -108,4 +130,4 @@ function buildLogger() { } exports.buildLogger = buildLogger; -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";AAAA,4BAA4B;AAC5B,yCAAyC;AACzC,yBAAyB;AACzB,6BAA6B;AAC7B,0CAA0C;AAC1C,mCAAmC;AAInC,IAAI,MAAM,GAAG;IACX,SAAS,EAAE,MAAM;CAClB,CAAC;AAEF,MAAM,WAAW,GAAG,CAAC,KAAa,EAAE,KAAa;IAC/C,MAAM,CAAC;QACL,KAAK,EAAE,KAAK;QACZ,UAAU,EAAE;YACV,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;gBAC/B,QAAQ,EAAE,IAAI;gBACd,KAAK,EAAE,KAAK;gBACZ,SAAS,EAAE;oBACT,IAAI,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;oBACrB,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;gBACvC,CAAC;aACF,CAAC;SACH;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC;AAExC,MAAM,SAAS,GAAG,CAAC,GAAG;IACpB,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG;QACtB,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACxB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,UAAU,GAAG,CAAC,CAAC,KAAc,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;AAE5F,QAAA,eAAe,GAAG,CAAC,CAAC;IAC/B,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3C,MAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IACvD,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG;QAC5C,IAAI,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;QAC9C,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEW,QAAA,IAAI,GAAG,CAAC,GAAG;IAEtB,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAE5B,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACT,MAAM,CAAC;IACT,CAAC;IAED,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACpB,SAAS,CAAC,GAAG,CAAC,CAAC;IACjB,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC3B,uBAAe,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,IAAI,CAAC;YACH,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YAClC,SAAS,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC;QAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACX,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACvB,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;gBACnD,SAAS,CAAC,GAAG,CAAC,CAAC;YACjB,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,OAAO,CAAC,KAAK,CAAC,mDAAmD,GAAG,GAAG,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAGF,mBAAmB,KAAK,EAAE,KAAc;IACtC,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC;IACpD,IAAI,GAAG,GAAG,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACpC,IAAI,MAAM,CAAC;IACX,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACtB,MAAM,CAAC,MAAM,CAAC;AAChB,CAAC;AAGY,QAAA,SAAS,GAAG,CAAC,EAAU;IAClC,IAAI,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEvC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;QACb,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IACxD,CAAC;AACH,CAAC,CAAC;AAGW,QAAA,UAAU,GAAG,CAAC,QAAQ;IACjC,IAAI,KAAK,CAAC;IACV,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAElC,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC;QAC5B,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAAC,IAAI,CAAC,CAAC;QACN,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IACtB,CAAC;IACD,MAAM,CAAC,iBAAS,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC,CAAC;AAYF;IACE,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC;IAC7B,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAClC,MAAM,CAAC,kBAAU,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAJD,kCAIC","file":"index.js","sourcesContent":["import * as _ from 'lodash';\nimport * as dateFormat from 'dateformat';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as stackTrace from 'stack-trace';\nimport * as winston from 'winston';\n\n//levels: error > warn > info > verbose > debug > silly\n\nlet config = {\n  'default': 'info'\n};\n\nconst mkLogConfig = (label: string, level: string) => {\n  return {\n    level: level,\n    transports: [\n      new (winston.transports.Console)({\n        colorize: true,\n        label: label,\n        timestamp: () => {\n          var now = new Date();\n          return dateFormat(now, 'HH:MM:ss.l');\n        }\n      })\n    ]\n  };\n};\n\nconst logger = addLogger('LOG_FACTORY');\n\nconst setConfig = (cfg) => {\n  config = _.merge({}, config, cfg);\n  _.forIn(cfg, (value, key) => {\n    addLogger(key, value);\n  });\n};\n\nconst isLogLevel = (l): Boolean => _.includes(['error', 'warn', 'info', 'verbose', 'debug', 'silly'], l);\n\nexport const setDefaultLevel = (l) => {\n  config = _.merge(config, { 'default': l });\n  logger.debug('default level now: ', config['default']);\n  _.forEach(winston.loggers.loggers, (value, key) => {\n    let logger = winston.loggers.get(key);\n    let cfg = mkLogConfig(key, config['default']);\n    logger.configure(cfg);\n  });\n};\n\nexport const init = (log): void => {\n\n  logger.debug('init: ', log);\n\n  if (!log) {\n    return;\n  }\n\n  if (_.isObject(log)) {\n    setConfig(log);\n  } else if (isLogLevel(log)) {\n    setDefaultLevel(log);\n  } else {\n    try {\n      let config = JSON.parse(log);\n      logger.debug('parsed log: ', log);\n      setConfig(config);\n    } catch (e) {\n      if (fs.existsSync(log)) {\n        var cfg = JSON.parse(fs.readFileSync(log, 'utf8'));\n        setConfig(cfg);\n      } else {\n        console.error('can not configure logging using cli param value: ' + log);\n      }\n    }\n  }\n};\n\n\nfunction addLogger(label, level?: string): winston.LoggerInstance {\n  level = level ? level : config['default'] || 'info';\n  let cfg = mkLogConfig(label, level);\n  let logger;\n  if (winston.loggers.has(label)) {\n    logger = winston.loggers.get(label);\n  } else {\n    logger = winston.loggers.add(label, {});\n  }\n\n  logger.configure(cfg);\n  return logger;\n}\n\n/** get a logger and give it a name */\nexport const getLogger = (id: string): winston.LoggerInstance => {\n  var existing = winston.loggers.has(id);\n\n  if (existing) {\n    return winston.loggers.get(id);\n  } else {\n    return addLogger(id, config[id] || config['default']);\n  }\n};\n\n/** get a logger and name it by it's file name. */\nexport const fileLogger = (filename): winston.LoggerInstance => {\n  var label;\n  var parsed = path.parse(filename);\n\n  if (parsed.name === 'index') {\n    label = path.basename(parsed.dir);\n  } else {\n    label = parsed.name;\n  }\n  return getLogger(label);\n};\n\n/**\n * Create a logger and automatically name it by using the filename of the call site.\n * Eg:\n * ```\n * //my-file.js\n * import {buildLogger} from 'log-factory';\n * let logger = buildLogger();\n * logger.info('hi') //=> emits [INFO] [my-file] hi\n * ```\n */\nexport function buildLogger(): winston.LoggerInstance {\n  let trace = stackTrace.get();\n  let name = trace[1].getFileName();\n  return fileLogger(name);\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import * as _ from 'lodash';\nimport * as dateFormat from 'dateformat';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as stackTrace from 'stack-trace';\nimport * as winston from 'winston';\n\n//levels: error > warn > info > verbose > debug > silly\n\ntype LogFactoryOpts = {\n  console: boolean,\n  file?: string,\n  log?: any\n};\n\nconst moduleOpts = {\n  console: true,\n  file: null,\n  log: 'INFO'\n};\n\nlet config = {\n  'default': 'info'\n};\n\nconst timestamp = () => {\n  var now = new Date();\n  return dateFormat(now, 'HH:MM:ss.l');\n};\n\nconst consoleTransport = (label: string): winston.TransportInstance => {\n  return new (winston.transports.Console)({\n    colorize: true,\n    label: label,\n    timestamp\n  });\n};\n\nconst fileTransport = (label: string): winston.TransportInstance => {\n  return new winston.transports.File({\n    colorize: false,\n    json: false,\n    filename: moduleOpts.file,\n    label,\n    timestamp\n  });\n};\n\nconst mkLogConfig = (label: string, level: string) => {\n\n  const addConsole = !moduleOpts.file && moduleOpts.console;\n\n  const transports: winston.TransportInstance[] = [\n    addConsole ? consoleTransport(label) : null,\n    moduleOpts.file ? fileTransport(label) : null\n  ].filter(t => t !== null);\n\n  return { level, transports };\n};\n\nconst logger = addLogger('LOG_FACTORY');\n\nconst setConfig = (cfg) => {\n  config = _.merge({}, config, cfg);\n  _.forIn(cfg, (value, key) => {\n    addLogger(key, value);\n  });\n};\n\nconst isLogLevel = (l): Boolean => _.includes(['error', 'warn', 'info', 'verbose', 'debug', 'silly'], l);\n\nexport const setDefaultLevel = (l) => {\n  config = _.merge(config, { 'default': l });\n  logger.debug('default level now: ', config['default']);\n  _.forEach(winston.loggers.loggers, (value, key) => {\n    let logger = winston.loggers.get(key);\n    let cfg = mkLogConfig(key, config['default']);\n    logger.configure(cfg);\n  });\n};\n\nexport const init = (opts: LogFactoryOpts): void => {\n\n  logger.debug('init: ', opts);\n\n  moduleOpts.console = opts.console;\n  moduleOpts.file = opts.file;\n  moduleOpts.log = opts.log;\n\n  const { log } = moduleOpts;\n\n  if (!log) {\n    return;\n  }\n\n  if (_.isObject(log)) {\n    setConfig(log);\n  } else if (isLogLevel(log)) {\n    setDefaultLevel(log);\n  } else {\n    try {\n      let config = JSON.parse(log);\n      logger.debug('parsed log: ', log);\n      setConfig(config);\n    } catch (e) {\n      if (fs.existsSync(log)) {\n        var cfg = JSON.parse(fs.readFileSync(log, 'utf8'));\n        setConfig(cfg);\n      } else {\n        console.error('can not configure logging using cli param value: ' + log);\n      }\n    }\n  }\n};\n\nfunction addLogger(label, level?: string): winston.LoggerInstance {\n\n  level = level ? level : config['default'] || 'info';\n  let cfg = mkLogConfig(label, level);\n  let logger;\n  if (winston.loggers.has(label)) {\n    logger = winston.loggers.get(label);\n  } else {\n    logger = winston.loggers.add(label, {});\n  }\n\n  logger.configure(cfg);\n  return logger;\n}\n\n/** get a logger and give it a name */\nexport const getLogger = (id: string): winston.LoggerInstance => {\n  var existing = winston.loggers.has(id);\n\n  if (existing) {\n    return winston.loggers.get(id);\n  } else {\n    return addLogger(id, config[id] || config['default']);\n  }\n};\n\n/** get a logger and name it by it's file name. */\nexport const fileLogger = (filename): winston.LoggerInstance => {\n  var label;\n  var parsed = path.parse(filename);\n\n  if (parsed.name === 'index') {\n    label = path.basename(parsed.dir);\n  } else {\n    label = parsed.name;\n  }\n  return getLogger(label);\n};\n\n/**\n * Create a logger and automatically name it by using the filename of the call site.\n * Eg:\n * ```\n * //my-file.js\n * import {buildLogger} from 'log-factory';\n * let logger = buildLogger();\n * logger.info('hi') //=> emits [INFO] [my-file] hi\n * ```\n */\nexport function buildLogger(): winston.LoggerInstance {\n  let trace = stackTrace.get();\n  let name = trace[1].getFileName();\n  return fileLogger(name);\n}\n"]} diff --git a/package.json b/package.json index c6ecf6d..8d8f21d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "log-factory", - "version": "0.1.0-prerelease", + "version": "1.0.0-prerelease", "author": "", "main": "lib/index.js", "types": "lib/index.d.ts", diff --git a/src/index.ts b/src/index.ts index ddabfbb..d01824e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -7,24 +7,55 @@ import * as winston from 'winston'; //levels: error > warn > info > verbose > debug > silly +type LogFactoryOpts = { + console: boolean, + file?: string, + log?: any +}; + +const moduleOpts = { + console: true, + file: null, + log: 'INFO' +}; + let config = { 'default': 'info' }; +const timestamp = () => { + var now = new Date(); + return dateFormat(now, 'HH:MM:ss.l'); +}; + +const consoleTransport = (label: string): winston.TransportInstance => { + return new (winston.transports.Console)({ + colorize: true, + label: label, + timestamp + }); +}; + +const fileTransport = (label: string): winston.TransportInstance => { + return new winston.transports.File({ + colorize: false, + json: false, + filename: moduleOpts.file, + label, + timestamp + }); +}; + const mkLogConfig = (label: string, level: string) => { - return { - level: level, - transports: [ - new (winston.transports.Console)({ - colorize: true, - label: label, - timestamp: () => { - var now = new Date(); - return dateFormat(now, 'HH:MM:ss.l'); - } - }) - ] - }; + + const addConsole = !moduleOpts.file && moduleOpts.console; + + const transports: winston.TransportInstance[] = [ + addConsole ? consoleTransport(label) : null, + moduleOpts.file ? fileTransport(label) : null + ].filter(t => t !== null); + + return { level, transports }; }; const logger = addLogger('LOG_FACTORY'); @@ -48,9 +79,15 @@ export const setDefaultLevel = (l) => { }); }; -export const init = (log): void => { +export const init = (opts: LogFactoryOpts): void => { - logger.debug('init: ', log); + logger.debug('init: ', opts); + + moduleOpts.console = opts.console; + moduleOpts.file = opts.file; + moduleOpts.log = opts.log; + + const { log } = moduleOpts; if (!log) { return; @@ -76,8 +113,8 @@ export const init = (log): void => { } }; - function addLogger(label, level?: string): winston.LoggerInstance { + level = level ? level : config['default'] || 'info'; let cfg = mkLogConfig(label, level); let logger; From a7e0ae82e91e8e1a6289247a77df667b22da3a3d Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Mon, 27 Mar 2017 12:46:17 +0100 Subject: [PATCH 3/6] update tests --- README.md | 2 + lib/index.js | 10 +-- src/index.ts | 10 +-- test/index-test.js | 165 +++++++++++++++++++++++++++++++-------------- 4 files changed, 122 insertions(+), 65 deletions(-) diff --git a/README.md b/README.md index c8efd78..c1aea84 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,8 @@ The options for `init` are: * json-string - a string that can be parsed as json * path-to-json - a path to a json file + +> If you want to disable logging you can pass in: `{ console: false, file: undefined}` If using json you can define levels for different categories. For example: ```json diff --git a/lib/index.js b/lib/index.js index 637db30..b6213ab 100644 --- a/lib/index.js +++ b/lib/index.js @@ -8,7 +8,7 @@ const winston = require("winston"); const moduleOpts = { console: true, file: null, - log: 'INFO' + log: 'info' }; let config = { 'default': 'info' @@ -41,7 +41,6 @@ const mkLogConfig = (label, level) => { ].filter(t => t !== null); return { level, transports }; }; -const logger = addLogger('LOG_FACTORY'); const setConfig = (cfg) => { config = _.merge({}, config, cfg); _.forIn(cfg, (value, key) => { @@ -51,7 +50,6 @@ const setConfig = (cfg) => { const isLogLevel = (l) => _.includes(['error', 'warn', 'info', 'verbose', 'debug', 'silly'], l); exports.setDefaultLevel = (l) => { config = _.merge(config, { 'default': l }); - logger.debug('default level now: ', config['default']); _.forEach(winston.loggers.loggers, (value, key) => { let logger = winston.loggers.get(key); let cfg = mkLogConfig(key, config['default']); @@ -59,10 +57,9 @@ exports.setDefaultLevel = (l) => { }); }; exports.init = (opts) => { - logger.debug('init: ', opts); moduleOpts.console = opts.console; moduleOpts.file = opts.file; - moduleOpts.log = opts.log; + moduleOpts.log = opts.log || moduleOpts.log; const { log } = moduleOpts; if (!log) { return; @@ -76,7 +73,6 @@ exports.init = (opts) => { else { try { let config = JSON.parse(log); - logger.debug('parsed log: ', log); setConfig(config); } catch (e) { @@ -130,4 +126,4 @@ function buildLogger() { } exports.buildLogger = buildLogger; -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import * as _ from 'lodash';\nimport * as dateFormat from 'dateformat';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as stackTrace from 'stack-trace';\nimport * as winston from 'winston';\n\n//levels: error > warn > info > verbose > debug > silly\n\ntype LogFactoryOpts = {\n  console: boolean,\n  file?: string,\n  log?: any\n};\n\nconst moduleOpts = {\n  console: true,\n  file: null,\n  log: 'INFO'\n};\n\nlet config = {\n  'default': 'info'\n};\n\nconst timestamp = () => {\n  var now = new Date();\n  return dateFormat(now, 'HH:MM:ss.l');\n};\n\nconst consoleTransport = (label: string): winston.TransportInstance => {\n  return new (winston.transports.Console)({\n    colorize: true,\n    label: label,\n    timestamp\n  });\n};\n\nconst fileTransport = (label: string): winston.TransportInstance => {\n  return new winston.transports.File({\n    colorize: false,\n    json: false,\n    filename: moduleOpts.file,\n    label,\n    timestamp\n  });\n};\n\nconst mkLogConfig = (label: string, level: string) => {\n\n  const addConsole = !moduleOpts.file && moduleOpts.console;\n\n  const transports: winston.TransportInstance[] = [\n    addConsole ? consoleTransport(label) : null,\n    moduleOpts.file ? fileTransport(label) : null\n  ].filter(t => t !== null);\n\n  return { level, transports };\n};\n\nconst logger = addLogger('LOG_FACTORY');\n\nconst setConfig = (cfg) => {\n  config = _.merge({}, config, cfg);\n  _.forIn(cfg, (value, key) => {\n    addLogger(key, value);\n  });\n};\n\nconst isLogLevel = (l): Boolean => _.includes(['error', 'warn', 'info', 'verbose', 'debug', 'silly'], l);\n\nexport const setDefaultLevel = (l) => {\n  config = _.merge(config, { 'default': l });\n  logger.debug('default level now: ', config['default']);\n  _.forEach(winston.loggers.loggers, (value, key) => {\n    let logger = winston.loggers.get(key);\n    let cfg = mkLogConfig(key, config['default']);\n    logger.configure(cfg);\n  });\n};\n\nexport const init = (opts: LogFactoryOpts): void => {\n\n  logger.debug('init: ', opts);\n\n  moduleOpts.console = opts.console;\n  moduleOpts.file = opts.file;\n  moduleOpts.log = opts.log;\n\n  const { log } = moduleOpts;\n\n  if (!log) {\n    return;\n  }\n\n  if (_.isObject(log)) {\n    setConfig(log);\n  } else if (isLogLevel(log)) {\n    setDefaultLevel(log);\n  } else {\n    try {\n      let config = JSON.parse(log);\n      logger.debug('parsed log: ', log);\n      setConfig(config);\n    } catch (e) {\n      if (fs.existsSync(log)) {\n        var cfg = JSON.parse(fs.readFileSync(log, 'utf8'));\n        setConfig(cfg);\n      } else {\n        console.error('can not configure logging using cli param value: ' + log);\n      }\n    }\n  }\n};\n\nfunction addLogger(label, level?: string): winston.LoggerInstance {\n\n  level = level ? level : config['default'] || 'info';\n  let cfg = mkLogConfig(label, level);\n  let logger;\n  if (winston.loggers.has(label)) {\n    logger = winston.loggers.get(label);\n  } else {\n    logger = winston.loggers.add(label, {});\n  }\n\n  logger.configure(cfg);\n  return logger;\n}\n\n/** get a logger and give it a name */\nexport const getLogger = (id: string): winston.LoggerInstance => {\n  var existing = winston.loggers.has(id);\n\n  if (existing) {\n    return winston.loggers.get(id);\n  } else {\n    return addLogger(id, config[id] || config['default']);\n  }\n};\n\n/** get a logger and name it by it's file name. */\nexport const fileLogger = (filename): winston.LoggerInstance => {\n  var label;\n  var parsed = path.parse(filename);\n\n  if (parsed.name === 'index') {\n    label = path.basename(parsed.dir);\n  } else {\n    label = parsed.name;\n  }\n  return getLogger(label);\n};\n\n/**\n * Create a logger and automatically name it by using the filename of the call site.\n * Eg:\n * ```\n * //my-file.js\n * import {buildLogger} from 'log-factory';\n * let logger = buildLogger();\n * logger.info('hi') //=> emits [INFO] [my-file] hi\n * ```\n */\nexport function buildLogger(): winston.LoggerInstance {\n  let trace = stackTrace.get();\n  let name = trace[1].getFileName();\n  return fileLogger(name);\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import * as _ from 'lodash';\nimport * as dateFormat from 'dateformat';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as stackTrace from 'stack-trace';\nimport * as winston from 'winston';\n\n//levels: error > warn > info > verbose > debug > silly\n\ntype LogFactoryOpts = {\n  console: boolean,\n  file?: string,\n  log?: any\n};\n\nconst moduleOpts = {\n  console: true,\n  file: null,\n  log: 'info'\n};\n\nlet config = {\n  'default': 'info'\n};\n\nconst timestamp = () => {\n  var now = new Date();\n  return dateFormat(now, 'HH:MM:ss.l');\n};\n\nconst consoleTransport = (label: string): winston.TransportInstance => {\n  return new (winston.transports.Console)({\n    colorize: true,\n    label: label,\n    timestamp\n  });\n};\n\nconst fileTransport = (label: string): winston.TransportInstance => {\n  return new winston.transports.File({\n    colorize: false,\n    json: false,\n    filename: moduleOpts.file,\n    label,\n    timestamp\n  });\n};\n\nconst mkLogConfig = (label: string, level: string) => {\n\n  const addConsole = !moduleOpts.file && moduleOpts.console;\n\n  const transports: winston.TransportInstance[] = [\n    addConsole ? consoleTransport(label) : null,\n    moduleOpts.file ? fileTransport(label) : null\n  ].filter(t => t !== null);\n\n\n  return { level, transports };\n};\n\n\nconst setConfig = (cfg) => {\n  config = _.merge({}, config, cfg);\n  _.forIn(cfg, (value, key) => {\n    addLogger(key, value);\n  });\n};\n\nconst isLogLevel = (l): Boolean => _.includes(['error', 'warn', 'info', 'verbose', 'debug', 'silly'], l);\n\nexport const setDefaultLevel = (l) => {\n  config = _.merge(config, { 'default': l });\n  _.forEach(winston.loggers.loggers, (value, key) => {\n    let logger = winston.loggers.get(key);\n    let cfg = mkLogConfig(key, config['default']);\n    logger.configure(cfg);\n  });\n};\n\nexport const init = (opts: LogFactoryOpts): void => {\n\n  moduleOpts.console = opts.console;\n  moduleOpts.file = opts.file;\n  moduleOpts.log = opts.log || moduleOpts.log;\n\n  const { log } = moduleOpts;\n\n  if (!log) {\n    return;\n  }\n\n  if (_.isObject(log)) {\n    setConfig(log);\n  } else if (isLogLevel(log)) {\n    setDefaultLevel(log);\n  } else {\n    try {\n      let config = JSON.parse(log);\n      setConfig(config);\n    } catch (e) {\n      if (fs.existsSync(log)) {\n        var cfg = JSON.parse(fs.readFileSync(log, 'utf8'));\n        setConfig(cfg);\n      } else {\n        console.error('can not configure logging using cli param value: ' + log);\n      }\n    }\n  }\n};\n\nfunction addLogger(label, level?: string): winston.LoggerInstance {\n\n  level = level ? level : config['default'] || 'info';\n  let cfg = mkLogConfig(label, level);\n  let logger;\n  if (winston.loggers.has(label)) {\n    logger = winston.loggers.get(label);\n  } else {\n    logger = winston.loggers.add(label, {});\n  }\n\n  logger.configure(cfg);\n  return logger;\n}\n\n/** get a logger and give it a name */\nexport const getLogger = (id: string): winston.LoggerInstance => {\n  var existing = winston.loggers.has(id);\n\n  if (existing) {\n    return winston.loggers.get(id);\n  } else {\n    return addLogger(id, config[id] || config['default']);\n  }\n};\n\n/** get a logger and name it by it's file name. */\nexport const fileLogger = (filename): winston.LoggerInstance => {\n  var label;\n  var parsed = path.parse(filename);\n\n  if (parsed.name === 'index') {\n    label = path.basename(parsed.dir);\n  } else {\n    label = parsed.name;\n  }\n  return getLogger(label);\n};\n\n/**\n * Create a logger and automatically name it by using the filename of the call site.\n * Eg:\n * ```\n * //my-file.js\n * import {buildLogger} from 'log-factory';\n * let logger = buildLogger();\n * logger.info('hi') //=> emits [INFO] [my-file] hi\n * ```\n */\nexport function buildLogger(): winston.LoggerInstance {\n  let trace = stackTrace.get();\n  let name = trace[1].getFileName();\n  return fileLogger(name);\n}\n"]} diff --git a/src/index.ts b/src/index.ts index d01824e..bb859fe 100644 --- a/src/index.ts +++ b/src/index.ts @@ -16,7 +16,7 @@ type LogFactoryOpts = { const moduleOpts = { console: true, file: null, - log: 'INFO' + log: 'info' }; let config = { @@ -55,10 +55,10 @@ const mkLogConfig = (label: string, level: string) => { moduleOpts.file ? fileTransport(label) : null ].filter(t => t !== null); + return { level, transports }; }; -const logger = addLogger('LOG_FACTORY'); const setConfig = (cfg) => { config = _.merge({}, config, cfg); @@ -71,7 +71,6 @@ const isLogLevel = (l): Boolean => _.includes(['error', 'warn', 'info', 'verbose export const setDefaultLevel = (l) => { config = _.merge(config, { 'default': l }); - logger.debug('default level now: ', config['default']); _.forEach(winston.loggers.loggers, (value, key) => { let logger = winston.loggers.get(key); let cfg = mkLogConfig(key, config['default']); @@ -81,11 +80,9 @@ export const setDefaultLevel = (l) => { export const init = (opts: LogFactoryOpts): void => { - logger.debug('init: ', opts); - moduleOpts.console = opts.console; moduleOpts.file = opts.file; - moduleOpts.log = opts.log; + moduleOpts.log = opts.log || moduleOpts.log; const { log } = moduleOpts; @@ -100,7 +97,6 @@ export const init = (opts: LogFactoryOpts): void => { } else { try { let config = JSON.parse(log); - logger.debug('parsed log: ', log); setConfig(config); } catch (e) { if (fs.existsSync(log)) { diff --git a/test/index-test.js b/test/index-test.js index 622704d..f7c22c1 100644 --- a/test/index-test.js +++ b/test/index-test.js @@ -17,7 +17,8 @@ describe('log-factory', () => { deps = { 'winston': { transports: { - Console: stub().returns(instance) + Console: stub().returns(instance), + File: stub().returns(instance) }, loggers: { get: stub().returns(instance), @@ -32,84 +33,146 @@ describe('log-factory', () => { }, 'stack-trace': {} } - logFactory = proxyquire('../lib', deps); }); describe('init', () => { - beforeEach(() => { - logFactory.setDefaultLevel = stub(); - }); - - it('inits via a level', () => { - logFactory.init('silly'); - assert.calledWith(logFactory.setDefaultLevel, 'silly'); - }); + describe('disabled', () => { + beforeEach(() => { + logFactory.init({ console: false, file: undefined }); + logFactory.fileLogger('test'); + }); - let prepLoggers = (has) => { - deps.winston.loggers.has.withArgs('app').returns(has); - deps.winston.loggers.get.withArgs('app').returns(instance); - deps.winston.loggers.add.withArgs('app').returns(instance); - logFactory.init({ app: 'silly' }); - } + it('does not create a Console transport', () => { + assert.notCalled(deps.winston.transports.Console); + }); + it('does not create a File transport', () => { + assert.notCalled(deps.winston.transports.File) + }); + }); - let assertSetConfig = (run) => { + describe('console', () => { - it('calls logger.has', () => { - run(); - assert.calledWith(deps.winston.loggers.has, 'app'); + beforeEach(() => { + logFactory.init({ console: true, file: undefined }); + logFactory.fileLogger('test'); }); - it('calls logger.configure', () => { - run(); - assert.calledWith(instance.configure, { - level: 'silly', - transports: match.array + it('creates a new Console transport', () => { + assert.calledWith(deps.winston.transports.Console, { + colorize: true, + label: 'test', + timestamp: match.func }); }); + it('does not create a File transport', () => { + assert.notCalled(deps.winston.transports.File) + }); + }); + + describe('file', () => { - it('calls logger.add if there is no logger', () => { - run(false); - assert.calledWith(deps.winston.loggers.add, 'app', {}); + beforeEach(() => { + logFactory.init({ console: false, file: 'my-file.log' }); + logFactory.fileLogger('test'); }); - it('calls logger.get if there is a logger', () => { - run(true); - assert.calledWith(deps.winston.loggers.get, 'app'); + it('does not create a new Console transport', () => { + assert.notCalled(deps.winston.transports.Console) }); - } + it('creates a new File transport', () => + + assert.calledWith(deps.winston.transports.File, { + filename: 'my-file.log', + colorize: false, + json: false, + label: 'test', + timestamp: match.func + })); + }); + - describe('with object', () => { + describe('log', () => { - let run = (has) => { - prepLoggers(has); + beforeEach(() => { + logFactory.setDefaultLevel = stub(); + }); + + it('inits via a level', () => { + logFactory.init({ + log: 'silly' + }); + assert.calledWith(logFactory.setDefaultLevel, 'silly'); + }); + + let prepLoggers = (has) => { + deps.winston.loggers.has.withArgs('app').returns(has); + deps.winston.loggers.get.withArgs('app').returns(instance); + deps.winston.loggers.add.withArgs('app').returns(instance); logFactory.init({ app: 'silly' }); } - assertSetConfig(run); - }); - describe('with json string', () => { - let run = (has) => { - prepLoggers(has); - logFactory.init(JSON.stringify({ app: 'silly' })); - } - assertSetConfig(run); - }); + let assertSetConfig = (run) => { + + it('calls logger.has', () => { + run(); + assert.calledWith(deps.winston.loggers.has, 'app'); + }); + + it('calls logger.configure', () => { + run(); + assert.calledWith(instance.configure, { + level: 'silly', + transports: match.array + }); + }); + + + it('calls logger.add if there is no logger', () => { + run(false); + assert.calledWith(deps.winston.loggers.add, 'app', {}); + }); + + it('calls logger.get if there is a logger', () => { + run(true); + assert.calledWith(deps.winston.loggers.get, 'app'); + }); - describe('with path to file', () => { - let run = (has) => { - prepLoggers(has); - deps.fs.existsSync.returns(true); - deps.fs.readFileSync.returns(JSON.stringify({ app: 'silly' })); - logFactory.init('path/to/file'); } - assertSetConfig(run); + describe('with object', () => { + + let run = (has) => { + prepLoggers(has); + logFactory.init({ log: { app: 'silly' } }); + } + assertSetConfig(run); + }); + + describe('with json string', () => { + + let run = (has) => { + prepLoggers(has); + logFactory.init({ log: JSON.stringify({ app: 'silly' }) }); + } + assertSetConfig(run); + }); + + describe('with path to file', () => { + let run = (has) => { + prepLoggers(has); + deps.fs.existsSync.returns(true); + deps.fs.readFileSync.returns(JSON.stringify({ app: 'silly' })); + logFactory.init({ log: 'path/to/file' }); + } + + assertSetConfig(run); + }); }); }); }); \ No newline at end of file From 548d178fda4f0b45de6c278cd24b1c367f81cc5f Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Mon, 27 Mar 2017 12:49:06 +0100 Subject: [PATCH 4/6] bump version --- package.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 8d8f21d..e86ae40 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "log-factory", - "version": "1.0.0-prerelease", + "version": "1.1.0-prerelease", "author": "", "main": "lib/index.js", "types": "lib/index.d.ts", @@ -38,4 +38,4 @@ "test": "./node_modules/.bin/gulp build && ./node_modules/.bin/mocha", "live-test": "./node_modules/.bin/gulp watch" } -} \ No newline at end of file +} From e8ef396527e131a2dec8b21f68c963a04ca1e779 Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Mon, 27 Mar 2017 12:52:53 +0100 Subject: [PATCH 5/6] reset version - 1.0.0 not released yet --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index e86ae40..729afdf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "log-factory", - "version": "1.1.0-prerelease", + "version": "1.0.0-prerelease", "author": "", "main": "lib/index.js", "types": "lib/index.d.ts", From 2d5b6134de82d049a3144b1532c5e342bc3d4ede Mon Sep 17 00:00:00 2001 From: Ed Eustace Date: Mon, 27 Mar 2017 18:54:49 +0100 Subject: [PATCH 6/6] more info in readme --- README.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index c1aea84..91d2997 100644 --- a/README.md +++ b/README.md @@ -9,17 +9,21 @@ let logger = buildLogger(); ``` +The logger will be named after the module that called `buildLogger`. So if your file was called `utils/index.js` the logger category will be `[utils]`. + ### Configuration +By default logging targets the console with a `level` of `info`. You can change this by calling `init`. + ```javascript import {init} from 'log-factory'; /** - * Calling init will only affect loggers after this call. - * So it is advisable to call this at the start of your app + * Will only affect loggers created after the call to init. + * It is advisable to call this at the start of your app + * before any log instances have been created. */ - init({ console: false, file: 'my-log.log', @@ -37,7 +41,8 @@ The options for `init` are: * path-to-json - a path to a json file -> If you want to disable logging you can pass in: `{ console: false, file: undefined}` +> If you want to disable logging you can pass in: `{console: false, file: undefined}` + If using json you can define levels for different categories. For example: ```json