@dreamhorizonorg/pulse-react-native 0.0.2 → 0.0.4

package/plugin/build/withAndroidPulse.js

@@ -7,7 +7,7 @@ const utils_1 = require("./utils");
 const withAndroidPulse = (config, props) => {
     return (0, config_plugins_1.withMainApplication)(config, (modConfig) => {
         try {
-            const { endpointBaseUrl, endpointHeaders, globalAttributes, instrumentation, } = props;
+            const { endpointBaseUrl, tenantId, endpointHeaders, configEndpointUrl, globalAttributes, instrumentation, } = props;
             // 1. Add import statements
             modConfig.modResults.contents = (0, generateCode_1.mergeContents)({
                 src: modConfig.modResults.contents,
@@ -29,7 +29,9 @@ const withAndroidPulse = (config, props) => {
             }
             const initCode = (0, utils_1.buildPulseInitializationCode)({
                 endpointBaseUrl,
+                tenantId,
                 endpointHeaders,
+                configEndpointUrl,
                 globalAttributes,
                 instrumentation,
             });

package/src/NativePulseReactNativeOtel.ts

@@ -60,7 +60,17 @@ export interface Spec extends TurboModule {
   setCurrentScreenName(screenName: string): boolean;
 
   /** Get all SDK Remote Config features */
-  getAllFeatures(): Object;
+  getAllFeatures(): {
+    rn_screen_load: boolean;
+    screen_session: boolean;
+    rn_screen_interactive: boolean;
+    network_instrumentation: boolean;
+    custom_events: boolean;
+    js_crash: boolean;
+  } | null;
+
+  /** Shut down the Pulse SDK. After this, re-init is not supported. */
+  shutdown(): boolean;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('PulseReactNativeOtel');

package/src/config.ts

@@ -1,48 +1,71 @@
-import { setupErrorHandler } from './errorHandler';
+import { setupErrorHandler, uninstallErrorHandler } from './errorHandler';
 import { isSupportedPlatform } from './initialization';
 import {
   createReactNavigationIntegration,
+  uninstallNavigationIntegration,
   type ReactNavigationIntegration,
   type NavigationIntegrationOptions,
 } from './navigation';
-import { initializeNetworkInterceptor } from './network-interceptor/initialization';
+import {
+  initializeNetworkInterceptor,
+  uninstallNetworkInterceptor,
+} from './network-interceptor/initialization';
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
 import type { PulseFeatureConfig } from './pulse.interface';
+import { PULSE_FEATURE_NAMES } from './pulse.constants';
 
-export type PulseConfig = {
-  autoDetectExceptions?: boolean;
-  autoDetectNavigation?: boolean;
-  autoDetectNetwork?: boolean;
+export type NetworkHeaderConfig = {
+  requestHeaders?: string[];
+  responseHeaders?: string[];
 };
 
-export type PulseStartOptions = {
+export type PulseConfig = {
   autoDetectExceptions?: boolean;
   autoDetectNavigation?: boolean;
   autoDetectNetwork?: boolean;
+  networkHeaders?: NetworkHeaderConfig;
 };
 
-const defaultConfig: PulseConfig = {
+const defaultConfig: Required<PulseConfig> = {
   autoDetectExceptions: true,
   autoDetectNavigation: true,
   autoDetectNetwork: true,
+  networkHeaders: {
+    requestHeaders: [],
+    responseHeaders: [],
+  },
 };
 
 let currentConfig: PulseConfig = { ...defaultConfig };
 
+/** After shutdown, start() and initialize are no-ops; re-initialization is not supported. */
+let isShutdown = false;
+
+/** True only after start() has been called at least once. Integrations (e.g. navigation) are no-ops until then. */
+let isStarted = false;
+
 // Cache for features from remote SDK config
-let cachedFeatures: PulseFeatureConfig = null;
+let cachedFeatures: PulseFeatureConfig;
+
+export function getIsShutdown(): boolean {
+  return isShutdown;
+}
+
+/** True only after start() has been called at least once. Public APIs (trackEvent, reportException, startSpan, etc.) no-op until then. */
+export function getIsStarted(): boolean {
+  return isStarted;
+}
 
 /**
  * Gets all features from the remote SDK config.
- * @returns Record of feature names to their enabled status
+ * @returns Record of feature names to their enabled status, or null if config not available or start() not called
  */
 export function getFeaturesFromRemoteConfig(): PulseFeatureConfig {
-  if (cachedFeatures !== null) {
+  if (cachedFeatures !== undefined) {
     return cachedFeatures;
   }
 
-  const features = PulseReactNativeOtel.getAllFeatures();
-  cachedFeatures = features as PulseFeatureConfig;
+  cachedFeatures = PulseReactNativeOtel.getAllFeatures();
   return cachedFeatures;
 }
 
@@ -54,27 +77,84 @@ function configure(config: PulseConfig): void {
   setupErrorHandler(currentConfig.autoDetectExceptions ?? true);
 
   if (currentConfig.autoDetectNetwork) {
-    initializeNetworkInterceptor();
+    initializeNetworkInterceptor(
+      currentConfig.networkHeaders ?? {
+        requestHeaders: [],
+        responseHeaders: [],
+      }
+    );
   }
 }
 
-export function start(options?: PulseStartOptions): void {
-  if (!isSupportedPlatform()) {
+function resolveFeatureState(
+  features: PulseFeatureConfig,
+  featureName: string,
+  optionValue: boolean
+): boolean {
+  if (features !== undefined && features !== null)
+    return features[featureName] ?? optionValue;
+  return optionValue;
+}
+
+function resolveNavigationState(
+  features: PulseFeatureConfig,
+  optionValue: boolean
+): boolean {
+  if (features !== undefined && features !== null) {
+    const hasAny =
+      features[PULSE_FEATURE_NAMES.SCREEN_SESSION] === true ||
+      features[PULSE_FEATURE_NAMES.RN_SCREEN_LOAD] === true ||
+      features[PULSE_FEATURE_NAMES.RN_SCREEN_INTERACTIVE] === true;
+    return hasAny ?? optionValue;
+  }
+  return optionValue;
+}
+
+export function start(options?: PulseConfig): void {
+  if (!isSupportedPlatform()) return;
+  if (isShutdown) {
+    console.log(
+      '[Pulse] SDK has been shut down. Pulse.start() is a no-op; re-initialization is not supported.'
+    );
     return;
   }
+
+  isStarted = true;
   const features = getFeaturesFromRemoteConfig();
-  const autoDetectExceptions =
-    features?.js_crash ?? options?.autoDetectExceptions ?? true;
-  const autoDetectNavigation =
-    features?.rn_navigation ?? options?.autoDetectNavigation ?? true;
-  const autoDetectNetwork =
-    features?.network_instrumentation ?? options?.autoDetectNetwork ?? true;
-
-  configure({
-    autoDetectExceptions,
-    autoDetectNavigation,
-    autoDetectNetwork,
-  });
+  const config: PulseConfig = {
+    autoDetectExceptions: resolveFeatureState(
+      features,
+      PULSE_FEATURE_NAMES.JS_CRASH,
+      options?.autoDetectExceptions ?? defaultConfig.autoDetectExceptions
+    ),
+    autoDetectNavigation: resolveNavigationState(
+      features,
+      options?.autoDetectNavigation ?? defaultConfig.autoDetectNavigation
+    ),
+    autoDetectNetwork: resolveFeatureState(
+      features,
+      PULSE_FEATURE_NAMES.NETWORK_INSTRUMENTATION,
+      options?.autoDetectNetwork ?? defaultConfig.autoDetectNetwork
+    ),
+    networkHeaders: options?.networkHeaders ?? {
+      requestHeaders: [],
+      responseHeaders: [],
+    },
+  };
+
+  configure(config);
+}
+
+export function shutdown(): void {
+  if (isShutdown) {
+    console.warn('[Pulse] SDK already shut down.');
+    return;
+  }
+  uninstallErrorHandler();
+  uninstallNetworkInterceptor();
+  uninstallNavigationIntegration();
+  PulseReactNativeOtel.shutdown();
+  isShutdown = true;
 }
 
 export function createNavigationIntegrationWithConfig(
@@ -86,6 +166,18 @@ export function createNavigationIntegrationWithConfig(
       markContentReady: () => {},
     };
   }
+  if (!isStarted) {
+    return {
+      registerNavigationContainer: (_: unknown) => () => {},
+      markContentReady: () => {},
+    };
+  }
+  if (isShutdown) {
+    return {
+      registerNavigationContainer: (_: unknown) => () => {},
+      markContentReady: () => {},
+    };
+  }
   if (!currentConfig.autoDetectNavigation) {
     console.warn(
       '[Pulse Navigation] auto-detection disabled via Pulse.start; createNavigationIntegration() returning no-op.'

package/src/errorBoundary.tsx

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { Pulse } from './index';
+import { getIsShutdown } from './config';
 
 export const UNKNOWN_COMPONENT = 'unknown';
 const COMPONENT_STACK_UNAVAILABLE = '<component stack unavailable>';
@@ -46,7 +47,9 @@ export class ErrorBoundary extends React.Component<
 
     const errorToReport =
       error instanceof Error ? error : new Error(String(error));
-    Pulse.reportException(errorToReport, !handled);
+    if (!getIsShutdown()) {
+      Pulse.reportException(errorToReport, !handled);
+    }
 
     if (onError) {
       onError(error, componentStack);

package/src/errorHandler.ts

@@ -1,4 +1,5 @@
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { getIsShutdown, getIsStarted } from './config';
 import { mergeWithGlobalAttributes } from './globalAttributes';
 import { isSupportedPlatform } from './initialization';
 import { extractErrorDetails } from './utility';
@@ -68,7 +69,7 @@ export function reportException(
   isFatal: boolean = false,
   attributes?: PulseAttributes
 ): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || !getIsStarted() || getIsShutdown()) {
     return;
   }
 
@@ -160,6 +161,10 @@ function disableErrorHandler(): void {
   handlingFatal = false;
 }
 
+export function uninstallErrorHandler(): void {
+  disableErrorHandler();
+}
+
 export function setupErrorHandler(enableErrorHandler: boolean): void {
   if (enableErrorHandler) {
     initializeErrorHandler();

package/src/events.ts

@@ -1,11 +1,15 @@
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
-import { getFeaturesFromRemoteConfig } from './config';
+import {
+  getFeaturesFromRemoteConfig,
+  getIsShutdown,
+  getIsStarted,
+} from './config';
 import { mergeWithGlobalAttributes } from './globalAttributes';
 import { isSupportedPlatform } from './initialization';
 import type { PulseAttributes } from './pulse.interface';
 
 export function trackEvent(event: string, attributes?: PulseAttributes): void {
-  if (!isSupportedPlatform()) {
+  if (!isSupportedPlatform() || !getIsStarted() || getIsShutdown()) {
     return;
   }
   const features = getFeaturesFromRemoteConfig();

package/src/index.tsx

@@ -1,7 +1,7 @@
 import { startSpan, trackSpan } from './trace';
 import { reportException } from './errorHandler';
 import { trackEvent } from './events';
-import { start } from './config';
+import { start, shutdown } from './config';
 import { isInitialized } from './initialization';
 import { setGlobalAttribute } from './globalAttributes';
 import { setUserId, setUserProperty, setUserProperties } from './user';
@@ -9,7 +9,7 @@ import { ErrorBoundary, withErrorBoundary } from './errorBoundary';
 import { useNavigationTracking, markContentReady } from './navigation';
 
 export type { Span } from './trace';
-export type { PulseConfig, PulseStartOptions } from './config';
+export type { PulseConfig } from './config';
 export type { PulseAttributes, PulseAttributeValue } from './pulse.interface';
 export type {
   ReactNavigationIntegration,
@@ -22,6 +22,7 @@ export type { ErrorBoundaryProps, FallbackRender } from './errorBoundary';
 export { SpanStatusCode } from './trace';
 export const Pulse = {
   start,
+  shutdown,
   isInitialized,
   useNavigationTracking,
   markContentReady,

package/src/navigation/index.ts

@@ -5,6 +5,7 @@ import type {
   NavigationIntegrationOptions,
   NavigationRoute,
 } from './navigation.interface';
+import { DEFAULT_NAVIGATION_OPTIONS } from './navigation.interface';
 import { pushRecentRouteKey, LOG_TAGS } from './utils';
 import { discardSpan } from '../trace';
 import {
@@ -28,8 +29,22 @@ import { useNavigationTracking as useNavigationTrackingBase } from './useNavigat
 import { isSupportedPlatform } from '../initialization';
 import PulseReactNativeOtel from '../NativePulseReactNativeOtel';
 import { getFeaturesFromRemoteConfig } from '../config';
+import {
+  PULSE_FEATURE_NAMES,
+  type NavigationFeatureName,
+} from '../pulse.constants';
 
 export type { NavigationRoute, NavigationIntegrationOptions };
+export { DEFAULT_NAVIGATION_OPTIONS } from './navigation.interface';
+
+let currentNavigationUnregister: (() => void) | null = null;
+
+export function uninstallNavigationIntegration(): void {
+  if (currentNavigationUnregister) {
+    currentNavigationUnregister();
+    currentNavigationUnregister = null;
+  }
+}
 
 export interface ReactNavigationIntegration {
   registerNavigationContainer: (
@@ -38,18 +53,41 @@ export interface ReactNavigationIntegration {
   markContentReady: () => void;
 }
 
+function resolveNavigationFeatureState(
+  features: ReturnType<typeof getFeaturesFromRemoteConfig>,
+  featureName: NavigationFeatureName,
+  optionValue: boolean
+): boolean {
+  if (features !== undefined && features !== null)
+    return features[featureName] ?? optionValue;
+  return optionValue;
+}
+
 export function createReactNavigationIntegration(
   options?: NavigationIntegrationOptions
 ): ReactNavigationIntegration {
   const features = getFeaturesFromRemoteConfig();
-  const screenSessionTracking =
-    features?.screen_session ?? options?.screenSessionTracking ?? true;
-  const screenNavigationTracking =
-    features?.rn_screen_load ?? options?.screenNavigationTracking ?? true;
-  const screenInteractiveTracking =
-    features?.rn_screen_interactive ??
+
+  const screenSessionTracking = resolveNavigationFeatureState(
+    features,
+    PULSE_FEATURE_NAMES.SCREEN_SESSION,
+    options?.screenSessionTracking ??
+      DEFAULT_NAVIGATION_OPTIONS.screenSessionTracking
+  );
+
+  const screenNavigationTracking = resolveNavigationFeatureState(
+    features,
+    PULSE_FEATURE_NAMES.RN_SCREEN_LOAD,
+    options?.screenNavigationTracking ??
+      DEFAULT_NAVIGATION_OPTIONS.screenNavigationTracking
+  );
+
+  const screenInteractiveTracking = resolveNavigationFeatureState(
+    features,
+    PULSE_FEATURE_NAMES.RN_SCREEN_INTERACTIVE,
     options?.screenInteractiveTracking ??
-    false;
+      DEFAULT_NAVIGATION_OPTIONS.screenInteractiveTracking
+  );
 
   let navigationContainer: NavigationContainer | undefined;
   let recentRouteKeys: string[] = [];
@@ -241,6 +279,9 @@ export function createReactNavigationIntegration(
           }
           navigationContainer = undefined;
           isInitialized = false;
+          if (currentNavigationUnregister === unmountCleanup) {
+            currentNavigationUnregister = null;
+          }
 
           clearGlobalMarkContentReady(
             updatedInteractiveTracker.markContentReady
@@ -275,6 +316,7 @@ export function createReactNavigationIntegration(
       );
       isInitialized = true;
 
+      currentNavigationUnregister = unmountCleanup;
       return unmountCleanup;
     } catch (error) {
       console.error(

package/src/navigation/navigation.interface.ts

@@ -17,3 +17,10 @@ export interface NavigationIntegrationOptions {
   screenNavigationTracking?: boolean;
   screenInteractiveTracking?: boolean;
 }
+
+export const DEFAULT_NAVIGATION_OPTIONS: Required<NavigationIntegrationOptions> =
+  {
+    screenSessionTracking: true,
+    screenNavigationTracking: true,
+    screenInteractiveTracking: false,
+  };

package/src/navigation/screen-interactive.ts

@@ -1,4 +1,5 @@
 import { Pulse, type Span } from '../index';
+import { getIsStarted } from '../config';
 import { Platform } from 'react-native';
 import { SPAN_NAMES, ATTRIBUTE_KEYS, PULSE_TYPES } from '../pulse.constants';
 import { discardSpan } from '../trace';
@@ -131,6 +132,9 @@ export function createScreenInteractiveTracker(
 }
 
 export function markContentReady(): void {
+  if (!getIsStarted()) {
+    return;
+  }
   if (globalMarkContentReady) {
     globalMarkContentReady();
   } else {

package/src/navigation/screen-load.ts

@@ -1,11 +1,6 @@
 import { Pulse, type Span } from '../index';
 import { Platform } from 'react-native';
-import {
-  SPAN_NAMES,
-  ATTRIBUTE_KEYS,
-  PULSE_TYPES,
-  PHASE_VALUES,
-} from '../pulse.constants';
+import { SPAN_NAMES, ATTRIBUTE_KEYS, PULSE_TYPES } from '../pulse.constants';
 import type { NavigationRoute } from './navigation.interface';
 import { LOG_TAGS } from './utils';
 
@@ -34,7 +29,6 @@ export function createScreenLoadTracker(
     state.navigationSpan = Pulse.startSpan(SPAN_NAMES.NAVIGATED, {
       attributes: {
         [ATTRIBUTE_KEYS.PULSE_TYPE]: PULSE_TYPES.SCREEN_LOAD,
-        [ATTRIBUTE_KEYS.PHASE]: PHASE_VALUES.START,
         [ATTRIBUTE_KEYS.PLATFORM]: Platform.OS as 'android' | 'ios',
       },
     });

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,20 +1,43 @@
 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 uninstallXmlHttpRequestTracker: (() => void) | null = null;
+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 {
     // In react-native, we are intercepting XMLHttpRequest only, since axios and fetch both use it internally.
     // See: https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Network/fetch.js
     if (typeof XMLHttpRequest !== 'undefined') {
-      createXmlHttpRequestTracker(XMLHttpRequest);
+      const result = createXmlHttpRequestTracker(XMLHttpRequest);
+      uninstallXmlHttpRequestTracker = result.uninstall;
     } else {
       console.warn('[Pulse] XMLHttpRequest is not available');
     }
@@ -26,3 +49,14 @@ export function initializeNetworkInterceptor(): void {
 }
 
 export const isNetworkInterceptorInitialized = (): boolean => isInitialized;
+
+export function uninstallNetworkInterceptor(): void {
+  if (!isInitialized) {
+    return;
+  }
+  if (uninstallXmlHttpRequestTracker) {
+    uninstallXmlHttpRequestTracker();
+    uninstallXmlHttpRequestTracker = null;
+  }
+  isInitialized = false;
+}

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 =