@contractspec/lib.logger 1.56.1 → 1.58.0

package/dist/node/timer.js

@@ -0,0 +1,122 @@
+// 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;
+  }
+}
+export {
+  timedSync,
+  timed,
+  TimerManager,
+  Timer
+};

package/dist/node/tracer.js

@@ -0,0 +1,274 @@
+// src/context.node.ts
+import { AsyncLocalStorage } from "node: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/node/tracer.node.js

@@ -0,0 +1,274 @@
+// src/context.node.ts
+import { AsyncLocalStorage } from "node: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/node/types.js

@@ -0,0 +1,13 @@
+// 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
+};