function Logger()

in logger.js [37:143]
74 lines of code
13 McCabe index (conditional complexity)

function Logger(opts) {
    if (!(this instanceof Logger)) {
        return new Logger(opts);
    }
    var self = this;

    if (!opts) {
        throw errors.OptsRequired();
    }

    if (!opts.meta) {
        throw errors.MetaRequired();
    }

    if (!opts.backends) {
        throw errors.BackendsRequired();
    }

    EventEmitter.call(this);

    var meta = this.meta = opts.meta;
    var transforms = opts.transforms || [];
    var basemetaTransforms = opts.basemetaTransforms || [];

    basemetaTransforms.forEach(function initTransforms(transform) {
        transforms.push(transform(meta));
    });

    transforms.push(safeSerializeMeta);
    transforms.push(serializableErrorTransform);
    transforms.push(writePidAndHost(meta));

    this.statsd = opts.statsd;

    this.path = opts.path = "";

    // Performs a deep copy of the default log levels, overlaying the
    // configured levels and filtering nulled levels.
    var levels = this.levels = {};
    var configuredLevels = extend(defaultLevels, opts.levels || {});
    Object.keys(configuredLevels)
        .forEach(function copyDefaultLevel(levelName) {
            // Setting a level in opts.levels to null disables that level.
            if (!configuredLevels[levelName]) {
                return;
            }
            // Each log level will contain an array of transforms by default,
            // that will be suffixed with globally configured transforms.
            var level = extend({transforms: []}, configuredLevels[levelName]);
            level.transforms = level.transforms.concat(transforms);
            levels[levelName] = level;
        });

    // Create a log level method, e.g., info(message, meta, cb?), for every
    // configured log level.
    Object.keys(levels)
        .forEach(function makeMethodForLevel(levelName) {
            self[levelName] = makeLogMethod(levelName);
        });

    // Create a stream for each of the configured backends, indexed by backend
    // name.
    // streams: Object<backendName, Stream>
    var streams = this.streams = Object.keys(opts.backends)
        .reduce(function accumulateStreams(streamByBackend, backendName) {
            var backend = opts.backends[backendName];
            if (!backend) {
                return streamByBackend;
            }

            streamByBackend[backendName] = backend.createStream(meta, {
                highWaterMark: opts.highWaterMark || 1000
            });
            return streamByBackend;
        }, {});

    // Creates an index of all the streams that each log level will write to,
    // keyed by log level.
    // The index is used by the writeEntry method to look up all the target
    // streams for the given level.
    // The parallel write method uses the backend name to annotate errors.
    // _streamsByLevel: Object<logLevel, Array<Object<backendName, Stream>>>
    this._streamsByLevel = Object.keys(levels)
        .reduce(function accumulateStreamsByLevel(streamsByLevel, levelName) {
            if (!levels[levelName]) {
                return streamsByLevel;
            }

            var level = levels[levelName];

            streamsByLevel[levelName] = level.backends
                .reduce(function accumulateStreamsByBackend(
                    levelStreams,
                    backendName
                ) {
                    if (streams[backendName]) {
                        levelStreams.push({
                            name: backendName,
                            stream: streams[backendName]
                        });
                    }
                    return levelStreams;
                }, []);

            return streamsByLevel;
        }, {});
}