@ddd-ts-kit/tracing 0.0.0-stage → 0.1.1

package/dist/correlation/trace-log-fields.js

@@ -0,0 +1,20 @@
+import { isSpanContextValid, trace } from '@opentelemetry/api';
+import { logFieldsOf } from '@ddd-ts-kit/kernel';
+import { tracingConfiguration } from '../configuration/configure-tracing.js';
+/**
+ * Fields for a logger mixin (pino `mixin`, winston format...): the trace and span ids inside a
+ * span, and, inside the execution scope given here or to `configureTracing`, the log fields of
+ * the execution context (`logFieldsOf`: correlation, causation, origin, actor and tenant ids).
+ * Empty outside of both.
+ */
+export function traceLogFields(scope) {
+    const execution = (scope ?? tracingConfiguration().executionScope)?.current();
+    const spanContext = trace.getActiveSpan()?.spanContext();
+    return {
+        ...(execution === undefined ? {} : logFieldsOf(execution)),
+        ...(spanContext !== undefined && isSpanContextValid(spanContext)
+            ? { trace_id: spanContext.traceId, span_id: spanContext.spanId }
+            : {}),
+    };
+}
+//# sourceMappingURL=trace-log-fields.js.map

package/dist/correlation/trace-log-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-log-fields.js","sourceRoot":"","sources":["../../src/correlation/trace-log-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAuC,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAO7E;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,KAAsB;IACnD,MAAM,SAAS,GAAG,CAAC,KAAK,IAAI,oBAAoB,EAAE,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,CAAC;IAC9E,MAAM,WAAW,GAAG,KAAK,CAAC,aAAa,EAAE,EAAE,WAAW,EAAE,CAAC;IAEzD,OAAO;QACL,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QAC1D,GAAG,CAAC,WAAW,KAAK,SAAS,IAAI,kBAAkB,CAAC,WAAW,CAAC;YAC9D,CAAC,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE;YAChE,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;AACJ,CAAC"}

package/dist/correlation/traced-error-reporter.d.ts

@@ -0,0 +1,9 @@
+import type { ErrorReporter } from '@ddd-ts-kit/kernel';
+/**
+ * Decorates an error reporter: a report that names no trace takes the one the failure
+ * happened in, so the error tracker leads to the trace. That is the active trace, or, for a
+ * failure reported once its spans are over (a job, a buried event), the trace of the span
+ * that saw the error first.
+ */
+export declare function tracedErrorReporter(reporter: ErrorReporter): ErrorReporter;
+//# sourceMappingURL=traced-error-reporter.d.ts.map

package/dist/correlation/traced-error-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced-error-reporter.d.ts","sourceRoot":"","sources":["../../src/correlation/traced-error-reporter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,CAS1E"}

package/dist/correlation/traced-error-reporter.js

@@ -0,0 +1,23 @@
+import { isSpanContextValid, trace } from '@opentelemetry/api';
+import { failedTraces } from '../span/failed-traces.js';
+/**
+ * Decorates an error reporter: a report that names no trace takes the one the failure
+ * happened in, so the error tracker leads to the trace. That is the active trace, or, for a
+ * failure reported once its spans are over (a job, a buried event), the trace of the span
+ * that saw the error first.
+ */
+export function tracedErrorReporter(reporter) {
+    return {
+        report(error, report) {
+            const traceId = report.traceId ?? traceOf(error);
+            reporter.report(error, traceId === undefined ? report : { ...report, traceId });
+        },
+        flush: (timeoutMs) => reporter.flush(timeoutMs),
+    };
+}
+function traceOf(error) {
+    const failedIn = typeof error === 'object' && error !== null ? failedTraces.get(error) : undefined;
+    const active = trace.getActiveSpan()?.spanContext();
+    return failedIn ?? (active !== undefined && isSpanContextValid(active) ? active.traceId : undefined);
+}
+//# sourceMappingURL=traced-error-reporter.js.map

package/dist/correlation/traced-error-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced-error-reporter.js","sourceRoot":"","sources":["../../src/correlation/traced-error-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAuB;IACzD,OAAO;QACL,MAAM,CAAC,KAAK,EAAE,MAAM;YAClB,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;YAEjD,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;QAClF,CAAC;QACD,KAAK,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC;KAChD,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CAAC,KAAc;IAC7B,MAAM,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACnG,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,EAAE,EAAE,WAAW,EAAE,CAAC;IAEpD,OAAO,QAAQ,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AACvG,CAAC"}

package/dist/dependency/method.d.ts

@@ -0,0 +1,2 @@
+export type Method = (this: unknown, ...args: unknown[]) => unknown;
+//# sourceMappingURL=method.d.ts.map

package/dist/dependency/method.d.ts.map

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

package/dist/dependency/method.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=method.js.map

package/dist/dependency/method.js.map

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

package/dist/dependency/proxied.d.ts

@@ -0,0 +1,8 @@
+import type { Method } from './method.js';
+/**
+ * A sealed or frozen instance cannot receive own methods, so it is fronted by a proxy.
+ * Methods and getters run with the real instance as `this`: a proxy is not the object a
+ * built-in (a `Map`, a `Date`) or a class with hard-private members accepts as receiver.
+ */
+export declare function proxied<T extends object>(instance: T, wrappers: ReadonlyMap<string, Method>): T;
+//# sourceMappingURL=proxied.d.ts.map

package/dist/dependency/proxied.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxied.d.ts","sourceRoot":"","sources":["../../src/dependency/proxied.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAkB/F"}

package/dist/dependency/proxied.js

@@ -0,0 +1,21 @@
+/**
+ * A sealed or frozen instance cannot receive own methods, so it is fronted by a proxy.
+ * Methods and getters run with the real instance as `this`: a proxy is not the object a
+ * built-in (a `Map`, a `Date`) or a class with hard-private members accepts as receiver.
+ */
+export function proxied(instance, wrappers) {
+    const bound = new Map();
+    for (const [name, wrapper] of wrappers) {
+        bound.set(name, function (...args) {
+            return wrapper.apply(this === proxy ? instance : this, args);
+        });
+    }
+    const proxy = new Proxy(instance, {
+        get(target, property) {
+            const method = typeof property === 'string' ? bound.get(property) : undefined;
+            return method ?? Reflect.get(target, property, target);
+        },
+    });
+    return proxy;
+}
+//# sourceMappingURL=proxied.js.map

package/dist/dependency/proxied.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxied.js","sourceRoot":"","sources":["../../src/dependency/proxied.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAmB,QAAW,EAAE,QAAqC;IAC1F,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IAExC,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;QACvC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,UAAyB,GAAG,IAAe;YACzD,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/D,CAAC,CAAC,CAAC;IACL,CAAC;IAED,MAAM,KAAK,GAAM,IAAI,KAAK,CAAC,QAAQ,EAAE;QACnC,GAAG,CAAC,MAAM,EAAE,QAAQ;YAClB,MAAM,MAAM,GAAG,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAE9E,OAAO,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QACzD,CAAC;KACF,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/dependency/shadowed.d.ts

@@ -0,0 +1,4 @@
+import type { Method } from './method.js';
+/** The instance itself, its traced methods defined over the ones it had or inherited. */
+export declare function shadowed<T extends object>(instance: T, wrappers: ReadonlyMap<string, Method>): T;
+//# sourceMappingURL=shadowed.d.ts.map

package/dist/dependency/shadowed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowed.d.ts","sourceRoot":"","sources":["../../src/dependency/shadowed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,yFAAyF;AACzF,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAahG"}

package/dist/dependency/shadowed.js

@@ -0,0 +1,14 @@
+/** The instance itself, its traced methods defined over the ones it had or inherited. */
+export function shadowed(instance, wrappers) {
+    for (const [name, wrapper] of wrappers) {
+        const own = Object.getOwnPropertyDescriptor(instance, name);
+        Object.defineProperty(instance, name, {
+            value: wrapper,
+            writable: true,
+            configurable: true,
+            enumerable: own?.enumerable ?? false,
+        });
+    }
+    return instance;
+}
+//# sourceMappingURL=shadowed.js.map

package/dist/dependency/shadowed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowed.js","sourceRoot":"","sources":["../../src/dependency/shadowed.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,MAAM,UAAU,QAAQ,CAAmB,QAAW,EAAE,QAAqC;IAC3F,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAE5D,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE;YACpC,KAAK,EAAE,OAAO;YACd,QAAQ,EAAE,IAAI;YACd,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,GAAG,EAAE,UAAU,IAAI,KAAK;SACrC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/dependency/trace-bindings.d.ts

@@ -0,0 +1,25 @@
+import type { DependencyKind } from '@ddd-ts-kit/kernel';
+import { type Token } from '@ddd-ts-kit/kernel/declarations';
+/**
+ * What an application says about the binding an instance comes from: the `decorate` hook of
+ * `createApplication` and a binding aspect both fit.
+ */
+export interface TracedBinding {
+    /** Name of the module that declared the binding. */
+    readonly context: string;
+    /** The role the binding was declared with. A binding without one is not traced. */
+    readonly kind?: DependencyKind;
+    /** The port the binding is made under, or its description. */
+    readonly token?: Token<unknown> | string;
+    /** The bound class, when the application knows it. */
+    readonly className?: string;
+}
+/**
+ * Traces the bindings of an application, as a `decorate` hook or as the `binding` of
+ * `traceApplication()`: every instance of a repository, a gateway, an external adapter, a
+ * publisher or a domain event handler is wrapped by `traceDependency` under the name of its
+ * context and of its port. Use cases, consumers and jobs are left alone, since each already
+ * has its span; so is a binding without kind.
+ */
+export declare function traceBindings(): <T>(instance: T, binding: TracedBinding) => T;
+//# sourceMappingURL=trace-bindings.d.ts.map

package/dist/dependency/trace-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-bindings.d.ts","sourceRoot":"","sources":["../../src/dependency/trace-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAG5E;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC;IACzC,sDAAsD;IACtD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAQD;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,KAAK,CAAC,CAiB7E"}

package/dist/dependency/trace-bindings.js

@@ -0,0 +1,35 @@
+import { describeToken } from '@ddd-ts-kit/kernel/declarations';
+import { traceDependency } from './trace-dependency.js';
+/** Each has a span of its own kind already: the use case middleware, `process <consumer>`, `job <name>`. */
+const TRACED_ELSEWHERE = new Set(['use-case', 'consumer', 'job']);
+/** Named after their class: the token of a handler is the handler. */
+const NAMED_BY_CLASS = new Set(['domain-event-handler']);
+/**
+ * Traces the bindings of an application, as a `decorate` hook or as the `binding` of
+ * `traceApplication()`: every instance of a repository, a gateway, an external adapter, a
+ * publisher or a domain event handler is wrapped by `traceDependency` under the name of its
+ * context and of its port. Use cases, consumers and jobs are left alone, since each already
+ * has its span; so is a binding without kind.
+ */
+export function traceBindings() {
+    return (instance, binding) => {
+        const { context, kind, className } = binding;
+        if (kind === undefined || TRACED_ELSEWHERE.has(kind) || typeof instance !== 'object' || instance === null) {
+            return instance;
+        }
+        const port = NAMED_BY_CLASS.has(kind) ? undefined : portOf(binding.token);
+        return traceDependency(instance, {
+            kind,
+            context,
+            ...(className === undefined ? {} : { className }),
+            ...(port === undefined ? {} : { port }),
+        });
+    };
+}
+function portOf(token) {
+    if (token === undefined) {
+        return undefined;
+    }
+    return typeof token === 'string' ? token : describeToken(token);
+}
+//# sourceMappingURL=trace-bindings.js.map

package/dist/dependency/trace-bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-bindings.js","sourceRoot":"","sources":["../../src/dependency/trace-bindings.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAc,MAAM,iCAAiC,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAiBxD,4GAA4G;AAC5G,MAAM,gBAAgB,GAAgC,IAAI,GAAG,CAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;AAE/G,sEAAsE;AACtE,MAAM,cAAc,GAAgC,IAAI,GAAG,CAAiB,CAAC,sBAAsB,CAAC,CAAC,CAAC;AAEtG;;;;;;GAMG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;QAC3B,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QAE7C,IAAI,IAAI,KAAK,SAAS,IAAI,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC1G,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,MAAM,IAAI,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE1E,OAAO,eAAe,CAAC,QAAQ,EAAE;YAC/B,IAAI;YACJ,OAAO;YACP,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC;YACjD,GAAG,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;SACxC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,MAAM,CAAC,KAA6B;IAC3C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC"}

package/dist/dependency/trace-dependency.d.ts

@@ -0,0 +1,26 @@
+import type { DependencyKind } from '@ddd-ts-kit/kernel';
+export interface TraceDependencyOptions {
+    readonly kind: DependencyKind;
+    /** Defaults to the constructor name; set it when the build minifies class names. */
+    readonly className?: string;
+    /** Bounded context owning the dependency. */
+    readonly context?: string;
+    /** Name of the port the instance is bound under: it names the spans in place of the class. */
+    readonly port?: string;
+}
+/**
+ * Wraps the async methods of an adapter so each call is one span named
+ * `<kind> <Port>.<method>` (`repository OrderRepository.save`), after the port when it is
+ * known and after the class otherwise; the handler of a domain event is `handler <ClassName>`.
+ * Meant for the composition root only: the wrapped class imports nothing from this package.
+ *
+ * The methods are shadowed on the instance itself, so the returned value is the same
+ * object: `instanceof`, `this` and private members keep working, and wrapping twice
+ * is a no-op. A span never carries arguments, results or error messages.
+ *
+ * A method declared `async` is traced from its first call. Any other method is traced
+ * once it has been seen returning a thenable (that first call is not traced). A function
+ * held in a field, `private` or not, is a method like any other.
+ */
+export declare function traceDependency<T extends object>(instance: T, options: TraceDependencyOptions): T;
+//# sourceMappingURL=trace-dependency.d.ts.map

package/dist/dependency/trace-dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-dependency.d.ts","sourceRoot":"","sources":["../../src/dependency/trace-dependency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AASzD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,oFAAoF;IACpF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,sBAAsB,GAAG,CAAC,CAYjG"}

package/dist/dependency/trace-dependency.js

@@ -0,0 +1,56 @@
+import { tracingConfiguration } from '../configuration/configure-tracing.js';
+import { constructorName } from '../span/constructor-name.js';
+import { proxied } from './proxied.js';
+import { shadowed } from './shadowed.js';
+import { traceableMethods } from './traceable-methods.js';
+import { traced } from './traced.js';
+const wrapped = new WeakSet();
+/**
+ * Wraps the async methods of an adapter so each call is one span named
+ * `<kind> <Port>.<method>` (`repository OrderRepository.save`), after the port when it is
+ * known and after the class otherwise; the handler of a domain event is `handler <ClassName>`.
+ * Meant for the composition root only: the wrapped class imports nothing from this package.
+ *
+ * The methods are shadowed on the instance itself, so the returned value is the same
+ * object: `instanceof`, `this` and private members keep working, and wrapping twice
+ * is a no-op. A span never carries arguments, results or error messages.
+ *
+ * A method declared `async` is traced from its first call. Any other method is traced
+ * once it has been seen returning a thenable (that first call is not traced). A function
+ * held in a field, `private` or not, is a method like any other.
+ */
+export function traceDependency(instance, options) {
+    if (wrapped.has(instance)) {
+        return instance;
+    }
+    const wrappers = tracedMethods(instance, options);
+    const result = Object.isExtensible(instance) ? shadowed(instance, wrappers) : proxied(instance, wrappers);
+    wrapped.add(result);
+    return result;
+}
+function tracedMethods(instance, options) {
+    const className = options.className ?? ownClassName(instance);
+    const skipped = new Set(tracingConfiguration().lifecycleHooks);
+    const wrappers = new Map();
+    for (const [name, method] of traceableMethods(instance, skipped)) {
+        const attributes = {
+            'code.namespace': className,
+            'code.function': name,
+            'app.dependency.kind': options.kind,
+            ...(options.context === undefined ? {} : { 'app.context': options.context }),
+        };
+        wrappers.set(name, traced(method, spanName({ ...options, className }, name), attributes));
+    }
+    return wrappers;
+}
+function spanName(options, method) {
+    if (options.kind === 'domain-event-handler') {
+        return method === 'handle' ? `handler ${options.className}` : `handler ${options.className}.${method}`;
+    }
+    return `${options.kind} ${options.port ?? options.className}.${method}`;
+}
+function ownClassName(instance) {
+    const name = constructorName(instance);
+    return typeof name === 'string' ? name : 'Object';
+}
+//# sourceMappingURL=trace-dependency.js.map

package/dist/dependency/trace-dependency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-dependency.js","sourceRoot":"","sources":["../../src/dependency/trace-dependency.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAYrC,MAAM,OAAO,GAAG,IAAI,OAAO,EAAU,CAAC;AAEtC;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,eAAe,CAAmB,QAAW,EAAE,OAA+B;IAC5F,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,QAAQ,GAAG,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAElD,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAE1G,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEpB,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,aAAa,CAAC,QAAgB,EAAE,OAA+B;IACtE,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC9D,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,oBAAoB,EAAE,CAAC,cAAc,CAAC,CAAC;IAC/D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE3C,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,gBAAgB,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAAC;QACjE,MAAM,UAAU,GAAe;YAC7B,gBAAgB,EAAE,SAAS;YAC3B,eAAe,EAAE,IAAI;YACrB,qBAAqB,EAAE,OAAO,CAAC,IAAI;YACnC,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC;SAC7E,CAAC;QAEF,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,EAAE,IAAI,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;IAC5F,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,QAAQ,CAAC,OAAgE,EAAE,MAAc;IAChG,IAAI,OAAO,CAAC,IAAI,KAAK,sBAAsB,EAAE,CAAC;QAC5C,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,WAAW,OAAO,CAAC,SAAS,IAAI,MAAM,EAAE,CAAC;IACzG,CAAC;IAED,OAAO,GAAG,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,SAAS,IAAI,MAAM,EAAE,CAAC;AAC1E,CAAC;AAED,SAAS,YAAY,CAAC,QAAgB;IACpC,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;IAEvC,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACpD,CAAC"}

package/dist/dependency/traceable-methods.d.ts

@@ -0,0 +1,4 @@
+import type { Method } from './method.js';
+/** Own and inherited methods, without invoking any getter. */
+export declare function traceableMethods(instance: object, skipped: ReadonlySet<string>): Map<string, Method>;
+//# sourceMappingURL=traceable-methods.d.ts.map

package/dist/dependency/traceable-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceable-methods.d.ts","sourceRoot":"","sources":["../../src/dependency/traceable-methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAkBpG"}

package/dist/dependency/traceable-methods.js

@@ -0,0 +1,46 @@
+const UNTRACEABLE_CONSTRUCTORS = new Set(['GeneratorFunction', 'AsyncGeneratorFunction']);
+/** Own and inherited methods, without invoking any getter. */
+export function traceableMethods(instance, skipped) {
+    const methods = new Map();
+    for (const owner of prototypeChain(instance)) {
+        for (const name of Object.getOwnPropertyNames(owner)) {
+            if (name === 'constructor' || skipped.has(name) || methods.has(name)) {
+                continue;
+            }
+            const candidate = methodHeld(owner, name, instance);
+            if (isTraceable(candidate)) {
+                methods.set(name, candidate);
+            }
+        }
+    }
+    return methods;
+}
+/** What the instance answers for a name its owner holds a function under, `undefined` for anything else. */
+function methodHeld(owner, name, instance) {
+    const descriptor = Object.getOwnPropertyDescriptor(owner, name);
+    // A read-only own property cannot be shadowed, neither in place nor through a proxy.
+    if (descriptor === undefined || (owner === instance && isReadOnly(descriptor))) {
+        return undefined;
+    }
+    if (typeof descriptor.value !== 'function') {
+        return undefined;
+    }
+    // Read through the instance: a proxy put in front of it by an aspect answers its own wrapper.
+    return Reflect.get(instance, name);
+}
+function prototypeChain(instance) {
+    const chain = [];
+    for (let owner = instance; owner !== null && owner !== Object.prototype && owner !== Function.prototype; owner = Reflect.getPrototypeOf(owner)) {
+        chain.push(owner);
+    }
+    return chain;
+}
+function isReadOnly(descriptor) {
+    return !descriptor.writable && !descriptor.configurable;
+}
+function isTraceable(value) {
+    return (typeof value === 'function' &&
+        !UNTRACEABLE_CONSTRUCTORS.has(value.constructor.name) &&
+        !Function.prototype.toString.call(value).startsWith('class'));
+}
+//# sourceMappingURL=traceable-methods.js.map

package/dist/dependency/traceable-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceable-methods.js","sourceRoot":"","sources":["../../src/dependency/traceable-methods.ts"],"names":[],"mappings":"AAEA,MAAM,wBAAwB,GAAG,IAAI,GAAG,CAAC,CAAC,mBAAmB,EAAE,wBAAwB,CAAC,CAAC,CAAC;AAE1F,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB,CAAC,QAAgB,EAAE,OAA4B;IAC7E,MAAM,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE1C,KAAK,MAAM,KAAK,IAAI,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACrD,IAAI,IAAI,KAAK,aAAa,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrE,SAAS;YACX,CAAC;YAED,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YAEpD,IAAI,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,4GAA4G;AAC5G,SAAS,UAAU,CAAC,KAAa,EAAE,IAAY,EAAE,QAAgB;IAC/D,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAEhE,qFAAqF;IACrF,IAAI,UAAU,KAAK,SAAS,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;QAC/E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;QAC3C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,8FAA8F;IAC9F,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB;IACtC,MAAM,KAAK,GAAa,EAAE,CAAC;IAE3B,KACE,IAAI,KAAK,GAAkB,QAAQ,EACnC,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,QAAQ,CAAC,SAAS,EAC5E,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EACrC,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,UAAU,CAAC,UAA8B;IAChD,OAAO,CAAC,UAAU,CAAC,QAAQ,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;AAC1D,CAAC;AAED,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,CACL,OAAO,KAAK,KAAK,UAAU;QAC3B,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC;QACrD,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAC7D,CAAC;AACJ,CAAC"}

package/dist/dependency/traced.d.ts

@@ -0,0 +1,5 @@
+import { type Attributes } from '@opentelemetry/api';
+import type { Method } from './method.js';
+/** The method that runs `original` in a span of the given name, once it is known to be async. */
+export declare function traced(original: Method, spanName: string, attributes: Attributes): Method;
+//# sourceMappingURL=traced.d.ts.map

package/dist/dependency/traced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced.d.ts","sourceRoot":"","sources":["../../src/dependency/traced.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAK/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAK1C,iGAAiG;AACjG,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CAoBzF"}

package/dist/dependency/traced.js

@@ -0,0 +1,56 @@
+import { SpanKind, context, trace } from '@opentelemetry/api';
+import { admitDependencySpan } from '../local-root/admit-dependency-span.js';
+import { isThenable } from '../span/is-thenable.js';
+import { markSpanFailed } from '../span/mark-span-failed.js';
+import { tracer } from '../span/tracer.js';
+// Shared by every instance of a class: one call returning a thenable teaches them all.
+const learnedAsync = new WeakSet();
+/** The method that runs `original` in a span of the given name, once it is known to be async. */
+export function traced(original, spanName, attributes) {
+    const declaredAsync = original.constructor.name === 'AsyncFunction';
+    const wrapper = function (...args) {
+        const call = () => original.apply(this, args);
+        if (!declaredAsync && !learnedAsync.has(original)) {
+            return learningAsync(original, call);
+        }
+        if (!admitDependencySpan(spanName)) {
+            return call();
+        }
+        return inSpan(call, spanName, attributes);
+    };
+    Object.defineProperty(wrapper, 'name', { value: original.name, configurable: true });
+    return wrapper;
+}
+function learningAsync(original, call) {
+    const result = call();
+    if (isThenable(result)) {
+        learnedAsync.add(original);
+    }
+    return result;
+}
+function inSpan(call, spanName, attributes) {
+    const parent = context.active();
+    const span = tracer().startSpan(spanName, { kind: SpanKind.INTERNAL, attributes }, parent);
+    let result;
+    try {
+        result = context.with(trace.setSpan(parent, span), call);
+    }
+    catch (error) {
+        markSpanFailed(span, error);
+        span.end();
+        throw error;
+    }
+    if (!isThenable(result)) {
+        span.end();
+        return result;
+    }
+    return result.then((value) => {
+        span.end();
+        return value;
+    }, (error) => {
+        markSpanFailed(span, error);
+        span.end();
+        throw error;
+    });
+}
+//# sourceMappingURL=traced.js.map

package/dist/dependency/traced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced.js","sourceRoot":"","sources":["../../src/dependency/traced.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAmB,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,uFAAuF;AACvF,MAAM,YAAY,GAAG,IAAI,OAAO,EAAU,CAAC;AAE3C,iGAAiG;AACjG,MAAM,UAAU,MAAM,CAAC,QAAgB,EAAE,QAAgB,EAAE,UAAsB;IAC/E,MAAM,aAAa,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,KAAK,eAAe,CAAC;IAEpE,MAAM,OAAO,GAAW,UAAyB,GAAG,IAAe;QACjE,MAAM,IAAI,GAAG,GAAY,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAEvD,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClD,OAAO,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnC,OAAO,IAAI,EAAE,CAAC;QAChB,CAAC;QAED,OAAO,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC5C,CAAC,CAAC;IAEF,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;IAErF,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,aAAa,CAAC,QAAgB,EAAE,IAAmB;IAC1D,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC;IAEtB,IAAI,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,MAAM,CAAC,IAAmB,EAAE,QAAgB,EAAE,UAAsB;IAC3E,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAChC,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,MAAM,CAAC,CAAC;IAC3F,IAAI,MAAe,CAAC;IAEpB,IAAI,CAAC;QACH,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,GAAG,EAAE,CAAC;QAEX,MAAM,KAAK,CAAC;IACd,CAAC;IAED,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,EAAE,CAAC;QAEX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAChB,CAAC,KAAK,EAAE,EAAE;QACR,IAAI,CAAC,GAAG,EAAE,CAAC;QAEX,OAAO,KAAK,CAAC;IACf,CAAC,EACD,CAAC,KAAc,EAAE,EAAE;QACjB,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,GAAG,EAAE,CAAC;QAEX,MAAM,KAAK,CAAC;IACd,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/domain-events/traced-domain-events.d.ts

@@ -0,0 +1,14 @@
+import { type DomainEventDispatcher } from '@ddd-ts-kit/kernel';
+/**
+ * Decorates a dispatcher: each event is dispatched in a span `domain-event <name>`, and the
+ * handlers it reaches are its children. Never the aggregate id nor anything the event carries.
+ *
+ * At the end of a unit of work the events are under one span `unit-of-work before-commit`,
+ * which follows the saves under the span of the command: the trace shows that the handlers ran
+ * after every save and before the commit. What their handlers recorded in turn is under a second
+ * such span. Once the unit of work has committed, the events that have an `after-commit` handler
+ * are under `unit-of-work after-commit`, in the same trace. Outside of a unit of work the events
+ * stay under the save that dispatched them. The spans count against the caps of the local root.
+ */
+export declare function tracedDomainEvents(dispatcher: DomainEventDispatcher): DomainEventDispatcher;
+//# sourceMappingURL=traced-domain-events.d.ts.map

package/dist/domain-events/traced-domain-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced-domain-events.d.ts","sourceRoot":"","sources":["../../src/domain-events/traced-domain-events.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,oBAAoB,CAAC;AAI5B;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,qBAAqB,GAAG,qBAAqB,CAkB3F"}

package/dist/domain-events/traced-domain-events.js

@@ -0,0 +1,49 @@
+import { SpanKind } from '@opentelemetry/api';
+import { unitOfWorkStage, } from '@ddd-ts-kit/kernel';
+import { admitDependencySpan } from '../local-root/admit-dependency-span.js';
+import { inSpan } from '../span/in-span.js';
+/**
+ * Decorates a dispatcher: each event is dispatched in a span `domain-event <name>`, and the
+ * handlers it reaches are its children. Never the aggregate id nor anything the event carries.
+ *
+ * At the end of a unit of work the events are under one span `unit-of-work before-commit`,
+ * which follows the saves under the span of the command: the trace shows that the handlers ran
+ * after every save and before the commit. What their handlers recorded in turn is under a second
+ * such span. Once the unit of work has committed, the events that have an `after-commit` handler
+ * are under `unit-of-work after-commit`, in the same trace. Outside of a unit of work the events
+ * stay under the save that dispatched them. The spans count against the caps of the local root.
+ */
+export function tracedDomainEvents(dispatcher) {
+    const handledAfterCommit = new Set();
+    return {
+        on: (name, handler, subscription) => {
+            if (subscription?.phase === 'after-commit') {
+                handledAfterCommit.add(name);
+            }
+            dispatcher.on(name, handler, subscription);
+        },
+        dispatch(events, phase = 'before-commit') {
+            const shown = phase === 'before-commit' ? events : events.filter((event) => handledAfterCommit.has(event.name));
+            const each = () => dispatchedEach(events, { dispatcher, phase, shown });
+            return shown.length > 0 && unitOfWorkStage() === phase ? underThePhase(phase, each) : each();
+        },
+    };
+}
+function underThePhase(phase, work) {
+    const name = `unit-of-work ${phase}`;
+    return admitDependencySpan(name) ? inSpan({ name, options: { kind: SpanKind.INTERNAL } }, work) : work();
+}
+async function dispatchedEach(events, dispatch) {
+    for (const event of events) {
+        await dispatched(event, dispatch);
+    }
+}
+function dispatched(event, { dispatcher, phase, shown }) {
+    const name = `domain-event ${event.name}`;
+    if (!shown.includes(event) || !admitDependencySpan(name)) {
+        return dispatcher.dispatch([event], phase);
+    }
+    const options = { kind: SpanKind.INTERNAL, attributes: { 'app.domain_event.name': event.name } };
+    return inSpan({ name, options }, () => dispatcher.dispatch([event], phase));
+}
+//# sourceMappingURL=traced-domain-events.js.map

package/dist/domain-events/traced-domain-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced-domain-events.js","sourceRoot":"","sources":["../../src/domain-events/traced-domain-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EACL,eAAe,GAIhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAAiC;IAClE,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;IAE7C,OAAO;QACL,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE;YAClC,IAAI,YAAY,EAAE,KAAK,KAAK,cAAc,EAAE,CAAC;gBAC3C,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC;YAED,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QAC7C,CAAC;QACD,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,eAAe;YACtC,MAAM,KAAK,GAAG,KAAK,KAAK,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YAChH,MAAM,IAAI,GAAG,GAAkB,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;YAEvF,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,eAAe,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/F,CAAC;KACF,CAAC;AACJ,CAAC;AASD,SAAS,aAAa,CAAC,KAAuB,EAAE,IAAyB;IACvE,MAAM,IAAI,GAAG,gBAAgB,KAAK,EAAE,CAAC;IAErC,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AAC3G,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,MAA8B,EAAE,QAAkB;IAC9E,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACpC,CAAC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,KAAkB,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAY;IAC5E,MAAM,IAAI,GAAG,gBAAgB,KAAK,CAAC,IAAI,EAAE,CAAC;IAE1C,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;QACzD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,EAAE,uBAAuB,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;IAEjG,OAAO,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AAC9E,CAAC"}

package/dist/events/consumer-trace.d.ts

@@ -0,0 +1,8 @@
+/**
+ * How the span of a consumed event relates to the one that published it. `continue`: its
+ * child, in the same trace, so one action reads end to end in one place. `link`: the root of
+ * a new trace that links to it, for a system whose traces would otherwise never end (fan-out
+ * to many consumers, long retry chains).
+ */
+export type ConsumerTrace = 'continue' | 'link';
+//# sourceMappingURL=consumer-trace.d.ts.map

package/dist/events/consumer-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-trace.d.ts","sourceRoot":"","sources":["../../src/events/consumer-trace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,MAAM,CAAC"}

package/dist/events/consumer-trace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=consumer-trace.js.map

package/dist/events/consumer-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-trace.js","sourceRoot":"","sources":["../../src/events/consumer-trace.ts"],"names":[],"mappings":""}

package/dist/events/messaging-attributes.d.ts

@@ -0,0 +1,12 @@
+import type { Attributes } from '@opentelemetry/api';
+import type { IntegrationEvent } from '@ddd-ts-kit/kernel';
+export interface MessagingOperation {
+    /** What the kit calls it: `publish`, `append`, `process`. */
+    readonly name: string;
+    /** The operation type of the messaging conventions: `send`, `create`, `process`. */
+    readonly type: string;
+    readonly system?: string | undefined;
+}
+/** The payload never becomes an attribute: only the routing key and the event id. */
+export declare function messagingAttributes(operation: MessagingOperation, event: IntegrationEvent): Attributes;
+//# sourceMappingURL=messaging-attributes.d.ts.map

package/dist/events/messaging-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messaging-attributes.d.ts","sourceRoot":"","sources":["../../src/events/messaging-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,kBAAkB,EAAE,KAAK,EAAE,gBAAgB,GAAG,UAAU,CAQtG"}

package/dist/events/messaging-attributes.js

@@ -0,0 +1,11 @@
+/** The payload never becomes an attribute: only the routing key and the event id. */
+export function messagingAttributes(operation, event) {
+    return {
+        ...(operation.system === undefined ? {} : { 'messaging.system': operation.system }),
+        'messaging.operation.name': operation.name,
+        'messaging.operation.type': operation.type,
+        'messaging.destination.name': event.type,
+        'messaging.message.id': event.id,
+    };
+}
+//# sourceMappingURL=messaging-attributes.js.map

package/dist/events/messaging-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messaging-attributes.js","sourceRoot":"","sources":["../../src/events/messaging-attributes.ts"],"names":[],"mappings":"AAWA,qFAAqF;AACrF,MAAM,UAAU,mBAAmB,CAAC,SAA6B,EAAE,KAAuB;IACxF,OAAO;QACL,GAAG,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,kBAAkB,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC;QACnF,0BAA0B,EAAE,SAAS,CAAC,IAAI;QAC1C,0BAA0B,EAAE,SAAS,CAAC,IAAI;QAC1C,4BAA4B,EAAE,KAAK,CAAC,IAAI;QACxC,sBAAsB,EAAE,KAAK,CAAC,EAAE;KACjC,CAAC;AACJ,CAAC"}

package/dist/events/traced-consumer.d.ts

@@ -0,0 +1,22 @@
+import type { IntegrationEventCallback } from '@ddd-ts-kit/kernel';
+import type { ConsumerTrace } from './consumer-trace.js';
+export interface TracedConsumerOptions {
+    /** Stable name of the consumer: the span is `process <consumer>`. Without it, `process <type>`. */
+    readonly consumer?: string;
+    /** Bounded context of the consumer. */
+    readonly context?: string;
+    /** Default `continue`. */
+    readonly trace?: ConsumerTrace;
+    /** The transport, when the provider does not say it with each delivery. */
+    readonly system?: string;
+}
+export declare const ATTEMPT_ATTRIBUTE = "app.messaging.attempt";
+/**
+ * Wraps what a provider calls at each delivery: every attempt runs in its own CONSUMER span,
+ * which says which attempt it is, so a redelivery reads as one. A failed attempt is an error
+ * with the code of what was thrown; the attempt after which the provider gives the event up
+ * says `dead-lettered`. The span starts the unit of work: it carries the correlation id of the
+ * event. Never the payload.
+ */
+export declare function tracedConsumer(handler: IntegrationEventCallback, options?: TracedConsumerOptions): IntegrationEventCallback;
+//# sourceMappingURL=traced-consumer.d.ts.map