@runtime-digital-twin/sdk 1.0.0

package/dist/root-cause-analyzer.js

@@ -0,0 +1,606 @@
+"use strict";
+/**
+ * Multi-service root cause analyzer
+ *
+ * Analyzes distributed traces to determine which upstream service
+ * most likely caused a failure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMultiServiceRootCause = analyzeMultiServiceRootCause;
+const multi_service_edge_builder_1 = require("./multi-service-edge-builder");
+/**
+ * Find the symptom service (error event nearest to terminal 5xx or latest error)
+ */
+function findSymptomService(events) {
+    // Find all error events and 5xx responses
+    const errorEvents = [];
+    const fiveXXResponses = [];
+    for (const event of events) {
+        if (event.type === 'error') {
+            errorEvents.push(event);
+        }
+        else if (event.type === 'http.response.inbound' ||
+            event.type === 'http.response.outbound') {
+            if (event.statusCode && event.statusCode >= 500) {
+                fiveXXResponses.push(event);
+            }
+        }
+    }
+    // If we have 5xx responses, find error event nearest to the latest one
+    if (fiveXXResponses.length > 0) {
+        const latest5xx = fiveXXResponses.reduce((latest, current) => current.timestamp > latest.timestamp ? current : latest);
+        // Find error event closest in time to latest 5xx
+        let nearestError = null;
+        let minTimeDiff = Infinity;
+        for (const error of errorEvents) {
+            const timeDiff = Math.abs(error.timestamp - latest5xx.timestamp);
+            if (timeDiff < minTimeDiff) {
+                minTimeDiff = timeDiff;
+                nearestError = error;
+            }
+        }
+        return nearestError || latest5xx;
+    }
+    // No 5xx responses - return latest error event
+    if (errorEvents.length > 0) {
+        return errorEvents.reduce((latest, current) => current.timestamp > latest.timestamp ? current : latest);
+    }
+    return null;
+}
+/**
+ * Common required fields that should trigger scoring when null
+ */
+const COMMON_REQUIRED_FIELDS = [
+    '$.price',
+    '$.amount',
+    '$.total',
+    '$.cost',
+    '$.id',
+    '$.userId',
+    '$.customerId',
+    '$.orderId',
+    '$.productId',
+];
+/**
+ * Check if nullPaths intersect with common required fields
+ */
+function hasRequiredFieldNulls(nullPaths) {
+    if (!nullPaths || nullPaths.length === 0) {
+        return false;
+    }
+    return nullPaths.some(path => COMMON_REQUIRED_FIELDS.some(required => path === required || path.startsWith(required + '.') || path.startsWith(required + '[')));
+}
+/**
+ * Find invariant events for a given outbound span
+ */
+function findInvariantsForSpan(spanId, events) {
+    return events.filter(e => e.type === 'state.invariant' &&
+        (e.spanId === spanId || e.parentSpanId === spanId) &&
+        e.passed === false);
+}
+/**
+ * Score a candidate span
+ */
+function scoreCandidate(event, allEvents) {
+    let score = 0;
+    const reasons = [];
+    if (event.type === 'http.request.outbound') {
+        const statusCode = event.statusCode;
+        // Check for invariant failures on this outbound call
+        const invariants = findInvariantsForSpan(event.spanId, allEvents);
+        for (const invariant of invariants) {
+            if (invariant.name === 'http.response.forbidden_null') {
+                score += 7;
+                reasons.push('Outbound response has forbidden_null invariant failure');
+            }
+            else if (invariant.name === 'http.response.5xx') {
+                score += 7;
+                reasons.push('Outbound response has 5xx invariant failure');
+            }
+        }
+        // Check responseShapeDigest for nullPaths intersecting required fields
+        if (event.responseShapeDigest?.nullPaths) {
+            if (hasRequiredFieldNulls(event.responseShapeDigest.nullPaths)) {
+                score += 6;
+                reasons.push('Response shape digest has nullPaths intersecting required fields');
+            }
+        }
+        // Original scoring logic
+        if (statusCode !== null && statusCode !== undefined) {
+            if (statusCode >= 500) {
+                score += 6;
+                reasons.push(`Outbound HTTP call returned 5xx (${statusCode})`);
+            }
+            else if (statusCode >= 400 && statusCode < 500) {
+                // Check if there's a downstream error (will be checked later)
+                score += 4;
+                reasons.push(`Outbound HTTP call returned 4xx (${statusCode}) with downstream error`);
+            }
+        }
+        else {
+            // Missing statusCode but request might have thrown
+            // This is handled by checking for error events with same parentSpanId
+            score += 4;
+            reasons.push('Outbound HTTP call failed (missing statusCode, likely threw error)');
+        }
+    }
+    else if (event.type === 'error') {
+        score += 3;
+        reasons.push('Error event (symptom, not root cause)');
+    }
+    return {
+        score,
+        reason: reasons.length > 0 ? reasons.join('; ') : 'No scoring factors',
+    };
+}
+/**
+ * Check if there's a downstream error for a given outbound span
+ */
+function hasDownstreamError(outboundSpanId, events) {
+    // Find inbound events that have this outbound span as parent
+    for (const event of events) {
+        if (event.type === 'http.request.inbound' &&
+            event.parentSpanId === outboundSpanId) {
+            // Check if there's an error event with this inbound span as parent or same span
+            for (const errorEvent of events) {
+                if (errorEvent.type === 'error' &&
+                    (errorEvent.parentSpanId === event.spanId ||
+                        errorEvent.spanId === event.spanId)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Build upstream graph from edges (reverse direction)
+ */
+function buildUpstreamGraph(edges) {
+    // Map: toService -> [edges that end at this service]
+    const graph = new Map();
+    for (const edge of edges) {
+        if (!graph.has(edge.toService)) {
+            graph.set(edge.toService, []);
+        }
+        graph.get(edge.toService).push(edge);
+    }
+    return graph;
+}
+/**
+ * Walk upstream from a service to find all upstream services
+ */
+function walkUpstream(startService, edges, visited = new Set()) {
+    if (visited.has(startService)) {
+        return [];
+    }
+    visited.add(startService);
+    const path = [startService];
+    // Find edges where this service is the destination
+    for (const edge of edges) {
+        if (edge.toService === startService && !visited.has(edge.fromService)) {
+            const upstreamPath = walkUpstream(edge.fromService, edges, visited);
+            path.push(...upstreamPath);
+        }
+    }
+    return path;
+}
+/**
+ * Find all candidate spans for root cause analysis
+ */
+function findCandidateSpans(events) {
+    const candidates = [];
+    for (const event of events) {
+        const { score, reason } = scoreCandidate(event, events);
+        // Adjust score for 4xx with downstream error
+        if (event.type === 'http.request.outbound' &&
+            event.statusCode !== null &&
+            event.statusCode !== undefined &&
+            event.statusCode >= 400 &&
+            event.statusCode < 500) {
+            if (!hasDownstreamError(event.spanId, events)) {
+                // No downstream error - reduce score (but keep if invariants/shape digest scored)
+                // Only reduce if score is purely from status code
+                if (score <= 4) {
+                    // Skip this candidate if score is only from 4xx
+                    continue;
+                }
+            }
+        }
+        // Adjust score for missing statusCode
+        if (event.type === 'http.request.outbound' &&
+            (event.statusCode === null || event.statusCode === undefined)) {
+            // Check if there's an error event for this span
+            const hasError = events.some((e) => e.type === 'error' &&
+                (e.spanId === event.spanId || e.parentSpanId === event.spanId));
+            if (!hasError && score <= 4) {
+                // No error evidence and score is only from missing statusCode
+                continue;
+            }
+        }
+        if (score > 0) {
+            const operationName = event.type === 'http.request.outbound'
+                ? `${event.method || 'UNKNOWN'} ${event.urlTemplate || event.peerHost || 'unknown'}`
+                : event.type === 'error'
+                    ? 'error'
+                    : `${event.method || 'UNKNOWN'} ${event.path || event.route || 'unknown'}`;
+            const evidence = {
+                kind: event.type === 'error' ? 'error' : 'http',
+            };
+            if (event.type === 'http.request.outbound') {
+                evidence.statusCode = event.statusCode ?? undefined;
+                evidence.peerService = event.peerService ?? undefined;
+                // Collect invariant events for this span
+                const invariants = findInvariantsForSpan(event.spanId, events);
+                if (invariants.length > 0) {
+                    evidence.invariants = invariants.map(inv => ({
+                        name: inv.name || 'unknown',
+                        paths: inv.details?.paths,
+                    }));
+                }
+                // Collect responseShapeDigest info
+                if (event.responseShapeDigest) {
+                    evidence.responseShapeDigest = {
+                        hash: event.responseShapeDigest.hash,
+                        nullPaths: event.responseShapeDigest.nullPaths?.slice(0, 5), // Top 5 nullPaths
+                    };
+                }
+            }
+            else if (event.type === 'error') {
+                evidence.message = event.error?.message || 'Unknown error';
+            }
+            candidates.push({
+                spanId: event.spanId,
+                serviceName: event.serviceName,
+                operationName,
+                score,
+                reason,
+                evidence,
+                event,
+            });
+        }
+    }
+    return candidates;
+}
+/**
+ * Build propagation path from edges
+ */
+function buildPropagationPath(edges) {
+    if (edges.length === 0) {
+        return [];
+    }
+    // Find the root service (service that appears as 'from' but never as 'to')
+    const toServices = new Set(edges.map((e) => e.toService));
+    const fromServices = new Set(edges.map((e) => e.fromService));
+    // Find services that are only 'from' (root services)
+    const rootServices = Array.from(fromServices).filter((s) => !toServices.has(s));
+    if (rootServices.length === 0) {
+        // No clear root - use first edge's fromService
+        return [edges[0].fromService];
+    }
+    // Start from root and walk downstream
+    const path = [];
+    const visited = new Set();
+    function walkDownstream(service) {
+        if (visited.has(service)) {
+            return;
+        }
+        visited.add(service);
+        path.push(service);
+        // Find edges where this service is the source
+        for (const edge of edges) {
+            if (edge.fromService === service && !visited.has(edge.toService)) {
+                walkDownstream(edge.toService);
+            }
+        }
+    }
+    // Start from first root service
+    walkDownstream(rootServices[0]);
+    return path;
+}
+/**
+ * Calculate confidence score
+ */
+function calculateConfidence(culprit, events, edges) {
+    // High confidence (0.85-0.95): upstream outbound with strong evidence
+    if (culprit.event.type === 'http.request.outbound') {
+        const statusCode = culprit.event.statusCode;
+        // Check for invariant failures (strong signal)
+        const hasInvariantFailure = culprit.evidence.invariants?.some(inv => inv.name === 'http.response.forbidden_null' || inv.name === 'http.response.5xx');
+        // Check for required field nulls in shape digest (strong signal)
+        const hasRequiredFieldNulls = culprit.evidence.responseShapeDigest?.nullPaths?.some(path => COMMON_REQUIRED_FIELDS.some(required => path === required || path.startsWith(required + '.') || path.startsWith(required + '[')));
+        // Very high confidence: invariant failure or required field nulls
+        if (hasInvariantFailure || hasRequiredFieldNulls) {
+            return 0.9;
+        }
+        // High confidence: 5xx status
+        if (statusCode !== null && statusCode !== undefined && statusCode >= 500) {
+            return 0.9;
+        }
+        // High confidence: missing statusCode with error event
+        if (statusCode === null &&
+            events.some((e) => e.type === 'error' &&
+                (e.spanId === culprit.spanId || e.parentSpanId === culprit.spanId))) {
+            return 0.85;
+        }
+        // Medium-high confidence: has shape digest with nullPaths (but not required fields)
+        if (culprit.evidence.responseShapeDigest?.nullPaths && culprit.evidence.responseShapeDigest.nullPaths.length > 0) {
+            return 0.8;
+        }
+    }
+    // Medium confidence (0.6-0.8): only symptom errors exist
+    if (culprit.event.type === 'error') {
+        // Check if there are upstream services
+        const hasUpstream = edges.some((e) => e.toService === culprit.serviceName);
+        if (!hasUpstream) {
+            return 0.7; // No upstream - likely root cause
+        }
+        return 0.65; // Has upstream - might be symptom
+    }
+    // Low confidence (<=0.55): trace incomplete or ambiguous
+    if (edges.length === 0) {
+        return 0.5; // No edges - trace might be incomplete
+    }
+    return 0.6; // Default medium-low
+}
+/**
+ * Analyze multi-service root cause
+ *
+ * @param traceId - The trace ID
+ * @param events - All events for this traceId
+ * @returns Root cause analysis result
+ */
+function analyzeMultiServiceRootCause(traceId, events) {
+    // Filter events to this traceId
+    const traceEvents = events.filter((e) => e.traceId === traceId);
+    if (traceEvents.length === 0) {
+        throw new Error(`No events found for traceId: ${traceId}`);
+    }
+    // Build edges
+    const edges = (0, multi_service_edge_builder_1.buildEdges)(traceEvents);
+    // Find symptom service
+    const symptomEvent = findSymptomService(traceEvents);
+    if (!symptomEvent) {
+        // No errors found - return analysis with first service as culprit
+        const firstEvent = traceEvents[0];
+        return {
+            culprit: {
+                serviceName: firstEvent.serviceName,
+                spanId: firstEvent.spanId,
+                operationName: `${firstEvent.method || 'UNKNOWN'} ${firstEvent.path || 'unknown'}`,
+                evidence: {
+                    kind: 'http',
+                },
+                confidence: 0.5,
+            },
+            propagationPath: buildPropagationPath(edges),
+            rankedFindings: [],
+        };
+    }
+    // Find all candidate spans
+    const candidates = findCandidateSpans(traceEvents);
+    // Walk upstream from symptom to find root cause
+    // Build parent chain: child spanId -> parent spanId
+    const parentChain = new Map();
+    for (const event of traceEvents) {
+        if (event.parentSpanId) {
+            parentChain.set(event.spanId, event.parentSpanId);
+        }
+    }
+    // Build spanId -> event map for quick lookup
+    const spanToEvent = new Map();
+    for (const event of traceEvents) {
+        spanToEvent.set(event.spanId, event);
+    }
+    // Walk upstream from symptom span following parentSpanId chain
+    // Also collect all spans in the chain for upstream service lookup
+    const upstreamCandidates = [];
+    const chainSpanIds = new Set();
+    let currentSpanId = symptomEvent.spanId;
+    const visitedSpans = new Set();
+    while (currentSpanId && !visitedSpans.has(currentSpanId)) {
+        visitedSpans.add(currentSpanId);
+        chainSpanIds.add(currentSpanId);
+        // Find candidate for this span
+        const candidate = candidates.find((c) => c.spanId === currentSpanId);
+        if (candidate) {
+            upstreamCandidates.push(candidate);
+        }
+        // Move to parent span
+        currentSpanId = parentChain.get(currentSpanId) || null;
+    }
+    // Also check if any candidate's spanId is a parent of any span in the chain
+    // This catches outbound calls whose child spans are in the chain
+    for (const candidate of candidates) {
+        // Check if any span in the chain has this candidate's spanId as parentSpanId
+        const isParentOfChainSpan = traceEvents.some(e => chainSpanIds.has(e.spanId) && e.parentSpanId === candidate.spanId);
+        if (isParentOfChainSpan && !upstreamCandidates.some(c => c.spanId === candidate.spanId)) {
+            upstreamCandidates.push(candidate);
+        }
+    }
+    // Also find candidates from upstream services via edges
+    // Build service -> spanIds map
+    const serviceToSpans = new Map();
+    for (const event of traceEvents) {
+        if (!serviceToSpans.has(event.serviceName)) {
+            serviceToSpans.set(event.serviceName, []);
+        }
+        serviceToSpans.get(event.serviceName).push(event.spanId);
+    }
+    // Find upstream services from edges
+    const symptomService = symptomEvent.serviceName;
+    const upstreamServices = new Set();
+    for (const edge of edges) {
+        if (edge.toService === symptomService) {
+            upstreamServices.add(edge.fromService);
+        }
+    }
+    // Recursively find all upstream services
+    const allUpstreamServices = new Set(upstreamServices);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const upstreamService of Array.from(allUpstreamServices)) {
+            for (const edge of edges) {
+                if (edge.toService === upstreamService && !allUpstreamServices.has(edge.fromService)) {
+                    allUpstreamServices.add(edge.fromService);
+                    changed = true;
+                }
+            }
+        }
+    }
+    // Add candidates from all upstream services
+    // Also add candidates that are in the parent chain (even if not in upstream services)
+    for (const candidate of candidates) {
+        const isUpstreamService = allUpstreamServices.has(candidate.serviceName);
+        const isInChain = chainSpanIds.has(candidate.spanId);
+        if ((isUpstreamService || isInChain) &&
+            !upstreamCandidates.some((c) => c.spanId === candidate.spanId)) {
+            upstreamCandidates.push(candidate);
+        }
+    }
+    // Sort by score (highest first), then by timestamp (latest first for same score - prefer closer to symptom)
+    upstreamCandidates.sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score;
+        }
+        // For same score, prefer later timestamp (closer to symptom)
+        return b.event.timestamp - a.event.timestamp;
+    });
+    // Pick highest scoring candidate as culprit
+    // Prefer upstream candidates, but fall back to all candidates if none found
+    let culprit = null;
+    if (upstreamCandidates.length > 0) {
+        culprit = upstreamCandidates[0];
+        // If culprit is an outbound call with peerService, try to find the downstream service
+        // This helps identify the actual service causing the problem (e.g., pricing-service)
+        // rather than just the caller (e.g., checkout-service)
+        // This is especially important when invariants or shape digest issues are present
+        if (culprit.event.type === 'http.request.outbound' && culprit.event.peerService) {
+            // Find the inbound event that corresponds to this outbound call
+            // The inbound event's parentSpanId should match the outbound event's spanId
+            const outboundSpanId = culprit.event.spanId;
+            const correspondingInbound = traceEvents.find(e => e.type === 'http.request.inbound' && e.parentSpanId === outboundSpanId);
+            // If we have invariants or shape digest issues, ALWAYS prefer the downstream service
+            // because the problem is with the response FROM that service
+            const hasInvariantOrShapeDigestIssue = (culprit.evidence.invariants && culprit.evidence.invariants.length > 0) ||
+                (culprit.evidence.responseShapeDigest?.nullPaths && culprit.evidence.responseShapeDigest.nullPaths.length > 0);
+            // If we found the downstream service and it's different, prefer identifying that service
+            // But keep the outbound event's evidence (shape digest, invariants)
+            if (correspondingInbound && correspondingInbound.serviceName !== culprit.serviceName) {
+                // Always prefer downstream service when we have invariant/shape digest issues
+                // OR when peerService matches the downstream service name
+                // This helps identify the actual service causing the problem (e.g., pricing-service)
+                // rather than just the caller (e.g., checkout-service)
+                if (hasInvariantOrShapeDigestIssue || culprit.event.peerService === correspondingInbound.serviceName) {
+                    // Create a new candidate for the downstream service with the same score and evidence
+                    culprit = {
+                        ...culprit,
+                        serviceName: correspondingInbound.serviceName,
+                        spanId: correspondingInbound.spanId,
+                        operationName: `${correspondingInbound.method || 'UNKNOWN'} ${correspondingInbound.path || correspondingInbound.route || 'unknown'}`,
+                    };
+                }
+            }
+            else if (hasInvariantOrShapeDigestIssue && culprit.event.peerService) {
+                // If we can't find the inbound event but we have peerService and invariant/shape digest issues,
+                // use the peerService as the service name
+                culprit = {
+                    ...culprit,
+                    serviceName: culprit.event.peerService,
+                    // Keep the outbound spanId since we don't have the inbound spanId
+                };
+            }
+            else if (culprit.event.peerService && !correspondingInbound && hasInvariantOrShapeDigestIssue) {
+                // If we have peerService but no corresponding inbound, and we have invariant/shape digest issues,
+                // prefer the peerService as the culprit service name
+                culprit = {
+                    ...culprit,
+                    serviceName: culprit.event.peerService,
+                };
+            }
+        }
+    }
+    else {
+        // Sort all candidates by score (highest first), then by timestamp (latest first)
+        const allCandidatesSorted = [...candidates].sort((a, b) => {
+            if (b.score !== a.score) {
+                return b.score - a.score;
+            }
+            // For same score, prefer later timestamp (closer to symptom)
+            return b.event.timestamp - a.event.timestamp;
+        });
+        if (allCandidatesSorted.length > 0) {
+            culprit = allCandidatesSorted[0];
+            // Same logic: if outbound call, try to identify downstream service
+            if (culprit.event.type === 'http.request.outbound' && culprit.event.peerService) {
+                const outboundSpanId = culprit.event.spanId;
+                const correspondingInbound = traceEvents.find(e => e.type === 'http.request.inbound' && e.parentSpanId === outboundSpanId);
+                const hasInvariantOrShapeDigestIssue = (culprit.evidence.invariants && culprit.evidence.invariants.length > 0) ||
+                    (culprit.evidence.responseShapeDigest?.nullPaths && culprit.evidence.responseShapeDigest.nullPaths.length > 0);
+                if (correspondingInbound && correspondingInbound.serviceName !== culprit.serviceName) {
+                    if (hasInvariantOrShapeDigestIssue || culprit.event.peerService === correspondingInbound.serviceName) {
+                        culprit = {
+                            ...culprit,
+                            serviceName: correspondingInbound.serviceName,
+                            spanId: correspondingInbound.spanId,
+                            operationName: `${correspondingInbound.method || 'UNKNOWN'} ${correspondingInbound.path || correspondingInbound.route || 'unknown'}`,
+                        };
+                    }
+                }
+                else if (hasInvariantOrShapeDigestIssue && culprit.event.peerService) {
+                    culprit = {
+                        ...culprit,
+                        serviceName: culprit.event.peerService,
+                    };
+                }
+            }
+        }
+    }
+    if (!culprit) {
+        // Fallback - use symptom event
+        const operationName = symptomEvent.type === 'http.request.outbound'
+            ? `${symptomEvent.method || 'UNKNOWN'} ${symptomEvent.urlTemplate || symptomEvent.peerHost || 'unknown'}`
+            : symptomEvent.type === 'error'
+                ? 'error'
+                : `${symptomEvent.method || 'UNKNOWN'} ${symptomEvent.path || symptomEvent.route || 'unknown'}`;
+        return {
+            culprit: {
+                serviceName: symptomEvent.serviceName,
+                spanId: symptomEvent.spanId,
+                operationName,
+                evidence: {
+                    kind: symptomEvent.type === 'error' ? 'error' : 'http',
+                    message: symptomEvent.type === 'error' ? (symptomEvent.error?.message || 'Unknown error') : undefined,
+                },
+                confidence: 0.5,
+            },
+            propagationPath: buildPropagationPath(edges),
+            rankedFindings: [],
+        };
+    }
+    // Calculate confidence
+    const confidence = calculateConfidence(culprit, traceEvents, edges);
+    // Build ranked findings
+    const rankedFindings = upstreamCandidates
+        .slice(0, 10) // Top 10
+        .map((c) => ({
+        score: c.score,
+        reason: c.reason,
+        serviceName: c.serviceName,
+        spanId: c.spanId,
+    }));
+    // Build propagation path
+    const propagationPath = buildPropagationPath(edges);
+    return {
+        culprit: {
+            serviceName: culprit.serviceName,
+            spanId: culprit.spanId,
+            operationName: culprit.operationName,
+            evidence: culprit.evidence,
+            confidence,
+        },
+        propagationPath,
+        rankedFindings,
+    };
+}

package/dist/shape-digest-utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shape Digest Utilities
+ *
+ * Utilities for computing shape digests with sampling and feature flags.
+ */
+import { type ShapeDigest } from "@runtime-digital-twin/core";
+export type ShapeDigestMode = "off" | "sampled" | "on";
+/**
+ * Get shape digest mode from environment
+ */
+export declare function getShapeDigestMode(): ShapeDigestMode;
+/**
+ * Get sample rate from environment
+ */
+export declare function getShapeDigestSampleRate(): number;
+/**
+ * Determine if shape digest should be computed
+ */
+export declare function shouldComputeShapeDigest(mode: ShapeDigestMode, sampleRate: number, statusCode?: number | null, hasError?: boolean): boolean;
+/**
+ * Check if content type indicates JSON
+ */
+export declare function isJsonContentType(contentType: string | null | undefined): boolean;
+/**
+ * Attempt to parse body as JSON
+ */
+export declare function tryParseJson(body: string | Buffer | object | null | undefined): unknown;
+/**
+ * Compute shape digest for a body if conditions are met
+ */
+export declare function computeBodyShapeDigest(body: string | Buffer | object | null | undefined, contentType: string | null | undefined, options: {
+    mode: ShapeDigestMode;
+    sampleRate: number;
+    statusCode?: number | null;
+    hasError?: boolean;
+}): Promise<ShapeDigest | null>;
+/**
+ * Get content type from headers
+ */
+export declare function getContentType(headers: Record<string, string | string[] | undefined> | Headers | null): string | null;
+/**
+ * Get size in bytes for a body
+ */
+export declare function getBodySizeBytes(body: string | Buffer | object | null | undefined): number | undefined;
+//# sourceMappingURL=shape-digest-utils.d.ts.map

package/dist/shape-digest-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-digest-utils.d.ts","sourceRoot":"","sources":["../src/shape-digest-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAElF,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,SAAS,GAAG,IAAI,CAAC;AAEvD;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAMpD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAMjD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,EAC1B,QAAQ,CAAC,EAAE,OAAO,GACjB,OAAO,CAcT;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CASjF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAoBvF;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EACjD,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACtC,OAAO,EAAE;IACP,IAAI,EAAE,eAAe,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GACA,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAmB7B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAgBrH;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgBtG"}