@dreamhorizonorg/pulse-react-native 0.0.2 → 0.0.4

package/src/network-interceptor/request-tracker-xhr.ts

@@ -6,6 +6,8 @@ import { RequestTracker } from './request-tracker';
 import { getAbsoluteUrl } from '../utility';
 import type { Span } from '../index';
 import { createNetworkSpan, completeNetworkSpan } from './span-helpers';
+import { getHeaderConfig } from './initialization';
+import { shouldCaptureHeader } from './header-helper';
 
 interface RequestData {
   method: string;
@@ -16,12 +18,17 @@ type ReadyStateChangeHandler = (this: XMLHttpRequest, ev: Event) => any;
 
 let isXHRIntercepted = false;
 
+export interface XmlHttpRequestTrackerResult {
+  requestTracker: RequestTracker;
+  uninstall: () => void;
+}
+
 function createXmlHttpRequestTracker(
   xhr: typeof XMLHttpRequest
-): RequestTracker {
+): XmlHttpRequestTrackerResult {
   if (isXHRIntercepted) {
     console.warn('[Pulse] XMLHttpRequest already intercepted');
-    return new RequestTracker();
+    return { requestTracker: new RequestTracker(), uninstall: () => {} };
   }
 
   const requestTracker = new RequestTracker();
@@ -48,6 +55,28 @@ function createXmlHttpRequestTracker(
   };
   isXHRIntercepted = true;
 
+  // Store request headers before send
+  const requestHeadersMap = new WeakMap<
+    XMLHttpRequest,
+    Record<string, string>
+  >();
+  const originalSetRequestHeader = xhr.prototype.setRequestHeader;
+  xhr.prototype.setRequestHeader = function setRequestHeader(
+    name: string,
+    value: string
+  ): void {
+    const headerConfig = getHeaderConfig();
+    const requestHeadersList = headerConfig.requestHeaders ?? [];
+    if (
+      requestHeadersList.length > 0 &&
+      shouldCaptureHeader(name, requestHeadersList)
+    ) {
+      const existing = requestHeadersMap.get(this) || {};
+      requestHeadersMap.set(this, { ...existing, [name]: value });
+    }
+    originalSetRequestHeader.call(this, name, value);
+  };
+
   const originalSend = xhr.prototype.send;
   xhr.prototype.send = function send(
     body?: Document | XMLHttpRequestBodyInit | null
@@ -58,10 +87,28 @@ function createXmlHttpRequestTracker(
       if (existingHandler)
         this.removeEventListener('readystatechange', existingHandler);
 
+      // Capture request headers
+      const headerConfig = getHeaderConfig();
+      const capturedRequestHeaders = requestHeadersMap.get(this);
+      const requestHeadersList = headerConfig.requestHeaders ?? [];
+      const filteredRequestHeaders: Record<string, string> | undefined =
+        capturedRequestHeaders && requestHeadersList.length > 0
+          ? Object.fromEntries(
+              Object.entries(capturedRequestHeaders).filter(([name]) =>
+                shouldCaptureHeader(name, requestHeadersList)
+              )
+            )
+          : undefined;
+
       const startContext: RequestStartContext = {
         type: 'xmlhttprequest',
         method: requestData.method,
         url: requestData.url,
+        requestHeaders:
+          filteredRequestHeaders &&
+          Object.keys(filteredRequestHeaders).length > 0
+            ? filteredRequestHeaders
+            : undefined,
       };
 
       this.setRequestHeader('X-Pulse-RN-Tracked', 'true');
@@ -74,13 +121,56 @@ function createXmlHttpRequestTracker(
         if (this.readyState === xhr.DONE && onRequestEnd) {
           const activeSpan = trackedSpans.get(this);
 
+          // Capture response headers
+          const responseHeaderConfig = getHeaderConfig();
+          const capturedResponseHeaders: Record<string, string> = {};
+          const responseHeadersList =
+            responseHeaderConfig.responseHeaders ?? [];
+          if (responseHeadersList.length > 0) {
+            try {
+              const allHeaders = this.getAllResponseHeaders();
+              if (allHeaders) {
+                const headerLines = allHeaders.trim().split(/[\r\n]+/);
+                for (const line of headerLines) {
+                  const parts = line.split(': ');
+                  if (parts.length === 2) {
+                    const [name, value] = parts;
+                    if (
+                      name &&
+                      value &&
+                      shouldCaptureHeader(name, responseHeadersList)
+                    ) {
+                      capturedResponseHeaders[name] = value;
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              // Headers may not be available in some cases (CORS, etc.)
+              console.debug('[Pulse] Could not read response headers:', e);
+            }
+          }
+
           // Determine request outcome based on status code
           let endContext: RequestEndContext;
 
+          const responseHeaders =
+            Object.keys(capturedResponseHeaders).length > 0
+              ? capturedResponseHeaders
+              : undefined;
+
           if (this.status <= 0 || this.status >= 400) {
-            endContext = { state: 'error', status: this.status };
+            endContext = {
+              state: 'error',
+              status: this.status,
+              responseHeaders,
+            };
           } else {
-            endContext = { state: 'success', status: this.status };
+            endContext = {
+              state: 'success',
+              status: this.status,
+              responseHeaders,
+            };
           }
 
           if (activeSpan) {
@@ -93,6 +183,9 @@ function createXmlHttpRequestTracker(
             trackedSpans.delete(this);
           }
 
+          // Clean up
+          requestHeadersMap.delete(this);
+
           onRequestEnd(endContext);
         }
       };
@@ -104,7 +197,15 @@ function createXmlHttpRequestTracker(
     originalSend.call(this, body);
   };
 
-  return requestTracker;
+  const uninstall = (): void => {
+    if (!isXHRIntercepted) return;
+    xhr.prototype.open = originalOpen;
+    xhr.prototype.setRequestHeader = originalSetRequestHeader;
+    xhr.prototype.send = originalSend;
+    isXHRIntercepted = false;
+  };
+
+  return { requestTracker, uninstall };
 }
 
 export default createXmlHttpRequestTracker;

package/src/network-interceptor/span-helpers.ts

@@ -8,7 +8,8 @@ import { Pulse, SpanStatusCode } from '../index';
 import type { PulseAttributes } from '../pulse.interface';
 import { extractHttpAttributes } from './url-helper';
 import { updateAttributesWithGraphQLData } from './graphql-helper';
-import { ATTRIBUTE_KEYS, PHASE_VALUES } from '../pulse.constants';
+import { ATTRIBUTE_KEYS, PULSE_TYPES } from '../pulse.constants';
+import { normalizeHeaderName } from './header-helper';
 
 export function setNetworkSpanAttributes(
   span: Span,
@@ -19,7 +20,7 @@ export function setNetworkSpanAttributes(
   let attributes: PulseAttributes = {
     [ATTRIBUTE_KEYS.HTTP_METHOD]: method,
     [ATTRIBUTE_KEYS.HTTP_URL]: startContext.url,
-    [ATTRIBUTE_KEYS.PULSE_TYPE]: `network.${endContext.status ?? 0}`,
+    [ATTRIBUTE_KEYS.PULSE_TYPE]: `${PULSE_TYPES.NETWORK}.${endContext.status ?? 0}`,
     [ATTRIBUTE_KEYS.HTTP_REQUEST_TYPE]: startContext.type,
     [ATTRIBUTE_KEYS.PLATFORM]: Platform.OS,
   };
@@ -43,6 +44,26 @@ export function setNetworkSpanAttributes(
     span.recordException(endContext.error, attributes);
   }
 
+  if (startContext.requestHeaders) {
+    for (const [headerName, headerValue] of Object.entries(
+      startContext.requestHeaders
+    )) {
+      const normalizedName = normalizeHeaderName(headerName);
+      attributes[`${ATTRIBUTE_KEYS.HTTP_REQUEST_HEADER}.${normalizedName}`] =
+        headerValue;
+    }
+  }
+
+  if (endContext.responseHeaders) {
+    for (const [headerName, headerValue] of Object.entries(
+      endContext.responseHeaders
+    )) {
+      const normalizedName = normalizeHeaderName(headerName);
+      attributes[`${ATTRIBUTE_KEYS.HTTP_RESPONSE_HEADER}.${normalizedName}`] =
+        headerValue;
+    }
+  }
+
   span.setAttributes(attributes);
   return attributes;
 }
@@ -58,7 +79,6 @@ export function createNetworkSpan(
   let baseAttributes: PulseAttributes = {
     [ATTRIBUTE_KEYS.HTTP_METHOD]: method,
     [ATTRIBUTE_KEYS.HTTP_URL]: startContext.url,
-    [ATTRIBUTE_KEYS.PULSE_TYPE]: PHASE_VALUES.NETWORK,
     [ATTRIBUTE_KEYS.HTTP_REQUEST_TYPE]: interceptorType,
   };
 

package/src/pulse.constants.ts

@@ -12,7 +12,6 @@ export enum ATTRIBUTE_KEYS {
   PULSE_TYPE = 'pulse.type',
   SCREEN_NAME = 'screen.name',
   ROUTE_KEY = 'routeKey',
-  PHASE = 'phase',
   LAST_SCREEN_NAME = 'last.screen.name',
   ROUTE_HAS_BEEN_SEEN = 'routeHasBeenSeen',
   PLATFORM = 'platform',
@@ -22,6 +21,8 @@ export enum ATTRIBUTE_KEYS {
   HTTP_URL = 'http.url',
   HTTP_STATUS_CODE = 'http.status_code',
   HTTP_REQUEST_TYPE = 'http.request.type',
+  HTTP_REQUEST_HEADER = 'http.request.header',
+  HTTP_RESPONSE_HEADER = 'http.response.header',
   ERROR_MESSAGE = 'error.message',
   ERROR_STACK = 'error.stack',
 }
@@ -30,9 +31,22 @@ export enum PULSE_TYPES {
   SCREEN_SESSION = 'screen_session',
   SCREEN_LOAD = 'screen_load',
   SCREEN_INTERACTIVE = 'screen_interactive',
-}
-
-export enum PHASE_VALUES {
-  START = 'start',
   NETWORK = 'network',
 }
+
+export const PULSE_FEATURE_NAMES = {
+  RN_SCREEN_LOAD: 'rn_screen_load',
+  SCREEN_SESSION: 'screen_session',
+  RN_SCREEN_INTERACTIVE: 'rn_screen_interactive',
+  NETWORK_INSTRUMENTATION: 'network_instrumentation',
+  CUSTOM_EVENTS: 'custom_events',
+  JS_CRASH: 'js_crash',
+} as const;
+
+export type PulseFeatureName =
+  (typeof PULSE_FEATURE_NAMES)[keyof typeof PULSE_FEATURE_NAMES];
+
+export type NavigationFeatureName =
+  | typeof PULSE_FEATURE_NAMES.SCREEN_SESSION
+  | typeof PULSE_FEATURE_NAMES.RN_SCREEN_LOAD
+  | typeof PULSE_FEATURE_NAMES.RN_SCREEN_INTERACTIVE;

package/src/pulse.interface.ts

@@ -16,4 +16,4 @@ export type PulseAttributes = Record<
   PulseAttributeValue | undefined | null
 >;
 
-export type PulseFeatureConfig = Record<string, boolean> | null;
+export type PulseFeatureConfig = Record<string, boolean> | null | undefined;

package/src/trace.ts

@@ -1,9 +1,18 @@
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { getIsShutdown, getIsStarted } from './config';
 import { isSupportedPlatform } from './initialization';
 import { mergeWithGlobalAttributes } from './globalAttributes';
 import { extractErrorDetails } from './utility';
 import type { PulseAttributes } from './pulse.interface';
 
+const noopSpan: Span = {
+  end: (_statusCode?: SpanStatusCode) => {},
+  addEvent: (_eventName: string, _eventAttributes?: PulseAttributes) => {},
+  setAttributes: (_attributes?: PulseAttributes) => {},
+  recordException: (_error: Error, _attributes?: PulseAttributes) => {},
+  spanId: undefined,
+};
+
 /**
  * Options for starting a span.
  * @param attributes - Attributes to set on the span.
@@ -30,14 +39,8 @@ export type Span = {
 };
 
 export function startSpan(name: string, options?: SpanOptions): Span {
-  if (!isSupportedPlatform()) {
-    return {
-      end: (_statusCode?: SpanStatusCode) => {},
-      addEvent: (_eventName: string, _eventAttributes?: PulseAttributes) => {},
-      setAttributes: (_attributes?: PulseAttributes) => {},
-      recordException: (_error: Error, _attributes?: PulseAttributes) => {},
-      spanId: undefined,
-    };
+  if (!isSupportedPlatform() || !getIsStarted() || getIsShutdown()) {
+    return noopSpan;
   }
 
   const mergedAttributes = mergeWithGlobalAttributes(options?.attributes || {});
@@ -69,7 +72,7 @@ export function trackSpan<T>(
   options: SpanOptions,
   fn: () => T | Promise<T>
 ): T | Promise<T> {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || !getIsStarted() || getIsShutdown()) {
     return fn();
   }
 
@@ -94,11 +97,12 @@ export function trackSpan<T>(
 }
 
 function endSpan(spanId: string, statusCode?: SpanStatusCode): void {
+  if (getIsShutdown()) return;
   PulseReactNativeOtel.endSpan(spanId, statusCode);
 }
 
 export function discardSpan(spanId: string): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || !getIsStarted() || getIsShutdown()) {
     return;
   }
   PulseReactNativeOtel.discardSpan(spanId);
@@ -109,14 +113,17 @@ function addSpanEvent(
   name: string,
   attributes?: PulseAttributes
 ): void {
+  if (getIsShutdown()) return;
   PulseReactNativeOtel.addSpanEvent(spanId, name, attributes || undefined);
 }
 
 function setSpanAttributes(spanId: string, attributes?: PulseAttributes): void {
+  if (getIsShutdown()) return;
   PulseReactNativeOtel.setSpanAttributes(spanId, attributes || undefined);
 }
 
 function recordSpanException(error: Error, attributes?: PulseAttributes): void {
+  if (getIsShutdown()) return;
   const { message, stackTrace, errorType } = extractErrorDetails(error);
   const observedTimeMs = Date.now();
   const mergedAttributes = mergeWithGlobalAttributes(attributes || {});

package/src/user.ts

@@ -1,23 +1,24 @@
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { getIsShutdown } from './config';
 import { isSupportedPlatform } from './initialization';
 import type { PulseAttributes } from './pulse.interface';
 
 export function setUserId(id: string | null): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || getIsShutdown()) {
     return;
   }
   PulseReactNativeOtel.setUserId(id);
 }
 
 export function setUserProperty(name: string, value: string | null): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || getIsShutdown()) {
     return;
   }
   PulseReactNativeOtel.setUserProperty(name, value);
 }
 
 export function setUserProperties(properties: PulseAttributes): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || getIsShutdown()) {
     return;
   }
   PulseReactNativeOtel.setUserProperties(properties);