@aimee-blue/ab-service-kit/lib/shared/logging/logger.js

Aimee Blue Service Template

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createLogger = createLogger;
exports.createNoOpLogger = createNoOpLogger;
exports.createTaggedLogger = createTaggedLogger;
exports.createNoOpTaggedLogger = createNoOpTaggedLogger;
exports.defaultLogger = void 0;

var _logEvents = require("./logEvents");

var _basicLogger = require("./basicLogger");

function createLogger(basicLogger = (0, _basicLogger.defaultBasicLogger)()) {
  return Object.freeze({ ...basicLogger,
    logEvents: arg => (0, _logEvents.logEvents)((0, _logEvents.logEventsParams)(arg, basicLogger))
  });
}

function createNoOpLogger() {
  const basicLogger = (0, _basicLogger.createNoOpBasicLogger)();
  return Object.freeze({ ...basicLogger,
    logEvents: _arg => stream => stream
  });
}

const defaultLogger = createLogger();
exports.defaultLogger = defaultLogger;

function splitFirstLineAndBody(text) {
  // empty or whitespace only?
  if (/^\s*$/u.test(text)) {
    return [text, ''];
  }

  const firstLineAndRest = /^(\s*([^\s\n]+[^\n]*)+)(.*)/u;
  const result = firstLineAndRest.exec(text);

  if (!result) {
    return [text, ''];
  }

  return [result[1], result[3]];
}

function determineTagsInjectionPoint(args) {
  const emptyOrWhitespace = /^\s*$/u;
  const injectAt = args.findIndex(arg => {
    if (typeof arg === 'string' && emptyOrWhitespace.test(arg)) {
      return false;
    }

    return true;
  });

  if (injectAt === -1) {
    return [args, []];
  }

  const beforeArgs = args.slice(0, injectAt);
  const injectAtArg = args[injectAt];
  const afterArgs = args.slice(injectAt + 1);

  if (typeof injectAtArg === 'string') {
    const [firstLine, rest] = splitFirstLineAndBody(injectAtArg);
    return [firstLine ? [...beforeArgs, firstLine] : beforeArgs, rest ? [rest, ...afterArgs] : afterArgs];
  }

  return [beforeArgs, [injectAtArg, ...afterArgs]];
}

function appendTags(args, tags) {
  const [before, after] = determineTagsInjectionPoint(args);
  return [...before, ...tags, ...after];
}

function isTaggedLogger(logger) {
  return logger !== null && typeof logger === 'object' && 'withTags' in logger && 'parent' in logger;
}

function taggedLoggerFactory(parent, startWith = []) {
  const locked = [...startWith];
  return Object.freeze({
    log: (...args) => {
      parent.log(...appendTags(args, locked));
    },
    warn: (...args) => {
      parent.warn(...appendTags(args, locked));
    },
    error: (...args) => {
      parent.error(...appendTags(args, locked));
    },
    withTags: (...args) => {
      return taggedLoggerFactory(parent, [...locked, ...args]);
    },
    logEvents: (0, _logEvents.createTaggedLogEvents)(startWith, parent),
    parent
  });
}

function createTaggedLogger(tags, parent) {
  if (parent && isTaggedLogger(parent)) {
    return parent.withTags(...tags);
  }

  return taggedLoggerFactory(parent || (0, _basicLogger.defaultBasicLogger)(), tags);
}

function createNoOpTaggedLogger() {
  return createTaggedLogger([], createNoOpLogger());
}
//# sourceMappingURL=logger.js.map