@servicetitan/journey 4.0.0 → 4.2.0

package/src/__tests__/integrations/request-correlation.test.ts

@@ -0,0 +1,383 @@
+/** @jest-environment jsdom */
+import { baseJourneyDef, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { excludeJourney, journeyStep } from '../../core';
+import { createJourneyRuntime, moduleRuntime } from '../../core/runtime';
+import type { StepHandle } from '../../core/types';
+import { instrumentFetch } from '../../integrations/fetch';
+import { onHttpComplete, type HttpCompleteReport } from '../../integrations/http-report';
+import { captureRequestCorrelation } from '../../integrations/request-correlation';
+import { sendToDatadog } from '../../sinks/datadog';
+
+const emit = jest.fn();
+const addAction = jest.fn();
+const ray = '0123456789abcdef-IAD';
+const epoch = 1_800_000_000_000;
+
+function report(step: StepHandle, overrides: Partial<HttpCompleteReport> = {}): HttpCompleteReport {
+    return {
+        stamp: step.stamp(),
+        status: 500,
+        durationMs: 250,
+        requestKey: '/test',
+        url: 'https://go.servicetitan.com/test?secret=do-not-emit',
+        response: { headers: { 'cf-ray': ray, 'authorization': 'do-not-emit' } },
+        ...overrides,
+    };
+}
+
+function event() {
+    return emit.mock.calls[emit.mock.calls.length - 1][0].journey;
+}
+
+describe('[journey] request correlation', () => {
+    useJourneyTestRuntime(emit);
+    beforeEach(() => {
+        jest.spyOn(Date, 'now').mockReturnValue(epoch);
+        addAction.mockClear();
+        (globalThis as Record<string, unknown>).DD_RUM = { addAction };
+    });
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>).DD_RUM;
+        jest.restoreAllMocks();
+    });
+
+    test('captures the response before a 5xx synchronously emits, with a usable URL', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            onHttpComplete(report(step));
+            expect(emit).toHaveBeenCalledTimes(1);
+        });
+        expect(event().outcome).toBe('bad');
+        expect(event().reason).toBe('request-error');
+        expect(event().steps[0].requests).toEqual([
+            {
+                rayId: ray.toLowerCase(),
+                startedAtEpoch: epoch - 250,
+                durationMs: 250,
+                status: 500,
+            },
+        ]);
+        sendToDatadog(emit.mock.calls[0][0]);
+        const context = addAction.mock.calls[0][1];
+        const request = context.journey.steps[0].requests[0];
+        expect(request.request_id).toBe(ray.toLowerCase());
+        expect(context.journey.failed_request_id).toBe(ray.toLowerCase());
+        expect(context.journey.kibana_url).toBe(request.kibana_url);
+        expect(decodeURIComponent(request.kibana_url)).toContain(
+            'Request.RequestId: 0123456789abcdef*'
+        );
+        expect(request.kibana_url).toContain('https://kibana.st.dev/app/discover#/?');
+        expect(JSON.stringify(context)).not.toMatch(/secret|authorization|do-not-emit/);
+        expect(context.journey.tags).toBeUndefined();
+    });
+
+    test.each([
+        { status: 200, durationMs: 5000, reason: 'request-latency' },
+        {
+            status: 400,
+            meta: { httpClientErrorRequests: 'bad' as const },
+            reason: 'request-client-error',
+        },
+    ])('captures before %j is scored', async ({ reason, ...overrides }) => {
+        await journeyStep(baseJourneyDef, 'save', step => onHttpComplete(report(step, overrides)));
+        expect(event().reason).toBe(reason);
+        expect(event().steps[0].requests[0].status).toBe(overrides.status);
+    });
+
+    test.each([200, 400])('does not change the default verdict for status %s', async status => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            onHttpComplete(report(step, { status }));
+            expect(emit).not.toHaveBeenCalled();
+            step.completeJourney();
+        });
+        expect(event().outcome).toBe('good');
+        expect(event().steps[0].requests).toHaveLength(1);
+        expect(event().failedRequest).toBeUndefined();
+    });
+
+    test.each([
+        { status: undefined, response: undefined },
+        { response: { headers: {} } },
+        { response: { headers: { 'cf-ray': 'invalid OR Request.User:*' } } },
+        {
+            response: {
+                getResponseHeader() {
+                    throw new Error('blocked');
+                },
+            },
+        },
+        { url: 'https://third-party.example/test' },
+        { url: 'https://go.servicetitan.com.attacker.invalid/test' },
+        { url: '/test', baseURL: 'https://qa.servicetitan.com' },
+        { response: { headers: { 'cf-ray': ray }, url: 'https://third-party.example/test' } },
+    ])('does not invent a link or change failure scoring for %j', async overrides => {
+        await journeyStep(baseJourneyDef, 'save', step => onHttpComplete(report(step, overrides)));
+        expect(event().outcome).toBe('bad');
+        expect(event().reason).toBe('request-error');
+        expect(event().steps[0].requests).toBeUndefined();
+        expect(event().failedRequest).toBeUndefined();
+    });
+
+    test.each([{ meta: { ignore: true } }, { aborted: true, status: undefined }])(
+        'skips ignored/aborted metadata and preserves outcome for %j',
+        async overrides => {
+            await journeyStep(baseJourneyDef, 'save', step => {
+                onHttpComplete(report(step, overrides));
+                step.completeJourney();
+            });
+            expect(event().outcome).toBe('good');
+            expect(event().steps[0].requests).toBeUndefined();
+        }
+    );
+
+    test('does not record a journey-level ignored endpoint', async () => {
+        const config = { ...baseJourneyDef, endpoints: [{ match: '/test', ignore: true }] };
+        await journeyStep(config, 'save', step => {
+            onHttpComplete(report(step));
+            step.failJourney('different-failure');
+        });
+        expect(event().steps[0].requests).toBeUndefined();
+        expect(event().failedRequest).toBeUndefined();
+    });
+
+    test('captures before a request-specific score closes the journey', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            onHttpComplete(report(step, { status: 200, stamp: step.stamp(() => 'bad') }));
+        });
+        expect(event().outcome).toBe('bad');
+        expect(event().steps[0].requests).toHaveLength(1);
+    });
+
+    test('bounds requests, keeps errors, and deduplicates early/global jQuery observations', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            const first = report(step, { status: 400 });
+            captureRequestCorrelation(first);
+            onHttpComplete(first);
+            for (let n = 1; n < 9; n++) {
+                onHttpComplete(
+                    report(step, {
+                        status: 200,
+                        response: { headers: { 'cf-ray': n.toString(16).padStart(16, '0') } },
+                    })
+                );
+            }
+            onHttpComplete(
+                report(step, { response: { headers: { 'cf-ray': 'fedcba9876543210-LAX' } } })
+            );
+        });
+        const { requests, requestsTruncated } = event().steps[0];
+        expect(requests).toHaveLength(5);
+        expect(
+            requests.filter((item: { rayId: string }) => item.rayId === ray.toLowerCase())
+        ).toHaveLength(1);
+        expect(requests[4].rayId).toBe('fedcba9876543210-lax');
+        expect(requestsTruncated).toBe(true);
+    });
+
+    test('an old request cannot attach its ID to a restarted journey', async () => {
+        let old: HttpCompleteReport;
+        await journeyStep(baseJourneyDef, 'old', step => {
+            old = report(step);
+        });
+        moduleRuntime.startJourney(baseJourneyDef);
+        emit.mockClear();
+        onHttpComplete(old!);
+        expect(emit).not.toHaveBeenCalled();
+        await journeyStep(baseJourneyDef, 'new', step => {
+            onHttpComplete(report(step, { response: { headers: {} } }));
+        });
+        expect(event().steps[0].requests).toBeUndefined();
+        expect(event().failedRequest).toBeUndefined();
+    });
+
+    test('routes an explicit stamp to its owning runtime, not a same-named host journey', async () => {
+        const foreignEmit = jest.fn();
+        const foreign = createJourneyRuntime({ sinks: [foreignEmit] });
+        moduleRuntime.startJourney(baseJourneyDef);
+        await foreign.journeyStep(baseJourneyDef, 'foreign-save', step =>
+            onHttpComplete(report(step))
+        );
+        expect(foreignEmit.mock.calls[0][0].journey.steps[0].requests).toHaveLength(1);
+        expect(moduleRuntime.getOpenJourney(baseJourneyDef.name)).toBeDefined();
+        expect(emit).not.toHaveBeenCalled();
+        foreign.reset();
+    });
+
+    test('fetch preserves response identity and captures Headers.get before caller settlement', async () => {
+        const response = { status: 500, headers: new Headers({ 'cf-ray': ray }) };
+        const target = { fetch: jest.fn().mockResolvedValue(response) };
+        const restore = instrumentFetch({ target });
+        try {
+            await journeyStep(baseJourneyDef, 'fetch', async step => {
+                expect(
+                    await target.fetch('https://go.servicetitan.com/test', { stamp: step.stamp() })
+                ).toBe(response);
+                expect(emit).toHaveBeenCalledTimes(1);
+            });
+            expect(event().steps[0].requests).toHaveLength(1);
+        } finally {
+            restore();
+        }
+    });
+
+    test('unrelated concurrent steps receive only their explicitly stamped requests', async () => {
+        let settleFirst!: () => void;
+        const first = journeyStep({ ...baseJourneyDef, name: 'first' }, 'save', async step => {
+            await new Promise<void>(resolve => {
+                settleFirst = resolve;
+            });
+            onHttpComplete(report(step));
+        });
+        await journeyStep({ ...baseJourneyDef, name: 'second' }, 'save', step => {
+            onHttpComplete(
+                report(step, { response: { headers: { 'cf-ray': 'fedcba9876543210-IAD' } } })
+            );
+        });
+        settleFirst();
+        await first;
+        expect(
+            emit.mock.calls.map(call => [
+                call[0].journey.name,
+                call[0].journey.steps[0].requests[0].rayId,
+            ])
+        ).toEqual([
+            ['second', 'fedcba9876543210-iad'],
+            ['first', ray.toLowerCase()],
+        ]);
+    });
+    test('does not blame a previous HTTP response for a later business failure', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            onHttpComplete(report(step, { status: 200 }));
+            step.failJourney('business-validation');
+        });
+        expect(event().steps[0].requests).toHaveLength(1);
+        expect(event().failedRequest).toBeUndefined();
+        sendToDatadog(emit.mock.calls[0][0]);
+        expect(addAction.mock.calls[0][1].journey.kibana_scope).toBe('related_requests');
+        expect(addAction.mock.calls[0][1].journey.failed_request_id).toBeUndefined();
+    });
+
+    test('a successful response never replaces an earlier captured failure', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            for (let n = 1; n <= 5; n++) {
+                captureRequestCorrelation(
+                    report(step, {
+                        response: { headers: { 'cf-ray': n.toString(16).padStart(16, '0') } },
+                    })
+                );
+            }
+            captureRequestCorrelation(report(step, { status: 200 }));
+            step.failJourney('application-error');
+        });
+        expect(event().steps[0].requests).toHaveLength(5);
+        expect(
+            event().steps[0].requests.every((item: { status: number }) => item.status === 500)
+        ).toBe(true);
+    });
+    test('a later network failure has no top-level link to an earlier successful request', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            onHttpComplete(report(step, { status: 200 }));
+            onHttpComplete(report(step, { status: undefined, response: undefined }));
+        });
+        expect(event().reason).toBe('request-error');
+        expect(event().failedRequest).toBeUndefined();
+        expect(event().steps[0].requests).toHaveLength(1);
+    });
+
+    test('a slow successful response still gets its failure link when the step history is full', async () => {
+        await journeyStep(baseJourneyDef, 'save', step => {
+            for (let n = 1; n <= 5; n++) {
+                captureRequestCorrelation(
+                    report(step, {
+                        response: { headers: { 'cf-ray': n.toString(16).padStart(16, '0') } },
+                    })
+                );
+            }
+            onHttpComplete(report(step, { status: 200, durationMs: 5000 }));
+        });
+        expect(event().reason).toBe('request-latency');
+        expect(event().failedRequest.rayId).toBe(ray.toLowerCase());
+    });
+
+    test.each(['continue', 'exclude'] as const)(
+        'preserves the request-specific %s policy',
+        async policy => {
+            await journeyStep(baseJourneyDef, 'save', step => {
+                onHttpComplete(report(step, { stamp: step.stamp(() => policy) }));
+                if (policy === 'continue') {
+                    expect(emit).not.toHaveBeenCalled();
+                    step.completeJourney();
+                }
+            });
+            expect(event().outcome).toBe(policy === 'continue' ? 'good' : 'excluded');
+            expect(event().failedRequest).toBeUndefined();
+            expect(event().steps[0].requests).toHaveLength(1);
+        }
+    );
+});
+
+describe('[journey] request links independent of verdict', () => {
+    useJourneyTestRuntime(emit);
+    beforeEach(() => {
+        jest.spyOn(Date, 'now').mockReturnValue(epoch);
+        addAction.mockClear();
+        (globalThis as Record<string, unknown>).DD_RUM = { addAction };
+    });
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>).DD_RUM;
+        jest.restoreAllMocks();
+    });
+
+    test.each(['good', 'excluded'] as const)('keeps successful request details on %s', outcome => {
+        return journeyStep(baseJourneyDef, 'load', step => {
+            onHttpComplete(report(step, { status: 200 }));
+            if (outcome === 'good') {
+                step.completeJourney();
+            } else {
+                excludeJourney(baseJourneyDef.name);
+            }
+        }).then(() => {
+            expect(event().outcome).toBe(outcome);
+            expect(event().steps[0].requests).toHaveLength(1);
+            sendToDatadog(emit.mock.calls[0][0]);
+            const j = addAction.mock.calls[0][1].journey;
+            expect(j.kibana_scope).toBe('related_requests');
+            expect(j.steps[0].requests[0].http_status).toBe(200);
+            expect(j.steps[0].requests[0].kibana_url).toContain('https://kibana.st.dev/');
+            expect(j.failed_request_id).toBeUndefined();
+        });
+    });
+
+    test('step-error keeps its request link without claiming HTTP scoring caused it', async () => {
+        const failure = new Error('application error');
+        await expect(
+            journeyStep(baseJourneyDef, 'save', step => {
+                captureRequestCorrelation(report(step));
+                throw failure;
+            })
+        ).rejects.toBe(failure);
+        expect(event().reason).toBe('step-error');
+        sendToDatadog(emit.mock.calls[0][0]);
+        const j = addAction.mock.calls[0][1].journey;
+        expect(j.kibana_scope).toBe('related_requests');
+        expect(j.failed_request_id).toBeUndefined();
+        expect(j.steps[0].requests[0].http_status).toBe(500);
+    });
+
+    test('captures request IDs from verified Enterprise Hub monolith endpoints', async () => {
+        await journeyStep(baseJourneyDef, 'save', step =>
+            onHttpComplete(
+                report(step, {
+                    url: 'https://test_tenant.eh.go.servicetitan.com/test',
+                    response: {
+                        headers: { 'cf-ray': ray },
+                        responseURL: 'https://test_tenant.eh.go.servicetitan.com/test',
+                    },
+                })
+            )
+        );
+        expect(event().outcome).toBe('bad');
+        expect(event().failedRequest.rayId).toBe(ray.toLowerCase());
+        sendToDatadog(emit.mock.calls[0][0]);
+        expect(addAction.mock.calls[0][1].journey.kibana_scope).toBe('request');
+    });
+});

package/src/__tests__/sinks/datadog-links.test.ts

@@ -0,0 +1,58 @@
+/**
+ * @jest-environment jsdom
+ * @jest-environment-options {"url": "https://go.servicetitan.com/"}
+ */
+import type { JourneyEvent } from '../../core/types';
+import { sendToDatadog } from '../../sinks/datadog';
+
+function sampleEvent(overrides: Partial<JourneyEvent['journey']> = {}): JourneyEvent {
+    return {
+        journey: {
+            name: 'test',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            outcome: 'good',
+            durationMs: 120,
+            steps: [],
+            ...overrides,
+        },
+    };
+}
+
+describe('[journey] link visibility independent of failure reason', () => {
+    const addAction = jest.fn();
+    const getUser = jest.fn();
+    beforeEach(() => {
+        addAction.mockClear();
+        getUser.mockReset().mockReturnValue({ tenant: 'test_tenant', name: 'test-agent' });
+        (globalThis as Record<string, unknown>).DD_RUM = { addAction, getUser };
+    });
+    afterEach(() => {
+        delete (globalThis as Record<string, unknown>).DD_RUM;
+    });
+
+    test.each(['step-error', 'request-error', 'step-timeout', 'journey-timeout'])(
+        'always uses the same visible field for %s with host user context',
+        reason => {
+            sendToDatadog(sampleEvent({ outcome: 'bad', reason }));
+            const j = addAction.mock.calls[0][1].journey;
+            expect(j.kibana_url).toContain('https://kibana.st.dev/app/discover');
+            expect(j.kibana_scope).toBe('related_logs');
+            expect(j.failed_request_id).toBeUndefined();
+            expect(j.reason).toBe(reason);
+            expect(j.outcome).toBe('bad');
+        }
+    );
+
+    test('getUser failure does not lose an event without requests', () => {
+        getUser.mockImplementation(() => {
+            throw new Error('getUser unavailable');
+        });
+        expect(() =>
+            sendToDatadog(sampleEvent({ reason: 'step-error', outcome: 'bad' }))
+        ).not.toThrow();
+        expect(addAction).toHaveBeenCalledTimes(1);
+        expect(addAction.mock.calls[0][1].journey.outcome).toBe('bad');
+    });
+});