@percy/logger 1.0.0-beta.7 → 1.0.0-beta.73

package/README.md

@@ -1,58 +1,93 @@
 # @percy/logger
 
-Common [winston](https://github.com/winstonjs/winston) logger used throughout the Percy CLI.
+Common logger used throughout the Percy CLI and SDKs.
+
+- [Usage](#usage)
+  - [`logger()`](#loggerdebug)
+  - [`logger.loglevel()`](#loggerloglevel)
+  - [`logger.format()`](#loggerformat)
+  - [`logger.query()`](#loggerquery)
 
 ## Usage
 
 ``` js
-import log from '@percy/logger'
+import logger from '@percy/logger'
+
+const log = logger('foobar')
 
 log.info('info message')
 log.error('error message')
 log.warn('warning message')
 log.debug('debug message')
+log.deprecated('deprecation message')
+```
+
+### `logger([debug])`
+
+Creates a group of logging functions that will be associated with the provided `debug` label. When
+debug logging is enabled, this label is printed with the `[percy:*]` label and can be filtered via
+the `PERCY_DEBUG` environment variable.
+
+``` js
+PERCY_DEBUG="one:*,*:a,-*:b"
+
+logger.loglevel('debug')
+
+logger('one').debug('test')
+logger('one:a').debug('test')
+logger('one:b').debug('test')
+logger('one:c').debug('test')
+logger('two').debug('test')
+logger('two:a').debug('test')
+
+// only logs from the matching debug string are printed
+//=> [percy:one] test
+//=> [percy:one:a] test
+//=> [percy:one:c] test
+//=> [percy:two:a] test
 ```
 
-### `#loglevel([level][, flags])`
+### `logger.loglevel([level][, flags])`
 
-Sets or retrieves the log level of the console transport. If the second argument is provided,
-`level` is treated as a fallback when all logging flags are `false`. When no arguments are provided,
-the method will return the current log level of the console transport.
+Sets or retrieves the log level of the shared logger. If the second argument is provided, `level` is
+treated as a fallback when all logging flags are `false`. When no arguments are provided, the method
+will return the current log level of the shared logger.
 
 ``` js
-log.loglevel('info', { verbose: true })
-log.loglevel() === 'debug'
+logger.loglevel('info', { verbose: true })
+logger.loglevel() === 'debug'
 
-log.loglevel('info', { quiet: true })
-log.loglevel() === 'warn'
+logger.loglevel('info', { quiet: true })
+logger.loglevel() === 'warn'
 
-log.loglevel('info', { silent: true })
-log.loglevel() === 'silent'
+logger.loglevel('info', { silent: true })
+logget.loglevel() === 'silent'
 
-log.loglevel('info')
-log.loglevel() === 'info'
+logger.loglevel('info')
+logger.loglevel() === 'info'
 ```
 
-### `#error(errorOrMessage)`
+### `logger.format(message, debug[, level])`
 
-Patched `#error()` method that handles `Error` instance's and similar error objects. When
-`#loglevel()` is equal to `debug`, the `Error` instance's stack trace is logged.
+Returns a formatted `message` depending on the provided level and logger's own log level. When
+debugging, the `debug` label is added to the prepended `[percy:*]` label.
 
 ``` js
-log.loglevel('debug')
-log.error(new Error('example'))
-// [percy] Error: example
-//   at example:2:10
-//   ...
+logger.format('foobar', 'test')
+//=> [percy] foobar
+
+logger.loglevel('debug')
+logger.format('foobar', 'test', warn')
+//=> [percy:test] foobar (yellow for warnings)
 ```
 
-### `#query(options)`
+### `logger.query(filter)`
 
-Patched `#query()` method that is promisified and allows a `filter` function option.
+Returns an array of logs matching the provided filter function.
 
 ``` js
-let logs = await log.query({
-  filter: log => true
-  // ...other query options (see winston docs)
+let logs = logger.query(log => {
+  return log.level === 'debug' &&
+    log.message.match(/foobar/)
 })
 ```

package/dist/browser.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.PercyBrowserLogger = void 0;
+
+var _util = require("./util");
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class PercyBrowserLogger extends _logger.default {
+  write(level, message) {
+    let out = ['warn', 'error'].includes(level) ? level : 'log';
+    let colors = [];
+    message = message.replace(_util.ANSI_REG, (_, ansi) => {
+      colors.push(`color:${_util.ANSI_COLORS[ansi] || 'inherit'}`);
+      return '%c';
+    });
+    console[out](message, ...colors);
+  }
+
+  progress() {
+    console.error('The log.progress() method is not supported in browsers');
+  }
+
+}
+
+exports.PercyBrowserLogger = PercyBrowserLogger;
+var _default = PercyBrowserLogger;
+exports.default = _default;

package/dist/bundle.js

@@ -0,0 +1,481 @@
+(function() {
+  (function (exports) {
+  	'use strict';
+
+  	const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
+  	process.env = process.env || {};
+  	process.env.__PERCY_BROWSERIFIED__ = true;
+
+  	function getAugmentedNamespace(n) {
+  		if (n.__esModule) return n;
+  		var a = Object.defineProperty({}, '__esModule', {value: true});
+  		Object.keys(n).forEach(function (k) {
+  			var d = Object.getOwnPropertyDescriptor(n, k);
+  			Object.defineProperty(a, k, d.get ? d : {
+  				enumerable: true,
+  				get: function () {
+  					return n[k];
+  				}
+  			});
+  		});
+  		return a;
+  	}
+
+  	const {
+  	  assign,
+  	  entries
+  	} = Object; // matches ansi escape sequences
+
+  	const ANSI_REG = new RegExp('[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', 'g'); // color names by ansi escape code
+
+  	const ANSI_COLORS = {
+  	  '91m': 'red',
+  	  '32m': 'green',
+  	  '93m': 'yellow',
+  	  '34m': 'blue',
+  	  '95m': 'magenta',
+  	  '90m': 'grey'
+  	}; // colorize each line of a string using an ansi escape sequence
+
+  	const LINE_REG = /^.*$/gm;
+
+  	function colorize(code, str) {
+  	  return str.replace(LINE_REG, line => `\u001b[${code}${line}\u001b[39m`);
+  	} // map ansi colors to bound colorize functions
+
+
+  	const colors = entries(ANSI_COLORS).reduce((colors, _ref) => {
+  	  let [code, name] = _ref;
+  	  return assign(colors, {
+  	    [name]: colorize.bind(null, code)
+  	  });
+  	}, {});
+
+  	function _defineProperty(obj, key, value) {
+  	  if (key in obj) {
+  	    Object.defineProperty(obj, key, {
+  	      value: value,
+  	      enumerable: true,
+  	      configurable: true,
+  	      writable: true
+  	    });
+  	  } else {
+  	    obj[key] = value;
+  	  }
+
+  	  return obj;
+  	}
+
+  	const URL_REGEXP = /\bhttps?:\/\/[^\s/$.?#].[^\s]*\b/i;
+  	const LOG_LEVELS = {
+  	  debug: 0,
+  	  info: 1,
+  	  warn: 2,
+  	  error: 3
+  	}; // A PercyLogger instance retains logs in-memory for quick lookups while also writing log
+  	// messages to stdout and stderr depending on the log level and debug string.
+
+  	class PercyLogger {
+  	  // default log level
+  	  // namespace regular expressions used to determine which debug logs to write
+  	  // in-memory store for logs and meta info
+  	  // track deprecations to limit noisy logging
+  	  // static vars can be overriden for testing
+  	  // Handles setting env var values and returns a singleton
+  	  constructor() {
+  	    _defineProperty(this, "level", 'info');
+
+  	    _defineProperty(this, "namespaces", {
+  	      include: [/^.*?$/],
+  	      exclude: []
+  	    });
+
+  	    _defineProperty(this, "messages", new Set());
+
+  	    _defineProperty(this, "deprecations", new Set());
+
+  	    let {
+  	      instance = this
+  	    } = this.constructor;
+
+  	    if (process.env.PERCY_DEBUG) {
+  	      instance.debug(process.env.PERCY_DEBUG);
+  	    } else if (process.env.PERCY_LOGLEVEL) {
+  	      instance.loglevel(process.env.PERCY_LOGLEVEL);
+  	    }
+
+  	    this.constructor.instance = instance;
+  	    return instance;
+  	  } // Change log level at any time or return the current log level
+
+
+  	  loglevel(level) {
+  	    if (level) this.level = level;
+  	    return this.level;
+  	  } // Change namespaces by generating an array of namespace regular expressions from a
+  	  // comma separated debug string
+
+
+  	  debug(namespaces) {
+  	    if (this.namespaces.string === namespaces) return;
+  	    this.namespaces.string = namespaces;
+  	    namespaces = namespaces.split(/[\s,]+/).filter(Boolean);
+  	    if (!namespaces.length) return this.namespaces;
+  	    this.loglevel('debug');
+  	    this.namespaces = namespaces.reduce((namespaces, ns) => {
+  	      ns = ns.replace(/:?\*/g, m => m[0] === ':' ? ':?.*?' : '.*?');
+
+  	      if (ns[0] === '-') {
+  	        namespaces.exclude.push(new RegExp('^' + ns.substr(1) + '$'));
+  	      } else {
+  	        namespaces.include.push(new RegExp('^' + ns + '$'));
+  	      }
+
+  	      return namespaces;
+  	    }, {
+  	      string: namespaces,
+  	      include: [],
+  	      exclude: []
+  	    });
+  	  } // Creates a new log group and returns level specific functions for logging
+
+
+  	  group(name) {
+  	    return Object.keys(LOG_LEVELS).reduce((group, level) => Object.assign(group, {
+  	      [level]: this.log.bind(this, name, level)
+  	    }), {
+  	      deprecated: this.deprecated.bind(this, name),
+  	      shouldLog: this.shouldLog.bind(this, name),
+  	      progress: this.progress.bind(this, name),
+  	      format: this.format.bind(this, name),
+  	      loglevel: this.loglevel.bind(this),
+  	      stdout: this.constructor.stdout,
+  	      stderr: this.constructor.stderr
+  	    });
+  	  } // Query for a set of logs by filtering the in-memory store
+
+
+  	  query(filter) {
+  	    return Array.from(this.messages).filter(filter);
+  	  } // Formats messages before they are logged to stdio
+
+
+  	  format(debug, level, message, elapsed) {
+  	    let label = 'percy';
+  	    let suffix = '';
+
+  	    if (arguments.length === 1) {
+  	      // format(message)
+  	      [debug, message] = [null, debug];
+  	    } else if (arguments.length === 2) {
+  	      // format(debug, message)
+  	      [level, message] = [null, level];
+  	    }
+
+  	    if (this.level === 'debug') {
+  	      // include debug info in the label
+  	      if (debug) label += `:${debug}`; // include elapsed time since last log
+
+  	      if (elapsed != null) {
+  	        suffix = ' ' + colors.grey(`(${elapsed}ms)`);
+  	      }
+  	    }
+
+  	    label = colors.magenta(label);
+
+  	    if (level === 'error') {
+  	      // red errors
+  	      message = colors.red(message);
+  	    } else if (level === 'warn') {
+  	      // yellow warnings
+  	      message = colors.yellow(message);
+  	    } else if (level === 'info' || level === 'debug') {
+  	      // blue info and debug URLs
+  	      message = message.replace(URL_REGEXP, colors.blue('$&'));
+  	    }
+
+  	    return `[${label}] ${message}${suffix}`;
+  	  } // Replaces the current line with a log message
+
+
+  	  progress(debug, message, persist) {
+  	    if (!this.shouldLog(debug, 'info')) return;
+  	    let {
+  	      stdout
+  	    } = this.constructor;
+
+  	    if (stdout.isTTY || !this._progress) {
+  	      message && (message = this.format(debug, message));
+  	      if (stdout.isTTY) stdout.cursorTo(0);else message && (message = message + '\n');
+  	      if (message) stdout.write(message);
+  	      if (stdout.isTTY) stdout.clearLine(1);
+  	    }
+
+  	    this._progress = !!message && {
+  	      message,
+  	      persist
+  	    };
+  	  } // Returns true or false if the level and debug group can write messages to stdio
+
+
+  	  shouldLog(debug, level) {
+  	    return LOG_LEVELS[level] != null && LOG_LEVELS[level] >= LOG_LEVELS[this.level] && !this.namespaces.exclude.some(ns => ns.test(debug)) && this.namespaces.include.some(ns => ns.test(debug));
+  	  } // Ensures that deprecation messages are not logged more than once
+
+
+  	  deprecated(debug, message, meta) {
+  	    if (this.deprecations.has(message)) return;
+  	    this.deprecations.add(message);
+  	    this.log(debug, 'warn', `Warning: ${message}`, meta);
+  	  } // Returns true if a socket is present and ready
+
+
+  	  get isRemote() {
+  	    var _this$socket;
+
+  	    return ((_this$socket = this.socket) === null || _this$socket === void 0 ? void 0 : _this$socket.readyState) === 1;
+  	  } // Generic log method accepts a debug group, log level, log message, and optional meta
+  	  // information to store with the message and other info
+
+
+  	  log(debug, level, message) {
+  	    let meta = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  	    // message might be an error object
+  	    let isError = typeof message !== 'string' && (level === 'error' || level === 'debug');
+  	    let error = isError && message; // if remote, send logs there
+
+  	    if (this.isRemote) {
+  	      // serialize error messages
+  	      message = isError && 'stack' in error ? {
+  	        message: error.message,
+  	        stack: error.stack
+  	      } : message;
+  	      return this.socket.send(JSON.stringify({
+  	        log: [debug, level, message, {
+  	          remote: true,
+  	          ...meta
+  	        }]
+  	      }));
+  	    } // ensure the message is a string
+
+
+  	    message = isError && message.stack || message.message || message.toString(); // timestamp each log
+
+  	    let timestamp = Date.now();
+  	    let entry = {
+  	      debug,
+  	      level,
+  	      message,
+  	      meta,
+  	      timestamp
+  	    };
+  	    this.messages.add(entry); // maybe write the message to stdio
+
+  	    if (this.shouldLog(debug, level)) {
+  	      let elapsed = timestamp - (this.lastlog || timestamp);
+  	      if (isError && this.level !== 'debug') message = error.toString();
+  	      this.write(level, this.format(debug, error ? 'error' : level, message, elapsed));
+  	      this.lastlog = timestamp;
+  	    }
+  	  } // Writes a message to stdio based on the loglevel
+
+
+  	  write(level, message) {
+  	    var _this$_progress;
+
+  	    let {
+  	      stdout,
+  	      stderr
+  	    } = this.constructor;
+  	    let progress = stdout.isTTY && this._progress;
+
+  	    if (progress) {
+  	      stdout.cursorTo(0);
+  	      stdout.clearLine();
+  	    }
+
+  	    (level === 'info' ? stdout : stderr).write(message + '\n');
+  	    if (!((_this$_progress = this._progress) !== null && _this$_progress !== void 0 && _this$_progress.persist)) delete this._progress;else if (progress) stdout.write(progress.message);
+  	  } // Opens a socket logging connection
+
+
+  	  connect(socket) {
+  	    // send logging environment info
+  	    let PERCY_DEBUG = process.env.PERCY_DEBUG;
+  	    let PERCY_LOGLEVEL = process.env.PERCY_LOGLEVEL || this.loglevel();
+  	    socket.send(JSON.stringify({
+  	      env: {
+  	        PERCY_DEBUG,
+  	        PERCY_LOGLEVEL
+  	      }
+  	    })); // attach remote logging handler
+
+  	    socket.onmessage = _ref => {
+  	      let {
+  	        data
+  	      } = _ref;
+  	      let {
+  	        log,
+  	        logAll
+  	      } = JSON.parse(data);
+  	      if (logAll) logAll.forEach(e => this.messages.add(e));
+  	      if (log) this.log(...log);
+  	    }; // return a cleanup function
+
+
+  	    return () => {
+  	      socket.onmessage = null;
+  	    };
+  	  } // Connects to a remote logger
+
+
+  	  async remote(createSocket) {
+  	    let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  	    if (this.isRemote) return; // if not already connected, wait until the timeout
+
+  	    let err = await new Promise(resolve => {
+  	      let done = event => {
+  	        if (timeoutid == null) return;
+  	        timeoutid = clearTimeout(timeoutid);
+  	        if (this.socket) this.socket.onopen = this.socket.onerror = null;
+  	        resolve((event === null || event === void 0 ? void 0 : event.error) || (event === null || event === void 0 ? void 0 : event.type) === 'error' && 'Error: Socket connection failed');
+  	      };
+
+  	      let timeoutid = setTimeout(done, timeout, {
+  	        error: 'Error: Socket connection timed out'
+  	      });
+  	      Promise.resolve().then(async () => {
+  	        this.socket = await createSocket();
+  	        if (this.isRemote) return done();
+  	        this.socket.onopen = this.socket.onerror = done;
+  	      }).catch(error => done({
+  	        error
+  	      }));
+  	    }); // there was an error connecting, will fallback to normal logging
+
+  	    if (err) {
+  	      this.log('logger', 'debug', 'Unable to connect to remote logger');
+  	      this.log('logger', 'debug', err);
+  	      return;
+  	    } // send any messages already logged in this environment
+
+
+  	    if (this.messages.size) {
+  	      this.socket.send(JSON.stringify({
+  	        logAll: Array.from(this.messages).map(entry => ({ ...entry,
+  	          meta: {
+  	            remote: true,
+  	            ...entry.meta
+  	          }
+  	        }))
+  	      }));
+  	    } // attach an incoming message handler
+
+
+  	    this.socket.onmessage = _ref2 => {
+  	      let {
+  	        data
+  	      } = _ref2;
+  	      let {
+  	        env
+  	      } = JSON.parse(data); // update local environment info
+
+  	      if (env) Object.assign(process.env, env);
+  	    }; // return a cleanup function
+
+
+  	    return () => {
+  	      this.socket.onmessage = null;
+  	      this.socket = null;
+  	    };
+  	  }
+
+  	}
+
+  	_defineProperty(PercyLogger, "stdout", process.stdout);
+
+  	_defineProperty(PercyLogger, "stderr", process.stderr);
+
+  	var logger$1 = /*#__PURE__*/Object.freeze({
+  		__proto__: null,
+  		PercyLogger: PercyLogger,
+  		'default': PercyLogger
+  	});
+
+  	class PercyBrowserLogger extends PercyLogger {
+  	  write(level, message) {
+  	    let out = ['warn', 'error'].includes(level) ? level : 'log';
+  	    let colors = [];
+  	    message = message.replace(ANSI_REG, (_, ansi) => {
+  	      colors.push(`color:${ANSI_COLORS[ansi] || 'inherit'}`);
+  	      return '%c';
+  	    });
+  	    console[out](message, ...colors);
+  	  }
+
+  	  progress() {
+  	    console.error('The log.progress() method is not supported in browsers');
+  	  }
+
+  	}
+
+  	var browser = /*#__PURE__*/Object.freeze({
+  		__proto__: null,
+  		PercyBrowserLogger: PercyBrowserLogger,
+  		'default': PercyBrowserLogger
+  	});
+
+  	var require$$0 = /*@__PURE__*/getAugmentedNamespace(browser);
+
+  	var require$$1 = /*@__PURE__*/getAugmentedNamespace(logger$1);
+
+  	const {
+  	  default: Logger
+  	} = process.env.__PERCY_BROWSERIFIED__ ? require$$0 : require$$1;
+
+  	function logger(name) {
+  	  return new Logger().group(name);
+  	}
+
+  	Object.assign(logger, {
+  	  format: function () {
+  	    return new Logger().format(...arguments);
+  	  },
+  	  query: function () {
+  	    return new Logger().query(...arguments);
+  	  },
+  	  connect: function () {
+  	    return new Logger().connect(...arguments);
+  	  },
+  	  remote: function () {
+  	    return new Logger().remote(...arguments);
+  	  },
+  	  loglevel: function () {
+  	    return new Logger().loglevel(...arguments);
+  	  }
+  	});
+  	Object.defineProperties(logger, {
+  	  Logger: {
+  	    get: () => Logger
+  	  },
+  	  stdout: {
+  	    get: () => Logger.stdout
+  	  },
+  	  stderr: {
+  	    get: () => Logger.stderr
+  	  }
+  	});
+  	var src = logger;
+
+  	exports["default"] = src;
+
+  	Object.defineProperty(exports, '__esModule', { value: true });
+
+  })(this.PercyLogger = this.PercyLogger || {});
+}).call(window);
+
+if (typeof define === "function" && define.amd) {
+  define([], () => window.PercyLogger);
+} else if (typeof module === "object" && module.exports) {
+  module.exports = window.PercyLogger;
+}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const {
+  default: Logger
+} = process.env.__PERCY_BROWSERIFIED__ ? require('./browser') : require('./logger');
+
+function logger(name) {
+  return new Logger().group(name);
+}
+
+Object.assign(logger, {
+  format: (...args) => new Logger().format(...args),
+  query: (...args) => new Logger().query(...args),
+  connect: (...args) => new Logger().connect(...args),
+  remote: (...args) => new Logger().remote(...args),
+  loglevel: (...args) => new Logger().loglevel(...args)
+});
+Object.defineProperties(logger, {
+  Logger: {
+    get: () => Logger
+  },
+  stdout: {
+    get: () => Logger.stdout
+  },
+  stderr: {
+    get: () => Logger.stderr
+  }
+});
+module.exports = logger;