@servicetitan/journey 1.0.0

package/src/integrations/request-key.ts

@@ -0,0 +1,46 @@
+/**
+ * Timing metadata stamped onto a request config so the response handler can attribute
+ * and measure the round trip. Intersect with your transport's config type.
+ *
+ * `journeyStep` is a JourneyStepTag (from `step.tag()` or ambient instrumentation)
+ * or, historically, a raw StepRecord. Adapters unwrap via `resolveJourneyStep`.
+ */
+export interface JourneyTimedMeta {
+    journeyStart?: number;
+    journeyStep?: unknown;
+}
+
+function pageOrigin(): string {
+    try {
+        return globalThis.location?.origin ?? '';
+    } catch {
+        return '';
+    }
+}
+
+/**
+ * Endpoint key for timeout / ignore lookup: PATH for same-origin (vs instance baseURL),
+ * or "host/path" for cross-domain.
+ */
+export function requestKey(
+    url: string | undefined,
+    configBaseURL: string | undefined,
+    instanceBaseURL: string | undefined
+): string {
+    const origin = pageOrigin();
+    const base = configBaseURL ?? instanceBaseURL ?? origin;
+    let abs: URL;
+    try {
+        abs = new URL(url ?? '', base || undefined);
+    } catch {
+        return url ?? '';
+    }
+    let homeOrigin: string;
+    try {
+        const homeBase = instanceBaseURL ?? origin;
+        homeOrigin = new URL(homeBase || 'http://localhost').origin;
+    } catch {
+        homeOrigin = origin;
+    }
+    return abs.origin === homeOrigin ? abs.pathname : abs.host + abs.pathname;
+}

package/src/sinks/datadog.ts

@@ -0,0 +1,71 @@
+import { datadogRum } from '@datadog/browser-rum';
+
+import type { JourneyEvent, JourneyStepEvent, TagValue } from '../core/types';
+
+const JOURNEY_ACTION = 'user_journey';
+
+const RUM_GLOBAL_KEY = '__stJourneyRum';
+
+/** Host-only: publish the initialized RUM instance so MFE bundles share the same session. */
+export function setJourneyRum(rum: unknown): void {
+    (globalThis as Record<string, unknown>)[RUM_GLOBAL_KEY] = rum;
+}
+
+function resolveRum(): typeof datadogRum {
+    const shared = (globalThis as Record<string, unknown>)[RUM_GLOBAL_KEY];
+    return (shared as typeof datadogRum | undefined) ?? datadogRum;
+}
+
+// Match Datadog metric-tag value rules so RUM attributes join derived SLO tags.
+const MAX_TAG_VALUE_LEN = 200;
+function normalizeTagValue(value: string): string {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9_\-:./]/g, '_')
+        .replace(/_+/g, '_')
+        .slice(0, MAX_TAG_VALUE_LEN)
+        .replace(/_+$/, '');
+}
+
+function normalizeTags(tags: Record<string, TagValue>): Record<string, TagValue> {
+    const out: Record<string, TagValue> = {};
+    for (const [key, value] of Object.entries(tags)) {
+        out[key] = typeof value === 'string' ? normalizeTagValue(value) : value;
+    }
+    return out;
+}
+
+function toDatadogStep(step: JourneyStepEvent) {
+    /* eslint-disable @typescript-eslint/naming-convention -- Datadog RUM wire format (snake_case) */
+    return {
+        name: step.name,
+        start_ms: step.startMs,
+        duration_ms: step.durationMs,
+        outcome: step.outcome,
+        ...(step.reason ? { reason: step.reason } : {}),
+        ...(step.httpStatus !== undefined ? { http_status: step.httpStatus } : {}),
+        ...(step.attributes ? { attributes: step.attributes } : {}),
+    };
+    /* eslint-enable @typescript-eslint/naming-convention */
+}
+
+/** Ship one terminal journey as a RUM custom action (`user_journey`). */
+export function sendToDatadog(payload: JourneyEvent): void {
+    const j = payload.journey;
+    /* eslint-disable @typescript-eslint/naming-convention -- Datadog RUM wire format (snake_case) */
+    resolveRum().addAction(JOURNEY_ACTION, {
+        journey: {
+            name: normalizeTagValue(j.name),
+            team: normalizeTagValue(j.team),
+            group: normalizeTagValue(j.group),
+            service: normalizeTagValue(j.service),
+            outcome: j.outcome,
+            ...(j.reason ? { reason: normalizeTagValue(j.reason) } : {}),
+            duration_ms: j.durationMs,
+            steps: j.steps.map(toDatadogStep),
+            ...(j.expected ? { expected: j.expected } : {}),
+            ...(j.tags ? { tags: normalizeTags(j.tags) } : {}),
+        },
+    });
+    /* eslint-enable @typescript-eslint/naming-convention */
+}