envio/src/Logging.res.mjs

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

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as Pino from "./bindings/Pino.res.mjs";
import * as Pino$1 from "pino";
import * as Utils from "./Utils.res.mjs";
import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";

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

let logger = {
  contents: undefined
};

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

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

function getLogger() {
  let logger$1 = logger.contents;
  if (logger$1 !== undefined) {
    return logger$1;
  } else {
    return Stdlib_JsError.throwWithMessage("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));
}

let cacheKey = "_logger";

function getItemLogger(item) {
  let l = item[cacheKey];
  if (l !== undefined) {
    return l;
  }
  let tmp;
  if (item.kind === 0) {
    let 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 {
    let onBlockConfig = item.onBlockConfig;
    tmp = Pino.createChildParams({
      onBlock: onBlockConfig.name,
      chainId: onBlockConfig.chainId,
      block: item.blockNumber
    });
  }
  let l$1 = getLogger().child(tmp);
  item[cacheKey] = l$1;
  return l$1;
}

function logForItem(item, level, message, params) {
  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) {
  
}

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

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

export {
  logLevels,
  makeLogger,
  setLogger,
  getLogger,
  setLogLevel,
  trace,
  debug,
  info,
  warn,
  error,
  errorWithExn,
  fatal,
  childTrace,
  childDebug,
  childInfo,
  childWarn,
  childError,
  childErrorWithExn,
  childFatal,
  createChild,
  createChildFrom,
  getItemLogger,
  logForItem,
  noopLogger,
  getUserLogger,
}
/* logLevels Not a pure module */