@smoothbricks/lmao 0.1.0

package/dist/lib/tracer.js

@@ -0,0 +1,346 @@
+import { createTagWriter } from './codegen/fixedPositionWriterGenerator.js';
+import { createSpanLogger as createSpanLoggerFromGenerator } from './codegen/spanLoggerGenerator.js';
+import { Op } from './op.js';
+import { createOpMetadata } from './opContext/defineOp.js';
+import { Err, Ok } from './result.js';
+import { createFeatureFlagEvaluator, InMemoryFlagEvaluator } from './schema/evaluator.js';
+import { ENTRY_TYPE_SPAN_EXCEPTION, ENTRY_TYPE_SPAN_OK } from './schema/systemSchema.js';
+import { EMPTY_SCOPE } from './spanBuffer.js';
+import { createSpanContextClass, writeSpanEnd, writeSpanStart, } from './spanContext.js';
+import { generateTraceId, isValidTraceId } from './traceId.js';
+function isTraceOverridesArg(value) {
+    return value !== null && typeof value === 'object' && !(value instanceof Op);
+}
+function isTraceFn(value) {
+    return typeof value === 'function';
+}
+function isPromiseResult(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof Reflect.get(value, 'then') === 'function');
+}
+// =============================================================================
+// Tracer Class
+// =============================================================================
+/**
+ * Tracer - Abstract base class for trace collection
+ *
+ * Provides trace execution with lifecycle hooks for buffer management.
+ * Subclasses implement onTraceStart, onTraceEnd, onSpanStart, onSpanEnd to define
+ * how spans are collected and processed.
+ *
+ * BufferStrategy is injected to control memory management and Arrow conversion.
+ *
+ * @typeParam B - OpContextBinding type (inferred from constructor argument)
+ */
+export class Tracer {
+    logBinding;
+    SpanContextClass;
+    flagEvaluator;
+    ctxDefaults;
+    deps;
+    createTraceRoot;
+    /**
+     * Buffer strategy for memory management and Arrow conversion.
+     * Public because SpanContext needs access for child span creation.
+     * Also accessible to subclasses for toArrowTable/releaseBuffer calls.
+     */
+    bufferStrategy;
+    constructor(binding, options) {
+        this.logBinding = binding.logBinding;
+        this.bufferStrategy = options.bufferStrategy;
+        this.ctxDefaults = binding.ctxDefaults ?? EMPTY_SCOPE;
+        this.deps = binding.deps ?? EMPTY_SCOPE;
+        this.flagEvaluator = this._createFlagEvaluator(binding.flags, options.flagEvaluator);
+        this.createTraceRoot = options.createTraceRoot;
+        // Create SpanContext class for all contexts created by this tracer
+        // The class closes over schema/logBinding and provides typed methods
+        this.SpanContextClass = createSpanContextClass(binding.logBinding.logSchema, binding.logBinding);
+        // Bind methods for destructuring (per AGENTS.md - "Always destructure")
+        this.trace = this.trace.bind(this);
+        this.trace_op = this.trace_op.bind(this);
+        this.trace_fn = this.trace_fn.bind(this);
+        this.flush = this.flush.bind(this);
+    }
+    _createFlagEvaluator(flags, evaluator) {
+        const delegate = evaluator ?? new InMemoryFlagEvaluator(flags);
+        const boundEvaluator = {
+            getSync: (ctx, flag) => delegate.getSync(ctx, flag),
+            getAsync: (ctx, flag) => delegate.getAsync(ctx, flag),
+            forContext: (ctx) => createFeatureFlagEvaluator(flags, ctx, boundEvaluator),
+        };
+        return boundEvaluator;
+    }
+    /**
+     * Flush any pending data. Default is no-op.
+     * Subclasses override if they batch data (e.g., collecting in onTraceEnd then flushing here).
+     */
+    async flush() {
+        // Default no-op - subclasses override if needed
+    }
+    trace(...args) {
+        const len = args.length;
+        if (len === 0)
+            throw new Error('trace() requires at least 1 argument');
+        // Detect if first arg is a line number (transformer-injected)
+        const firstArg = args[0];
+        const hasLine = typeof firstArg === 'number';
+        const line = hasLine ? firstArg : 0;
+        // Name is always required and comes after optional line
+        const nameIdx = hasLine ? 1 : 0;
+        const name = args[nameIdx];
+        if (typeof name !== 'string') {
+            throw new Error('trace() requires a trace name string');
+        }
+        // Check if next arg is overrides (object but not Op or function)
+        const nextIdx = nameIdx + 1;
+        const nextArg = args[nextIdx];
+        const hasOverrides = isTraceOverridesArg(nextArg) && !isTraceFn(nextArg);
+        const overrides = hasOverrides ? nextArg : EMPTY_SCOPE;
+        const fnIdx = nextIdx + (hasOverrides ? 1 : 0);
+        const fnOrOp = args[fnIdx];
+        const argCount = len - fnIdx - 1;
+        // Dispatch to monomorphic methods
+        if (fnOrOp instanceof Op) {
+            switch (argCount) {
+                case 0:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn);
+                case 1:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1]);
+                case 2:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2]);
+                case 3:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3]);
+                case 4:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3], args[fnIdx + 4]);
+                case 5:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3], args[fnIdx + 4], args[fnIdx + 5]);
+                case 6:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3], args[fnIdx + 4], args[fnIdx + 5], args[fnIdx + 6]);
+                case 7:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3], args[fnIdx + 4], args[fnIdx + 5], args[fnIdx + 6], args[fnIdx + 7]);
+                case 8:
+                    return this._trace_unknown_op(line, name, overrides, fnOrOp.metadata, fnOrOp.fn, args[fnIdx + 1], args[fnIdx + 2], args[fnIdx + 3], args[fnIdx + 4], args[fnIdx + 5], args[fnIdx + 6], args[fnIdx + 7], args[fnIdx + 8]);
+                default:
+                    throw new Error(`trace() supports up to 8 op arguments, got ${argCount}`);
+            }
+        }
+        // Function path - no args allowed
+        if (argCount > 0) {
+            throw new Error('trace() with inline function does not accept additional arguments');
+        }
+        if (!isTraceFn(fnOrOp)) {
+            throw new Error('trace() requires an Op or function callback');
+        }
+        return this._trace_unknown_fn(line, name, overrides, fnOrOp);
+    }
+    // ===========================================================================
+    // Monomorphic trace methods (for transformer optimization)
+    // ===========================================================================
+    /**
+     * Execute an Op as a root trace (internal monomorphic method).
+     * Supports 0-8 arguments. The transformer rewrites trace() calls to this.
+     */
+    _trace_op(line, name, overrides, op, ...opArgs) {
+        const ctx = this._createRootContext(line, name, overrides, op.metadata);
+        return this._executeResultWithContext(ctx, (c) => op.fn(c, ...opArgs));
+    }
+    _trace_unknown_op(line, name, overrides, metadata, fn, ...opArgs) {
+        const ctx = this._createRootContext(line, name, overrides, metadata);
+        return this._executeResultWithContext(ctx, (childCtx) => fn(childCtx, ...opArgs));
+    }
+    _trace_fn(line, name, overrides, fn) {
+        const ctx = this._createRootContext(line, name, overrides, createOpMetadata('root', 'tracer', 'runtime', 'unknown', 0));
+        return this._executeUnknownWithContext(ctx, fn);
+    }
+    _trace_unknown_fn(line, name, overrides, fn) {
+        return this._trace_fn(line, name, overrides, fn);
+    }
+    // ===========================================================================
+    // Public monomorphic methods (for transformer direct calls)
+    // ===========================================================================
+    /**
+     * Execute an Op as a root trace (monomorphic - for transformer optimization).
+     * Public API for transformer to call directly, bypassing polymorphic dispatch.
+     */
+    trace_op(line, name, overrides, op, ...opArgs) {
+        return this._trace_op(line, name, overrides, op, ...opArgs);
+    }
+    trace_fn(line, name, overrides, fn) {
+        return this._trace_fn(line, name, overrides, fn);
+    }
+    // ===========================================================================
+    // Internal helpers
+    // ===========================================================================
+    _createRootContext(_line, name, overrides, metadata) {
+        // Extract trace_id from overrides if present
+        const traceId = isValidTraceId(overrides.trace_id) ? overrides.trace_id : generateTraceId();
+        const schema = this.logBinding.logSchema;
+        // Validate null-sentinel required fields and merge user context.
+        // _resolveUserContext ignores trace_id (transport-only field).
+        const overrideRecord = { ...overrides };
+        const resolvedUserCtx = this._resolveUserContext(overrideRecord);
+        // Create TraceRoot via platform-specific factory
+        const traceRoot = this.createTraceRoot(traceId, this);
+        // Create root SpanBuffer with pre-built TraceRoot via strategy
+        const buffer = this.bufferStrategy.createSpanBuffer(schema, traceRoot, // pre-built TraceRoot with trace_id, anchors, tracer
+        metadata);
+        // Write span-start entry (row 0)
+        writeSpanStart(buffer, name);
+        // Create tag writer and span logger (needed for constructor)
+        const tagWriter = createTagWriter(schema, buffer);
+        const spanLogger = createSpanLoggerFromGenerator(schema, buffer);
+        // Instantiate SpanContext class with direct arguments (no temp object allocation)
+        const ctx = new this.SpanContextClass(buffer, schema, spanLogger, tagWriter);
+        // Set up deps from config (may be EMPTY_SCOPE if none provided)
+        ctx.deps = this.deps;
+        ctx.ff = this.flagEvaluator.forContext(ctx);
+        // Copy resolved user context onto SpanContext.
+        for (const key in resolvedUserCtx) {
+            ctx[key] = resolvedUserCtx[key];
+        }
+        return ctx;
+    }
+    /**
+     * Validate null-sentinel required fields and merge with provided overrides.
+     *
+     * Per the ctx config pattern:
+     * - Properties with null values in ctxDefaults must be provided in overrides
+     * - Properties with default values can optionally be overridden
+     * - undefined is allowed for optional fields
+     */
+    _resolveUserContext(overrides) {
+        const ctxDefaults = this.ctxDefaults;
+        // Check that all null-sentinel keys are provided in overrides
+        for (const key of Object.keys(ctxDefaults)) {
+            const defaultValue = ctxDefaults[key];
+            if (defaultValue === null) {
+                const providedValue = overrides[key];
+                if (providedValue === null || providedValue === undefined) {
+                    throw new Error(`Required context parameter '${key}' must be provided. ` +
+                        'Properties with null values in ctx config are required.');
+                }
+            }
+        }
+        // Merge defaults with provided overrides (provided values win)
+        const resolvedUserCtx = { ...ctxDefaults };
+        for (const key of Object.keys(overrides)) {
+            if (key === 'trace_id') {
+                continue;
+            }
+            const value = overrides[key];
+            if (value !== undefined) {
+                resolvedUserCtx[key] = value;
+            }
+        }
+        return resolvedUserCtx;
+    }
+    /**
+     * Execute function with context and handle span-ok/span-err/span-exception writes
+     * Promise-agnostic: returns sync for sync fn, Promise for async fn
+     *
+     * Writes span-end entry (entry_type, timestamp, error_code) and applies deferred tags
+     * when the function returns an Ok/Err result.
+     */
+    _executeResultWithContext(ctx, fn) {
+        const buffer = ctx._buffer;
+        this.onTraceStart(buffer);
+        let isAsync = false;
+        try {
+            const result = fn(ctx);
+            if (isPromiseResult(result)) {
+                isAsync = true;
+                return result
+                    .then((resolved) => {
+                    writeSpanEnd(buffer, resolved);
+                    return resolved;
+                }, (error) => {
+                    buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_EXCEPTION);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorStack = error instanceof Error ? error.stack : undefined;
+                    buffer.message(1, errorMessage);
+                    if (errorStack) {
+                        buffer.exception_stack(1, errorStack);
+                    }
+                    throw error;
+                })
+                    .finally(() => this.onTraceEnd(buffer));
+            }
+            writeSpanEnd(buffer, result);
+            return result;
+        }
+        catch (error) {
+            buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_EXCEPTION);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            buffer.message(1, errorMessage);
+            if (errorStack) {
+                buffer.exception_stack(1, errorStack);
+            }
+            throw error;
+        }
+        finally {
+            if (!isAsync) {
+                this.onTraceEnd(buffer);
+            }
+        }
+    }
+    _executeUnknownWithContext(ctx, fn) {
+        const buffer = ctx._buffer;
+        // Call trace start hook
+        this.onTraceStart(buffer);
+        let isAsync = false;
+        try {
+            const result = fn(ctx);
+            if (isPromiseResult(result)) {
+                isAsync = true;
+                return result
+                    .then((resolved) => {
+                    if (resolved instanceof Ok || resolved instanceof Err) {
+                        writeSpanEnd(buffer, resolved);
+                    }
+                    else {
+                        buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_OK);
+                    }
+                    return resolved;
+                }, (error) => {
+                    buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_EXCEPTION);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorStack = error instanceof Error ? error.stack : undefined;
+                    buffer.message(1, errorMessage);
+                    if (errorStack) {
+                        buffer.exception_stack(1, errorStack);
+                    }
+                    throw error;
+                })
+                    .finally(() => this.onTraceEnd(buffer));
+            }
+            // Sync path - write span-end
+            if (result instanceof Ok || result instanceof Err) {
+                writeSpanEnd(buffer, result);
+            }
+            else {
+                buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_OK);
+            }
+            return result;
+        }
+        catch (error) {
+            // Sync exception path
+            buffer._traceRoot.writeSpanEnd(buffer, ENTRY_TYPE_SPAN_EXCEPTION);
+            // Write exception details
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            buffer.message(1, errorMessage);
+            if (errorStack) {
+                buffer.exception_stack(1, errorStack);
+            }
+            throw error;
+        }
+        finally {
+            // Only call for sync path - async uses .finally() on promise
+            if (!isAsync) {
+                this.onTraceEnd(buffer);
+            }
+        }
+    }
+}

package/dist/lib/tracers/ArrayQueueTracer.d.ts

@@ -0,0 +1,56 @@
+import type { OpContextBinding } from '../opContext/types.js';
+import { Tracer } from '../tracer.js';
+import type { SpanBuffer } from '../types.js';
+/**
+ * Tracer that batches completed root traces in an in-memory queue.
+ *
+ * Use `drain()` to consume all queued buffers and clear the queue.
+ * Designed for production scenarios where traces should be batched
+ * before sending to a backend.
+ *
+ * @example
+ * ```typescript
+ * import { createTraceRoot } from '@smoothbricks/lmao/node';
+ * import { JsBufferStrategy } from '@smoothbricks/lmao';
+ *
+ * const ctx = defineOpContext({ logSchema });
+ * const tracer = new ArrayQueueTracer(ctx, {
+ *   bufferStrategy: new JsBufferStrategy(),
+ *   createTraceRoot,
+ * });
+ * const { trace } = tracer;
+ *
+ * // Process requests, traces accumulate
+ * await trace('request-1', handleRequest, req1);
+ * await trace('request-2', handleRequest, req2);
+ *
+ * // Periodically drain and process
+ * const batch = tracer.drain();
+ * for (const buf of batch) {
+ *   const table = await tracer.bufferStrategy.toArrowTable(buf);
+ *   await sendToBackend(table);
+ *   tracer.bufferStrategy.releaseBuffer(buf);
+ * }
+ * ```
+ */
+export declare class ArrayQueueTracer<B extends OpContextBinding = OpContextBinding> extends Tracer<B> {
+    /**
+     * Queue of completed root trace buffers.
+     * Use `drain()` to consume and clear.
+     * Public for test inspection.
+     */
+    readonly queue: SpanBuffer<B['logBinding']['logSchema']>[];
+    onTraceStart(_rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onTraceEnd(rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onSpanStart(_childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onSpanEnd(_childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onStatsWillResetFor(_buffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    /**
+     * Consume all queued buffers and clear the queue.
+     * Returns an independent copy of the queue contents.
+     *
+     * @returns Array of root buffers (with child spans in _children tree)
+     */
+    drain(): SpanBuffer<B['logBinding']['logSchema']>[];
+}
+//# sourceMappingURL=ArrayQueueTracer.d.ts.map

package/dist/lib/tracers/ArrayQueueTracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayQueueTracer.d.ts","sourceRoot":"","sources":["../../../src/lib/tracers/ArrayQueueTracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC5F;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAM;IAEhE,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIzE,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAItE,WAAW,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIzE,SAAS,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIvE,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAI5E;;;;;OAKG;IACH,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE;CAKpD"}

package/dist/lib/tracers/ArrayQueueTracer.js

@@ -0,0 +1,67 @@
+import { Tracer } from '../tracer.js';
+/**
+ * Tracer that batches completed root traces in an in-memory queue.
+ *
+ * Use `drain()` to consume all queued buffers and clear the queue.
+ * Designed for production scenarios where traces should be batched
+ * before sending to a backend.
+ *
+ * @example
+ * ```typescript
+ * import { createTraceRoot } from '@smoothbricks/lmao/node';
+ * import { JsBufferStrategy } from '@smoothbricks/lmao';
+ *
+ * const ctx = defineOpContext({ logSchema });
+ * const tracer = new ArrayQueueTracer(ctx, {
+ *   bufferStrategy: new JsBufferStrategy(),
+ *   createTraceRoot,
+ * });
+ * const { trace } = tracer;
+ *
+ * // Process requests, traces accumulate
+ * await trace('request-1', handleRequest, req1);
+ * await trace('request-2', handleRequest, req2);
+ *
+ * // Periodically drain and process
+ * const batch = tracer.drain();
+ * for (const buf of batch) {
+ *   const table = await tracer.bufferStrategy.toArrowTable(buf);
+ *   await sendToBackend(table);
+ *   tracer.bufferStrategy.releaseBuffer(buf);
+ * }
+ * ```
+ */
+export class ArrayQueueTracer extends Tracer {
+    /**
+     * Queue of completed root trace buffers.
+     * Use `drain()` to consume and clear.
+     * Public for test inspection.
+     */
+    queue = [];
+    onTraceStart(_rootBuffer) {
+        // No-op
+    }
+    onTraceEnd(rootBuffer) {
+        this.queue.push(rootBuffer);
+    }
+    onSpanStart(_childBuffer) {
+        // No-op
+    }
+    onSpanEnd(_childBuffer) {
+        // No-op
+    }
+    onStatsWillResetFor(_buffer) {
+        // No-op - override in subclass to capture stats
+    }
+    /**
+     * Consume all queued buffers and clear the queue.
+     * Returns an independent copy of the queue contents.
+     *
+     * @returns Array of root buffers (with child spans in _children tree)
+     */
+    drain() {
+        const buffers = [...this.queue];
+        this.queue.length = 0;
+        return buffers;
+    }
+}

package/dist/lib/tracers/CompositeTracer.d.ts

@@ -0,0 +1,24 @@
+import type { OpContextBinding } from '../opContext/types.js';
+import { Tracer, type TracerOptions } from '../tracer.js';
+import type { SpanBuffer } from '../types.js';
+export interface CompositeTracerOptions<B extends OpContextBinding = OpContextBinding> extends TracerOptions<B['logBinding']['logSchema']> {
+    delegates: Tracer<B>[];
+}
+/**
+ * Composite tracer that fans lifecycle hooks out to delegate tracers.
+ *
+ * Useful when you want multiple outputs from a single trace run,
+ * for example Stdio + SQLite.
+ */
+export declare class CompositeTracer<B extends OpContextBinding = OpContextBinding> extends Tracer<B> {
+    private readonly delegates;
+    constructor(binding: B, options: CompositeTracerOptions<B>);
+    onTraceStart(rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onTraceEnd(rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onSpanStart(childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onSpanEnd(childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    onStatsWillResetFor(buffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=CompositeTracer.d.ts.map

package/dist/lib/tracers/CompositeTracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeTracer.d.ts","sourceRoot":"","sources":["../../../src/lib/tracers/CompositeTracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAQ9C,MAAM,WAAW,sBAAsB,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CACnF,SAAQ,aAAa,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC;IACnD,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC3F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;gBAE5B,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC;IAK1D,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAMxE,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAMtE,WAAW,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAMxE,SAAS,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAMtE,mBAAmB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAM5D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAU7B"}

package/dist/lib/tracers/CompositeTracer.js

@@ -0,0 +1,57 @@
+import { Tracer } from '../tracer.js';
+function hasClose(value) {
+    return typeof value === 'object' && value !== null && typeof Reflect.get(value, 'close') === 'function';
+}
+/**
+ * Composite tracer that fans lifecycle hooks out to delegate tracers.
+ *
+ * Useful when you want multiple outputs from a single trace run,
+ * for example Stdio + SQLite.
+ */
+export class CompositeTracer extends Tracer {
+    delegates;
+    constructor(binding, options) {
+        super(binding, options);
+        this.delegates = options.delegates;
+    }
+    onTraceStart(rootBuffer) {
+        for (const tracer of this.delegates) {
+            tracer.onTraceStart(rootBuffer);
+        }
+    }
+    onTraceEnd(rootBuffer) {
+        for (const tracer of this.delegates) {
+            tracer.onTraceEnd(rootBuffer);
+        }
+    }
+    onSpanStart(childBuffer) {
+        for (const tracer of this.delegates) {
+            tracer.onSpanStart(childBuffer);
+        }
+    }
+    onSpanEnd(childBuffer) {
+        for (const tracer of this.delegates) {
+            tracer.onSpanEnd(childBuffer);
+        }
+    }
+    onStatsWillResetFor(buffer) {
+        for (const tracer of this.delegates) {
+            tracer.onStatsWillResetFor(buffer);
+        }
+    }
+    async flush() {
+        for (const tracer of this.delegates) {
+            await tracer.flush();
+        }
+    }
+    async close() {
+        for (const tracer of this.delegates) {
+            if (hasClose(tracer)) {
+                const { close } = tracer;
+                if (close) {
+                    await close.call(tracer);
+                }
+            }
+        }
+    }
+}

package/dist/lib/tracers/NoOpTracer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * NoOpTracer - A tracer that executes ops but discards all trace data
+ *
+ * All lifecycle hooks are no-ops - traces execute normally but produce no output.
+ * Useful for:
+ * - Tests that don't need to inspect trace output
+ * - Disabling tracing in production without code changes
+ * - Baseline performance testing (measures op execution cost without tracing overhead)
+ *
+ * @example
+ * ```typescript
+ * import { createTraceRoot } from '@smoothbricks/lmao/node';
+ * import { JsBufferStrategy } from '@smoothbricks/lmao';
+ *
+ * const ctx = defineOpContext({ logSchema });
+ * const { trace } = new NoOpTracer(ctx, {
+ *   bufferStrategy: new JsBufferStrategy(),
+ *   createTraceRoot,
+ * });
+ *
+ * // Trace executes, result returned, no side effects
+ * const result = await trace('fetch', fetchOp);
+ * ```
+ */
+import type { OpContextBinding } from '../opContext/types.js';
+import { Tracer } from '../tracer.js';
+import type { SpanBuffer } from '../types.js';
+/**
+ * No-op tracer - executes ops normally but discards all trace data
+ *
+ * All lifecycle hooks are empty - no processing, no output.
+ * Useful for testing and measuring op execution cost without trace overhead.
+ *
+ * @typeParam B - OpContextBinding type
+ */
+export declare class NoOpTracer<B extends OpContextBinding = OpContextBinding> extends Tracer<B> {
+    /**
+     * No-op hook for trace start.
+     */
+    onTraceStart(_rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    /**
+     * No-op hook for trace end.
+     */
+    onTraceEnd(_rootBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    /**
+     * No-op hook for span start.
+     */
+    onSpanStart(_childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    /**
+     * No-op hook for span end.
+     */
+    onSpanEnd(_childBuffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+    /**
+     * No-op hook for stats reset.
+     */
+    onStatsWillResetFor(_buffer: SpanBuffer<B['logBinding']['logSchema']>): void;
+}
+//# sourceMappingURL=NoOpTracer.d.ts.map

package/dist/lib/tracers/NoOpTracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoOpTracer.d.ts","sourceRoot":"","sources":["../../../src/lib/tracers/NoOpTracer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;GAOG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACtF;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIzE;;OAEG;IACH,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIvE;;OAEG;IACH,WAAW,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIzE;;OAEG;IACH,SAAS,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAIvE;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;CAG7E"}

package/dist/lib/tracers/NoOpTracer.js

@@ -0,0 +1,41 @@
+import { Tracer } from '../tracer.js';
+/**
+ * No-op tracer - executes ops normally but discards all trace data
+ *
+ * All lifecycle hooks are empty - no processing, no output.
+ * Useful for testing and measuring op execution cost without trace overhead.
+ *
+ * @typeParam B - OpContextBinding type
+ */
+export class NoOpTracer extends Tracer {
+    /**
+     * No-op hook for trace start.
+     */
+    onTraceStart(_rootBuffer) {
+        // No-op
+    }
+    /**
+     * No-op hook for trace end.
+     */
+    onTraceEnd(_rootBuffer) {
+        // No-op
+    }
+    /**
+     * No-op hook for span start.
+     */
+    onSpanStart(_childBuffer) {
+        // No-op
+    }
+    /**
+     * No-op hook for span end.
+     */
+    onSpanEnd(_childBuffer) {
+        // No-op
+    }
+    /**
+     * No-op hook for stats reset.
+     */
+    onStatsWillResetFor(_buffer) {
+        // No-op
+    }
+}