Code coverage report for legacy.js

# All files legacy.js

69.23% Statements 18/26
43.75% Branches 7/16
20% Functions 1/5
69.23% Lines 18/26

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76

    1x
    1x

    1x
    3x
    3x
    2x

    1x

    1x
    1x
    1x
    1x

    1x

    1x
    1x
    1x

    1x

    1x

    1x

     'use strict';

    const util = require('util');
    const TransportStream = require('./');

    /**
     * Constructor function for the LegacyTransportStream. This is an internal wrapper
     * `winston >= 3` uses to wrap older transports implementing log(level, message, meta).
     *
     * @param  {Object} opts Options for this TransportStream instance.
     *   @param {Transpot} opts.transport winston@2 or older Transport to wrap.
     */
    var LegacyTransportStream = module.exports = function LegacyTransportStream(opts) {
      opts = opts || {};
      if (!opts.transport || typeof opts.transport.log !== 'function') {
        throw new Error('Invalid transport, must be an object with a log method.');
      }

      TransportStream.call(this, opts);

      var self = this;
      this.transport = opts.transport;
      this.level = opts.transport.level;
      this.handleExceptions = opts.transport.handleExceptions;

      console.error([
        `${opts.transport.name} is a legacy winston transport. Consider upgrading: `,
        '- Upgrade docs: https://github.com/winstonjs/winston/tree/master/UPGRADE.md'
      ].join('\n'));

      //
      // Properly bubble up errors from the transport to the LegacyTransportStream
      // instance, but only once no matter how many times this transport is shared.
      //
      function transportError(err) {
        self.emit('error', err, self.transport);
      }

      Eif (!this.transport.__winstonError) {
        this.transport.__winstonError = transportError;
        this.transport.on('error', this.transport.__winstonError);
      }
    };

    util.inherits(LegacyTransportStream, TransportStream);

    /*
     * @private function _write(info)
     * Writes the info object to our transport instance.
     */
    LegacyTransportStream.prototype._write = function (info, enc, callback) {
      //
      // Remark: This has to be handled in the base transport now because we cannot
      // conditionally write to our pipe targets as stream.
      //
      if (!this.level || this.levels[this.level] >= this.levels[info.level]) {
        this.transport.log(info.level, info.message, info, function () {});
      }

      callback(null);
    };

    /*
     * Clean up error handling state on the legacy transport associated
     * with this instance.
     */
    LegacyTransportStream.prototype.close = function () {
      if (this.transport.close) {
        this.transport.close();
      }

      if (this.transport.__winstonError) {
        this.transport.removeListener('error', this.transport.__winstonError);
      }
    };