autotel 7.0.1 → 7.2.0

package/README.md

@@ -775,6 +775,31 @@ app.use((req, res, next) => {
 - Baggage values are strings (convert numbers/objects before setting)
 - Never put PII in baggage - it propagates in HTTP headers across services!
 
+### Getting the trace id, and a link to it
+
+`getActiveTraceContext()` reads the trace currently in scope, and
+`resolveTraceUrl()` turns its id into a link to wherever you view traces. Printing
+that link beside a slow request is the shortest path from "this was slow" to
+looking at why:
+
+```typescript
+import { getActiveTraceContext, resolveTraceUrl, span } from 'autotel';
+
+await span('GET /feed', async () => {
+  const traceId = getActiveTraceContext()?.traceId;
+  const url = resolveTraceUrl(
+    'http://localhost:4318/#trace={traceId}',
+    traceId,
+  );
+  console.log(`feed request ${url ?? traceId}`);
+});
+```
+
+`resolveTraceUrl(template, traceId)` substitutes `{traceId}`. Pass `undefined`
+as the template and it falls back to `OTEL_TRACE_URL_TEMPLATE`, so the same code
+points at devtools locally and at your vendor in production without a branch.
+It returns `undefined` when neither is set.
+
 ### Reusable Middleware Helpers
 
 - `withTracing(options)` : create a preconfigured wrapper (service name, default attributes, skip rules).

package/dist/analysis.cjs

@@ -81,6 +81,23 @@ function compareCohorts(options) {
 	results.sort((a, b) => Math.abs(b.difference) - Math.abs(a.difference) || b.difference - a.difference || a.field.localeCompare(b.field) || a.value.localeCompare(b.value));
 	return results.slice(0, limit);
 }
+/**
+* Label a numeric value with the range it falls in.
+*
+* `compareCohorts` skips a field whose values never repeat, which is what a
+* raw duration or byte count does. Bucketing at instrumentation time turns
+* such a field into one that can describe a cohort.
+*/
+function bucket(value, boundaries) {
+	if (!Number.isFinite(value) || boundaries.length === 0) return "unknown";
+	const ordered = [...boundaries].sort((a, b) => a - b);
+	for (const [index, boundary] of ordered.entries()) if (value < boundary) {
+		const lower = ordered[index - 1];
+		return lower === void 0 ? `<${boundary}` : `${lower}-${boundary}`;
+	}
+	return `>=${ordered.at(-1)}`;
+}
 
 //#endregion
+exports.bucket = bucket;
 exports.compareCohorts = compareCohorts;

package/dist/analysis.d.cts

@@ -82,5 +82,13 @@ interface CompareCohortsOptions {
  * @returns Differences sorted by absolute strength, strongest first
  */
 declare function compareCohorts(options: CompareCohortsOptions): CohortDifference[];
+/**
+ * Label a numeric value with the range it falls in.
+ *
+ * `compareCohorts` skips a field whose values never repeat, which is what a
+ * raw duration or byte count does. Bucketing at instrumentation time turns
+ * such a field into one that can describe a cohort.
+ */
+declare function bucket(value: number, boundaries: readonly number[]): string;
 //#endregion
-export { AnalysisEvent, CohortDifference, CompareCohortsOptions, compareCohorts };
+export { AnalysisEvent, CohortDifference, CompareCohortsOptions, bucket, compareCohorts };

package/dist/analysis.d.ts

@@ -82,5 +82,13 @@ interface CompareCohortsOptions {
  * @returns Differences sorted by absolute strength, strongest first
  */
 declare function compareCohorts(options: CompareCohortsOptions): CohortDifference[];
+/**
+ * Label a numeric value with the range it falls in.
+ *
+ * `compareCohorts` skips a field whose values never repeat, which is what a
+ * raw duration or byte count does. Bucketing at instrumentation time turns
+ * such a field into one that can describe a cohort.
+ */
+declare function bucket(value: number, boundaries: readonly number[]): string;
 //#endregion
-export { AnalysisEvent, CohortDifference, CompareCohortsOptions, compareCohorts };
+export { AnalysisEvent, CohortDifference, CompareCohortsOptions, bucket, compareCohorts };

package/dist/analysis.js

@@ -79,6 +79,22 @@ function compareCohorts(options) {
 	results.sort((a, b) => Math.abs(b.difference) - Math.abs(a.difference) || b.difference - a.difference || a.field.localeCompare(b.field) || a.value.localeCompare(b.value));
 	return results.slice(0, limit);
 }
+/**
+* Label a numeric value with the range it falls in.
+*
+* `compareCohorts` skips a field whose values never repeat, which is what a
+* raw duration or byte count does. Bucketing at instrumentation time turns
+* such a field into one that can describe a cohort.
+*/
+function bucket(value, boundaries) {
+	if (!Number.isFinite(value) || boundaries.length === 0) return "unknown";
+	const ordered = [...boundaries].sort((a, b) => a - b);
+	for (const [index, boundary] of ordered.entries()) if (value < boundary) {
+		const lower = ordered[index - 1];
+		return lower === void 0 ? `<${boundary}` : `${lower}-${boundary}`;
+	}
+	return `>=${ordered.at(-1)}`;
+}
 
 //#endregion
-export { compareCohorts };
+export { bucket, compareCohorts };

package/dist/auto.cjs

@@ -1,6 +1,5 @@
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
-const require_init = require('./init-C5aHRqi2.cjs');
-const require_yaml_config = require('./yaml-config.cjs');
+const require_init = require('./init-aTZKsAwy.cjs');
 let node_module = require("node:module");
 node_module = require_rolldown_runtime.__toESM(node_module, 1);
 let import_in_the_middle = require("import-in-the-middle");
@@ -42,7 +41,7 @@ let import_in_the_middle = require("import-in-the-middle");
 */
 const { registerOptions } = (0, import_in_the_middle.createAddHookMessageChannel)();
 node_module.register("import-in-the-middle/hook.mjs", require("url").pathToFileURL(__filename).href, registerOptions);
-const yamlConfig = require_yaml_config.loadYamlConfig();
+const yamlConfig = require_init.loadYamlConfig();
 const autoInstrumentationsEnv = process.env.AUTOTEL_INTEGRATIONS;
 const autoInstrumentations = autoInstrumentationsEnv === "true" ? true : autoInstrumentationsEnv ? autoInstrumentationsEnv.split(",").map((s) => s.trim()) : yamlConfig?.autoInstrumentations ?? ["http", "express"];
 require_init.init({

package/dist/auto.js

@@ -1,5 +1,4 @@
-import { i as init } from "./init-DDyaLzeg.js";
-import { loadYamlConfig } from "./yaml-config.js";
+import { g as loadYamlConfig, i as init } from "./init-DzAdgcFM.js";
 import * as nodeModule from "node:module";
 import { createAddHookMessageChannel } from "import-in-the-middle";
 

package/dist/correlation-id.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_init = require('./init-C5aHRqi2.cjs');
+const require_init = require('./init-aTZKsAwy.cjs');
 
 exports.CORRELATION_ID_BAGGAGE_KEY = require_init.CORRELATION_ID_BAGGAGE_KEY;
 exports.generateCorrelationId = require_init.generateCorrelationId;

package/dist/correlation-id.js

@@ -1,3 +1,3 @@
-import { C as setCorrelationId, S as runWithCorrelationId, _ as CORRELATION_ID_BAGGAGE_KEY, b as getCorrelationStorage, v as generateCorrelationId, w as setCorrelationIdInBaggage, x as getOrCreateCorrelationId, y as getCorrelationId } from "./init-DDyaLzeg.js";
+import { $ as getOrCreateCorrelationId, Q as getCorrelationStorage, X as generateCorrelationId, Y as CORRELATION_ID_BAGGAGE_KEY, Z as getCorrelationId, et as runWithCorrelationId, nt as setCorrelationIdInBaggage, tt as setCorrelationId } from "./init-DzAdgcFM.js";
 
 export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getCorrelationStorage, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage };

package/dist/decorators.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_values = require('./values-DApyq53y.cjs');
 const require_config = require('./config.cjs');
-const require_init = require('./init-C5aHRqi2.cjs');
+const require_init = require('./init-aTZKsAwy.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/decorators.ts

package/dist/decorators.d.cts

@@ -1,5 +1,5 @@
 import { n as TraceContext } from "./trace-context-C1Cn1q0y.cjs";
-import { m as TracingOptions } from "./functional-CJn2zY4o.cjs";
+import { m as TracingOptions } from "./functional-CgWcRXGX.cjs";
 //#region src/decorators.d.ts
 /**
  * Options for @Trace method decorator

package/dist/decorators.d.ts

@@ -1,5 +1,5 @@
 import { n as TraceContext } from "./trace-context-f89xPJbK.js";
-import { m as TracingOptions } from "./functional-DXy1cHFF.js";
+import { m as TracingOptions } from "./functional-RFFpQzAV.js";
 //#region src/decorators.d.ts
 /**
  * Options for @Trace method decorator

package/dist/decorators.js

@@ -1,6 +1,6 @@
 import { y as splitNameOrOptions } from "./values-BenyvWKz.js";
 import { getConfig } from "./config.js";
-import { T as createTraceContext } from "./init-DDyaLzeg.js";
+import { H as createTraceContext } from "./init-DzAdgcFM.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 
 //#region src/decorators.ts

package/dist/event.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_init = require('./init-C5aHRqi2.cjs');
+const require_init = require('./init-aTZKsAwy.cjs');
 
 exports.Event = require_init.Event;
 exports.getEvents = require_init.getEvents;

package/dist/event.js

@@ -1,3 +1,3 @@
-import { d as getEvents, f as resetEvents, u as Event } from "./init-DDyaLzeg.js";
+import { d as getEvents, f as resetEvents, u as Event } from "./init-DzAdgcFM.js";
 
 export { Event, getEvents, resetEvents };

package/dist/evidence.cjs

@@ -0,0 +1,57 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/evidence.ts
+/** Prefix for per-field evidence labels. */
+const EVIDENCE_ATTR_PREFIX = "autotel.evidence.";
+/** The span attribute key carrying `field`'s evidence label. */
+function evidenceAttribute(field) {
+	return `${EVIDENCE_ATTR_PREFIX}${field}`;
+}
+/** Label how `field` on this span came to be. */
+function recordEvidence(ctx, field, quality) {
+	ctx.setAttribute(evidenceAttribute(field), quality);
+}
+/**
+* The capture surfaces a deployment can be asked about. Closed set, because the
+* point is that a backend can query `unobserved` across services and get
+* comparable answers.
+*/
+const CAPTURE_SURFACES = [
+	"llm_calls",
+	"tool_calls",
+	"user_prompts",
+	"file_io",
+	"subprocess",
+	"network",
+	"ide_context"
+];
+const CAPTURE_COVERAGE_ATTR = {
+	observed: "autotel.coverage.observed",
+	unobserved: "autotel.coverage.unobserved"
+};
+/**
+* Resource attributes declaring {@link CaptureCoverage}.
+*
+* An empty list is omitted rather than emitted: `unobserved: []` would read as
+* "this process has no blind spots", which is a stronger claim than declaring
+* nothing. A surface claimed as both is dropped from both — a contradiction
+* that left `observed` intact would let a reader conclude a gap does not exist.
+*/
+function captureCoverageAttributes(coverage) {
+	const claimedBoth = new Set(coverage.observed.filter((s) => coverage.unobserved.includes(s)));
+	const keep = (surfaces) => [...new Set(surfaces.filter((s) => !claimedBoth.has(s)))];
+	const observed = keep(coverage.observed);
+	const unobserved = keep(coverage.unobserved);
+	return {
+		...observed.length > 0 && { [CAPTURE_COVERAGE_ATTR.observed]: observed },
+		...unobserved.length > 0 && { [CAPTURE_COVERAGE_ATTR.unobserved]: unobserved }
+	};
+}
+
+//#endregion
+exports.CAPTURE_COVERAGE_ATTR = CAPTURE_COVERAGE_ATTR;
+exports.CAPTURE_SURFACES = CAPTURE_SURFACES;
+exports.EVIDENCE_ATTR_PREFIX = EVIDENCE_ATTR_PREFIX;
+exports.captureCoverageAttributes = captureCoverageAttributes;
+exports.evidenceAttribute = evidenceAttribute;
+exports.recordEvidence = recordEvidence;

package/dist/evidence.d.cts

@@ -0,0 +1,61 @@
+import { Attributes } from "@opentelemetry/api";
+//#region src/evidence.d.ts
+/**
+ * Why a recorded fact is the way it is.
+ *
+ * There is deliberately no `unknown` member: a field carrying no evidence label
+ * is already unknown, and encoding that as a value invites code that treats an
+ * unlabelled field as *verified* unknown rather than simply unexamined.
+ */
+type EvidenceQuality =
+/** The instrumentation saw the value directly. */
+'observed' |
+/** Derived from other observed facts, not seen. */
+'inferred' |
+/** Computed from a price table, heuristic, or model — not reported upstream. */
+'estimated' |
+/** Seen, then cut short. What is here is real; what is missing is not. */
+'truncated' |
+/** Seen, then removed before storage. */
+'redacted' |
+/** Expected here and not present — a real gap in an observable place. */
+'absent' |
+/** This process cannot see it at all, so its absence proves nothing. */
+'unobservable';
+/** Prefix for per-field evidence labels. */
+declare const EVIDENCE_ATTR_PREFIX = "autotel.evidence.";
+/** The span attribute key carrying `field`'s evidence label. */
+declare function evidenceAttribute(field: string): string;
+/** The one thing {@link recordEvidence} needs — any `TraceContext` or `Span`. */
+interface EvidenceTarget {
+  setAttribute(key: string, value: string): void;
+}
+/** Label how `field` on this span came to be. */
+declare function recordEvidence(ctx: EvidenceTarget, field: string, quality: EvidenceQuality): void;
+/**
+ * The capture surfaces a deployment can be asked about. Closed set, because the
+ * point is that a backend can query `unobserved` across services and get
+ * comparable answers.
+ */
+declare const CAPTURE_SURFACES: readonly ["llm_calls", "tool_calls", "user_prompts", "file_io", "subprocess", "network", "ide_context"];
+type CaptureSurface = (typeof CAPTURE_SURFACES)[number];
+/** What this process can and cannot see. Anything in neither list is unknown. */
+interface CaptureCoverage {
+  observed: readonly CaptureSurface[];
+  unobserved: readonly CaptureSurface[];
+}
+declare const CAPTURE_COVERAGE_ATTR: {
+  readonly observed: "autotel.coverage.observed";
+  readonly unobserved: "autotel.coverage.unobserved";
+};
+/**
+ * Resource attributes declaring {@link CaptureCoverage}.
+ *
+ * An empty list is omitted rather than emitted: `unobserved: []` would read as
+ * "this process has no blind spots", which is a stronger claim than declaring
+ * nothing. A surface claimed as both is dropped from both — a contradiction
+ * that left `observed` intact would let a reader conclude a gap does not exist.
+ */
+declare function captureCoverageAttributes(coverage: CaptureCoverage): Attributes;
+//#endregion
+export { CAPTURE_COVERAGE_ATTR, CAPTURE_SURFACES, CaptureCoverage, CaptureSurface, EVIDENCE_ATTR_PREFIX, EvidenceQuality, EvidenceTarget, captureCoverageAttributes, evidenceAttribute, recordEvidence };

package/dist/evidence.d.ts

@@ -0,0 +1,61 @@
+import { Attributes } from "@opentelemetry/api";
+//#region src/evidence.d.ts
+/**
+ * Why a recorded fact is the way it is.
+ *
+ * There is deliberately no `unknown` member: a field carrying no evidence label
+ * is already unknown, and encoding that as a value invites code that treats an
+ * unlabelled field as *verified* unknown rather than simply unexamined.
+ */
+type EvidenceQuality =
+/** The instrumentation saw the value directly. */
+'observed' |
+/** Derived from other observed facts, not seen. */
+'inferred' |
+/** Computed from a price table, heuristic, or model — not reported upstream. */
+'estimated' |
+/** Seen, then cut short. What is here is real; what is missing is not. */
+'truncated' |
+/** Seen, then removed before storage. */
+'redacted' |
+/** Expected here and not present — a real gap in an observable place. */
+'absent' |
+/** This process cannot see it at all, so its absence proves nothing. */
+'unobservable';
+/** Prefix for per-field evidence labels. */
+declare const EVIDENCE_ATTR_PREFIX = "autotel.evidence.";
+/** The span attribute key carrying `field`'s evidence label. */
+declare function evidenceAttribute(field: string): string;
+/** The one thing {@link recordEvidence} needs — any `TraceContext` or `Span`. */
+interface EvidenceTarget {
+  setAttribute(key: string, value: string): void;
+}
+/** Label how `field` on this span came to be. */
+declare function recordEvidence(ctx: EvidenceTarget, field: string, quality: EvidenceQuality): void;
+/**
+ * The capture surfaces a deployment can be asked about. Closed set, because the
+ * point is that a backend can query `unobserved` across services and get
+ * comparable answers.
+ */
+declare const CAPTURE_SURFACES: readonly ["llm_calls", "tool_calls", "user_prompts", "file_io", "subprocess", "network", "ide_context"];
+type CaptureSurface = (typeof CAPTURE_SURFACES)[number];
+/** What this process can and cannot see. Anything in neither list is unknown. */
+interface CaptureCoverage {
+  observed: readonly CaptureSurface[];
+  unobserved: readonly CaptureSurface[];
+}
+declare const CAPTURE_COVERAGE_ATTR: {
+  readonly observed: "autotel.coverage.observed";
+  readonly unobserved: "autotel.coverage.unobserved";
+};
+/**
+ * Resource attributes declaring {@link CaptureCoverage}.
+ *
+ * An empty list is omitted rather than emitted: `unobserved: []` would read as
+ * "this process has no blind spots", which is a stronger claim than declaring
+ * nothing. A surface claimed as both is dropped from both — a contradiction
+ * that left `observed` intact would let a reader conclude a gap does not exist.
+ */
+declare function captureCoverageAttributes(coverage: CaptureCoverage): Attributes;
+//#endregion
+export { CAPTURE_COVERAGE_ATTR, CAPTURE_SURFACES, CaptureCoverage, CaptureSurface, EVIDENCE_ATTR_PREFIX, EvidenceQuality, EvidenceTarget, captureCoverageAttributes, evidenceAttribute, recordEvidence };

package/dist/evidence.js

@@ -0,0 +1,50 @@
+//#region src/evidence.ts
+/** Prefix for per-field evidence labels. */
+const EVIDENCE_ATTR_PREFIX = "autotel.evidence.";
+/** The span attribute key carrying `field`'s evidence label. */
+function evidenceAttribute(field) {
+	return `${EVIDENCE_ATTR_PREFIX}${field}`;
+}
+/** Label how `field` on this span came to be. */
+function recordEvidence(ctx, field, quality) {
+	ctx.setAttribute(evidenceAttribute(field), quality);
+}
+/**
+* The capture surfaces a deployment can be asked about. Closed set, because the
+* point is that a backend can query `unobserved` across services and get
+* comparable answers.
+*/
+const CAPTURE_SURFACES = [
+	"llm_calls",
+	"tool_calls",
+	"user_prompts",
+	"file_io",
+	"subprocess",
+	"network",
+	"ide_context"
+];
+const CAPTURE_COVERAGE_ATTR = {
+	observed: "autotel.coverage.observed",
+	unobserved: "autotel.coverage.unobserved"
+};
+/**
+* Resource attributes declaring {@link CaptureCoverage}.
+*
+* An empty list is omitted rather than emitted: `unobserved: []` would read as
+* "this process has no blind spots", which is a stronger claim than declaring
+* nothing. A surface claimed as both is dropped from both — a contradiction
+* that left `observed` intact would let a reader conclude a gap does not exist.
+*/
+function captureCoverageAttributes(coverage) {
+	const claimedBoth = new Set(coverage.observed.filter((s) => coverage.unobserved.includes(s)));
+	const keep = (surfaces) => [...new Set(surfaces.filter((s) => !claimedBoth.has(s)))];
+	const observed = keep(coverage.observed);
+	const unobserved = keep(coverage.unobserved);
+	return {
+		...observed.length > 0 && { [CAPTURE_COVERAGE_ATTR.observed]: observed },
+		...unobserved.length > 0 && { [CAPTURE_COVERAGE_ATTR.unobserved]: unobserved }
+	};
+}
+
+//#endregion
+export { CAPTURE_COVERAGE_ATTR, CAPTURE_SURFACES, EVIDENCE_ATTR_PREFIX, captureCoverageAttributes, evidenceAttribute, recordEvidence };

package/dist/{functional-C2ONG9PK.cjs → functional-C925G95W.cjs}

@@ -2,8 +2,8 @@ const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_values = require('./values-DApyq53y.cjs');
 const require_tracer_provider = require('./tracer-provider.cjs');
 const require_config = require('./config.cjs');
-const require_sampling = require('./sampling.cjs');
-const require_init = require('./init-C5aHRqi2.cjs');
+const require_init = require('./init-aTZKsAwy.cjs');
+const require_evidence = require('./evidence.cjs');
 const require_trace_helpers = require('./trace-helpers.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 let node_fs = require("node:fs");
@@ -11,6 +11,36 @@ node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
 let node_url = require("node:url");
 node_url = require_rolldown_runtime.__toESM(node_url, 1);
 
+//#region src/is-thenable.ts
+/**
+* Convert anything `await` would wait on into a native Promise, or return
+* `undefined` for a synchronous value.
+*
+* `instanceof Promise` is not enough. ORM query builders (drizzle, knex,
+* Prisma, Sequelize) are lazy thenables that are not native Promises, and a
+* promise created in another realm fails the check too. Treating those as
+* synchronous ends the span before the work runs, which produces a short
+* parent span with its real children orphaned outside it.
+*/
+function promiseFromThenable(value) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null) return;
+	let then;
+	try {
+		then = value.then;
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	if (typeof then !== "function") return void 0;
+	return new Promise((resolve, reject) => {
+		try {
+			then.call(value, resolve, reject);
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+
+//#endregion
 //#region src/variable-name-inference.ts
 /**
 * Variable Name Inference Utility
@@ -205,25 +235,41 @@ function createDummyCtx() {
 		getAllBaggage: () => /* @__PURE__ */ new Map()
 	};
 }
+/**
+* Serialize a captured value, and say whether the ceiling cut it. The flag is
+* separate from the text because `…[truncated]` inside the value is only
+* legible to a human reading one span — a backend cannot filter on it.
+*/
 function serializeCapture(value) {
 	if (value === void 0) return void 0;
 	try {
 		const json = require_values.asString(value) ?? JSON.stringify(value);
 		if (json === void 0) return void 0;
-		return json.length > CAPTURE_MAX_CHARS ? `${json.slice(0, CAPTURE_MAX_CHARS)}…[truncated]` : json;
+		return json.length > CAPTURE_MAX_CHARS ? {
+			text: `${json.slice(0, CAPTURE_MAX_CHARS)}…[truncated]`,
+			truncated: true
+		} : {
+			text: json,
+			truncated: false
+		};
 	} catch {
 		return;
 	}
 }
-function captureInputAttrs(args, enabled) {
+function captureAttrs(value, valueAttr, field, enabled) {
 	if (!enabled) return {};
-	const serialized = serializeCapture(args.length === 1 ? args[0] : args);
-	return serialized === void 0 ? {} : { [AUTOTEL_INPUT_ATTR]: serialized };
+	const serialized = serializeCapture(value);
+	if (serialized === void 0) return {};
+	return {
+		[valueAttr]: serialized.text,
+		...serialized.truncated && { [require_evidence.evidenceAttribute(field)]: "truncated" }
+	};
+}
+function captureInputAttrs(args, enabled) {
+	return captureAttrs(args.length === 1 ? args[0] : args, AUTOTEL_INPUT_ATTR, "input", enabled);
 }
 function captureOutputAttrs(result, enabled) {
-	if (!enabled) return {};
-	const serialized = serializeCapture(result);
-	return serialized === void 0 ? {} : { [AUTOTEL_OUTPUT_ATTR]: serialized };
+	return captureAttrs(result, AUTOTEL_OUTPUT_ATTR, "output", enabled);
 }
 function truncateErrorMessage(message) {
 	return message.length <= 500 ? message : `${message.slice(0, 500)}... (truncated)`;
@@ -302,7 +348,7 @@ function runWithTraceContextStorage(fn) {
 }
 function wrapWithTracingSync(fnFactory, options, variableName) {
 	const { tracer, meter } = require_config.getConfig();
-	const sampler = options.sampler || new require_sampling.AlwaysSampler();
+	const sampler = options.sampler || new require_init.AlwaysSampler();
 	const spanName = getSpanName(options, fnFactory, variableName);
 	const callCounter = options.withMetrics ? meter.createCounter(`${spanName}.calls`, {
 		description: `Call count for ${spanName}`,
@@ -321,7 +367,10 @@ function wrapWithTracingSync(fnFactory, options, variableName) {
 		const shouldSample = sampler.shouldSample(samplingContext);
 		const sampleRate = sampler.sampleRate?.(samplingContext);
 		const needsTailSampling = sampler.needsTailSampling?.() ?? false;
-		if (!shouldSample && !needsTailSampling) return fnFactory(createDummyCtx()).call(this, ...args);
+		if (!shouldSample && !needsTailSampling) {
+			const unsampled = fnFactory(createDummyCtx()).call(this, ...args);
+			return promiseFromThenable(unsampled) ?? unsampled;
+		}
 		const startTime = performance.now();
 		const flushRootTelemetry = createRootTelemetryFlusher(options, options.startNewRoot || _opentelemetry_api.trace.getActiveSpan() === void 0);
 		const spanOptions = {};
@@ -330,21 +379,21 @@ function wrapWithTracingSync(fnFactory, options, variableName) {
 		return tracer.startActiveSpan(spanName, spanOptions, require_init.getActiveContextWithBaggage(), (span) => require_init.runInOperationContext(spanName, () => runWithTraceContextStorage(() => {
 			let shouldKeepSpan = true;
 			require_trace_helpers.setSpanName(span, spanName);
-			if (sampleRate !== void 0 && sampleRate > 1) span.setAttribute(require_sampling.AUTOTEL_SAMPLING_RATE, sampleRate);
+			if (sampleRate !== void 0 && sampleRate > 1) span.setAttribute(require_init.AUTOTEL_SAMPLING_RATE, sampleRate);
 			const fn = fnFactory(require_init.createTraceContext(span));
 			const argsAttributes = {
 				...captureInputAttrs(args, options.captureInput),
 				...options.attributesFromArgs?.(args)
 			};
 			const handleTailSampling = (success, duration, error) => {
-				if (needsTailSampling && sampler.shouldKeepTrace) {
+				if (needsTailSampling && sampler.shouldKeepTrace && !require_init.isForceKept(span) && !require_init.debugCaptureRequested()) {
 					shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {
 						success,
 						duration,
 						error
 					});
-					span.setAttribute(require_sampling.AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
-					span.setAttribute(require_sampling.AUTOTEL_SAMPLING_TAIL_EVALUATED, true);
+					span.setAttribute(require_init.AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
+					span.setAttribute(require_init.AUTOTEL_SAMPLING_TAIL_EVALUATED, true);
 				}
 			};
 			const onSuccess = (result) => {
@@ -392,7 +441,8 @@ function wrapWithTracingSync(fnFactory, options, variableName) {
 					status: "started"
 				});
 				const result = _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(require_init.getActiveContextWithBaggage(), span), () => fn.call(this, ...args));
-				if (result instanceof Promise) return result.then(async (value) => {
+				const resultPromise = promiseFromThenable(result);
+				if (resultPromise) return resultPromise.then(async (value) => {
 					const completed = onSuccess(value);
 					await flushRootTelemetry();
 					return completed;
@@ -642,7 +692,8 @@ function span(nameOrOptions, fn) {
 			try {
 				if (attributes) for (const [key, value] of Object.entries(attributes)) span.setAttribute(key, value);
 				const result = fn(span);
-				if (result instanceof Promise) return result.then((resolved) => {
+				const resultPromise = promiseFromThenable(result);
+				if (resultPromise) return resultPromise.then((resolved) => {
 					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
 					span.end();
 					return resolved;

package/dist/{functional-CJn2zY4o.d.cts → functional-CgWcRXGX.d.cts}

@@ -1,5 +1,5 @@
 import { n as TraceContext } from "./trace-context-C1Cn1q0y.cjs";
-import { p as Sampler } from "./sampling-CmRdnXUi.cjs";
+import { m as Sampler } from "./sampling-Er217Mge.cjs";
 import { Attributes, Span, SpanKind } from "@opentelemetry/api";
 //#region src/functional-wrapper.d.ts
 type WrappedFunction<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn | Promise<TReturn>;
@@ -192,7 +192,9 @@ declare const ctx: TraceContext;
  * })
  * ```
  */
+declare function traceImpl<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => PromiseLike<TReturn>): (...args: TArgs) => Promise<TReturn>;
 declare function traceImpl<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function traceImpl<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => PromiseLike<TReturn>): (...args: TArgs) => Promise<TReturn>;
 declare function traceImpl<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
 declare function traceImpl<TArgs extends unknown[], TReturn>(options: TracingOptions<TArgs, TReturn>, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
 declare function traceImpl(name: string): <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => (...args: TArgs) => TReturn;
@@ -258,7 +260,7 @@ declare const trace$1: typeof traceImpl & {
  * )(ctx => async (data) => { })
  * ```
  */
-declare function withTracing<TCfgArgs extends unknown[] = unknown[], TCfgReturn = unknown>(options?: TracingOptions<TCfgArgs, TCfgReturn>): <TArgs extends TCfgArgs, TReturn extends TCfgReturn>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>) => WrappedFunction<TArgs, TReturn>;
+declare function withTracing<TCfgArgs extends unknown[] = unknown[], TCfgReturn = unknown>(options?: TracingOptions<TCfgArgs, TCfgReturn>): <TArgs extends TCfgArgs, TReturn extends TCfgReturn>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn | PromiseLike<TReturn>) => WrappedFunction<TArgs, TReturn>;
 /**
  * Approach 3: instrument() - Batch auto-instrumentation
  *
@@ -309,8 +311,13 @@ declare function withTracing<TCfgArgs extends unknown[] = unknown[], TCfgReturn
  * })
  * ```
  */
+type InstrumentedFunction<TFunction extends AnyInstrumentable> = TFunction extends ((...args: infer TArgs) => infer TReturn) ? (...args: TArgs) => TReturn extends PromiseLike<infer TValue> ? Promise<TValue> : TReturn : never;
+type InstrumentedFunctions<T extends Record<string, AnyInstrumentable>> = { [TKey in keyof T]: InstrumentedFunction<T[TKey]>; };
+declare function instrument<TFunction extends AnyInstrumentable>(options: SingleInstrumentOptions<TFunction> & {
+  fn: TFunction & ((...args: Parameters<TFunction>) => PromiseLike<unknown>);
+}): (...args: Parameters<TFunction>) => Promise<Awaited<ReturnType<TFunction>>>;
 declare function instrument<TFunction extends AnyInstrumentable>(options: SingleInstrumentOptions<TFunction>): TFunction;
-declare function instrument<T extends Record<string, AnyInstrumentable>>(options: InstrumentOptions<T>): T;
+declare function instrument<T extends Record<string, AnyInstrumentable>>(options: InstrumentOptions<T>): InstrumentedFunctions<T>;
 /**
  * Options for span() function
  */
@@ -352,10 +359,10 @@ interface SpanOptions {
  * })
  * ```
  */
+declare function span<T = unknown>(name: string, fn: (span: Span) => PromiseLike<T>): Promise<T>;
+declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => PromiseLike<T>): Promise<T>;
 declare function span<T = unknown>(name: string, fn: (span: Span) => T): T;
-declare function span<T = unknown>(name: string, fn: (span: Span) => Promise<T>): Promise<T>;
 declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => T): T;
-declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
 /**
  * Options for withNewContext() function
  */