@dreamhorizonorg/pulse-react-native 0.0.1 → 0.0.2

package/scripts/pulse-cli.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+const { checkAndAssertNodeVersion } = require('./utils');
+checkAndAssertNodeVersion();
+
+const { Command } = require('commander');
+const { upload } = require('./uploadService');
+const TAG_OPTIONAL = '(OPTIONAL)';
+
+const program = new Command();
+
+program
+  .name('pulse-cli')
+  .description('Pulse CLI - Command-line tool for Pulse SDK')
+  .usage('[command] [subcommand] [options]')
+  .version(require('../package.json').version);
+
+const uploadCommand = new Command('upload')
+  .description(
+    'Upload multiple symbol files to deobfuscate stack traces and improve error debugging.'
+  )
+  .usage('[subcommand] [options]');
+
+uploadCommand
+  .command('react-native-android')
+  .description('Upload React Native Android files')
+  .requiredOption(
+    '-u, --api-url <url>',
+    'URL for uploading source maps and related build artifacts.'
+  )
+  .requiredOption(
+    '-v, --app-version <version>',
+    'App version of the application (e.g., 1.0.0)'
+  )
+  .requiredOption('-c, --version-code <code>', 'Version code (e.g., 1)')
+  .requiredOption(
+    '-j, --js-sourcemap <path>',
+    'JavaScript source map file path'
+  )
+  .option(
+    '-b, --bundle-id <id>',
+    `${TAG_OPTIONAL} CodePush bundle label for identifying the specific bundle version (e.g., v1)`
+  )
+  .option(
+    '-m, --mapping <path>',
+    `${TAG_OPTIONAL} ProGuard/R8 mapping file path`
+  )
+  .option('-d, --debug', `${TAG_OPTIONAL} Show debug information`)
+  .action(async (options) => {
+    await upload('react-native-android', options);
+  });
+
+uploadCommand
+  .command('react-native-ios')
+  .description('Upload React Native iOS source maps')
+  .requiredOption(
+    '-u, --api-url <url>',
+    'URL for uploading source maps and related build artifacts.'
+  )
+  .requiredOption(
+    '-v, --bundle-version <version>',
+    'Bundle version from Info.plist CFBundleShortVersionString (e.g., 1.0.0)'
+  )
+  .requiredOption('-c, --version-code <code>', 'Version code (e.g., 1)')
+  .requiredOption(
+    '-j, --js-sourcemap <path>',
+    'JavaScript source map file path'
+  )
+  .option(
+    '-b, --bundle-id <id>',
+    `${TAG_OPTIONAL} CodePush bundle label for identifying the specific bundle version (e.g., v1)`
+  )
+  .option('-d, --debug', `${TAG_OPTIONAL} Show debug information`)
+  .action(async (options) => {
+    await upload('react-native-ios', options);
+  });
+
+program.addCommand(uploadCommand);
+
+program.showHelpAfterError();
+
+program.parse();

package/scripts/uploadService.js

@@ -0,0 +1,122 @@
+/* global Buffer */
+const fs = require('fs');
+const {
+  getPlatform,
+  validateFiles,
+  validateVersionVersionCodeBundleId,
+} = require('./utils');
+
+function buildMetadata(files, appVersion, versionCode, platform, bundleId) {
+  const metadata = files.map((file) => ({
+    type: file.metadataType,
+    appVersion: appVersion,
+    versionCode: versionCode,
+    platform: platform,
+    fileName: file.fileName,
+    bundleId: bundleId || null,
+  }));
+  return metadata;
+}
+
+async function uploadFiles(commandName, options) {
+  const platform = getPlatform(commandName);
+  const files = validateFiles(options);
+  const version =
+    platform === 'ios' ? options.bundleVersion : options.appVersion;
+
+  const metadata = buildMetadata(
+    files,
+    version,
+    options.versionCode,
+    platform,
+    options.bundleId
+  );
+
+  const formData = new FormData();
+  const metadataContent = JSON.stringify(metadata, null, 2);
+
+  if (options.debug) {
+    console.log('\n📋 Metadata content (metadata.txt):');
+    console.log('─'.repeat(60));
+    console.log(metadataContent);
+    console.log('─'.repeat(60));
+    console.log(
+      `Metadata size: ${Buffer.byteLength(metadataContent, 'utf-8')} bytes\n`
+    );
+  }
+
+  const metadataBlob = new Blob([metadataContent], {
+    type: 'application/json',
+  });
+  formData.append('metadata', metadataBlob, 'metadata.txt');
+
+  for (const file of files) {
+    const fileBuffer = fs.readFileSync(file.path);
+    const fileBlob = new Blob([fileBuffer]);
+    formData.append('fileContent', fileBlob, file.fileName);
+  }
+
+  console.log(`\n📤 Uploading ${files.length} file(s) to ${options.apiUrl}...`);
+  console.log(`   Command: ${commandName}`);
+  console.log(`   Platform: ${platform}`);
+  files.forEach((file) => {
+    console.log(`   - ${file.fileName} (${file.metadataType})`);
+  });
+
+  if (options.debug) {
+    console.log('\n🔍 Debug Info:');
+    console.log(`   API URL: ${options.apiUrl}`);
+    console.log(`   App Version: ${version}`);
+    console.log(`   Version Code: ${options.versionCode}`);
+    if (options.bundleId) {
+      console.log(`   Bundle ID: ${options.bundleId}`);
+    }
+    files.forEach((file) => {
+      const stats = fs.statSync(file.path);
+      console.log(
+        `   File: ${file.fileName} (${(stats.size / 1024).toFixed(2)} KB)`
+      );
+      console.log(`   File Path: ${file.path}`);
+    });
+  }
+
+  const response = await fetch(options.apiUrl, {
+    method: 'POST',
+    body: formData,
+  });
+
+  const responseData = await response.json().catch(async () => {
+    const text = await response.text();
+    return text ? { message: text } : {};
+  });
+
+  if (options.debug && responseData && Object.keys(responseData).length > 0) {
+    console.log('\n📥 Backend Response:');
+    console.log(`   Status: ${response.status} ${response.statusText}`);
+    console.log(`   Response: ${JSON.stringify(responseData, null, 2)}`);
+  }
+
+  if (!response.ok) {
+    const errorText =
+      responseData.error || responseData.message || 'Unknown error';
+    throw new Error(
+      `Upload failed: HTTP ${response.status} ${response.statusText}. ${errorText}`
+    );
+  }
+
+  console.log('\n✓ Files uploaded successfully');
+}
+
+async function upload(commandName, options) {
+  try {
+    validateVersionVersionCodeBundleId(options, commandName);
+    await uploadFiles(commandName, options);
+  } catch (error) {
+    console.error(`\n✗ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  upload,
+};

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,12 @@ 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(): Object;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('PulseReactNativeOtel');

package/src/config.ts

@@ -3,8 +3,11 @@ 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';
 
 export type PulseConfig = {
   autoDetectExceptions?: boolean;
@@ -26,6 +29,23 @@ const defaultConfig: PulseConfig = {
 
 let currentConfig: PulseConfig = { ...defaultConfig };
 
+// Cache for features from remote SDK config
+let cachedFeatures: PulseFeatureConfig = null;
+
+/**
+ * Gets all features from the remote SDK config.
+ * @returns Record of feature names to their enabled status
+ */
+export function getFeaturesFromRemoteConfig(): PulseFeatureConfig {
+  if (cachedFeatures !== null) {
+    return cachedFeatures;
+  }
+
+  const features = PulseReactNativeOtel.getAllFeatures();
+  cachedFeatures = features as PulseFeatureConfig;
+  return cachedFeatures;
+}
+
 function configure(config: PulseConfig): void {
   currentConfig = {
     ...currentConfig,
@@ -42,9 +62,14 @@ export function start(options?: PulseStartOptions): void {
   if (!isSupportedPlatform()) {
     return;
   }
-  const autoDetectExceptions = options?.autoDetectExceptions ?? true;
-  const autoDetectNavigation = options?.autoDetectNavigation ?? true;
-  const autoDetectNetwork = options?.autoDetectNetwork ?? 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,
@@ -52,10 +77,13 @@ export function start(options?: PulseStartOptions): void {
   });
 }
 
-export function createNavigationIntegrationWithConfig(): ReactNavigationIntegration {
+export function createNavigationIntegrationWithConfig(
+  options?: NavigationIntegrationOptions
+): ReactNavigationIntegration {
   if (!isSupportedPlatform()) {
     return {
-      registerNavigationContainer: (_: unknown) => {},
+      registerNavigationContainer: (_: unknown) => () => {},
+      markContentReady: () => {},
     };
   }
   if (!currentConfig.autoDetectNavigation) {
@@ -63,13 +91,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,11 +1,12 @@
 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';
@@ -13,7 +14,8 @@ 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,