@pryv/boiler 1.2.3 → 1.2.5

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2020–2023 Pryv S.A https://pryv.com
+Copyright (c) 2020–2024 Pryv S.A https://pryv.com
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

package/examples/customLogger/src/index.js

@@ -1,20 +1,24 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/pryv-boiler/blob/master/LICENSE)
+ */
 
-module.exports = { 
-  init, 
+module.exports = {
+  init,
   log
-}
+};
 
-async function init(settings) {
+async function init (settings) {
   console.log('CUSTOM LOGGER initilaized with', settings);
 }
 
 /**
- * 
+ *
  * @param {string} level one of 'debug', 'info', 'warn', 'error'
  * @param {string} key ':' namespaced keys
- * @param {message} message 
- * @param {object} meta 
+ * @param {message} message
+ * @param {object} meta
  */
-function log(level, key, text, meta) {
-  console.log('Custom: ' + JSON.stringify({level, key, text, meta}));
-}
+function log (level, key, text, meta) {
+  console.log('Custom: ' + JSON.stringify({ level, key, text, meta }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pryv/boiler",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "private": false,
   "description": "Logging and config boilerplate library for Node.js apps and services at Pryv",
   "keywords": [
@@ -19,6 +19,7 @@
   "license": "BSD-3-Clause",
   "author": "Pryv S.A <info@pryv.com> (https://pryv.com)",
   "main": "src/index",
+  "types": "src/index.d.ts",
   "scripts": {
     "license": "source-licenser -c .licenser.yml .",
     "lint": "semistandard"
@@ -27,7 +28,6 @@
     "debug": "^4.3.4",
     "js-yaml": "^4.1.0",
     "nconf": "^0.12.0",
-    "superagent": "^8.0.9",
     "winston": "^3.9.0",
     "winston-daily-rotate-file": "^4.7.1"
   },

package/src/config.js

@@ -24,8 +24,6 @@ const path = require('path');
 const nconf = require('nconf');
 nconf.formats.yaml = require('./lib/nconf-yaml');
 
-const superagent = require('superagent');
-
 /**
  * Default values for Logger
  */
@@ -50,8 +48,6 @@ const defaults = {
   }
 };
 
-
-
 /**
  * Config manager
  */
@@ -62,7 +58,7 @@ class Config {
   baseConfigDir;
   learnDirectoryAndFilename;
 
-  constructor() {
+  constructor () {
     this.extraAsync = [];
   }
 
@@ -78,7 +74,7 @@ class Config {
    * @param {Object} logging
    * @returns {Config} this
    */
-  initSync(options, logging) {
+  initSync (options, logging) {
     this.appName = options.appName;
     this.learnDirectoryAndFilename = getLearnFilename(options.appName, options.learnDirectory);
     this.baseFilesDir = options.baseFilesDir || process.cwd();
@@ -103,12 +99,12 @@ class Config {
     // memory must come first for config.set() to work without loading config files
     // 3. `process.env`
     // 4. `process.argv`
-    store.argv({parseValues: true}).env({parseValues: true, separator: '__'});
+    store.argv({ parseValues: true }).env({ parseValues: true, separator: '__' });
 
     // 5. Values in `${NODE_ENV}-config.yml` or from --config parameter
     let configFile;
     if (store.get('config')) {
-      configFile = store.get('config')
+      configFile = store.get('config');
     } else if (store.get('NODE_ENV')) {
       configFile = path.resolve(baseConfigDir, store.get('NODE_ENV') + '-config.yml');
     }
@@ -122,7 +118,7 @@ class Config {
 
     // load extra config files & plugins
     if (options.extras) {
-      for (let extra of options.extras) {
+      for (const extra of options.extras) {
         if (extra.file) {
           loadFile(extra.scope, extra.file);
           continue;
@@ -133,7 +129,7 @@ class Config {
           continue;
         }
         if (extra.data) {
-          const conf = extra.key ? {[extra.key]: extra.data} : extra.data;
+          const conf = extra.key ? { [extra.key]: extra.data } : extra.data;
           store.use(extra.scope, { type: 'literal', store: conf });
           logger.debug('Loaded [' + extra.scope + '] from DATA: ' + (extra.key ? ' under [' + extra.key + ']' : ''));
           continue;
@@ -141,7 +137,7 @@ class Config {
         if (extra.url || extra.urlFromKey || extra.fileAsync) {
           // register scope in the chain to keep order of configs
           store.use(extra.scope, { type: 'literal', store: {} });
-          logger.debug('Booked [' + extra.scope +'] for async Loading ');
+          logger.debug('Booked [' + extra.scope + '] for async Loading ');
           this.extraAsync.push(extra);
           continue;
         }
@@ -154,7 +150,6 @@ class Config {
       }
     }
 
-
     // .end-1 load default and custom config from configs/default-config.json
     loadFile('default-file', path.resolve(baseConfigDir, 'default-config.yml'));
 
@@ -167,36 +162,34 @@ class Config {
 
     // --- helpers --/
 
-    function loadFile(scope, filePath) {
-
+    function loadFile (scope, filePath) {
       if (fs.existsSync(filePath)) {
-
-        if (filePath.endsWith('.js')) {  // JS file
+        if (filePath.endsWith('.js')) { // JS file
           const conf = require(filePath);
           store.use(scope, { type: 'literal', store: conf });
-        } else {   // JSON or YAML
-          const options = { file: filePath }
-          if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) { options.format = nconf.formats.yaml }
+        } else { // JSON or YAML
+          const options = { file: filePath };
+          if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) { options.format = nconf.formats.yaml; }
           store.file(scope, options);
         }
 
-        logger.debug('Loaded [' + scope + '] from file: ' + filePath)
+        logger.debug('Loaded [' + scope + '] from file: ' + filePath);
       } else {
         logger.debug('Cannot find file: ' + filePath + ' for scope [' + scope + ']');
       }
     }
   }
 
-  async initASync() {
+  async initASync () {
     const store = this.store;
     const logger = this.logger;
     const baseConfigDir = this.baseConfigDir;
     const baseFilesDir = this.baseFilesDir;
 
-    async function loadUrl(scope, key, url) {
+    async function loadUrl (scope, key, url) {
       if (typeof url === 'undefined' || url === null) {
-          logger.warn('Null or Undefined Url for [' + scope +']');
-          return;
+        logger.warn('Null or Undefined Url for [' + scope + ']');
+        return;
       }
 
       let res = null;
@@ -205,13 +198,13 @@ class Config {
       } else {
         res = await loadFromUrl(url);
       }
-      const conf = key ? {[key]: res} : res;
+      const conf = key ? { [key]: res } : res;
       store.add(scope, { type: 'literal', store: conf });
       logger.debug('Loaded [' + scope + '] from URL: ' + url + (key ? ' under [' + key + ']' : ''));
     }
 
     // load remote config files
-    for (let extra of this.extraAsync) {
+    for (const extra of this.extraAsync) {
       if (extra.url) {
         await loadUrl(extra.scope, extra.key, extra.url);
         continue;
@@ -231,11 +224,11 @@ class Config {
       if (extra.fileAsync) {
         const filePath = path.resolve(baseConfigDir, extra.fileAsync);
 
-        if (! fs.existsSync(filePath)) {
+        if (!fs.existsSync(filePath)) {
           logger.warn('Cannot find file: ' + filePath + ' for scope [' + extra.scope + ']');
           continue;
         }
-        if (! filePath.endsWith('.js')) {
+        if (!filePath.endsWith('.js')) {
           logger.warn('Cannot only load .js file: ' + filePath + ' for scope [' + extra.scope + ']');
           continue;
         }
@@ -257,8 +250,8 @@ class Config {
    * @param {string} key
    * @returns {boolean}
    */
-  has(key) {
-    if (! this.store) { throw(new Error('Config not yet initialized'))}
+  has (key) {
+    if (!this.store) { throw (new Error('Config not yet initialized')); }
     const value = this.store.get(key);
     return (typeof value !== 'undefined');
   }
@@ -267,10 +260,10 @@ class Config {
    * Retreive value
    * @param {string} [key] if no key is provided all the config is returned
    */
-  get(key) {
-    if (! this.store) { throw(new Error('Config not yet initialized'))}
+  get (key) {
+    if (!this.store) { throw (new Error('Config not yet initialized')); }
     const value = this.store.get(key);
-    if (typeof value === 'undefined') this.logger.debug('get: [' + key +'] is undefined');
+    if (typeof value === 'undefined') this.logger.debug('get: [' + key + '] is undefined');
     learn(this.learnDirectoryAndFilename, key);
     return value;
   }
@@ -279,20 +272,20 @@ class Config {
    * Retreive value and store info that applies
    * @param {string} key
    */
-  getScopeAndValue(key) {
-    if (! this.store) { throw(new Error('Config not yet initialized'))};
-    for (let scopeName of Object.keys(this.store.stores)) {
+  getScopeAndValue (key) {
+    if (!this.store) { throw (new Error('Config not yet initialized')); }
+    for (const scopeName of Object.keys(this.store.stores)) {
       const store = this.store.stores[scopeName];
       const value = store.get(key);
       if (typeof value !== 'undefined') {
         const res = {
-          value: value,
+          value,
           scope: scopeName
-        }
+        };
         if (store.type === 'file') {
-          res.info = 'From file: ' + store.file
+          res.info = 'From file: ' + store.file;
         } else {
-          info = 'Type: ' + store.type
+          res.info = 'Type: ' + store.type;
         }
         return res;
       }
@@ -305,8 +298,8 @@ class Config {
    * @param {string} key
    * @param {Object} value
    */
-  set(key, value) {
-    if (! this.store) { throw(new Error('Config not yet initialized'))}
+  set (key, value) {
+    if (!this.store) { throw (new Error('Config not yet initialized')); }
     this.store.set(key, value);
   }
 
@@ -314,7 +307,7 @@ class Config {
    * Inject Test Config and override any other option
    * @param {Object} configObject;
    */
-  injectTestConfig(configObject) {
+  injectTestConfig (configObject) {
     this.replaceScopeConfig('test', configObject);
   }
 
@@ -323,12 +316,11 @@ class Config {
    * @param {string} scope;
    * @param {Object} configObject;
    */
-  replaceScopeConfig(scope, configObject) {
-    if (! this.store) { throw(new Error('Config not yet initialized'))}
-    this.logger.debug('Replace ['+ scope + '] with: ', configObject);
-    this.store.add(scope, {type: 'literal', store: configObject});
+  replaceScopeConfig (scope, configObject) {
+    if (!this.store) { throw (new Error('Config not yet initialized')); }
+    this.logger.debug('Replace [' + scope + '] with: ', configObject);
+    this.store.add(scope, { type: 'literal', store: configObject });
   }
-
 }
 
 module.exports = Config;
@@ -338,12 +330,12 @@ module.exports = Config;
 const FILE_PROTOCOL = 'file://';
 const FILE_PROTOCOL_LENGTH = FILE_PROTOCOL.length;
 
-async function loadFromUrl(url) {
-  const res = await superagent.get(url);
-  return res.body;
+async function loadFromUrl (url) {
+  const res = await fetch(url);
+  return res.json();
 }
 
-function loadFromFile(fileUrl, baseFilesDir) {
+function loadFromFile (fileUrl, baseFilesDir) {
   const filePath = stripFileProtocol(fileUrl);
 
   if (isRelativePath(filePath)) {
@@ -358,69 +350,65 @@ function loadFromFile(fileUrl, baseFilesDir) {
   return res;
 }
 
-
-function isFileUrl(filePath) {
+function isFileUrl (filePath) {
   return filePath.startsWith(FILE_PROTOCOL);
 }
 
-function isRelativePath(filePath) {
+function isRelativePath (filePath) {
   return !path.isAbsolute(filePath);
 }
 
-function stripFileProtocol(filePath) {
+function stripFileProtocol (filePath) {
   return filePath.substring(FILE_PROTOCOL_LENGTH);
 }
 
-
 // -------- learning mode ------- //
 
-function getLearnFilename(appName, learnDirectory) {
-  if (! learnDirectory) return;
+function getLearnFilename (appName, learnDirectory) {
+  if (!learnDirectory) return;
   let i = 0;
   let res;
   do {
-    res = path.join(learnDirectory, appName + i );
+    res = path.join(learnDirectory, appName + i);
     i++;
-  } while(fs.existsSync(res + '-config.json'));
+  } while (fs.existsSync(res + '-config.json'));
   return res;
 }
 
-function learn(learnDirectoryAndFilename, key) {
+function learn (learnDirectoryAndFilename, key) {
   if (learnDirectoryAndFilename) {
     const caller_line = (new Error()).stack.split('\n')[3]; // get callee name and line
-    const index = caller_line.indexOf("at ");
-    const str = key + ';' + caller_line.slice(index+3, caller_line.length) + '\n';
+    const index = caller_line.indexOf('at ');
+    const str = key + ';' + caller_line.slice(index + 3, caller_line.length) + '\n';
     fs.appendFileSync(learnDirectoryAndFilename + '-calls.csv', str);
   }
 }
 
-function saveConfig(learnDirectoryAndFilename, store) {
+function saveConfig (learnDirectoryAndFilename, store) {
   if (learnDirectoryAndFilename) {
     const filename = learnDirectoryAndFilename + '-config.json';
-    fs.writeFileSync(filename, JSON.stringify({stores: store.stores, config: store.get()}, null, 2));
+    fs.writeFileSync(filename, JSON.stringify({ stores: store.stores, config: store.get() }, null, 2));
   }
 }
 
-
 /**
  * @typedef ConfigFile
  * @property {string} scope - scope for nconf hierachical load
  * @property {string} file - the config file (.yml, .json, .js)
  */
 
- /**
+/**
  * @typedef ConfigPlugin
  * @property {Object} plugin
  * @property {Function} plugin.load - a function that takes the "nconf store" as argument and returns the "name" of the plugin
  */
 
- /**
+/**
  * @typedef ConfigData
  * @property {string} scope - scope for nconf hierachical load
  * @property {string} [key] - (optional) key to load result of url. If null loaded at root of the config
  * @property {object} data - the data to load
 
-
 /**
  * @typedef ConfigRemoteURL
  * @property {string} scope - scope for nconf hierachical load

package/src/index.d.ts

@@ -0,0 +1,210 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/pryv-boiler/blob/master/LICENSE)
+ */
+
+export = boiler;
+
+declare const boiler: {
+  /**
+   * Get a Logger
+   * @param name - The name of the logger
+   */
+  getLogger: (name?: string) => boiler.Logger;
+
+  /**
+   * Preferred way to get the configuration.
+   * Waits until the configuration is fully initialized.
+   */
+  getConfig: () => Promise<boiler.Config>;
+
+  /**
+   * Get the configuration.
+   * If the configuration is not fully initialized, throws an error (or warns if warnOnly is true).
+   * @param warnOnly - Only warns about potential misuse of config instead of throwing
+   */
+  getConfigUnsafe: (warnOnly?: boolean) => boiler.Config;
+
+  /**
+   * Initialize Boiler. Should be called just once when starting an app.
+   * @param options - Initialization options
+   * @param fullyLoadedCallback - Called when the config is fully loaded
+   */
+  init: (options: boiler.InitOptions, fullyLoadedCallback?: (config: boiler.Config) => void) => typeof boiler;
+};
+
+declare namespace boiler {
+  interface InitOptions {
+    /** The name of the application, used by Logger and debug */
+    appName: string;
+    /** Directory to use to look for configs (default, env) */
+    baseConfigDir?: string;
+    /** Directory to use for `file://` relative paths */
+    baseFilesDir?: string;
+    /** Array of extra config sources to load */
+    extraConfigs?: Array<ConfigFile | ConfigPlugin | ConfigPluginAsync | ConfigData | ConfigRemoteURL | ConfigRemoteURLFromKey | ConfigFileAsync>;
+  }
+
+  interface ConfigFile {
+    /** Scope for nconf hierarchical load */
+    scope: string;
+    /** The config file path (.yml, .json, .js) */
+    file: string;
+  }
+
+  interface ConfigFileAsync {
+    /** Scope for nconf hierarchical load */
+    scope: string;
+    /** The async config file path (.js that exports an async function) */
+    fileAsync: string;
+  }
+
+  interface ConfigPlugin {
+    plugin: {
+      /** Function that takes the Config instance and returns the plugin name */
+      load: (config: Config) => string;
+    };
+  }
+
+  interface ConfigPluginAsync {
+    pluginAsync: {
+      /** Async function that takes the Config instance and returns the plugin name */
+      load: (config: Config) => Promise<string>;
+    };
+  }
+
+  interface ConfigData {
+    /** Scope for nconf hierarchical load */
+    scope: string;
+    /** Key to load data under. If null, loaded at root of the config */
+    key?: string;
+    /** The data to load */
+    data: object;
+  }
+
+  interface ConfigRemoteURL {
+    /** Scope for nconf hierarchical load */
+    scope: string;
+    /** Key to load result of URL under. If null, loaded at root of the config */
+    key?: string;
+    /** The URL to the config definition */
+    url: string;
+  }
+
+  interface ConfigRemoteURLFromKey {
+    /** Scope for nconf hierarchical load */
+    scope: string;
+    /** Key to load result of URL under. If null, override */
+    key?: string;
+    /** Retrieve URL from config matching this key */
+    urlFromKey: string;
+  }
+
+  interface ScopeAndValue {
+    value: unknown;
+    scope: string;
+    info: string;
+  }
+
+  class Config {
+    /** The nconf store instance */
+    store: unknown;
+    /** The logger instance for config */
+    logger: Logger;
+    /** Base directory for config files */
+    baseConfigDir: string;
+
+    /**
+     * Return true if key has a value
+     * @param key - The config key to check
+     */
+    has(key: string): boolean;
+
+    /**
+     * Retrieve value
+     * @param key - The config key. If no key is provided, all the config is returned
+     */
+    get(key?: string): unknown;
+    get<T>(key: string): T | undefined;
+
+    /**
+     * Retrieve value and store info that applies
+     * @param key - The config key
+     */
+    getScopeAndValue(key: string): ScopeAndValue | null;
+
+    /**
+     * Set value
+     * @param key - The config key
+     * @param value - The value to set
+     */
+    set(key: string, value: unknown): void;
+
+    /**
+     * Inject test config and override any other option
+     * @param configObject - The config object to inject for testing
+     */
+    injectTestConfig(configObject: object): void;
+
+    /**
+     * Replace a scope config set
+     * @param scope - The scope to replace
+     * @param configObject - The new config object for the scope
+     */
+    replaceScopeConfig(scope: string, configObject: object): void;
+  }
+
+  class Logger {
+    /** The name of this logger */
+    name: string;
+    /** The parent logger, if any */
+    parent: Logger | null;
+
+    /**
+     * Log a message at the specified level
+     * @param level - The log level
+     * @param message - The log message
+     * @param context - Additional context
+     */
+    log(level: string, message: string, ...context: unknown[]): void;
+
+    /**
+     * Log an info message
+     * @param message - The log message
+     * @param context - Additional context
+     */
+    info(message: string, ...context: unknown[]): void;
+
+    /**
+     * Log a warning message
+     * @param message - The log message
+     * @param context - Additional context
+     */
+    warn(message: string, ...context: unknown[]): void;
+
+    /**
+     * Log an error message
+     * @param message - The log message
+     * @param context - Additional context
+     */
+    error(message: string, ...context: unknown[]): void;
+
+    /**
+     * Log a debug message
+     * @param message - The log message
+     * @param context - Additional context
+     */
+    debug(message: string, ...context: unknown[]): void;
+
+    /**
+     * Get a "sub" Logger
+     * @param name - The name of the child logger
+     */
+    getLogger(name: string): Logger;
+
+    /**
+     * Dump objects with file and line for debugging
+     */
+    inspect(...args: unknown[]): void;
+  }
+}

package/src/index.js

@@ -25,14 +25,14 @@ const boiler = {
    * Prefered way to get the configuration
    * @returns {Promise<Config>}
    */
-  getConfig: getConfig,
+  getConfig,
   /**
    * get the configuration.
    * If the configuration is not fully initialized throw an error
    * @param {boolean} warnOnly - Only warns about potential misuse of config
    * @returns {Config}
    */
-  getConfigUnsafe: getConfigUnsafe,
+  getConfigUnsafe,
 
   /**
    * Init Boiler, should be called just once when starting an APP
@@ -42,7 +42,7 @@ const boiler = {
    * @param {Array<ConfigFile|ConfigRemoteURL|ConfigRemoteURLFromKey|ConfigPlugin>} [options.extraConfigs] - (optional) and array of extra files to load
    * @param {Function} [fullyLoadedCallback] - (optional) called when the config is fully loaded
    */
-  init: init
+  init
 };
 
 let logger;

package/src/logging.js

@@ -13,17 +13,17 @@ let customLoggerInstance = null;
 // ------ winston formating
 
 /**
- * 
- * @param {Object} options 
+ *
+ * @param {Object} options
  * @param {boolean} options.color - set to true to have colors
  * @param {boolean} options.time - set to true to for timestamp
  * @param {boolean} options.align - set to true to allign logs items
  */
-function generateFormat(options) {
+function generateFormat (options) {
   const formats = [];
   if (options.color) {
     formats.push(winston.format.colorize());
-  } 
+  }
   if (options.time) {
     formats.push(winston.format.timestamp());
   }
@@ -31,13 +31,13 @@ function generateFormat(options) {
     formats.push(winston.format.align());
   }
 
-  function printf(info) {
+  function printf (info) {
     const {
       timestamp, level, message, ...args
     } = info;
-    
-    let items = info[Symbol.for('splat')] || {};
-    
+
+    let items = info[Symbol.for('splat')] || {};
+
     let itemStr = '';
     if (items.length > 0) {
       let skip = false;
@@ -45,17 +45,14 @@ function generateFormat(options) {
         if (typeof items[0] === 'undefined') {
           skip = true;
         } else {
-          if (items[0] && items[0].context) { 
+          if (items[0] && items[0].context) {
             items = items[0].context;
-          } 
+          }
         }
       }
-      if (! skip)
-        itemStr = util.inspect(items, {depth: 10, colors: true});
+      if (!skip) { itemStr = util.inspect(items, { depth: 10, colors: true }); }
     }
 
-
-
     const line = `[${level}]: ${message} ${itemStr}`;
 
     if (options.time) {
@@ -69,12 +66,10 @@ function generateFormat(options) {
   return winston.format.combine(...formats);
 }
 
-
-
 /**
  * Helper to pass log instructions to winston
  */
-function globalLog(level, key, message, context) { 
+function globalLog (level, key, message, context) {
   const text = `[${key}] ${message}`;
   if (winstonInstance) {
     winstonInstance[level](text, context);
@@ -86,56 +81,60 @@ function globalLog(level, key, message, context) {
   }
 }
 
-
 /**
  * Config initialize Logger right after beeing loaded
  * This is done by config Only
- */ 
-async function initLoggerWithConfig(config) { 
+ */
+async function initLoggerWithConfig (config) {
   if (winstonInstance) {
-    throw new Error("Logger was already initialized");
+    throw new Error('Logger was already initialized');
   }
   // console
   winstonInstance = winston.createLogger({ });
   const logConsole = config.get('logs:console');
-  let isSilent = ! config.get('logs:console:active');
+  let isSilent = !config.get('logs:console:active');
 
   // LOGS env var can override settings
   if (process.env.LOGS) {
     logConsole.level = process.env.LOGS;
     isSilent = false;
-  } 
-
+  }
 
-  const format = generateFormat(logConsole.format)
-  const myconsole = new winston.transports.Console({ format: format , level: logConsole.level, silent: isSilent});
+  const consoleFormat = generateFormat(logConsole.format);
+  const myconsole = new winston.transports.Console({ format: consoleFormat, level: logConsole.level, silent: isSilent });
   winstonInstance.add(myconsole);
-  
-  rootLogger.debug((isSilent ?  '** silent ** ' : '') + 'Console with level: ', logConsole.level);
+
+  rootLogger.debug((isSilent ? '** silent ** ' : '') + 'Console with level: ', logConsole.level);
 
   // file
   const logFile = config.get('logs:file');
   if (config.get('logs:file:active')) {
+    const fileFormat = winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.json()
+    );
+
     rootLogger.debug('File active: ' + logFile.path);
     if (logFile.rotation.isActive) {
-      const transport = new winston.transports.DailyRotateFile({
+      const rotatedFiles = new winston.transports.DailyRotateFile({
         filename: logFile.path + '.%DATE%',
         datePattern: 'YYYY-MM-DD',
         zippedArchive: true,
+        level: logFile.level,
         maxFiles: logFile.rotation.days ? logFile.rotation.days + 'd' : null,
+        format: fileFormat
       });
+      winstonInstance.add(rotatedFiles);
     } else {
-      const files = new winston.transports.File({ 
+      const files = new winston.transports.File({
         filename: logFile.path,
         level: logFile.level,
-        maxsize: logFile.maxFileBytes,
-        maxFiles: logFile.maxNbFiles,
-        timestamp: true,
-        json: false
+        maxSize: logFile.maxFileBytes || '10m',
+        maxFiles: logFile.maxNbFiles || '14d',
+        format: fileFormat
       });
       winstonInstance.add(files);
     }
-    
   }
 
   // custom
@@ -144,17 +143,23 @@ async function initLoggerWithConfig(config) {
     await customLoggerInstance.init(config.get('logs:custom:settings'));
   }
 
-  rootLogger.debug('Logger Initialized');
-};
-
+  // catch all errors.
+  if (!config.get('logs:skipUncaughtException')) {
+    process.on('uncaughtException', function (err) {
+      rootLogger.error('UncaughtException', { message: err.message, name: err.name, stack: err.stack });
+      throw err;
+    });
+  }
 
+  rootLogger.debug('Logger Initialized');
+}
 
-// --------------- debug utils 
+// --------------- debug utils
 
 /**
  * Dump objects with file and line
  */
-function inspect() {
+function inspect () {
   let line = '';
   try {
     throw new Error();
@@ -162,38 +167,37 @@ function inspect() {
     line = e.stack.split(' at ')[2].trim();
   }
   let res = '\n * dump at: ' + line;
-  for (var i = 0; i < arguments.length; i++) {
+  for (let i = 0; i < arguments.length; i++) {
     res += '\n' + i + ' ' + util.inspect(arguments[i], true, 10, true) + '\n';
   }
   return res;
-};
-
+}
 
-function setGlobalName(name) {
+function setGlobalName (name) {
   // create root logger
   rootLogger = new Logger(name, null);
   rootLogger.debug('setGlobalName: ' + name);
 }
 
-
 class Logger {
   parent; // eventual parent
   debugInstance; // debug instance
 
-  constructor(name, parent) {
+  constructor (name, parent) {
     this.name = name;
     this.parent = parent;
-    this.debugInstance =  debugModule('pryv:' + this._name());
+    this.debugInstance = debugModule('pryv:' + this._name());
   }
+
   /**
    * Private
    */
-  _name() {
+  _name () {
     if (this.parent) return this.parent._name() + ':' + this.name;
     return this.name;
   }
 
-  log() {
+  log () {
     const level = arguments[0];
     const message = hideSensitiveValues(arguments[1]);
     const context = [];
@@ -204,9 +208,9 @@ class Logger {
       context.push(inspectAndHide(arguments[i]));
     }
     if (context.length === 1) {
-      meta = {context:  context[0]};
+      meta = { context: context[0] };
     } else if (context.length > 1) {
-      meta = {context:  context};
+      meta = { context };
     }
     globalLog(level, this._name(), message, meta);
   }
@@ -214,69 +218,69 @@ class Logger {
   info () { this.log('info', ...arguments); }
   warn () { this.log('warn', ...arguments); }
   error () { this.log('error', ...arguments); }
-  debug () { 
+  debug () {
     if (winstonInstance) {
-      this.log('debug', ...arguments); 
+      this.log('debug', ...arguments);
     }
-    this.debugInstance(...arguments); 
-  } 
+    this.debugInstance(...arguments);
+  }
 
   /**
    * get a "sub" Logger
-   * @param {Logger} name 
+   * @param {Logger} name
    * @returns {Logger}
    */
   getLogger (name) {
     return new Logger(name, this);
   }
 
-  inspect() { inspect(...arguments); }
+  inspect () { inspect(...arguments); }
 }
 
 /**
  * Get a new logger, or root loggger if no name is provided
- * @param {string} [name]  
+ * @param {string} [name]
  * @returns {Logger}
  */
-function getLogger(name) {
-  if (! rootLogger) {
-    throw new Error('Initalize boiler before using logger')
+function getLogger (name) {
+  if (!rootLogger) {
+    throw new Error('Initalize boiler before using logger');
   }
-  if(! name) {
+  if (!name) {
     return rootLogger;
   }
   return rootLogger.getLogger(name);
 }
 
 module.exports = {
-  getLogger: getLogger,
-  setGlobalName: setGlobalName,
-  initLoggerWithConfig: initLoggerWithConfig
-}
+  getLogger,
+  setGlobalName,
+  initLoggerWithConfig
+};
 
 // ----------------- Hide sensite data -------------------- //
 
-function inspectAndHide(o) {
+function inspectAndHide (o) {
   if (typeof o === 'undefined') return o;
   if (o instanceof Error) return o;
   return _inspectAndHide(JSON.parse(JSON.stringify(o))); // clone and remove circular
 }
 
-function _inspectAndHide(o) {
+function _inspectAndHide (o) {
   if (typeof o === 'string') {
     return hideSensitiveValues(o);
   }
   if (o !== null && typeof o === 'object') {
     if (Array.isArray(o)) {
       const res = [];
-      for (let item of o) {
+      for (const item of o) {
         res.push(inspectAndHide(item));
       }
       return res;
     }
 
     const res = {};
-    for (let key of Object.keys(o)) {
+    for (const key of Object.keys(o)) {
       if (['password', 'passwordHash', 'newPassword'].includes(key)) {
         res[key] = '(hidden password)';
       } else {
@@ -288,7 +292,6 @@ function _inspectAndHide(o) {
   return o;
 }
 
-
 // Hides sensitive values (auth tokens and passwords) in log messages
 function hideSensitiveValues (msg) {
   if (typeof msg !== 'string') return msg;
@@ -297,8 +300,8 @@ function hideSensitiveValues (msg) {
   const mask = '(hidden)';
 
   const res = msg
-    .replace(tokenRegexp, 'auth='+mask)
-    .replace(passwordRegexp, '$1='+mask);
-  
+    .replace(tokenRegexp, 'auth=' + mask)
+    .replace(passwordRegexp, '$1=' + mask);
+
   return res;
-}
+}