@percy/logger 1.0.0-beta.8 → 1.0.1

package/dist/logger.js

@@ -0,0 +1,321 @@
+import { colors } from './utils.js';
+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.
+
+export class PercyLogger {
+  // default log level
+  level = 'info'; // namespace regular expressions used to determine which debug logs to write
+
+  namespaces = {
+    include: [/^.*?$/],
+    exclude: []
+  }; // in-memory store for logs and meta info
+
+  messages = new Set(); // track deprecations to limit noisy logging
+
+  deprecations = new Set(); // static vars can be overriden for testing
+
+  static stdout = process.stdout;
+  static stderr = process.stderr; // Handles setting env var values and returns a singleton
+
+  constructor() {
+    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, meta = {}) {
+    // 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 = ({
+      data
+    }) => {
+      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, timeout = 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 = ({
+      data
+    }) => {
+      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;
+    };
+  }
+
+}
+export default PercyLogger;

package/dist/utils.js

@@ -0,0 +1,28 @@
+const {
+  assign,
+  entries
+} = Object; // matches ansi escape sequences
+
+export 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
+
+export 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
+
+
+export const colors = entries(ANSI_COLORS).reduce((colors, [code, name]) => {
+  return assign(colors, {
+    [name]: colorize.bind(null, code)
+  });
+}, {});

package/package.json

@@ -1,25 +1,48 @@
 {
   "name": "@percy/logger",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.1",
   "license": "MIT",
-  "main": "index.js",
-  "scripts": {
-    "lint": "eslint --ignore-path ../../.gitignore .",
-    "test": "cross-env NODE_ENV=test mocha",
-    "test:coverage": "nyc yarn test"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/logger"
   },
   "publishConfig": {
     "access": "public"
   },
-  "mocha": {
-    "require": "../../scripts/babel-register"
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "dist",
+    "test/helpers.js",
+    "test/client.js"
+  ],
+  "main": "./dist/index.js",
+  "browser": "./dist/bundle.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./utils": "./dist/utils.js",
+    "./test/helpers": "./test/helpers.js",
+    "./test/client": "./test/client.js"
   },
-  "dependencies": {
-    "colors": "^1.4.0",
-    "winston": "^3.2.1"
+  "imports": {
+    "#logger": {
+      "node": "./dist/logger.js",
+      "default": "./dist/browser.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/build",
+    "lint": "eslint --ignore-path ../../.gitignore .",
+    "test": "node ../../scripts/test",
+    "test:coverage": "yarn test --coverage"
   },
-  "devDependencies": {
-    "strip-ansi": "^6.0.0"
+  "rollup": {
+    "output": {
+      "name": "PercyLogger"
+    }
   },
-  "gitHead": "6015850e7c20c130d625fcb327b10d7513b35707"
+  "gitHead": "38917e6027299d6cd86008e2ccd005d90bbf89c0"
 }

package/test/client.js

@@ -0,0 +1,173 @@
+(function() {
+  this.PercyLogger = this.PercyLogger || {};
+  this.PercyLogger.TestHelpers = (function (logger) {
+    'use strict';
+
+    const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
+    process.env = process.env || {};
+    process.env.__PERCY_BROWSERIFIED__ = true;
+
+    globalThis.process = globalThis.process || process;
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var logger__default = /*#__PURE__*/_interopDefaultLegacy(logger);
+
+    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
+
+
+    entries(ANSI_COLORS).reduce((colors, _ref) => {
+      let [code, name] = _ref;
+      return assign(colors, {
+        [name]: colorize.bind(null, code)
+      });
+    }, {});
+
+    const ELAPSED_REG = /\s\S*?\(\d+ms\)\S*/;
+    const NEWLINE_REG = /\r\n/g;
+    const LASTLINE_REG = /\n$/;
+
+    function sanitizeLog(str) {
+      let {
+        ansi,
+        elapsed
+      } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // normalize line endings
+      str = str.replace(NEWLINE_REG, '\n'); // strip ansi colors
+
+      if (!ansi) str = str.replace(ANSI_REG, ''); // strip elapsed time
+
+      if (!elapsed) str = str.replace(ELAPSED_REG, ''); // strip trailing line endings
+
+      return str.replace(LASTLINE_REG, '');
+    }
+
+    function spy(object, method, func) {
+      if (object[method].restore) object[method].restore();
+      let spy = Object.assign(function spy() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        spy.calls.push(args);
+        if (func) return func.apply(this, args);
+      }, {
+        restore: () => object[method] = spy.originalValue,
+        reset: () => (spy.calls.length = 0) || spy,
+        originalValue: object[method],
+        calls: []
+      });
+      object[method] = spy;
+      return spy;
+    }
+
+    const {
+      Logger,
+      loglevel
+    } = logger__default["default"];
+    const helpers = {
+      stdout: [],
+      stderr: [],
+      loglevel,
+
+      async mock() {
+        let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        helpers.reset();
+
+        if (process.env.__PERCY_BROWSERIFIED__) {
+          spy(Logger.prototype, 'write', function (lvl, msg) {
+            let stdio = lvl === 'info' ? 'stdout' : 'stderr';
+            helpers[stdio].push(sanitizeLog(msg, options));
+            return this.write.originalValue.call(this, lvl, msg);
+          });
+          spy(console, 'log');
+          spy(console, 'warn');
+          spy(console, 'error');
+        } else {
+          let {
+            Writable
+          } = await import('stream');
+
+          for (let stdio of ['stdout', 'stderr']) {
+            Logger[stdio] = Object.assign(new Writable(), {
+              columns: options.isTTY ? 100 : null,
+              isTTY: options.isTTY,
+
+              cursorTo() {},
+
+              clearLine() {},
+
+              _write(chunk, encoding, callback) {
+                helpers[stdio].push(sanitizeLog(chunk.toString(), options));
+                callback();
+              }
+
+            });
+          }
+        }
+      },
+
+      reset(soft) {
+        if (soft) loglevel('info');else delete Logger.instance;
+        helpers.stdout.length = 0;
+        helpers.stderr.length = 0;
+
+        if (console.log.reset) {
+          console.log.reset();
+          console.warn.reset();
+          console.error.reset();
+        }
+      },
+
+      dump() {
+        let msgs = Array.from(Logger.instance && Logger.instance.messages || []);
+        if (!msgs.length) return;
+
+        let log = m => process.env.__PERCY_BROWSERIFIED__ ? console.log.and ? console.log.and.originalFn(m) : console.log(m) : process.stderr.write(`${m}\n`);
+
+        logger__default["default"].loglevel('debug');
+        log(logger__default["default"].format('testing', 'warn', '--- DUMPING LOGS ---'));
+        msgs.reduce((last, _ref) => {
+          let {
+            debug,
+            level,
+            message,
+            timestamp
+          } = _ref;
+          log(logger__default["default"].format(debug, level, message, timestamp - last));
+          return timestamp;
+        }, msgs[0].timestamp);
+      }
+
+    };
+
+    return helpers;
+
+  })(PercyLogger);
+}).call(window);
+
+if (typeof define === "function" && define.amd) {
+  define([], () => window.PercyLogger.TestHelpers);
+} else if (typeof module === "object" && module.exports) {
+  module.exports = window.PercyLogger.TestHelpers;
+}

package/test/helpers.js

@@ -0,0 +1,111 @@
+import logger from '@percy/logger';
+import { ANSI_REG } from '@percy/logger/utils';
+
+const ELAPSED_REG = /\s\S*?\(\d+ms\)\S*/;
+const NEWLINE_REG = /\r\n/g;
+const LASTLINE_REG = /\n$/;
+
+function sanitizeLog(str, { ansi, elapsed } = {}) {
+  // normalize line endings
+  str = str.replace(NEWLINE_REG, '\n');
+  // strip ansi colors
+  if (!ansi) str = str.replace(ANSI_REG, '');
+  // strip elapsed time
+  if (!elapsed) str = str.replace(ELAPSED_REG, '');
+  // strip trailing line endings
+  return str.replace(LASTLINE_REG, '');
+}
+
+function spy(object, method, func) {
+  if (object[method].restore) object[method].restore();
+
+  let spy = Object.assign(function spy(...args) {
+    spy.calls.push(args);
+    if (func) return func.apply(this, args);
+  }, {
+    restore: () => (object[method] = spy.originalValue),
+    reset: () => (spy.calls.length = 0) || spy,
+    originalValue: object[method],
+    calls: []
+  });
+
+  object[method] = spy;
+  return spy;
+}
+
+const {
+  Logger,
+  loglevel
+} = logger;
+
+const helpers = {
+  stdout: [],
+  stderr: [],
+  loglevel,
+
+  async mock(options = {}) {
+    helpers.reset();
+
+    if (process.env.__PERCY_BROWSERIFIED__) {
+      spy(Logger.prototype, 'write', function(lvl, msg) {
+        let stdio = lvl === 'info' ? 'stdout' : 'stderr';
+        helpers[stdio].push(sanitizeLog(msg, options));
+        return this.write.originalValue.call(this, lvl, msg);
+      });
+
+      spy(console, 'log');
+      spy(console, 'warn');
+      spy(console, 'error');
+    } else {
+      let { Writable } = await import('stream');
+
+      for (let stdio of ['stdout', 'stderr']) {
+        Logger[stdio] = Object.assign(new Writable(), {
+          columns: options.isTTY ? 100 : null,
+          isTTY: options.isTTY,
+          cursorTo() {},
+          clearLine() {},
+
+          _write(chunk, encoding, callback) {
+            helpers[stdio].push(sanitizeLog(chunk.toString(), options));
+            callback();
+          }
+        });
+      }
+    }
+  },
+
+  reset(soft) {
+    if (soft) loglevel('info');
+    else delete Logger.instance;
+
+    helpers.stdout.length = 0;
+    helpers.stderr.length = 0;
+
+    if (console.log.reset) {
+      console.log.reset();
+      console.warn.reset();
+      console.error.reset();
+    }
+  },
+
+  dump() {
+    let msgs = Array.from((Logger.instance && Logger.instance.messages) || []);
+    if (!msgs.length) return;
+
+    let log = m => process.env.__PERCY_BROWSERIFIED__ ? (
+      console.log.and ? console.log.and.originalFn(m) : console.log(m)
+    ) : process.stderr.write(`${m}\n`);
+
+    logger.loglevel('debug');
+    log(logger.format('testing', 'warn', '--- DUMPING LOGS ---'));
+
+    msgs.reduce((last, { debug, level, message, timestamp }) => {
+      log(logger.format(debug, level, message, timestamp - last));
+      return timestamp;
+    }, msgs[0].timestamp);
+  }
+};
+
+export { helpers as logger };
+export default helpers;