@truewatchtech/react-native-mobile 0.3.15-alpha.1 → 0.3.16

package/src/ft_mobile_agent.tsx

@@ -1,5 +1,95 @@
-import { NativeModules } from 'react-native';
-import { version as sdkVersion } from './version'
+import { EmitterSubscription, NativeEventEmitter, NativeModules } from 'react-native';
+import { version as sdkVersion } from './version';
+
+/**
+ * Bridge context manager for managing shared properties across RUM and Logger modules
+ * This class provides a centralized way to store and retrieve global properties that will be
+ * automatically merged with local properties when making calls to RUM and Logger functions
+ */
+class BridgeContextManager {
+  private static instance: BridgeContextManager;
+  private properties: Map<string, any> = new Map();
+
+  private constructor() {
+    // Initialize with SDK version information
+    this.initializeSDKInfo();
+  }
+
+  /**
+   * Initialize SDK information properties
+   * @private
+   */
+  private initializeSDKInfo(): void {
+    // Create sdk_bridge_info with version information
+    const sdkBridgeInfo = {
+      react_native: sdkVersion,
+    };
+
+    // Set the sdk_bridge_info property
+    this.properties.set('sdk_bridge_info', JSON.stringify(sdkBridgeInfo));
+  }
+
+  /**
+   * Get singleton instance of BridgeContextManager
+   * @returns BridgeContextManager instance
+   */
+  public static getInstance(): BridgeContextManager {
+    if (!BridgeContextManager.instance) {
+      BridgeContextManager.instance = new BridgeContextManager();
+    }
+    return BridgeContextManager.instance;
+  }
+
+  /**
+   * Add bridge context properties that will be automatically merged with local properties
+   * @param properties Object containing key-value pairs
+   */
+  public appendBridgeContext(properties: Record<string, any>): void {
+    // Store properties locally in JavaScript
+    try {
+      // Store properties locally in JavaScript
+      Object.entries(properties).forEach(([key, value]) => {
+        this.properties.set(key, value);
+      });
+    } catch (error) {
+      console.warn('Failed to append bridge context:', error);
+    }
+  }
+
+  /**
+   * Merge bridge context properties with local properties
+   * Bridge context properties take precedence over local properties
+   * @param localProperties Local properties to merge with bridge context properties
+   * @returns Merged properties object
+   */
+  public mergeWithLocalPropertiesSync(localProperties?: object): Record<string, any> {
+    try {
+      const merged: Record<string, any> = {};
+
+      // First add local properties (if any)
+      if (localProperties) {
+        Object.assign(merged, localProperties);
+      }
+
+      // Then add bridge context properties (these will override local properties with same keys)
+      this.properties.forEach((value, key) => {
+        merged[key] = value;
+      });
+
+      return merged;
+    } catch (error) {
+      console.warn(
+        'Failed to merge bridge context with local properties:',
+        error
+      );
+      // Return empty object or only local properties on error
+      return localProperties ? { ...localProperties } : {};
+    }
+  }
+}
+
+// Internal bridge context manager - not exported
+export const bridgeContextManager = BridgeContextManager.getInstance();
 
 /**
  * Environment.
@@ -8,6 +98,87 @@ export enum EnvType {
   prod, gray, pre, common, local
 };
 export enum FTDBCacheDiscard { discard, discardOldest };
+
+/**
+ * Remote config override rule matching condition for custom keys. Supports exact match and contains match.
+ * For exact match, set the value directly, for example: "userid": "test_user", which means the rule will be applied when the custom key "userid" is exactly "test_user".
+ * For contains match, set the value as an object with a "contains" field, for example: "userid": { "contains": "test_user" }, which means the rule will be applied when the custom key "userid" contains the object "test_user".
+*/
+export type FTRemoteConfigCustomKeyContainsMatch = {
+  contains: string | number | boolean;
+};
+
+/**
+ * Matching rules for remote config override
+ * Defines matching conditions using customKeys
+ */
+export type FTRemoteConfigOverrideMatch = {
+  customKeys?: Record<string, string | number | boolean | FTRemoteConfigCustomKeyContainsMatch>;
+};
+
+/**
+ * Values that can be modified by remote config override rules.
+ * These values will adjust the fetched remote configuration before it is applied.
+*/
+export type FTRemoteConfigOverrideValues = {
+  env?: string;
+  serviceName?: string;
+  autoSync?: boolean;
+  compressIntakeRequests?: boolean;
+  syncPageSize?: number;
+  syncSleepTime?: number;
+  rumSampleRate?: number;
+  rumSessionOnErrorSampleRate?: number;
+  rumEnableTraceUserAction?: boolean;
+  rumEnableTraceUserView?: boolean;
+  rumEnableTraceUserResource?: boolean;
+  rumEnableResourceHostIP?: boolean;
+  rumEnableTrackAppUIBlock?: boolean;
+  rumBlockDurationMs?: number;
+  rumEnableTrackAppCrash?: boolean;
+  rumEnableTrackAppANR?: boolean;
+  rumEnableTraceWebView?: boolean;
+  rumAllowWebViewHost?: Array<string>;
+  traceSampleRate?: number;
+  traceEnableAutoTrace?: boolean;
+  traceType?: string;
+  logSampleRate?: number;
+  logLevelFilters?: Array<string>;
+  logEnableCustomLog?: boolean;
+  logEnableConsoleLog?: boolean;
+};
+
+/**
+ * Remote config override rules .
+ * Adjust the fetched remote configuration before application.
+*/
+export type FTRemoteConfigOverrideRule = {
+  id?: string,
+  enabled?: boolean,
+  match: FTRemoteConfigOverrideMatch,
+  override: FTRemoteConfigOverrideValues,
+}
+/**
+ * Final result of the remote config update
+ * @param triggerType the type of remote config update trigger, auto or manual
+ * @param success whether the remote config update was successful
+ * @param platform the platform of the device, ios or android
+ * @param timestamp the timestamp when the remote config update was triggered
+ * @param rawJson the final remote config update result, in JSON string format
+ * @param errorCode the error code if the remote config update failed, may be null if the update was successful
+ * @param errorMessage the error message if the remote config update failed, may be null if the update was successful
+ * @param appliedOverrideRuleIds the list of override rule IDs applied in this remote config update, may be null if no rules were applied
+ */
+export type FTRemoteConfigResult = {
+  triggerType: 'auto' | 'manual';
+  success: boolean;
+  platform: 'ios' | 'android';
+  timestamp: number;
+  rawJson?: string;
+  errorCode?: string | number;
+  errorMessage?: string;
+  appliedOverrideRuleIds?: string[];
+};
 /**
  * Configure SDK startup parameters.
  * @param serverUrl data reporting address, deprecated, use [datakitUrl] instead
@@ -29,7 +200,10 @@ export enum FTDBCacheDiscard { discard, discardOldest };
  * @param dbDiscardStrategy db data discard strategy
  * @param dataModifier data modifier, modify individual fields {key:value}, after setting, the SDK will replace the original value with the set value according to the key
  * @param lineDataModifier data modifier, modify single data {"measurement":measurement,"data":{key:value}}, after setting, the SDK will replace the original value with the set value according to the key
- */
+ * @param remoteConfiguration Set whether to enable remote dynamic configuration
+ * @param remoteConfigMiniUpdateInterval Set remote dynamic configuration minimum update interval, unit seconds, default 12*60*60
+ * @param remoteConfigOverrideRules Remote config override rules .Adjust the fetched remote configuration before application.
+*/
  export interface FTMobileConfig {
    /**
     * @deprecated "serverUrl" parameter renamed to "datakitUrl"
@@ -52,12 +226,13 @@ export enum FTDBCacheDiscard { discard, discardOldest };
    enableLimitWithDbSize?:boolean,
    dbCacheLimit?:number,
    dbDiscardStrategy?:FTDBCacheDiscard,
-   pkgInfo?: string,
    dataModifier?:object,
-   lineDataModifier?:object
+   lineDataModifier?:object,
+   remoteConfiguration?:boolean,
+   remoteConfigMiniUpdateInterval?:number,
+   remoteConfigOverrideRules?:Array<FTRemoteConfigOverrideRule>,
  }
 
-
 type FTMobileReactNativeType = {
 
   /**
@@ -118,16 +293,38 @@ type FTMobileReactNativeType = {
     * Clear all data that has not yet been uploaded to the server.
     */
    clearAllData():Promise<void>
+   /**
+    * Add bridge context properties that will be automatically merged with local properties
+    * @param properties Object containing key-value pairs
+    */
+   appendBridgeContext(properties: Record<string, any>): void;
+   /**
+   * Update remote configuration, after enabling remote configuration, you can call this method to update the configuration in real time.
+    */
+   updateRemoteConfig():Promise<FTRemoteConfigResult>
+   /**
+    * Update remote configuration with minimum update interval, after enabling remote configuration, you can call this method to update the configuration in real time.
+    * This method is used to set the minimum update interval for remote configuration updates. If the time since the last update is less than the specified interval, the update will not be performed.
+    * @param interval minimum update interval, unit seconds
+    * @param rules Remote config override rules .Adjust the fetched remote configuration before application. 
+    * @returns the result of the remote config update
+   */
+   updateRemoteConfigWithMiniUpdateInterval(interval:number,rules?: Array<FTRemoteConfigOverrideRule>):Promise<FTRemoteConfigResult>
+   /**
+    * Listen for auto remote configuration updates triggered by the native SDK.
+    * Manual updates are returned through the update Promise instead of this event.
+    */
+   addRemoteConfigListener(listener:(result:FTRemoteConfigResult)=>void): EmitterSubscription
  };
 
  class FTMobileReactNativeWrapper implements FTMobileReactNativeType {
    private sdk:FTMobileReactNativeType = NativeModules.FTMobileReactNative;
+   private emitter = new NativeEventEmitter(NativeModules.FTMobileReactNative);
 
    sdkConfig(config:FTMobileConfig): Promise<void> {
      if(config.serverUrl != null && config.serverUrl.length>0 && config.datakitUrl == null){
        config.datakitUrl = config.serverUrl;
      }
-     config.pkgInfo = sdkVersion;
      return this.sdk.sdkConfig(config);
    }
    bindRUMUserData(userId: string,userName?:string,userEmail?:string,extra?:object): Promise<void> {
@@ -157,6 +354,18 @@ type FTMobileReactNativeType = {
    clearAllData():Promise<void>{
     return this.sdk.clearAllData();
    }
+   appendBridgeContext(properties: Record<string, any>): void {
+     // Use bridgeContextManager to store properties in JavaScript and send to native SDK
+    bridgeContextManager.appendBridgeContext(properties);
+  }
+   updateRemoteConfig():Promise<FTRemoteConfigResult>{
+    return this.sdk.updateRemoteConfig();
+   }
+   updateRemoteConfigWithMiniUpdateInterval(interval:number,rules?: Array<FTRemoteConfigOverrideRule>):Promise<FTRemoteConfigResult>{
+      return this.sdk.updateRemoteConfigWithMiniUpdateInterval(interval,rules);
+   }
+   addRemoteConfigListener(listener:(result:FTRemoteConfigResult)=>void): EmitterSubscription {
+     return this.emitter.addListener('ft_remote_config_callback', listener);
+   }
  }
 export const FTMobileReactNative: FTMobileReactNativeType = new FTMobileReactNativeWrapper();
-

package/src/ft_rum.tsx

@@ -1,6 +1,7 @@
 import { NativeModules } from 'react-native';
 import { FTRumErrorTracking} from './rum/FTRumErrorTracking';
 import { FTRumActionTracking} from './rum/FTRumActionTracking';
+import { bridgeContextManager } from './ft_mobile_agent';
 
 /**
  * Error monitoring type.
@@ -26,7 +27,41 @@ import { FTRumActionTracking} from './rum/FTRumActionTracking';
   */
  export enum DetectFrequency { normal, frequent, rare }
 
- export enum FTRUMCacheDiscard { discard, discardOldest };
+export enum FTRUMCacheDiscard {
+  discard,
+  discardOldest,
+}
+
+export enum IOSCrashMonitoringType {
+  /** Monitor Mach kernel exceptions. */
+  machException = 0x01,
+
+  /** Monitor fatal signals. */
+  signal = 0x02,
+
+  /** Monitor uncaught C++ exceptions. */
+  cppException = 0x04,
+
+  /** Monitor uncaught Objective-C NSExceptions. */
+  nsException = 0x08,
+
+  /** Track and inject system information. */
+  system = 0x40,
+
+  /** Track and inject application state information. */
+  applicationState = 0x80,
+
+  /** All crash monitor types. */
+  all = machException |
+    signal |
+    cppException |
+    nsException |
+    applicationState |
+    system,
+
+  /** High compatibility crash monitor types (excludes Mach exceptions). */
+  highCompatibility = all & ~machException,
+}
 
 /**
  * Set RUM tracking conditions.
@@ -50,6 +85,9 @@ import { FTRumActionTracking} from './rum/FTRumActionTracking';
  * @param globalContext custom global parameters
  * @param rumCacheLimitCount RUM max cache size, default 100_000
  * @param rumDiscardStrategy RUM data discard strategy
+ * @param enableTraceWebView Set whether to enable WebView data collection, default true
+ * @param allowWebViewHost Set specific hosts or domains allowed to collect WebView data, nil means collect all
+ * @param iosCrashMonitoringType iOS crash monitoring type , default is highCompatibility, which does not include Mach exceptions for better compatibility. you must enable system crash monitoring to get crash stack traces and crash information. 
  */
  export interface FTRUMConfig{
    androidAppId:string,
@@ -72,6 +110,9 @@ import { FTRumActionTracking} from './rum/FTRumActionTracking';
    globalContext?:object,
    rumCacheLimitCount?:number,
    rumDiscardStrategy?:FTRUMCacheDiscard,
+   enableTraceWebView?: boolean,
+   allowWebViewHost?: Array<string>,
+   iosCrashMonitoringType?: IOSCrashMonitoringType,
  }
 /**
  * RUM Resource data.
@@ -212,31 +253,47 @@ import { FTRumActionTracking} from './rum/FTRumActionTracking';
      return this.rum.setConfig(config);
    }
    startAction(actionName:string,actionType:string,property?:object): Promise<void>{
-     return this.rum.startAction(actionName,actionType,property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.startAction(actionName,actionType,mergedProperties);
    }
    addAction(actionName: string, actionType: string, property?: object): Promise<void> {
-    return this.rum.addAction(actionName,actionType,property);
+    // Automatically merge bridge context properties with local properties
+    const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+    return this.rum.addAction(actionName,actionType,mergedProperties);
    }
    onCreateView(viewName:string,loadTime:number): Promise<void>{
      return this.rum.onCreateView(viewName,loadTime);
    }
    startView(viewName: string, property?:object): Promise<void>{
-     return this.rum.startView(viewName,property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.startView(viewName,mergedProperties);
    }
    stopView(property?:object): Promise<void>{
-     return this.rum.stopView(property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.stopView(mergedProperties);
    }
    addError(stack: string, message: string,property?:object): Promise<void>{
-     return this.rum.addError(stack,message,property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.addError(stack,message,mergedProperties);
    }
    addErrorWithType(type:string,stack: string, message: string,property?:object): Promise<void>{
-    return this.rum.addErrorWithType(type,stack,message,property);
+    // Automatically merge bridge context properties with local properties
+    const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+    return this.rum.addErrorWithType(type,stack,message,mergedProperties);
   }
    startResource(key: string,property?:object): Promise<void>{
-     return this.rum.startResource(key,property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.startResource(key,mergedProperties);
    }
    stopResource(key: string,property?:object): Promise<void>{
-     return this.rum.stopResource(key,property);
+     // Automatically merge bridge context properties with local properties
+     const mergedProperties = bridgeContextManager.mergeWithLocalPropertiesSync(property);
+     return this.rum.stopResource(key,mergedProperties);
    }
    addResource(key:string, resource:FTRUMResource,metrics:FTRUMResourceMetrics={}):Promise<void>{
      return this.rum.addResource(key,resource,metrics);

package/src/ft_tracing.tsx

@@ -5,11 +5,30 @@ import { NativeModules } from 'react-native';
  * Trace types for use.
  */
  export enum TraceType {
+  //
+  //  datadog trace
+  //
+  //  x-datadog-trace-id
+  //  x-datadog-parent-id
+  //  x-datadog-sampling-priority
+  //  x-datadog-origin
+  //
    ddTrace,
+   //
+   //  zipkin multi header
+   //
+   //  X-B3-TraceId
+   //  X-B3-SpanId
+   //  X-B3-Sampled
+   //
    zipkinMulti,
+   /// zipkin single header,b3
    zipkinSingle,
+   //  w3c, traceparent
    traceparent,
+   // skywalking 8.0+, sw-8
    skywalking,
+   // jaeger, header uber-trace-id
    jaeger,
  };
 /**
@@ -32,7 +51,7 @@ import { NativeModules } from 'react-native';
    * @param config trace configuration parameters.
    * @returns a Promise.
    */
-   setConfig(config: FTTraceConfig): Promise<void>; 
+   setConfig(config: FTTraceConfig): Promise<void>;
   /**
    * Get trace HTTP request header data.
    * @param url request URL
@@ -75,5 +94,5 @@ import { NativeModules } from 'react-native';
    }
 
  }
- export const FTReactNativeTrace:FTReactNativeTraceType = new FTReactNativeTraceWrapper(); 
+ export const FTReactNativeTrace:FTReactNativeTraceType = new FTReactNativeTraceWrapper();
 

package/src/index.tsx

@@ -1,17 +1,18 @@
-import {FTMobileConfig,FTMobileReactNative,EnvType,FTDBCacheDiscard} from './ft_mobile_agent'
+import {FTMobileConfig,FTMobileReactNative,EnvType,FTDBCacheDiscard,FTRemoteConfigResult,
+  FTRemoteConfigOverrideRule,FTRemoteConfigOverrideMatch,FTRemoteConfigOverrideValues} from './ft_mobile_agent'
 import {FTLogConfig,FTReactNativeLog,FTLogStatus,FTLogCacheDiscard} from './ft_logger'
-import {FTRUMConfig,FTRUMResource,FTReactNativeRUM,ErrorMonitorType,DeviceMetricsMonitorType,DetectFrequency,FTRUMResourceMetrics,FTRUMCacheDiscard} from './ft_rum'
+import {FTRUMConfig,FTRUMResource,FTReactNativeRUM,ErrorMonitorType,DeviceMetricsMonitorType,DetectFrequency,FTRUMResourceMetrics,FTRUMCacheDiscard,IOSCrashMonitoringType} from './ft_rum'
 import {FTTraceConfig,FTReactNativeTrace,TraceType} from './ft_tracing'
 import {FTRumActionTracking} from './rum/FTRumActionTracking'
 import {FTRumErrorTracking} from './rum/FTRumErrorTracking'
 
  
  export {
-   FTMobileReactNative,FTMobileConfig,EnvType,FTDBCacheDiscard,
+   FTMobileReactNative,FTMobileConfig,EnvType,FTDBCacheDiscard,FTRemoteConfigResult,
+   FTRemoteConfigOverrideRule,FTRemoteConfigOverrideMatch,FTRemoteConfigOverrideValues,
    FTLogConfig, FTReactNativeLog,FTLogStatus,FTLogCacheDiscard,
-   FTRUMConfig,FTReactNativeRUM,FTRUMResource,ErrorMonitorType,DeviceMetricsMonitorType,DetectFrequency,FTRUMResourceMetrics,FTRUMCacheDiscard,
+   FTRUMConfig,FTReactNativeRUM,FTRUMResource,ErrorMonitorType,DeviceMetricsMonitorType,DetectFrequency,FTRUMResourceMetrics,FTRUMCacheDiscard,IOSCrashMonitoringType,
    FTTraceConfig,FTReactNativeTrace,TraceType,
    FTRumActionTracking,
    FTRumErrorTracking
  };
-

package/src/version.ts

@@ -1,2 +1,2 @@
 // generated by genversion
-export const version = '0.3.15-alpha.1';
+export const version = '0.3.16';

package/android/src/main/java/com/ft/sdk/InnerClassProxy.java

@@ -1,8 +0,0 @@
-package com.ft.sdk;
-
-public class InnerClassProxy {
-
-  public static void addPkgInfo(FTSDKConfig config, String key, String value) {
-    config.addPkgInfo(key, value);
-  }
-}