@superblocksteam/telemetry 2.0.0-SNAPSHOT.329be19cb7ca892b

package/dist/common/tier-hints.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Tier Policy Hints
+ *
+ * SDK-level hints that inform the OTEL Collector how to route spans.
+ * These are HINTS, not guarantees — the Collector makes final routing decisions.
+ *
+ * NOTE: This is different from tier TAGS (which indicate which pipeline processed
+ * a span). Hints are prescriptive ("please route this way"), tags are descriptive
+ * ("this was processed by Tier X"). The Collector adds tier tags; the SDK adds hints.
+ *
+ * See: engineering/projects/o11y-refactor/proposals/sdk-tier-policy-hints.md
+ */
+import type { Span } from "@opentelemetry/api";
+/**
+ * The attribute key used for tier policy hints.
+ * Collector filters on this attribute to make routing decisions.
+ */
+export declare const TIER_HINT_ATTRIBUTE = "superblocks.tier_hint";
+/**
+ * Tier policy hints that inform the Collector how to route spans.
+ *
+ * These are HINTS, not guarantees — the Collector makes final routing decisions
+ * based on its configuration. In cloud-prem deployments, the Collector respects
+ * these hints to control which tiers receive the span.
+ *
+ * @example
+ * ```typescript
+ * import { trace } from '@opentelemetry/api';
+ * import { TierPolicyHint, TIER_HINT_ATTRIBUTE } from '@superblocksteam/telemetry';
+ *
+ * const span = tracer.startSpan('sensitive_operation');
+ * span.setAttribute(TIER_HINT_ATTRIBUTE, TierPolicyHint.TIER1_ONLY);
+ * ```
+ */
+export declare enum TierPolicyHint {
+    /**
+     * Route to Tier 1 only. Do not export to Tier 2 or Tier 3.
+     *
+     * Use for:
+     * - Spans containing customer secrets or credentials
+     * - Highly sensitive customer data that must not leave their environment
+     * - Debug/diagnostic spans that should remain local
+     *
+     * The span will be stored in the customer's Tier 1 backend (e.g., Tempo)
+     * but will NOT be exported to Superblocks (Tier 2) or AI analytics (Tier 3).
+     */
+    TIER1_ONLY = "tier1_only",
+    /**
+     * Include in Tier 3 (AI quality analysis) in addition to Tier 1 and Tier 2.
+     *
+     * Use for:
+     * - GenAI spans that should be analyzed for quality metrics
+     * - AI/LLM operations where prompts and responses are valuable for analysis
+     * - Spans with AI quality signals (latency, token usage, etc.)
+     *
+     * The span will go to all tiers: Tier 1 (full fidelity), Tier 2 (sanitized),
+     * and Tier 3 (AI analytics with identity stripped).
+     */
+    INCLUDE_TIER3 = "include_tier3",
+    /**
+     * Skip all external export. Tier 1 (local) only, no Tier 2/3.
+     * Alias for TIER1_ONLY, kept for semantic clarity.
+     *
+     * Use for:
+     * - High-cardinality diagnostic spans (cost control)
+     * - Temporary debug spans that shouldn't persist
+     * - Spans that are only useful for local debugging
+     *
+     * This is functionally equivalent to TIER1_ONLY but communicates
+     * a different intent: "this is for cost/noise control" rather than
+     * "this contains sensitive data."
+     */
+    SKIP_EXPORT = "skip_export"
+}
+/**
+ * Set a tier policy hint on a span.
+ *
+ * This is a convenience function that sets the `superblocks.tier_hint` attribute.
+ * You can also set the attribute directly if preferred.
+ *
+ * @param span - The span to set the hint on
+ * @param hint - The tier policy hint
+ *
+ * @example
+ * ```typescript
+ * import { setTierHint, TierPolicyHint } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('decrypt_secret', (span) => {
+ *   setTierHint(span, TierPolicyHint.TIER1_ONLY);
+ *   // ... perform operation
+ *   span.end();
+ * });
+ * ```
+ */
+export declare function setTierHint(span: Span, hint: TierPolicyHint): void;
+/**
+ * Mark a span as containing sensitive data that should not leave Tier 1.
+ *
+ * Use this for spans that handle customer secrets, credentials, or other
+ * highly sensitive data that must remain in the customer's environment.
+ *
+ * @param span - The span to mark as sensitive
+ *
+ * @example
+ * ```typescript
+ * import { markSensitive } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('decrypt_customer_secret', (span) => {
+ *   markSensitive(span);
+ *   // ... decrypt operation
+ *   span.end();
+ * });
+ * ```
+ */
+export declare function markSensitive(span: Span): void;
+/**
+ * Mark a span for AI quality analysis (Tier 3).
+ *
+ * Use this for GenAI spans that should be analyzed for quality metrics.
+ * The span will go to all tiers, with Tier 3 receiving the content
+ * (prompts/responses) for AI quality analysis.
+ *
+ * @param span - The span to mark for AI analysis
+ *
+ * @example
+ * ```typescript
+ * import { markForAIAnalysis } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('gen_ai.chat', (span) => {
+ *   markForAIAnalysis(span);
+ *   span.setAttribute('gen_ai.system', 'anthropic');
+ *   // ... LLM call
+ *   span.end();
+ * });
+ * ```
+ */
+export declare function markForAIAnalysis(span: Span): void;
+/**
+ * Mark a span as debug-only (no export to Tier 2/3).
+ *
+ * Use this for high-cardinality diagnostic spans where you want to
+ * control costs by preventing export to paid backends.
+ *
+ * @param span - The span to mark as debug-only
+ *
+ * @example
+ * ```typescript
+ * import { markDebugOnly } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('debug.cache_lookup', (span) => {
+ *   markDebugOnly(span);
+ *   span.setAttribute('cache.key', cacheKey); // High cardinality OK
+ *   // ... lookup
+ *   span.end();
+ * });
+ * ```
+ */
+export declare function markDebugOnly(span: Span): void;
+/**
+ * Check if a span has a tier hint set.
+ *
+ * @param span - The span to check (must be a ReadableSpan with attributes)
+ * @returns The tier hint if set, undefined otherwise
+ */
+export declare function getTierHint(span: {
+    attributes?: Record<string, unknown>;
+}): TierPolicyHint | undefined;
+/**
+ * Check if a tier hint indicates the span should skip Tier 2 export.
+ *
+ * @param hint - The tier hint to check
+ * @returns true if Tier 2 should be skipped
+ */
+export declare function shouldSkipTier2(hint: TierPolicyHint | undefined): boolean;
+/**
+ * Check if a tier hint indicates the span should be included in Tier 3.
+ *
+ * @param hint - The tier hint to check
+ * @returns true if Tier 3 should be included
+ */
+export declare function shouldIncludeTier3(hint: TierPolicyHint | undefined): boolean;
+//# sourceMappingURL=tier-hints.d.ts.map

package/dist/common/tier-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-hints.d.ts","sourceRoot":"","sources":["../../src/common/tier-hints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,oBAAY,cAAc;IACxB;;;;;;;;;;OAUG;IACH,UAAU,eAAe;IAEzB;;;;;;;;;;OAUG;IACH,aAAa,kBAAkB;IAE/B;;;;;;;;;;;;OAYG;IACH,WAAW,gBAAgB;CAC5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAElE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAE9C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAElD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,GAAG,cAAc,GAAG,SAAS,CAS7B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAIzE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,CAE5E"}

package/dist/common/tier-hints.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Tier Policy Hints
+ *
+ * SDK-level hints that inform the OTEL Collector how to route spans.
+ * These are HINTS, not guarantees — the Collector makes final routing decisions.
+ *
+ * NOTE: This is different from tier TAGS (which indicate which pipeline processed
+ * a span). Hints are prescriptive ("please route this way"), tags are descriptive
+ * ("this was processed by Tier X"). The Collector adds tier tags; the SDK adds hints.
+ *
+ * See: engineering/projects/o11y-refactor/proposals/sdk-tier-policy-hints.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TierPolicyHint = exports.TIER_HINT_ATTRIBUTE = void 0;
+exports.setTierHint = setTierHint;
+exports.markSensitive = markSensitive;
+exports.markForAIAnalysis = markForAIAnalysis;
+exports.markDebugOnly = markDebugOnly;
+exports.getTierHint = getTierHint;
+exports.shouldSkipTier2 = shouldSkipTier2;
+exports.shouldIncludeTier3 = shouldIncludeTier3;
+/**
+ * The attribute key used for tier policy hints.
+ * Collector filters on this attribute to make routing decisions.
+ */
+exports.TIER_HINT_ATTRIBUTE = "superblocks.tier_hint";
+/**
+ * Tier policy hints that inform the Collector how to route spans.
+ *
+ * These are HINTS, not guarantees — the Collector makes final routing decisions
+ * based on its configuration. In cloud-prem deployments, the Collector respects
+ * these hints to control which tiers receive the span.
+ *
+ * @example
+ * ```typescript
+ * import { trace } from '@opentelemetry/api';
+ * import { TierPolicyHint, TIER_HINT_ATTRIBUTE } from '@superblocksteam/telemetry';
+ *
+ * const span = tracer.startSpan('sensitive_operation');
+ * span.setAttribute(TIER_HINT_ATTRIBUTE, TierPolicyHint.TIER1_ONLY);
+ * ```
+ */
+var TierPolicyHint;
+(function (TierPolicyHint) {
+    /**
+     * Route to Tier 1 only. Do not export to Tier 2 or Tier 3.
+     *
+     * Use for:
+     * - Spans containing customer secrets or credentials
+     * - Highly sensitive customer data that must not leave their environment
+     * - Debug/diagnostic spans that should remain local
+     *
+     * The span will be stored in the customer's Tier 1 backend (e.g., Tempo)
+     * but will NOT be exported to Superblocks (Tier 2) or AI analytics (Tier 3).
+     */
+    TierPolicyHint["TIER1_ONLY"] = "tier1_only";
+    /**
+     * Include in Tier 3 (AI quality analysis) in addition to Tier 1 and Tier 2.
+     *
+     * Use for:
+     * - GenAI spans that should be analyzed for quality metrics
+     * - AI/LLM operations where prompts and responses are valuable for analysis
+     * - Spans with AI quality signals (latency, token usage, etc.)
+     *
+     * The span will go to all tiers: Tier 1 (full fidelity), Tier 2 (sanitized),
+     * and Tier 3 (AI analytics with identity stripped).
+     */
+    TierPolicyHint["INCLUDE_TIER3"] = "include_tier3";
+    /**
+     * Skip all external export. Tier 1 (local) only, no Tier 2/3.
+     * Alias for TIER1_ONLY, kept for semantic clarity.
+     *
+     * Use for:
+     * - High-cardinality diagnostic spans (cost control)
+     * - Temporary debug spans that shouldn't persist
+     * - Spans that are only useful for local debugging
+     *
+     * This is functionally equivalent to TIER1_ONLY but communicates
+     * a different intent: "this is for cost/noise control" rather than
+     * "this contains sensitive data."
+     */
+    TierPolicyHint["SKIP_EXPORT"] = "skip_export";
+})(TierPolicyHint || (exports.TierPolicyHint = TierPolicyHint = {}));
+/**
+ * Set a tier policy hint on a span.
+ *
+ * This is a convenience function that sets the `superblocks.tier_hint` attribute.
+ * You can also set the attribute directly if preferred.
+ *
+ * @param span - The span to set the hint on
+ * @param hint - The tier policy hint
+ *
+ * @example
+ * ```typescript
+ * import { setTierHint, TierPolicyHint } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('decrypt_secret', (span) => {
+ *   setTierHint(span, TierPolicyHint.TIER1_ONLY);
+ *   // ... perform operation
+ *   span.end();
+ * });
+ * ```
+ */
+function setTierHint(span, hint) {
+    span.setAttribute(exports.TIER_HINT_ATTRIBUTE, hint);
+}
+/**
+ * Mark a span as containing sensitive data that should not leave Tier 1.
+ *
+ * Use this for spans that handle customer secrets, credentials, or other
+ * highly sensitive data that must remain in the customer's environment.
+ *
+ * @param span - The span to mark as sensitive
+ *
+ * @example
+ * ```typescript
+ * import { markSensitive } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('decrypt_customer_secret', (span) => {
+ *   markSensitive(span);
+ *   // ... decrypt operation
+ *   span.end();
+ * });
+ * ```
+ */
+function markSensitive(span) {
+    setTierHint(span, TierPolicyHint.TIER1_ONLY);
+}
+/**
+ * Mark a span for AI quality analysis (Tier 3).
+ *
+ * Use this for GenAI spans that should be analyzed for quality metrics.
+ * The span will go to all tiers, with Tier 3 receiving the content
+ * (prompts/responses) for AI quality analysis.
+ *
+ * @param span - The span to mark for AI analysis
+ *
+ * @example
+ * ```typescript
+ * import { markForAIAnalysis } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('gen_ai.chat', (span) => {
+ *   markForAIAnalysis(span);
+ *   span.setAttribute('gen_ai.system', 'anthropic');
+ *   // ... LLM call
+ *   span.end();
+ * });
+ * ```
+ */
+function markForAIAnalysis(span) {
+    setTierHint(span, TierPolicyHint.INCLUDE_TIER3);
+}
+/**
+ * Mark a span as debug-only (no export to Tier 2/3).
+ *
+ * Use this for high-cardinality diagnostic spans where you want to
+ * control costs by preventing export to paid backends.
+ *
+ * @param span - The span to mark as debug-only
+ *
+ * @example
+ * ```typescript
+ * import { markDebugOnly } from '@superblocksteam/telemetry';
+ *
+ * tracer.startActiveSpan('debug.cache_lookup', (span) => {
+ *   markDebugOnly(span);
+ *   span.setAttribute('cache.key', cacheKey); // High cardinality OK
+ *   // ... lookup
+ *   span.end();
+ * });
+ * ```
+ */
+function markDebugOnly(span) {
+    setTierHint(span, TierPolicyHint.SKIP_EXPORT);
+}
+/**
+ * Check if a span has a tier hint set.
+ *
+ * @param span - The span to check (must be a ReadableSpan with attributes)
+ * @returns The tier hint if set, undefined otherwise
+ */
+function getTierHint(span) {
+    const hint = span.attributes?.[exports.TIER_HINT_ATTRIBUTE];
+    if (typeof hint === "string" &&
+        Object.values(TierPolicyHint).includes(hint)) {
+        return hint;
+    }
+    return undefined;
+}
+/**
+ * Check if a tier hint indicates the span should skip Tier 2 export.
+ *
+ * @param hint - The tier hint to check
+ * @returns true if Tier 2 should be skipped
+ */
+function shouldSkipTier2(hint) {
+    return (hint === TierPolicyHint.TIER1_ONLY || hint === TierPolicyHint.SKIP_EXPORT);
+}
+/**
+ * Check if a tier hint indicates the span should be included in Tier 3.
+ *
+ * @param hint - The tier hint to check
+ * @returns true if Tier 3 should be included
+ */
+function shouldIncludeTier3(hint) {
+    return hint === TierPolicyHint.INCLUDE_TIER3;
+}
+//# sourceMappingURL=tier-hints.js.map

package/dist/common/tier-hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-hints.js","sourceRoot":"","sources":["../../src/common/tier-hints.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAyFH,kCAEC;AAqBD,sCAEC;AAuBD,8CAEC;AAsBD,sCAEC;AAQD,kCAWC;AAQD,0CAIC;AAQD,gDAEC;AAxMD;;;GAGG;AACU,QAAA,mBAAmB,GAAG,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,IAAY,cAyCX;AAzCD,WAAY,cAAc;IACxB;;;;;;;;;;OAUG;IACH,2CAAyB,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,iDAA+B,CAAA;IAE/B;;;;;;;;;;;;OAYG;IACH,6CAA2B,CAAA;AAC7B,CAAC,EAzCW,cAAc,8BAAd,cAAc,QAyCzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,WAAW,CAAC,IAAU,EAAE,IAAoB;IAC1D,IAAI,CAAC,YAAY,CAAC,2BAAmB,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,aAAa,CAAC,IAAU;IACtC,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,iBAAiB,CAAC,IAAU;IAC1C,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,aAAa,CAAC,IAAU;IACtC,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,CAAC;AAChD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,IAE3B;IACC,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,2BAAmB,CAAC,CAAC;IACpD,IACE,OAAO,IAAI,KAAK,QAAQ;QACxB,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,CAAC,IAAsB,CAAC,EAC9D,CAAC;QACD,OAAO,IAAsB,CAAC;IAChC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,eAAe,CAAC,IAAgC;IAC9D,OAAO,CACL,IAAI,KAAK,cAAc,CAAC,UAAU,IAAI,IAAI,KAAK,cAAc,CAAC,WAAW,CAC1E,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,IAAgC;IACjE,OAAO,IAAI,KAAK,cAAc,CAAC,aAAa,CAAC;AAC/C,CAAC"}

package/dist/common/trace-sanitizer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Tier 2 Trace Sanitizer
+ *
+ * Sanitizes spans for Tier 2 export per epic-a3-sanitized-traces.
+ * - Drops spans for high-volume, low-value routes (health, metrics)
+ * - Drops spans not in the contract
+ * - Drops forbidden attributes (PII, Tier 1 content)
+ * - Drops high-cardinality attributes (e.g. binding_keys) when configured
+ * - Hashes configured attributes using keyed HMAC (when hash config provided)
+ * - Only includes attributes in the allowlist for each span type
+ */
+import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import { type SpanDefinition } from "./contracts/tier2-traces.js";
+export interface HashConfig {
+    secretKey: Buffer;
+    salt: string;
+    algorithm: "sha256" | "sha384" | "sha512";
+    outputLengthBytes: number;
+}
+/**
+ * Configuration for the trace sanitizer. Attribute sets and contract can vary by deployment type
+ * (e.g. cloud vs cloud-prem). Use getTraceSanitizerAttributeSets(deploymentType)
+ * from the contract to obtain sets for a given policy.
+ */
+export interface TraceSanitizerOptions {
+    hashConfig: HashConfig | null;
+    forbiddenAttributes: Set<string>;
+    droppedAttributes: Set<string>;
+    hashedAttributes: Set<string>;
+    /** Span definitions for name matching; defaults to TIER_2_TRACE_CONTRACT if omitted. */
+    spanDefinitions?: SpanDefinition[];
+    /** When true, span attributes are not filtered by allowedAttributes (pass-through). */
+    attributeAllowlistPassthrough?: boolean;
+}
+export declare class TraceSanitizer {
+    private readonly contractMap;
+    private readonly hashConfig;
+    private readonly forbiddenAttributes;
+    private readonly droppedAttributes;
+    private readonly hashedAttributes;
+    private readonly attributeAllowlistPassthrough;
+    constructor(options: TraceSanitizerOptions);
+    /**
+     * Check if a span should be exported to Tier 2.
+     */
+    shouldExport(span: ReadableSpan): boolean;
+    /**
+     * Sanitize span attributes for Tier 2 export.
+     * Returns null if span should not be exported.
+     *
+     * Returns a ReadableSpan-like object that delegates to the original span for
+     * spanContext() and other methods (spread does not copy prototype methods,
+     * and the OTLP exporter calls span.spanContext()).
+     */
+    sanitize(span: ReadableSpan): ReadableSpan | null;
+    private findMatchingDefinition;
+    /**
+     * Pattern matching: "*" matches any name; suffix wildcards (e.g. "HTTP POST *", "ws.*").
+     * For "HTTP POST *", matches "HTTP POST" (exact) or "HTTP POST /path" (prefix + rest).
+     */
+    private matchesPattern;
+    /**
+     * Sanitize span links for Tier 2: link attributes are filtered the same way as
+     * event attributes (forbidden dropped, high-cardinality dropped, hashed values).
+     * Link context (trace/span IDs) is preserved.
+     */
+    private sanitizeLinks;
+    /**
+     * Sanitize span events for Tier 2: event attributes are filtered the same way as
+     * span attributes (forbidden dropped, high-cardinality dropped, hashed values).
+     * Event names and timestamps are preserved.
+     */
+    private sanitizeEvents;
+    /**
+     * Sanitize attributes that appear on events or links (no allowlist; only
+     * drop forbidden/high-cardinality and hash hashed).
+     */
+    private sanitizeEventOrLinkAttributes;
+    private sanitizeAttributes;
+    private hashValue;
+}
+//# sourceMappingURL=trace-sanitizer.d.ts.map

package/dist/common/trace-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-sanitizer.d.ts","sourceRoot":"","sources":["../../src/common/trace-sanitizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAYH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AAErC,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC/B,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,wFAAwF;IACxF,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IACnC,uFAAuF;IACvF,6BAA6B,CAAC,EAAE,OAAO,CAAC;CACzC;AAcD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAc;IAClD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAc;IAChD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAc;IAC/C,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAU;gBAE5C,OAAO,EAAE,qBAAqB;IAc1C;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO;IAIzC;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,GAAG,IAAI;IA6CjD,OAAO,CAAC,sBAAsB;IAe9B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAYrB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAetB;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAkBrC,OAAO,CAAC,kBAAkB;IAuC1B,OAAO,CAAC,SAAS;CAYlB"}