routeflow-browser 0.1.1 → 0.1.4

package/dist/client.d.ts

@@ -2,6 +2,10 @@
  * HTTP client for sending events to Routeflow backend.
  */
 import { IngestPayload } from "./types";
+/**
+ * Get the RouteFlow backend URL (for telemetry ingestion).
+ */
+export declare function getRouteflowBackendUrl(): string;
 /**
  * Send events to Routeflow backend.
  */

package/dist/client.js

@@ -1,17 +1,21 @@
 /**
  * HTTP client for sending events to Routeflow backend.
  */
-// Use localhost for development, production URL for deployed environments
-const BACKEND_URL = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1"
-    ? "http://127.0.0.1:5004"
-    : "https://routeflow-backend-production.up.railway.app";
+// Hardcoded RouteFlow backend URL - always use production
+const ROUTEFLOW_BACKEND_URL = "https://routeflow-backend-production.up.railway.app";
 const INGEST_ENDPOINT = "/v1/ingest";
+/**
+ * Get the RouteFlow backend URL (for telemetry ingestion).
+ */
+export function getRouteflowBackendUrl() {
+    return ROUTEFLOW_BACKEND_URL;
+}
 /**
  * Send events to Routeflow backend.
  */
 export async function sendEvents(payload, ingestKey) {
     try {
-        const url = `${BACKEND_URL}${INGEST_ENDPOINT}`;
+        const url = `${ROUTEFLOW_BACKEND_URL}${INGEST_ENDPOINT}`;
         const body = JSON.stringify(payload);
         // Use fetch with keepalive for best reliability
         const success = await fetch(url, {

package/dist/external_spans.js

@@ -16,7 +16,7 @@ class ExternalSpanTracker {
         };
         this.flushTimer = null;
         this.SDK_NAME = "@routeflow/browser";
-        this.SDK_VERSION = "0.1.0"; // TODO: sync with package.json
+        this.SDK_VERSION = "0.1.4";
         this.config = config;
         this.startFlushTimer();
     }

package/dist/fetch_patch.d.ts

@@ -1,10 +1,14 @@
 /**
  * Fetch patching for correlation headers and external span tracking.
+ *
+ * This SDK patches fetch() to:
+ * 1. Add correlation headers to requests to user's app backend
+ * 2. Track external requests and send telemetry to RouteFlow backend
  */
 /**
- * Patch window.fetch to add correlation headers.
+ * Patch window.fetch to add correlation headers and track external requests.
  */
-export declare function patchFetch(enableExternalTracking: boolean): void;
+export declare function patchFetch(enableExternalTracking: boolean, backendUrl?: string): void;
 /**
  * Restore original fetch.
  */

package/dist/fetch_patch.js

@@ -1,5 +1,9 @@
 /**
  * Fetch patching for correlation headers and external span tracking.
+ *
+ * This SDK patches fetch() to:
+ * 1. Add correlation headers to requests to user's app backend
+ * 2. Track external requests and send telemetry to RouteFlow backend
  */
 import { isSameOrigin } from "./validate";
 import { getOrCreateSessionId, generateTraceId } from "./trace";
@@ -11,10 +15,33 @@ const FRONTEND_ROUTE_HEADER = "x-routeflow-frontend-route";
 let originalFetch;
 let isPatched = false;
 let trackExternal = false;
+let userBackendUrl = ""; // User's app backend URL for header injection
 /**
- * Patch window.fetch to add correlation headers.
+ * Check if a URL should receive correlation headers.
+ * Returns true if:
+ * - URL matches the configured user backend URL, OR
+ * - No backend URL configured and request is same-origin
  */
-export function patchFetch(enableExternalTracking) {
+function shouldInjectHeaders(url) {
+    // If user explicitly configured their backend URL, match against it
+    if (userBackendUrl) {
+        try {
+            const requestUrl = new URL(url, window.location.href);
+            const backendUrlObj = new URL(userBackendUrl, window.location.href);
+            // Match by origin (protocol + hostname + port)
+            return requestUrl.origin === backendUrlObj.origin;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Fallback: inject headers for same-origin requests
+    return isSameOrigin(url);
+}
+/**
+ * Patch window.fetch to add correlation headers and track external requests.
+ */
+export function patchFetch(enableExternalTracking, backendUrl) {
     if (isPatched) {
         return;
     }
@@ -23,6 +50,7 @@ export function patchFetch(enableExternalTracking) {
     }
     originalFetch = window.fetch;
     trackExternal = enableExternalTracking;
+    userBackendUrl = backendUrl || "";
     window.fetch = async function patchedFetch(input, init) {
         // Convert input to URL string
         const url = typeof input === "string"
@@ -30,13 +58,14 @@ export function patchFetch(enableExternalTracking) {
             : input instanceof URL
                 ? input.href
                 : input.url;
+        const shouldInject = shouldInjectHeaders(url);
         const sameOrigin = isSameOrigin(url);
-        // Add correlation headers for same-origin requests
-        // For external requests, we'll add headers in trackAndFetch if tracking is enabled
-        if (sameOrigin) {
+        // Add correlation headers to requests going to user's app backend
+        if (shouldInject) {
             init = addCorrelationHeaders(input, init);
         }
-        // Track external spans if enabled (will also add correlation headers)
+        // Track external spans if enabled and not same-origin
+        // This sends telemetry to the RouteFlow backend
         if (trackExternal && !sameOrigin) {
             return trackAndFetch(url, init);
         }
@@ -46,7 +75,7 @@ export function patchFetch(enableExternalTracking) {
     isPatched = true;
 }
 /**
- * Add correlation headers to same-origin requests.
+ * Add RouteFlow correlation headers to requests going to user's app backend.
  */
 function addCorrelationHeaders(input, init) {
     // Get or create headers
@@ -72,16 +101,13 @@ function addCorrelationHeaders(input, init) {
     };
 }
 /**
- * Track external fetch call and execute it.
- * Also adds correlation headers to tracked external requests.
+ * Track external fetch call and send telemetry to RouteFlow backend.
+ * This does NOT add correlation headers - those are only for same-origin requests.
  */
 async function trackAndFetch(url, init) {
     const startTime = performance.now();
     let response = null;
     let error = null;
-    // Add correlation headers to tracked external requests
-    // This allows backends in your infrastructure to correlate requests
-    init = addCorrelationHeaders(url, init);
     try {
         response = await originalFetch(url, init);
         return response;
@@ -92,6 +118,7 @@ async function trackAndFetch(url, init) {
     }
     finally {
         const endTime = performance.now();
+        // This sends telemetry data to RouteFlow backend
         trackExternalFetch(url, init, startTime, endTime, response, error);
     }
 }

package/dist/init.js

@@ -15,6 +15,7 @@ let config = {
     externalAllowlist: [],
     flushIntervalMs: 1000,
     maxQueueSize: 5000,
+    backendUrl: "",
 };
 /**
  * Detect environment from deployment platform environment variables.
@@ -94,6 +95,7 @@ export function initRouteflow(opts) {
         externalAllowlist: opts?.externalAllowlist || [],
         flushIntervalMs: opts?.flushIntervalMs ?? 1000,
         maxQueueSize: opts?.maxQueueSize ?? 5000,
+        backendUrl: opts?.backendUrl || "",
     };
     // Try to get ingest key from window if not provided
     if (!config.ingestKey && typeof window !== "undefined") {
@@ -107,8 +109,8 @@ export function initRouteflow(opts) {
     initRouteTracking();
     // Initialize session ID (persists across page navigation within session)
     getOrCreateSessionId();
-    // Patch fetch for correlation headers
-    patchFetch(config.trackExternal);
+    // Patch fetch for correlation headers (pass user's backend URL)
+    patchFetch(config.trackExternal, config.backendUrl);
     // Initialize external span tracking if enabled
     if (config.trackExternal) {
         initExternalSpanTracking({

package/dist/types.d.ts

@@ -19,6 +19,8 @@ export interface RouteflowInitOptions {
     flushIntervalMs?: number;
     /** Maximum queue size before dropping events (default: 5000) */
     maxQueueSize?: number;
+    /** User's app backend URL for header injection (default: same-origin only) */
+    backendUrl?: string;
 }
 export interface ExternalSpanEvent {
     type: "frontend_external_request_observed";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routeflow-browser",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Browser SDK for Routeflow - Frontend to backend correlation and external dependency tracking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",