@servicetitan/journey 2.1.0 → 3.0.0

package/src/__tests__/core/requests.test.ts

@@ -9,17 +9,17 @@ import {
     completeJourney,
     journeyStep,
     reportBackendRequest,
-    resolveJourneyStep,
     type JourneyDef,
-    type JourneyStepRef,
+    type JourneyStepStamp,
 } from '../../core';
+import type { StepRecord } from '../../core/types';
 import { moduleRuntime } from '../../core/runtime';
 
 const emitMock = jest.fn();
 const baseDef = { ...baseJourneyDef, name: 'requests-journey' };
 
 describe('[journey] reportBackendRequest', () => {
-    let stepRef: JourneyStepRef | undefined;
+    let stepRef: StepRecord | undefined;
     let status: number | undefined;
     let durationMs: number;
     let key: string;
@@ -36,12 +36,12 @@ describe('[journey] reportBackendRequest', () => {
     const subject = () => reportBackendRequest(stepRef, status, durationMs, key);
 
     async function withOpenStep(
-        run: (ref: JourneyStepRef) => void | Promise<void>,
-        def: JourneyDef = { ...baseDef, requestTimeoutMs: 5_000 }
+        run: (ref: StepRecord) => void | Promise<void>,
+        def: JourneyDef = { ...baseDef, slowRequestMs: 5_000 }
     ) {
         moduleRuntime.startJourney(def);
         await journeyStep(baseDef.name, 'do-work', async step => {
-            stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+            stepRef = (step.stamp() as JourneyStepStamp).step;
             await run(stepRef!);
         });
     }
@@ -100,7 +100,7 @@ describe('[journey] reportBackendRequest', () => {
                 () => {
                     subject();
                 },
-                { ...baseDef, requestTimeoutMs: 50 }
+                { ...baseDef, slowRequestMs: 50 }
             );
 
             expect(lastJourney(emitMock).reason).toBe('request-latency');
@@ -160,7 +160,7 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
+                    slowRequestMs: 5_000,
                     endpoints: [{ match: '/flaky', ignore: true }],
                 }
             );
@@ -170,28 +170,29 @@ describe('[journey] reportBackendRequest', () => {
         });
     });
 
-    describe('when a journey endpoint timeoutMs is 0', () => {
-        test('falls through to the journey requestTimeoutMs', async () => {
+    describe('when a journey endpoint slowRequestMs is 0', () => {
+        test('never scores latency for that prefix', async () => {
             moduleRuntime.startJourney({
                 ...baseDef,
-                requestTimeoutMs: 30,
-                endpoints: [{ match: '/special', timeoutMs: 0 }],
+                slowRequestMs: 30,
+                endpoints: [{ match: '/special', slowRequestMs: 0 }],
             });
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/special/path';
                 subject();
             });
+            completeJourney(baseDef.name);
 
-            expect(lastJourney(emitMock).reason).toBe('request-latency');
+            expect(lastJourney(emitMock).outcome).toBe('good');
         });
     });
 
     describe('when journey endpoint timeoutMs is set', () => {
-        test('wins over the journey requestTimeoutMs', async () => {
+        test('wins over the journey slowRequestMs', async () => {
             await withOpenStep(
                 () => {
                     status = 200;
@@ -201,8 +202,8 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
-                    endpoints: [{ match: '/special', timeoutMs: 20 }],
+                    slowRequestMs: 5_000,
+                    endpoints: [{ match: '/special', slowRequestMs: 20 }],
                 }
             );
 
@@ -213,7 +214,7 @@ describe('[journey] reportBackendRequest', () => {
     describe('when the journey endpoint ignore overrides the app-wide policy', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 4_000,
                     endpoints: [{ match: '/flaky', ignore: true }],
                 },
@@ -229,7 +230,7 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
+                    slowRequestMs: 5_000,
                     endpoints: [{ match: '/flaky', ignore: false }],
                 }
             );
@@ -241,11 +242,11 @@ describe('[journey] reportBackendRequest', () => {
     describe('when only app-wide endpoint policies apply', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 4_000,
                     endpoints: [
                         { match: '/ignored', ignore: true },
-                        { match: '/tight', timeoutMs: 30 },
+                        { match: '/tight', slowRequestMs: 30 },
                     ],
                 },
             });
@@ -274,41 +275,42 @@ describe('[journey] reportBackendRequest', () => {
         });
     });
 
-    describe('when app endpoint timeoutMs is 0', () => {
+    describe('when app endpoint slowRequestMs is 0', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 40,
-                    endpoints: [{ match: '/loose', timeoutMs: 0 }],
+                    endpoints: [{ match: '/loose', slowRequestMs: 0 }],
                 },
             });
         });
 
-        test('falls through to defaultMs', async () => {
+        test('never scores latency for that prefix', async () => {
             moduleRuntime.startJourney(baseDef);
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/loose/x';
                 subject();
             });
+            completeJourney(baseDef.name);
 
-            expect(lastJourney(emitMock).reason).toBe('request-latency');
+            expect(lastJourney(emitMock).outcome).toBe('good');
         });
     });
 
-    describe('when the journey has no requestTimeoutMs', () => {
+    describe('when the journey has no slowRequestMs', () => {
         beforeEach(() => {
-            configureJourney({ requestTimeouts: { defaultMs: 40, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 40, endpoints: [] } });
         });
 
         test('uses the app defaultMs', async () => {
             moduleRuntime.startJourney(baseDef);
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/any';
@@ -320,7 +322,7 @@ describe('[journey] reportBackendRequest', () => {
     });
 
     describe('against a closed journey step ref', () => {
-        let closedRef: JourneyStepRef | undefined;
+        let closedRef: StepRecord | undefined;
 
         beforeEach(async () => {
             await withOpenStep(ref => {
@@ -338,4 +340,20 @@ describe('[journey] reportBackendRequest', () => {
             expect(emitMock).not.toHaveBeenCalled();
         });
     });
+
+    describe('when many distinct keys are attributed', () => {
+        test('stops recording after 50 keys', async () => {
+            await withOpenStep(ref => {
+                for (let i = 0; i < 55; i += 1) {
+                    reportBackendRequest(ref, 200, 1, `/api/${i}`);
+                }
+                expect(ref.attributedRequestKeys).toHaveLength(50);
+                expect(
+                    moduleRuntime.getDebugSnapshot().openJourneys[0].steps[0].attributedRequestKeys
+                ).toHaveLength(50);
+            });
+            completeJourney(baseDef.name);
+            expect(lastJourney(emitMock).outcome).toBe('good');
+        });
+    });
 });

package/src/__tests__/core/runtime.test.ts

@@ -1,14 +1,15 @@
 /** @jest-environment jsdom */
 import { lastJourney, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
-import { configureJourney, getRequestTimeouts } from '../../config';
+import { configureJourney, getSlowRequests } from '../../config';
 import {
-    activeJourneyStep,
     completeJourney,
     defineJourney,
     journeyStep,
     resetJourney,
+    singleInFlightJourneyStep,
 } from '../../core';
 import { createJourneyRuntime, moduleRuntime } from '../../core/runtime';
+import { registerJourneyRuntime, setJourneyDefaultEnabled } from '../../global';
 import { sendToConsole } from '../../sinks/console';
 import { sendToDatadog } from '../../sinks/datadog';
 
@@ -52,29 +53,31 @@ describe('[journey] resetJourney', () => {
 
     describe('when request timeouts were customized', () => {
         beforeEach(() => {
-            configureJourney({ requestTimeouts: { defaultMs: 100, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 100, endpoints: [] } });
         });
 
         const subject = () => resetJourney({ sinks: [emitMock] });
 
-        test('restores the 4s default', () => {
+        test('clears this runtime overlay and inherits shared policies', () => {
             subject();
 
-            expect(getRequestTimeouts().defaultMs).toBe(4_000);
+            expect(moduleRuntime.getDebugSnapshot().policyOverlay.slowRequests).toBe(false);
+            expect(moduleRuntime.getSlowRequests().defaultMs).toBe(100);
+            expect(getSlowRequests().defaultMs).toBe(100);
         });
     });
 
-    describe('when reset passes custom requestTimeouts', () => {
+    describe('when reset passes custom slowRequests', () => {
         const subject = () =>
             resetJourney({
                 sinks: [emitMock],
-                requestTimeouts: { defaultMs: 250, endpoints: [] },
+                slowRequests: { defaultMs: 250, endpoints: [] },
             });
 
-        test('applies those timeouts', () => {
+        test('applies those timeouts on the module engine', () => {
             subject();
 
-            expect(getRequestTimeouts().defaultMs).toBe(250);
+            expect(moduleRuntime.getSlowRequests().defaultMs).toBe(250);
         });
     });
 
@@ -120,11 +123,24 @@ describe('[journey] resetJourney', () => {
         const subject = () => resetJourney({ sinks: [emitMock] });
 
         test('clears the ambient step', () => {
-            expect(activeJourneyStep()).not.toBeNull();
+            expect(singleInFlightJourneyStep()).not.toBeNull();
 
             subject();
 
-            expect(activeJourneyStep()).toBeNull();
+            expect(singleInFlightJourneyStep()).toBeNull();
+        });
+
+        test('reuses the same ambient stamp while the active step is unchanged', async () => {
+            const first = singleInFlightJourneyStep();
+            const second = singleInFlightJourneyStep();
+
+            expect(first).not.toBeNull();
+            expect(second).toBe(first);
+
+            resolveWork();
+            await stepPromise;
+
+            expect(singleInFlightJourneyStep()).toBeNull();
         });
     });
 
@@ -157,19 +173,35 @@ describe('[journey] createJourneyRuntime', () => {
     let runtime: ReturnType<typeof createJourneyRuntime>;
 
     beforeEach(() => {
+        setJourneyDefaultEnabled(true);
         resetJourney({
             sinks: [defaultEmit],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
         defaultEmit.mockClear();
         isolatedEmit.mockClear();
         runtime = createJourneyRuntime({ sinks: [isolatedEmit] });
     });
 
+    test('auto-assigns a unique runtime-N id when registered without an id', () => {
+        registerJourneyRuntime(runtime);
+
+        expect(moduleRuntime.id).toMatch(/^runtime-\d+$/);
+        expect(runtime.id).toMatch(/^runtime-\d+$/);
+        expect(runtime.id).not.toBe(moduleRuntime.id);
+    });
+
+    test('uses the provided id', () => {
+        const named = createJourneyRuntime({ id: 'job-booking', sinks: [isolatedEmit] });
+        expect(named.id).toBe('job-booking');
+    });
+
     afterEach(() => {
+        setJourneyDefaultEnabled(false);
+        localStorage.clear();
         resetJourney({
             sinks: [sendToDatadog, sendToConsole],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
     });
 
@@ -192,18 +224,20 @@ describe('[journey] createJourneyRuntime', () => {
         });
     });
 
-    describe('when the isolated runtime has its own requestTimeouts', () => {
+    describe('when the isolated runtime has its own slowRequests', () => {
         beforeEach(() => {
             runtime = createJourneyRuntime({
                 sinks: [isolatedEmit],
-                requestTimeouts: { defaultMs: 10, endpoints: [] },
+                slowRequests: { defaultMs: 10, endpoints: [] },
             });
-            configureJourney({ requestTimeouts: { defaultMs: 9_000, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 9_000, endpoints: [] } });
         });
 
-        test('keeps timeouts separate from the module engine', () => {
-            expect(runtime.getRequestTimeouts().defaultMs).toBe(10);
-            expect(getRequestTimeouts().defaultMs).toBe(9_000);
+        test('inherits shared host thresholds unless this runtime overlays', () => {
+            expect(runtime.getSlowRequests().defaultMs).toBe(9_000);
+            runtime.setPolicyOverlay({ slowRequests: { defaultMs: 10, endpoints: [] } });
+            expect(runtime.getSlowRequests().defaultMs).toBe(10);
+            expect(getSlowRequests().defaultMs).toBe(9_000);
         });
     });
 
@@ -227,7 +261,7 @@ describe('[journey] createJourneyRuntime', () => {
     describe('when defineJourney is used', () => {
         const subject = () =>
             defineJourney(def).step('load', step => {
-                step.complete();
+                step.completeJourney();
             });
 
         test('binds to the module runtime', async () => {
@@ -270,4 +304,17 @@ describe('[journey] createJourneyRuntime', () => {
             expect(isolatedEmit).toHaveBeenCalledTimes(1);
         });
     });
+
+    describe('maxSteps bounds', () => {
+        test('clamps invalid and oversized values', () => {
+            moduleRuntime.setMaxSteps(Infinity);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+            moduleRuntime.setMaxSteps(0);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+            moduleRuntime.setMaxSteps(500);
+            expect(moduleRuntime.getMaxSteps()).toBe(200);
+            moduleRuntime.setMaxSteps(Number.NaN);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+        });
+    });
 });

package/src/__tests__/core/sanitize.test.ts

@@ -0,0 +1,69 @@
+/** @jest-environment jsdom */
+import { MAX_ATTRIBUTE_KEYS, MAX_TAG_KEYS, isUnsafeKey } from '../../core/limits';
+import { assignRecord, copyRecord, emptyRecord, sanitizeJourneyEvent } from '../../core/sanitize';
+import type { JourneyEvent } from '../../core/types';
+
+describe('[journey] sanitize / copyRecord', () => {
+    test('isUnsafeKey blocks proto and secret names', () => {
+        expect(isUnsafeKey('__proto__')).toBe(true);
+        expect(isUnsafeKey('constructor')).toBe(true);
+        expect(isUnsafeKey('Authorization')).toBe(true);
+        expect(isUnsafeKey('token')).toBe(true);
+        expect(isUnsafeKey('customer.id')).toBe(false);
+    });
+
+    test('JSON __proto__ assign does not pollute Object.prototype', () => {
+        const target = emptyRecord();
+        const polluted = JSON.parse('{"__proto__":{"polluted":true},"ok":1}') as Record<
+            string,
+            unknown
+        >;
+        assignRecord(target, polluted, MAX_TAG_KEYS);
+        expect(target.ok).toBe(1);
+        expect(({} as { polluted?: boolean }).polluted).toBeUndefined();
+        expect(Object.prototype.hasOwnProperty.call(target, '__proto__')).toBe(false);
+    });
+
+    test('copyRecord caps keys and drops secrets', () => {
+        const src: Record<string, string | number> = { token: 'secret', keep: 1 };
+        for (let i = 0; i < MAX_ATTRIBUTE_KEYS + 5; i += 1) {
+            src[`k${i}`] = i;
+        }
+        const out = copyRecord(src, { maxKeys: MAX_ATTRIBUTE_KEYS, normalizeKeys: true });
+        expect(out.token).toBeUndefined();
+        expect(Object.keys(out).length).toBe(MAX_ATTRIBUTE_KEYS);
+    });
+
+    test('sanitizeJourneyEvent normalizes step names and tag keys', () => {
+        const event: JourneyEvent = {
+            journey: {
+                name: 'Make A Sale!!',
+                team: 'Sales',
+                group: 'retail',
+                service: 'checkout',
+                outcome: 'good',
+                durationMs: 10,
+                expected: ['Create Sale'],
+                tags: { 'User Email': 'a@b.com', 'token': 'nope', 'plan': 'Pro' },
+                steps: [
+                    {
+                        name: 'Load Customer 1',
+                        startMs: 0,
+                        durationMs: 4,
+                        outcome: 'good',
+                        attributes: { 'token': 'x', 'Draft.id': 'abc' },
+                    },
+                ],
+            },
+        };
+        const j = sanitizeJourneyEvent(event).journey;
+        expect(j.name).toBe('make_a_sale');
+        expect(j.expected).toEqual(['create_sale']);
+        expect(j.steps[0].name).toBe('load_customer_1');
+        expect(j.tags?.user_email).toBe('a_b.com');
+        expect(j.tags?.token).toBeUndefined();
+        expect(j.tags?.plan).toBe('pro');
+        expect(j.steps[0].attributes?.token).toBeUndefined();
+        expect(j.steps[0].attributes?.['draft.id']).toBe('abc');
+    });
+});