@servicetitan/journey 3.0.1 → 4.1.0

package/src/core/runtime.ts

@@ -11,6 +11,7 @@ import {
     sortEndpointsByLongestMatch,
     type SlowRequestConfig,
 } from './endpoint-policy';
+import { deserializeJourneyState, projectJourneyState } from './persist';
 import {
     clampMaxSteps,
     DEFAULT_MAX_STEPS,
@@ -36,6 +37,7 @@ import {
     type JourneyStepOptions,
     type JourneyStepTarget,
     type Outcome,
+    type SerializedJourneyState,
     type StepHandle,
     type StepRecord,
     type TagValue,
@@ -106,7 +108,8 @@ export interface JourneyRuntimeDebugSnapshot {
     };
 }
 
-function freezeJourneyDef(config: JourneyDef, tags: Record<string, TagValue>): JourneyDef {
+/** @internal Freeze a caller-supplied journey def + tags snapshot. */
+export function freezeJourneyDef(config: JourneyDef, tags: Record<string, TagValue>): JourneyDef {
     const endpoints = sortEndpointsByLongestMatch(config.endpoints);
     return Object.freeze({
         ...config,
@@ -164,6 +167,17 @@ export interface JourneyRuntime {
     completeJourneyState(journey: JourneyState, tags?: Record<string, TagValue>): void;
     excludeJourney(journey: JourneyState): void;
     updateOpenJourney(config: JourneyDef): void;
+    /**
+     * @internal Snapshot an open journey for cross-page transfer. Does NOT
+     * close the journey. Returns `null` when no journey is open under `name`.
+     */
+    serializeJourneyState(name: string): SerializedJourneyState | null;
+    /**
+     * @internal Rehydrate a serialized journey onto this runtime. Returns
+     * `null` (after emitting a `bad` `journey-timeout` event) when the journey
+     * already exhausted its budget in transit.
+     */
+    restoreJourney(serialized: SerializedJourneyState, config: JourneyDef): JourneyState | null;
 
     activeJourneyStep(): StepRecord | null;
     journeyStep<T>(
@@ -192,7 +206,8 @@ export interface JourneyRuntime {
     reset(options?: JourneyRuntimeOptions): void;
 }
 
-function bindJourneyEngine(
+/** @internal Bind the fail/exclude/report hooks for a journey's creating engine. */
+export function bindJourneyEngine(
     api: JourneyRuntime,
     journey: JourneyState,
     shouldIgnoreRequest: (target: JourneyState, key: string) => boolean
@@ -321,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 } } : {}),
+            ...(finalOutcome === 'bad' && s.requests?.length
+                ? { requests: s.requests.map(request => ({ ...request })) }
+                : {}),
+            ...(finalOutcome === 'bad' && s.requestsTruncated ? { requestsTruncated: true } : {}),
         }));
 
         emit({
@@ -330,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,
@@ -685,6 +707,51 @@ export function createJourneyRuntime(options: JourneyRuntimeOptions = {}): Journ
             armCountdown(journey, remainingMs);
         },
 
+        serializeJourneyState(name) {
+            const journey = journeys.get(name);
+            if (!journey || journey.closed) {
+                return null;
+            }
+            return projectJourneyState(journey);
+        },
+
+        restoreJourney(serialized, config) {
+            // Refuse double-registration: leave an existing journey under this name in place.
+            if (journeys.has(config.name)) {
+                return null;
+            }
+
+            const journey = deserializeJourneyState(serialized, config, api, defaultJourneyIdleMs);
+
+            if (journey.timeoutMs > 0) {
+                const elapsedMs = globalThis.performance.now() - journey.startedAt;
+                if (elapsedMs >= journey.timeoutMs) {
+                    // journey not yet in journeys Map — finish() handles unregistered journeys gracefully.
+                    if (journey.timeoutExplicit) {
+                        finish(journey, 'bad', 'journey-timeout');
+                    } else {
+                        finish(
+                            journey,
+                            journey.verdict === 'bad' ? 'bad' : 'excluded',
+                            'journey-idle-timeout'
+                        );
+                    }
+                    return null;
+                }
+
+                journeys.set(config.name, journey);
+
+                const remainingMs = journey.timeoutMs - elapsedMs;
+                if (remainingMs > 0) {
+                    armCountdown(journey, remainingMs);
+                }
+            } else {
+                journeys.set(config.name, journey);
+            }
+
+            return journey;
+        },
+
         activeJourneyStep() {
             if (!api.getAutoAttributeRequests()) {
                 return null;

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');
 
@@ -124,10 +129,20 @@ export function setSafeAttribute(
     }
 }
 
-function sanitizeStep(step: JourneyStepEvent): JourneyStepEvent {
+function sanitizeStep(step: JourneyStepEvent, includeRequests: boolean): 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 name = normalizeTagValue(step.name);
     return {
-        ...step,
+        ...rest,
+        ...(requests.length ? { requests } : {}),
+        ...(includeRequests && requestsTruncated === true ? { requestsTruncated: true } : {}),
         name: name || step.name,
         ...(step.reason ? { reason: normalizeTagValue(step.reason) } : {}),
         ...(step.attributes
@@ -149,6 +164,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(step => sanitizeStep(step, j.outcome === 'bad'));
+    // 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 +193,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,35 @@ 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;
+}
+
+/**
+ * Snapshot of an open journey that can survive a page navigation. Produced by
+ * `serializeJourneyState` and rehydrated by `restoreJourney`. Mirrors the
+ * `JourneyStepEvent` projection emitted by `finish()`, plus the wall-clock
+ * start time, verdict, reason, and tags needed to re-arm the countdown.
+ */
+export interface SerializedJourneyState {
+    /** `st_journey_id` tag — cross-page correlation key. Empty string when unset. */
+    stJourneyId: string;
+    /** Wall-clock epoch (Date.now()) when the journey started. */
+    startedAtEpoch: number;
+    verdict: 'good' | 'bad';
+    reason: string | null;
+    steps: {
+        name: string;
+        /** Offset from the journey start, ms. */
+        startMs: number;
+        durationMs: number;
+        outcome: 'good' | 'bad';
+        reason?: string;
+        httpStatus?: number;
+        attributes?: Record<string, TagValue>;
+    }[];
+    tags: Record<string, TagValue>;
 }
 
 /** Neutral journey event payload (journey-specific fields only; session context is host RUM globals). */
@@ -174,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

@@ -13,6 +13,8 @@ export {
     excludeJourney,
     failJourney,
     journeyStep,
+    restoreJourney,
+    serializeJourneyState,
     setJourneyTags,
     // Custom transport adapters / request attribution.
     singleInFlightJourneyStep,
@@ -23,6 +25,7 @@ export {
     type JourneyNameLike,
     type JourneyStepOptions,
     type JourneyStepTarget,
+    type SerializedJourneyState,
     type StepHandle,
 } from './core';
 
@@ -57,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);
         }

package/src/integrations/request-correlation.ts

@@ -0,0 +1,90 @@
+import { 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 {
+    headers?: { 'cf-ray'?: unknown; 'get'?(name: string): unknown };
+    url?: string;
+    responseURL?: string;
+    request?: { responseURL?: string };
+    getResponseHeader?(name: string): unknown;
+}
+
+/** Observation only. Safe to run before jQuery invokes application callbacks. */
+export function captureRequestCorrelation(
+    report: HttpCompleteReport
+): JourneyRequestEvent | undefined {
+    try {
+        const step = report.stamp?.step;
+        if (
+            !step?.journey ||
+            step.journey.closed ||
+            !canRouteHttpToJourney(step.journey) ||
+            report.stamp?.ignore ||
+            report.meta?.ignore ||
+            report.aborted ||
+            !report.url ||
+            resolveJourneyEngine(step.journey).shouldIgnoreRequest(report.requestKey)
+        ) {
+            return;
+        }
+
+        // Other environments/backends have not verified this log-field/data-view contract.
+        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) {
+            return;
+        }
+        const response = report.response as ResponseHeaders | undefined;
+        if (!response || typeof response !== 'object') {
+            return;
+        }
+        const captured = capturedResponses.get(response);
+        if (captured) {
+            return step.requests?.includes(captured) ? captured : undefined;
+        }
+        const finalUrl = response.url || response.responseURL || response.request?.responseURL;
+        if (finalUrl && new URL(finalUrl).origin !== MONOLITH_ORIGIN) {
+            return;
+        }
+        const rayId =
+            typeof response.getResponseHeader === 'function'
+                ? response.getResponseHeader('cf-ray')
+                : typeof response.headers?.get === 'function'
+                  ? response.headers.get('cf-ray')
+                  : response.headers?.['cf-ray'];
+        if (typeof rayId !== 'string') {
+            return;
+        }
+        const request = sanitizeRequestCorrelation({
+            rayId,
+            startedAtEpoch: Date.now() - report.durationMs,
+            durationMs: report.durationMs,
+            status: report.status as number,
+        });
+        if (!request) {
+            return;
+        }
+        capturedResponses.set(response, request);
+        step.requests ??= [];
+        const requests = step.requests;
+        if (requests.length >= MAX_CORRELATED_REQUESTS) {
+            step.requestsTruncated = true;
+            // Keep errors when later successes arrive. A new error replaces a success first.
+            const replace = requests.findIndex(item => item.status < 400);
+            if (replace < 0 && request.status < 400) {
+                return request;
+            }
+            requests.splice(replace < 0 ? 0 : replace, 1);
+        }
+        requests.push(request);
+        return request;
+    } catch {
+        // Missing/blocked headers and unusual transport objects must not affect requests.
+    }
+}

package/src/sinks/datadog.ts

@@ -1,6 +1,7 @@
 import { isSanitizedJourneyEvent, sanitizeJourneyEvent } from '../core/sanitize';
 import { getJourneyRumFallback, setJourneyRumFallback } from '../global';
 import type { JourneyEvent, JourneyStepEvent } from '../core/types';
+import { requestLogsUrl } from './kibana';
 
 export { normalizeTagValue } from '../core/sanitize';
 
@@ -54,6 +55,18 @@ function toDatadogStep(step: JourneyStepEvent) {
         outcome: step.outcome,
         ...(step.reason ? { reason: step.reason } : {}),
         ...(step.httpStatus !== undefined ? { http_status: step.httpStatus } : {}),
+        ...(step.requests?.length
+            ? {
+                  requests: step.requests.map(request => ({
+                      request_id: request.rayId,
+                      started_at: new Date(request.startedAtEpoch).toISOString(),
+                      duration_ms: request.durationMs,
+                      http_status: request.status,
+                      kibana_url: requestLogsUrl(request),
+                  })),
+              }
+            : {}),
+        ...(step.requestsTruncated ? { requests_truncated: true } : {}),
         ...(step.attributes && Object.keys(step.attributes).length
             ? { attributes: step.attributes }
             : {}),
@@ -79,6 +92,12 @@ export function sendToDatadog(payload: JourneyEvent): void {
             group: j.group,
             service: j.service,
             outcome: j.outcome,
+            ...(j.failedRequest
+                ? {
+                      failed_request_id: j.failedRequest.rayId,
+                      kibana_url: requestLogsUrl(j.failedRequest),
+                  }
+                : {}),
             ...(j.reason ? { reason: j.reason } : {}),
             duration_ms: j.durationMs,
             steps: j.steps.map(toDatadogStep),

package/src/sinks/kibana.ts

@@ -0,0 +1,24 @@
+import { sanitizeRequestCorrelation } from '../core/request-correlation';
+import type { JourneyRequestEvent } from '../core/types';
+
+const DISCOVER_URL = 'https://kibana.st.dev/app/discover#/';
+// Production monolith logs; deliberately not the user's default data view.
+const DATA_VIEW_ID = '894110ed-c22d-449c-9dc2-c4816f08712a';
+const WINDOW_PADDING_MS = 60_000;
+
+/** Fixed destination and validated Ray ID only — no request URL, query string or user data. */
+export function requestLogsUrl(value: JourneyRequestEvent): string | undefined {
+    const request = sanitizeRequestCorrelation(value);
+    if (!request) {
+        return undefined;
+    }
+    const from = new Date(request.startedAtEpoch - WINDOW_PADDING_MS).toISOString();
+    const to = new Date(
+        request.startedAtEpoch + request.durationMs + WINDOW_PADDING_MS
+    ).toISOString();
+    // Origin/edge datacenter suffixes can differ. Match the hex prefix within the request window.
+    const rayPrefix = request.rayId.slice(0, 16);
+    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}*'))`;
+    return `${DISCOVER_URL}?_g=${encodeURIComponent(globalState)}&_a=${encodeURIComponent(appState)}`;
+}