@contractspec/lib.logger 1.56.1 → 1.58.0

package/dist/tracer.js

@@ -0,0 +1,275 @@
+// @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/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);
+  }
+}
+export {
+  Tracer
+};

package/dist/tracer.node.d.ts

@@ -0,0 +1,47 @@
+import type { TraceContext, TracingOptions } from './types';
+export declare class Tracer {
+    private context;
+    private activeSpans;
+    constructor();
+    /**
+     * Start a new trace span
+     */
+    startSpan(options: TracingOptions): TraceContext;
+    /**
+     * Finish a trace span
+     */
+    finishSpan(spanId: string): number | undefined;
+    /**
+     * Execute a function within a trace span
+     */
+    trace<T>(options: TracingOptions, fn: () => T | Promise<T>): Promise<T>;
+    /**
+     * Add metadata to current span
+     */
+    addMetadata(key: string, value: unknown): void;
+    /**
+     * Add tags to current span
+     */
+    addTags(...tags: string[]): void;
+    /**
+     * Get current trace context
+     */
+    getCurrentTrace(): TraceContext | undefined;
+    /**
+     * Get all active spans
+     */
+    getActiveSpans(): TraceContext[];
+    /**
+     * Find a span by ID
+     */
+    findSpanById(spanId: string): TraceContext | undefined;
+    /**
+     * Generate a unique trace ID
+     */
+    private generateTraceId;
+    /**
+     * Generate a unique span ID
+     */
+    private generateSpanId;
+}
+//# sourceMappingURL=tracer.node.d.ts.map

package/dist/tracer.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.node.d.ts","sourceRoot":"","sources":["../src/tracer.node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI5D,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,WAAW,CAAmC;;IAMtD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,YAAY;IAqBhD;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAqB9C;;OAEG;IACG,KAAK,CAAC,CAAC,EACX,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC;IAuCb;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAO9C;;OAEG;IACH,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAOhC;;OAEG;IACH,eAAe,IAAI,YAAY,GAAG,SAAS;IAI3C;;OAEG;IACH,cAAc,IAAI,YAAY,EAAE;IAIhC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAItD;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,cAAc;CAGvB"}

package/dist/tracer.node.js

@@ -0,0 +1,275 @@
+// @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/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);
+  }
+}
+export {
+  Tracer
+};

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+export declare enum LogLevel {
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    FATAL = 5
+}
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    traceId?: string;
+    parentId?: string;
+    spanId?: string;
+    context?: Record<string, any>;
+    metadata?: Record<string, any>;
+    duration?: number;
+    error?: Error;
+    tags?: string[];
+}
+export interface TraceContext {
+    traceId: string;
+    parentId?: string;
+    spanId: string;
+    operationType: string;
+    operationName: string;
+    startTime: number;
+    metadata: Record<string, any>;
+    tags: string[];
+}
+export interface TracingOptions {
+    operationType: 'http' | 'websocket' | 'cron' | 'queue' | 'database' | 'custom';
+    operationName: string;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    autoTiming?: boolean;
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    environment: 'development' | 'production' | 'test';
+    enableTracing: boolean;
+    enableTiming: boolean;
+    enableContext: boolean;
+    enableColors: boolean;
+    maxContextDepth: number;
+    timestampFormat: 'iso' | 'epoch' | 'relative';
+}
+export interface Formatter {
+    format(entry: LogEntry): string;
+}
+export interface Timer {
+    readonly id: string;
+    stop(): number;
+    lap(label?: string): number;
+    getElapsed(): number;
+}
+export interface ContextData {
+    [key: string]: any;
+    userId?: string;
+    requestId?: string;
+    sessionId?: string;
+    ip?: string;
+    userAgent?: string;
+}
+export type LogMethod = (message: string, metadata?: Record<string, any>) => void;
+export type TraceMethod = <T>(options: TracingOptions, fn: () => T | Promise<T>) => Promise<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;IACT,KAAK,IAAI;CACV;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE9B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAElB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,EACT,MAAM,GACN,WAAW,GACX,MAAM,GACN,OAAO,GACP,UAAU,GACV,QAAQ,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,WAAW,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;IACnD,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,KAAK,GAAG,OAAO,GAAG,UAAU,CAAC;CAC/C;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,IAAI,IAAI,MAAM,CAAC;IACf,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,UAAU,IAAI,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAE1B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,SAAS,GAAG,CACtB,OAAO,EAAE,MAAM,EAEf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAC3B,IAAI,CAAC;AACV,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,EAC1B,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACrB,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,14 @@
+// @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 ||= {});
+export {
+  LogLevel
+};