ali-skills 0.0.21 → 0.0.23

package/node_modules/egg-logger/lib/logger.js

@@ -0,0 +1,170 @@
+const util = require('util');
+const depd = require('depd')('egg-logger');
+const utils = require('./utils');
+
+/**
+ * Base class for all sub Logger class.
+ * It extends Map, and can contains multi {@link Transport}
+ *
+ * @example
+ * ```js
+ * const logger = new Logger();
+ * logger.set('file', new FileTransport({
+ *   file: '/path/to/log',
+ *   level: 'INFO',
+ * }));
+ * logger.set('console', new ConsoleTransport({
+ *   level: 'INFO',
+ * }));
+ * logger.info('foo');
+ * ```
+ */
+class Logger extends Map {
+  /**
+   * @param {Object} options - assign with `defaults` propery
+   */
+  constructor(options) {
+    super();
+    this.options = utils.assign(this.defaults, options);
+    this.transports = {};
+    this.name = this.constructor.name;
+    this.redirectLoggers = new Map();
+    this.duplicateLoggers = new Map();
+  }
+
+  /**
+   * disable a transport
+   * @param {String} name - transport name
+   */
+  disable(name) {
+    const transport = this.get(name);
+    if (transport) transport.disable();
+  }
+
+  /**
+   * enable a transport
+   * @param {String} name - transport name
+   */
+  enable(name) {
+    const transport = this.get(name);
+    if (transport) transport.enable();
+  }
+
+  /**
+   * Send log to all transports.
+   * It's proxy to {@link Transport}'s log method.
+   * @param {String} level - log level
+   * @param {Array} args - log arguments
+   * @param {Object} meta - log meta
+   */
+  log(level, args, meta) {
+    let excludes;
+    let { logger, options } = this.duplicateLoggers.get(level) || {};
+    if (logger) {
+      excludes = options.excludes;
+      logger.log(level, args, meta);
+    } else {
+      logger = this.redirectLoggers.get(level);
+      if (logger) {
+        logger.log(level, args, meta);
+        return;
+      }
+    }
+
+    for (const [ key, transport ] of this.entries()) {
+      if (transport.shouldLog(level) && !(excludes && excludes.includes(key))) {
+        transport.log(level, args, meta);
+      }
+    }
+  }
+
+  /**
+   * write raw log to all transports
+   * @param {String} msg - log message
+   */
+  write(msg) {
+    // support util.format
+    if (arguments.length > 1) msg = util.format.apply(util, arguments);
+    // `NONE` is the top level
+    this.log('NONE', [ msg ], { raw: true });
+  }
+
+  /**
+   * Redirect specify level log to the other logger
+   * @param {String} level - log level
+   * @param {Logger} logger - target logger instance
+   */
+  redirect(level, logger) {
+    level = level.toUpperCase();
+    if (!this.redirectLoggers.has(level) && logger instanceof Logger) {
+      this.redirectLoggers.set(level, logger);
+    }
+  }
+
+  /**
+   * Un-redirect specify level log
+   * @param {String} level - log level
+   */
+  unredirect(level) {
+    level = level.toUpperCase();
+    this.redirectLoggers.delete(level);
+  }
+
+  /**
+   * Duplicate specify level log to the other logger
+   * @param {String} level - log level
+   * @param {Logger} logger - target logger instance
+   * @param {Object} [options] - { excludes: [] }
+   */
+  duplicate(level, logger, options = {}) {
+    level = level.toUpperCase();
+    if (!this.duplicateLoggers.has(level) && logger instanceof Logger) {
+      this.duplicateLoggers.set(level, { logger, options });
+    }
+  }
+
+  /**
+   * Un-duplicate specify level log
+   * @param {String} level - log level
+   */
+  unduplicate(level) {
+    level = level.toUpperCase();
+    this.duplicateLoggers.delete(level);
+  }
+
+  /**
+   * Reload all transports
+   */
+  reload() {
+    for (const transport of this.values()) {
+      transport.reload();
+    }
+  }
+
+  /**
+   * End all transports
+   */
+  close() {
+    for (const transport of this.values()) {
+      transport.close();
+    }
+  }
+
+  /**
+   * @deprecated
+   */
+  end() {
+    depd('logger.end() is deprecated, use logger.close()');
+    this.close();
+  }
+
+}
+
+[ 'error', 'warn', 'info', 'debug' ].forEach(level => {
+  const LEVEL = level.toUpperCase();
+  Logger.prototype[level] = function(...args) {
+    this.log(LEVEL, args);
+  };
+});
+
+module.exports = Logger;

package/node_modules/egg-logger/lib/transports/console.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const Transport = require('./transport');
+const utils = require('../utils');
+const levels = require('../level');
+
+
+/**
+ * output log to console {@link Transport}。
+ * specifical level by EGG_LOG has the highest priority
+ */
+class ConsoleTransport extends Transport {
+
+  /**
+   * @class
+   * @param {Object} options
+   * - {Array} [stderrLevel = ERROR] - output to stderr level, must higher than options.level
+   */
+  constructor(options) {
+    super(options);
+    this.options.stderrLevel = utils.normalizeLevel(this.options.stderrLevel);
+    // EGG_LOG has the highest priority
+    if (process.env.EGG_LOG) {
+      this.options.level = utils.normalizeLevel(process.env.EGG_LOG);
+    }
+  }
+
+  get defaults() {
+    return utils.assign(super.defaults, {
+      stderrLevel: 'ERROR',
+    });
+  }
+
+  /**
+   * output log, see {@link Transport#log}
+   * if stderrLevel presents, will output log to stderr
+   * @param  {String} level - log level, in upper case
+   * @param  {Array} args - all arguments
+   * @param  {Object} meta - meta infomations
+   */
+  log(level, args, meta) {
+    const msg = super.log(level, args, meta);
+    if (levels[level] >= this.options.stderrLevel && levels[level] < levels['NONE']) {
+      process.stderr.write(msg);
+    } else {
+      process.stdout.write(msg);
+    }
+  }
+
+}
+
+module.exports = ConsoleTransport;

package/node_modules/egg-logger/lib/transports/file.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const { mkdirSync } = require('fs');
+const utility = require('utility');
+const depd = require('depd')('egg-logger');
+const Transport = require('./transport');
+const utils = require('../utils');
+
+
+/**
+ * output log into file {@link Transport}。
+ */
+class FileTransport extends Transport {
+
+  /**
+   * @class
+   * @param {Object} options
+   * - {String} file - file path
+   * - {String} [level = INFO] - log level
+   */
+  constructor(options) {
+    super(options);
+    assert(this.options.file, 'should pass options.file');
+
+    this._stream = null;
+    this.reload();
+  }
+
+  get defaults() {
+    return utils.assign(super.defaults, {
+      file: null,
+      level: 'INFO',
+    });
+  }
+
+  /**
+   * reload file stream
+   */
+  reload() {
+    this._closeStream();
+    this._stream = this._createStream();
+  }
+
+  /**
+   * output log, see {@link Transport#log}
+   * @param  {String} level - log level
+   * @param  {Array} args - all arguments
+   * @param  {Object} meta - meta information
+   */
+  log(level, args, meta) {
+    if (!this.writable) {
+      // ignore error on unittest env
+      if (process.env.NODE_ENV === 'test') return;
+      const err = new Error(`${this.options.file} log stream had been closed`);
+      console.error(err.stack);
+      return;
+    }
+    const buf = super.log(level, args, meta);
+    if (buf.length) {
+      this._write(buf);
+    }
+  }
+
+  /**
+   * close stream
+   */
+  close() {
+    this._closeStream();
+  }
+
+  /**
+   * @deprecated
+   */
+  end() {
+    depd('transport.end() is deprecated, use transport.close()');
+    this.close();
+  }
+
+  /**
+   * write stream directly
+   * @param {Buffer|String} buf - log content
+   * @private
+   */
+  _write(buf) {
+    this._stream.write(buf);
+  }
+
+  /**
+   * transport is writable
+   * @return {Boolean} writable
+   */
+  get writable() {
+    return this._stream && !this._stream.closed && this._stream.writable && !this._stream.destroyed;
+  }
+
+  /**
+   * create stream
+   * @return {Stream} return writeStream
+   * @private
+   */
+  _createStream() {
+    mkdirSync(path.dirname(this.options.file), { recursive: true });
+    const stream = fs.createWriteStream(this.options.file, { flags: 'a' });
+
+    const onError = err => {
+      console.error('%s ERROR %s [egg-logger] [%s] %s',
+        utility.logDate(','), process.pid, this.options.file, err.stack);
+      this.reload();
+      console.warn('%s WARN %s [egg-logger] [%s] reloaded', utility.logDate(','), process.pid, this.options.file);
+    };
+    // only listen error once because stream will reload after error
+    stream.once('error', onError);
+    stream._onError = onError;
+    return stream;
+  }
+
+  /**
+   * close stream
+   * @private
+   */
+  _closeStream() {
+    if (this._stream) {
+      this._stream.end();
+      this._stream.removeListener('error', this._stream._onError);
+      this._stream = null;
+    }
+  }
+
+}
+
+module.exports = FileTransport;

package/node_modules/egg-logger/lib/transports/file_buffer.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const depd = require('depd')('egg-logger');
+const FileTransport = require('./file');
+const utils = require('../utils');
+
+/**
+ * extends from {@link FileTransport}
+ * save log in memory and flush to log file at intervals
+ */
+class FileBufferTransport extends FileTransport {
+
+  /**
+   * @class
+   * @param {Object} options
+   * - {String} file - log file path
+   * - {Number} [flushInterval = 1000] - interval for flush to file
+   * - {Number} [maxBufferLength = 1000] - max buffer queue length
+   * - {String} [level = INFO] - log level
+   */
+  constructor(options) {
+    super(options);
+
+    this._bufSize = 0;
+    this._buf = [];
+    this._timer = this._createInterval();
+  }
+
+  get defaults() {
+    return utils.assign(super.defaults, {
+      flushInterval: 1000,
+      maxBufferLength: 1000,
+    });
+  }
+
+  /**
+   * close stream and interval
+   */
+  close() {
+    this._closeInterval();
+    super.close();
+  }
+
+  /**
+   * @deprecated
+   */
+  end() {
+    depd('transport.end() is deprecated, use transport.close()');
+    this.close();
+  }
+
+  /**
+   * flush log into file
+   */
+  flush() {
+    if (this._buf.length > 0 && this.writable) {
+      if (this.options.encoding === 'utf8') {
+        this._stream.write(this._buf.join(''));
+      } else {
+        this._stream.write(Buffer.concat(this._buf, this._bufSize));
+      }
+      this._buf = [];
+      this._bufSize = 0;
+    }
+  }
+
+  /**
+   * override, flush before close stream
+   * @private
+   */
+  _closeStream() {
+    // FileTransport 在初始化时会 reload，这时 _buf 还未初始化
+    if (this._buf && this._buf.length > 0) {
+      this.flush();
+    }
+    super._closeStream();
+  }
+
+  /**
+   * override, save in memory temporary
+   * @param {Buffer} buf - log buffer
+   * @private
+   */
+  _write(buf) {
+    this._bufSize += buf.length;
+    this._buf.push(buf);
+    if (this._buf.length > this.options.maxBufferLength) {
+      this.flush();
+    }
+  }
+
+  /**
+   * create interval to flush log into file
+   * @return {Interval} 定时器
+   * @private
+   */
+  _createInterval() {
+    return setInterval(() => this.flush(), this.options.flushInterval);
+  }
+
+  /**
+   * close interval
+   * @private
+   */
+  _closeInterval() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+}
+
+module.exports = FileBufferTransport;

package/node_modules/egg-logger/lib/transports/transport.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const os = require('os');
+const utils = require('../utils');
+const levels = require('../level');
+
+const ENABLED = Symbol('Transport#enabled');
+
+/**
+ * Transport is an output channel of the log that can be output to a file, console or service.
+ * A {@link Logger} can configure multiple Transports to meet a variety of complex needs
+ */
+class Transport {
+
+  /**
+   * @class
+   * @param  {Object} options
+   * - {String} [level = NONE] - log level. ouput method must higher than this option. if level is `info`, `debug` will disabled
+   * - {Function} [formatter] - format function
+   * - {Function} [contextFormatter] - format function for context logger
+   * - {Function} [paddingMessageFormatter] - format function for padding message
+   * - {Boolean} [json = false] - log format is json or not
+   * - {Boolean} [dateISOFormat = false] - format date with ISO format
+   * - {String} [encoding = utf8] - log encodeing, see {@link https://github.com/ashtuchkin/iconv-lite#supported-encodings}
+   * - {String} [eol = os.EOL] - end of line
+   * - {AsyncLocalStorage} [localStorage] - AsyncLocalStorage instance to get current ctx
+   * - {number} [maxCauseChainLength]
+   */
+  constructor(options) {
+    this.options = utils.assign(this.defaults, options);
+    if (this.options.encoding === 'utf-8') {
+      this.options.encoding = 'utf8';
+    }
+    this.options.level = utils.normalizeLevel(this.options.level);
+    this[ENABLED] = true;
+  }
+
+  get defaults() {
+    return {
+      level: 'NONE',
+      formatter: null,
+      contextFormatter: null,
+      json: false,
+      encoding: 'utf8',
+      eol: os.EOL,
+      // localStorage: null,
+    };
+  }
+
+  /**
+   * enable or not
+   * @return {[type]} [description]
+   */
+  get enabled() {
+    return this[ENABLED];
+  }
+
+  /**
+   * enable transport
+   */
+  enable() {
+    this[ENABLED] = true;
+  }
+
+  /**
+   * disable transport
+   */
+  disable() {
+    this[ENABLED] = false;
+  }
+
+  set level(level) {
+    this.options.level = utils.normalizeLevel(level);
+  }
+
+  get level() {
+    return this.options.level;
+  }
+
+  /**
+   * should  output log or not
+   * @param  {String} level log level, must in upper case
+   * @return {Boolean} should or not
+   */
+  shouldLog(level) {
+    if (!this[ENABLED]) {
+      return false;
+    }
+
+    if (this.options.level === levels['NONE']) {
+      return false;
+    }
+
+    return this.options.level <= levels[level];
+  }
+
+  /**
+   * Transport log method
+   * @param  {String} level - log level
+   * @param  {Array} args - all methods
+   * @param  {Object} meta - meta infomations
+   * @return {Buffer|String} log message
+   *   - empty string means no log
+   *   - utf8 encoding return String
+   *   - other encoding return Buffer
+   */
+  log(level, args, meta) {
+    if (!meta?.ctx && this.options.localStorage) {
+      const ctx = this.options.localStorage.getStore();
+      if (ctx) {
+        meta = { ...meta, ctx };
+      }
+    }
+    return utils.format(level, args, meta, this.options);
+  }
+
+  /**
+   * reload Transport
+   */
+  reload() {}
+
+  /**
+   * close Transport
+   */
+  close() {}
+  end() {}
+}
+
+module.exports = Transport;