@servicetitan/journey 4.0.0 → 4.2.0

package/src/__tests__/sinks/kibana.test.ts

@@ -0,0 +1,267 @@
+/** @jest-environment jsdom */
+import { sanitizeJourneyEvent } from '../../core/sanitize';
+import {
+    isMonolithLogOrigin,
+    MAX_JOURNEY_CORRELATED_REQUESTS,
+} from '../../core/request-correlation';
+import type { JourneyEvent, JourneyRequestEvent } from '../../core/types';
+import { journeyLogsLink, requestLogsUrl } from '../../sinks/kibana';
+
+const request: JourneyRequestEvent = {
+    rayId: '0123456789abcdef-IAD',
+    startedAtEpoch: Date.parse('2026-09-17T18:00:00.000Z'),
+    durationMs: 2000,
+    status: 500,
+};
+
+function event(outcome: JourneyEvent['journey']['outcome'] = 'bad'): JourneyEvent {
+    return {
+        journey: {
+            name: 'test',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            outcome,
+            durationMs: 2000,
+            steps: [
+                { name: 'save', startMs: 0, durationMs: 2000, outcome: 'bad', requests: [request] },
+            ],
+        },
+    };
+}
+
+describe('[journey] request logs link', () => {
+    test('uses the verified production view and an absolute request window', () => {
+        const url = new URL(requestLogsUrl(request)!);
+        expect(url.origin).toBe('https://kibana.st.dev');
+        expect(url.pathname).toBe('/app/discover');
+        const params = new URLSearchParams(url.hash.slice(3));
+        expect(params.get('_g')).toBe(
+            "(refreshInterval:(pause:!t,value:0),time:(from:'2026-09-17T17:59:00.000Z',to:'2026-09-17T18:01:02.000Z'))"
+        );
+        expect(params.get('_a')).toBe(
+            "(dataSource:(type:dataView,dataViewId:'894110ed-c22d-449c-9dc2-c4816f08712a'),query:(language:kuery,query:'Request.RequestId: 0123456789abcdef*'))"
+        );
+        expect(url.href).not.toContain('IAD');
+    });
+
+    test.each([
+        { rayId: "0123456789abcdef') OR *" },
+        { rayId: 'https://attacker.example' },
+        { rayId: 'a'.repeat(1000) },
+        { rayId: '0123456789abcde' },
+        { rayId: '0123456789abcdef-INVALID' },
+        { startedAtEpoch: NaN },
+        { startedAtEpoch: Infinity },
+        { startedAtEpoch: -1 },
+        { startedAtEpoch: 8.64e15 },
+        { durationMs: -1 },
+        { durationMs: Infinity },
+        { status: 0 },
+        { status: 600 },
+        { status: 200.5 },
+    ])('rejects invalid correlation %j', invalid => {
+        expect(requestLogsUrl({ ...request, ...invalid })).toBeUndefined();
+        const payload = event();
+        payload.journey.steps[0].requests = [{ ...request, ...invalid }];
+        expect(sanitizeJourneyEvent(payload).journey.steps[0].requests).toBeUndefined();
+    });
+
+    test('sanitizes correlation by allowlist, not the metric-tag string normalizer', () => {
+        const payload = event();
+        payload.journey.steps[0].requests = [
+            {
+                ...request,
+                url: '/test?password=secret',
+                headers: { authorization: 'secret' },
+            } as JourneyRequestEvent,
+        ];
+        expect(sanitizeJourneyEvent(payload).journey.steps[0].requests).toEqual([
+            { ...request, rayId: request.rayId.toLowerCase() },
+        ]);
+    });
+
+    test.each(['good', 'excluded'] as const)('keeps request links on %s events', outcome => {
+        expect(sanitizeJourneyEvent(event(outcome)).journey.steps[0].requests).toEqual([
+            { ...request, rayId: request.rayId.toLowerCase() },
+        ]);
+    });
+
+    test('caps the event payload and preserves links on the last failing step', () => {
+        const payload = event();
+        payload.journey.steps = Array.from({ length: 50 }, (_, index) => ({
+            ...payload.journey.steps[0],
+            name: `step-${index}`,
+        }));
+        const steps = sanitizeJourneyEvent(payload).journey.steps;
+        expect(steps.reduce((count, step) => count + (step.requests?.length ?? 0), 0)).toBe(
+            MAX_JOURNEY_CORRELATED_REQUESTS
+        );
+        expect(steps[0].requestsTruncated).toBe(true);
+        expect(steps[49].requests).toHaveLength(1);
+    });
+    test('validates the top-level failure request and strips it from non-bad events', () => {
+        const payload = event();
+        payload.journey.failedRequest = { ...request, rayId: "0123456789abcdef') OR *" };
+        expect(sanitizeJourneyEvent(payload).journey.failedRequest).toBeUndefined();
+        payload.journey.failedRequest = request;
+        expect(sanitizeJourneyEvent(payload).journey.failedRequest).toEqual({
+            ...request,
+            rayId: request.rayId.toLowerCase(),
+        });
+        payload.journey.outcome = 'good';
+        expect(sanitizeJourneyEvent(payload).journey.failedRequest).toBeUndefined();
+    });
+});
+
+describe('[journey] visible Kibana link', () => {
+    const now = Date.parse('2026-09-17T18:00:02.000Z');
+    const user = { tenant: 'test_tenant', name: 'test-agent', email: 'agent@example.test' };
+    const page = 'https://go.servicetitan.com/';
+
+    beforeEach(() => {
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+    });
+    afterEach(() => jest.restoreAllMocks());
+
+    function queryState(url: string): string {
+        return new URLSearchParams(new URL(url).hash.slice(3)).get('_a')!;
+    }
+
+    test.each(['step-error', 'request-error', 'step-timeout', 'journey-timeout', 'custom-failure'])(
+        'links %s without an HTTP response to scoped related logs',
+        reason => {
+            const journey = { ...event().journey, reason, steps: [] };
+            const link = journeyLogsLink(journey, () => user, page)!;
+            expect(link.scope).toBe('related_logs');
+            expect(queryState(link.url)).toContain('Context.TenantName: "test_tenant"');
+            expect(queryState(link.url)).toContain('Request.User: "test-agent"');
+            expect(queryState(link.url)).toContain('Request.User: "agent@example.test"');
+            expect(queryState(link.url)).not.toContain('Request.RequestId');
+            const params = new URLSearchParams(new URL(link.url).hash.slice(3));
+            expect(params.get('_g')).toContain("from:'2026-09-17T17:59:00.000Z'");
+            expect(params.get('_g')).toContain("to:'2026-09-17T18:01:02.000Z'");
+        }
+    );
+
+    test.each(['good', 'excluded'] as const)('includes a visible link for %s journeys', outcome => {
+        const link = journeyLogsLink(event(outcome).journey, () => user, page)!;
+        expect(link.scope).toBe('related_logs');
+    });
+
+    test('keeps the existing precise failure link ahead of the fallback', () => {
+        const getUser = jest.fn(() => user);
+        const journey = { ...event().journey, failedRequest: request };
+        expect(journeyLogsLink(journey, getUser, page)).toEqual({
+            url: requestLogsUrl(request),
+            scope: 'request',
+        });
+        expect(getUser).not.toHaveBeenCalled();
+    });
+
+    test('does not blame an earlier successful request for a later network error', () => {
+        const journey = event().journey;
+        journey.reason = 'request-error';
+        journey.steps[0].requests![0] = { ...request, status: 200 };
+        const link = journeyLogsLink(journey, () => user, page)!;
+        expect(link.scope).toBe('related_logs');
+        expect(queryState(link.url)).not.toContain('Request.RequestId');
+    });
+
+    test('makes nested captured requests visible when host user context is unavailable', () => {
+        const journey = event().journey;
+        const other = { ...request, rayId: 'fedcba9876543210', status: 200 };
+        journey.steps[0].requests = [request, other, request];
+        const link = journeyLogsLink(journey)!;
+        expect(link.scope).toBe('related_requests');
+        expect(queryState(link.url)).toContain(
+            'Request.RequestId: 0123456789abcdef* OR Request.RequestId: fedcba9876543210*'
+        );
+        expect(queryState(link.url).match(/0123456789abcdef/g)).toHaveLength(1);
+    });
+
+    test.each([
+        {},
+        { tenant: 'test_tenant' },
+        { name: 'test-agent' },
+        { tenant: 'test_tenant OR *', name: 'test-agent' },
+        { tenant: 'test_tenant', name: 'agent\nOR *' },
+        { tenant: 'test_tenant', name: 'x'.repeat(255) },
+    ])('does not create a broad cross-tenant search for %j', invalid => {
+        const journey = { ...event().journey, steps: [] };
+        expect(journeyLogsLink(journey, () => invalid, page)).toBeUndefined();
+    });
+
+    test.each([-1, Infinity, NaN, 86_400_001])('rejects invalid duration %s', durationMs => {
+        const journey = { ...event().journey, durationMs, steps: [] };
+        expect(journeyLogsLink(journey, () => user, page)).toBeUndefined();
+    });
+
+    test('deduplicates identical user and email values', () => {
+        const link = journeyLogsLink(event().journey, () => ({ ...user, email: user.name }), page)!;
+        expect(queryState(link.url).match(/Request.User/g)).toHaveLength(1);
+    });
+
+    test('escapes quotes and exclamation marks at both KQL and Rison layers', () => {
+        const name = `O'Neil!" OR *`;
+        const link = journeyLogsLink(
+            event().journey,
+            () => ({ ...user, name, email: undefined }),
+            page
+        )!;
+        expect(queryState(link.url)).toContain(`Request.User: "O!'Neil!!\\" OR *"`);
+        expect(queryState(link.url)).toContain('Context.TenantName: "test_tenant" AND (');
+    });
+
+    test('request caps still apply on good journeys', () => {
+        const payload = event('good');
+        payload.journey.steps = Array.from({ length: 50 }, (_, index) => ({
+            ...payload.journey.steps[0],
+            name: `step-${index}`,
+        }));
+        const safe = sanitizeJourneyEvent(payload);
+        expect(
+            safe.journey.steps.reduce((count, step) => count + (step.requests?.length ?? 0), 0)
+        ).toBe(MAX_JOURNEY_CORRELATED_REQUESTS);
+        expect(safe.journey.outcome).toBe('good');
+        expect(safe.journey.steps[0].requestsTruncated).toBe(true);
+    });
+
+    test('does not turn non-production user context into a production log link', () => {
+        const journey = { ...event().journey, steps: [] };
+        expect(
+            journeyLogsLink(journey, () => user, 'https://qa.servicetitan.com/')
+        ).toBeUndefined();
+    });
+
+    test('a throwing getUser cannot prevent captured request links', () => {
+        expect(
+            journeyLogsLink(
+                event().journey,
+                () => {
+                    throw new Error('unavailable');
+                },
+                page
+            )?.scope
+        ).toBe('related_requests');
+    });
+});
+
+describe('[journey] verified monolith origins', () => {
+    test.each([
+        'https://go.servicetitan.com/path',
+        'https://testtenant.eh.go.servicetitan.com/path',
+        'https://test_tenant.eh.go.servicetitan.com/path',
+    ])('accepts %s', url => expect(isMonolithLogOrigin(url)).toBe(true));
+
+    test.each([
+        'https://go.servicetitan.com.attacker.test',
+        'https://test.eh.go.servicetitan.com.attacker.test',
+        'https://qa.servicetitan.com',
+        'https://foo.go.servicetitan.com',
+        'https://go.servicetitan.com:8443',
+        'https://user:secret@go.servicetitan.com',
+        'http://go.servicetitan.com',
+        'not-a-url',
+    ])('rejects %s', url => expect(isMonolithLogOrigin(url)).toBe(false));
+});

package/src/core/index.ts

@@ -20,6 +20,7 @@ export {
 export type {
     JourneyDef,
     JourneyEvent,
+    JourneyRequestEvent,
     JourneyHandle,
     JourneyNameLike,
     JourneySink,

package/src/core/request-correlation.ts

@@ -0,0 +1,51 @@
+import type { JourneyRequestEvent } from './types';
+
+export const MAX_CORRELATED_REQUESTS = 5;
+export const MAX_JOURNEY_CORRELATED_REQUESTS = 20;
+
+/** Only allow a Cloudflare Ray ID and bounded numeric response metadata onto the wire. */
+export function sanitizeRequestCorrelation(
+    value: JourneyRequestEvent
+): JourneyRequestEvent | undefined {
+    if (
+        !value ||
+        typeof value.rayId !== 'string' ||
+        !/^[a-f0-9]{16}(?:-[a-z]{3})?$/i.test(value.rayId) ||
+        !Number.isFinite(value.startedAtEpoch) ||
+        value.startedAtEpoch <= 0 ||
+        value.startedAtEpoch > 8.64e15 - 2 * 86_400_000 ||
+        !Number.isFinite(value.durationMs) ||
+        value.durationMs < 0 ||
+        value.durationMs > 86_400_000 ||
+        !Number.isInteger(value.status) ||
+        value.status < 100 ||
+        value.status > 599
+    ) {
+        return undefined;
+    }
+    return {
+        rayId: value.rayId.toLowerCase(),
+        startedAtEpoch: Math.round(value.startedAtEpoch),
+        durationMs: Math.round(value.durationMs),
+        status: value.status,
+    };
+}
+
+/** Production monolith origins whose Ray IDs have been verified against the log data view. */
+export function isMonolithLogOrigin(value: string): boolean {
+    try {
+        const url = new URL(value);
+        return (
+            url.protocol === 'https:' &&
+            !url.port &&
+            !url.username &&
+            !url.password &&
+            (url.hostname === 'go.servicetitan.com' ||
+                /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:_[a-z0-9-]+)*\.eh\.go\.servicetitan\.com$/i.test(
+                    url.hostname
+                ))
+        );
+    } catch {
+        return false;
+    }
+}

package/src/core/runtime.ts

@@ -336,6 +336,10 @@ export function createJourneyRuntime(options: JourneyRuntimeOptions = {}): Journ
             ...(s.reason ? { reason: s.reason } : {}),
             ...(s.httpStatus !== undefined ? { httpStatus: s.httpStatus } : {}),
             ...(Object.keys(s.attributes).length ? { attributes: { ...s.attributes } } : {}),
+            ...(s.requests?.length
+                ? { requests: s.requests.map(request => ({ ...request })) }
+                : {}),
+            ...(s.requestsTruncated ? { requestsTruncated: true } : {}),
         }));
 
         emit({
@@ -345,6 +349,9 @@ export function createJourneyRuntime(options: JourneyRuntimeOptions = {}): Journ
                 group: journey.group,
                 service: journey.service,
                 outcome: finalOutcome,
+                ...(finalOutcome === 'bad' && journey.scoringRequest
+                    ? { failedRequest: { ...journey.scoringRequest } }
+                    : {}),
                 ...(finalReason ? { reason: finalReason } : {}),
                 durationMs,
                 steps,

package/src/core/sanitize.ts

@@ -1,5 +1,10 @@
 import { isUnsafeKey, MAX_ATTRIBUTE_KEYS, MAX_TAG_KEYS, MAX_TAG_VALUE_LEN } from './limits';
 import type { JourneyEvent, JourneyStepEvent, TagValue } from './types';
+import {
+    MAX_CORRELATED_REQUESTS,
+    MAX_JOURNEY_CORRELATED_REQUESTS,
+    sanitizeRequestCorrelation,
+} from './request-correlation';
 
 const SANITIZED_EVENT = Symbol.for('st.journey.sanitized');
 
@@ -125,9 +130,18 @@ export function setSafeAttribute(
 }
 
 function sanitizeStep(step: JourneyStepEvent): JourneyStepEvent {
+    const { requests: rawRequests, requestsTruncated, ...rest } = step;
+    const requests = Array.isArray(rawRequests)
+        ? rawRequests
+              .slice(0, MAX_CORRELATED_REQUESTS)
+              .map(sanitizeRequestCorrelation)
+              .filter(request => request !== undefined)
+        : [];
     const name = normalizeTagValue(step.name);
     return {
-        ...step,
+        ...rest,
+        ...(requests.length ? { requests } : {}),
+        ...(requestsTruncated === true ? { requestsTruncated: true } : {}),
         name: name || step.name,
         ...(step.reason ? { reason: normalizeTagValue(step.reason) } : {}),
         ...(step.attributes
@@ -149,6 +163,28 @@ export function sanitizeJourneyEvent(event: JourneyEvent): JourneyEvent {
         ? copyRecord(j.tags, { maxKeys: MAX_TAG_KEYS, normalizeKeys: true })
         : undefined;
     const tagKeys = tags ? Object.keys(tags) : [];
+    const steps = j.steps.map(sanitizeStep);
+    // Prefer recently started steps at the cap; failedRequest preserves the scoring request separately.
+    let requestBudget = MAX_JOURNEY_CORRELATED_REQUESTS;
+    for (let index = steps.length - 1; index >= 0; index--) {
+        const step = steps[index];
+        if (!step.requests) {
+            continue;
+        }
+        if (step.requests.length > requestBudget) {
+            step.requestsTruncated = true;
+            if (requestBudget === 0) {
+                delete step.requests;
+            } else {
+                step.requests = step.requests.slice(-requestBudget);
+            }
+        }
+        requestBudget -= step.requests?.length ?? 0;
+    }
+    const failedRequest =
+        j.outcome === 'bad' && j.failedRequest
+            ? sanitizeRequestCorrelation(j.failedRequest)
+            : undefined;
     const sanitized: JourneyEvent = {
         journey: {
             name: normalizeTagValue(j.name),
@@ -156,9 +192,10 @@ export function sanitizeJourneyEvent(event: JourneyEvent): JourneyEvent {
             group: normalizeTagValue(j.group),
             service: normalizeTagValue(j.service),
             outcome: j.outcome,
+            ...(failedRequest ? { failedRequest } : {}),
             ...(j.reason ? { reason: normalizeTagValue(j.reason) } : {}),
             durationMs: j.durationMs,
-            steps: j.steps.map(sanitizeStep),
+            steps,
             ...(expected?.length ? { expected } : {}),
             ...(tagKeys.length ? { tags } : {}),
         },

package/src/core/types.ts

@@ -134,6 +134,16 @@ export interface JourneyState {
     /** Frozen snapshot taken at start — not the caller's original object. */
     config: JourneyDef;
     [JOURNEY_ENGINE]?: JourneyEngine;
+    /** Present only during synchronous HTTP scoring, so finish can identify the causing request. */
+    scoringRequest?: JourneyRequestEvent;
+}
+
+/** Response correlation for production monolith logs. Never a metric tag. */
+export interface JourneyRequestEvent {
+    rayId: string;
+    startedAtEpoch: number;
+    durationMs: number;
+    status: number;
 }
 
 /** @internal Engine in-flight / completed step record — not part of the supported public API. */
@@ -150,6 +160,9 @@ export interface StepRecord {
     onHttpAborted?: boolean;
     /** @internal Request keys attributed while this step was in flight (debug). */
     attributedRequestKeys?: string[];
+    /** Bounded response metadata; no URLs, bodies, or other headers. */
+    requests?: JourneyRequestEvent[];
+    requestsTruncated?: boolean;
 }
 
 export interface JourneyStepEvent {
@@ -161,6 +174,9 @@ export interface JourneyStepEvent {
     reason?: string;
     httpStatus?: number;
     attributes?: Record<string, TagValue>;
+    /** Correlated requests on bad journeys, not necessarily the cause of a business error. */
+    requests?: JourneyRequestEvent[];
+    requestsTruncated?: boolean;
 }
 
 /**
@@ -200,6 +216,8 @@ export interface JourneyEvent {
         reason?: string;
         durationMs: number;
         steps: JourneyStepEvent[];
+        /** Present only when a correlated HTTP report synchronously closed the journey as bad. */
+        failedRequest?: JourneyRequestEvent;
         expected?: string[];
         tags?: Record<string, TagValue>;
     };

package/src/index.ts

@@ -60,7 +60,7 @@ export {
 export { sendToConsole } from './sinks/console';
 export { normalizeTagValue, sendToDatadog, setJourneyRum } from './sinks/datadog';
 
-export type { JourneyEvent, JourneyStepEvent, TagValue } from './core';
+export type { JourneyEvent, JourneyRequestEvent, JourneyStepEvent, TagValue } from './core';
 
 export { useJourneyName, useOptionalJourneyName } from './integrations/react/context';
 export { JourneyScope } from './integrations/react/scope';

package/src/integrations/axios.ts

@@ -60,6 +60,7 @@ function reportTiming(
         requestKey: key,
         aborted,
         url: config.url,
+        baseURL: config.baseURL ?? instance.defaults.baseURL,
         method: config.method,
         meta: config,
         request: extras?.request ?? config,

package/src/integrations/http-report.ts

@@ -10,6 +10,7 @@ import { canRouteHttpToJourney, resolveJourneyEngine } from '../core/runtime';
 import type { JourneyStepStamp } from '../core/step-tag';
 import type { StepRecord } from '../core/types';
 import type { JourneyTimedMeta } from './request-key';
+import { captureRequestCorrelation } from './request-correlation';
 
 export interface HttpCompleteReport {
     stamp: JourneyStepStamp | undefined;
@@ -18,6 +19,8 @@ export interface HttpCompleteReport {
     requestKey: string;
     aborted?: boolean;
     url?: string;
+    /** Actual request base, used only to validate the log-correlation origin. */
+    baseURL?: string;
     method?: string;
     /** Per-request literal overrides from JourneyTimedMeta. */
     meta?: JourneyTimedMeta;
@@ -73,19 +76,7 @@ function httpScoreReason(report: HttpCompleteReport): string {
  * 4xx with policy `'continue'` (default) still scores latency.
  */
 export function onHttpComplete(report: HttpCompleteReport): void {
-    const {
-        stamp,
-        status,
-        durationMs,
-        requestKey,
-        aborted,
-        url,
-        method,
-        meta,
-        request,
-        response,
-        error,
-    } = report;
+    const { stamp, requestKey, aborted, meta } = report;
     if (!stamp) {
         return;
     }
@@ -124,6 +115,34 @@ export function onHttpComplete(report: HttpCompleteReport): void {
         return;
     }
 
+    // Capture before a policy/latency breach synchronously emits the terminal event.
+    const correlation = captureRequestCorrelation(report);
+    const previous = step.journey.scoringRequest;
+    // Scope this pointer to scoring. Later JS/business failures must not blame the last request.
+    step.journey.scoringRequest = correlation;
+    try {
+        scoreHttpComplete(report, step);
+    } finally {
+        step.journey.scoringRequest = previous;
+    }
+}
+
+function scoreHttpComplete(report: HttpCompleteReport, step: StepRecord): void {
+    const {
+        stamp,
+        status,
+        durationMs,
+        requestKey,
+        aborted,
+        url,
+        method,
+        meta,
+        request,
+        response,
+        error,
+    } = report;
+    const engine = resolveJourneyEngine(step.journey);
+
     const ctx: JourneyHttpPolicyContext = {
         requestKey,
         status,
@@ -134,7 +153,7 @@ export function onHttpComplete(report: HttpCompleteReport): void {
         stepName: step.name,
     };
 
-    const score = stamp.score;
+    const score = stamp?.score;
     if (score) {
         let policy: JourneyRequestPolicy | undefined;
         try {

package/src/integrations/jquery/instrument.ts

@@ -5,7 +5,8 @@ import {
     registerInstrumentRecord,
     type InstrumentRecord,
 } from '../../global';
-import { onHttpComplete } from '../http-report';
+import { onHttpComplete, type HttpCompleteReport } from '../http-report';
+import { captureRequestCorrelation } from '../request-correlation';
 import { requestKey, type JourneyTimedMeta } from '../request-key';
 import { acceptInstrumentTarget } from '../soft-skip';
 
@@ -14,6 +15,8 @@ export interface JqueryXHR {
     statusText?: string;
     stamp?: unknown;
     journeyStart?: number;
+    getResponseHeader?(name: string): string | null;
+    always?(callback: () => void): unknown;
 }
 
 export interface JqueryAjaxSettings extends JourneyTimedMeta {
@@ -39,7 +42,10 @@ export interface JqueryStatic {
     };
 }
 
-function reportTiming(jqXHR: JqueryXHR, settings: JqueryAjaxSettings): void {
+function timingReport(
+    jqXHR: JqueryXHR,
+    settings: JqueryAjaxSettings
+): HttpCompleteReport | undefined {
     const stamp = jqueryStamps.get(jqXHR) ?? adoptJourneyStepStamp(jqXHR.stamp);
     if (!stamp || stamp.ignore || settings.ignore === true) {
         return;
@@ -48,7 +54,7 @@ function reportTiming(jqXHR: JqueryXHR, settings: JqueryAjaxSettings): void {
     const aborted = jqXHR.statusText === 'abort';
     // jQuery uses status 0 for network / abort failures — treat like a missing status.
     const status = aborted || jqXHR.status === 0 ? undefined : jqXHR.status;
-    onHttpComplete({
+    return {
         stamp,
         status,
         durationMs: globalThis.performance.now() - start,
@@ -59,7 +65,7 @@ function reportTiming(jqXHR: JqueryXHR, settings: JqueryAjaxSettings): void {
         meta: settings,
         request: settings,
         response: jqXHR,
-    });
+    };
 }
 
 function isJqueryStatic(value: unknown): value is JqueryStatic {
@@ -118,6 +124,29 @@ export function instrumentJquery($: JqueryStatic | null | undefined): () => void
                     return;
                 }
                 stampAjax(jqXHR, options);
+                /*
+                 * Prefilters run before application success/error callbacks; ajaxComplete runs after.
+                 * Capture headers here, but keep verdict scoring in ajaxComplete as before.
+                 */
+                try {
+                    if (jqueryStamps.has(jqXHR)) {
+                        jqXHR.always?.(() => {
+                            if (current.disposed) {
+                                return;
+                            }
+                            try {
+                                const report = timingReport(jqXHR, options);
+                                if (report) {
+                                    captureRequestCorrelation(report);
+                                }
+                            } catch {
+                                // This observer must never interrupt application callbacks.
+                            }
+                        });
+                    }
+                } catch {
+                    // Partial jQuery-compatible clients may not support response observers.
+                }
             });
             jqueryPrefiltersInstalled.add(key);
         }
@@ -127,7 +156,10 @@ export function instrumentJquery($: JqueryStatic | null | undefined): () => void
                 if (!current || current.disposed) {
                     return;
                 }
-                reportTiming(jqXHR, settings);
+                const report = timingReport(jqXHR, settings);
+                if (report) {
+                    onHttpComplete(report);
+                }
             });
             jqueryCompletesInstalled.add(key);
         }