~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
100 lines · 3.5 KB Raw History
export type Logger = (
  level: string,
  message: string,
  meta?: Record<string, unknown>,
) => void;

export interface LoggerInterface {
  info: (message: string, meta?: Record<string, unknown>) => void;
  warn: (message: string, meta?: Record<string, unknown>) => void;
  error: (message: string, meta?: Record<string, unknown>) => void;
  debug: (message: string, meta?: Record<string, unknown>) => void;
}

export function createLogger(prefix?: string): LoggerInterface;
export function createLogger(opts: { serviceName: string }): StructuredLoggerInterface;
export function createLogger(
  arg?: string | { serviceName: string },
): LoggerInterface | StructuredLoggerInterface {
  if (arg && typeof arg === "object" && "serviceName" in arg) {
    return createStructuredLogger(arg.serviceName);
  }
  const prefix = arg as string | undefined;
  const p = prefix ? `[${prefix}] ` : "";
  return {
    info: (msg, meta) => console.log(`${p}INFO  ${msg}`, meta ?? ""),
    warn: (msg, meta) => console.warn(`${p}WARN  ${msg}`, meta ?? ""),
    error: (msg, meta) => console.error(`${p}ERROR ${msg}`, meta ?? ""),
    debug: (msg, meta) => console.log(`${p}DEBUG ${msg}`, meta ?? ""),
  };
}

export function rawLogger(prefix?: string): Logger {
  const p = prefix ? `[${prefix}] ` : "";
  return (level, message, meta) => {
    const line = `${p}${level.toUpperCase()} ${message}`;
    if (level === "error") console.error(line, meta ?? "");
    else if (level === "warn") console.warn(line, meta ?? "");
    else console.log(line, meta ?? "");
  };
}

export type LogLevel = "debug" | "info" | "warn" | "error";

const LEVEL_ORDER: Record<LogLevel, number> = { debug: 0, info: 1, warn: 2, error: 3 };

export interface StructuredLoggerInterface {
  info: (message: string, meta?: Record<string, unknown>) => void;
  warn: (message: string, meta?: Record<string, unknown>) => void;
  error: (message: string, meta?: Record<string, unknown>) => void;
  debug: (message: string, meta?: Record<string, unknown>) => void;
}

export function rawStructuredLogger(prefix?: string, minLevel?: LogLevel): Logger {
  const p = prefix ?? "";
  const resolvedMinLevel = minLevel ?? "info";
  const minRank = LEVEL_ORDER[resolvedMinLevel] ?? 1;
  return (level, message, meta) => {
    const lvl = level as LogLevel;
    if ((LEVEL_ORDER[lvl] ?? 1) < minRank) return;
    const line = JSON.stringify({
      ts: new Date().toISOString(),
      level: lvl,
      message,
      prefix: p,
      ...meta,
    });
    if (level === "error" || level === "warn") console.error(line);
    else console.log(line);
  };
}

export function createStructuredLogger(
  prefix?: string,
  minLevel?: LogLevel,
): StructuredLoggerInterface {
  const raw = rawStructuredLogger(prefix, minLevel);
  return {
    info: (message, meta) => raw("info", message, meta),
    warn: (message, meta) => raw("warn", message, meta),
    error: (message, meta) => raw("error", message, meta),
    debug: (message, meta) => raw("debug", message, meta),
  };
}

export const noopLogger: Logger = () => {};

export const noopLoggerInterface: LoggerInterface = {
  info: () => {},
  warn: () => {},
  error: () => {},
  debug: () => {},
};

/** Read MIN_LOG_LEVEL env var, returning valid LogLevel or "info" default.
 * CLIs call this to propagate env config into createStructuredLogger. */
export function getMinLogLevelFromEnv(): LogLevel {
  const raw = globalThis.Deno?.env?.get("MIN_LOG_LEVEL");
  if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") return raw;
  return "info";
}