voltlog-io 1.0.0

package/dist/index.mjs

@@ -0,0 +1,738 @@
+// src/core/logger.ts
+import { createId } from "@paralleldrive/cuid2";
+
+// src/core/types.ts
+var LogLevel = {
+  TRACE: 10,
+  DEBUG: 20,
+  INFO: 30,
+  WARN: 40,
+  ERROR: 50,
+  FATAL: 60,
+  SILENT: Infinity
+};
+var LogLevelNameMap = Object.fromEntries(
+  Object.entries(LogLevel).map(([k, v]) => [k.toLowerCase(), v])
+);
+var LogLevelValueMap = Object.fromEntries(
+  Object.entries(LogLevel).filter(([, v]) => Number.isFinite(v)).map(([k, v]) => [v, k])
+);
+
+// src/core/levels.ts
+function resolveLevel(level) {
+  const n = LogLevelNameMap[level.toLowerCase()];
+  return n !== void 0 ? n : LogLevel.INFO;
+}
+function shouldLog(entryLevel, filterLevel) {
+  return entryLevel >= filterLevel;
+}
+function shouldIncludeStack(entryLevel, includeStack) {
+  if (typeof includeStack === "boolean") return includeStack;
+  return entryLevel >= resolveLevel(includeStack);
+}
+
+// src/core/pipeline.ts
+function composeMiddleware(middleware, final) {
+  if (middleware.length === 0) return final;
+  return (entry) => {
+    let index = 0;
+    const next = (e) => {
+      if (index < middleware.length) {
+        const mw = middleware[index++];
+        mw(e, next);
+      } else {
+        final(e);
+      }
+    };
+    next(entry);
+  };
+}
+function fanOutToTransformers(entry, transformers, loggerLevel) {
+  for (const t of transformers) {
+    const tLevel = t.level ? resolveLevel(t.level) : loggerLevel;
+    if (!shouldLog(entry.level, tLevel)) continue;
+    try {
+      const result = t.transform(entry);
+      if (result && typeof result.catch === "function") {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+}
+
+// src/core/logger.ts
+var LoggerImpl = class {
+  _level;
+  _transports;
+  _middlewareList;
+  _pipeline;
+  _context;
+  _includeStack;
+  _timestampFn;
+  constructor(options = {}) {
+    this._level = resolveLevel(options.level ?? "INFO");
+    this._transports = [...options.transports ?? []];
+    this._middlewareList = [...options.middleware ?? []];
+    this._context = options.context ? { ...options.context } : {};
+    this._includeStack = options.includeStack ?? "ERROR";
+    this._timestampFn = options.timestamp ?? Date.now;
+    this._pipeline = this._buildPipeline();
+  }
+  // ─── Log Methods ────────────────────────────────────────────
+  trace(message, meta) {
+    this._log(10, "TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this._log(20, "DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this._log(30, "INFO", message, meta);
+  }
+  warn(message, meta) {
+    this._log(40, "WARN", message, meta);
+  }
+  error(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._log(50, "ERROR", message, void 0, metaOrError);
+    } else {
+      this._log(50, "ERROR", message, metaOrError, error);
+    }
+  }
+  fatal(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._log(60, "FATAL", message, void 0, metaOrError);
+    } else {
+      this._log(60, "FATAL", message, metaOrError, error);
+    }
+  }
+  // ─── Child Logger ───────────────────────────────────────────
+  child(context) {
+    return new ChildLoggerImpl(this, { ...this._context, ...context });
+  }
+  // ─── Dynamic Configuration ─────────────────────────────────
+  addTransformer(transformer) {
+    this._transports.push(transformer);
+  }
+  removeTransformer(name) {
+    this._transports = this._transports.filter((t) => t.name !== name);
+  }
+  addMiddleware(middleware) {
+    this._middlewareList.push(middleware);
+    this._pipeline = this._buildPipeline();
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────
+  async flush() {
+    await Promise.all(this._transports.map((t) => t.flush?.()).filter(Boolean));
+  }
+  async close() {
+    await this.flush();
+    await Promise.all(this._transports.map((t) => t.close?.()).filter(Boolean));
+  }
+  // ─── Internal ───────────────────────────────────────────────
+  /** @internal */
+  _log(level, levelName, message, meta, error) {
+    this._logWithContext(level, levelName, message, this._context, meta, error);
+  }
+  /** @internal — used by child loggers to inject bound context */
+  _logWithContext(level, levelName, message, context, meta, error) {
+    if (!shouldLog(level, this._level)) return;
+    const entry = {
+      id: createId(),
+      level,
+      levelName,
+      message,
+      timestamp: this._timestampFn(),
+      meta: meta ?? {},
+      context: Object.keys(context).length > 0 ? context : void 0
+    };
+    if (error) {
+      const logError = {
+        message: error.message,
+        name: error.name,
+        code: error.code
+      };
+      if (shouldIncludeStack(level, this._includeStack)) {
+        logError.stack = error.stack;
+      }
+      entry.error = logError;
+    }
+    this._pipeline(entry);
+  }
+  _buildPipeline() {
+    return composeMiddleware(this._middlewareList, (entry) => {
+      fanOutToTransformers(entry, this._transports, this._level);
+    });
+  }
+};
+var ChildLoggerImpl = class _ChildLoggerImpl {
+  constructor(_parent, _context) {
+    this._parent = _parent;
+    this._context = _context;
+  }
+  trace(message, meta) {
+    this._parent._logWithContext(10, "TRACE", message, this._context, meta);
+  }
+  debug(message, meta) {
+    this._parent._logWithContext(20, "DEBUG", message, this._context, meta);
+  }
+  info(message, meta) {
+    this._parent._logWithContext(30, "INFO", message, this._context, meta);
+  }
+  warn(message, meta) {
+    this._parent._logWithContext(40, "WARN", message, this._context, meta);
+  }
+  error(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._parent._logWithContext(
+        50,
+        "ERROR",
+        message,
+        this._context,
+        void 0,
+        metaOrError
+      );
+    } else {
+      this._parent._logWithContext(
+        50,
+        "ERROR",
+        message,
+        this._context,
+        metaOrError,
+        error
+      );
+    }
+  }
+  fatal(message, metaOrError, error) {
+    if (metaOrError instanceof Error) {
+      this._parent._logWithContext(
+        60,
+        "FATAL",
+        message,
+        this._context,
+        void 0,
+        metaOrError
+      );
+    } else {
+      this._parent._logWithContext(
+        60,
+        "FATAL",
+        message,
+        this._context,
+        metaOrError,
+        error
+      );
+    }
+  }
+  child(context) {
+    return new _ChildLoggerImpl(this._parent, {
+      ...this._context,
+      ...context
+    });
+  }
+  addTransformer(transformer) {
+    this._parent.addTransformer(transformer);
+  }
+  removeTransformer(name) {
+    this._parent.removeTransformer(name);
+  }
+  addMiddleware(middleware) {
+    this._parent.addMiddleware(middleware);
+  }
+  flush() {
+    return this._parent.flush();
+  }
+  close() {
+    return this._parent.close();
+  }
+};
+function createLogger(options) {
+  return new LoggerImpl(options);
+}
+
+// src/middleware/redaction.ts
+var DEFAULT_REDACT_VALUE = "[REDACTED]";
+function redactionMiddleware(options) {
+  const paths = new Set(options.paths.map((p) => p.toLowerCase()));
+  const replacement = options.replacement ?? DEFAULT_REDACT_VALUE;
+  const deep = options.deep ?? true;
+  function redactObject(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (paths.has(key.toLowerCase())) {
+        result[key] = replacement;
+      } else if (deep && value !== null && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = redactObject(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return (entry, next) => {
+    const redacted = { ...entry };
+    if (entry.meta && typeof entry.meta === "object") {
+      redacted.meta = redactObject(
+        entry.meta
+      );
+    }
+    if (entry.context && typeof entry.context === "object") {
+      redacted.context = redactObject(entry.context);
+    }
+    next(redacted);
+  };
+}
+
+// src/middleware/sampling.ts
+function samplingMiddleware(options = {}) {
+  const keyFn = options.keyFn ?? ((entry) => entry.message);
+  const maxPerWindow = options.maxPerWindow ?? 100;
+  const windowMs = options.windowMs ?? 6e4;
+  const sampleRate = options.sampleRate ?? 1;
+  const priorityLevel = options.priorityLevel ?? 40;
+  const buckets = /* @__PURE__ */ new Map();
+  return (entry, next) => {
+    if (entry.level >= priorityLevel) {
+      return next(entry);
+    }
+    if (sampleRate < 1 && Math.random() > sampleRate) {
+      return;
+    }
+    const key = keyFn(entry);
+    const now = entry.timestamp;
+    let bucket = buckets.get(key);
+    if (!bucket || now - bucket.windowStart >= windowMs) {
+      bucket = { count: 0, windowStart: now };
+      buckets.set(key, bucket);
+    }
+    if (bucket.count < maxPerWindow) {
+      bucket.count++;
+      next(entry);
+    }
+    if (buckets.size > 2e3) {
+      const expireBefore = now - windowMs * 2;
+      for (const [k, b] of buckets) {
+        if (b.windowStart < expireBefore) {
+          buckets.delete(k);
+        }
+      }
+    }
+  };
+}
+
+// src/middleware/ocpp.ts
+function ocppMiddleware(options = {}) {
+  const autoPayloadSize = options.autoPayloadSize ?? true;
+  const propagateCorrelationId = options.propagateCorrelationId ?? true;
+  return (entry, next) => {
+    const enriched = { ...entry, meta: { ...entry.meta } };
+    if (autoPayloadSize && enriched.meta.payloadSize === void 0 && enriched.meta.action) {
+      try {
+        enriched.meta.payloadSize = JSON.stringify(enriched.meta).length;
+      } catch {
+      }
+    }
+    if (propagateCorrelationId && enriched.meta.correlationId && !enriched.correlationId) {
+      enriched.correlationId = enriched.meta.correlationId;
+    }
+    next(enriched);
+  };
+}
+
+// src/middleware/alert.ts
+function alertMiddleware(rules) {
+  const states = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    states.set(rule.name, { entries: [], lastFired: -Infinity });
+  }
+  return (entry, next) => {
+    const now = entry.timestamp;
+    for (const rule of rules) {
+      if (!rule.when(entry)) continue;
+      const state = states.get(rule.name);
+      const windowMs = rule.windowMs ?? Infinity;
+      const threshold = rule.threshold ?? 1;
+      const cooldownMs = rule.cooldownMs ?? 0;
+      if (Number.isFinite(windowMs)) {
+        state.entries = state.entries.filter(
+          (e) => now - e.timestamp < windowMs
+        );
+      }
+      state.entries.push(entry);
+      if (state.entries.length >= threshold && now - state.lastFired >= cooldownMs) {
+        const alertEntries = [...state.entries];
+        state.entries = [];
+        state.lastFired = now;
+        try {
+          const result = rule.onAlert(alertEntries);
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    next(entry);
+  };
+}
+
+// src/middleware/create-middleware.ts
+function createMiddleware(fn) {
+  return fn;
+}
+
+// src/transformers/console.ts
+function consoleTransport(options = {}) {
+  const useConsoleLevels = options.useConsoleLevels ?? true;
+  const formatter = options.formatter ?? ((entry) => JSON.stringify(entry));
+  return {
+    name: "console",
+    level: options.level,
+    transform(entry) {
+      const output = formatter(entry);
+      if (!useConsoleLevels) {
+        console.log(output);
+        return;
+      }
+      if (entry.level >= LogLevel.FATAL) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.ERROR) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.WARN) {
+        console.warn(output);
+      } else if (entry.level >= LogLevel.INFO) {
+        console.info(output);
+      } else if (entry.level >= LogLevel.DEBUG) {
+        console.debug(output);
+      } else {
+        console.log(output);
+      }
+    }
+  };
+}
+
+// src/transformers/pretty.ts
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var COLORS = {
+  TRACE: "\x1B[90m",
+  // gray
+  DEBUG: "\x1B[36m",
+  // cyan
+  INFO: "\x1B[32m",
+  // green
+  WARN: "\x1B[33m",
+  // yellow
+  ERROR: "\x1B[31m",
+  // red
+  FATAL: "\x1B[35;1m"
+  // bold magenta
+};
+var ICONS = {
+  TRACE: "\u{1F50D}",
+  DEBUG: "\u{1F41B}",
+  INFO: "\u2139",
+  WARN: "\u26A0",
+  ERROR: "\u2716",
+  FATAL: "\u{1F480}"
+};
+var EXCHANGE_ICONS = {
+  CALL: "\u26A1",
+  CALLRESULT: "\u2714",
+  CALLERROR: "\u{1F6A8}"
+};
+var DIRECTION_ARROWS = {
+  IN: "\u2192",
+  OUT: "\u2190"
+};
+function prettyTransport(options = {}) {
+  const showTimestamps = options.timestamps ?? true;
+  const useColors = options.colors ?? true;
+  function colorize(text, color) {
+    return useColors ? `${color}${text}${RESET}` : text;
+  }
+  function formatExchange(entry) {
+    const meta = entry.meta;
+    if (!meta || !meta.action || !meta.messageType) return null;
+    const icon = EXCHANGE_ICONS[meta.messageType] ?? "\u2022";
+    const arrow = DIRECTION_ARROWS[meta.direction ?? "IN"] ?? "\u2192";
+    const cpId = meta.chargePointId ?? "unknown";
+    const action = meta.action;
+    const msgType = meta.messageType;
+    const dir = meta.direction ?? "";
+    let line = `${icon} ${colorize(cpId, BOLD)}  ${arrow}  ${colorize(action, BOLD)}  [${dir}]  ${colorize(msgType, DIM)}`;
+    if (meta.status || meta.latencyMs !== void 0) {
+      const statusIcon = meta.messageType === "CALLERROR" ? "\u274C" : "\u2714";
+      const status = meta.status ?? "";
+      const latency = meta.latencyMs !== void 0 ? `(${meta.latencyMs}ms)` : "";
+      line += `
+${statusIcon} ${status}  ${colorize(latency, DIM)}`;
+    }
+    return line;
+  }
+  function formatStandard(entry) {
+    const icon = ICONS[entry.levelName] ?? "\u2022";
+    const levelColor = COLORS[entry.levelName] ?? "";
+    const level = colorize(entry.levelName.padEnd(5), levelColor);
+    const ts = showTimestamps ? colorize(new Date(entry.timestamp).toISOString(), DIM) + "  " : "";
+    let line = `${icon} ${ts}${level}  ${entry.message}`;
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      line += `  ${colorize(JSON.stringify(entry.context), DIM)}`;
+    }
+    if (entry.meta && Object.keys(entry.meta).length > 0) {
+      line += `  ${colorize(JSON.stringify(entry.meta), DIM)}`;
+    }
+    if (entry.error) {
+      line += `
+  ${colorize(`${entry.error.name ?? "Error"}: ${entry.error.message}`, COLORS["ERROR"] ?? "")}`;
+      if (entry.error.stack) {
+        line += `
+${colorize(entry.error.stack, DIM)}`;
+      }
+    }
+    return line;
+  }
+  return {
+    name: "pretty",
+    level: options.level,
+    transform(entry) {
+      const exchangeOutput = formatExchange(entry);
+      if (exchangeOutput) {
+        console.log(exchangeOutput);
+        return;
+      }
+      const output = formatStandard(entry);
+      if (entry.level >= LogLevel.ERROR) {
+        console.error(output);
+      } else if (entry.level >= LogLevel.WARN) {
+        console.warn(output);
+      } else {
+        console.log(output);
+      }
+    }
+  };
+}
+
+// src/transformers/json-stream.ts
+function jsonStreamTransport(options) {
+  const stream = options.stream;
+  const serialize = options.serializer ?? ((entry) => JSON.stringify(entry) + "\n");
+  return {
+    name: "json-stream",
+    level: options.level,
+    transform(entry) {
+      const data = serialize(entry);
+      stream.write(data);
+    },
+    close() {
+      return new Promise((resolve) => {
+        if ("end" in stream && typeof stream.end === "function") {
+          stream.end(() => resolve());
+        } else {
+          resolve();
+        }
+      });
+    }
+  };
+}
+
+// src/transformers/webhook.ts
+function webhookTransport(options) {
+  const {
+    url,
+    method = "POST",
+    headers = {},
+    batchSize = 1,
+    flushIntervalMs = 5e3,
+    retry = false,
+    maxRetries = 3
+  } = options;
+  const serialize = options.serializer ?? ((entries) => JSON.stringify({
+    entries,
+    count: entries.length,
+    timestamp: Date.now()
+  }));
+  let buffer = [];
+  let flushTimer = null;
+  async function sendBatch(entries, attempt = 0) {
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: serialize(entries)
+      });
+      if (!response.ok && retry && attempt < maxRetries) {
+        const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+        await new Promise((r) => setTimeout(r, delay));
+        return sendBatch(entries, attempt + 1);
+      }
+    } catch {
+      if (retry && attempt < maxRetries) {
+        const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+        await new Promise((r) => setTimeout(r, delay));
+        return sendBatch(entries, attempt + 1);
+      }
+    }
+  }
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      doFlush();
+    }, flushIntervalMs);
+  }
+  function doFlush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    sendBatch(batch).catch(() => {
+    });
+  }
+  return {
+    name: "webhook",
+    level: options.level,
+    transform(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        doFlush();
+      } else {
+        scheduleFlush();
+      }
+    },
+    async flush() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (buffer.length > 0) {
+        const batch = buffer;
+        buffer = [];
+        await sendBatch(batch);
+      }
+    },
+    async close() {
+      await this.flush();
+    }
+  };
+}
+
+// src/transformers/batch.ts
+function batchTransport(inner, options = {}) {
+  const batchSize = options.batchSize ?? 100;
+  const flushIntervalMs = options.flushIntervalMs ?? 5e3;
+  let buffer = [];
+  let flushTimer = null;
+  function scheduleFlush() {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      doFlush();
+    }, flushIntervalMs);
+  }
+  function doFlush() {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    for (const entry of batch) {
+      try {
+        const result = inner.transform(entry);
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    name: `batch(${inner.name})`,
+    level: inner.level,
+    transform(entry) {
+      buffer.push(entry);
+      if (buffer.length >= batchSize) {
+        doFlush();
+      } else {
+        scheduleFlush();
+      }
+    },
+    async flush() {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      doFlush();
+      await inner.flush?.();
+    },
+    async close() {
+      await this.flush();
+      await inner.close?.();
+    }
+  };
+}
+
+// src/transformers/redis.ts
+function redisTransport(options) {
+  const { client, streamKey = "logs", maxLen, level } = options;
+  const fieldMapper = options.fieldMapper ?? defaultFieldMapper;
+  function defaultFieldMapper(entry) {
+    return {
+      id: entry.id,
+      level: String(entry.level),
+      levelName: entry.levelName,
+      message: entry.message,
+      timestamp: String(entry.timestamp),
+      data: JSON.stringify({
+        meta: entry.meta,
+        context: entry.context,
+        correlationId: entry.correlationId,
+        error: entry.error
+      })
+    };
+  }
+  return {
+    name: "redis",
+    level,
+    transform(entry) {
+      const fields = fieldMapper(entry);
+      const args = [streamKey];
+      if (maxLen) {
+        args.push("MAXLEN", "~", maxLen);
+      }
+      args.push("*");
+      for (const [key, value] of Object.entries(fields)) {
+        args.push(key, value);
+      }
+      client.xadd(...args).catch(() => {
+      });
+    },
+    async close() {
+    }
+  };
+}
+export {
+  LogLevel,
+  LogLevelNameMap,
+  LogLevelValueMap,
+  alertMiddleware,
+  batchTransport,
+  consoleTransport,
+  createLogger,
+  createMiddleware,
+  jsonStreamTransport,
+  ocppMiddleware,
+  prettyTransport,
+  redactionMiddleware,
+  redisTransport,
+  resolveLevel,
+  samplingMiddleware,
+  shouldIncludeStack,
+  shouldLog,
+  webhookTransport
+};
+//# sourceMappingURL=index.mjs.map