winston-prisma 1.1.0

package/dist/winston_prisma/transports/http.js

@@ -0,0 +1,238 @@
+/**
+ * http.js: Transport for outputting to a json-rpcserver.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ */
+
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const {
+  Stream
+} = require('readable-stream');
+const TransportStream = require('winston-transport');
+const jsonStringify = require('safe-stable-stringify');
+
+/**
+ * Transport for outputting to a json-rpc server.
+ * @type {Stream}
+ * @extends {TransportStream}
+ */
+module.exports = class Http extends TransportStream {
+  /**
+   * Constructor function for the Http transport object responsible for
+   * persisting log messages and metadata to a terminal or TTY.
+   * @param {!Object} [options={}] - Options for this instance.
+   */
+  // eslint-disable-next-line max-statements
+  constructor(options = {}) {
+    super(options);
+    this.options = options;
+    this.name = options.name || 'http';
+    this.ssl = !!options.ssl;
+    this.host = options.host || 'localhost';
+    this.port = options.port;
+    this.auth = options.auth;
+    this.path = options.path || '';
+    this.agent = options.agent;
+    this.headers = options.headers || {};
+    this.headers['content-type'] = 'application/json';
+    this.batch = options.batch || false;
+    this.batchInterval = options.batchInterval || 5000;
+    this.batchCount = options.batchCount || 10;
+    this.batchOptions = [];
+    this.batchTimeoutID = -1;
+    this.batchCallback = {};
+    if (!this.port) {
+      this.port = this.ssl ? 443 : 80;
+    }
+  }
+
+  /**
+   * Core logging method exposed to Winston.
+   * @param {Object} info - TODO: add param description.
+   * @param {function} callback - TODO: add param description.
+   * @returns {undefined}
+   */
+  log(info, callback) {
+    this._request(info, null, null, (err, res) => {
+      if (res && res.statusCode !== 200) {
+        err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
+      }
+      if (err) {
+        this.emit('warn', err);
+      } else {
+        this.emit('logged', info);
+      }
+    });
+
+    // Remark: (jcrugzz) Fire and forget here so requests dont cause buffering
+    // and block more requests from happening?
+    if (callback) {
+      setImmediate(callback);
+    }
+  }
+
+  /**
+   * Query the transport. Options object is optional.
+   * @param {Object} options -  Loggly-like query options for this instance.
+   * @param {function} callback - Continuation to respond to when complete.
+   * @returns {undefined}
+   */
+  query(options, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    options = {
+      method: 'query',
+      params: this.normalizeQuery(options)
+    };
+    const auth = options.params.auth || null;
+    delete options.params.auth;
+    const path = options.params.path || null;
+    delete options.params.path;
+    this._request(options, auth, path, (err, res, body) => {
+      if (res && res.statusCode !== 200) {
+        err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
+      }
+      if (err) {
+        return callback(err);
+      }
+      if (typeof body === 'string') {
+        try {
+          body = JSON.parse(body);
+        } catch (e) {
+          return callback(e);
+        }
+      }
+      callback(null, body);
+    });
+  }
+
+  /**
+   * Returns a log stream for this transport. Options object is optional.
+   * @param {Object} options - Stream options for this instance.
+   * @returns {Stream} - TODO: add return description
+   */
+  stream(options = {}) {
+    const stream = new Stream();
+    options = {
+      method: 'stream',
+      params: options
+    };
+    const path = options.params.path || null;
+    delete options.params.path;
+    const auth = options.params.auth || null;
+    delete options.params.auth;
+    let buff = '';
+    const req = this._request(options, auth, path);
+    stream.destroy = () => req.destroy();
+    req.on('data', data => {
+      data = (buff + data).split(/\n+/);
+      const l = data.length - 1;
+      let i = 0;
+      for (; i < l; i++) {
+        try {
+          stream.emit('log', JSON.parse(data[i]));
+        } catch (e) {
+          stream.emit('error', e);
+        }
+      }
+      buff = data[l];
+    });
+    req.on('error', err => stream.emit('error', err));
+    return stream;
+  }
+
+  /**
+   * Make a request to a winstond server or any http server which can
+   * handle json-rpc.
+   * @param {function} options - Options to sent the request.
+   * @param {Object?} auth - authentication options
+   * @param {string} path - request path
+   * @param {function} callback - Continuation to respond to when complete.
+   */
+  _request(options, auth, path, callback) {
+    options = options || {};
+    auth = auth || this.auth;
+    path = path || this.path || '';
+    if (this.batch) {
+      this._doBatch(options, callback, auth, path);
+    } else {
+      this._doRequest(options, callback, auth, path);
+    }
+  }
+
+  /**
+   * Send or memorize the options according to batch configuration
+   * @param {function} options - Options to sent the request.
+   * @param {function} callback - Continuation to respond to when complete.
+   * @param {Object?} auth - authentication options
+   * @param {string} path - request path
+   */
+  _doBatch(options, callback, auth, path) {
+    this.batchOptions.push(options);
+    if (this.batchOptions.length === 1) {
+      // First message stored, it's time to start the timeout!
+      const me = this;
+      this.batchCallback = callback;
+      this.batchTimeoutID = setTimeout(function () {
+        // timeout is reached, send all messages to endpoint
+        me.batchTimeoutID = -1;
+        me._doBatchRequest(me.batchCallback, auth, path);
+      }, this.batchInterval);
+    }
+    if (this.batchOptions.length === this.batchCount) {
+      // max batch count is reached, send all messages to endpoint
+      this._doBatchRequest(this.batchCallback, auth, path);
+    }
+  }
+
+  /**
+   * Initiate a request with the memorized batch options, stop the batch timeout
+   * @param {function} callback - Continuation to respond to when complete.
+   * @param {Object?} auth - authentication options
+   * @param {string} path - request path
+   */
+  _doBatchRequest(callback, auth, path) {
+    if (this.batchTimeoutID > 0) {
+      clearTimeout(this.batchTimeoutID);
+      this.batchTimeoutID = -1;
+    }
+    const batchOptionsCopy = this.batchOptions.slice();
+    this.batchOptions = [];
+    this._doRequest(batchOptionsCopy, callback, auth, path);
+  }
+
+  /**
+   * Make a request to a winstond server or any http server which can
+   * handle json-rpc.
+   * @param {function} options - Options to sent the request.
+   * @param {function} callback - Continuation to respond to when complete.
+   * @param {Object?} auth - authentication options
+   * @param {string} path - request path
+   */
+  _doRequest(options, callback, auth, path) {
+    // Prepare options for outgoing HTTP request
+    const headers = Object.assign({}, this.headers);
+    if (auth && auth.bearer) {
+      headers.Authorization = `Bearer ${auth.bearer}`;
+    }
+    const req = (this.ssl ? https : http).request({
+      ...this.options,
+      method: 'POST',
+      host: this.host,
+      port: this.port,
+      path: `/${path.replace(/^\//, '')}`,
+      headers: headers,
+      auth: auth && auth.username && auth.password ? `${auth.username}:${auth.password}` : '',
+      agent: this.agent
+    });
+    req.on('error', callback);
+    req.on('response', res => res.on('end', () => callback(null, res)).resume());
+    req.end(Buffer.from(jsonStringify(options, this.options.replacer), 'utf8'));
+  }
+};

package/dist/winston_prisma/transports/index.js

@@ -0,0 +1,56 @@
+/**
+ * transports.js: Set of all transports Winston knows about.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ */
+
+'use strict';
+
+/**
+ * TODO: add property description.
+ * @type {Console}
+ */
+Object.defineProperty(exports, 'Console', {
+  configurable: true,
+  enumerable: true,
+  get() {
+    return require('./console');
+  }
+});
+
+/**
+ * TODO: add property description.
+ * @type {File}
+ */
+Object.defineProperty(exports, 'File', {
+  configurable: true,
+  enumerable: true,
+  get() {
+    return require('./file');
+  }
+});
+
+/**
+ * TODO: add property description.
+ * @type {Http}
+ */
+Object.defineProperty(exports, 'Http', {
+  configurable: true,
+  enumerable: true,
+  get() {
+    return require('./http');
+  }
+});
+
+/**
+ * TODO: add property description.
+ * @type {Stream}
+ */
+Object.defineProperty(exports, 'Stream', {
+  configurable: true,
+  enumerable: true,
+  get() {
+    return require('./stream');
+  }
+});

package/dist/winston_prisma/transports/stream.js

@@ -0,0 +1,63 @@
+/**
+ * stream.js: Transport for outputting to any arbitrary stream.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
+ */
+
+'use strict';
+
+const isStream = require('is-stream');
+const {
+  MESSAGE
+} = require('triple-beam');
+const os = require('os');
+const TransportStream = require('winston-transport');
+
+/**
+ * Transport for outputting to any arbitrary stream.
+ * @type {Stream}
+ * @extends {TransportStream}
+ */
+module.exports = class Stream extends TransportStream {
+  /**
+   * Constructor function for the Console transport object responsible for
+   * persisting log messages and metadata to a terminal or TTY.
+   * @param {!Object} [options={}] - Options for this instance.
+   */
+  constructor(options = {}) {
+    super(options);
+    if (!options.stream || !isStream(options.stream)) {
+      throw new Error('options.stream is required.');
+    }
+
+    // We need to listen for drain events when write() returns false. This can
+    // make node mad at times.
+    this._stream = options.stream;
+    this._stream.setMaxListeners(Infinity);
+    this.isObjectMode = options.stream._writableState.objectMode;
+    this.eol = typeof options.eol === 'string' ? options.eol : os.EOL;
+  }
+
+  /**
+   * Core logging method exposed to Winston.
+   * @param {Object} info - TODO: add param description.
+   * @param {Function} callback - TODO: add param description.
+   * @returns {undefined}
+   */
+  log(info, callback) {
+    setImmediate(() => this.emit('logged', info));
+    if (this.isObjectMode) {
+      this._stream.write(info);
+      if (callback) {
+        callback(); // eslint-disable-line callback-return
+      }
+      return;
+    }
+    this._stream.write(`${info[MESSAGE]}${this.eol}`);
+    if (callback) {
+      callback(); // eslint-disable-line callback-return
+    }
+    return;
+  }
+};

package/index.d.ts

@@ -0,0 +1,220 @@
+// Type definitions for winston 3.0
+// Project: https://github.com/winstonjs/winston
+
+/// <reference types="node" />
+
+import * as NodeJSStream from 'stream';
+
+import * as logform from 'logform';
+import * as Transport from 'winston-transport';
+
+import * as Config from './lib/winston_prisma/config/index';
+import * as Prisma from "./lib/winston_prisma/config/prisma-config"
+import * as Transports from './lib/winston_prisma/transports/index';
+
+declare namespace winston {
+  // Hoisted namespaces from other modules
+  export import format = logform.format;
+  export import Logform = logform;
+  export import config = Config;
+  export import transports = Transports;
+  export import transport = Transport;
+  export import prismalog = Prisma;
+  class ExceptionHandler {
+    constructor(logger: Logger);
+    logger: Logger;
+    handlers: Map<any, any>;
+    catcher: Function | boolean;
+
+    handle(...transports: Transport[]): void;
+    unhandle(...transports: Transport[]): void;
+    getAllInfo(err: string | Error): object;
+    getProcessInfo(): object;
+    getOsInfo(): object;
+    getTrace(err: Error): object;
+  }
+
+  class RejectionHandler {
+    constructor(logger: Logger);
+    logger: Logger;
+    handlers: Map<any, any>;
+    catcher: Function | boolean;
+
+    handle(...transports: Transport[]): void;
+    unhandle(...transports: Transport[]): void;
+    getAllInfo(err: string | Error): object;
+    getProcessInfo(): object;
+    getOsInfo(): object;
+    getTrace(err: Error): object;
+  }
+
+  interface QueryOptions {
+    rows?: number;
+    limit?: number;
+    start?: number;
+    from?: Date;
+    until?: Date;
+    order?: 'asc' | 'desc';
+    fields: any;
+  }
+
+  class Profiler {
+    logger: Logger;
+    start: Number;
+    done(info?: any): boolean;
+  }
+
+  type LogCallback = (
+    error?: any,
+    level?: string,
+    message?: string,
+    meta?: any
+  ) => void;
+
+  interface LogEntry {
+    level: string;
+    message: string;
+    [optionName: string]: any;
+  }
+
+  interface LogMethod {
+    (level: string, message: string, callback: LogCallback): Logger;
+    (level: string, message: string, meta: any, callback: LogCallback): Logger;
+    (level: string, message: string, ...meta: any[]): Logger;
+    (entry: LogEntry): Logger;
+    (level: string, message: any): Logger;
+  }
+
+  interface LeveledLogMethod {
+    (message: string, callback: LogCallback): Logger;
+    (message: string, meta: any, callback: LogCallback): Logger;
+    (message: string, ...meta: any[]): Logger;
+    (message: any): Logger;
+    (infoObject: object): Logger;
+  }
+
+  interface LoggerOptions {
+    levels?: Config.AbstractConfigSetLevels;
+    silent?: boolean;
+    format?: logform.Format;
+    level?: string;
+    exitOnError?: Function | boolean;
+    defaultMeta?: any;
+    transports?: Transport[] | Transport;
+    handleExceptions?: boolean;
+    handleRejections?: boolean;
+    exceptionHandlers?: any;
+    rejectionHandlers?: any;
+  }
+
+  class Logger extends NodeJSStream.Transform {
+    constructor(options?: LoggerOptions);
+
+    silent: boolean;
+    format: logform.Format;
+    levels: Config.AbstractConfigSetLevels;
+    level: string;
+    transports: Transport[];
+    exceptions: ExceptionHandler;
+    rejections: RejectionHandler;
+    profilers: object;
+    exitOnError: Function | boolean;
+    defaultMeta?: any;
+
+    log: LogMethod;
+    add(transport: Transport): this;
+    remove(transport: Transport): this;
+    clear(): this;
+    close(): this;
+
+    // for cli and npm levels
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    help: LeveledLogMethod;
+    data: LeveledLogMethod;
+    info: LeveledLogMethod;
+    debug: LeveledLogMethod;
+    prompt: LeveledLogMethod;
+    http: LeveledLogMethod;
+    verbose: LeveledLogMethod;
+    input: LeveledLogMethod;
+    silly: LeveledLogMethod;
+
+    // for syslog levels only
+    emerg: LeveledLogMethod;
+    alert: LeveledLogMethod;
+    crit: LeveledLogMethod;
+    warning: LeveledLogMethod;
+    notice: LeveledLogMethod;
+
+    query(
+      options?: QueryOptions,
+      callback?: (err: Error, results: any) => void
+    ): any;
+    stream(options?: any): NodeJS.ReadableStream;
+
+    startTimer(): Profiler;
+    profile(id: string | number, meta?: Record<string, any>): this;
+
+    configure(options: LoggerOptions): void;
+
+    child(options: Object): this;
+
+    isLevelEnabled(level: string): boolean;
+    isErrorEnabled(): boolean;
+    isWarnEnabled(): boolean;
+    isInfoEnabled(): boolean;
+    isVerboseEnabled(): boolean;
+    isDebugEnabled(): boolean;
+    isSillyEnabled(): boolean;
+  }
+
+  class Container {
+    loggers: Map<string, Logger>;
+    options: LoggerOptions;
+
+    add(id: string, options?: LoggerOptions): Logger;
+    get(id: string, options?: LoggerOptions): Logger;
+    has(id: string): boolean;
+    close(id?: string): void;
+
+    constructor(options?: LoggerOptions);
+  }
+
+  let version: string;
+  let loggers: Container;
+
+  let addColors: (target: Config.AbstractConfigSetColors) => any;
+  let createLogger: (options?: LoggerOptions) => Logger;
+
+  // Pass-through npm level methods routed to the default logger.
+  let error: LeveledLogMethod;
+  let warn: LeveledLogMethod;
+  let info: LeveledLogMethod;
+  let http: LeveledLogMethod;
+  let verbose: LeveledLogMethod;
+  let debug: LeveledLogMethod;
+  let silly: LeveledLogMethod;
+
+  // Other pass-through methods routed to the default logger.
+  let log: LogMethod;
+  let query: (
+    options?: QueryOptions,
+    callback?: (err: Error, results: any) => void
+  ) => any;
+  let stream: (options?: any) => NodeJS.ReadableStream;
+  let add: (transport: Transport) => Logger;
+  let remove: (transport: Transport) => Logger;
+  let clear: () => Logger;
+  let startTimer: () => Profiler;
+  let profile: (id: string | number) => Logger;
+  let configure: (options: LoggerOptions) => void;
+  let child: (options: Object) => Logger;
+  let level: string;
+  let exceptions: ExceptionHandler;
+  let rejections: RejectionHandler;
+  let exitOnError: Function | boolean;
+  // let default: object;
+}
+
+export = winston;