@contractspec/lib.logger 1.56.1 → 1.58.0

package/dist/formatters.d.ts

@@ -0,0 +1,25 @@
+import type { Formatter, LogEntry } from './types';
+export declare class DevFormatter implements Formatter {
+    private enableColors;
+    constructor(enableColors?: boolean);
+    format(entry: LogEntry): string;
+    private formatTimestamp;
+    private formatTraceInfo;
+    private formatDuration;
+    private formatContext;
+    private formatMetadata;
+    private formatError;
+    private formatObject;
+    private formatValue;
+    private colorize;
+}
+export declare class ProductionFormatter implements Formatter {
+    format(entry: LogEntry): string;
+}
+export declare class CustomFormatter implements Formatter {
+    private template;
+    private dateFormat;
+    constructor(template?: string, dateFormat?: (date: Date) => string);
+    format(entry: LogEntry): string;
+}
+//# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../src/formatters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAkCnD,qBAAa,YAAa,YAAW,SAAS;IAC5C,OAAO,CAAC,YAAY,CAAU;gBAElB,YAAY,UAAO;IAI/B,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAoD/B,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,YAAY;IAoBpB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,QAAQ;CAIjB;AAED,qBAAa,mBAAoB,YAAW,SAAS;IACnD,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;CA+ChC;AAED,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAyB;gBAGzC,QAAQ,SAAoC,EAC5C,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM;IAMrC,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;CAyBhC"}

package/dist/formatters.js

@@ -0,0 +1,232 @@
+// @bun
+// 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/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;
+  }
+}
+export {
+  ProductionFormatter,
+  DevFormatter,
+  CustomFormatter
+};

package/dist/index.browser.d.ts

@@ -0,0 +1,8 @@
+export { Logger } from './logger.browser';
+export { LogContext } from './context.browser';
+export { Tracer } from './tracer.browser';
+export { Timer } from './timer';
+export type { LogEntry, TraceContext, TracingOptions } from './types';
+export { LogLevel } from './types';
+export { DevFormatter, ProductionFormatter } from './formatters';
+//# sourceMappingURL=index.browser.d.ts.map

package/dist/index.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../src/index.browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}