@percy/logger 1.0.0-beta.8 → 1.0.1

package/index.js

@@ -1,99 +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: 'error',
-      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 method to handle error objects. Winston accepts objects with
-// messages and meta as an argument but will fail to log real error instances.
-logger.error = 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.error(message)
-  return this.constructor.prototype.error.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,134 +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('#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 })
-      ]);
-    });
-  });
-});