envio/src/Logging.res.js

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE
'use strict';

var Pino = require("./bindings/Pino.res.js");
var Pino$1 = require("pino");
var Utils = require("./Utils.res.js");
var Js_exn = require("rescript/lib/js/js_exn.js");
var Js_dict = require("rescript/lib/js/js_dict.js");
var Caml_obj = require("rescript/lib/js/caml_obj.js");
var Caml_option = require("rescript/lib/js/caml_option.js");

var logLevels = Js_dict.fromArray([
      [
        "udebug",
        32
      ],
      [
        "uinfo",
        34
      ],
      [
        "uwarn",
        36
      ],
      [
        "uerror",
        38
      ],
      [
        "trace",
        10
      ],
      [
        "debug",
        20
      ],
      [
        "info",
        30
      ],
      [
        "warn",
        40
      ],
      [
        "error",
        50
      ],
      [
        "fatal",
        60
      ]
    ]);

var logger = {
  contents: undefined
};

function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel) {
  var pinoFile_target = "pino/file";
  var pinoFile_options = Caml_option.some(Pino.Transport.makeTransportOptions({
            destination: logFilePath,
            append: true,
            mkdir: true
          }));
  var pinoFile_level = defaultFileLogLevel;
  var pinoFile = {
    target: pinoFile_target,
    options: pinoFile_options,
    level: pinoFile_level
  };
  var makeMultiStreamLogger = function (none, none$1) {
    return Pino.MultiStreamLogger.make(userLogLevel, logLevels, none, none$1, defaultFileLogLevel);
  };
  switch (logStrategy) {
    case "ecs-file" :
        var newrecord = Caml_obj.obj_dup(Pino.ECS.make());
        return Pino$1((newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
    case "ecs-console" :
        var newrecord$1 = Caml_obj.obj_dup(Pino.ECS.make());
        return Pino$1((newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
    case "ecs-console-multistream" :
        return makeMultiStreamLogger(undefined, Pino.ECS.make());
    case "file-only" :
        return Pino$1({
                    level: defaultFileLogLevel,
                    customLevels: logLevels
                  }, Pino$1.transport(pinoFile));
    case "console-raw" :
    case "console-pretty" :
        return makeMultiStreamLogger(undefined, undefined);
    case "both-prettyconsole" :
        return makeMultiStreamLogger(logFilePath, undefined);
    
  }
}

function setLogger(l) {
  logger.contents = l;
}

function getLogger() {
  var logger$1 = logger.contents;
  if (logger$1 !== undefined) {
    return logger$1;
  } else {
    return Js_exn.raiseError("Unreachable code. Logger not initialized");
  }
}

function setLogLevel(level) {
  getLogger().level = level;
}

function trace(message) {
  getLogger().trace(Pino.createPinoMessage(message));
}

function debug(message) {
  getLogger().debug(Pino.createPinoMessage(message));
}

function info(message) {
  getLogger().info(Pino.createPinoMessage(message));
}

function warn(message) {
  getLogger().warn(Pino.createPinoMessage(message));
}

function error(message) {
  getLogger().error(Pino.createPinoMessage(message));
}

function errorWithExn(error, message) {
  getLogger().error(Pino.createPinoMessageWithError(message, error));
}

function fatal(message) {
  getLogger().fatal(Pino.createPinoMessage(message));
}

function childTrace(logger, params) {
  logger.trace(Pino.createPinoMessage(params));
}

function childDebug(logger, params) {
  logger.debug(Pino.createPinoMessage(params));
}

function childInfo(logger, params) {
  logger.info(Pino.createPinoMessage(params));
}

function childWarn(logger, params) {
  logger.warn(Pino.createPinoMessage(params));
}

function childError(logger, params) {
  logger.error(Pino.createPinoMessage(params));
}

function childErrorWithExn(logger, error, params) {
  logger.error(Pino.createPinoMessageWithError(params, error));
}

function childFatal(logger, params) {
  logger.fatal(Pino.createPinoMessage(params));
}

function createChild(params) {
  return getLogger().child(Pino.createChildParams(params));
}

function createChildFrom(logger, params) {
  return logger.child(Pino.createChildParams(params));
}

var cacheKey = "_logger";

function getItemLogger(item) {
  var l = item[cacheKey];
  if (l !== undefined) {
    return Caml_option.valFromOption(l);
  }
  var tmp;
  if (item.kind === 0) {
    var eventConfig = item.eventConfig;
    tmp = Pino.createChildParams({
          contractName: eventConfig.contractName,
          eventName: eventConfig.name,
          chainId: item.chain,
          block: item.blockNumber,
          logIndex: item.logIndex,
          address: item.event.srcAddress
        });
  } else {
    var onBlockConfig = item.onBlockConfig;
    tmp = Pino.createChildParams({
          onBlock: onBlockConfig.name,
          chainId: onBlockConfig.chainId,
          block: item.blockNumber
        });
  }
  var l$1 = getLogger().child(tmp);
  item[cacheKey] = l$1;
  return l$1;
}

function logForItem(item, level, message, params) {
  return getItemLogger(item)[level](params, message);
}

function noopLogger_debug(_message, param) {
  
}

function noopLogger_info(_message, param) {
  
}

function noopLogger_warn(_message, param) {
  
}

function noopLogger_error(_message, param) {
  
}

function noopLogger_errorWithExn(_message, _exn) {
  
}

var noopLogger = {
  debug: noopLogger_debug,
  info: noopLogger_info,
  warn: noopLogger_warn,
  error: noopLogger_error,
  errorWithExn: noopLogger_errorWithExn
};

function getUserLogger(item) {
  return {
          debug: (function (message, params) {
              getItemLogger(item)["udebug"](params, message);
            }),
          info: (function (message, params) {
              getItemLogger(item)["uinfo"](params, message);
            }),
          warn: (function (message, params) {
              getItemLogger(item)["uwarn"](params, message);
            }),
          error: (function (message, params) {
              getItemLogger(item)["uerror"](params, message);
            }),
          errorWithExn: (function (message, exn) {
              var params = {
                err: Utils.prettifyExn(exn)
              };
              getItemLogger(item)["uerror"](params, message);
            })
        };
}

exports.logLevels = logLevels;
exports.makeLogger = makeLogger;
exports.setLogger = setLogger;
exports.getLogger = getLogger;
exports.setLogLevel = setLogLevel;
exports.trace = trace;
exports.debug = debug;
exports.info = info;
exports.warn = warn;
exports.error = error;
exports.errorWithExn = errorWithExn;
exports.fatal = fatal;
exports.childTrace = childTrace;
exports.childDebug = childDebug;
exports.childInfo = childInfo;
exports.childWarn = childWarn;
exports.childError = childError;
exports.childErrorWithExn = childErrorWithExn;
exports.childFatal = childFatal;
exports.createChild = createChild;
exports.createChildFrom = createChildFrom;
exports.getItemLogger = getItemLogger;
exports.logForItem = logForItem;
exports.noopLogger = noopLogger;
exports.getUserLogger = getUserLogger;
/* logLevels Not a pure module */