autotel 6.3.0 → 6.4.0

package/dist/{init-BneZ7WJ8.cjs → init-C5V4z7S5.cjs}

@@ -5,6 +5,7 @@ const require_sampling = require('./sampling.cjs');
 const require_node_require = require('./node-require-PFqDihze.cjs');
 const require_tail_sampling_processor = require('./tail-sampling-processor.cjs');
 const require_filtering_span_processor = require('./filtering-span-processor.cjs');
+const require_policy = require('./policy.cjs');
 const require_span_name_normalizer = require('./span-name-normalizer.cjs');
 const require_attribute_redacting_processor = require('./attribute-redacting-processor.cjs');
 const require_pretty_console_exporter = require('./pretty-console-exporter-CMzlrRNg.cjs');
@@ -546,11 +547,15 @@ function getContextStorage() {
 	return contextStorage;
 }
 /**
-* Get the active context, checking our stored context first
-* This ensures baggage setters work with OpenTelemetry's propagation
+* Get the active OTel context with the latest stored baggage overlaid.
+* Span identity always comes from the active OTel scope.
 */
 function getActiveContextWithBaggage() {
-	return contextStorage.getStore()?.value ?? _opentelemetry_api.context.active();
+	const activeContext = _opentelemetry_api.context.active();
+	const stored = contextStorage.getStore()?.value;
+	if (!stored) return activeContext;
+	const storedBaggage = _opentelemetry_api.propagation.getBaggage(stored);
+	return storedBaggage ? _opentelemetry_api.propagation.setBaggage(activeContext, storedBaggage) : activeContext;
 }
 /**
 * Set a value in AsyncLocalStorage, preferring enterWith() when available
@@ -630,15 +635,13 @@ function createTraceContext(span) {
 			return baggage?.getEntry(key)?.value;
 		},
 		setBaggage(key, value) {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const updated = (_opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage()).setEntry(key, { value });
 			updateActiveContext(_opentelemetry_api.propagation.setBaggage(currentContext, updated));
 			return value;
 		},
 		deleteBaggage(key) {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const baggage = _opentelemetry_api.propagation.getBaggage(currentContext);
 			if (baggage) {
 				const updated = baggage.removeEntry(key);
@@ -674,8 +677,7 @@ function createTraceContext(span) {
 			return Object.keys(result).length > 0 ? result : void 0;
 		}),
 		setTypedBaggage: ((namespace, value) => {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			let baggage = _opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage();
 			const prefix = namespace ? `${namespace}.` : "";
 			for (const [key, val] of Object.entries(value)) if (val !== void 0) {
@@ -3179,6 +3181,12 @@ function init(cfg) {
 		for (const subscriber of mergedConfig.subscribers) if (acceptsStringRedactor(subscriber)) subscriber.setStringRedactor(_stringRedactor);
 	}
 	if (mergedConfig.spanNameNormalizer && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new require_span_name_normalizer.SpanNameNormalizingProcessor(processor, { normalizer: mergedConfig.spanNameNormalizer }));
+	if (mergedConfig.policies) {
+		if (typeof mergedConfig.policies === "string") require_policy.watchPolicyFile(mergedConfig.policies);
+		else require_policy.setPolicies(mergedConfig.policies);
+		const userSpanFilter = mergedConfig.spanFilter;
+		mergedConfig.spanFilter = userSpanFilter ? (span) => userSpanFilter(span) && require_policy.policySpanFilter(span) : require_policy.policySpanFilter;
+	}
 	if (mergedConfig.spanFilter && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new require_filtering_span_processor.FilteringSpanProcessor(processor, { filter: mergedConfig.spanFilter }));
 	const metricReaders = [];
 	if (configuredMetricReaders && configuredMetricReaders.length > 0) metricReaders.push(...configuredMetricReaders);
@@ -3217,6 +3225,7 @@ function init(cfg) {
 		logRecordProcessors.push(...posthogProcessors);
 		logger.info({}, "[autotel] PostHog OTLP logs configured");
 	}
+	if (mergedConfig.policies && logRecordProcessors) logRecordProcessors = logRecordProcessors.map((processor) => new require_policy.PolicyLogRecordProcessor(processor));
 	let finalInstrumentations = mergedConfig.instrumentations ? [...mergedConfig.instrumentations] : [];
 	if (mergedConfig.autoInstrumentations !== void 0 && mergedConfig.autoInstrumentations !== false) {
 		if (isESMMode()) logger.info({}, "[autotel] ESM mode detected. For auto-instrumentation to work:\n  1. Install @opentelemetry/auto-instrumentations-node as a direct dependency\n  2. Import autotel/register FIRST in your instrumentation file\n  3. Use getNodeAutoInstrumentations() directly instead of autoInstrumentations\n  See: https://github.com/jagreehal/autotel#esm-setup");

package/dist/{init-CfVWN4ND.d.cts → init-Cc7-vvzj.d.cts}

@@ -3,6 +3,7 @@ import { s as Logger } from "./logger-CN4xpzMd.cjs";
 import { h as SamplingPreset, p as Sampler } from "./sampling-BR9fkSwx.cjs";
 import { a as EventSubscriber } from "./event-subscriber-CWh8sTGh.cjs";
 import { r as SpanFilterPredicate } from "./filtering-span-processor-BpDagWNa.cjs";
+import { r as Policy } from "./policy-CbpP4tFH.cjs";
 import { r as SpanNameNormalizerConfig } from "./span-name-normalizer-CN1-8C76.cjs";
 import { t as CanonicalLogLineOptions } from "./canonical-log-line-processor-B4WgG-VS.cjs";
 import { SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
@@ -959,6 +960,23 @@ interface AutotelConfig {
    * ```
    */
   spanFilter?: SpanFilterPredicate;
+  /**
+   * Telemetry Policies (experimental) — OTEP 4738.
+   *
+   * Portable, fail-open rules deciding what telemetry is kept and how it is
+   * transformed. Pass a path to a `.json` file or a directory of them (reloaded
+   * on change), or an inline array.
+   *
+   * Composes with `spanFilter`: a span must pass both.
+   *
+   * @example
+   * ```typescript
+   * init({ service: 'api', policies: './policies' })
+   * ```
+   *
+   * @see `autotel/policy` for the supported subset of policy stages.
+   */
+  policies?: string | Policy[];
   /**
    * Normalize span names to reduce cardinality from dynamic path segments.
    *

package/dist/{init-C1i2_2zl.d.ts → init-CsODvlau.d.ts}

@@ -3,6 +3,7 @@ import { s as Logger } from "./logger-CN4xpzMd.js";
 import { h as SamplingPreset, p as Sampler } from "./sampling-CP3e7-Yr.js";
 import { a as EventSubscriber } from "./event-subscriber-CWh8sTGh.js";
 import { r as SpanFilterPredicate } from "./filtering-span-processor-BpDagWNa.js";
+import { r as Policy } from "./policy-CbpP4tFH.js";
 import { r as SpanNameNormalizerConfig } from "./span-name-normalizer-CN1-8C76.js";
 import { t as CanonicalLogLineOptions } from "./canonical-log-line-processor-CL_J7gb5.js";
 import { NodeSDK, NodeSDKConfiguration } from "@opentelemetry/sdk-node";
@@ -959,6 +960,23 @@ interface AutotelConfig {
    * ```
    */
   spanFilter?: SpanFilterPredicate;
+  /**
+   * Telemetry Policies (experimental) — OTEP 4738.
+   *
+   * Portable, fail-open rules deciding what telemetry is kept and how it is
+   * transformed. Pass a path to a `.json` file or a directory of them (reloaded
+   * on change), or an inline array.
+   *
+   * Composes with `spanFilter`: a span must pass both.
+   *
+   * @example
+   * ```typescript
+   * init({ service: 'api', policies: './policies' })
+   * ```
+   *
+   * @see `autotel/policy` for the supported subset of policy stages.
+   */
+  policies?: string | Policy[];
   /**
    * Normalize span names to reduce cardinality from dynamic path segments.
    *

package/dist/instrumentation.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_node_require = require('./node-require-PFqDihze.cjs');
-const require_init = require('./init-BneZ7WJ8.cjs');
+const require_init = require('./init-C5V4z7S5.cjs');
 const require_tail_sampling_processor = require('./tail-sampling-processor.cjs');
 let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
 let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");

package/dist/instrumentation.js

@@ -1,5 +1,5 @@
 import { n as safeRequire, t as requireModule } from "./node-require-vROmTeJ8.js";
-import { n as getLogger } from "./init-Qn4gIW1i.js";
+import { n as getLogger } from "./init-C2fjPVkW.js";
 import { TailSamplingSpanProcessor } from "./tail-sampling-processor.js";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";

package/dist/messaging.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_sampling = require('./sampling.cjs');
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 const require_trace_factory_validation = require('./trace-factory-validation-Dc8epn87.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");

package/dist/messaging.js

@@ -1,5 +1,5 @@
 import { createLinkFromHeaders, extractLinksFromBatch } from "./sampling.js";
-import { c as withTracing } from "./functional-DCBhFool.js";
+import { c as withTracing } from "./functional-DbCVvGfT.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { t as assertTraceFactory } from "./trace-factory-validation-BjVAinz6.js";
 import { SpanKind, context, propagation } from "@opentelemetry/api";

package/dist/policy-CbpP4tFH.d.cts

@@ -0,0 +1,147 @@
+import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import { Context } from "@opentelemetry/api";
+import { LogRecordProcessor, SdkLogRecord } from "@opentelemetry/sdk-logs";
+//#region src/policy.d.ts
+/** A path into an attribute. `"ccn"` and `["ccn"]` are equivalent. */
+type AttributePath = string | string[];
+/**
+ * A single ANDed matcher. Exactly one field selector and exactly one match
+ * operator must be set. Regexes are RE2 in the spec but JS `RegExp` here —
+ * see {@link MAX_MATCH_LENGTH}.
+ */
+interface PolicyMatcher {
+  log_field?: string;
+  trace_field?: string;
+  span_attribute?: AttributePath;
+  log_attribute?: AttributePath;
+  resource_attribute?: AttributePath;
+  scope_attribute?: AttributePath;
+  span_kind?: string;
+  span_status?: string;
+  exact?: string;
+  regex?: string;
+  exists?: boolean;
+  starts_with?: string;
+  ends_with?: string;
+  contains?: string;
+  negate?: boolean;
+  case_insensitive?: boolean;
+}
+/** A field targeted by a transform operation. */
+interface PolicyField {
+  log_field?: string;
+  log_attribute?: AttributePath;
+  resource_attribute?: AttributePath;
+  scope_attribute?: AttributePath;
+}
+interface PolicyLogTransform {
+  remove?: PolicyField[];
+  redact?: Array<PolicyField & {
+    replacement?: string;
+  }>;
+  rename?: Array<PolicyField & {
+    to: string;
+    upsert?: boolean;
+  }>;
+  add?: Array<PolicyField & {
+    value: string;
+    upsert?: boolean;
+  }>;
+}
+interface PolicyLogTarget {
+  match: PolicyMatcher[];
+  /** `"all"` (default), `"none"`, or a percentage (`"5.0"` or `5`). */
+  keep?: string | number;
+  transform?: PolicyLogTransform;
+}
+interface PolicyTraceTarget {
+  match: PolicyMatcher[];
+  keep?: {
+    /** 0-100. Omitted means keep all matching spans. */
+    percentage?: number;
+    mode?: string;
+    sampling_precision?: number;
+    hash_seed?: number;
+    fail_closed?: boolean;
+  };
+}
+/** A telemetry policy. Exactly one target must be set. */
+interface Policy {
+  id: string;
+  name?: string;
+  description?: string;
+  enabled?: boolean;
+  labels?: Record<string, string>;
+  trace?: PolicyTraceTarget;
+  log?: PolicyLogTarget;
+  /** Recognised so it can be reported unsupported rather than silently ignored. */
+  metric?: unknown;
+}
+/**
+ * Values longer than this are not regex-matched (the matcher yields no match).
+ *
+ * The spec mandates RE2 for cross-implementation consistency; Node's `RegExp`
+ * backtracks, so an untrusted log body plus a pathological pattern is a DoS.
+ * Capping input bounds the damage without pulling in an RE2 binding.
+ *
+ * ponytail: length cap instead of a real RE2 engine — swap in a linear-time
+ * matcher if policies ever run against fully untrusted patterns.
+ */
+declare const MAX_MATCH_LENGTH = 4096;
+/**
+ * Returns a reason string if the policy cannot be applied, or undefined if it can.
+ *
+ * Per spec an implementation MAY support a subset of stages but MUST skip the
+ * policy — never the telemetry — when it meets one it does not understand.
+ */
+declare function unsupportedReason(policy: Policy): string | undefined;
+/**
+ * Replace the active policy set.
+ *
+ * Disabled policies are dropped (spec: they MUST be treated as if they do not
+ * exist) and unsupported ones are skipped with a warning.
+ */
+declare function setPolicies(policies: Policy[]): void;
+/** The currently active (validated, enabled) policies. */
+declare function getPolicies(): readonly Policy[];
+declare function clearPolicies(): void;
+/**
+ * A `SpanFilterPredicate` backed by the active policies. Returns true to keep.
+ *
+ * Fail-open: any error keeps the span.
+ */
+declare function policySpanFilter(span: ReadableSpan): boolean;
+/**
+ * Applies `log` policies — keep first, then transform (spec stage order).
+ *
+ * Fail-open: any error emits the record unmodified.
+ */
+declare class PolicyLogRecordProcessor implements LogRecordProcessor {
+  private readonly wrapped;
+  constructor(wrapped: LogRecordProcessor);
+  onEmit(logRecord: SdkLogRecord, context?: Context): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+/** True when any active policy targets logs — used to skip wrapping otherwise. */
+declare function hasLogPolicies(): boolean;
+/**
+ * Load every policy from a `.json` file, or from every `.json` file in a
+ * directory.
+ *
+ * Fail-open: an unreadable or malformed file yields no policies from that file
+ * and warns; it never throws.
+ */
+declare function loadPolicies(target: string): Policy[];
+/**
+ * The file policy provider: load `target` now and reload on change.
+ *
+ * Policies are expected to change outside the lifecycle of the process, so the
+ * watcher is what makes them dynamic. The watcher is unref'd — it never holds
+ * the process open.
+ *
+ * @returns a function that stops watching
+ */
+declare function watchPolicyFile(target: string): () => void;
+//#endregion
+export { watchPolicyFile as _, PolicyLogRecordProcessor as a, PolicyMatcher as c, getPolicies as d, hasLogPolicies as f, unsupportedReason as g, setPolicies as h, PolicyField as i, PolicyTraceTarget as l, policySpanFilter as m, MAX_MATCH_LENGTH as n, PolicyLogTarget as o, loadPolicies as p, Policy as r, PolicyLogTransform as s, AttributePath as t, clearPolicies as u };

package/dist/policy-CbpP4tFH.d.ts

@@ -0,0 +1,147 @@
+import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import { Context } from "@opentelemetry/api";
+import { LogRecordProcessor, SdkLogRecord } from "@opentelemetry/sdk-logs";
+//#region src/policy.d.ts
+/** A path into an attribute. `"ccn"` and `["ccn"]` are equivalent. */
+type AttributePath = string | string[];
+/**
+ * A single ANDed matcher. Exactly one field selector and exactly one match
+ * operator must be set. Regexes are RE2 in the spec but JS `RegExp` here —
+ * see {@link MAX_MATCH_LENGTH}.
+ */
+interface PolicyMatcher {
+  log_field?: string;
+  trace_field?: string;
+  span_attribute?: AttributePath;
+  log_attribute?: AttributePath;
+  resource_attribute?: AttributePath;
+  scope_attribute?: AttributePath;
+  span_kind?: string;
+  span_status?: string;
+  exact?: string;
+  regex?: string;
+  exists?: boolean;
+  starts_with?: string;
+  ends_with?: string;
+  contains?: string;
+  negate?: boolean;
+  case_insensitive?: boolean;
+}
+/** A field targeted by a transform operation. */
+interface PolicyField {
+  log_field?: string;
+  log_attribute?: AttributePath;
+  resource_attribute?: AttributePath;
+  scope_attribute?: AttributePath;
+}
+interface PolicyLogTransform {
+  remove?: PolicyField[];
+  redact?: Array<PolicyField & {
+    replacement?: string;
+  }>;
+  rename?: Array<PolicyField & {
+    to: string;
+    upsert?: boolean;
+  }>;
+  add?: Array<PolicyField & {
+    value: string;
+    upsert?: boolean;
+  }>;
+}
+interface PolicyLogTarget {
+  match: PolicyMatcher[];
+  /** `"all"` (default), `"none"`, or a percentage (`"5.0"` or `5`). */
+  keep?: string | number;
+  transform?: PolicyLogTransform;
+}
+interface PolicyTraceTarget {
+  match: PolicyMatcher[];
+  keep?: {
+    /** 0-100. Omitted means keep all matching spans. */
+    percentage?: number;
+    mode?: string;
+    sampling_precision?: number;
+    hash_seed?: number;
+    fail_closed?: boolean;
+  };
+}
+/** A telemetry policy. Exactly one target must be set. */
+interface Policy {
+  id: string;
+  name?: string;
+  description?: string;
+  enabled?: boolean;
+  labels?: Record<string, string>;
+  trace?: PolicyTraceTarget;
+  log?: PolicyLogTarget;
+  /** Recognised so it can be reported unsupported rather than silently ignored. */
+  metric?: unknown;
+}
+/**
+ * Values longer than this are not regex-matched (the matcher yields no match).
+ *
+ * The spec mandates RE2 for cross-implementation consistency; Node's `RegExp`
+ * backtracks, so an untrusted log body plus a pathological pattern is a DoS.
+ * Capping input bounds the damage without pulling in an RE2 binding.
+ *
+ * ponytail: length cap instead of a real RE2 engine — swap in a linear-time
+ * matcher if policies ever run against fully untrusted patterns.
+ */
+declare const MAX_MATCH_LENGTH = 4096;
+/**
+ * Returns a reason string if the policy cannot be applied, or undefined if it can.
+ *
+ * Per spec an implementation MAY support a subset of stages but MUST skip the
+ * policy — never the telemetry — when it meets one it does not understand.
+ */
+declare function unsupportedReason(policy: Policy): string | undefined;
+/**
+ * Replace the active policy set.
+ *
+ * Disabled policies are dropped (spec: they MUST be treated as if they do not
+ * exist) and unsupported ones are skipped with a warning.
+ */
+declare function setPolicies(policies: Policy[]): void;
+/** The currently active (validated, enabled) policies. */
+declare function getPolicies(): readonly Policy[];
+declare function clearPolicies(): void;
+/**
+ * A `SpanFilterPredicate` backed by the active policies. Returns true to keep.
+ *
+ * Fail-open: any error keeps the span.
+ */
+declare function policySpanFilter(span: ReadableSpan): boolean;
+/**
+ * Applies `log` policies — keep first, then transform (spec stage order).
+ *
+ * Fail-open: any error emits the record unmodified.
+ */
+declare class PolicyLogRecordProcessor implements LogRecordProcessor {
+  private readonly wrapped;
+  constructor(wrapped: LogRecordProcessor);
+  onEmit(logRecord: SdkLogRecord, context?: Context): void;
+  shutdown(): Promise<void>;
+  forceFlush(): Promise<void>;
+}
+/** True when any active policy targets logs — used to skip wrapping otherwise. */
+declare function hasLogPolicies(): boolean;
+/**
+ * Load every policy from a `.json` file, or from every `.json` file in a
+ * directory.
+ *
+ * Fail-open: an unreadable or malformed file yields no policies from that file
+ * and warns; it never throws.
+ */
+declare function loadPolicies(target: string): Policy[];
+/**
+ * The file policy provider: load `target` now and reload on change.
+ *
+ * Policies are expected to change outside the lifecycle of the process, so the
+ * watcher is what makes them dynamic. The watcher is unref'd — it never holds
+ * the process open.
+ *
+ * @returns a function that stops watching
+ */
+declare function watchPolicyFile(target: string): () => void;
+//#endregion
+export { watchPolicyFile as _, PolicyLogRecordProcessor as a, PolicyMatcher as c, getPolicies as d, hasLogPolicies as f, unsupportedReason as g, setPolicies as h, PolicyField as i, PolicyTraceTarget as l, policySpanFilter as m, MAX_MATCH_LENGTH as n, PolicyLogTarget as o, loadPolicies as p, Policy as r, PolicyLogTransform as s, AttributePath as t, clearPolicies as u };

package/dist/policy.d.cts

@@ -0,0 +1,2 @@
+import { _ as watchPolicyFile, a as PolicyLogRecordProcessor, c as PolicyMatcher, d as getPolicies, f as hasLogPolicies, g as unsupportedReason, h as setPolicies, i as PolicyField, l as PolicyTraceTarget, m as policySpanFilter, n as MAX_MATCH_LENGTH, o as PolicyLogTarget, p as loadPolicies, r as Policy, s as PolicyLogTransform, t as AttributePath, u as clearPolicies } from "./policy-CbpP4tFH.cjs";
+export { AttributePath, MAX_MATCH_LENGTH, Policy, PolicyField, PolicyLogRecordProcessor, PolicyLogTarget, PolicyLogTransform, PolicyMatcher, PolicyTraceTarget, clearPolicies, getPolicies, hasLogPolicies, loadPolicies, policySpanFilter, setPolicies, unsupportedReason, watchPolicyFile };

package/dist/policy.d.ts

@@ -0,0 +1,2 @@
+import { _ as watchPolicyFile, a as PolicyLogRecordProcessor, c as PolicyMatcher, d as getPolicies, f as hasLogPolicies, g as unsupportedReason, h as setPolicies, i as PolicyField, l as PolicyTraceTarget, m as policySpanFilter, n as MAX_MATCH_LENGTH, o as PolicyLogTarget, p as loadPolicies, r as Policy, s as PolicyLogTransform, t as AttributePath, u as clearPolicies } from "./policy-CbpP4tFH.js";
+export { AttributePath, MAX_MATCH_LENGTH, Policy, PolicyField, PolicyLogRecordProcessor, PolicyLogTarget, PolicyLogTransform, PolicyMatcher, PolicyTraceTarget, clearPolicies, getPolicies, hasLogPolicies, loadPolicies, policySpanFilter, setPolicies, unsupportedReason, watchPolicyFile };

package/dist/semantic-helpers.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_trace_factory_validation = require('./trace-factory-validation-Dc8epn87.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 

package/dist/semantic-helpers.js

@@ -1,4 +1,4 @@
-import { c as withTracing } from "./functional-DCBhFool.js";
+import { c as withTracing } from "./functional-DbCVvGfT.js";
 import { t as assertTraceFactory } from "./trace-factory-validation-BjVAinz6.js";
 import { SpanKind } from "@opentelemetry/api";
 

package/dist/webhook.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_structured_error = require('./structured-error-CHg7DoIQ.cjs');
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 

package/dist/webhook.js

@@ -1,5 +1,5 @@
 import { r as recordStructuredError } from "./structured-error-9--cxBay.js";
-import { c as withTracing } from "./functional-DCBhFool.js";
+import { c as withTracing } from "./functional-DbCVvGfT.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { SpanKind, trace } from "@opentelemetry/api";
 

package/dist/workflow-distributed.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 const require_business_baggage = require('./business-baggage.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");

package/dist/workflow-distributed.js

@@ -1,4 +1,4 @@
-import { c as withTracing } from "./functional-DCBhFool.js";
+import { c as withTracing } from "./functional-DbCVvGfT.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { createSafeBaggageSchema } from "./business-baggage.js";
 import { SpanKind, context, propagation } from "@opentelemetry/api";

package/dist/workflow.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_trace_helpers = require('./trace-helpers.cjs');
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 const require_trace_factory_validation = require('./trace-factory-validation-Dc8epn87.cjs');
 let node_async_hooks = require("node:async_hooks");

package/dist/workflow.js

@@ -1,5 +1,5 @@
 import { getActiveSpan } from "./trace-helpers.js";
-import { c as withTracing } from "./functional-DCBhFool.js";
+import { c as withTracing } from "./functional-DbCVvGfT.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { t as assertTraceFactory } from "./trace-factory-validation-BjVAinz6.js";
 import * as nodeAsyncHooks from "node:async_hooks";

package/dist/yaml-config.cjs

@@ -122,6 +122,7 @@ function yamlToAutotelConfig(yaml) {
 	if (yaml.exporter?.destinations) config.destinations = yaml.exporter.destinations;
 	if (yaml.resource) config.resourceAttributes = yaml.resource;
 	if (yaml.autoInstrumentations) config.autoInstrumentations = yaml.autoInstrumentations;
+	if (yaml.policies) config.policies = yaml.policies;
 	if (yaml.debug !== void 0) config.debug = yaml.debug;
 	if (yaml.sampling?.preset) {
 		warnOnIgnoredPresetOverrides(yaml.sampling);

package/dist/yaml-config.d.cts

@@ -1,5 +1,5 @@
 import { h as SamplingPreset } from "./sampling-BR9fkSwx.cjs";
-import { a as AutotelConfig, o as OtlpSignal } from "./init-CfVWN4ND.cjs";
+import { a as AutotelConfig, o as OtlpSignal } from "./init-Cc7-vvzj.cjs";
 //#region src/yaml-config.d.ts
 /**
  * YAML config structure
@@ -35,6 +35,8 @@ interface YamlConfig {
   autoInstrumentations?: string[] | Record<string, {
     enabled?: boolean;
   }>;
+  /** Path to a policy `.json` file or a directory of them (OTEP 4738). */
+  policies?: string;
   debug?: boolean;
 }
 /**

package/dist/yaml-config.d.ts

@@ -1,5 +1,5 @@
 import { h as SamplingPreset } from "./sampling-CP3e7-Yr.js";
-import { a as AutotelConfig, o as OtlpSignal } from "./init-C1i2_2zl.js";
+import { a as AutotelConfig, o as OtlpSignal } from "./init-CsODvlau.js";
 //#region src/yaml-config.d.ts
 /**
  * YAML config structure
@@ -35,6 +35,8 @@ interface YamlConfig {
   autoInstrumentations?: string[] | Record<string, {
     enabled?: boolean;
   }>;
+  /** Path to a policy `.json` file or a directory of them (OTEP 4738). */
+  policies?: string;
   debug?: boolean;
 }
 /**

package/dist/yaml-config.js

@@ -118,6 +118,7 @@ function yamlToAutotelConfig(yaml) {
 	if (yaml.exporter?.destinations) config.destinations = yaml.exporter.destinations;
 	if (yaml.resource) config.resourceAttributes = yaml.resource;
 	if (yaml.autoInstrumentations) config.autoInstrumentations = yaml.autoInstrumentations;
+	if (yaml.policies) config.policies = yaml.policies;
 	if (yaml.debug !== void 0) config.debug = yaml.debug;
 	if (yaml.sampling?.preset) {
 		warnOnIgnoredPresetOverrides(yaml.sampling);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Write Once, Observe Anywhere",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -110,6 +110,11 @@
       "import": "./dist/filtering-span-processor.js",
       "require": "./dist/filtering-span-processor.cjs"
     },
+    "./policy": {
+      "types": "./dist/policy.d.ts",
+      "import": "./dist/policy.js",
+      "require": "./dist/policy.cjs"
+    },
     "./span-name-normalizer": {
       "types": "./dist/span-name-normalizer.d.ts",
       "import": "./dist/span-name-normalizer.js",