autotel-edge 3.16.13 → 3.16.15

package/dist/sampling.js

@@ -1,108 +1,173 @@
-// src/sampling/index.ts
+//#region src/sampling/index.ts
+/**
+* Create an adaptive tail sampler
+*
+* This sampler ensures you never miss critical issues while keeping costs down:
+* - Always traces errors (status code = ERROR)
+* - Always traces slow requests (duration >= slowThresholdMs)
+* - Uses baseline sample rate for successful fast requests
+*
+* **Recommended for production use.**
+*
+* @example
+* ```typescript
+* const tailSampler = createAdaptiveTailSampler({
+*   baselineSampleRate: 0.1,    // 10% of normal requests
+*   slowThresholdMs: 1000,       // Requests > 1s are "slow"
+*   alwaysSampleErrors: true,    // Always trace errors
+*   alwaysSampleSlow: true       // Always trace slow requests
+* })
+* ```
+*/
 function createAdaptiveTailSampler(options = {}) {
-  const baselineSampleRate = options.baselineSampleRate ?? 0.1;
-  const slowThresholdMs = options.slowThresholdMs ?? 1e3;
-  const alwaysSampleErrors = options.alwaysSampleErrors ?? true;
-  const alwaysSampleSlow = options.alwaysSampleSlow ?? true;
-  if (baselineSampleRate < 0 || baselineSampleRate > 1) {
-    throw new Error("Baseline sample rate must be between 0 and 1");
-  }
-  const baselineDecisions = /* @__PURE__ */ new Map();
-  return (traceInfo) => {
-    const { traceId, localRootSpan } = traceInfo;
-    if (!baselineDecisions.has(traceId)) {
-      baselineDecisions.set(traceId, Math.random() < baselineSampleRate);
-    }
-    const baselineDecision = baselineDecisions.get(traceId);
-    if (alwaysSampleErrors && localRootSpan.status.code === 2) {
-      return true;
-    }
-    if (alwaysSampleSlow) {
-      const duration = getDurationMs(localRootSpan);
-      if (duration >= slowThresholdMs) {
-        return true;
-      }
-    }
-    return baselineDecision;
-  };
+	const baselineSampleRate = options.baselineSampleRate ?? .1;
+	const slowThresholdMs = options.slowThresholdMs ?? 1e3;
+	const alwaysSampleErrors = options.alwaysSampleErrors ?? true;
+	const alwaysSampleSlow = options.alwaysSampleSlow ?? true;
+	if (baselineSampleRate < 0 || baselineSampleRate > 1) throw new Error("Baseline sample rate must be between 0 and 1");
+	const baselineDecisions = /* @__PURE__ */ new Map();
+	return (traceInfo) => {
+		const { traceId, localRootSpan } = traceInfo;
+		if (!baselineDecisions.has(traceId)) baselineDecisions.set(traceId, Math.random() < baselineSampleRate);
+		const baselineDecision = baselineDecisions.get(traceId);
+		if (alwaysSampleErrors && localRootSpan.status.code === 2) return true;
+		if (alwaysSampleSlow) {
+			if (getDurationMs(localRootSpan) >= slowThresholdMs) return true;
+		}
+		return baselineDecision;
+	};
 }
+/**
+* Create a simple random tail sampler
+*
+* Samples a fixed percentage of all traces regardless of outcome.
+*
+* @example
+* ```typescript
+* const tailSampler = createRandomTailSampler(0.1) // 10% of all requests
+* ```
+*/
 function createRandomTailSampler(sampleRate) {
-  if (sampleRate < 0 || sampleRate > 1) {
-    throw new Error("Sample rate must be between 0 and 1");
-  }
-  const decisions = /* @__PURE__ */ new Map();
-  return (traceInfo) => {
-    const { traceId } = traceInfo;
-    if (!decisions.has(traceId)) {
-      decisions.set(traceId, Math.random() < sampleRate);
-    }
-    return decisions.get(traceId);
-  };
+	if (sampleRate < 0 || sampleRate > 1) throw new Error("Sample rate must be between 0 and 1");
+	const decisions = /* @__PURE__ */ new Map();
+	return (traceInfo) => {
+		const { traceId } = traceInfo;
+		if (!decisions.has(traceId)) decisions.set(traceId, Math.random() < sampleRate);
+		return decisions.get(traceId);
+	};
 }
+/**
+* Create a tail sampler that keeps all errors
+*
+* Useful for debugging - captures all failures while dropping successful requests.
+*
+* @example
+* ```typescript
+* const tailSampler = createErrorOnlyTailSampler()
+* ```
+*/
 function createErrorOnlyTailSampler() {
-  return (traceInfo) => {
-    return traceInfo.localRootSpan.status.code === 2;
-  };
+	return (traceInfo) => {
+		return traceInfo.localRootSpan.status.code === 2;
+	};
 }
+/**
+* Create a tail sampler that keeps slow requests
+*
+* Useful for performance debugging - captures slow requests while dropping fast ones.
+*
+* @example
+* ```typescript
+* const tailSampler = createSlowOnlyTailSampler(1000) // Keep requests > 1s
+* ```
+*/
 function createSlowOnlyTailSampler(thresholdMs) {
-  return (traceInfo) => {
-    const duration = getDurationMs(traceInfo.localRootSpan);
-    return duration >= thresholdMs;
-  };
+	return (traceInfo) => {
+		return getDurationMs(traceInfo.localRootSpan) >= thresholdMs;
+	};
 }
+/**
+* Combine multiple tail samplers with OR logic
+*
+* Keeps a trace if ANY sampler returns true.
+*
+* @example
+* ```typescript
+* const tailSampler = combineTailSamplers(
+*   createErrorOnlyTailSampler(),
+*   createSlowOnlyTailSampler(1000),
+*   createRandomTailSampler(0.01)  // 1% baseline
+* )
+* ```
+*/
 function combineTailSamplers(...samplers) {
-  if (samplers.length === 0) {
-    throw new Error("combineTailSamplers requires at least one sampler");
-  }
-  return (traceInfo) => {
-    return samplers.some((sampler) => sampler(traceInfo));
-  };
+	if (samplers.length === 0) throw new Error("combineTailSamplers requires at least one sampler");
+	return (traceInfo) => {
+		return samplers.some((sampler) => sampler(traceInfo));
+	};
 }
+/**
+* Create a tail sampler based on custom predicate
+*
+* @example
+* ```typescript
+* // Keep traces with specific attributes
+* const tailSampler = createCustomTailSampler((trace) => {
+*   const attrs = trace.localRootSpan.attributes
+*   return attrs['user.id'] === 'vip_123'
+* })
+* ```
+*/
 function createCustomTailSampler(predicate) {
-  return predicate;
+	return predicate;
 }
+/**
+* Helper: Get span duration in milliseconds
+*/
 function getDurationMs(span) {
-  const start = span.startTime[0] * 1e3 + span.startTime[1] / 1e6;
-  const end = span.endTime[0] * 1e3 + span.endTime[1] / 1e6;
-  return end - start;
+	const start = span.startTime[0] * 1e3 + span.startTime[1] / 1e6;
+	return span.endTime[0] * 1e3 + span.endTime[1] / 1e6 - start;
 }
-var SamplingPresets = {
-  /**
-   * Production: 10% baseline, all errors, all slow (>1s)
-   * Recommended for most production workloads
-   */
-  production: () => createAdaptiveTailSampler({
-    baselineSampleRate: 0.1,
-    slowThresholdMs: 1e3
-  }),
-  /**
-   * High-traffic: 1% baseline, all errors, all slow (>2s)
-   * For high-volume services where cost is a concern
-   */
-  highTraffic: () => createAdaptiveTailSampler({
-    baselineSampleRate: 0.01,
-    slowThresholdMs: 2e3
-  }),
-  /**
-   * Debugging: All errors, all slow (>500ms), 50% baseline
-   * For active debugging sessions
-   */
-  debugging: () => createAdaptiveTailSampler({
-    baselineSampleRate: 0.5,
-    slowThresholdMs: 500
-  }),
-  /**
-   * Development: 100% sampling
-   * For local development and testing
-   */
-  development: () => () => true,
-  /**
-   * Errors only: Capture all failures, drop all successes
-   * For error-focused monitoring
-   */
-  errorsOnly: () => createErrorOnlyTailSampler()
+/**
+* Common presets for quick setup
+*/
+const SamplingPresets = {
+	/**
+	* Production: 10% baseline, all errors, all slow (>1s)
+	* Recommended for most production workloads
+	*/
+	production: () => createAdaptiveTailSampler({
+		baselineSampleRate: .1,
+		slowThresholdMs: 1e3
+	}),
+	/**
+	* High-traffic: 1% baseline, all errors, all slow (>2s)
+	* For high-volume services where cost is a concern
+	*/
+	highTraffic: () => createAdaptiveTailSampler({
+		baselineSampleRate: .01,
+		slowThresholdMs: 2e3
+	}),
+	/**
+	* Debugging: All errors, all slow (>500ms), 50% baseline
+	* For active debugging sessions
+	*/
+	debugging: () => createAdaptiveTailSampler({
+		baselineSampleRate: .5,
+		slowThresholdMs: 500
+	}),
+	/**
+	* Development: 100% sampling
+	* For local development and testing
+	*/
+	development: () => () => true,
+	/**
+	* Errors only: Capture all failures, drop all successes
+	* For error-focused monitoring
+	*/
+	errorsOnly: () => createErrorOnlyTailSampler()
 };
 
+//#endregion
 export { SamplingPresets, combineTailSamplers, createAdaptiveTailSampler, createCustomTailSampler, createErrorOnlyTailSampler, createRandomTailSampler, createSlowOnlyTailSampler };
-//# sourceMappingURL=sampling.js.map
 //# sourceMappingURL=sampling.js.map

package/dist/sampling.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/sampling/index.ts"],"names":[],"mappings":"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","file":"sampling.js","sourcesContent":["/**\n * Sampling strategies for autotel-edge\n *\n * Provides intelligent sampling to reduce telemetry costs while capturing critical data.\n *\n * Key strategies:\n * - Always trace errors and slow requests (critical for debugging)\n * - Adaptive sampling based on load\n * - Baseline random sampling for normal traffic\n *\n * @example\n * ```typescript\n * import { createAdaptiveTailSampler } from 'autotel-edge/sampling'\n *\n * export default instrument(handler, {\n *   sampling: {\n *     tailSampler: createAdaptiveTailSampler({\n *       baselineSampleRate: 0.1,  // 10% of normal requests\n *       slowThresholdMs: 1000,     // Requests > 1s are \"slow\"\n *     })\n *   }\n * })\n * ```\n */\n\nimport type { TailSampleFn, LocalTrace } from '../types';\nimport type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\n\nexport interface AdaptiveSamplerOptions {\n  /**\n   * Baseline sample rate for normal (successful, fast) requests\n   * @default 0.1 (10%)\n   */\n  baselineSampleRate?: number;\n\n  /**\n   * Threshold in milliseconds for \"slow\" requests\n   * Requests taking longer than this will always be trace\n   * @default 1000ms\n   */\n  slowThresholdMs?: number;\n\n  /**\n   * Always trace error spans\n   * @default true\n   */\n  alwaysSampleErrors?: boolean;\n\n  /**\n   * Always trace slow spans\n   * @default true\n   */\n  alwaysSampleSlow?: boolean;\n}\n\n/**\n * Create an adaptive tail sampler\n *\n * This sampler ensures you never miss critical issues while keeping costs down:\n * - Always traces errors (status code = ERROR)\n * - Always traces slow requests (duration >= slowThresholdMs)\n * - Uses baseline sample rate for successful fast requests\n *\n * **Recommended for production use.**\n *\n * @example\n * ```typescript\n * const tailSampler = createAdaptiveTailSampler({\n *   baselineSampleRate: 0.1,    // 10% of normal requests\n *   slowThresholdMs: 1000,       // Requests > 1s are \"slow\"\n *   alwaysSampleErrors: true,    // Always trace errors\n *   alwaysSampleSlow: true       // Always trace slow requests\n * })\n * ```\n */\nexport function createAdaptiveTailSampler(\n  options: AdaptiveSamplerOptions = {},\n): TailSampleFn {\n  const baselineSampleRate = options.baselineSampleRate ?? 0.1;\n  const slowThresholdMs = options.slowThresholdMs ?? 1000;\n  const alwaysSampleErrors = options.alwaysSampleErrors ?? true;\n  const alwaysSampleSlow = options.alwaysSampleSlow ?? true;\n\n  if (baselineSampleRate < 0 || baselineSampleRate > 1) {\n    throw new Error('Baseline sample rate must be between 0 and 1');\n  }\n\n  // Store baseline decisions using trace ID\n  const baselineDecisions = new Map<string, boolean>();\n\n  return (traceInfo: LocalTrace): boolean => {\n    const { traceId, localRootSpan } = traceInfo;\n\n    // Get or create baseline decision for this trace\n    if (!baselineDecisions.has(traceId)) {\n      baselineDecisions.set(traceId, Math.random() < baselineSampleRate);\n    }\n    const baselineDecision = baselineDecisions.get(traceId)!;\n\n    // Always keep errors (SpanStatusCode.ERROR = 2)\n    if (alwaysSampleErrors && localRootSpan.status.code === 2) {\n      return true;\n    }\n\n    // Always keep slow requests\n    if (alwaysSampleSlow) {\n      const duration = getDurationMs(localRootSpan);\n      if (duration >= slowThresholdMs) {\n        return true;\n      }\n    }\n\n    // Otherwise, use baseline decision\n    return baselineDecision;\n  };\n}\n\n/**\n * Create a simple random tail sampler\n *\n * Samples a fixed percentage of all traces regardless of outcome.\n *\n * @example\n * ```typescript\n * const tailSampler = createRandomTailSampler(0.1) // 10% of all requests\n * ```\n */\nexport function createRandomTailSampler(sampleRate: number): TailSampleFn {\n  if (sampleRate < 0 || sampleRate > 1) {\n    throw new Error('Sample rate must be between 0 and 1');\n  }\n\n  const decisions = new Map<string, boolean>();\n\n  return (traceInfo: LocalTrace): boolean => {\n    const { traceId } = traceInfo;\n\n    if (!decisions.has(traceId)) {\n      decisions.set(traceId, Math.random() < sampleRate);\n    }\n\n    return decisions.get(traceId)!;\n  };\n}\n\n/**\n * Create a tail sampler that keeps all errors\n *\n * Useful for debugging - captures all failures while dropping successful requests.\n *\n * @example\n * ```typescript\n * const tailSampler = createErrorOnlyTailSampler()\n * ```\n */\nexport function createErrorOnlyTailSampler(): TailSampleFn {\n  return (traceInfo: LocalTrace): boolean => {\n    // SpanStatusCode.ERROR = 2\n    return traceInfo.localRootSpan.status.code === 2;\n  };\n}\n\n/**\n * Create a tail sampler that keeps slow requests\n *\n * Useful for performance debugging - captures slow requests while dropping fast ones.\n *\n * @example\n * ```typescript\n * const tailSampler = createSlowOnlyTailSampler(1000) // Keep requests > 1s\n * ```\n */\nexport function createSlowOnlyTailSampler(thresholdMs: number): TailSampleFn {\n  return (traceInfo: LocalTrace): boolean => {\n    const duration = getDurationMs(traceInfo.localRootSpan);\n    return duration >= thresholdMs;\n  };\n}\n\n/**\n * Combine multiple tail samplers with OR logic\n *\n * Keeps a trace if ANY sampler returns true.\n *\n * @example\n * ```typescript\n * const tailSampler = combineTailSamplers(\n *   createErrorOnlyTailSampler(),\n *   createSlowOnlyTailSampler(1000),\n *   createRandomTailSampler(0.01)  // 1% baseline\n * )\n * ```\n */\nexport function combineTailSamplers(...samplers: TailSampleFn[]): TailSampleFn {\n  if (samplers.length === 0) {\n    throw new Error('combineTailSamplers requires at least one sampler');\n  }\n\n  return (traceInfo: LocalTrace): boolean => {\n    return samplers.some((sampler) => sampler(traceInfo));\n  };\n}\n\n/**\n * Create a tail sampler based on custom predicate\n *\n * @example\n * ```typescript\n * // Keep traces with specific attributes\n * const tailSampler = createCustomTailSampler((trace) => {\n *   const attrs = trace.localRootSpan.attributes\n *   return attrs['user.id'] === 'vip_123'\n * })\n * ```\n */\nexport function createCustomTailSampler(\n  predicate: (traceInfo: LocalTrace) => boolean,\n): TailSampleFn {\n  return predicate;\n}\n\n/**\n * Helper: Get span duration in milliseconds\n */\nfunction getDurationMs(span: ReadableSpan): number {\n  const start = span.startTime[0] * 1000 + span.startTime[1] / 1_000_000;\n  const end = span.endTime[0] * 1000 + span.endTime[1] / 1_000_000;\n  return end - start;\n}\n\n/**\n * Common presets for quick setup\n */\nexport const SamplingPresets = {\n  /**\n   * Production: 10% baseline, all errors, all slow (>1s)\n   * Recommended for most production workloads\n   */\n  production: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.1,\n      slowThresholdMs: 1000,\n    }),\n\n  /**\n   * High-traffic: 1% baseline, all errors, all slow (>2s)\n   * For high-volume services where cost is a concern\n   */\n  highTraffic: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.01,\n      slowThresholdMs: 2000,\n    }),\n\n  /**\n   * Debugging: All errors, all slow (>500ms), 50% baseline\n   * For active debugging sessions\n   */\n  debugging: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.5,\n      slowThresholdMs: 500,\n    }),\n\n  /**\n   * Development: 100% sampling\n   * For local development and testing\n   */\n  development: (): TailSampleFn => () => true,\n\n  /**\n   * Errors only: Capture all failures, drop all successes\n   * For error-focused monitoring\n   */\n  errorsOnly: (): TailSampleFn => createErrorOnlyTailSampler(),\n};\n"]}
+{"version":3,"file":"sampling.js","names":[],"sources":["../src/sampling/index.ts"],"sourcesContent":["/**\n * Sampling strategies for autotel-edge\n *\n * Provides intelligent sampling to reduce telemetry costs while capturing critical data.\n *\n * Key strategies:\n * - Always trace errors and slow requests (critical for debugging)\n * - Adaptive sampling based on load\n * - Baseline random sampling for normal traffic\n *\n * @example\n * ```typescript\n * import { createAdaptiveTailSampler } from 'autotel-edge/sampling'\n *\n * export default instrument(handler, {\n *   sampling: {\n *     tailSampler: createAdaptiveTailSampler({\n *       baselineSampleRate: 0.1,  // 10% of normal requests\n *       slowThresholdMs: 1000,     // Requests > 1s are \"slow\"\n *     })\n *   }\n * })\n * ```\n */\n\nimport type { TailSampleFn, LocalTrace } from '../types';\nimport type { ReadableSpan } from '@opentelemetry/sdk-trace-base';\n\nexport interface AdaptiveSamplerOptions {\n  /**\n   * Baseline sample rate for normal (successful, fast) requests\n   * @default 0.1 (10%)\n   */\n  baselineSampleRate?: number;\n\n  /**\n   * Threshold in milliseconds for \"slow\" requests\n   * Requests taking longer than this will always be trace\n   * @default 1000ms\n   */\n  slowThresholdMs?: number;\n\n  /**\n   * Always trace error spans\n   * @default true\n   */\n  alwaysSampleErrors?: boolean;\n\n  /**\n   * Always trace slow spans\n   * @default true\n   */\n  alwaysSampleSlow?: boolean;\n}\n\n/**\n * Create an adaptive tail sampler\n *\n * This sampler ensures you never miss critical issues while keeping costs down:\n * - Always traces errors (status code = ERROR)\n * - Always traces slow requests (duration >= slowThresholdMs)\n * - Uses baseline sample rate for successful fast requests\n *\n * **Recommended for production use.**\n *\n * @example\n * ```typescript\n * const tailSampler = createAdaptiveTailSampler({\n *   baselineSampleRate: 0.1,    // 10% of normal requests\n *   slowThresholdMs: 1000,       // Requests > 1s are \"slow\"\n *   alwaysSampleErrors: true,    // Always trace errors\n *   alwaysSampleSlow: true       // Always trace slow requests\n * })\n * ```\n */\nexport function createAdaptiveTailSampler(\n  options: AdaptiveSamplerOptions = {},\n): TailSampleFn {\n  const baselineSampleRate = options.baselineSampleRate ?? 0.1;\n  const slowThresholdMs = options.slowThresholdMs ?? 1000;\n  const alwaysSampleErrors = options.alwaysSampleErrors ?? true;\n  const alwaysSampleSlow = options.alwaysSampleSlow ?? true;\n\n  if (baselineSampleRate < 0 || baselineSampleRate > 1) {\n    throw new Error('Baseline sample rate must be between 0 and 1');\n  }\n\n  // Store baseline decisions using trace ID\n  const baselineDecisions = new Map<string, boolean>();\n\n  return (traceInfo: LocalTrace): boolean => {\n    const { traceId, localRootSpan } = traceInfo;\n\n    // Get or create baseline decision for this trace\n    if (!baselineDecisions.has(traceId)) {\n      baselineDecisions.set(traceId, Math.random() < baselineSampleRate);\n    }\n    const baselineDecision = baselineDecisions.get(traceId)!;\n\n    // Always keep errors (SpanStatusCode.ERROR = 2)\n    if (alwaysSampleErrors && localRootSpan.status.code === 2) {\n      return true;\n    }\n\n    // Always keep slow requests\n    if (alwaysSampleSlow) {\n      const duration = getDurationMs(localRootSpan);\n      if (duration >= slowThresholdMs) {\n        return true;\n      }\n    }\n\n    // Otherwise, use baseline decision\n    return baselineDecision;\n  };\n}\n\n/**\n * Create a simple random tail sampler\n *\n * Samples a fixed percentage of all traces regardless of outcome.\n *\n * @example\n * ```typescript\n * const tailSampler = createRandomTailSampler(0.1) // 10% of all requests\n * ```\n */\nexport function createRandomTailSampler(sampleRate: number): TailSampleFn {\n  if (sampleRate < 0 || sampleRate > 1) {\n    throw new Error('Sample rate must be between 0 and 1');\n  }\n\n  const decisions = new Map<string, boolean>();\n\n  return (traceInfo: LocalTrace): boolean => {\n    const { traceId } = traceInfo;\n\n    if (!decisions.has(traceId)) {\n      decisions.set(traceId, Math.random() < sampleRate);\n    }\n\n    return decisions.get(traceId)!;\n  };\n}\n\n/**\n * Create a tail sampler that keeps all errors\n *\n * Useful for debugging - captures all failures while dropping successful requests.\n *\n * @example\n * ```typescript\n * const tailSampler = createErrorOnlyTailSampler()\n * ```\n */\nexport function createErrorOnlyTailSampler(): TailSampleFn {\n  return (traceInfo: LocalTrace): boolean => {\n    // SpanStatusCode.ERROR = 2\n    return traceInfo.localRootSpan.status.code === 2;\n  };\n}\n\n/**\n * Create a tail sampler that keeps slow requests\n *\n * Useful for performance debugging - captures slow requests while dropping fast ones.\n *\n * @example\n * ```typescript\n * const tailSampler = createSlowOnlyTailSampler(1000) // Keep requests > 1s\n * ```\n */\nexport function createSlowOnlyTailSampler(thresholdMs: number): TailSampleFn {\n  return (traceInfo: LocalTrace): boolean => {\n    const duration = getDurationMs(traceInfo.localRootSpan);\n    return duration >= thresholdMs;\n  };\n}\n\n/**\n * Combine multiple tail samplers with OR logic\n *\n * Keeps a trace if ANY sampler returns true.\n *\n * @example\n * ```typescript\n * const tailSampler = combineTailSamplers(\n *   createErrorOnlyTailSampler(),\n *   createSlowOnlyTailSampler(1000),\n *   createRandomTailSampler(0.01)  // 1% baseline\n * )\n * ```\n */\nexport function combineTailSamplers(...samplers: TailSampleFn[]): TailSampleFn {\n  if (samplers.length === 0) {\n    throw new Error('combineTailSamplers requires at least one sampler');\n  }\n\n  return (traceInfo: LocalTrace): boolean => {\n    return samplers.some((sampler) => sampler(traceInfo));\n  };\n}\n\n/**\n * Create a tail sampler based on custom predicate\n *\n * @example\n * ```typescript\n * // Keep traces with specific attributes\n * const tailSampler = createCustomTailSampler((trace) => {\n *   const attrs = trace.localRootSpan.attributes\n *   return attrs['user.id'] === 'vip_123'\n * })\n * ```\n */\nexport function createCustomTailSampler(\n  predicate: (traceInfo: LocalTrace) => boolean,\n): TailSampleFn {\n  return predicate;\n}\n\n/**\n * Helper: Get span duration in milliseconds\n */\nfunction getDurationMs(span: ReadableSpan): number {\n  const start = span.startTime[0] * 1000 + span.startTime[1] / 1_000_000;\n  const end = span.endTime[0] * 1000 + span.endTime[1] / 1_000_000;\n  return end - start;\n}\n\n/**\n * Common presets for quick setup\n */\nexport const SamplingPresets = {\n  /**\n   * Production: 10% baseline, all errors, all slow (>1s)\n   * Recommended for most production workloads\n   */\n  production: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.1,\n      slowThresholdMs: 1000,\n    }),\n\n  /**\n   * High-traffic: 1% baseline, all errors, all slow (>2s)\n   * For high-volume services where cost is a concern\n   */\n  highTraffic: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.01,\n      slowThresholdMs: 2000,\n    }),\n\n  /**\n   * Debugging: All errors, all slow (>500ms), 50% baseline\n   * For active debugging sessions\n   */\n  debugging: (): TailSampleFn =>\n    createAdaptiveTailSampler({\n      baselineSampleRate: 0.5,\n      slowThresholdMs: 500,\n    }),\n\n  /**\n   * Development: 100% sampling\n   * For local development and testing\n   */\n  development: (): TailSampleFn => () => true,\n\n  /**\n   * Errors only: Capture all failures, drop all successes\n   * For error-focused monitoring\n   */\n  errorsOnly: (): TailSampleFn => createErrorOnlyTailSampler(),\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA2EA,SAAgB,0BACd,UAAkC,CAAC,GACrB;CACd,MAAM,qBAAqB,QAAQ,sBAAsB;CACzD,MAAM,kBAAkB,QAAQ,mBAAmB;CACnD,MAAM,qBAAqB,QAAQ,sBAAsB;CACzD,MAAM,mBAAmB,QAAQ,oBAAoB;CAErD,IAAI,qBAAqB,KAAK,qBAAqB,GACjD,MAAM,IAAI,MAAM,8CAA8C;CAIhE,MAAM,oCAAoB,IAAI,IAAqB;CAEnD,QAAQ,cAAmC;EACzC,MAAM,EAAE,SAAS,kBAAkB;EAGnC,IAAI,CAAC,kBAAkB,IAAI,OAAO,GAChC,kBAAkB,IAAI,SAAS,KAAK,OAAO,IAAI,kBAAkB;EAEnE,MAAM,mBAAmB,kBAAkB,IAAI,OAAO;EAGtD,IAAI,sBAAsB,cAAc,OAAO,SAAS,GACtD,OAAO;EAIT,IAAI,kBAEF;OADiB,cAAc,aACpB,KAAK,iBACd,OAAO;EACT;EAIF,OAAO;CACT;AACF;;;;;;;;;;;AAYA,SAAgB,wBAAwB,YAAkC;CACxE,IAAI,aAAa,KAAK,aAAa,GACjC,MAAM,IAAI,MAAM,qCAAqC;CAGvD,MAAM,4BAAY,IAAI,IAAqB;CAE3C,QAAQ,cAAmC;EACzC,MAAM,EAAE,YAAY;EAEpB,IAAI,CAAC,UAAU,IAAI,OAAO,GACxB,UAAU,IAAI,SAAS,KAAK,OAAO,IAAI,UAAU;EAGnD,OAAO,UAAU,IAAI,OAAO;CAC9B;AACF;;;;;;;;;;;AAYA,SAAgB,6BAA2C;CACzD,QAAQ,cAAmC;EAEzC,OAAO,UAAU,cAAc,OAAO,SAAS;CACjD;AACF;;;;;;;;;;;AAYA,SAAgB,0BAA0B,aAAmC;CAC3E,QAAQ,cAAmC;EAEzC,OADiB,cAAc,UAAU,aAC3B,KAAK;CACrB;AACF;;;;;;;;;;;;;;;AAgBA,SAAgB,oBAAoB,GAAG,UAAwC;CAC7E,IAAI,SAAS,WAAW,GACtB,MAAM,IAAI,MAAM,mDAAmD;CAGrE,QAAQ,cAAmC;EACzC,OAAO,SAAS,MAAM,YAAY,QAAQ,SAAS,CAAC;CACtD;AACF;;;;;;;;;;;;;AAcA,SAAgB,wBACd,WACc;CACd,OAAO;AACT;;;;AAKA,SAAS,cAAc,MAA4B;CACjD,MAAM,QAAQ,KAAK,UAAU,KAAK,MAAO,KAAK,UAAU,KAAK;CAE7D,OADY,KAAK,QAAQ,KAAK,MAAO,KAAK,QAAQ,KAAK,MAC1C;AACf;;;;AAKA,MAAa,kBAAkB;;;;;CAK7B,kBACE,0BAA0B;EACxB,oBAAoB;EACpB,iBAAiB;CACnB,CAAC;;;;;CAMH,mBACE,0BAA0B;EACxB,oBAAoB;EACpB,iBAAiB;CACnB,CAAC;;;;;CAMH,iBACE,0BAA0B;EACxB,oBAAoB;EACpB,iBAAiB;CACnB,CAAC;;;;;CAMH,yBAAuC;;;;;CAMvC,kBAAgC,2BAA2B;AAC7D"}

package/dist/testing.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export { };

package/dist/testing.js

@@ -1,3 +1 @@
-
-//# sourceMappingURL=testing.js.map
-//# sourceMappingURL=testing.js.map
+export {  };

package/dist/types-HCbsjZzp.d.ts

@@ -0,0 +1,214 @@
+import { Attributes, Context, Span, SpanOptions, TextMapPropagator } from "@opentelemetry/api";
+import { ReadableSpan, ReadableSpan as ReadableSpan$1, Sampler, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+
+//#region src/types.d.ts
+/**
+ * Trigger types for edge handlers
+ * Can be a Request or any vendor-specific trigger type
+ */
+type Trigger = Request | DOConstructorTrigger | WorkflowTrigger | 'do-alarm' | unknown;
+interface DOConstructorTrigger {
+  id: string;
+  name?: string;
+}
+interface WorkflowTrigger {
+  type: 'workflow';
+  name: string;
+}
+/**
+ * Config types
+ */
+interface OTLPExporterConfig {
+  url: string;
+  headers?: Record<string, string>;
+}
+type ExporterConfig = OTLPExporterConfig | SpanExporter;
+interface ServiceConfig {
+  name: string;
+  namespace?: string;
+  version?: string;
+}
+interface ParentRatioSamplingConfig {
+  acceptRemote?: boolean;
+  ratio: number;
+}
+type HeadSamplerConf = Sampler | ParentRatioSamplingConfig;
+interface SamplingConfig<HS extends HeadSamplerConf = HeadSamplerConf> {
+  headSampler?: HS;
+  tailSampler?: TailSampleFn;
+}
+interface InstrumentationOptions {
+  instrumentGlobalFetch?: boolean;
+  instrumentGlobalCache?: boolean;
+  /**
+   * Disable instrumentation entirely (useful for local development)
+   * When enabled, the handler is returned as-is without any instrumentation
+   * @default false
+   */
+  disabled?: boolean;
+}
+/**
+ * Utility types
+ */
+type OrPromise<T> = T | Promise<T>;
+/**
+ * Adapter event types
+ */
+type FunnelStepStatus = 'started' | 'completed' | 'abandoned' | 'failed' | (string & {});
+type OutcomeStatus = 'success' | 'failure' | 'partial' | (string & {});
+interface EdgeEventBase {
+  [key: string]: unknown;
+  service: string;
+  timestamp: number;
+  attributes: Record<string, unknown>;
+  traceId?: string;
+  spanId?: string;
+  correlationId?: string;
+  name: string;
+}
+interface EdgeTrackEvent extends EdgeEventBase {
+  type: 'event';
+  event: string;
+}
+interface EdgeFunnelStepEvent extends EdgeEventBase {
+  type: 'funnel-step';
+  funnel: string;
+  status: FunnelStepStatus;
+}
+interface EdgeOutcomeEvent extends EdgeEventBase {
+  type: 'outcome';
+  operation: string;
+  outcome: OutcomeStatus;
+}
+interface EdgeValueEvent extends EdgeEventBase {
+  type: 'value';
+  metric: string;
+  value: number;
+}
+type EdgeEvent = EdgeTrackEvent | EdgeFunnelStepEvent | EdgeOutcomeEvent | EdgeValueEvent;
+type EdgeSubscriber = (event: EdgeEvent) => OrPromise<void>;
+interface FetcherConfig {
+  includeTraceContext?: boolean | ((request: Request) => boolean);
+}
+interface RouteServiceConfig {
+  service: string;
+}
+interface PostProcessParams {
+  /**
+   * The request object that was passed to the fetch handler.
+   */
+  request: Request;
+  /**
+   * The generated response object.
+   */
+  response: Response;
+  /**
+   * A readable version of the span object that can be used to access the span's attributes and events.
+   */
+  readable: ReadableSpan;
+}
+interface FetchHandlerConfig {
+  /**
+   * Whether to enable context propagation for incoming requests to `fetch`.
+   * This enables or disables distributed tracing from W3C Trace Context headers.
+   * @default true
+   */
+  acceptTraceContext?: boolean | ((request: Request) => boolean);
+  /**
+   * Allows further customization of the generated span, based on the request/response data.
+   */
+  postProcess?: (span: Span, ctx: PostProcessParams) => void;
+  /**
+   * Route patterns to include for fetch handler instrumentation.
+   * Supports glob patterns like '/api/**'.
+   * If not set, all routes are included.
+   */
+  include?: string[];
+  /**
+   * Route patterns to exclude from fetch handler instrumentation.
+   * Supports glob patterns like '/health' and '/_internal/**'.
+   * Exclusions take precedence over inclusions.
+   */
+  exclude?: string[];
+  /**
+   * Route-specific service mapping.
+   * The first matching pattern wins based on object iteration order.
+   */
+  routes?: Record<string, RouteServiceConfig>;
+}
+interface HandlerConfig {
+  fetch?: FetchHandlerConfig;
+}
+interface DataSafetyConfig {
+  /** Redact query parameters from URL attributes (default: false) */
+  redactQueryParams?: boolean;
+  /** Control D1 SQL statement capture: 'full' (default), 'obfuscated', or 'off' */
+  captureDbStatement?: 'off' | 'obfuscated' | 'full';
+  /** Only capture these email headers (lowercase). When set, other headers are excluded. */
+  emailHeaderAllowlist?: string[];
+}
+interface EdgeConfigBase {
+  service: ServiceConfig;
+  handlers?: HandlerConfig;
+  fetch?: FetcherConfig;
+  postProcessor?: PostProcessorFn;
+  sampling?: SamplingConfig;
+  propagator?: TextMapPropagator;
+  instrumentation?: InstrumentationOptions;
+  subscribers?: EdgeSubscriber[];
+  /** Opt-in data safety controls for sensitive attribute capture */
+  dataSafety?: DataSafetyConfig;
+}
+interface EdgeConfigExporter extends EdgeConfigBase {
+  exporter: ExporterConfig;
+}
+interface EdgeConfigSpanProcessors extends EdgeConfigBase {
+  spanProcessors: SpanProcessor | SpanProcessor[];
+}
+type EdgeConfig = EdgeConfigExporter | EdgeConfigSpanProcessors;
+interface ResolvedEdgeConfig extends EdgeConfigBase {
+  handlers: Required<HandlerConfig>;
+  fetch: Required<FetcherConfig>;
+  postProcessor: PostProcessorFn;
+  sampling: Required<SamplingConfig<Sampler>>;
+  spanProcessors: SpanProcessor[];
+  propagator: TextMapPropagator;
+  instrumentation: InstrumentationOptions;
+  subscribers: EdgeSubscriber[];
+}
+/**
+ * Function types
+ */
+type ResolveConfigFn<Env = any> = (env: Env, trigger: Trigger) => EdgeConfig;
+type ConfigurationOption = EdgeConfig | ResolveConfigFn;
+type PostProcessorFn = (spans: ReadableSpan[]) => ReadableSpan[];
+type TailSampleFn = (traceInfo: LocalTrace) => boolean;
+interface LocalTrace {
+  traceId: string;
+  spans: ReadableSpan[];
+  localRootSpan: ReadableSpan;
+}
+/**
+ * Span processor with flush support
+ */
+type TraceFlushableSpanProcessor = SpanProcessor & {
+  forceFlush: (traceId?: string) => Promise<void>;
+};
+/**
+ * Handler instrumentation
+ */
+interface InitialSpanInfo {
+  name: string;
+  options: SpanOptions;
+  context?: Context;
+}
+interface HandlerInstrumentation<T extends Trigger, R extends any> {
+  getInitialSpanInfo: (trigger: T) => InitialSpanInfo;
+  getAttributesFromResult?: (result: Awaited<R>) => Attributes;
+  instrumentTrigger?: (trigger: T) => T;
+  executionSucces?: (span: Span, trigger: T, result: Awaited<R>) => void;
+  executionFailed?: (span: Span, trigger: T, error?: any) => void;
+}
+//#endregion
+export { WorkflowTrigger as A, ResolvedEdgeConfig as C, TailSampleFn as D, ServiceConfig as E, TraceFlushableSpanProcessor as O, ResolveConfigFn as S, SamplingConfig as T, OTLPExporterConfig as _, EdgeEvent as a, PostProcessorFn as b, EdgeSubscriber as c, ExporterConfig as d, FunnelStepStatus as f, LocalTrace as g, InstrumentationOptions as h, EdgeConfig as i, Trigger as k, EdgeTrackEvent as l, InitialSpanInfo as m, DOConstructorTrigger as n, EdgeFunnelStepEvent as o, HandlerInstrumentation as p, DataSafetyConfig as r, EdgeOutcomeEvent as s, ConfigurationOption as t, EdgeValueEvent as u, OrPromise as v, RouteServiceConfig as w, ReadableSpan$1 as x, OutcomeStatus as y };
+//# sourceMappingURL=types-HCbsjZzp.d.ts.map

package/dist/types-HCbsjZzp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-HCbsjZzp.d.ts","names":[],"sources":["../src/types.ts"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-edge",
-  "version": "3.16.13",
+  "version": "3.16.15",
   "description": "Vendor-agnostic OpenTelemetry for edge runtimes - foundation for Cloudflare, Vercel, Netlify, Deno",
   "type": "module",
   "main": "./dist/index.js",
@@ -64,11 +64,11 @@
   },
   "devDependencies": {
     "@opentelemetry/context-async-hooks": "^2.7.1",
-    "@types/node": "^25.9.1",
+    "@types/node": "^25.9.2",
     "rimraf": "^6.1.3",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.22.2",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7",
+    "vitest": "^4.1.8",
     "vitest-mock-extended": "^4.0.0"
   },
   "repository": {
@@ -81,8 +81,8 @@
   },
   "homepage": "https://github.com/jagreehal/autotel/tree/main/packages/autotel-edge#readme",
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "eslint src/**/*.ts --fix",
     "type-check": "tsc --noEmit",

package/src/core/buffer.ts

@@ -11,6 +11,7 @@ import { Buffer } from 'node:buffer';
 //@ts-ignore
 globalThis.Buffer = Buffer;
 
-
-
-export {Buffer} from 'node:buffer';
+// Re-export the single imported binding. Importing AND re-exporting `Buffer`
+// from 'node:buffer' separately makes rolldown (tsdown) emit a dangling
+// `Buffer$1` reference, so keep exactly one binding.
+export { Buffer };

package/src/core/provider.context.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { trace } from '@opentelemetry/api';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { SamplingDecision, type SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { WorkerTracerProvider } from './provider';
+
+const noopProcessor: SpanProcessor = {
+  onStart: () => {},
+  onEnd: () => {},
+  shutdown: async () => {},
+  forceFlush: async () => {},
+};
+
+/**
+ * Regression guard for Issue 1.1: register() must register the context manager
+ * with the global OTel API, otherwise the active span is lost after the first
+ * `await` and consumers that resolve trace context from the active span
+ * (autotel-agent / autotel-audit inside a handler or Workflow step) break.
+ *
+ * NOTE: this test registers a global context manager, so it lives in its own
+ * file to avoid leaking that global state into other suites.
+ */
+describe('WorkerTracerProvider global context propagation', () => {
+  it('keeps the active span across an await after register()', async () => {
+    const provider = new WorkerTracerProvider(
+      [noopProcessor],
+      resourceFromAttributes({}),
+    );
+    provider.register();
+
+    // The provider's WorkerTracer needs a head sampler (normally set from config).
+    (
+      provider.getTracer('test') as unknown as {
+        setHeadSampler(s: unknown): void;
+      }
+    ).setHeadSampler({
+      shouldSample: () => ({
+        decision: SamplingDecision.RECORD_AND_SAMPLED,
+        attributes: {},
+        traceState: undefined,
+      }),
+      toString: () => 'AlwaysOn',
+    });
+
+    // Resolve via the global API to prove the global registration took effect.
+    const tracer = trace.getTracer('test');
+
+    await tracer.startActiveSpan('op', async (span) => {
+      // Simulate the async work a handler / step.do() callback performs.
+      await Promise.resolve();
+      expect(trace.getActiveSpan()).toBe(span);
+      span.end();
+    });
+  });
+});