logan-logger 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,642 @@
+var n = /* @__PURE__ */ ((t) => (t[t.DEBUG = 0] = "DEBUG", t[t.INFO = 1] = "INFO", t[t.WARN = 2] = "WARN", t[t.ERROR = 3] = "ERROR", t[t.SILENT = 4] = "SILENT", t))(n || {});
+function d() {
+  const t = u(), e = O(t), r = b(t);
+  return {
+    name: t,
+    version: e,
+    capabilities: r
+  };
+}
+function u() {
+  return typeof globalThis.Deno < "u" ? "deno" : typeof globalThis.Bun < "u" ? "bun" : typeof window < "u" && typeof document < "u" ? "browser" : typeof globalThis.importScripts == "function" && typeof window > "u" ? "webworker" : typeof process < "u" && process.versions && process.versions.node ? "node" : "unknown";
+}
+function O(t) {
+  switch (t) {
+    case "node":
+      return typeof process < "u" ? process.version : void 0;
+    case "deno":
+      return typeof globalThis.Deno < "u" ? globalThis.Deno.version?.deno : void 0;
+    case "bun":
+      return typeof globalThis.Bun < "u" ? globalThis.Bun.version : void 0;
+    case "browser":
+      return typeof navigator < "u" ? navigator.userAgent : void 0;
+    default:
+      return;
+  }
+}
+function b(t) {
+  switch (t) {
+    case "node":
+      return {
+        fileSystem: !0,
+        colorSupport: !0,
+        processInfo: !0,
+        streams: !0
+      };
+    case "deno":
+      return {
+        fileSystem: !0,
+        colorSupport: !0,
+        processInfo: !0,
+        streams: !0
+      };
+    case "bun":
+      return {
+        fileSystem: !0,
+        colorSupport: !0,
+        processInfo: !0,
+        streams: !0
+      };
+    case "browser":
+      return {
+        fileSystem: !1,
+        colorSupport: !0,
+        // CSS styling in console
+        processInfo: !1,
+        streams: !1
+      };
+    case "webworker":
+      return {
+        fileSystem: !1,
+        colorSupport: !1,
+        processInfo: !1,
+        streams: !1
+      };
+    default:
+      return {
+        fileSystem: !1,
+        colorSupport: !1,
+        processInfo: !1,
+        streams: !1
+      };
+  }
+}
+function T() {
+  return u() === "node";
+}
+function D() {
+  return u() === "browser";
+}
+function M() {
+  return u() === "deno";
+}
+function $() {
+  return u() === "bun";
+}
+function f(t, e) {
+  const r = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(t, (s, o) => {
+    if (typeof o == "object" && o !== null) {
+      if (r.has(o))
+        return "[Circular]";
+      r.add(o);
+    }
+    return o instanceof Error ? {
+      name: o.name,
+      message: o.message,
+      stack: o.stack,
+      ...Object.getOwnPropertyNames(o).reduce((a, i) => (i !== "name" && i !== "message" && i !== "stack" && (a[i] = o[i]), a), {})
+    } : typeof o == "function" ? `[Function: ${o.name || "anonymous"}]` : o === void 0 ? "[undefined]" : typeof o == "bigint" ? `[BigInt: ${o.toString()}]` : typeof o == "symbol" ? `[Symbol: ${o.toString()}]` : o;
+  }, e);
+}
+function N(t, e = ["password", "token", "secret", "key", "auth"]) {
+  if (typeof t != "object" || t === null)
+    return t;
+  const r = Array.isArray(t) ? [] : {};
+  for (const [s, o] of Object.entries(t))
+    e.some(
+      (i) => s.toLowerCase().includes(i.toLowerCase())
+    ) ? r[s] = "[REDACTED]" : typeof o == "object" && o !== null ? r[s] = N(o, e) : r[s] = o;
+  return r;
+}
+class p {
+  constructor(e = {}) {
+    this.childMetadata = {}, this.config = e, this.level = e.level ?? n.INFO, this.runtime = d().name;
+  }
+  debug(e, r) {
+    this.log(n.DEBUG, e, r);
+  }
+  info(e, r) {
+    this.log(n.INFO, e, r);
+  }
+  warn(e, r) {
+    this.log(n.WARN, e, r);
+  }
+  error(e, r) {
+    this.log(n.ERROR, e, r);
+  }
+  log(e, r, s) {
+    if (!this.shouldLog(e))
+      return;
+    const o = typeof r == "function" ? r() : r, a = { ...this.childMetadata, ...s }, i = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level: e,
+      message: o,
+      metadata: Object.keys(a).length > 0 ? a : void 0,
+      runtime: this.runtime
+    };
+    this.writeLog(i);
+  }
+  setLevel(e) {
+    this.level = e;
+  }
+  getLevel() {
+    return this.level;
+  }
+  child(e) {
+    const r = this.createChild();
+    return r.childMetadata = { ...this.childMetadata, ...e }, r;
+  }
+  shouldLog(e) {
+    return e >= this.level;
+  }
+}
+function W(t) {
+  return t instanceof Error ? {
+    name: t.name,
+    message: t.message,
+    stack: t.stack,
+    ...t
+    // Include any additional properties
+  } : t;
+}
+function A(t, e = "text") {
+  if (e === "json")
+    return f({
+      timestamp: t.timestamp.toISOString(),
+      level: n[t.level].toLowerCase(),
+      message: t.message,
+      metadata: t.metadata,
+      runtime: t.runtime
+    });
+  const r = t.timestamp.toISOString(), s = n[t.level].toUpperCase(), o = t.metadata ? ` ${f(t.metadata)}` : "";
+  return `[${r}] ${s}: ${t.message}${o}`;
+}
+class m extends p {
+  constructor(e = {}) {
+    super(e), this.initializeWinston();
+  }
+  async initializeWinston() {
+    try {
+      const e = await import("winston");
+      this.winston = this.createWinstonLogger(e);
+    } catch {
+      console.warn("[logan-logger] Winston not found, falling back to console logging");
+    }
+  }
+  createWinstonLogger(e) {
+    const r = e.format.combine(
+      e.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      e.format.errors({ stack: !0 }),
+      e.format.json(),
+      e.format.prettyPrint()
+    ), s = e.format.combine(
+      e.format.colorize(),
+      e.format.timestamp({ format: "HH:mm:ss" }),
+      e.format.printf(({ timestamp: a, level: i, message: E, ...g }) => {
+        const R = Object.keys(g).length ? JSON.stringify(g, null, 2) : "";
+        return `${a} [${i}]: ${E} ${R}`;
+      })
+    ), o = e.createLogger({
+      level: this.getWinstonLevel(this.level),
+      format: r,
+      transports: [
+        new e.transports.Console({
+          format: process.env.NODE_ENV === "production" ? r : s
+        })
+      ]
+    });
+    return process.env.NODE_ENV === "production" && (o.add(
+      new e.transports.File({
+        filename: "logs/error.log",
+        level: "error",
+        maxsize: 5242880,
+        // 5MB
+        maxFiles: 5
+      })
+    ), o.add(
+      new e.transports.File({
+        filename: "logs/combined.log",
+        maxsize: 5242880,
+        // 5MB
+        maxFiles: 10
+      })
+    )), o;
+  }
+  writeLog(e) {
+    this.winston ? this.winston.log({
+      level: this.getWinstonLevel(e.level),
+      message: e.message,
+      timestamp: e.timestamp,
+      ...e.metadata
+    }) : this.writeToConsole(e);
+  }
+  createChild() {
+    return new m(this.config);
+  }
+  writeToConsole(e) {
+    const r = e.timestamp.toISOString(), s = n[e.level].toLowerCase(), o = e.metadata ? ` ${f(e.metadata)}` : "", a = `[${r}] ${s.toUpperCase()}: ${e.message}${o}`;
+    switch (e.level) {
+      case n.DEBUG:
+        console.debug(a);
+        break;
+      case n.INFO:
+        console.info(a);
+        break;
+      case n.WARN:
+        console.warn(a);
+        break;
+      case n.ERROR:
+        console.error(a);
+        break;
+    }
+  }
+  getWinstonLevel(e) {
+    switch (e) {
+      case n.DEBUG:
+        return "debug";
+      case n.INFO:
+        return "info";
+      case n.WARN:
+        return "warn";
+      case n.ERROR:
+        return "error";
+      default:
+        return "info";
+    }
+  }
+  setLevel(e) {
+    super.setLevel(e), this.winston && (this.winston.level = this.getWinstonLevel(e));
+  }
+}
+function B(t) {
+  return {
+    write: (e) => {
+      t.info(e.trim());
+    }
+  };
+}
+class c extends p {
+  constructor(e = {}) {
+    super(e);
+  }
+  writeLog(e) {
+    const r = this.formatMessage(e), s = this.getConsoleStyle(e.level), o = e.metadata ? ` ${f(e.metadata)}` : "", a = `%c${r}${o}`;
+    switch (e.level) {
+      case n.DEBUG:
+        console.debug ? console.debug(a, s) : console.log(a, s);
+        break;
+      case n.INFO:
+        console.info(a, s);
+        break;
+      case n.WARN:
+        console.warn(a, s);
+        break;
+      case n.ERROR:
+        console.error(a, s);
+        break;
+    }
+  }
+  createChild() {
+    return new c(this.config);
+  }
+  formatMessage(e) {
+    const r = e.timestamp.toISOString(), s = n[e.level].toUpperCase();
+    return `[${r}] ${s}: ${e.message}`;
+  }
+  getConsoleStyle(e) {
+    if (!this.config.colorize)
+      return "";
+    switch (e) {
+      case n.DEBUG:
+        return "color: #888; font-weight: normal;";
+      case n.INFO:
+        return "color: #007acc; font-weight: normal;";
+      case n.WARN:
+        return "color: #ff8c00; font-weight: bold;";
+      case n.ERROR:
+        return "color: #dc3545; font-weight: bold;";
+      default:
+        return "";
+    }
+  }
+  shouldLogInProduction() {
+    return (globalThis.process?.env?.NODE_ENV || globalThis.process?.env?.NEXT_PUBLIC_APP_ENV || "development") !== "production" || this.level <= n.ERROR;
+  }
+  shouldLog(e) {
+    return !this.shouldLogInProduction() && e < n.ERROR ? !1 : super.shouldLog(e);
+  }
+}
+class G extends c {
+  constructor() {
+    super(...arguments), this.groupStack = [];
+  }
+  group(e) {
+    console.group(e), this.groupStack.push(e);
+  }
+  groupCollapsed(e) {
+    console.groupCollapsed(e), this.groupStack.push(e);
+  }
+  groupEnd() {
+    console.groupEnd(), this.groupStack.pop();
+  }
+  time(e) {
+    console.time(e);
+  }
+  timeEnd(e) {
+    console.timeEnd(e);
+  }
+  trace(e, r) {
+    console.trace(e, r);
+  }
+  count(e) {
+    console.count(e);
+  }
+  countReset(e) {
+    console.countReset(e);
+  }
+  table(e) {
+    console.table(e);
+  }
+}
+class _ extends c {
+  mark(e) {
+    typeof performance < "u" && performance.mark && performance.mark(e);
+  }
+  measure(e, r, s) {
+    if (typeof performance < "u" && performance.measure)
+      try {
+        performance.measure(e, r, s);
+        const o = performance.getEntriesByName(e, "measure");
+        if (o.length > 0) {
+          const a = o[o.length - 1];
+          this.info(`Performance: ${e}`, {
+            duration: a.duration,
+            startTime: a.startTime
+          });
+        }
+      } catch (o) {
+        this.warn("Failed to measure performance", { name: e, error: o });
+      }
+  }
+  clearMarks(e) {
+    typeof performance < "u" && performance.clearMarks && performance.clearMarks(e);
+  }
+  clearMeasures(e) {
+    typeof performance < "u" && performance.clearMeasures && performance.clearMeasures(e);
+  }
+}
+function h() {
+  const t = d();
+  return {
+    level: n.INFO,
+    format: "text",
+    timestamp: !0,
+    colorize: t.capabilities.colorSupport,
+    metadata: {},
+    transports: [
+      {
+        type: "console",
+        options: {}
+      }
+    ]
+  };
+}
+function j() {
+  const t = {};
+  if (typeof process < "u" && process.env) {
+    const e = process.env;
+    e.LOG_LEVEL && (t.level = L(e.LOG_LEVEL)), e.LOG_FORMAT && ["json", "text"].includes(e.LOG_FORMAT) && (t.format = e.LOG_FORMAT), e.LOG_TIMESTAMP && (t.timestamp = e.LOG_TIMESTAMP.toLowerCase() === "true"), e.LOG_COLOR && (t.colorize = e.LOG_COLOR.toLowerCase() === "true");
+  }
+  return t;
+}
+async function U(t) {
+  const e = d();
+  if (!e.capabilities.fileSystem)
+    return {};
+  const r = t ? [t] : [
+    "logan.config.json",
+    "logan.config.js",
+    ".loganrc.json",
+    "package.json"
+    // Check for logan config in package.json
+  ];
+  for (const s of r)
+    try {
+      if (e.name === "node")
+        return await w(s);
+      if (e.name === "deno")
+        return await v(s);
+      if (e.name === "bun")
+        return await S(s);
+    } catch {
+    }
+  return {};
+}
+async function w(t) {
+  try {
+    const e = await import("./__vite-browser-external-DYxpcVy9.mjs"), r = await import("./__vite-browser-external-DYxpcVy9.mjs");
+    if (t.endsWith(".json")) {
+      const s = await e.readFile(t, "utf-8"), o = JSON.parse(s);
+      return t === "package.json" ? o.logan || {} : o;
+    } else if (t.endsWith(".js")) {
+      const s = r.resolve(t);
+      delete require.cache[s];
+      const o = require(s);
+      return o.default || o;
+    }
+  } catch {
+  }
+  return {};
+}
+async function v(t) {
+  try {
+    if (t.endsWith(".json")) {
+      const e = await globalThis.Deno.readTextFile(t), r = JSON.parse(e);
+      return t === "package.json" ? r.logan || {} : r;
+    } else if (t.endsWith(".js")) {
+      const e = await import(
+        /* @vite-ignore */
+        `./${t}`
+      );
+      return e.default || e;
+    }
+  } catch {
+  }
+  return {};
+}
+async function S(t) {
+  return w(t);
+}
+function L(t) {
+  switch (t.toLowerCase()) {
+    case "debug":
+      return n.DEBUG;
+    case "info":
+      return n.INFO;
+    case "warn":
+    case "warning":
+      return n.WARN;
+    case "error":
+      return n.ERROR;
+    case "silent":
+    case "none":
+      return n.SILENT;
+    default:
+      return n.INFO;
+  }
+}
+function P(...t) {
+  const e = h();
+  return t.reduce((r, s) => ({
+    ...r,
+    ...s,
+    metadata: {
+      ...r.metadata,
+      ...s.metadata
+    },
+    transports: s.transports || r.transports
+  }), e);
+}
+class y {
+  /**
+   * Create a logger instance appropriate for the current runtime.
+   * @param config - Optional configuration for the logger
+   * @returns A logger instance
+   */
+  static create(e = {}) {
+    const r = d(), s = this.mergeConfig(e);
+    switch (r.name) {
+      case "node":
+        return new m(s);
+      case "deno":
+        return new c(s);
+      case "bun":
+        return new m(s);
+      case "browser":
+      case "webworker":
+        return new c(s);
+      default:
+        return new c(s);
+    }
+  }
+  /**
+   * Create a child logger with additional metadata.
+   * @param parent - The parent logger instance
+   * @param metadata - Additional metadata to include in all child log messages
+   * @returns A new logger instance with the additional metadata
+   */
+  static createChild(e, r) {
+    return e.child(r);
+  }
+  static mergeConfig(e) {
+    const r = h();
+    return {
+      ...r,
+      ...e,
+      metadata: {
+        ...r.metadata,
+        ...e.metadata
+      }
+    };
+  }
+}
+function C(t) {
+  return y.create(t);
+}
+function k() {
+  const t = I(), e = {
+    level: F(t),
+    colorize: t !== "production",
+    timestamp: !0,
+    format: t === "production" ? "json" : "text"
+  };
+  return C(e);
+}
+function I() {
+  return typeof process < "u" && process.env ? process.env.NODE_ENV || process.env.NEXT_PUBLIC_APP_ENV || process.env.ENVIRONMENT || "development" : typeof window < "u" && globalThis.__ENV__ || "development";
+}
+function F(t) {
+  switch (t) {
+    case "production":
+      return n.ERROR;
+    case "staging":
+    case "test":
+      return n.WARN;
+    case "development":
+    case "dev":
+      return n.DEBUG;
+    default:
+      return n.INFO;
+  }
+}
+function x(t) {
+  switch (t.toLowerCase()) {
+    case "debug":
+      return n.DEBUG;
+    case "info":
+      return n.INFO;
+    case "warn":
+    case "warning":
+      return n.WARN;
+    case "error":
+      return n.ERROR;
+    case "silent":
+    case "none":
+      return n.SILENT;
+    default:
+      return n.INFO;
+  }
+}
+function V(t) {
+  switch (t) {
+    case n.DEBUG:
+      return "debug";
+    case n.INFO:
+      return "info";
+    case n.WARN:
+      return "warn";
+    case n.ERROR:
+      return "error";
+    case n.SILENT:
+      return "silent";
+    default:
+      return "info";
+  }
+}
+const l = k(), z = {
+  debug: (t, e) => l.debug(t, e),
+  info: (t, e) => l.info(t, e),
+  warn: (t, e) => l.warn(t, e),
+  error: (t, e) => l.error(t, e)
+};
+export {
+  p as BaseLogger,
+  c as BrowserLogger,
+  G as ConsoleGroupLogger,
+  n as LogLevel,
+  y as LoggerFactory,
+  m as NodeLogger,
+  _ as PerformanceLogger,
+  C as createLogger,
+  k as createLoggerForEnvironment,
+  B as createMorganStream,
+  d as detectRuntime,
+  N as filterSensitiveData,
+  A as formatLogEntry,
+  h as getDefaultConfig,
+  D as isBrowser,
+  $ as isBun,
+  M as isDeno,
+  T as isNode,
+  j as loadConfigFromEnvironment,
+  U as loadConfigFromFile,
+  z as log,
+  V as logLevelToString,
+  l as logger,
+  P as mergeConfigs,
+  f as safeStringify,
+  W as serializeError,
+  x as stringToLogLevel
+};
+//# sourceMappingURL=index.esm.js.map