@percy/logger 1.0.0-beta.9 → 1.0.0

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/package.json

@@ -1,25 +1,48 @@
 {
   "name": "@percy/logger",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "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": "57a2eeb90c7f5cdf8827c78be1e5c12df581f4b5"
+  "gitHead": "6df509421a60144e4f9f5d59dc57a5675372a0b2"
 }

package/index.js

@@ -1,101 +0,0 @@
-const os = require('os');
-const path = require('path');
-const { createLogger, transports, format } = require('winston');
-const colors = require('colors/safe');
-
-// A very basic url regexp only used for highlighting URLs blue in the CLI.
-const URL_REGEXP = /\b(https?:\/\/)[\w-]+(\.[\w-]+)*(:\d+)?(\/\S*)?\b/gi;
-const TEMP_DIR = path.join(os.tmpdir(), 'percy');
-
-// Custom logging formatter to color log levels, insert a megenta label, and
-// highlight URLs logged to the transport
-function formatter({ label, level, message }) {
-  label = colors.magenta(label);
-
-  if (level === 'error') {
-    message = colors.red(message);
-  } else if (level === 'warn') {
-    message = colors.yellow(message);
-  } else if (level === 'info') {
-    // highlight urls blue
-    message = message.replace(URL_REGEXP, colors.blue('$&'));
-  }
-
-  return `[${label}] ${message}`;
-}
-
-// Global logger
-const logger = createLogger({
-  transports: [
-    // console transport logs errors by default
-    new transports.Console({
-      level: process.env.PERCY_LOGLEVEL || 'info',
-      stderrLevels: ['error'],
-      format: format.combine(
-        format.label({ label: 'percy' }),
-        format.printf(formatter)
-      )
-    }),
-    // file transport logs everything
-    new transports.File({
-      level: 'debug',
-      filename: path.join(TEMP_DIR, `percy.${Date.now()}.log`),
-      format: format.combine(
-        format.timestamp(),
-        format.json()
-      )
-    })
-  ]
-});
-
-// Attach the formatter so external logs can utilize it
-logger.formatter = message => formatter(
-  typeof message === 'string' ? { label: 'percy', message } : message
-);
-
-// Method to change the global logger's console log level. The second argument
-// can be used to set the appropriate level based on boolean flags and fallback
-// to the provided log level.
-logger.loglevel = function loglevel(level, flags = {}) {
-  if (!level) return this.transports[0].level;
-
-  if (flags.verbose) level = 'debug';
-  else if (flags.quiet) level = 'warn';
-  else if (flags.silent) level = 'silent';
-
-  this.transports[0].level = level;
-};
-
-// Patch the error and debug methods to handle error objects. Winston accepts objects
-// with messages and meta as an argument but will fail to log real error instances.
-for (let method of ['error', 'debug']) {
-  logger[method] = function(message) {
-    // libraries may also throw errors which are not technically Error instances
-    if (typeof message === 'object') {
-      // get the stack trace for debug (no ternary to always fallback to string)
-      message = (this.loglevel() === 'debug' && message.stack) || message.toString();
-    }
-
-    // return super[method](message)
-    return this.constructor.prototype[method].call(this, message);
-  };
-}
-
-// Patch the query method to return a promise, query the file transport only,
-// and allow filtering logs with a filter function.
-logger.query = function(options = {}) {
-  return new Promise((resolve, reject) => {
-    // the query method mutates options to normalize and set defaults, so the
-    // same is done here to set more desirable defaults
-    options.limit = options.limit || Infinity;
-    options.order = options.order || 'asc';
-
-    this.transports[1].query(options, (err, logs) => {
-      if (err) return reject(err);
-      if (options.filter) logs = logs.filter(options.filter);
-      resolve(logs);
-    });
-  });
-};
-
-module.exports = logger;

package/test/.eslintrc

@@ -1,2 +0,0 @@
-env:
-  mocha: true

package/test/helper.js

@@ -1,52 +0,0 @@
-import stripAnsi from 'strip-ansi';
-
-const og = {
-  out: process.stdout.write,
-  err: process.stderr.write
-};
-
-function format(chunk, { ansi = false } = {}) {
-  // strip ansi and normalize line endings
-  return (ansi ? chunk : stripAnsi(chunk)).replace('\r\n', '\n');
-}
-
-function tryFinally(fn, cb) {
-  let done = (r, e) => {
-    if ((cb(), e)) throw e;
-    return r;
-  };
-
-  let r, e;
-  try { r = fn(); } catch (err) { e = err; }
-
-  if (typeof r?.then === 'function') {
-    return r.then(done, e => done(null, e));
-  } else {
-    return done(r, e);
-  }
-}
-
-const stdio = {
-  1: [],
-  2: [],
-
-  capture(fn, options) {
-    stdio.flush();
-    process.stdout.write = chunk => stdio[1].push(format(chunk, options));
-    process.stderr.write = chunk => stdio[2].push(format(chunk, options));
-    return fn ? tryFinally(fn, stdio.restore) : null;
-  },
-
-  restore() {
-    process.stdout.write = og.out;
-    process.stderr.write = og.err;
-  },
-
-  flush() {
-    let output = [null, stdio[1], stdio[2]];
-    stdio[1] = []; stdio[2] = [];
-    return output;
-  }
-};
-
-export default stdio;

package/test/index.test.js

@@ -1,142 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import expect from 'expect';
-import colors from 'colors/safe';
-import stdio from './helper';
-import log from '..';
-
-describe('logger', () => {
-  const label = colors.magenta('percy');
-
-  beforeEach(() => {
-    let { dirname, filename } = log.transports[1];
-    let logfile = path.join(dirname, filename);
-    fs.writeFileSync(logfile, '');
-    log.loglevel('debug');
-  });
-
-  afterEach(() => {
-    log.loglevel('error');
-  });
-
-  it('formats the message with a percy label', () => {
-    stdio.capture(() => log.debug('test'), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] test\n`]);
-  });
-
-  it('formats errors red', () => {
-    stdio.capture(() => log.error('error'), { ansi: true });
-    expect(stdio[2]).toEqual([`[${label}] ${colors.red('error')}\n`]);
-  });
-
-  it('formats warnings yellow', () => {
-    stdio.capture(() => log.warn('warning'), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] ${colors.yellow('warning')}\n`]);
-  });
-
-  it('formats info URLs blue', () => {
-    let url = 'https://localhost:3000/foobar/baz.png';
-    stdio.capture(() => log.info(`url = ${url}`), { ansi: true });
-    expect(stdio[1]).toEqual([`[${label}] url = ${colors.blue(url)}\n`]);
-  });
-
-  describe('#formatter()', () => {
-    it('returns a string formatted as a percy log', () => {
-      expect(log.formatter('testing')).toEqual(`[${label}] testing`);
-    });
-
-    it('accepts a logger meta object', () => {
-      expect(log.formatter({ label: 'test', message: 'foobar' }))
-        .toEqual(`[${colors.magenta('test')}] foobar`);
-    });
-  });
-
-  describe('#loglevel()', () => {
-    it('sets the first transport log level', () => {
-      expect(log.transports[0].level).toBe('debug');
-      log.loglevel('info');
-      expect(log.transports[0].level).toBe('info');
-    });
-
-    it('returns the first transport log level without args', () => {
-      expect(log.loglevel()).toBe(log.transports[0].level);
-    });
-
-    it('sets the log level to debug with a verbose flag', () => {
-      log.loglevel('info', { verbose: true });
-      expect(log.loglevel()).toBe('debug');
-    });
-
-    it('sets the log level to warn with a quiet flag', () => {
-      log.loglevel('info', { quiet: true });
-      expect(log.loglevel()).toBe('warn');
-    });
-
-    it('sets the log level to silent with a silent flag', () => {
-      log.loglevel('info', { silent: true });
-      expect(log.loglevel()).toBe('silent');
-    });
-  });
-
-  describe('#error()', () => {
-    it('is patched to log error instance strings', () => {
-      log.loglevel('error');
-      stdio.capture(() => log.error(new Error('message')));
-      expect(stdio[2]).toEqual(['[percy] Error: message\n']);
-    });
-
-    it('logs the error instance stack trace in debug', () => {
-      let err = new Error('message');
-      stdio.capture(() => log.error(err));
-      expect(stdio[2]).toEqual([`[percy] ${err.stack}\n`]);
-    });
-
-    it('falls back if there is no error instance stack in debug', () => {
-      let err = { toString: () => 'error' };
-      stdio.capture(() => log.error(err));
-      expect(stdio[2]).toEqual(['[percy] error\n']);
-    });
-  });
-
-  describe('#debug()', () => {
-    it('is patched to log error instance strings', () => {
-      let err = { toString: () => 'error' };
-      stdio.capture(() => log.debug(err));
-      expect(stdio[1]).toEqual(['[percy] error\n']);
-    });
-  });
-
-  describe('#query()', () => {
-    beforeEach(() => {
-      stdio.capture(() => {
-        log.info('foo', { foo: true });
-        log.info('bar', { bar: true });
-      });
-    });
-
-    it('is promisified', async () => {
-      await expect(log.query()).resolves.toEqual([
-        expect.objectContaining({ message: 'foo', foo: true }),
-        expect.objectContaining({ message: 'bar', bar: true })
-      ]);
-
-      await expect(log.query({
-        get level() { throw new Error('test'); }
-      })).rejects.toThrow('test');
-    });
-
-    it('can filter logs', async () => {
-      await expect(log.query({
-        filter: log => log.foo
-      })).resolves.toEqual([
-        expect.objectContaining({ message: 'foo', foo: true })
-      ]);
-
-      await expect(log.query({
-        filter: log => log.bar
-      })).resolves.toEqual([
-        expect.objectContaining({ message: 'bar', bar: true })
-      ]);
-    });
-  });
-});