@contractspec/lib.logger 1.57.0 → 1.58.0

package/dist/elysia-plugin.js

@@ -0,0 +1,793 @@
+// @bun
+// src/context.node.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+class LogContext {
+  static instance;
+  storage;
+  constructor() {
+    this.storage = new AsyncLocalStorage;
+  }
+  static getInstance() {
+    if (!LogContext.instance) {
+      LogContext.instance = new LogContext;
+    }
+    return LogContext.instance;
+  }
+  run(context, fn) {
+    const contextData = {
+      context: { ...context },
+      trace: this.getCurrentTrace()
+    };
+    return this.storage.run(contextData, fn);
+  }
+  extend(additionalContext, fn) {
+    const currentContext = this.getContext();
+    const mergedContext = {
+      ...currentContext,
+      ...additionalContext
+    };
+    return this.run(mergedContext, fn);
+  }
+  set(key, value) {
+    const current = this.storage.getStore();
+    if (current) {
+      current.context[key] = value;
+    }
+  }
+  get(key) {
+    const current = this.storage.getStore();
+    return current?.context?.[key];
+  }
+  getContext() {
+    const current = this.storage.getStore();
+    return current?.context || {};
+  }
+  setTrace(trace) {
+    const current = this.storage.getStore();
+    if (current) {
+      current.trace = trace;
+    }
+  }
+  getCurrentTrace() {
+    const current = this.storage.getStore();
+    return current?.trace;
+  }
+  generateId() {
+    return crypto.randomUUID();
+  }
+}
+
+// src/types.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2[LogLevel2["TRACE"] = 0] = "TRACE";
+  LogLevel2[LogLevel2["DEBUG"] = 1] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+  LogLevel2[LogLevel2["FATAL"] = 5] = "FATAL";
+})(LogLevel ||= {});
+
+// src/timer.ts
+class Timer {
+  id;
+  startTime;
+  laps = [];
+  stopped = false;
+  stopTime;
+  constructor(id) {
+    this.id = id || crypto.randomUUID();
+    this.startTime = performance.now();
+  }
+  stop() {
+    if (this.stopped) {
+      return this.getElapsed();
+    }
+    this.stopTime = performance.now();
+    this.stopped = true;
+    const elapsed = this.stopTime - this.startTime;
+    this.laps.push({
+      label: "stop",
+      time: this.stopTime,
+      elapsed
+    });
+    return elapsed;
+  }
+  lap(label) {
+    if (this.stopped) {
+      return this.getElapsed();
+    }
+    const now = performance.now();
+    const elapsed = now - this.startTime;
+    this.laps.push({
+      label: label || `lap-${this.laps.length + 1}`,
+      time: now,
+      elapsed
+    });
+    return elapsed;
+  }
+  getElapsed() {
+    if (this.stopped && this.stopTime) {
+      return this.stopTime - this.startTime;
+    }
+    return performance.now() - this.startTime;
+  }
+  getLaps() {
+    return [...this.laps];
+  }
+  getSummary() {
+    return {
+      id: this.id,
+      totalTime: this.getElapsed(),
+      isRunning: !this.stopped,
+      laps: this.getLaps()
+    };
+  }
+  reset() {
+    this.startTime = performance.now();
+    this.laps = [];
+    this.stopped = false;
+    this.stopTime = undefined;
+  }
+}
+
+class TimerManager {
+  timers = new Map;
+  start(id) {
+    const timer = new Timer(id);
+    this.timers.set(timer.id, timer);
+    return timer;
+  }
+  get(id) {
+    return this.timers.get(id);
+  }
+  stop(id) {
+    const timer = this.timers.get(id);
+    if (timer) {
+      const elapsed = timer.stop();
+      this.timers.delete(id);
+      return elapsed;
+    }
+    return;
+  }
+  getActive() {
+    return Array.from(this.timers.values()).filter((timer) => !timer.getSummary().isRunning === false);
+  }
+  clear() {
+    this.timers.clear();
+  }
+  getSummary() {
+    return Array.from(this.timers.values()).map((timer) => timer.getSummary());
+  }
+}
+async function timed(operation, options) {
+  const timer = new Timer(options?.id);
+  try {
+    const result = await operation();
+    const elapsed = timer.stop();
+    options?.onComplete?.(elapsed);
+    return { result, elapsed, timer };
+  } catch (error) {
+    timer.stop();
+    throw error;
+  }
+}
+function timedSync(operation, options) {
+  const timer = new Timer(options?.id);
+  try {
+    const result = operation();
+    const elapsed = timer.stop();
+    options?.onComplete?.(elapsed);
+    return { result, elapsed, timer };
+  } catch (error) {
+    timer.stop();
+    throw error;
+  }
+}
+
+// src/tracer.node.ts
+class Tracer {
+  context;
+  activeSpans = new Map;
+  constructor() {
+    this.context = LogContext.getInstance();
+  }
+  startSpan(options) {
+    const parentTrace = this.context.getCurrentTrace();
+    const traceId = parentTrace?.traceId || this.generateTraceId();
+    const span = {
+      traceId,
+      parentId: parentTrace?.spanId,
+      spanId: this.generateSpanId(),
+      operationType: options.operationType,
+      operationName: options.operationName,
+      startTime: performance.now(),
+      metadata: { ...options.metadata },
+      tags: [...options.tags || []]
+    };
+    this.activeSpans.set(span.spanId, span);
+    this.context.setTrace(span);
+    return span;
+  }
+  finishSpan(spanId) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) {
+      return;
+    }
+    const duration = performance.now() - span.startTime;
+    this.activeSpans.delete(spanId);
+    const currentTrace = this.context.getCurrentTrace();
+    if (currentTrace?.spanId === spanId && span.parentId) {
+      const parentSpan = this.findSpanById(span.parentId);
+      if (parentSpan) {
+        this.context.setTrace(parentSpan);
+      }
+    }
+    return duration;
+  }
+  async trace(options, fn) {
+    const span = this.startSpan(options);
+    const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : undefined;
+    try {
+      const result = await fn();
+      const duration = this.finishSpan(span.spanId);
+      if (timer) {
+        timer.stop();
+      }
+      if (duration !== undefined) {
+        span.metadata.duration = duration;
+      }
+      return result;
+    } catch (error) {
+      span.metadata.error = {
+        name: error.name || "Unknown",
+        message: error.message || "Unknown error",
+        stack: error.stack
+      };
+      const duration = this.finishSpan(span.spanId);
+      span.metadata.duration = duration;
+      if (timer) {
+        timer.stop();
+      }
+      throw error;
+    }
+  }
+  addMetadata(key, value) {
+    const currentTrace = this.context.getCurrentTrace();
+    if (currentTrace) {
+      currentTrace.metadata[key] = value;
+    }
+  }
+  addTags(...tags) {
+    const currentTrace = this.context.getCurrentTrace();
+    if (currentTrace) {
+      currentTrace.tags.push(...tags);
+    }
+  }
+  getCurrentTrace() {
+    return this.context.getCurrentTrace();
+  }
+  getActiveSpans() {
+    return Array.from(this.activeSpans.values());
+  }
+  findSpanById(spanId) {
+    return this.activeSpans.get(spanId);
+  }
+  generateTraceId() {
+    return crypto.randomUUID().replace(/-/g, "");
+  }
+  generateSpanId() {
+    return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+  }
+}
+
+// src/formatters.ts
+var colors = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+var levelConfig = {
+  [0 /* TRACE */]: { color: colors.gray, symbol: "\u25CB", name: "TRACE" },
+  [1 /* DEBUG */]: { color: colors.blue, symbol: "\u25CF", name: "DEBUG" },
+  [2 /* INFO */]: { color: colors.green, symbol: "\u25CF", name: "INFO " },
+  [3 /* WARN */]: { color: colors.yellow, symbol: "\u25B2", name: "WARN " },
+  [4 /* ERROR */]: { color: colors.red, symbol: "\u2716", name: "ERROR" },
+  [5 /* FATAL */]: {
+    color: colors.bgRed + colors.white,
+    symbol: "\uD83D\uDC80",
+    name: "FATAL"
+  }
+};
+
+class DevFormatter {
+  enableColors;
+  constructor(enableColors = true) {
+    this.enableColors = enableColors;
+  }
+  format(entry) {
+    const parts = [];
+    const config = levelConfig[entry.level];
+    const timestamp = this.formatTimestamp(entry.timestamp);
+    parts.push(this.colorize(timestamp, colors.gray));
+    const levelText = `${config.symbol} ${config.name}`;
+    parts.push(this.colorize(levelText, config.color));
+    if (entry.traceId) {
+      const traceInfo = this.formatTraceInfo(entry);
+      parts.push(this.colorize(traceInfo, colors.cyan));
+    }
+    parts.push(this.colorize(entry.message, colors.white));
+    if (entry.duration !== undefined) {
+      const durationText = `(${this.formatDuration(entry.duration)})`;
+      parts.push(this.colorize(durationText, colors.magenta));
+    }
+    let output = parts.join(" ");
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      output += `
+` + this.formatContext(entry.context);
+    }
+    if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+      output += `
+` + this.formatMetadata(entry.metadata);
+    }
+    if (entry.error) {
+      output += `
+` + this.formatError(entry.error);
+    }
+    if (entry.tags && entry.tags.length > 0) {
+      const tagsText = entry.tags.map((tag) => `#${tag}`).join(" ");
+      output += `
+` + this.colorize(`Tags: ${tagsText}`, colors.blue);
+    }
+    return output;
+  }
+  formatTimestamp(timestamp) {
+    return timestamp.toISOString().substring(11, 23);
+  }
+  formatTraceInfo(entry) {
+    const parts = [`trace:${entry.traceId?.substring(0, 8) || "unknown"}`];
+    if (entry.spanId && entry.spanId.length >= 8) {
+      parts.push(`span:${entry.spanId.substring(0, 8)}`);
+    }
+    if (entry.parentId && entry.parentId.length >= 8) {
+      parts.push(`parent:${entry.parentId.substring(0, 8)}`);
+    }
+    return `[${parts.join("|")}]`;
+  }
+  formatDuration(duration) {
+    if (duration < 1) {
+      return `${(duration * 1000).toFixed(0)}\u03BCs`;
+    } else if (duration < 1000) {
+      return `${duration.toFixed(2)}ms`;
+    } else {
+      return `${(duration / 1000).toFixed(2)}s`;
+    }
+  }
+  formatContext(context) {
+    const formatted = this.formatObject(context, 2);
+    return this.colorize(`Context: ${formatted}`, colors.cyan);
+  }
+  formatMetadata(metadata) {
+    const formatted = this.formatObject(metadata, 2);
+    return this.colorize(`Metadata: ${formatted}`, colors.blue);
+  }
+  formatError(error) {
+    let output = this.colorize(`Error: ${error.name}: ${error.message}`, colors.red);
+    if (error.stack) {
+      const stackLines = error.stack.split(`
+`).slice(1, 6);
+      const indentedStack = stackLines.map((line) => `  ${line}`).join(`
+`);
+      output += `
+` + this.colorize(indentedStack, colors.gray);
+    }
+    return output;
+  }
+  formatObject(obj, indent = 0) {
+    const spaces = " ".repeat(indent);
+    const entries = Object.entries(obj);
+    if (entries.length === 0)
+      return "{}";
+    if (entries[0] && typeof entries[0][1] !== "object") {
+      return `{ ${entries[0][0]}: ${this.formatValue(entries[0][1])} }`;
+    }
+    const formatted = entries.map(([key, value]) => {
+      return `${spaces}  ${key}: ${this.formatValue(value, indent + 2)}`;
+    }).join(`
+`);
+    return `{
+${formatted}
+${spaces}}`;
+  }
+  formatValue(value, indent = 0) {
+    if (value === null)
+      return "null";
+    if (value === undefined)
+      return "undefined";
+    if (typeof value === "string")
+      return `"${value}"`;
+    if (typeof value === "boolean" || typeof value === "number")
+      return String(value);
+    if (value instanceof Date)
+      return value.toISOString();
+    if (Array.isArray(value)) {
+      if (value.length === 0)
+        return "[]";
+      return `[${value.map((v) => this.formatValue(v)).join(", ")}]`;
+    }
+    if (typeof value === "object") {
+      return this.formatObject(value, indent);
+    }
+    return String(value);
+  }
+  colorize(text, color) {
+    if (!this.enableColors)
+      return text;
+    return `${color}${text}${colors.reset}`;
+  }
+}
+
+class ProductionFormatter {
+  format(entry) {
+    const logObject = {
+      timestamp: entry.timestamp,
+      level: entry.level,
+      message: entry.message
+    };
+    if (entry.traceId) {
+      logObject.traceId = entry.traceId;
+    }
+    if (entry.spanId) {
+      logObject.spanId = entry.spanId;
+    }
+    if (entry.parentId) {
+      logObject.parentId = entry.parentId;
+    }
+    if (entry.duration !== undefined) {
+      logObject.duration = entry.duration;
+    }
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      logObject.context = entry.context;
+    }
+    if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+      logObject.metadata = entry.metadata;
+    }
+    if (entry.error) {
+      logObject.error = {
+        name: entry.error.name,
+        message: entry.error.message,
+        stack: entry.error.stack
+      };
+    }
+    if (entry.tags && entry.tags.length > 0) {
+      logObject.tags = entry.tags;
+    }
+    return JSON.stringify(logObject);
+  }
+}
+
+class CustomFormatter {
+  template;
+  dateFormat;
+  constructor(template = "{timestamp} [{level}] {message}", dateFormat) {
+    this.template = template;
+    this.dateFormat = dateFormat || ((date) => date.toISOString());
+  }
+  format(entry) {
+    const levelName = LogLevel[entry.level];
+    const timestamp = this.dateFormat(entry.timestamp);
+    let formatted = this.template.replace("{timestamp}", timestamp).replace("{level}", levelName).replace("{message}", entry.message).replace("{traceId}", entry.traceId || "").replace("{spanId}", entry.spanId || "").replace("{duration}", entry.duration?.toString() || "");
+    if (entry.context) {
+      formatted = formatted.replace("{context}", JSON.stringify(entry.context));
+    }
+    if (entry.metadata) {
+      formatted = formatted.replace("{metadata}", JSON.stringify(entry.metadata));
+    }
+    return formatted;
+  }
+}
+
+// src/logger.node.ts
+class Logger {
+  config;
+  formatter;
+  context;
+  tracer;
+  timerManager;
+  constructor(config) {
+    this.config = {
+      level: 2 /* INFO */,
+      environment: "development",
+      enableTracing: true,
+      enableTiming: true,
+      enableContext: true,
+      enableColors: true,
+      maxContextDepth: 10,
+      timestampFormat: "iso",
+      ...config
+    };
+    this.context = LogContext.getInstance();
+    this.tracer = new Tracer;
+    this.timerManager = new TimerManager;
+    this.formatter = this.config.environment === "production" ? new ProductionFormatter : new DevFormatter(this.config.enableColors);
+  }
+  traceLog(message, metadata) {
+    this.log(0 /* TRACE */, message, metadata);
+  }
+  debug(message, metadata) {
+    this.log(1 /* DEBUG */, message, metadata);
+  }
+  info(message, metadata) {
+    this.log(2 /* INFO */, message, metadata);
+  }
+  warn(message, metadata) {
+    this.log(3 /* WARN */, message, metadata);
+  }
+  error(message, metadata, error) {
+    this.log(4 /* ERROR */, message, metadata, error);
+  }
+  fatal(message, metadata, error) {
+    this.log(5 /* FATAL */, message, metadata, error);
+  }
+  withContext(context, fn) {
+    return this.context.run(context, fn);
+  }
+  extendContext(additionalContext, fn) {
+    return this.context.extend(additionalContext, fn);
+  }
+  setContext(key, value) {
+    this.context.set(key, value);
+  }
+  getContext() {
+    return this.context.getContext();
+  }
+  trace = async (options, fn) => {
+    if (!this.config.enableTracing) {
+      return await fn();
+    }
+    return this.tracer.trace(options, fn);
+  };
+  getTraceId() {
+    return this.tracer.getCurrentTrace()?.traceId;
+  }
+  startSpan(options) {
+    if (!this.config.enableTracing) {
+      return null;
+    }
+    return this.tracer.startSpan(options);
+  }
+  finishSpan(spanId) {
+    if (!this.config.enableTracing) {
+      return;
+    }
+    return this.tracer.finishSpan(spanId);
+  }
+  addTraceMetadata(key, value) {
+    if (this.config.enableTracing) {
+      this.tracer.addMetadata(key, value);
+    }
+  }
+  addTraceTags(...tags) {
+    if (this.config.enableTracing) {
+      this.tracer.addTags(...tags);
+    }
+  }
+  startTimer(id) {
+    if (!this.config.enableTiming) {
+      return null;
+    }
+    return this.timerManager.start(id);
+  }
+  stopTimer(id) {
+    if (!this.config.enableTiming) {
+      return;
+    }
+    return this.timerManager.stop(id);
+  }
+  getTimer(id) {
+    return this.timerManager.get(id);
+  }
+  child(context) {
+    const childLogger = new Logger(this.config);
+    Object.entries(context).forEach(([key, value]) => {
+      childLogger.setContext(key, value);
+    });
+    return childLogger;
+  }
+  setLevel(level) {
+    this.config.level = level;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  async profile(operationName, fn, options) {
+    const timer = this.startTimer(`profile-${operationName}`);
+    const startTime = performance.now();
+    try {
+      const result = await this.tracer.trace({
+        operationType: "custom",
+        operationName: `profile:${operationName}`,
+        autoTiming: true
+      }, fn);
+      const duration = performance.now() - startTime;
+      timer?.stop();
+      const logLevel = options?.logLevel || 1 /* DEBUG */;
+      this.log(logLevel, `Profile: ${operationName} completed`, {
+        operation: operationName,
+        duration: `${duration.toFixed(2)}ms`,
+        result: options?.logResult ? result : "[result hidden]"
+      });
+      return result;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+      timer?.stop();
+      this.error(`Profile: ${operationName} failed`, {
+        operation: operationName,
+        duration: `${duration.toFixed(2)}ms`,
+        error: error.message
+      }, error);
+      throw error;
+    }
+  }
+  logRequest(method, url, statusCode, duration) {
+    const level = this.getHttpLogLevel(statusCode);
+    const message = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
+    this.log(level, message, {
+      method,
+      url,
+      statusCode,
+      duration: duration ? `${duration.toFixed(2)}ms` : undefined,
+      type: "http_request"
+    });
+  }
+  async flush() {
+    this.timerManager.clear();
+  }
+  getStats() {
+    return {
+      activeTimers: this.timerManager.getActive().length,
+      activeSpans: this.tracer.getActiveSpans().length,
+      config: { ...this.config }
+    };
+  }
+  output(message, level) {
+    if (level >= 4 /* ERROR */) {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  }
+  log(level, message, metadata, error) {
+    if (level < this.config.level) {
+      return;
+    }
+    const currentTrace = this.config.enableTracing ? this.tracer.getCurrentTrace() : undefined;
+    const contextData = this.config.enableContext ? this.context.getContext() : undefined;
+    const entry = {
+      level,
+      message,
+      timestamp: new Date,
+      traceId: currentTrace?.traceId,
+      parentId: currentTrace?.parentId,
+      spanId: currentTrace?.spanId,
+      context: contextData,
+      metadata,
+      error,
+      tags: currentTrace?.tags
+    };
+    if (currentTrace?.metadata?.duration) {
+      entry.duration = currentTrace.metadata.duration;
+    }
+    const formatted = this.formatter.format(entry);
+    this.output(formatted, level);
+  }
+  getHttpLogLevel(statusCode) {
+    if (!statusCode)
+      return 2 /* INFO */;
+    if (statusCode >= 500)
+      return 4 /* ERROR */;
+    if (statusCode >= 400)
+      return 3 /* WARN */;
+    return 2 /* INFO */;
+  }
+}
+
+// src/elysia-plugin.ts
+function elysiaLogger(config = {}) {
+  const {
+    logger = new Logger,
+    logRequests = true,
+    logResponses = true,
+    excludePaths = ["/health", "/metrics"]
+  } = config;
+  const context = LogContext.getInstance();
+  return function(app) {
+    return app.derive((ctx) => {
+      const { request, path } = ctx;
+      if (excludePaths.some((excludePath) => path.startsWith(excludePath))) {
+        return { logger };
+      }
+      const url = new URL(request.url);
+      const requestContext = {
+        requestId: context.generateId(),
+        method: request.method,
+        url: request.url,
+        path: url.pathname,
+        userAgent: request.headers.get("user-agent") || undefined,
+        timestamp: new Date().toISOString()
+      };
+      const startTime = performance.now();
+      context.run(requestContext, () => {
+        if (logRequests) {
+          logger.info(`\u2192 ${request.method} ${path}`, {
+            method: request.method,
+            path,
+            userAgent: requestContext.userAgent,
+            requestId: requestContext.requestId
+          });
+        }
+      });
+      return {
+        logger,
+        requestContext,
+        startTime
+      };
+    }).onAfterHandle((ctx) => {
+      const { request, startTime, requestContext, logger: logger2 } = ctx;
+      if (!startTime || !requestContext)
+        return;
+      const duration = performance.now() - startTime;
+      const path = new URL(request.url).pathname;
+      if (logResponses) {
+        logger2.info(`\u2190 200 ${request.method} ${path}`, {
+          method: request.method,
+          path,
+          duration: `${duration.toFixed(2)}ms`,
+          requestId: requestContext.requestId
+        });
+      }
+    }).onError((ctx) => {
+      const { request, error, code, startTime, requestContext, logger: logger2 } = ctx;
+      if (!startTime || !requestContext)
+        return;
+      const duration = performance.now() - startTime;
+      const path = new URL(request.url).pathname;
+      logger2?.error(`\u2716 ${code} ${request.method} ${path}`, {
+        method: request.method,
+        path,
+        error: error?.toString?.() || "Unknown error",
+        code,
+        duration: `${duration.toFixed(2)}ms`,
+        requestId: requestContext.requestId
+      });
+    }).derive(() => ({
+      logInfo: (message, metadata) => {
+        logger.info(message, metadata);
+      },
+      logError: (message, error, metadata) => {
+        logger.error(message, metadata, error);
+      },
+      traceOperation: async (operationName, operation) => {
+        return logger.trace({
+          operationType: "custom",
+          operationName,
+          autoTiming: true
+        }, operation);
+      }
+    }));
+  };
+}
+export {
+  elysiaLogger
+};