@dreamhorizonorg/pulse-react-native 0.0.2 → 0.0.3

package/src/navigation/useNavigationTracking.ts

@@ -1,5 +1,8 @@
 import { useRef, useCallback, useEffect, useMemo, type RefObject } from 'react';
-import type { NavigationIntegrationOptions } from './navigation.interface';
+import {
+  DEFAULT_NAVIGATION_OPTIONS,
+  type NavigationIntegrationOptions,
+} from './navigation.interface';
 import type { ReactNavigationIntegration } from './index';
 
 export function useNavigationTracking(
@@ -9,9 +12,15 @@ export function useNavigationTracking(
     options?: NavigationIntegrationOptions
   ) => ReactNavigationIntegration
 ): () => void {
-  const screenSessionTracking = options?.screenSessionTracking ?? true;
-  const screenNavigationTracking = options?.screenNavigationTracking ?? true;
-  const screenInteractiveTracking = options?.screenInteractiveTracking ?? false;
+  const screenSessionTracking =
+    options?.screenSessionTracking ??
+    DEFAULT_NAVIGATION_OPTIONS.screenSessionTracking;
+  const screenNavigationTracking =
+    options?.screenNavigationTracking ??
+    DEFAULT_NAVIGATION_OPTIONS.screenNavigationTracking;
+  const screenInteractiveTracking =
+    options?.screenInteractiveTracking ??
+    DEFAULT_NAVIGATION_OPTIONS.screenInteractiveTracking;
 
   const integration = useMemo(() => {
     if (createIntegration) {

package/src/network-interceptor/header-helper.ts

@@ -0,0 +1,26 @@
+/**
+ * Normalizes header name according to OpenTelemetry HTTP semantic conventions:
+ * - Lowercase
+ * - Dashes replaced by underscores
+ * - Reference: https://opentelemetry.io/docs/specs/semconv/registry/attributes/http/
+ * @example
+ * normalizeHeaderName('Content-Type') => 'content_type'
+ * normalizeHeaderName('X-Request-ID') => 'x_request_id'
+ */
+export function normalizeHeaderName(headerName: string): string {
+  return headerName.toLowerCase().replace(/-/g, '_');
+}
+
+/**
+ * Checks if a header should be captured based on configuration.
+ */
+export function shouldCaptureHeader(
+  headerName: string,
+  headerList: string[]
+): boolean {
+  if (headerList.length === 0) return false;
+  // Case-insensitive comparison
+  return headerList.some(
+    (configHeader) => configHeader.toLowerCase() === headerName.toLowerCase()
+  );
+}

package/src/network-interceptor/initialization.ts

@@ -1,13 +1,34 @@
 import createXmlHttpRequestTracker from './request-tracker-xhr';
+import type { NetworkHeaderConfig } from '../config';
+// Re-export header utilities for convenience (they're in a separate file to avoid dependency issues)
+export { normalizeHeaderName, shouldCaptureHeader } from './header-helper';
 
 let isInitialized = false;
+let headerConfig: NetworkHeaderConfig = {
+  requestHeaders: [],
+  responseHeaders: [],
+};
 
-export function initializeNetworkInterceptor(): void {
+export function getHeaderConfig(): NetworkHeaderConfig {
+  return headerConfig;
+}
+
+export function initializeNetworkInterceptor(
+  config?: NetworkHeaderConfig
+): void {
   if (isInitialized) {
     console.warn('[Pulse] Network interceptor already initialized');
     return;
   }
 
+  // Store header configuration
+  if (config) {
+    headerConfig = {
+      requestHeaders: config.requestHeaders ?? [],
+      responseHeaders: config.responseHeaders ?? [],
+    };
+  }
+
   console.log('[Pulse] 🔄 Starting network interceptor initialization...');
 
   try {

package/src/network-interceptor/network.interface.ts

@@ -3,17 +3,20 @@ export interface RequestStartContext {
   method: string;
   type: 'fetch' | 'xmlhttprequest';
   baseUrl?: string;
+  requestHeaders?: Record<string, string>;
 }
 
 export interface RequestEndContextSuccess {
   status: number;
   state: 'success';
+  responseHeaders?: Record<string, string>;
 }
 
 export interface RequestEndContextError {
   state: 'error';
   status?: number;
   error?: Error;
+  responseHeaders?: Record<string, string>;
 }
 
 export type RequestEndContext =

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;
@@ -48,6 +50,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 +82,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 +116,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 +178,9 @@ function createXmlHttpRequestTracker(
             trackedSpans.delete(this);
           }
 
+          // Clean up
+          requestHeadersMap.delete(this);
+
           onRequestEnd(endContext);
         }
       };

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;