@servicetitan/journey 4.1.0 → 4.2.0

package/src/core/request-correlation.ts

@@ -30,3 +30,22 @@ export function sanitizeRequestCorrelation(
         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,10 +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 } } : {}),
-            ...(finalOutcome === 'bad' && s.requests?.length
+            ...(s.requests?.length
                 ? { requests: s.requests.map(request => ({ ...request })) }
                 : {}),
-            ...(finalOutcome === 'bad' && s.requestsTruncated ? { requestsTruncated: true } : {}),
+            ...(s.requestsTruncated ? { requestsTruncated: true } : {}),
         }));
 
         emit({

package/src/core/sanitize.ts

@@ -129,20 +129,19 @@ export function setSafeAttribute(
     }
 }
 
-function sanitizeStep(step: JourneyStepEvent, includeRequests: boolean): JourneyStepEvent {
+function sanitizeStep(step: JourneyStepEvent): JourneyStepEvent {
     const { requests: rawRequests, requestsTruncated, ...rest } = step;
-    const requests =
-        includeRequests && Array.isArray(rawRequests)
-            ? rawRequests
-                  .slice(0, MAX_CORRELATED_REQUESTS)
-                  .map(sanitizeRequestCorrelation)
-                  .filter(request => request !== undefined)
-            : [];
+    const requests = Array.isArray(rawRequests)
+        ? rawRequests
+              .slice(0, MAX_CORRELATED_REQUESTS)
+              .map(sanitizeRequestCorrelation)
+              .filter(request => request !== undefined)
+        : [];
     const name = normalizeTagValue(step.name);
     return {
         ...rest,
         ...(requests.length ? { requests } : {}),
-        ...(includeRequests && requestsTruncated === true ? { requestsTruncated: true } : {}),
+        ...(requestsTruncated === true ? { requestsTruncated: true } : {}),
         name: name || step.name,
         ...(step.reason ? { reason: normalizeTagValue(step.reason) } : {}),
         ...(step.attributes
@@ -164,7 +163,7 @@ 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(step => sanitizeStep(step, j.outcome === 'bad'));
+    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--) {

package/src/integrations/request-correlation.ts

@@ -1,9 +1,12 @@
-import { MAX_CORRELATED_REQUESTS, sanitizeRequestCorrelation } from '../core/request-correlation';
+import {
+    isMonolithLogOrigin,
+    MAX_CORRELATED_REQUESTS,
+    sanitizeRequestCorrelation,
+} from '../core/request-correlation';
 import { canRouteHttpToJourney, resolveJourneyEngine } from '../core/runtime';
 import type { HttpCompleteReport } from './http-report';
 import type { JourneyRequestEvent } from '../core/types';
 
-const MONOLITH_ORIGIN = 'https://go.servicetitan.com';
 const capturedResponses = new WeakMap<object, JourneyRequestEvent>();
 
 interface ResponseHeaders {
@@ -37,7 +40,7 @@ export function captureRequestCorrelation(
         const pageUrl = globalThis.location?.href;
         const base = report.baseURL ? new URL(report.baseURL, pageUrl).href : pageUrl;
         const url = new URL(report.url, base);
-        if (url.origin !== MONOLITH_ORIGIN) {
+        if (!isMonolithLogOrigin(url.href)) {
             return;
         }
         const response = report.response as ResponseHeaders | undefined;
@@ -49,7 +52,7 @@ export function captureRequestCorrelation(
             return step.requests?.includes(captured) ? captured : undefined;
         }
         const finalUrl = response.url || response.responseURL || response.request?.responseURL;
-        if (finalUrl && new URL(finalUrl).origin !== MONOLITH_ORIGIN) {
+        if (finalUrl && !isMonolithLogOrigin(finalUrl)) {
             return;
         }
         const rayId =

package/src/sinks/datadog.ts

@@ -1,7 +1,7 @@
 import { isSanitizedJourneyEvent, sanitizeJourneyEvent } from '../core/sanitize';
 import { getJourneyRumFallback, setJourneyRumFallback } from '../global';
 import type { JourneyEvent, JourneyStepEvent } from '../core/types';
-import { requestLogsUrl } from './kibana';
+import { journeyLogsLink, requestLogsUrl } from './kibana';
 
 export { normalizeTagValue } from '../core/sanitize';
 
@@ -15,6 +15,7 @@ const DD_RUM_KEY = 'DD_RUM';
  */
 interface RumLike {
     addAction(name: string, context?: object): void;
+    getUser?(): unknown;
 }
 
 function getDdRum(): RumLike | undefined {
@@ -84,6 +85,7 @@ export function sendToDatadog(payload: JourneyEvent): void {
     const j = isSanitizedJourneyEvent(payload)
         ? payload.journey
         : sanitizeJourneyEvent(payload).journey;
+    const logs = journeyLogsLink(j, () => rum.getUser?.(), globalThis.location?.href);
     /* eslint-disable @typescript-eslint/naming-convention -- Datadog RUM wire format (snake_case) */
     rum.addAction(JOURNEY_ACTION, {
         journey: {
@@ -95,9 +97,9 @@ export function sendToDatadog(payload: JourneyEvent): void {
             ...(j.failedRequest
                 ? {
                       failed_request_id: j.failedRequest.rayId,
-                      kibana_url: requestLogsUrl(j.failedRequest),
                   }
                 : {}),
+            ...(logs ? { kibana_url: logs.url, kibana_scope: logs.scope } : {}),
             ...(j.reason ? { reason: j.reason } : {}),
             duration_ms: j.durationMs,
             steps: j.steps.map(toDatadogStep),

package/src/sinks/kibana.ts

@@ -1,5 +1,9 @@
-import { sanitizeRequestCorrelation } from '../core/request-correlation';
-import type { JourneyRequestEvent } from '../core/types';
+import {
+    isMonolithLogOrigin,
+    MAX_JOURNEY_CORRELATED_REQUESTS,
+    sanitizeRequestCorrelation,
+} from '../core/request-correlation';
+import type { JourneyEvent, JourneyRequestEvent } from '../core/types';
 
 const DISCOVER_URL = 'https://kibana.st.dev/app/discover#/';
 // Production monolith logs; deliberately not the user's default data view.
@@ -18,7 +22,119 @@ export function requestLogsUrl(value: JourneyRequestEvent): string | undefined {
     ).toISOString();
     // Origin/edge datacenter suffixes can differ. Match the hex prefix within the request window.
     const rayPrefix = request.rayId.slice(0, 16);
+    return discoverUrl(`Request.RequestId: ${rayPrefix}*`, from, to);
+}
+
+interface JourneyLogLink {
+    url: string;
+    scope: 'request' | 'related_requests' | 'related_logs';
+}
+
+function discoverUrl(query: string, from: string, to: string): string {
     const globalState = `(refreshInterval:(pause:!t,value:0),time:(from:'${from}',to:'${to}'))`;
-    const appState = `(dataSource:(type:dataView,dataViewId:'${DATA_VIEW_ID}'),query:(language:kuery,query:'Request.RequestId: ${rayPrefix}*'))`;
+    // The query is a quoted Rison string containing a separately escaped KQL expression.
+    const quotedQuery = query.replace(/!/g, '!!').replace(/'/g, "!'");
+    const appState = `(dataSource:(type:dataView,dataViewId:'${DATA_VIEW_ID}'),query:(language:kuery,query:'${quotedQuery}'))`;
     return `${DISCOVER_URL}?_g=${encodeURIComponent(globalState)}&_a=${encodeURIComponent(appState)}`;
 }
+
+function userValue(value: unknown): string | undefined {
+    return typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= 254 &&
+        // eslint-disable-next-line no-control-regex -- Reject controls in log query values.
+        !/[\u0000-\u001f\u007f]/.test(value)
+        ? value
+        : undefined;
+}
+
+function kqlValue(value: string): string {
+    return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function relatedLogsUrl(
+    durationMs: number,
+    user: unknown,
+    pageUrl: string | undefined
+): string | undefined {
+    if (
+        !pageUrl ||
+        !isMonolithLogOrigin(pageUrl) ||
+        !user ||
+        typeof user !== 'object' ||
+        !Number.isFinite(durationMs) ||
+        durationMs < 0 ||
+        durationMs > 86_400_000
+    ) {
+        return;
+    }
+    const context = user as Record<string, unknown>;
+    const tenant = userValue(context.tenant);
+    const users = [...new Set([userValue(context.name), userValue(context.email)])].filter(
+        (value): value is string => value !== undefined
+    );
+    // Never fall back to all tenants or all users when identity is missing.
+    if (!tenant || !/^[a-z0-9][a-z0-9_-]*$/i.test(tenant) || users.length === 0) {
+        return;
+    }
+    const query = `Context.TenantName: ${kqlValue(tenant)} AND (${users
+        .map(value => `Request.User: ${kqlValue(value)}`)
+        .join(' OR ')})`;
+    const now = Date.now();
+    return discoverUrl(
+        query,
+        new Date(now - durationMs - WINDOW_PADDING_MS).toISOString(),
+        new Date(now + WINDOW_PADDING_MS).toISOString()
+    );
+}
+
+/** Keep one visible link without claiming unrelated requests caused a JS/business failure. */
+export function journeyLogsLink(
+    journey: JourneyEvent['journey'],
+    getUser?: () => unknown,
+    pageUrl?: string
+): JourneyLogLink | undefined {
+    if (journey.failedRequest) {
+        const url = requestLogsUrl(journey.failedRequest);
+        if (url) {
+            return { url, scope: 'request' };
+        }
+    }
+
+    /*
+     * With no identified failure request, search this user's logs during the journey.
+     * RUM stubs/older hosts can lack getUser; enrichment must never prevent emission.
+     */
+    try {
+        const url = relatedLogsUrl(journey.durationMs, getUser?.(), pageUrl);
+        if (url) {
+            return { url, scope: 'related_logs' };
+        }
+    } catch {
+        // Retain request-only links if session context is unavailable or malformed.
+    }
+
+    const requests = journey.steps
+        .flatMap(step => step.requests ?? [])
+        .slice(0, MAX_JOURNEY_CORRELATED_REQUESTS)
+        .map(sanitizeRequestCorrelation)
+        .filter((request): request is JourneyRequestEvent => request !== undefined);
+    if (!requests.length) {
+        return;
+    }
+    const prefixes = [...new Set(requests.map(request => request.rayId.slice(0, 16)))];
+    const query = prefixes.map(prefix => `Request.RequestId: ${prefix}*`).join(' OR ');
+    return {
+        url: discoverUrl(
+            query,
+            new Date(
+                Math.min(...requests.map(request => request.startedAtEpoch)) - WINDOW_PADDING_MS
+            ).toISOString(),
+            new Date(
+                Math.max(...requests.map(request => request.startedAtEpoch + request.durationMs)) +
+                    WINDOW_PADDING_MS
+            ).toISOString()
+        ),
+        scope: 'related_requests',
+    };
+}