@dreamhorizonorg/pulse-react-native 0.0.1 → 0.0.3

package/scripts/utils.js

@@ -0,0 +1,125 @@
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json');
+
+const FILE_TYPE_TO_BACKEND_TYPE = {
+  'js-sourcemap': 'JS',
+  'mapping': 'mapping',
+  'android-ndk': 'ndk',
+};
+
+function checkAndAssertNodeVersion() {
+  const nodeVersion = process.versions.node.split('.');
+  const majorVersion = parseInt(nodeVersion[0], 10);
+
+  const requiredVersion = packageJson.engines?.node;
+  let minMajorVersion = 18; // fallback
+
+  if (requiredVersion) {
+    const match = requiredVersion.match(/>=(\d+)/);
+    if (match) {
+      minMajorVersion = parseInt(match[1], 10);
+    }
+  }
+
+  if (majorVersion < minMajorVersion) {
+    console.error(
+      `✗ Error: Pulse CLI requires Node.js ${minMajorVersion}.0.0 or higher.`
+    );
+    console.error(`  Current version: ${process.versions.node}`);
+    console.error(
+      `  Required: ${requiredVersion || `>=${minMajorVersion}.0.0`}`
+    );
+    console.error(`  Please upgrade Node.js: https://nodejs.org/`);
+    process.exit(1);
+  }
+}
+
+function getPlatform(commandName) {
+  if (commandName.includes('android')) {
+    return 'android';
+  }
+  if (commandName.includes('ios')) {
+    return 'ios';
+  }
+  return 'Unknown';
+}
+
+function validateFiles(options) {
+  const files = [];
+  const errors = [];
+
+  Object.keys(FILE_TYPE_TO_BACKEND_TYPE).forEach((fileOption) => {
+    const optionKey = fileOption.replace(/-([a-z])/g, (_, letter) =>
+      letter.toUpperCase()
+    );
+    const optionValue = options[optionKey];
+
+    if (!optionValue) {
+      return;
+    }
+
+    const filePath = path.resolve(optionValue);
+    if (!fs.existsSync(filePath)) {
+      errors.push(`File not found for filepath: ${filePath}`);
+      return;
+    }
+
+    files.push({
+      optionName: fileOption,
+      path: filePath,
+      fileName: path.basename(filePath),
+      metadataType: FILE_TYPE_TO_BACKEND_TYPE[fileOption],
+    });
+  });
+
+  if (errors.length > 0) {
+    throw new Error(`Validation errors:\n  ${errors.join('\n  ')}`);
+  }
+
+  if (files.length === 0) {
+    throw new Error('No files to upload');
+  }
+
+  return files;
+}
+
+function validateVersionVersionCodeBundleId(options, commandName) {
+  const platform = getPlatform(commandName);
+  const isIOS = platform === 'ios';
+  const version = isIOS ? options.bundleVersion : options.appVersion;
+
+  if (!options.versionCode) {
+    throw new Error('Version code is required');
+  }
+  const versionCodeNum = parseInt(options.versionCode, 10);
+  if (isNaN(versionCodeNum) || versionCodeNum <= 0) {
+    throw new Error(
+      `Invalid version code: "${options.versionCode}". Must be a positive integer.`
+    );
+  }
+
+  if (!version || typeof version !== 'string' || version.trim().length === 0) {
+    throw new Error(
+      !version
+        ? `Missing required option: ${isIOS ? '--bundle-version' : '--app-version'}`
+        : `Invalid ${isIOS ? 'bundle version' : 'app version'}: "${version}". Must be a non-empty string.`
+    );
+  }
+
+  if (options.bundleId) {
+    const bundleIdPattern = /^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)+$/i;
+    if (!bundleIdPattern.test(options.bundleId)) {
+      throw new Error(
+        `Invalid bundle-id: "${options.bundleId}". Must be in reverse domain notation (e.g., com.example.app).`
+      );
+    }
+  }
+}
+
+module.exports = {
+  checkAndAssertNodeVersion,
+  getPlatform,
+  validateFiles,
+  validateVersionVersionCodeBundleId,
+};

package/src/NativePulseReactNativeOtel.ts

@@ -22,8 +22,8 @@ export interface Spec extends TurboModule {
     attributes?: Object
   ): boolean;
 
-  /** Start an active span; returns spanId (simplified). */
-  startSpan(name: string, attributes?: Object): string;
+  /** Start an active span; returns spanId. */
+  startSpan(name: string, inheritContext: boolean, attributes?: Object): string;
 
   /** End a span with optional status code. */
   endSpan(spanId: string, statusCode?: string): boolean;
@@ -41,6 +41,9 @@ export interface Spec extends TurboModule {
     stackTrace?: string
   ): boolean;
 
+  /** Discard a span without sending it to backend. */
+  discardSpan(spanId: string): boolean;
+
   /** Set user id for the session. Setting null will reset the id */
   setUserId(id: string | null): void;
 
@@ -52,6 +55,19 @@ export interface Spec extends TurboModule {
 
   /** Trigger ANR test (freezes main thread for 6 seconds) */
   triggerAnr(): void;
+
+  /** Set the current React Native screen name to sync active screen name on Android/iOS */
+  setCurrentScreenName(screenName: string): boolean;
+
+  /** Get all SDK Remote Config features */
+  getAllFeatures(): {
+    rn_screen_load: boolean;
+    screen_session: boolean;
+    rn_screen_interactive: boolean;
+    network_instrumentation: boolean;
+    custom_events: boolean;
+    js_crash: boolean;
+  } | null;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('PulseReactNativeOtel');

package/src/config.ts

@@ -3,29 +3,53 @@ import { isSupportedPlatform } from './initialization';
 import {
   createReactNavigationIntegration,
   type ReactNavigationIntegration,
-} from './reactNavigation';
+  type NavigationIntegrationOptions,
+} from './navigation';
 import { initializeNetworkInterceptor } 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 };
 
+// Cache for features from remote SDK config
+let cachedFeatures: PulseFeatureConfig;
+
+/**
+ * Gets all features from the remote SDK config.
+ * @returns Record of feature names to their enabled status, or null if config not available
+ */
+export function getFeaturesFromRemoteConfig(): PulseFeatureConfig {
+  if (cachedFeatures !== undefined) {
+    return cachedFeatures;
+  }
+
+  cachedFeatures = PulseReactNativeOtel.getAllFeatures();
+  return cachedFeatures;
+}
+
 function configure(config: PulseConfig): void {
   currentConfig = {
     ...currentConfig,
@@ -34,28 +58,74 @@ 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()) {
-    return;
+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;
   }
-  const autoDetectExceptions = options?.autoDetectExceptions ?? true;
-  const autoDetectNavigation = options?.autoDetectNavigation ?? true;
-  const autoDetectNetwork = options?.autoDetectNetwork ?? true;
-  configure({
-    autoDetectExceptions,
-    autoDetectNavigation,
-    autoDetectNetwork,
-  });
+  return optionValue;
+}
+
+export function start(options?: PulseConfig): void {
+  if (!isSupportedPlatform()) return;
+
+  const features = getFeaturesFromRemoteConfig();
+  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 createNavigationIntegrationWithConfig(): ReactNavigationIntegration {
+export function createNavigationIntegrationWithConfig(
+  options?: NavigationIntegrationOptions
+): ReactNavigationIntegration {
   if (!isSupportedPlatform()) {
     return {
-      registerNavigationContainer: (_: unknown) => {},
+      registerNavigationContainer: (_: unknown) => () => {},
+      markContentReady: () => {},
     };
   }
   if (!currentConfig.autoDetectNavigation) {
@@ -63,13 +133,14 @@ export function createNavigationIntegrationWithConfig(): ReactNavigationIntegrat
       '[Pulse Navigation] auto-detection disabled via Pulse.start; createNavigationIntegration() returning no-op.'
     );
     const noop: ReactNavigationIntegration = {
-      registerNavigationContainer: (_: unknown) => {
+      registerNavigationContainer: (_: unknown) => () => {
         console.warn(
           '[Pulse Navigation] auto-detection disabled via Pulse.start; registerNavigationContainer() returning no-op.'
         );
       },
+      markContentReady: () => {},
     };
     return noop;
   }
-  return createReactNavigationIntegration();
+  return createReactNavigationIntegration(options);
 }

package/src/errorBoundary.tsx

@@ -30,17 +30,22 @@ const INITIAL_STATE: ErrorBoundaryState = {
   error: null,
 };
 
-export class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+export class ErrorBoundary extends React.Component<
+  ErrorBoundaryProps,
+  ErrorBoundaryState
+> {
   public state: ErrorBoundaryState = INITIAL_STATE;
 
   public componentDidCatch(error: unknown, errorInfo: React.ErrorInfo): void {
-    const componentStack = errorInfo.componentStack || COMPONENT_STACK_UNAVAILABLE;
+    const componentStack =
+      errorInfo.componentStack || COMPONENT_STACK_UNAVAILABLE;
     const { onError } = this.props;
 
     // Error is handled if a fallback is provided, otherwise it's unhandled (fatal)
     const handled = !!this.props.fallback;
 
-    const errorToReport = error instanceof Error ? error : new Error(String(error));
+    const errorToReport =
+      error instanceof Error ? error : new Error(String(error));
     Pulse.reportException(errorToReport, !handled);
 
     if (onError) {
@@ -76,9 +81,10 @@ export class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoun
 
 export function withErrorBoundary<P extends Record<string, any>>(
   WrappedComponent: React.ComponentType<P>,
-  errorBoundaryOptions: ErrorBoundaryProps,
+  errorBoundaryOptions: ErrorBoundaryProps
 ): React.FC<P> {
-  const componentDisplayName = WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;
+  const componentDisplayName =
+    WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;
 
   const Wrapped = React.memo((props: P) => (
     <ErrorBoundary {...errorBoundaryOptions}>

package/src/events.ts

@@ -1,4 +1,5 @@
 import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { getFeaturesFromRemoteConfig } from './config';
 import { mergeWithGlobalAttributes } from './globalAttributes';
 import { isSupportedPlatform } from './initialization';
 import type { PulseAttributes } from './pulse.interface';
@@ -7,6 +8,12 @@ export function trackEvent(event: string, attributes?: PulseAttributes): void {
   if (!isSupportedPlatform()) {
     return;
   }
+  const features = getFeaturesFromRemoteConfig();
+  const customEventsEnabled = features?.custom_events ?? true;
+
+  if (!customEventsEnabled) {
+    return;
+  }
 
   const observedTimeMs = Date.now();
   const mergedAttributes = mergeWithGlobalAttributes(attributes || {});

package/src/global.d.ts

@@ -6,4 +6,3 @@ declare global {
 }
 
 export {};
-

package/src/index.tsx

@@ -1,19 +1,21 @@
 import { startSpan, trackSpan } from './trace';
 import { reportException } from './errorHandler';
 import { trackEvent } from './events';
-import { start, createNavigationIntegrationWithConfig } from './config';
+import { start } from './config';
 import { isInitialized } from './initialization';
 import { setGlobalAttribute } from './globalAttributes';
 import { setUserId, setUserProperty, setUserProperties } from './user';
 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,
   NavigationRoute,
-} from './reactNavigation';
+  NavigationIntegrationOptions,
+} from './navigation';
 
 export type { ErrorBoundaryProps, FallbackRender } from './errorBoundary';
 
@@ -21,7 +23,8 @@ export { SpanStatusCode } from './trace';
 export const Pulse = {
   start,
   isInitialized,
-  createNavigationIntegration: createNavigationIntegrationWithConfig,
+  useNavigationTracking,
+  markContentReady,
   trackEvent,
   reportException,
   trackSpan,