rivetkit/dist/tsup/chunk-7E5K3375.js

Lightweight libraries for building stateful actors on edge platforms

import {
  getEnvUniversal
} from "./chunk-HI55LHM3.js";

// src/common/log.ts
import {
  pino,
  stdTimeFunctions
} from "pino";
import { z } from "zod";

// src/common/log-levels.ts
var LogLevels = {
  TRACE: 0,
  DEBUG: 1,
  INFO: 2,
  WARN: 3,
  ERROR: 4,
  CRITICAL: 5
};

// src/common/logfmt.ts
var LOG_LEVEL_COLORS = {
  [LogLevels.CRITICAL]: "\x1B[31m",
  // Red
  [LogLevels.ERROR]: "\x1B[31m",
  // Red
  [LogLevels.WARN]: "\x1B[33m",
  // Yellow
  [LogLevels.INFO]: "\x1B[32m",
  // Green
  [LogLevels.DEBUG]: "\x1B[36m",
  // Cyan
  [LogLevels.TRACE]: "\x1B[36m"
  // Cyan
};
var RESET_COLOR = "\x1B[0m";
function stringify(data) {
  let line = "";
  const entries = Object.entries(data);
  for (let i = 0; i < entries.length; i++) {
    const [key, valueRaw] = entries[i];
    let isNull = false;
    let valueString;
    if (valueRaw == null) {
      isNull = true;
      valueString = "";
    } else {
      valueString = valueRaw.toString();
    }
    if (valueString.length > 512 && key !== "msg" && key !== "error")
      valueString = `${valueString.slice(0, 512)}...`;
    const needsQuoting = valueString.indexOf(" ") > -1 || valueString.indexOf("=") > -1;
    const needsEscaping = valueString.indexOf('"') > -1 || valueString.indexOf("\\") > -1;
    valueString = valueString.replace(/\n/g, "\\n");
    if (needsEscaping) valueString = valueString.replace(/["\\]/g, "\\$&");
    if (needsQuoting || needsEscaping) valueString = `"${valueString}"`;
    if (valueString === "" && !isNull) valueString = '""';
    if (LOGGER_CONFIG.enableColor) {
      let color = "\x1B[2m";
      if (key === "level") {
        const level = LogLevels[valueString];
        const levelColor = LOG_LEVEL_COLORS[level];
        if (levelColor) {
          color = levelColor;
        }
      } else if (key === "msg") {
        color = "\x1B[32m";
      } else if (key === "trace") {
        color = "\x1B[34m";
      }
      line += `\x1B[0m\x1B[1m${key}\x1B[0m\x1B[2m=\x1B[0m${color}${valueString}${RESET_COLOR}`;
    } else {
      line += `${key}=${valueString}`;
    }
    if (i !== entries.length - 1) {
      line += " ";
    }
  }
  return line;
}
function formatTimestamp(date) {
  const year = date.getUTCFullYear();
  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
  const day = String(date.getUTCDate()).padStart(2, "0");
  const hours = String(date.getUTCHours()).padStart(2, "0");
  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
  const milliseconds = String(date.getUTCMilliseconds()).padStart(3, "0");
  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
}
function castToLogValue(v) {
  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint" || typeof v === "boolean" || v === null || v === void 0) {
    return v;
  }
  if (v instanceof Error) {
    return String(v);
  }
  try {
    return JSON.stringify(v);
  } catch {
    return "[cannot stringify]";
  }
}
var LOGGER_CONFIG = {
  enableColor: false,
  enableSpreadObject: false,
  enableErrorStack: false
};

// src/common/log.ts
var baseLogger;
var configuredLogLevel;
var loggerCache = /* @__PURE__ */ new Map();
var LogLevelSchema = z.enum([
  "trace",
  "debug",
  "info",
  "warn",
  "error",
  "fatal",
  "silent"
]);
function getPinoLevel(logLevel) {
  if (logLevel) {
    return logLevel;
  }
  if (configuredLogLevel) {
    return configuredLogLevel;
  }
  const raw = (getEnvUniversal("LOG_LEVEL") || "warn").toString().toLowerCase();
  const parsed = LogLevelSchema.safeParse(raw);
  if (parsed.success) {
    return parsed.data;
  }
  return "info";
}
function getIncludeTarget() {
  return getEnvUniversal("LOG_TARGET") === "1";
}
function configureBaseLogger(logger) {
  baseLogger = logger;
  loggerCache.clear();
}
function customWrite(level, o) {
  const entries = {};
  if (getEnvUniversal("LOG_TIMESTAMP") === "1" && o.time) {
    const date = typeof o.time === "number" ? new Date(o.time) : /* @__PURE__ */ new Date();
    entries.ts = formatTimestamp(date);
  }
  entries.level = level.toUpperCase();
  if (o.target) {
    entries.target = o.target;
  }
  if (o.msg) {
    entries.msg = o.msg;
  }
  for (const [key, value] of Object.entries(o)) {
    if (key !== "time" && key !== "level" && key !== "target" && key !== "msg" && key !== "pid" && key !== "hostname") {
      entries[key] = castToLogValue(value);
    }
  }
  const output = stringify(entries);
  console.log(output);
}
async function configureDefaultLogger(logLevel) {
  if (logLevel) {
    configuredLogLevel = logLevel;
  }
  baseLogger = pino({
    level: getPinoLevel(logLevel),
    messageKey: "msg",
    // Do not include pid/hostname in output
    base: {},
    // Keep a string level in the output
    formatters: {
      level(_label, number) {
        return { level: number };
      }
    },
    timestamp: getEnvUniversal("LOG_TIMESTAMP") === "1" ? stdTimeFunctions.epochTime : false,
    browser: {
      write: {
        fatal: customWrite.bind(null, "fatal"),
        error: customWrite.bind(null, "error"),
        warn: customWrite.bind(null, "warn"),
        info: customWrite.bind(null, "info"),
        debug: customWrite.bind(null, "debug"),
        trace: customWrite.bind(null, "trace")
      }
    },
    hooks: {
      logMethod(inputArgs, _method, level) {
        const levelMap = {
          10: "trace",
          20: "debug",
          30: "info",
          40: "warn",
          50: "error",
          60: "fatal"
        };
        const levelName = levelMap[level] || "info";
        const time = getEnvUniversal("LOG_TIMESTAMP") === "1" ? Date.now() : void 0;
        if (inputArgs.length >= 2) {
          const [objOrMsg, msg] = inputArgs;
          if (typeof objOrMsg === "object" && objOrMsg !== null) {
            customWrite(levelName, { ...objOrMsg, msg, time });
          } else {
            customWrite(levelName, { msg: String(objOrMsg), time });
          }
        } else if (inputArgs.length === 1) {
          const [objOrMsg] = inputArgs;
          if (typeof objOrMsg === "object" && objOrMsg !== null) {
            customWrite(levelName, { ...objOrMsg, time });
          } else {
            customWrite(levelName, { msg: String(objOrMsg), time });
          }
        }
      }
    }
  });
  loggerCache.clear();
}
function getBaseLogger() {
  if (!baseLogger) {
    configureDefaultLogger();
  }
  return baseLogger;
}
function getLogger(name = "default") {
  const cached = loggerCache.get(name);
  if (cached) {
    return cached;
  }
  const base = getBaseLogger();
  const child = getIncludeTarget() ? base.child({ target: name }) : base;
  loggerCache.set(name, child);
  return child;
}

export {
  LogLevelSchema,
  getPinoLevel,
  getIncludeTarget,
  configureBaseLogger,
  configureDefaultLogger,
  getBaseLogger,
  getLogger
};
//# sourceMappingURL=chunk-7E5K3375.js.map