@zudojs/observability 0.1.0 → 1.0.1

package/dist/processor/processor.log.js

@@ -0,0 +1,119 @@
+/**
+ * @zudojs/observability — Log Processor
+ *
+ * Buffers log records and hands them to an exporter in batches.
+ *
+ * A logger writes synchronously and cannot await anything, so the naive
+ * bridge — `void exporter.export([record])` — exports one record per line and
+ * turns any exporter rejection into an unhandled rejection, which ends the
+ * process under Node's default. This transport is that bridge done properly:
+ * bounded queue, batched export, errors reported, and a `flush()` that
+ * shutdown can await so the last records are not lost.
+ */
+const DEFAULT_BATCH_SIZE = 256;
+const DEFAULT_FLUSH_INTERVAL_MS = 1_000;
+const DEFAULT_MAX_QUEUE_SIZE = 4_096;
+/** A {@link LogTransport} that batches records into a {@link LogExporter}. */
+export class BatchLogProcessor {
+    name = "batch";
+    exporter;
+    batchSize;
+    flushIntervalMs;
+    maxQueueSize;
+    onError;
+    onDrop;
+    buffer = [];
+    timer;
+    shuttingDown = false;
+    inFlight;
+    droppedRecords = 0;
+    constructor(options) {
+        this.exporter = options.exporter;
+        this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+        this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+        this.maxQueueSize = Math.max(options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE, this.batchSize);
+        this.onError = options.onError;
+        this.onDrop = options.onDrop;
+    }
+    write(record) {
+        if (this.shuttingDown)
+            return;
+        if (this.buffer.length >= this.maxQueueSize) {
+            this.droppedRecords++;
+            this.onDrop?.(this.droppedRecords);
+            return;
+        }
+        this.buffer.push(record);
+        if (this.buffer.length >= this.batchSize) {
+            void this.flush();
+            return;
+        }
+        this.startTimer();
+    }
+    startTimer() {
+        if (this.timer !== undefined || this.shuttingDown)
+            return;
+        this.timer = setInterval(() => {
+            if (this.buffer.length === 0) {
+                this.stopTimer();
+                return;
+            }
+            void this.flush();
+        }, this.flushIntervalMs);
+        if (typeof this.timer === "object" && "unref" in this.timer) {
+            this.timer.unref();
+        }
+    }
+    stopTimer() {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+    }
+    /** Records dropped because the queue was full. */
+    getDroppedCount() {
+        return this.droppedRecords;
+    }
+    /** Records currently queued. */
+    getQueueSize() {
+        return this.buffer.length;
+    }
+    async flush() {
+        if (this.inFlight) {
+            await this.inFlight;
+            if (this.buffer.length === 0)
+                return;
+        }
+        const run = this.drain();
+        this.inFlight = run;
+        try {
+            await run;
+        }
+        finally {
+            if (this.inFlight === run)
+                this.inFlight = undefined;
+        }
+    }
+    async drain() {
+        while (this.buffer.length > 0) {
+            const batch = this.buffer.splice(0, this.batchSize);
+            try {
+                await this.exporter.export(batch);
+            }
+            catch (error) {
+                this.onError?.(error, "LogExporter.export");
+            }
+        }
+    }
+    async shutdown() {
+        this.shuttingDown = true;
+        this.stopTimer();
+        await this.flush();
+        await this.exporter.shutdown();
+    }
+}
+/** Creates a batching log transport. */
+export function createBatchLogProcessor(options) {
+    return new BatchLogProcessor(options);
+}
+//# sourceMappingURL=processor.log.js.map

package/dist/propagation/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Context propagation with AsyncLocalStorage for request-scoped IDs.
  */
-export { createPropagationContext, derivePropagationContext, getCurrentContext, AsyncPropagationManager, createPropagationManager, } from "./propagation.core.js";
+export { createPropagationContext, derivePropagationContext, getCurrentContext, requireCurrentContext, AsyncPropagationManager, createPropagationManager, } from "./propagation.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/propagation/index.js

@@ -3,5 +3,5 @@
  *
  * Context propagation with AsyncLocalStorage for request-scoped IDs.
  */
-export { createPropagationContext, derivePropagationContext, getCurrentContext, AsyncPropagationManager, createPropagationManager, } from "./propagation.core.js";
+export { createPropagationContext, derivePropagationContext, getCurrentContext, requireCurrentContext, AsyncPropagationManager, createPropagationManager, } from "./propagation.core.js";
 //# sourceMappingURL=index.js.map

package/dist/propagation/propagation.core.d.ts

@@ -7,17 +7,37 @@
 import type { PropagationContext, PropagationContextOptions, PropagationManager } from "../types.js";
 /** Creates a new propagation context. */
 export declare function createPropagationContext(options?: PropagationContextOptions): PropagationContext;
-/** Derives a child context from a parent. */
-export declare function derivePropagationContext(parent: PropagationContext, overrides?: Partial<PropagationContextOptions>): PropagationContext;
-/** Gets the current propagation context. */
-export declare function getCurrentContext(): PropagationContext;
+/**
+ * Derives a child context from a parent.
+ *
+ * The trace ID, the sampling flags and the baggage all carry over: a child
+ * that dropped the flags would break the sampling decision for everything
+ * below it.
+ */
+export declare function derivePropagationContext(parent: PropagationContext, overrides?: PropagationContextOptions): PropagationContext;
+/**
+ * The active propagation context, or `undefined` when there is none.
+ *
+ * Returning `undefined` rather than inventing a context keeps "no active
+ * trace" distinguishable from a real one — two calls outside a `run()` scope
+ * used to hand back two unrelated trace IDs.
+ */
+export declare function getCurrentContext(): PropagationContext | undefined;
+/**
+ * The active propagation context, creating a fresh one when there is none.
+ *
+ * Use this only where a context is genuinely required and a new trace is an
+ * acceptable answer.
+ */
+export declare function requireCurrentContext(): PropagationContext;
 /**
  * PropagationManager implementation using AsyncLocalStorage.
  */
 export declare class AsyncPropagationManager implements PropagationManager {
-    current(): PropagationContext;
+    current(): PropagationContext | undefined;
     run<T>(context: PropagationContext, fn: () => T | Promise<T>): Promise<T>;
-    derive(overrides?: Partial<PropagationContextOptions>): PropagationContext;
+    runSync<T>(context: PropagationContext, fn: () => T): T;
+    derive(overrides?: PropagationContextOptions): PropagationContext;
 }
 /** Creates a propagation manager. */
 export declare function createPropagationManager(): AsyncPropagationManager;

package/dist/propagation/propagation.core.js

@@ -5,50 +5,61 @@
  * trace, span, request, and correlation IDs.
  */
 import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
+import { generateSpanId, generateTraceId } from "../internal/index.js";
 const storage = new AsyncLocalStorage();
-/** Generates a random hex ID. */
-function generateId(byteLength = 16) {
-    const bytes = new Uint8Array(byteLength);
-    for (let i = 0; i < byteLength; i++) {
-        bytes[i] = Math.floor(Math.random() * 256);
-    }
-    return Array.from(bytes)
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("");
-}
 /** Creates a new propagation context. */
 export function createPropagationContext(options) {
-    const traceId = options?.traceId ?? generateId(16);
-    const spanId = options?.spanId ?? generateId(8);
     return {
-        traceId,
-        spanId,
+        traceId: options?.traceId ?? generateTraceId(),
+        spanId: options?.spanId ?? generateSpanId(),
         parentSpanId: options?.parentSpanId,
         requestId: options?.requestId,
         correlationId: options?.correlationId,
         userId: options?.userId,
         service: options?.service,
+        traceFlags: options?.traceFlags,
         baggage: options?.baggage
             ? Object.freeze({ ...options.baggage })
             : undefined,
     };
 }
-/** Derives a child context from a parent. */
+/**
+ * Derives a child context from a parent.
+ *
+ * The trace ID, the sampling flags and the baggage all carry over: a child
+ * that dropped the flags would break the sampling decision for everything
+ * below it.
+ */
 export function derivePropagationContext(parent, overrides) {
     return createPropagationContext({
         traceId: overrides?.traceId ?? parent.traceId,
-        spanId: overrides?.spanId ?? generateId(8),
+        spanId: overrides?.spanId ?? generateSpanId(),
         parentSpanId: parent.spanId,
         requestId: overrides?.requestId ?? parent.requestId,
         correlationId: overrides?.correlationId ?? parent.correlationId,
         userId: overrides?.userId ?? parent.userId,
         service: overrides?.service ?? parent.service,
+        traceFlags: overrides?.traceFlags ?? parent.traceFlags,
         baggage: overrides?.baggage ?? parent.baggage,
     });
 }
-/** Gets the current propagation context. */
+/**
+ * The active propagation context, or `undefined` when there is none.
+ *
+ * Returning `undefined` rather than inventing a context keeps "no active
+ * trace" distinguishable from a real one — two calls outside a `run()` scope
+ * used to hand back two unrelated trace IDs.
+ */
 export function getCurrentContext() {
+    return storage.getStore();
+}
+/**
+ * The active propagation context, creating a fresh one when there is none.
+ *
+ * Use this only where a context is genuinely required and a new trace is an
+ * acceptable answer.
+ */
+export function requireCurrentContext() {
     return storage.getStore() ?? createPropagationContext();
 }
 /**
@@ -61,9 +72,14 @@ export class AsyncPropagationManager {
     async run(context, fn) {
         return storage.run(context, fn);
     }
+    runSync(context, fn) {
+        return storage.run(context, fn);
+    }
     derive(overrides) {
         const current = this.current();
-        return derivePropagationContext(current, overrides);
+        return current
+            ? derivePropagationContext(current, overrides)
+            : createPropagationContext(overrides);
     }
 }
 /** Creates a propagation manager. */

package/dist/redaction/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Sensitive field redaction for logs and traces.
  */
-export { createRedactor, redactObject, isSensitiveField, } from "./redaction.core.js";
+export { createRedactor, createStructureRedactor, redactObject, redactValue, isSensitiveField, DEFAULT_SENSITIVE_FIELDS, CIRCULAR_MARKER, MAX_DEPTH_MARKER, } from "./redaction.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/redaction/index.js

@@ -3,5 +3,5 @@
  *
  * Sensitive field redaction for logs and traces.
  */
-export { createRedactor, redactObject, isSensitiveField, } from "./redaction.core.js";
+export { createRedactor, createStructureRedactor, redactObject, redactValue, isSensitiveField, DEFAULT_SENSITIVE_FIELDS, CIRCULAR_MARKER, MAX_DEPTH_MARKER, } from "./redaction.core.js";
 //# sourceMappingURL=index.js.map

package/dist/redaction/redaction.core.d.ts

@@ -2,18 +2,53 @@
  * @zudojs/observability — Redaction
  *
  * Redacts sensitive fields from log contexts and trace attributes.
- * Never automatically dumps passwords, tokens, cookies, or auth headers.
+ *
+ * The rules that make this safe rather than decorative:
+ *   - arrays are traversed, because secrets usually arrive inside one
+ *     (`headers: [{ authorization: "Bearer …" }]`);
+ *   - traversal is cycle-aware and depth-capped, because a request object in
+ *     a log context is a graph, not a tree;
+ *   - built-ins such as `Error`, `Date`, `Map` and `Set` are left intact
+ *     instead of collapsing to `{}`, while an instance of a user-defined
+ *     class is walked like a plain object — its own fields are what an
+ *     exporter serializes, so a DTO carrying a `password` must not slip
+ *     past the field list;
+ *   - matching is substring-based by default, so `userPassword` and
+ *     `x-api-key` are caught, not just the exact names in the list.
  */
 import type { RedactionConfig } from "../types.js";
+/** Default sensitive field names, matched case-insensitively. */
+export declare const DEFAULT_SENSITIVE_FIELDS: readonly string[];
+/** Marker used in place of a structure that was too deep or already seen. */
+export declare const CIRCULAR_MARKER = "[CIRCULAR]";
+export declare const MAX_DEPTH_MARKER = "[MAX_DEPTH]";
 /**
- * Creates a redactor that replaces sensitive values in objects.
+ * Creates a redactor that replaces sensitive values for a single field.
+ *
+ * This is the leaf-level decision. Use {@link redactObject} to walk a
+ * structure — it applies this to every field it reaches.
  */
 export declare function createRedactor(config?: RedactionConfig): (key: string, value: unknown) => unknown;
 /**
- * Redacts sensitive fields from a plain object.
- * Returns a new object with sensitive values replaced.
+ * Redacts sensitive fields from a structure.
+ *
+ * Returns a new value; the input is never mutated. Arrays are traversed,
+ * cycles become {@link CIRCULAR_MARKER}, and anything deeper than
+ * `maxDepth` becomes {@link MAX_DEPTH_MARKER}.
  */
 export declare function redactObject<T extends Record<string, unknown>>(obj: T, config?: RedactionConfig): T;
-/** Checks if a field name is sensitive. */
+/**
+ * Redacts any value, not just a plain object — an array of headers, a scalar,
+ * a nested mix.
+ */
+export declare function redactValue(value: unknown, config?: RedactionConfig): unknown;
+/** Checks if a field name is sensitive under the given configuration. */
 export declare function isSensitiveField(fieldName: string, config?: RedactionConfig): boolean;
+/**
+ * Compiles a configuration once into a reusable structure redactor.
+ *
+ * Prefer this on a hot path: {@link redactObject} recompiles the field
+ * matcher on every call.
+ */
+export declare function createStructureRedactor(config?: RedactionConfig): (value: unknown) => unknown;
 //# sourceMappingURL=redaction.core.d.ts.map

package/dist/redaction/redaction.core.js

@@ -2,66 +2,251 @@
  * @zudojs/observability — Redaction
  *
  * Redacts sensitive fields from log contexts and trace attributes.
- * Never automatically dumps passwords, tokens, cookies, or auth headers.
+ *
+ * The rules that make this safe rather than decorative:
+ *   - arrays are traversed, because secrets usually arrive inside one
+ *     (`headers: [{ authorization: "Bearer …" }]`);
+ *   - traversal is cycle-aware and depth-capped, because a request object in
+ *     a log context is a graph, not a tree;
+ *   - built-ins such as `Error`, `Date`, `Map` and `Set` are left intact
+ *     instead of collapsing to `{}`, while an instance of a user-defined
+ *     class is walked like a plain object — its own fields are what an
+ *     exporter serializes, so a DTO carrying a `password` must not slip
+ *     past the field list;
+ *   - matching is substring-based by default, so `userPassword` and
+ *     `x-api-key` are caught, not just the exact names in the list.
  */
-/** Default sensitive field names. */
-const DEFAULT_SENSITIVE_FIELDS = [
+/** Default sensitive field names, matched case-insensitively. */
+export const DEFAULT_SENSITIVE_FIELDS = [
     "password",
+    "passwd",
     "secret",
     "token",
     "authorization",
+    "auth",
     "cookie",
+    "session",
+    "credential",
+    "api_key",
+    "apikey",
     "access_token",
     "refresh_token",
-    "api_key",
-    "apiKey",
-    "accessToken",
-    "refreshToken",
+    "private_key",
+    "client_secret",
     "credit_card",
-    "creditCard",
+    "creditcard",
+    "card_number",
+    "cardnumber",
+    "cvv",
     "ssn",
     "social_security",
+    "pin",
+    "otp",
 ];
 const DEFAULT_REPLACEMENT = "[REDACTED]";
+const DEFAULT_MAX_DEPTH = 8;
+/** Marker used in place of a structure that was too deep or already seen. */
+export const CIRCULAR_MARKER = "[CIRCULAR]";
+export const MAX_DEPTH_MARKER = "[MAX_DEPTH]";
 /**
- * Creates a redactor that replaces sensitive values in objects.
+ * Splits a field name into its lowercase words.
+ *
+ * `x-api-key`, `api_key` and `apiKey` all reduce to `["api", "key"]`, and a
+ * digit run is its own word so `token2` yields `["token", "2"]`.
  */
-export function createRedactor(config) {
-    const fields = new Set((config?.fields ?? DEFAULT_SENSITIVE_FIELDS).map((f) => f.toLowerCase()));
-    const replacement = config?.replacement ?? DEFAULT_REPLACEMENT;
-    const customRedactor = config?.customRedactor;
-    return (key, value) => {
-        if (customRedactor) {
-            const result = customRedactor(key, value);
-            if (result !== value)
-                return result;
+function words(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/([a-zA-Z])([0-9])/g, "$1 $2")
+        .replace(/([0-9])([a-zA-Z])/g, "$1 $2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+/**
+ * Every run of consecutive words in `key`, joined.
+ *
+ * Matching on these rather than on a raw substring is what keeps
+ * `shippingAddress` out of the `pin` rule and `authorId` out of the `auth`
+ * rule, while still catching `userPassword`, `x-api-key` and `accessToken`.
+ * A plain `normalized.includes(field)` test redacts every one of those — a
+ * silent, permanent loss of legitimate log data that looks exactly like the
+ * field never being logged.
+ */
+function wordJoins(key) {
+    const parts = words(key);
+    const joins = [];
+    for (let start = 0; start < parts.length; start++) {
+        let joined = "";
+        for (let end = start; end < parts.length; end++) {
+            joined += parts[end] ?? "";
+            joins.push(joined);
         }
-        if (fields.has(key.toLowerCase())) {
-            return replacement;
+    }
+    return joins;
+}
+function compile(config) {
+    const fields = (config?.fields ?? DEFAULT_SENSITIVE_FIELDS).map((field) => field.toLowerCase());
+    const patterns = config?.patterns ?? [];
+    const matchMode = config?.matchMode ?? "contains";
+    const exact = new Set(fields);
+    const normalizedFields = new Set(fields.map((field) => field.replace(/[^a-z0-9]/g, "")).filter(Boolean));
+    const isSensitive = (key) => {
+        const lower = key.toLowerCase();
+        if (exact.has(lower))
+            return true;
+        if (matchMode === "contains") {
+            for (const candidate of wordJoins(key)) {
+                if (normalizedFields.has(candidate))
+                    return true;
+                // Tolerate a plural: `passwords` is the `password` field.
+                if (candidate.endsWith("s") &&
+                    normalizedFields.has(candidate.slice(0, -1))) {
+                    return true;
+                }
+            }
         }
-        return value;
+        for (const pattern of patterns) {
+            pattern.lastIndex = 0;
+            if (pattern.test(key))
+                return true;
+        }
+        return false;
+    };
+    return {
+        isSensitive,
+        replacement: config?.replacement ?? DEFAULT_REPLACEMENT,
+        maxDepth: config?.maxDepth ?? DEFAULT_MAX_DEPTH,
+        customRedactor: config?.customRedactor,
     };
 }
 /**
- * Redacts sensitive fields from a plain object.
- * Returns a new object with sensitive values replaced.
+ * Creates a redactor that replaces sensitive values for a single field.
+ *
+ * This is the leaf-level decision. Use {@link redactObject} to walk a
+ * structure — it applies this to every field it reaches.
  */
-export function redactObject(obj, config) {
-    const redactor = createRedactor(config);
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-            result[key] = redactObject(value, config);
-        }
-        else {
-            result[key] = redactor(key, value);
+export function createRedactor(config) {
+    const compiled = compile(config);
+    return (key, value) => redactField(key, value, compiled);
+}
+function redactField(key, value, compiled) {
+    if (compiled.customRedactor) {
+        const result = compiled.customRedactor(key, value);
+        if (result !== value)
+            return result;
+    }
+    if (compiled.isSensitive(key))
+        return compiled.replacement;
+    return value;
+}
+/** True when a value should be walked rather than treated as a leaf. */
+function isPlainContainer(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Built-ins whose contents are not key/value fields: they are left intact
+ * rather than walked, because rebuilding them field by field would collapse
+ * a `Date` or a `Map` to `{}`.
+ */
+function isOpaqueBuiltin(value) {
+    return (value instanceof Date ||
+        value instanceof RegExp ||
+        value instanceof Error ||
+        value instanceof Map ||
+        value instanceof Set ||
+        value instanceof WeakMap ||
+        value instanceof WeakSet ||
+        value instanceof Promise ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value) ||
+        value instanceof Number ||
+        value instanceof String ||
+        value instanceof Boolean ||
+        (typeof URL !== "undefined" && value instanceof URL) ||
+        (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams));
+}
+/**
+ * True for an instance of a user-defined class (a DTO, a request model).
+ *
+ * Its own enumerable fields are exactly what `JSON.stringify` — and so every
+ * exporter — writes out, so a `password` field on a class instance leaked
+ * through a redactor that only walked plain objects. Such an instance is
+ * walked like a plain object and rebuilt on the same prototype, so
+ * `instanceof` and any `toJSON` it defines survive.
+ */
+function isWalkableInstance(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (Array.isArray(value) || isPlainContainer(value))
+        return false;
+    if (isOpaqueBuiltin(value))
+        return false;
+    return Object.keys(value).length > 0;
+}
+function walk(value, compiled, depth, seen) {
+    if (depth > compiled.maxDepth)
+        return MAX_DEPTH_MARKER;
+    if (Array.isArray(value)) {
+        if (seen.has(value))
+            return CIRCULAR_MARKER;
+        seen.add(value);
+        const result = value.map((entry) => walk(entry, compiled, depth + 1, seen));
+        seen.delete(value);
+        return result;
+    }
+    if (isPlainContainer(value) || isWalkableInstance(value)) {
+        if (seen.has(value))
+            return CIRCULAR_MARKER;
+        seen.add(value);
+        const result = Object.create(Object.getPrototypeOf(value));
+        for (const [key, entry] of Object.entries(value)) {
+            const redacted = redactField(key, entry, compiled);
+            // A field the matcher replaced is done — never walk into it, or a
+            // nested object under a sensitive key would leak through its children.
+            result[key] =
+                redacted === entry ? walk(entry, compiled, depth + 1, seen) : redacted;
         }
+        seen.delete(value);
+        return result;
     }
-    return result;
+    return value;
+}
+/**
+ * Redacts sensitive fields from a structure.
+ *
+ * Returns a new value; the input is never mutated. Arrays are traversed,
+ * cycles become {@link CIRCULAR_MARKER}, and anything deeper than
+ * `maxDepth` becomes {@link MAX_DEPTH_MARKER}.
+ */
+export function redactObject(obj, config) {
+    return walk(obj, compile(config), 0, new WeakSet());
+}
+/**
+ * Redacts any value, not just a plain object — an array of headers, a scalar,
+ * a nested mix.
+ */
+export function redactValue(value, config) {
+    return walk(value, compile(config), 0, new WeakSet());
 }
-/** Checks if a field name is sensitive. */
+/** Checks if a field name is sensitive under the given configuration. */
 export function isSensitiveField(fieldName, config) {
-    const fields = (config?.fields ?? DEFAULT_SENSITIVE_FIELDS).map((f) => f.toLowerCase());
-    return fields.includes(fieldName.toLowerCase());
+    return compile(config).isSensitive(fieldName);
+}
+/**
+ * Compiles a configuration once into a reusable structure redactor.
+ *
+ * Prefer this on a hot path: {@link redactObject} recompiles the field
+ * matcher on every call.
+ */
+export function createStructureRedactor(config) {
+    const compiled = compile(config);
+    return (value) => walk(value, compiled, 0, new WeakSet());
 }
 //# sourceMappingURL=redaction.core.js.map

package/dist/sampling/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Sampling strategies: AlwaysOn, AlwaysOff, Probability, ParentBased.
  */
-export { AlwaysOnSampler, AlwaysOffSampler, ProbabilitySampler, ParentBasedSampler, createAlwaysOnSampler, createAlwaysOffSampler, createProbabilitySampler, createParentBasedSampler, } from "./sampler.type.js";
+export { AlwaysOnSampler, AlwaysOffSampler, ProbabilitySampler, ParentBasedSampler, createAlwaysOnSampler, createAlwaysOffSampler, createProbabilitySampler, createParentBasedSampler, isSampled, isRecording, type ParentBasedSamplerOptions, } from "./sampler.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/sampling/index.js

@@ -3,5 +3,5 @@
  *
  * Sampling strategies: AlwaysOn, AlwaysOff, Probability, ParentBased.
  */
-export { AlwaysOnSampler, AlwaysOffSampler, ProbabilitySampler, ParentBasedSampler, createAlwaysOnSampler, createAlwaysOffSampler, createProbabilitySampler, createParentBasedSampler, } from "./sampler.type.js";
+export { AlwaysOnSampler, AlwaysOffSampler, ProbabilitySampler, ParentBasedSampler, createAlwaysOnSampler, createAlwaysOffSampler, createProbabilitySampler, createParentBasedSampler, isSampled, isRecording, } from "./sampler.type.js";
 //# sourceMappingURL=index.js.map