@contractspec/lib.logger 1.56.1 → 1.58.0

package/dist/timer.d.ts

@@ -0,0 +1,99 @@
+import type { Timer as ITimer } from './types';
+export declare class Timer implements ITimer {
+    readonly id: string;
+    private startTime;
+    private laps;
+    private stopped;
+    private stopTime?;
+    constructor(id?: string);
+    /**
+     * Stop the timer and return elapsed time in milliseconds
+     */
+    stop(): number;
+    /**
+     * Record a lap time and return elapsed time since start
+     */
+    lap(label?: string): number;
+    /**
+     * Get elapsed time without stopping the timer
+     */
+    getElapsed(): number;
+    /**
+     * Get all recorded laps
+     */
+    getLaps(): {
+        label?: string;
+        time: number;
+        elapsed: number;
+    }[];
+    /**
+     * Get timer summary with total time and laps
+     */
+    getSummary(): {
+        id: string;
+        totalTime: number;
+        isRunning: boolean;
+        laps: {
+            label?: string;
+            time: number;
+            elapsed: number;
+        }[];
+    };
+    /**
+     * Reset the timer (starts a new timing session)
+     */
+    reset(): void;
+}
+/**
+ * Utility class for managing multiple timers
+ */
+export declare class TimerManager {
+    private timers;
+    /**
+     * Start a new timer
+     */
+    start(id?: string): Timer;
+    /**
+     * Get an existing timer
+     */
+    get(id: string): Timer | undefined;
+    /**
+     * Stop and remove a timer
+     */
+    stop(id: string): number | undefined;
+    /**
+     * Get all active timers
+     */
+    getActive(): Timer[];
+    /**
+     * Clear all timers
+     */
+    clear(): void;
+    /**
+     * Get summary of all timers
+     */
+    getSummary(): ReturnType<Timer['getSummary']>[];
+}
+/**
+ * Decorator/wrapper function to time async operations
+ */
+export declare function timed<T>(operation: () => Promise<T>, options?: {
+    id?: string;
+    onComplete?: (elapsed: number) => void;
+}): Promise<{
+    result: T;
+    elapsed: number;
+    timer: Timer;
+}>;
+/**
+ * Decorator/wrapper function to time synchronous operations
+ */
+export declare function timedSync<T>(operation: () => T, options?: {
+    id?: string;
+    onComplete?: (elapsed: number) => void;
+}): {
+    result: T;
+    elapsed: number;
+    timer: Timer;
+};
+//# sourceMappingURL=timer.d.ts.map

package/dist/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../src/timer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,MAAM,EAAE,MAAM,SAAS,CAAC;AAE/C,qBAAa,KAAM,YAAW,MAAM;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAA2D;IACvE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,EAAE,CAAC,EAAE,MAAM;IAKvB;;OAEG;IACH,IAAI,IAAI,MAAM;IAkBd;;OAEG;IACH,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAiB3B;;OAEG;IACH,UAAU,IAAI,MAAM;IAOpB;;OAEG;IACH,OAAO,IAAI;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE;IAI9D;;OAEG;IACH,UAAU,IAAI;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,OAAO,CAAC;QACnB,IAAI,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KAC3D;IASD;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAA4B;IAE1C;;OAEG;IACH,KAAK,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK;IAMzB;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIlC;;OAEG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAUpC;;OAEG;IACH,SAAS,IAAI,KAAK,EAAE;IAMpB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,EAAE;CAGhD;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,CAAC,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAChE,OAAO,CAAC;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAcvD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,SAAS,EAAE,MAAM,CAAC,EAClB,OAAO,CAAC,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAChE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAc9C"}

package/dist/timer.js

@@ -0,0 +1,123 @@
+// @bun
+// 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/tracer.browser.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.browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.browser.d.ts","sourceRoot":"","sources":["../src/tracer.browser.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.browser.js

@@ -0,0 +1,290 @@
+// @bun
+// src/context.browser.ts
+import"zone.js";
+var ZONE = globalThis.Zone;
+var STORE_KEY = "__lssm_log_context_data__";
+function getStore() {
+  if (!ZONE)
+    return;
+  return ZONE.current.get(STORE_KEY);
+}
+
+class LogContext {
+  static instance;
+  static fallbackCounter = 0;
+  static getInstance() {
+    if (!LogContext.instance) {
+      LogContext.instance = new LogContext;
+    }
+    return LogContext.instance;
+  }
+  run(context, fn) {
+    const contextData = {
+      context: { ...context },
+      trace: this.getCurrentTrace()
+    };
+    if (!ZONE) {
+      return fn();
+    }
+    const zone = ZONE.current.fork({
+      name: "log-context",
+      properties: { [STORE_KEY]: contextData }
+    });
+    return zone.run(fn);
+  }
+  extend(additionalContext, fn) {
+    const currentContext = this.getContext();
+    const mergedContext = {
+      ...currentContext,
+      ...additionalContext
+    };
+    return this.run(mergedContext, fn);
+  }
+  set(key, value) {
+    const current = getStore();
+    if (current) {
+      current.context[key] = value;
+    }
+  }
+  get(key) {
+    const current = getStore();
+    return current?.context?.[key];
+  }
+  getContext() {
+    const current = getStore();
+    return current?.context || {};
+  }
+  setTrace(trace) {
+    const current = getStore();
+    if (current) {
+      current.trace = trace;
+    }
+  }
+  getCurrentTrace() {
+    const current = getStore();
+    return current?.trace;
+  }
+  generateId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    LogContext.fallbackCounter += 1;
+    return `log-${LogContext.fallbackCounter}`;
+  }
+}
+
+// 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.browser.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.d.ts

@@ -0,0 +1,2 @@
+export { Tracer } from './tracer.node';
+//# sourceMappingURL=tracer.d.ts.map

package/dist/tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../src/tracer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC"}