@pristine-ts/telemetry 2.0.3 → 2.0.5

package/dist/types/managers/tracing.manager.d.ts

@@ -9,13 +9,23 @@ import { LogHandlerInterface } from "@pristine-ts/logging";
  * It is tagged and can be injected using TracingManagerInterface which facilitates mocking.
  * It is module scoped to the TelemetryModuleKeyname.
  *
+ * **Where the active `Trace` lives.** The active trace is stored on `EventContext.trace`,
+ * propagated via `AsyncLocalStorage`. Every `TracingManager` instance — whether resolved
+ * from the root container (kernel boot) or from a per-event child container — reads and
+ * writes spans through the same `EventContext.trace` reference, so a span started in the
+ * kernel and an event added in a controller belong to the same trace tree.
+ *
+ * **Fallback `this.trace`.** During kernel boot (`Kernel.start()` and friends), there is
+ * no `EventContext` yet — the framework hasn't started handling an event. In that window
+ * the manager falls back to `this.trace`. This is the only time `this.trace` is touched.
+ *
  * **Lifecycle: container-scoped, not singleton.** Each per-event DI child container gets
- * its own `TracingManager` instance with its own `trace` and `spans` state. Earlier
- * versions used `@singleton()` — a single instance shared across every event — which
- * was a latent bug: parallel events would clobber each other's `this.trace`. Resolving
- * `TracingManager` from the root container still returns the root instance (used for
- * kernel-initialization spans before any event has started); resolving from a child
- * container returns the per-event instance, which is what application code wants.
+ * its own `TracingManager` instance. The per-instance `this.trace` fallback is what keeps
+ * parallel events isolated *if* tracing is somehow started outside an EventContext.
+ * Resolving `TracingManager` from the root container returns the root instance (used for
+ * kernel-initialization spans); resolving from a child container returns the per-event
+ * instance — both will agree on what trace is active inside an event because they read
+ * from EventContext.
  */
 export declare class TracingManager implements TracingManagerInterface {
     private readonly tracers;
@@ -24,15 +34,10 @@ export declare class TracingManager implements TracingManagerInterface {
     private readonly debug;
     private readonly tracingContext;
     /**
-     * This property contains a reference to the active trace.
+     * Fallback trace used only during kernel boot when no `EventContext` is active.
+     * Inside an event, the active trace lives on `EventContext.trace` instead.
      */
     trace?: Trace;
-    /**
-     * This object contains a map of all the spans sorted by their keyname.
-     */
-    spans: {
-        [keyname: string]: Span[];
-    };
     /**
      * The Tracing Manager provides methods to help with tracing.
      * It is tagged and can be injected using TracingManagerInterface which facilitates mocking.
@@ -45,6 +50,16 @@ export declare class TracingManager implements TracingManagerInterface {
      * @param tracingContext The tracing context.
      */
     constructor(tracers: TracerInterface[], loghandler: LogHandlerInterface, isActive: boolean, debug: boolean, tracingContext: TracingContext);
+    /**
+     * Returns the currently active trace from the EventContext, falling back to the
+     * per-instance `this.trace` when no EventContext is active (kernel boot).
+     */
+    private getActiveTrace;
+    /**
+     * Stores `trace` as the active trace — on `EventContext.trace` when an event is active,
+     * otherwise on the instance fallback `this.trace`.
+     */
+    private setActiveTrace;
     /**
      * This methods starts the Tracing. This should be the first method called before doing anything else.
      * @param spanRootKeyname The keyname of the span at the root.
@@ -84,4 +99,47 @@ export declare class TracingManager implements TracingManagerInterface {
      * This method ends the trace entirely.
      */
     endTrace(): void;
+    /**
+     * Attaches a named, timestamped event to the most-recently-started in-progress span.
+     * Use for noteworthy moments that don't warrant a child span — "validation passed",
+     * "found 50 rows", "rate limit ok". Cheap (just pushes onto an array); shows up in
+     * the trace rendered by tracers (ConsoleTracer, FileTracer, X-Ray, etc.).
+     *
+     * If no span is currently active (no trace started, or every span has already ended),
+     * a warning is logged and the marker is dropped. The warning is the explicit signal
+     * that "this marker call had nowhere to go" — usually the sign of a missing
+     * `startTracing()` call earlier in the flow.
+     */
+    addEventToCurrentSpan(message: string, attributes?: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Returns the active trace's spans + their events as a flat, timestamp-sorted list of
+     * `{kind, name, date, attributes}` entries. Public utility for custom tracers, debug
+     * endpoints, test helpers, or anyone who wants "the active trace as a flat list."
+     * Returns an empty array when no active trace exists.
+     */
+    getCurrentTrail(): Array<{
+        kind: "span" | "event";
+        name: string;
+        date: Date;
+        attributes: {
+            [key: string]: string;
+        };
+    }>;
+    /**
+     * Finds the deepest in-progress span — the leaf of the still-open subtree. Used as
+     * the target for `addEventToCurrentSpan`. Intuition: events attach to whatever is
+     * currently open at the bottom of the call stack.
+     *
+     * Walking the in-progress subtree (rather than ranking all spans by start date)
+     * avoids the edge case where a parent and child have the same `Date.now()` value —
+     * picking the "latest started" by raw timestamp would incorrectly attach to the
+     * parent. Depth-first traversal of in-progress children naturally lands on the
+     * deepest leaf. Tie-broken by latest start date when multiple leaves exist.
+     *
+     * Returns undefined when nothing is in progress (no trace, or every span has ended).
+     * @private
+     */
+    private findActiveLeafSpan;
 }

package/dist/types/models/models.d.ts

@@ -1,2 +1,3 @@
+export * from "./span-event.model";
 export * from "./span.model";
 export * from "./trace.model";

package/dist/types/models/span-event.model.d.ts

@@ -0,0 +1 @@
+export { SpanEvent } from "@pristine-ts/common";

package/dist/types/models/span.model.d.ts

@@ -1,73 +1 @@
-import { Trace } from "./trace.model";
-import { TracingManagerInterface } from "../interfaces/tracing-manager.interface";
-/**
- * This model represents a span.
- */
-export declare class Span {
-    keyname: string;
-    /**
-     * The unique id of the span.
-     */
-    id: string;
-    /**
-     * The tracing manager.
-     */
-    tracingManager?: TracingManagerInterface;
-    /**
-     * The trace the span is attached to.
-     */
-    trace?: Trace;
-    /**
-     * The timestamp in milliseconds at which the span was started.
-     */
-    startDate: number;
-    /**
-     * The timestamp in milliseconds at which the span was ended.
-     */
-    endDate?: number;
-    /**
-     * The parent span.
-     */
-    parentSpan?: Span;
-    /**
-     * The children spans.
-     */
-    children: Span[];
-    /**
-     * The context associated with the span.
-     */
-    context: {
-        [key: string]: string;
-    };
-    /**
-     * Whether or not the span is in progress, meaning it has not ended.
-     */
-    inProgress: boolean;
-    /**
-     * This model represents a span.
-     * @param keyname The keyname of the span.
-     * @param id The unique id of the span.
-     * @param context The context to associate with the span.
-     */
-    constructor(keyname: string, id?: string, context?: {
-        [key: string]: string;
-    });
-    /**
-     * This method returns the duration of the span in milliseconds.
-     */
-    getDuration(): number;
-    /**
-     * This method ends the span.
-     */
-    end(): void;
-    /**
-     * This method sets the trace for the span and all of its children.
-     * @param trace The trace the span should be attached to.
-     */
-    setTrace(trace: Trace): void;
-    /**
-     * This method adds a child span to the current span. It only adds it if it's not already part of the children.
-     * @param span The span to add as a child.
-     */
-    addChild(span: Span): void;
-}
+export { Span, SpanLifecycleOwnerInterface } from "@pristine-ts/common";

package/dist/types/models/trace.model.d.ts

@@ -1,44 +1 @@
-import { Span } from "./span.model";
-/**
- * This model represents a trace.
- */
-export declare class Trace {
-    /**
-     * The unique id of the trace.
-     */
-    id: string;
-    /**
-     * The timestamp in milliseconds at which the trace was started.
-     */
-    startDate: number;
-    /**
-     * The timestamp in milliseconds at which the trace was ended.
-     */
-    endDate?: number;
-    /**
-     * The span that is at the root.
-     */
-    rootSpan?: Span;
-    /**
-     * The context associated with the trace.
-     */
-    context?: {
-        [key: string]: string;
-    };
-    /**
-     * Whether or not the trace was ended.
-     */
-    hasEnded: boolean;
-    /**
-     * This model represents a trace.
-     * @param id The unique id of the trace.
-     * @param context The context associated with the trace.
-     */
-    constructor(id?: string, context?: {
-        [key: string]: string;
-    });
-    /**
-     * This returns the duration of the trace in miliseconds.
-     */
-    getDuration(): number;
-}
+export { Trace } from "@pristine-ts/common";

package/dist/types/telemetry.module.d.ts

@@ -1,5 +1,4 @@
 import { ModuleInterface } from "@pristine-ts/common";
-export * from "./decorators/decorators";
 export * from "./enums/enums";
 export * from "./interfaces/interfaces";
 export * from "./managers/managers";

package/dist/types/utils/utils.d.ts

@@ -1,2 +1 @@
-export * from "./span-runner";
 export * from "./trace-renderer";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/telemetry",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "",
   "module": "dist/lib/esm/telemetry.module.js",
   "main": "dist/lib/cjs/telemetry.module.js",
@@ -12,8 +12,8 @@
     "test:cov": "jest --coverage"
   },
   "dependencies": {
-    "@pristine-ts/common": "^2.0.3",
-    "@pristine-ts/logging": "^2.0.3",
+    "@pristine-ts/common": "^2.0.5",
+    "@pristine-ts/logging": "^2.0.5",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
@@ -61,7 +61,7 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "c741bb430ab8f6286068dc3870fcadf4cefd0023",
+  "gitHead": "9a960b330ee1961bb9a6151ce50257c4d8ccd48d",
   "repository": {
     "type": "git",
     "url": "https://github.com/magieno/pristine-ts.git",

package/dist/lib/cjs/decorators/decorators.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./traced.decorator"), exports);
-//# sourceMappingURL=decorators.js.map

package/dist/lib/cjs/decorators/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../src/decorators/decorators.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC"}

package/dist/lib/cjs/decorators/traced.decorator.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traced = traced;
-const span_runner_1 = require("../utils/span-runner");
-/**
- * Method decorator that wraps the decorated method in a span. The span is automatically
- * ended when the method returns or throws, and the `TracingManager` is auto-resolved
- * from the active `EventContext` — no need to inject it manually.
- *
- * ```ts
- * class PaymentService {
- *   @traced()                                // span name = "PaymentService.charge"
- *   async charge(amount: number) { ... }
- *
- *   @traced("payment.refund.action")         // explicit name
- *   async refund(chargeId: string) { ... }
- * }
- * ```
- *
- * **Behavior outside an event context.** When the decorated method runs without an
- * active `EventContext` (e.g. a unit test calling the method directly, or background
- * work that escaped the event lifecycle), the decorator is a no-op — the original
- * method runs unchanged. Tracing must never throw or alter semantics.
- *
- * **Sync methods become async.** The decorator awaits the wrapped method internally,
- * so any decorated method returns a `Promise`. Decorating a sync method changes its
- * signature visible to callers — apply `@traced` to methods you'd already be awaiting
- * (DB calls, HTTP, expensive computations), not to tight sync helpers.
- *
- * **Type-level caveat.** TypeScript's parameter and method decorator types don't carry
- * enough information for the compiler to verify that the wrapped method's return type
- * is compatible with `Promise<T>`. The wrapper is type-safe at runtime; the call site's
- * static types are unchanged. Pair with explicit `: Promise<T>` annotations on the
- * method when you want the static type to match what's actually returned.
- *
- * @param spanName Optional explicit name for the span. Defaults to
- *   `${ClassName}.${methodName}`.
- */
-function traced(spanName) {
-    return (target, propertyKey, descriptor) => {
-        var _a, _b, _c;
-        const original = descriptor.value;
-        if (typeof original !== "function") {
-            // Decorator was applied to something other than a method (a getter, a property
-            // with no initial value, etc.). Leave it alone — silently no-op rather than
-            // throw at decoration time.
-            return descriptor;
-        }
-        // Resolve a stable default name at decoration time. `target.constructor.name` is
-        // the class name for instance methods; for static methods, `target.name` is the
-        // class. We cover both via the fallback chain.
-        const className = (_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : target === null || target === void 0 ? void 0 : target.name) !== null && _c !== void 0 ? _c : "anonymous";
-        const resolvedName = spanName !== null && spanName !== void 0 ? spanName : `${className}.${String(propertyKey)}`;
-        descriptor.value = function (...args) {
-            return span_runner_1.spanRunner.runWithSpan(resolvedName, () => original.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-//# sourceMappingURL=traced.decorator.js.map

package/dist/lib/cjs/decorators/traced.decorator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traced.decorator.js","sourceRoot":"","sources":["../../../../src/decorators/traced.decorator.ts"],"names":[],"mappings":";;AAoCA,wBAsBC;AA1DD,sDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,MAAM,CAAC,QAAiB;IACtC,OAAO,CAAC,MAAW,EAAE,WAA4B,EAAE,UAA8B,EAAE,EAAE;;QACnF,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;QAClC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,+EAA+E;YAC/E,4EAA4E;YAC5E,4BAA4B;YAC5B,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,iFAAiF;QACjF,gFAAgF;QAChF,+CAA+C;QAC/C,MAAM,SAAS,GAAW,MAAA,MAAA,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,0CAAE,IAAI,mCAAI,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,mCAAI,WAAW,CAAC;QACnF,MAAM,YAAY,GAAG,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,GAAG,SAAS,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAEvE,UAAU,CAAC,KAAK,GAAG,UAAyB,GAAG,IAAW;YACxD,OAAO,wBAAU,CAAC,WAAW,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/lib/cjs/utils/span-runner.js

@@ -1,112 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.spanRunner = exports.SpanRunner = void 0;
-const common_1 = require("@pristine-ts/common");
-/**
- * Runs a function inside a span that is automatically ended when the function returns
- * or throws.
- *
- * Two call shapes are supported:
- *
- * **Explicit form** (`runWithSpan(tracingManager, name, fn)`) — pass the manager you've
- * already injected. Works anywhere, including outside an event context. Use this when
- * you have a `TracingManager` reference in hand:
- *
- * ```ts
- * return spanRunner.runWithSpan(this.tracingManager, "payment.charge",
- *   () => this.client.charge(amount));
- * ```
- *
- * **ALS form** (`runWithSpan(name, fn)`) — auto-resolves the `TracingManager` from the
- * active `EventContext`'s container. Concise; works when called from anywhere inside
- * a Pristine event (controller, service, etc.) without needing the manager threaded
- * through:
- *
- * ```ts
- * return spanRunner.runWithSpan("payment.charge", () => this.client.charge(amount));
- * ```
- *
- * If the ALS form is used outside any `EventContext` (e.g. a unit test that doesn't
- * boot a kernel), no span is created and `fn` runs unchanged — same no-throw contract
- * as the rest of the tracing layer.
- *
- * On thrown errors: the error's name/message is attached to the span's context (visible
- * in the rendered tree/JSON output) and then re-thrown. The span is ended either way.
- *
- * Stateless — instantiate once and reuse, or use the exported singleton `spanRunner`.
- */
-class SpanRunner {
-    runWithSpan(tracingManagerOrSpanKeyname, spanKeynameOrFn, fnOrOptions, maybeOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Disambiguate by the first argument's shape. A string means "ALS form"; an object
-            // with `startSpan` means the explicit-manager form.
-            let tracingManager;
-            let spanKeyname;
-            let fn;
-            let options;
-            if (typeof tracingManagerOrSpanKeyname === "string") {
-                spanKeyname = tracingManagerOrSpanKeyname;
-                fn = spanKeynameOrFn;
-                options = fnOrOptions;
-                // Resolve the manager from the active event context. If there isn't one (e.g. a
-                // unit test calling this directly), fall back to running the function without a
-                // span — tracing must never throw or change semantics.
-                const container = common_1.EventContextManager.container();
-                if (container !== undefined) {
-                    try {
-                        tracingManager = container.resolve("TracingManagerInterface");
-                    }
-                    catch (_a) {
-                        tracingManager = undefined;
-                    }
-                }
-            }
-            else {
-                tracingManager = tracingManagerOrSpanKeyname;
-                spanKeyname = spanKeynameOrFn;
-                fn = fnOrOptions;
-                options = maybeOptions;
-            }
-            if (tracingManager === undefined) {
-                // No manager available: ALS form called outside any event context, or no
-                // TracingManager registered in the container. Run the function unchanged so
-                // callers get the same behavior they'd see without `runWithSpan` wrapping at all.
-                return yield fn();
-            }
-            const span = tracingManager.startSpan(spanKeyname, options === null || options === void 0 ? void 0 : options.parentKeyname, options === null || options === void 0 ? void 0 : options.parentId, options === null || options === void 0 ? void 0 : options.context);
-            try {
-                return yield fn();
-            }
-            catch (error) {
-                // Annotate the span with error info so it surfaces in the rendered output without
-                // forcing the caller to remember to add it themselves. Span.context is string-typed
-                // by design (cheap to serialize), so we coerce.
-                if (error instanceof Error) {
-                    span.context = Object.assign(Object.assign({}, span.context), { error: "true", errorName: error.name, errorMessage: error.message });
-                }
-                else {
-                    span.context = Object.assign(Object.assign({}, span.context), { error: "true", errorName: "non-error-throw", errorMessage: String(error) });
-                }
-                throw error;
-            }
-            finally {
-                span.end();
-            }
-        });
-    }
-}
-exports.SpanRunner = SpanRunner;
-/**
- * Default singleton. Stateless so sharing is safe.
- */
-exports.spanRunner = new SpanRunner();
-//# sourceMappingURL=span-runner.js.map

package/dist/lib/cjs/utils/span-runner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"span-runner.js","sourceRoot":"","sources":["../../../../src/utils/span-runner.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,gDAAwD;AAexD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAa,UAAU;IAcf,WAAW,CACf,2BAA6D,EAC7D,eAAgD,EAChD,WAAwD,EACxD,YAAgC;;YAEhC,mFAAmF;YACnF,oDAAoD;YACpD,IAAI,cAAmD,CAAC;YACxD,IAAI,WAAmB,CAAC;YACxB,IAAI,EAAwB,CAAC;YAC7B,IAAI,OAAsC,CAAC;YAE3C,IAAI,OAAO,2BAA2B,KAAK,QAAQ,EAAE,CAAC;gBACpD,WAAW,GAAG,2BAA2B,CAAC;gBAC1C,EAAE,GAAG,eAAuC,CAAC;gBAC7C,OAAO,GAAG,WAA4C,CAAC;gBACvD,gFAAgF;gBAChF,gFAAgF;gBAChF,uDAAuD;gBACvD,MAAM,SAAS,GAAG,4BAAmB,CAAC,SAAS,EAAE,CAAC;gBAClD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBAC5B,IAAI,CAAC;wBACH,cAAc,GAAG,SAAS,CAAC,OAAO,CAA0B,yBAAyB,CAAC,CAAC;oBACzF,CAAC;oBAAC,WAAM,CAAC;wBACP,cAAc,GAAG,SAAS,CAAC;oBAC7B,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,cAAc,GAAG,2BAA2B,CAAC;gBAC7C,WAAW,GAAG,eAAyB,CAAC;gBACxC,EAAE,GAAG,WAAmC,CAAC;gBACzC,OAAO,GAAG,YAAY,CAAC;YACzB,CAAC;YAED,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;gBACjC,yEAAyE;gBACzE,4EAA4E;gBAC5E,kFAAkF;gBAClF,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;YAED,MAAM,IAAI,GAAG,cAAc,CAAC,SAAS,CACnC,WAAW,EACX,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,aAAa,EACtB,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,EACjB,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,CACjB,CAAC;YAEF,IAAI,CAAC;gBACH,OAAO,MAAM,EAAE,EAAE,CAAC;YACpB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,kFAAkF;gBAClF,oFAAoF;gBACpF,gDAAgD;gBAChD,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;oBAC3B,IAAI,CAAC,OAAO,mCACP,IAAI,CAAC,OAAO,KACf,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,KAAK,CAAC,IAAI,EACrB,YAAY,EAAE,KAAK,CAAC,OAAO,GAC5B,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,OAAO,mCACP,IAAI,CAAC,OAAO,KACf,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,iBAAiB,EAC5B,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,GAC5B,CAAC;gBACJ,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;oBAAS,CAAC;gBACT,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,CAAC;QACH,CAAC;KAAA;CACF;AAzFD,gCAyFC;AAED;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC"}

package/dist/lib/esm/decorators/decorators.js

@@ -1,2 +0,0 @@
-export * from "./traced.decorator";
-//# sourceMappingURL=decorators.js.map

package/dist/lib/esm/decorators/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../src/decorators/decorators.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/lib/esm/decorators/traced.decorator.js

@@ -1,57 +0,0 @@
-import { spanRunner } from "../utils/span-runner";
-/**
- * Method decorator that wraps the decorated method in a span. The span is automatically
- * ended when the method returns or throws, and the `TracingManager` is auto-resolved
- * from the active `EventContext` — no need to inject it manually.
- *
- * ```ts
- * class PaymentService {
- *   @traced()                                // span name = "PaymentService.charge"
- *   async charge(amount: number) { ... }
- *
- *   @traced("payment.refund.action")         // explicit name
- *   async refund(chargeId: string) { ... }
- * }
- * ```
- *
- * **Behavior outside an event context.** When the decorated method runs without an
- * active `EventContext` (e.g. a unit test calling the method directly, or background
- * work that escaped the event lifecycle), the decorator is a no-op — the original
- * method runs unchanged. Tracing must never throw or alter semantics.
- *
- * **Sync methods become async.** The decorator awaits the wrapped method internally,
- * so any decorated method returns a `Promise`. Decorating a sync method changes its
- * signature visible to callers — apply `@traced` to methods you'd already be awaiting
- * (DB calls, HTTP, expensive computations), not to tight sync helpers.
- *
- * **Type-level caveat.** TypeScript's parameter and method decorator types don't carry
- * enough information for the compiler to verify that the wrapped method's return type
- * is compatible with `Promise<T>`. The wrapper is type-safe at runtime; the call site's
- * static types are unchanged. Pair with explicit `: Promise<T>` annotations on the
- * method when you want the static type to match what's actually returned.
- *
- * @param spanName Optional explicit name for the span. Defaults to
- *   `${ClassName}.${methodName}`.
- */
-export function traced(spanName) {
-    return (target, propertyKey, descriptor) => {
-        var _a, _b, _c;
-        const original = descriptor.value;
-        if (typeof original !== "function") {
-            // Decorator was applied to something other than a method (a getter, a property
-            // with no initial value, etc.). Leave it alone — silently no-op rather than
-            // throw at decoration time.
-            return descriptor;
-        }
-        // Resolve a stable default name at decoration time. `target.constructor.name` is
-        // the class name for instance methods; for static methods, `target.name` is the
-        // class. We cover both via the fallback chain.
-        const className = (_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : target === null || target === void 0 ? void 0 : target.name) !== null && _c !== void 0 ? _c : "anonymous";
-        const resolvedName = spanName !== null && spanName !== void 0 ? spanName : `${className}.${String(propertyKey)}`;
-        descriptor.value = function (...args) {
-            return spanRunner.runWithSpan(resolvedName, () => original.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-//# sourceMappingURL=traced.decorator.js.map

package/dist/lib/esm/decorators/traced.decorator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traced.decorator.js","sourceRoot":"","sources":["../../../../src/decorators/traced.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,MAAM,CAAC,QAAiB;IACtC,OAAO,CAAC,MAAW,EAAE,WAA4B,EAAE,UAA8B,EAAE,EAAE;;QACnF,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;QAClC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,+EAA+E;YAC/E,4EAA4E;YAC5E,4BAA4B;YAC5B,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,iFAAiF;QACjF,gFAAgF;QAChF,+CAA+C;QAC/C,MAAM,SAAS,GAAW,MAAA,MAAA,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,0CAAE,IAAI,mCAAI,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,mCAAI,WAAW,CAAC;QACnF,MAAM,YAAY,GAAG,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,GAAG,SAAS,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAEvE,UAAU,CAAC,KAAK,GAAG,UAAyB,GAAG,IAAW;YACxD,OAAO,UAAU,CAAC,WAAW,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}