@runtime-digital-twin/sdk 1.0.0

package/dist/http-wrapper.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setTraceContext = setTraceContext;
+exports.getTraceContext = getTraceContext;
+exports.wrapFetch = wrapFetch;
+const trace_bundle_writer_1 = require("./trace-bundle-writer");
+const async_hooks_1 = require("async_hooks");
+const peer_service_resolver_1 = require("./peer-service-resolver");
+const shape_digest_utils_1 = require("./shape-digest-utils");
+const http_sentinels_1 = require("./http-sentinels");
+// Use AsyncLocalStorage for request-scoped trace context
+const traceContextStorage = new async_hooks_1.AsyncLocalStorage();
+/**
+ * Set the current trace context (called by Fastify plugin)
+ * Note: This uses enterWith which sets the context for the current async execution
+ */
+function setTraceContext(bundle, spanId) {
+    if (bundle && spanId) {
+        traceContextStorage.enterWith({ bundle, spanId });
+    }
+    else {
+        // For clearing, we can't use enterWith with null, so we'll check in getTraceContext
+        // In practice, the context will be naturally cleared when the async context ends
+    }
+}
+/**
+ * Get the current trace context
+ */
+function getTraceContext() {
+    const context = traceContextStorage.getStore();
+    if (!context) {
+        return { bundle: null, spanId: null };
+    }
+    return { bundle: context.bundle, spanId: context.spanId };
+}
+/**
+ * Wrap fetch/undici to capture outbound HTTP calls
+ */
+function wrapFetch(originalFetch) {
+    return async function wrappedFetch(input, init) {
+        const { bundle, spanId } = getTraceContext();
+        const mode = process.env.RDT_MODE;
+        const mockBase = process.env.RDT_MOCK_BASE;
+        // L2-5: SUBGRAPH mode - route calls based on service boundaries
+        // In replay mode, check if call is leaving subgraph
+        if (mode === 'replay' && mockBase) {
+            const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+            const urlObj = new URL(url);
+            // L2-5: Check if this call is leaving the subgraph
+            const subgraphServicesJson = process.env.RDT_SUBGRAPH_SERVICES;
+            const stubServicesJson = process.env.RDT_STUB_SERVICES;
+            let shouldRouteToMock = true; // Default: route to mock server
+            if (subgraphServicesJson) {
+                try {
+                    const subgraphServices = JSON.parse(subgraphServicesJson);
+                    const stubServices = stubServicesJson ? JSON.parse(stubServicesJson) : [];
+                    // Resolve peer service from hostname
+                    const hostname = urlObj.hostname;
+                    const { peerService } = (0, peer_service_resolver_1.resolvePeerService)(hostname);
+                    // L2-5: Route logic:
+                    // - If peerService is in subgraphServices → route to actual service (not implemented yet, route to mock for now)
+                    // - If peerService is in stubServices → route to mock server (stub)
+                    // - If peerService is NOT in subgraphServices → route to mock server (stub)
+                    // - If peerService is null → route to mock server (stub)
+                    if (peerService) {
+                        if (subgraphServices.includes(peerService)) {
+                            // Call is to a service in subgraph - should route to actual service
+                            // TODO: Implement actual service routing (requires service discovery/URL mapping)
+                            // For now, route to mock server as fallback
+                            shouldRouteToMock = true;
+                        }
+                        else if (stubServices.includes(peerService)) {
+                            // Call is to a stubbed service - route to mock server
+                            shouldRouteToMock = true;
+                        }
+                        else {
+                            // Call is to a service outside subgraph - route to mock server (stub)
+                            shouldRouteToMock = true;
+                        }
+                    }
+                    else {
+                        // Cannot resolve peer service - route to mock server (safe default)
+                        shouldRouteToMock = true;
+                    }
+                }
+                catch (error) {
+                    // Failed to parse subgraph config - fall back to routing all to mock
+                    console.warn(`[SDK] Failed to parse SUBGRAPH config: ${error}`);
+                    shouldRouteToMock = true;
+                }
+            }
+            // Route to mock server but keep path+query for matching
+            // The mock server will match based on method + path+query + body hash
+            const mockUrl = `${mockBase}${urlObj.pathname}${urlObj.search}`;
+            // Make request to mock server
+            try {
+                const response = await originalFetch(mockUrl, init);
+                // L2-5: Check if mock server returned 502 (no match) - FAIL LOUDLY
+                if (response.status === 502) {
+                    let errorBody = {};
+                    try {
+                        errorBody = await response.json();
+                    }
+                    catch {
+                        // Ignore JSON parse errors
+                    }
+                    // L2-5: Typed error for missing stub
+                    const errorMessage = `[Replay] Outbound HTTP call not found in trace (missing stub): ${url}\n` +
+                        `Computed match key: ${errorBody.computedKey || 'unknown'}\n` +
+                        `This call was not recorded in the trace bundle.\n` +
+                        `In SUBGRAPH mode, calls leaving the subgraph must have recorded stubs.`;
+                    throw new Error(errorMessage);
+                }
+                return response;
+            }
+            catch (error) {
+                // Block unknown network calls - fail loudly
+                if (error.message.includes('[Replay]')) {
+                    throw error; // Re-throw our custom error
+                }
+                throw new Error(`[Replay] Outbound HTTP call blocked: ${url}\n` +
+                    `Mock server base: ${mockBase}\n` +
+                    `Original error: ${error.message}`);
+            }
+        }
+        // Record mode: capture and make real request
+        if (!bundle || !spanId) {
+            // No trace context - in replay mode this should not happen
+            if (mode === 'replay') {
+                throw new Error('[Replay] Outbound HTTP call made without trace context');
+            }
+            return originalFetch(input, init);
+        }
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+        const method = init?.method || 'GET';
+        const headers = init?.headers ? init.headers : {};
+        const body = init?.body || null;
+        const requestSpanId = (0, trace_bundle_writer_1.generateSpanId)();
+        const startTime = Date.now();
+        // Extract peer service and hostname
+        let hostname = null;
+        try {
+            const urlObj = new URL(url);
+            hostname = urlObj.hostname;
+        }
+        catch {
+            // URL parsing failed, try to extract hostname manually
+            const hostMatch = url.match(/^https?:\/\/([^\/]+)/);
+            if (hostMatch) {
+                hostname = hostMatch[1];
+            }
+        }
+        const { peerService, peerHost } = hostname ? (0, peer_service_resolver_1.resolvePeerService)(hostname) : { peerService: null, peerHost: null };
+        const urlTemplate = (0, peer_service_resolver_1.extractUrlTemplate)(url);
+        // Process request body
+        let requestBody = null;
+        if (body) {
+            if (typeof body === 'string') {
+                requestBody = body;
+            }
+            else if (Buffer.isBuffer(body)) {
+                requestBody = body;
+            }
+            else if (body instanceof FormData || body instanceof URLSearchParams) {
+                // For FormData/URLSearchParams, we'll skip body capture for P0
+                requestBody = null;
+            }
+            else {
+                requestBody = JSON.stringify(body);
+            }
+        }
+        const { bodyHash: requestBodyHash, bodyBlob: requestBodyBlob } = await (0, trace_bundle_writer_1.processBody)(requestBody, bundle.writeBlob);
+        // Filter headers
+        const filteredHeaders = (0, trace_bundle_writer_1.filterHeaders)(headers);
+        // Inject trace context propagation headers
+        const propagationHeaders = {};
+        if (bundle.traceId) {
+            propagationHeaders['x-wraith-trace-id'] = bundle.traceId;
+        }
+        propagationHeaders['x-wraith-parent-span-id'] = requestSpanId;
+        // Merge propagation headers with existing headers
+        // Note: Headers object might be Headers instance, Record, or array of tuples
+        let mergedHeaders;
+        if (init?.headers instanceof Headers) {
+            const headers = new Headers(init.headers);
+            Object.entries(propagationHeaders).forEach(([key, value]) => {
+                headers.set(key, value);
+            });
+            mergedHeaders = headers;
+        }
+        else if (Array.isArray(init?.headers)) {
+            mergedHeaders = [
+                ...init.headers,
+                ...Object.entries(propagationHeaders),
+            ];
+        }
+        else {
+            mergedHeaders = {
+                ...(init?.headers || {}),
+                ...propagationHeaders,
+            };
+        }
+        // Create new init object with merged headers
+        const enhancedInit = {
+            ...init,
+            headers: mergedHeaders,
+        };
+        try {
+            // Make the actual HTTP request with propagation headers
+            const response = await originalFetch(input, enhancedInit);
+            const endTime = Date.now();
+            const durationMs = endTime - startTime;
+            // Debug logging
+            if (process.env.DEBUG_HTTP_WRAPPER) {
+                console.log('[HTTP_WRAPPER] Response received:', {
+                    status: response.status,
+                    headersType: response.headers?.constructor?.name,
+                    hasForEach: typeof response.headers?.forEach === 'function',
+                });
+            }
+            // Read response body (clone response so we can read it without consuming the original)
+            let responseClone;
+            try {
+                responseClone = response.clone();
+            }
+            catch (error) {
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.error('[HTTP_WRAPPER] Failed to clone response:', error);
+                }
+                throw error;
+            }
+            let responseBody = null;
+            let responseBodyForDigest = null;
+            try {
+                const contentType = response.headers.get('content-type') || '';
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.log('[HTTP_WRAPPER] Content-Type:', contentType);
+                }
+                if (contentType.includes('application/json') || contentType.includes('text/')) {
+                    responseBody = await responseClone.text();
+                    responseBodyForDigest = responseBody;
+                    if (process.env.DEBUG_HTTP_WRAPPER) {
+                        console.log('[HTTP_WRAPPER] Response body read, length:', responseBody?.length);
+                    }
+                }
+                else {
+                    // For shape digest, try to read body even if content-type isn't explicitly JSON/text
+                    // This allows us to compute digests for JSON responses with missing/wrong content-type
+                    try {
+                        responseBodyForDigest = await responseClone.text();
+                        // Try to parse as JSON - if it fails, we'll skip digest computation
+                        try {
+                            JSON.parse(responseBodyForDigest);
+                            // If parse succeeds, use it for digest
+                        }
+                        catch {
+                            // Not JSON, don't use for digest
+                            responseBodyForDigest = null;
+                        }
+                    }
+                    catch {
+                        // Failed to read, skip
+                    }
+                }
+            }
+            catch (error) {
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.error('[HTTP_WRAPPER] Failed to read response body:', error);
+                }
+                // Failed to read response body, continue without it
+            }
+            const { bodyHash: responseBodyHash, bodyBlob: responseBodyBlob } = await (0, trace_bundle_writer_1.processBody)(responseBody, bundle.writeBlob);
+            // Filter response headers
+            const responseHeaders = {};
+            try {
+                response.headers.forEach((value, key) => {
+                    responseHeaders[key] = value;
+                });
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.log('[HTTP_WRAPPER] Response headers processed:', Object.keys(responseHeaders));
+                }
+            }
+            catch (error) {
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.error('[HTTP_WRAPPER] Failed to process response headers:', error);
+                    console.error('[HTTP_WRAPPER] Headers object:', {
+                        type: typeof response.headers,
+                        constructor: response.headers?.constructor?.name,
+                        hasForEach: typeof response.headers?.forEach === 'function',
+                        keys: response.headers ? Object.keys(response.headers) : 'null',
+                    });
+                }
+                // Try to extract headers manually if forEach fails
+                if (response.headers && typeof response.headers === 'object') {
+                    try {
+                        for (const [key, value] of Object.entries(response.headers)) {
+                            responseHeaders[key] = String(value);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore
+                    }
+                }
+            }
+            const filteredResponseHeaders = (0, trace_bundle_writer_1.filterHeaders)(responseHeaders);
+            // Compute shape digests (async, non-blocking)
+            const mode = (0, shape_digest_utils_1.getShapeDigestMode)();
+            const sampleRate = (0, shape_digest_utils_1.getShapeDigestSampleRate)();
+            const requestContentType = (0, shape_digest_utils_1.getContentType)(headers);
+            const responseContentType = (0, shape_digest_utils_1.getContentType)(response.headers);
+            if (process.env.DEBUG_HTTP_WRAPPER) {
+                console.log('[HTTP_WRAPPER] Content types:', {
+                    request: requestContentType,
+                    response: responseContentType,
+                    mode,
+                    sampleRate,
+                });
+            }
+            const statusCode = response.status;
+            const hasError = statusCode >= 400;
+            let requestShapeDigest = null;
+            let responseShapeDigest = null;
+            try {
+                [requestShapeDigest, responseShapeDigest] = await Promise.all([
+                    (0, shape_digest_utils_1.computeBodyShapeDigest)(requestBody, requestContentType, {
+                        mode,
+                        sampleRate,
+                        statusCode,
+                        hasError,
+                    }),
+                    (0, shape_digest_utils_1.computeBodyShapeDigest)(responseBodyForDigest || responseBody, responseContentType, {
+                        mode,
+                        sampleRate,
+                        statusCode,
+                        hasError,
+                    }),
+                ]);
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.log('[HTTP_WRAPPER] Shape digests computed:', {
+                        request: !!requestShapeDigest,
+                        response: !!responseShapeDigest,
+                        responseKind: responseShapeDigest?.kind,
+                        responseNullPaths: responseShapeDigest?.nullPaths?.length,
+                    });
+                }
+            }
+            catch (error) {
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.error('[HTTP_WRAPPER] Failed to compute shape digests:', error);
+                }
+                // Continue without digests
+            }
+            const requestSizeBytes = (0, shape_digest_utils_1.getBodySizeBytes)(requestBody);
+            const responseSizeBytes = (0, shape_digest_utils_1.getBodySizeBytes)(responseBody);
+            if (process.env.DEBUG_HTTP_WRAPPER) {
+                console.log('[HTTP_WRAPPER] Body sizes:', {
+                    request: requestSizeBytes,
+                    response: responseSizeBytes,
+                });
+            }
+            // Check response sentinels (automatic contract checking)
+            // This emits state.invariant events for contract violations
+            try {
+                await (0, http_sentinels_1.checkResponseSentinels)(responseShapeDigest, statusCode, responseBodyForDigest || responseBody, requestSpanId, // Use requestSpanId so sentinel is attached to outbound call
+                spanId // parentSpanId
+                );
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.log('[HTTP_WRAPPER] Sentinels checked');
+                }
+            }
+            catch (error) {
+                if (process.env.DEBUG_HTTP_WRAPPER) {
+                    console.error('[HTTP_WRAPPER] Failed to check sentinels:', error);
+                }
+                // Continue without sentinels
+            }
+            // Write http.request.outbound event (after completion with statusCode and durationMs)
+            const outboundEvent = {
+                type: 'http.request.outbound',
+                timestamp: startTime, // Use start time for request timestamp
+                spanId: requestSpanId,
+                parentSpanId: spanId,
+                method,
+                url,
+                headers: filteredHeaders,
+                bodyHash: requestBodyHash,
+                bodyBlob: requestBodyBlob,
+                peerService,
+                peerHost,
+                urlTemplate,
+                statusCode: response.status,
+                durationMs,
+                ...(requestShapeDigest && { requestShapeDigest }),
+                ...(requestContentType && { requestContentType }),
+                ...(requestSizeBytes !== undefined && { requestSizeBytes }),
+                ...(responseShapeDigest && { responseShapeDigest }),
+                ...(responseContentType && { responseContentType }),
+                ...(responseSizeBytes !== undefined && { responseSizeBytes }),
+            };
+            if (process.env.DEBUG_HTTP_WRAPPER) {
+                console.log('[HTTP_WRAPPER] Writing outbound event with fields:', {
+                    statusCode: outboundEvent.statusCode,
+                    responseContentType: outboundEvent.responseContentType,
+                    responseSizeBytes: outboundEvent.responseSizeBytes,
+                    hasResponseShapeDigest: !!outboundEvent.responseShapeDigest,
+                    hasRequestShapeDigest: !!outboundEvent.requestShapeDigest,
+                });
+            }
+            await bundle.writeEvent(outboundEvent);
+            // Write http.response.outbound event
+            await bundle.writeEvent({
+                type: 'http.response.outbound',
+                timestamp: endTime,
+                spanId: requestSpanId,
+                parentSpanId: spanId,
+                statusCode: response.status,
+                headers: filteredResponseHeaders,
+                bodyHash: responseBodyHash,
+                bodyBlob: responseBodyBlob,
+                durationMs,
+            });
+            return response;
+        }
+        catch (error) {
+            if (process.env.DEBUG_HTTP_WRAPPER) {
+                console.error('[HTTP_WRAPPER] Error in fetch wrapper:', error);
+                console.error('[HTTP_WRAPPER] Error stack:', error.stack);
+            }
+            const endTime = Date.now();
+            const durationMs = endTime - startTime;
+            // Compute shape digest for request (errors always include digest)
+            const mode = (0, shape_digest_utils_1.getShapeDigestMode)();
+            const sampleRate = (0, shape_digest_utils_1.getShapeDigestSampleRate)();
+            const requestContentType = (0, shape_digest_utils_1.getContentType)(headers);
+            const requestShapeDigest = await (0, shape_digest_utils_1.computeBodyShapeDigest)(requestBody, requestContentType, {
+                mode,
+                sampleRate,
+                statusCode: null,
+                hasError: true, // Always compute for errors
+            });
+            const requestSizeBytes = (0, shape_digest_utils_1.getBodySizeBytes)(requestBody);
+            // Write http.request.outbound event (after error with durationMs, null statusCode)
+            await bundle.writeEvent({
+                type: 'http.request.outbound',
+                timestamp: startTime, // Use start time for request timestamp
+                spanId: requestSpanId,
+                parentSpanId: spanId,
+                method,
+                url,
+                headers: filteredHeaders,
+                bodyHash: requestBodyHash,
+                bodyBlob: requestBodyBlob,
+                peerService,
+                peerHost,
+                urlTemplate,
+                statusCode: null, // Error - no status code
+                durationMs,
+                ...(requestShapeDigest && { requestShapeDigest }),
+                ...(requestContentType && { requestContentType }),
+                ...(requestSizeBytes !== undefined && { requestSizeBytes }),
+            });
+            // Write error event
+            await bundle.writeEvent({
+                type: 'error',
+                timestamp: endTime,
+                spanId: requestSpanId,
+                parentSpanId: spanId,
+                error: {
+                    name: error.name || 'Error',
+                    message: error.message || String(error),
+                    stack: error.stack || undefined,
+                },
+            });
+            throw error;
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Runtime Digital Twin SDK
+ *
+ * In-process instrumentation for capturing runtime behavior.
+ */
+export { CURRENT_TRACE_FORMAT_VERSION } from "./constants";
+export { createTrace, processBody, filterHeaders, generateSpanId, type CreateTraceOptions, type TraceBundle, } from "./trace-bundle-writer";
+export { loadTraceMeta, validateTraceStructure, formatTraceLoadFailure, type TraceLoadFailure, type TraceMetadata, type TraceVersionWarning, type TraceLoadResult, } from "./trace-loader";
+export { fastifyTracing, type FastifyTracingOptions } from "./fastify-plugin";
+export { wrapFetch, setTraceContext, getTraceContext } from "./http-wrapper";
+export { OutboundMatcher, normalizeUrl, normalizeHeaders, computeBodyHash, computeMatchSignature, compareOutboundCalls, parseRecordedOutboundCalls, formatOutboundMismatch, formatUnexpectedOutboundCall, formatMissingOutboundCall, formatOutboundCallFailure, type ReplayMode, type OutboundRequestMismatch, type UnexpectedOutboundCall, type MissingOutboundCall, type OutboundCallFailure, type OutboundDivergence, type RecordedOutboundCall, type OutboundCallSignature, } from "./outbound-matcher";
+export { DbQueryMatcher, wrapDbClient, createWrappedDbClient, normalizeSql, computeParamsHash, extractOperation, compareDbQueries, parseRecordedDbQueries, formatDbQueryMismatch, formatUnexpectedDbQuery, formatMissingDbQuery, formatBlockedDbAccess, formatDbQueryFailure, type DbReplayMode, type DbQueryMismatch, type UnexpectedDbQuery, type MissingDbQuery, type BlockedDbAccess, type DbQueryFailure, type DbQueryDivergence, type RecordedDbQuery, type DbQuerySignature, type DbClient, type WrappedDbClient, type WrapDbClientOptions, type CreateWrappedDbClientOptions, } from "./db-wrapper";
+export { ReplayLogger, getReplayLogger, resetReplayLogger, createReplayLogger, type ReplayLogFormat, type ReplayLogLevel, type ReplayEventCategory, type ReplayEventBase, type ReplayEvent, type ReplayLoggerConfig, type HttpOutboundMatchEvent, type HttpOutboundReturnEvent, type HttpOutboundMismatchEvent, type HttpOutboundUnexpectedEvent, type HttpOutboundMissingEvent, type HttpOutboundBlockedEvent, type DbQueryMatchEvent, type DbQueryReturnEvent, type DbQueryMismatchEvent, type DbQueryUnexpectedEvent, type DbQueryMissingEvent, type DbQueryBlockedEvent, type TraceLoadEvent, type TraceLoadWarningEvent, type TraceLoadErrorEvent, type ReplayStartEvent, type ReplayCompleteEvent, type ReplayErrorEvent, type ReplayDivergenceEvent, } from "./replay-logger";
+export { buildEdges, buildEdgesForTrace, type TraceEvent, type ServiceEdge, } from "./multi-service-edge-builder";
+export { analyzeMultiServiceRootCause, type RootCauseAnalysis, } from "./root-cause-analyzer";
+export { redactHeaders, redactBody, redactBodyObject, redactBodyPatterns, redactQueryParams, redactUrl, loadRedactionConfig, setRedactionConfig, getRedactionConfig, resetRedactionConfig, computeRedactionHash, createRedactedValue, shouldRedactHeader, shouldRedactQueryParam, containsSensitivePatterns, SENSITIVE_HEADERS, SENSITIVE_QUERY_PARAMS, SENSITIVE_BODY_FIELDS, type RedactionRule, type RedactionRuleType, type RedactionConfig, } from "./redaction";
+export { emitInvariant, assertNonNull, assertHasKeys, assertInRange, type InvariantDetails, type EmitInvariantOptions, } from "./invariants";
+export { uploadTrace, type TraceUploadOptions, type TraceUploadResult, } from "./trace-uploader";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Runtime Digital Twin SDK
+ *
+ * In-process instrumentation for capturing runtime behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRedactionConfig = exports.redactUrl = exports.redactQueryParams = exports.redactBodyPatterns = exports.redactBodyObject = exports.redactBody = exports.redactHeaders = exports.analyzeMultiServiceRootCause = exports.buildEdgesForTrace = exports.buildEdges = exports.createReplayLogger = exports.resetReplayLogger = exports.getReplayLogger = exports.ReplayLogger = exports.formatDbQueryFailure = exports.formatBlockedDbAccess = exports.formatMissingDbQuery = exports.formatUnexpectedDbQuery = exports.formatDbQueryMismatch = exports.parseRecordedDbQueries = exports.compareDbQueries = exports.extractOperation = exports.computeParamsHash = exports.normalizeSql = exports.createWrappedDbClient = exports.wrapDbClient = exports.DbQueryMatcher = exports.formatOutboundCallFailure = exports.formatMissingOutboundCall = exports.formatUnexpectedOutboundCall = exports.formatOutboundMismatch = exports.parseRecordedOutboundCalls = exports.compareOutboundCalls = exports.computeMatchSignature = exports.computeBodyHash = exports.normalizeHeaders = exports.normalizeUrl = exports.OutboundMatcher = exports.getTraceContext = exports.setTraceContext = exports.wrapFetch = exports.fastifyTracing = exports.formatTraceLoadFailure = exports.validateTraceStructure = exports.loadTraceMeta = exports.generateSpanId = exports.filterHeaders = exports.processBody = exports.createTrace = exports.CURRENT_TRACE_FORMAT_VERSION = void 0;
+exports.uploadTrace = exports.assertInRange = exports.assertHasKeys = exports.assertNonNull = exports.emitInvariant = exports.SENSITIVE_BODY_FIELDS = exports.SENSITIVE_QUERY_PARAMS = exports.SENSITIVE_HEADERS = exports.containsSensitivePatterns = exports.shouldRedactQueryParam = exports.shouldRedactHeader = exports.createRedactedValue = exports.computeRedactionHash = exports.resetRedactionConfig = exports.getRedactionConfig = exports.setRedactionConfig = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "CURRENT_TRACE_FORMAT_VERSION", { enumerable: true, get: function () { return constants_1.CURRENT_TRACE_FORMAT_VERSION; } });
+var trace_bundle_writer_1 = require("./trace-bundle-writer");
+Object.defineProperty(exports, "createTrace", { enumerable: true, get: function () { return trace_bundle_writer_1.createTrace; } });
+Object.defineProperty(exports, "processBody", { enumerable: true, get: function () { return trace_bundle_writer_1.processBody; } });
+Object.defineProperty(exports, "filterHeaders", { enumerable: true, get: function () { return trace_bundle_writer_1.filterHeaders; } });
+Object.defineProperty(exports, "generateSpanId", { enumerable: true, get: function () { return trace_bundle_writer_1.generateSpanId; } });
+var trace_loader_1 = require("./trace-loader");
+Object.defineProperty(exports, "loadTraceMeta", { enumerable: true, get: function () { return trace_loader_1.loadTraceMeta; } });
+Object.defineProperty(exports, "validateTraceStructure", { enumerable: true, get: function () { return trace_loader_1.validateTraceStructure; } });
+Object.defineProperty(exports, "formatTraceLoadFailure", { enumerable: true, get: function () { return trace_loader_1.formatTraceLoadFailure; } });
+var fastify_plugin_1 = require("./fastify-plugin");
+Object.defineProperty(exports, "fastifyTracing", { enumerable: true, get: function () { return fastify_plugin_1.fastifyTracing; } });
+var http_wrapper_1 = require("./http-wrapper");
+Object.defineProperty(exports, "wrapFetch", { enumerable: true, get: function () { return http_wrapper_1.wrapFetch; } });
+Object.defineProperty(exports, "setTraceContext", { enumerable: true, get: function () { return http_wrapper_1.setTraceContext; } });
+Object.defineProperty(exports, "getTraceContext", { enumerable: true, get: function () { return http_wrapper_1.getTraceContext; } });
+var outbound_matcher_1 = require("./outbound-matcher");
+Object.defineProperty(exports, "OutboundMatcher", { enumerable: true, get: function () { return outbound_matcher_1.OutboundMatcher; } });
+Object.defineProperty(exports, "normalizeUrl", { enumerable: true, get: function () { return outbound_matcher_1.normalizeUrl; } });
+Object.defineProperty(exports, "normalizeHeaders", { enumerable: true, get: function () { return outbound_matcher_1.normalizeHeaders; } });
+Object.defineProperty(exports, "computeBodyHash", { enumerable: true, get: function () { return outbound_matcher_1.computeBodyHash; } });
+Object.defineProperty(exports, "computeMatchSignature", { enumerable: true, get: function () { return outbound_matcher_1.computeMatchSignature; } });
+Object.defineProperty(exports, "compareOutboundCalls", { enumerable: true, get: function () { return outbound_matcher_1.compareOutboundCalls; } });
+Object.defineProperty(exports, "parseRecordedOutboundCalls", { enumerable: true, get: function () { return outbound_matcher_1.parseRecordedOutboundCalls; } });
+Object.defineProperty(exports, "formatOutboundMismatch", { enumerable: true, get: function () { return outbound_matcher_1.formatOutboundMismatch; } });
+Object.defineProperty(exports, "formatUnexpectedOutboundCall", { enumerable: true, get: function () { return outbound_matcher_1.formatUnexpectedOutboundCall; } });
+Object.defineProperty(exports, "formatMissingOutboundCall", { enumerable: true, get: function () { return outbound_matcher_1.formatMissingOutboundCall; } });
+Object.defineProperty(exports, "formatOutboundCallFailure", { enumerable: true, get: function () { return outbound_matcher_1.formatOutboundCallFailure; } });
+var db_wrapper_1 = require("./db-wrapper");
+Object.defineProperty(exports, "DbQueryMatcher", { enumerable: true, get: function () { return db_wrapper_1.DbQueryMatcher; } });
+Object.defineProperty(exports, "wrapDbClient", { enumerable: true, get: function () { return db_wrapper_1.wrapDbClient; } });
+Object.defineProperty(exports, "createWrappedDbClient", { enumerable: true, get: function () { return db_wrapper_1.createWrappedDbClient; } });
+Object.defineProperty(exports, "normalizeSql", { enumerable: true, get: function () { return db_wrapper_1.normalizeSql; } });
+Object.defineProperty(exports, "computeParamsHash", { enumerable: true, get: function () { return db_wrapper_1.computeParamsHash; } });
+Object.defineProperty(exports, "extractOperation", { enumerable: true, get: function () { return db_wrapper_1.extractOperation; } });
+Object.defineProperty(exports, "compareDbQueries", { enumerable: true, get: function () { return db_wrapper_1.compareDbQueries; } });
+Object.defineProperty(exports, "parseRecordedDbQueries", { enumerable: true, get: function () { return db_wrapper_1.parseRecordedDbQueries; } });
+Object.defineProperty(exports, "formatDbQueryMismatch", { enumerable: true, get: function () { return db_wrapper_1.formatDbQueryMismatch; } });
+Object.defineProperty(exports, "formatUnexpectedDbQuery", { enumerable: true, get: function () { return db_wrapper_1.formatUnexpectedDbQuery; } });
+Object.defineProperty(exports, "formatMissingDbQuery", { enumerable: true, get: function () { return db_wrapper_1.formatMissingDbQuery; } });
+Object.defineProperty(exports, "formatBlockedDbAccess", { enumerable: true, get: function () { return db_wrapper_1.formatBlockedDbAccess; } });
+Object.defineProperty(exports, "formatDbQueryFailure", { enumerable: true, get: function () { return db_wrapper_1.formatDbQueryFailure; } });
+var replay_logger_1 = require("./replay-logger");
+Object.defineProperty(exports, "ReplayLogger", { enumerable: true, get: function () { return replay_logger_1.ReplayLogger; } });
+Object.defineProperty(exports, "getReplayLogger", { enumerable: true, get: function () { return replay_logger_1.getReplayLogger; } });
+Object.defineProperty(exports, "resetReplayLogger", { enumerable: true, get: function () { return replay_logger_1.resetReplayLogger; } });
+Object.defineProperty(exports, "createReplayLogger", { enumerable: true, get: function () { return replay_logger_1.createReplayLogger; } });
+// Multi-service edge builder
+var multi_service_edge_builder_1 = require("./multi-service-edge-builder");
+Object.defineProperty(exports, "buildEdges", { enumerable: true, get: function () { return multi_service_edge_builder_1.buildEdges; } });
+Object.defineProperty(exports, "buildEdgesForTrace", { enumerable: true, get: function () { return multi_service_edge_builder_1.buildEdgesForTrace; } });
+// Root cause analyzer
+var root_cause_analyzer_1 = require("./root-cause-analyzer");
+Object.defineProperty(exports, "analyzeMultiServiceRootCause", { enumerable: true, get: function () { return root_cause_analyzer_1.analyzeMultiServiceRootCause; } });
+// Redaction module
+var redaction_1 = require("./redaction");
+Object.defineProperty(exports, "redactHeaders", { enumerable: true, get: function () { return redaction_1.redactHeaders; } });
+Object.defineProperty(exports, "redactBody", { enumerable: true, get: function () { return redaction_1.redactBody; } });
+Object.defineProperty(exports, "redactBodyObject", { enumerable: true, get: function () { return redaction_1.redactBodyObject; } });
+Object.defineProperty(exports, "redactBodyPatterns", { enumerable: true, get: function () { return redaction_1.redactBodyPatterns; } });
+Object.defineProperty(exports, "redactQueryParams", { enumerable: true, get: function () { return redaction_1.redactQueryParams; } });
+Object.defineProperty(exports, "redactUrl", { enumerable: true, get: function () { return redaction_1.redactUrl; } });
+Object.defineProperty(exports, "loadRedactionConfig", { enumerable: true, get: function () { return redaction_1.loadRedactionConfig; } });
+Object.defineProperty(exports, "setRedactionConfig", { enumerable: true, get: function () { return redaction_1.setRedactionConfig; } });
+Object.defineProperty(exports, "getRedactionConfig", { enumerable: true, get: function () { return redaction_1.getRedactionConfig; } });
+Object.defineProperty(exports, "resetRedactionConfig", { enumerable: true, get: function () { return redaction_1.resetRedactionConfig; } });
+Object.defineProperty(exports, "computeRedactionHash", { enumerable: true, get: function () { return redaction_1.computeRedactionHash; } });
+Object.defineProperty(exports, "createRedactedValue", { enumerable: true, get: function () { return redaction_1.createRedactedValue; } });
+Object.defineProperty(exports, "shouldRedactHeader", { enumerable: true, get: function () { return redaction_1.shouldRedactHeader; } });
+Object.defineProperty(exports, "shouldRedactQueryParam", { enumerable: true, get: function () { return redaction_1.shouldRedactQueryParam; } });
+Object.defineProperty(exports, "containsSensitivePatterns", { enumerable: true, get: function () { return redaction_1.containsSensitivePatterns; } });
+Object.defineProperty(exports, "SENSITIVE_HEADERS", { enumerable: true, get: function () { return redaction_1.SENSITIVE_HEADERS; } });
+Object.defineProperty(exports, "SENSITIVE_QUERY_PARAMS", { enumerable: true, get: function () { return redaction_1.SENSITIVE_QUERY_PARAMS; } });
+Object.defineProperty(exports, "SENSITIVE_BODY_FIELDS", { enumerable: true, get: function () { return redaction_1.SENSITIVE_BODY_FIELDS; } });
+// Invariant checking
+var invariants_1 = require("./invariants");
+Object.defineProperty(exports, "emitInvariant", { enumerable: true, get: function () { return invariants_1.emitInvariant; } });
+Object.defineProperty(exports, "assertNonNull", { enumerable: true, get: function () { return invariants_1.assertNonNull; } });
+Object.defineProperty(exports, "assertHasKeys", { enumerable: true, get: function () { return invariants_1.assertHasKeys; } });
+Object.defineProperty(exports, "assertInRange", { enumerable: true, get: function () { return invariants_1.assertInRange; } });
+// Trace upload
+var trace_uploader_1 = require("./trace-uploader");
+Object.defineProperty(exports, "uploadTrace", { enumerable: true, get: function () { return trace_uploader_1.uploadTrace; } });