@strkfarm/sdk 2.0.0-dev.26 → 2.0.0-dev.28

package/src/utils/logger.node.ts

@@ -1,35 +1,270 @@
+import fs from "fs";
+import path from "path";
 import winston, { format } from "winston";
 
+export type LoggerLevel = "error" | "warn" | "info" | "verbose" | "debug";
+
+export interface LoggerConfig {
+  level?: LoggerLevel;
+  consoleLevel?: LoggerLevel;
+  fileLevel?: LoggerLevel;
+  filePath?: string;
+  enableConsole?: boolean;
+  enableFile?: boolean;
+  colorizeConsole?: boolean;
+  shortErrorsInConsole?: boolean;
+  emitConfigLog?: boolean;
+}
+
 const colors = {
   error: "red",
   warn: "yellow",
   info: "blue",
-  verbose: "white",
-  debug: "white",
+  verbose: "cyan",
+  debug: "gray",
 };
-
-// Add custom colors to Winston
 winston.addColors(colors);
 
-export const logger = winston.createLogger({
-  level: "debug", // Set the minimum logging level
-  format: format.combine(
-    format.colorize({ all: true }), // Apply custom colors
-    format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), // Add timestamp to log messages
-    format.printf(({ timestamp, level, message, ...meta }) => {
-      let msg = `${timestamp} ${level}: ${message}`;
-      // Print stack trace if error is passed
-      if (meta && meta[Symbol.for("splat")]) {
-        for (const arg of meta[Symbol.for("splat")]) {
-          if (arg instanceof Error) {
-            msg += `\n${arg.stack}`;
-          }
-        }
+const stringifyUnknown = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  if (typeof value === "undefined") return "undefined";
+  if (value === null) return "null";
+  if (value instanceof Error) return value.message || value.name || "Error";
+  try {
+    const encoded = JSON.stringify(value, (_, v) =>
+      typeof v === "bigint" ? v.toString() : v,
+    );
+    return encoded ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const stripAnsi = (text: unknown): string =>
+  stringifyUnknown(text).replace(/\u001b\[[0-9;]*m/g, "");
+
+const escapeValue = (value: string): string =>
+  value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+
+const escapeMessageValue = (value: string): string =>
+  value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, "'")
+    .replace(/\n/g, "\\n");
+
+const ANSI = {
+  reset: "\x1b[0m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+};
+
+const paint = (text: string, color: string): string =>
+  `${color}${text}${ANSI.reset}`;
+
+const highlightRoutes = (text: string): string =>
+  text.replace(/\b[A-Z][A-Z0-9_]{2,}\b/g, (token) => paint(token, ANSI.yellow));
+
+const highlightCases = (text: string): string =>
+  text.replace(/\[[A-Z][A-Z0-9_]+\]/g, (token) => paint(token, ANSI.green));
+
+const colorizeMessageForConsole = (message: string): string => {
+  const hasExtendedTradeContext =
+    /\bEXTENDED_(LIMIT|MARKET)_(BUY|SELL)\b/.test(message) ||
+    /\bEXTENDED_(INCREASE|DECREASE)_LEVER\b/.test(message);
+
+  if (hasExtendedTradeContext && /\b(SUCCESS|SUCCEEDED|FILLED)\b/i.test(message)) {
+    return paint(highlightRoutes(message), ANSI.green);
+  }
+
+  if (
+    hasExtendedTradeContext &&
+    /\b(INITIATED|PENDING|SUBMITTED|RETRY|PARTIAL)\b/i.test(message)
+  ) {
+    return paint(highlightRoutes(message), ANSI.yellow);
+  }
+
+  // Failure paths should dominate visually.
+  if (/\b(fail|failed|failure|error)\b/i.test(message)) {
+    return paint(highlightRoutes(highlightCases(message)), ANSI.red);
+  }
+
+  if (/Transaction sent/i.test(message)) {
+    return paint(message, ANSI.yellow);
+  }
+
+  if (/Transaction succeeded/i.test(message)) {
+    return paint(message, ANSI.green);
+  }
+
+  if (/Detected \d+ case\(s\)/i.test(message)) {
+    return paint(highlightRoutes(highlightCases(message)), ANSI.green);
+  }
+
+  if (/_executeStandardCase route/i.test(message)) {
+    return paint(highlightRoutes(message), ANSI.green);
+  }
+
+  // For route-heavy messages, keep routes highlighted in yellow.
+  if (/\broute\b/i.test(message)) {
+    return highlightRoutes(message);
+  }
+
+  return message;
+};
+
+const FIXED_TAG_WIDTH = 10;
+
+const toFixedTag = (rawTag: string): string => {
+  const compact = rawTag.replace(/[^A-Za-z0-9_-]/g, "");
+  if (!compact) return "general".slice(0, FIXED_TAG_WIDTH).padEnd(FIXED_TAG_WIDTH, " ");
+  return compact.slice(0, FIXED_TAG_WIDTH).padEnd(FIXED_TAG_WIDTH, " ");
+};
+
+const extractTagAndMessage = (rawMessage: string): { tag: string; body: string } => {
+  const normalized = stripAnsi(rawMessage).trim();
+
+  const bracketTagMatch = normalized.match(/^\[([^\]]+)\]\s*(.*)$/);
+  if (bracketTagMatch) {
+    return {
+      tag: toFixedTag(bracketTagMatch[1]),
+      body: bracketTagMatch[2] || normalized,
+    };
+  }
+
+  const scopeTagMatch = normalized.match(/^([A-Za-z0-9_-]+)::\s*(.*)$/);
+  if (scopeTagMatch) {
+    return {
+      tag: toFixedTag(scopeTagMatch[1]),
+      body: scopeTagMatch[2] || normalized,
+    };
+  }
+
+  return {
+    tag: toFixedTag("general"),
+    body: normalized,
+  };
+};
+
+const getStackFromMeta = (
+  stack: unknown,
+  meta: Record<string, unknown>,
+): string | undefined => {
+  if (typeof stack === "string" && stack.length > 0) {
+    return stack;
+  }
+  const splat = meta[Symbol.for("splat") as unknown as keyof typeof meta] as unknown;
+  if (Array.isArray(splat)) {
+    for (const item of splat) {
+      if (item instanceof Error && item.stack) {
+        return item.stack;
       }
-      return msg;
-    })
-  ),
-  transports: [
-    new winston.transports.Console(), // Output logs to the console
-  ],
+    }
+  }
+  return undefined;
+};
+
+const DEFAULT_LEVEL = (
+  process.env.LOG_LEVEL ||
+  process.env.SDK_LOG_LEVEL ||
+  "debug"
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_CONSOLE_LEVEL = (
+  process.env.LOG_CONSOLE_LEVEL || "info"
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_FILE_LEVEL = (
+  process.env.LOG_FILE_LEVEL || DEFAULT_LEVEL
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_FILE_PATH = process.env.LOG_FILE_PATH;
+
+export const logger = winston.createLogger({
+  level: DEFAULT_LEVEL,
+  transports: [],
 });
+
+export function configureLogger(config: LoggerConfig = {}): winston.Logger {
+  const level = config.level ?? DEFAULT_LEVEL;
+  const consoleLevel = config.consoleLevel ?? DEFAULT_CONSOLE_LEVEL;
+  const fileLevel = config.fileLevel ?? DEFAULT_FILE_LEVEL;
+  const filePath = config.filePath ?? DEFAULT_FILE_PATH;
+  const enableConsole = config.enableConsole ?? true;
+  const enableFile = config.enableFile ?? Boolean(filePath);
+  const colorizeConsole = config.colorizeConsole ?? true;
+  const shortErrorsInConsole = config.shortErrorsInConsole ?? true;
+  const emitConfigLog = config.emitConfigLog ?? false;
+
+  logger.clear();
+  logger.level = level;
+
+  if (enableConsole) {
+    logger.add(
+      new winston.transports.Console({
+        level: consoleLevel,
+        format: format.combine(
+          colorizeConsole ? format.colorize({ level: true }) : format.uncolorize(),
+          format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+          format.errors({ stack: true }),
+          format.printf(({ timestamp, level, message, stack, ...meta }) => {
+            const baseMessage = stringifyUnknown(message);
+            const { tag, body } = extractTagAndMessage(baseMessage);
+            const consoleBody = colorizeConsole
+              ? colorizeMessageForConsole(body)
+              : body;
+            let out = `ts="${timestamp}" level=${stringifyUnknown(level)} [${tag}] msg="${escapeMessageValue(consoleBody)}"`;
+            if (!shortErrorsInConsole) {
+              const derivedStack = getStackFromMeta(stack, meta);
+              if (derivedStack) {
+                out += ` stack="${escapeValue(derivedStack)}"`;
+              }
+            }
+            return out;
+          }),
+        ),
+      }),
+    );
+  }
+
+  if (enableFile && filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    logger.add(
+      new winston.transports.File({
+        filename: filePath,
+        level: fileLevel,
+        format: format.combine(
+          format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+          format.errors({ stack: true }),
+          format.printf(({ timestamp, level, message, stack, ...meta }) => {
+            const parsedMessage = stringifyUnknown(message);
+            const normalizedMessage = stripAnsi(parsedMessage);
+            const { tag, body } = extractTagAndMessage(normalizedMessage);
+            let out = `ts="${timestamp}" level=${stripAnsi(level)} [${tag}] msg="${escapeMessageValue(body)}"`;
+            const derivedStack = getStackFromMeta(stack, meta);
+            if (derivedStack) {
+              out += ` stack="${escapeValue(stripAnsi(derivedStack))}"`;
+            }
+            const metaCopy = { ...meta } as Record<string, unknown>;
+            delete metaCopy[
+              Symbol.for("splat") as unknown as keyof typeof metaCopy
+            ];
+            if (Object.keys(metaCopy).length > 0) {
+              out += ` meta=${escapeValue(stringifyUnknown(metaCopy))}`;
+            }
+            return out;
+          }),
+        ),
+      }),
+    );
+  }
+
+  if (emitConfigLog) {
+    logger.info(
+      `[Logger] configured level=${level} console=${enableConsole ? consoleLevel : "off"} file=${enableFile ? fileLevel : "off"}${filePath ? ` path=${filePath}` : ""}`,
+    );
+  }
+  return logger;
+}
+
+configureLogger();