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

package/android/src/main/java/com/ft/sdk/reactnative/FTRUMImpl.java

@@ -0,0 +1,267 @@
+package com.ft.sdk.reactnative;
+
+import com.ft.sdk.reactnative.BuildConfig;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.ft.sdk.DetectFrequency;
+import com.ft.sdk.FTInTakeUrlHandler;
+import com.ft.sdk.FTRUMConfig;
+import com.ft.sdk.FTRUMGlobalManager;
+import com.ft.sdk.FTSdk;
+import com.ft.sdk.RUMCacheDiscard;
+import com.ft.sdk.garble.bean.AppState;
+import com.ft.sdk.garble.bean.NetStatusBean;
+import com.ft.sdk.garble.bean.ResourceParams;
+import com.ft.sdk.reactnative.utils.ReactNativeUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FTRUMImpl {
+
+  private static final String DEFAULT_ERROR_TYPE = "reactnative_crash";
+  public static final String NAME = "FTReactNativeRUM";
+
+  @ReactMethod
+  public void setConfig(ReadableMap context, Promise promise) {
+    Map<String, Object> map = context.toHashMap();
+    String rumAppId = (String) map.get("androidAppId");
+    Double sampleRate = (Double) map.get("sampleRate");
+    Double sessionOnErrorSampleRate = (Double) map.get("sessionOnErrorSampleRate");
+
+    Boolean enableNativeUserAction = (Boolean) map.get("enableNativeUserAction");
+    Boolean enableNativeUserView = (Boolean) map.get("enableNativeUserView");
+    Boolean enableNativeUserResource = (Boolean) map.get("enableNativeUserResource");
+    Boolean enableResourceHostIP = (Boolean) map.get("enableResourceHostIP");
+    Boolean enableTrackNativeCrash = (Boolean) map.get("enableTrackNativeCrash");
+    Boolean enableTrackNativeAppANR = (Boolean) map.get("enableTrackNativeAppANR");
+    Boolean enableTrackNativeFreeze = (Boolean) map.get("enableTrackNativeFreeze");
+    Double nativeFreezeDurationMs = (Double) map.get("nativeFreezeDurationMs");
+    Integer monitorType = ReactNativeUtils.convertToNativeInt(map.get("errorMonitorType"));
+    Integer deviceMonitorType = ReactNativeUtils.convertToNativeInt(map.get("deviceMonitorType"));
+    Integer detectFrequency = ReactNativeUtils.convertToNativeInt(map.get("detectFrequency"));
+    Map<String, Object> globalContext = (Map<String, Object>) map.get("globalContext");
+    Integer rumCacheLimitCount = ReactNativeUtils.convertToNativeInt(map.get("rumCacheLimitCount"));
+    Integer rumDiscardStrategy = ReactNativeUtils.convertToNativeInt(map.get("rumDiscardStrategy"));
+
+    FTRUMConfig rumConfig = new FTRUMConfig().setRumAppId(rumAppId);
+    if (sampleRate != null) {
+      rumConfig.setSamplingRate(sampleRate.floatValue());
+    }
+    if (sessionOnErrorSampleRate != null) {
+      rumConfig.setSessionErrorSampleRate(sessionOnErrorSampleRate.floatValue());
+    }
+    if (enableNativeUserAction != null) {
+      rumConfig.setEnableTraceUserAction(enableNativeUserAction);
+    }
+    if (enableNativeUserView != null) {
+      rumConfig.setEnableTraceUserView(enableNativeUserView);
+    }
+    if (enableNativeUserResource != null) {
+      rumConfig.setEnableTraceUserResource(enableNativeUserResource);
+    }
+    if (enableResourceHostIP != null) {
+      rumConfig.setEnableResourceHostIP(enableResourceHostIP);
+    }
+    if (enableTrackNativeCrash != null) {
+      rumConfig.setEnableTrackAppCrash(enableTrackNativeCrash);
+    }
+    if (enableTrackNativeFreeze != null) {
+      if (nativeFreezeDurationMs != null) {
+        rumConfig.setEnableTrackAppUIBlock(enableTrackNativeFreeze, nativeFreezeDurationMs.longValue());
+      } else {
+        rumConfig.setEnableTrackAppUIBlock(enableTrackNativeFreeze);
+      }
+    }
+    if (enableTrackNativeAppANR != null) {
+      rumConfig.setEnableTrackAppANR(enableTrackNativeAppANR);
+    }
+    if (monitorType != null) {
+      rumConfig.setExtraMonitorTypeWithError(monitorType);
+    }
+    if (deviceMonitorType != null) {
+      if (detectFrequency != null) {
+        DetectFrequency deviceMetricsDetectFrequency;
+        switch (detectFrequency) {
+          case 1:
+            deviceMetricsDetectFrequency = DetectFrequency.FREQUENT;
+            break;
+          case 2:
+            deviceMetricsDetectFrequency = DetectFrequency.RARE;
+            break;
+          default:
+            deviceMetricsDetectFrequency = DetectFrequency.DEFAULT;
+            break;
+        }
+        rumConfig.setDeviceMetricsMonitorType(deviceMonitorType, deviceMetricsDetectFrequency);
+      } else {
+        rumConfig.setDeviceMetricsMonitorType(deviceMonitorType);
+      }
+    }
+    if (globalContext != null) {
+      for (Map.Entry<String, Object> entry : globalContext.entrySet()) {
+        rumConfig.addGlobalContext(entry.getKey(), entry.getValue().toString());
+      }
+    }
+    if (BuildConfig.DEBUG) {
+      rumConfig.setResourceUrlHandler(new FTInTakeUrlHandler() {
+        @Override
+        public boolean isInTakeUrl(String url) {
+          return ReactNativeUtils.isReactNativeDevUrl(url);
+        }
+      });
+    }
+    if (rumCacheLimitCount != null) {
+      rumConfig.setRumCacheLimitCount(rumCacheLimitCount);
+    }
+    if (rumDiscardStrategy != null) {
+      RUMCacheDiscard rumCacheDiscard = RUMCacheDiscard.DISCARD;
+      if (rumDiscardStrategy == 1) {
+        rumCacheDiscard = RUMCacheDiscard.DISCARD_OLDEST;
+      }
+      rumConfig.setRumCacheDiscardStrategy(rumCacheDiscard);
+    }
+    FTSdk.initRUMWithConfig(rumConfig);
+    //LogUtils.d("configCheck","rumConfig:"+new Gson().toJson(rumConfig));
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void startAction(String actionName, String actionType, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().startAction(actionName, actionType, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().startAction(actionName, actionType);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void addAction(String actionName, String actionType, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().addAction(actionName, actionType, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().addAction(actionName, actionType);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void onCreateView(String viewName, Double duration, Promise promise) {
+    FTRUMGlobalManager.get().onCreateView(viewName, duration.longValue());
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void startView(String viewName, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().startView(viewName, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().startView(viewName);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void stopView(ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().stopView(map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().stopView();
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void addError(String stack, String message, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().addError(stack, message, DEFAULT_ERROR_TYPE, AppState.RUN, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().addError(stack, message, DEFAULT_ERROR_TYPE, AppState.RUN);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void addErrorWithType(String errorType, String stack, String message, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().addError(stack, message, errorType, AppState.RUN, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().addError(stack, message, errorType, AppState.RUN);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void startResource(String key, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().startResource(key, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().startResource(key);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void stopResource(String key, ReadableMap map, Promise promise) {
+    if (map != null) {
+      FTRUMGlobalManager.get().stopResource(key, map.toHashMap());
+    } else {
+      FTRUMGlobalManager.get().stopResource(key);
+    }
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void addResource(String key, ReadableMap resourceContext, ReadableMap metricsContext, Promise promise) {
+    HashMap<String, Object> resourceMap = resourceContext.toHashMap();
+    String url = (String) resourceMap.get("url");
+    HashMap<String, String> responseHeader = (HashMap<String, String>) resourceMap.get("responseHeader");
+    HashMap<String, String> requestHeader = (HashMap<String, String>) resourceMap.get("requestHeader");
+    String method = (String) resourceMap.get("httpMethod");
+    Integer resourceStatus = ReactNativeUtils.convertToNativeInt(resourceMap.get("resourceStatus"));
+    String responseBody = (String) resourceMap.get("responseBody");
+//    String responseConnection = (String) resourceMap.get("responseConnection");
+//    String responseContentType = (String) resourceMap.get("responseContentType");
+//    String responseContentEncoding = (String) resourceMap.get("responseContentEncoding");
+
+//    HashMap<String, Object> metricsMap = metricsContext.toHashMap();
+//    Long fetchStartTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("fetchStartTime"));
+//    Long tcpStartTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("tcpStartTime"));
+//    Long tcpEndTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("tcpEndTime"));
+//    Long dnsStartTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("dnsStartTime"));
+//    Long dnsEndTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("dnsEndTime"));
+//    Long responseStartTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("responseStartTime"));
+//    Long responseEndTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("responseEndTime"));
+//    Long sslStartTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("sslStartTime"));
+//    Long sslEndTime = ReactNativeUtils.convertToNativeLong(metricsMap.get("sslEndTime"));
+
+    ResourceParams params = new ResourceParams();
+    params.url = url != null ? url : "";
+    params.responseHeader = responseHeader != null ? responseHeader.toString() : "";
+    params.resourceMethod = method;
+    params.requestHeader = requestHeader != null ? requestHeader.toString() : "";
+    params.resourceStatus = resourceStatus != null ? resourceStatus : 0;
+    params.responseBody = responseBody != null ? responseBody : "";
+//    params.responseConnection = responseConnection != null ? responseConnection : "";
+//    params.responseContentType = responseContentType != null ? responseContentType : "";
+//    params.responseContentEncoding = responseContentEncoding != null ? responseContentEncoding : "";
+
+    //not implement
+    NetStatusBean netStatusBean = new NetStatusBean();
+//    netStatusBean.fetchStartTime = (fetchStartTime != null ? fetchStartTime : -1L);
+//    netStatusBean.tcpStartTime = (tcpStartTime != null ? tcpStartTime : -1L);
+//    netStatusBean.tcpEndTime = (tcpEndTime != null ? tcpEndTime : -1L);
+//    netStatusBean.dnsStartTime = (dnsStartTime != null ? dnsStartTime : -1L);
+//    netStatusBean.dnsEndTime = (dnsEndTime != null ? dnsEndTime : -1L);
+//    netStatusBean.responseStartTime = (responseStartTime != null ? responseStartTime : -1L);
+//    netStatusBean.responseEndTime = (responseEndTime != null ? responseEndTime : -1L);
+//    netStatusBean.sslStartTime = (sslStartTime != null ? sslStartTime : -1L);
+//    netStatusBean.sslEndTime = (sslEndTime != null ? sslEndTime : -1L);
+
+    FTRUMGlobalManager.get().addResource(key, params, netStatusBean);
+    promise.resolve(null);
+  }
+
+}

package/android/src/main/java/com/ft/sdk/reactnative/FTTraceImpl.java

@@ -0,0 +1,89 @@
+package com.ft.sdk.reactnative;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.ft.sdk.FTSdk;
+import com.ft.sdk.FTTraceConfig;
+import com.ft.sdk.FTTraceManager;
+import com.ft.sdk.TraceType;
+import com.ft.sdk.reactnative.utils.ReactNativeUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FTTraceImpl {
+  public static final String NAME = "FTReactNativeTrace";
+  private static final String TAG = "FTTraceModule";
+
+  @ReactMethod
+  public void setConfig(ReadableMap context, Promise promise) {
+    Map<String, Object> map = context.toHashMap();
+    Double sampleRate = (Double) map.get("sampleRate");
+    Integer traceType = ReactNativeUtils.convertToNativeInt(map.get("traceType"));
+    Boolean enableLinkRUMData = (Boolean) map.get("enableLinkRUMData");
+    Boolean enableNativeAutoTrace = (Boolean) map.get("enableNativeAutoTrace");
+
+    FTTraceConfig traceConfig = new FTTraceConfig();
+    if (sampleRate != null) {
+      traceConfig.setSamplingRate(sampleRate.floatValue());
+    }
+
+    if (traceType != null) {
+      switch (traceType) {
+        case 0:
+          traceConfig.setTraceType(TraceType.DDTRACE);
+          break;
+        case 1:
+          traceConfig.setTraceType(TraceType.ZIPKIN_MULTI_HEADER);
+          break;
+        case 2:
+          traceConfig.setTraceType(TraceType.ZIPKIN_SINGLE_HEADER);
+          break;
+        case 3:
+          traceConfig.setTraceType(TraceType.TRACEPARENT);
+          break;
+        case 4:
+          traceConfig.setTraceType(TraceType.SKYWALKING);
+          break;
+        case 5:
+          traceConfig.setTraceType(TraceType.JAEGER);
+          break;
+        default:
+          traceConfig.setTraceType(TraceType.JAEGER);
+          break;
+      }
+    }
+
+    if (enableLinkRUMData != null) {
+      traceConfig.setEnableLinkRUMData(enableLinkRUMData);
+    }
+
+    if (enableNativeAutoTrace != null) {
+      traceConfig.setEnableAutoTrace(enableNativeAutoTrace);
+    }
+
+    FTSdk.initTraceWithConfig(traceConfig);
+    //LogUtils.d("configCheck","traceConfig:"+new Gson().toJson(traceConfig));
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void getTraceHeaderFields(String url, String key, Promise promise) {
+    HashMap<String, String> hashMap = null;
+    if (key == null) {
+      hashMap = FTTraceManager.get().getTraceHeader(url);
+    } else {
+      hashMap = FTTraceManager.get().getTraceHeader(key, url);
+    }
+
+    WritableNativeMap map = new WritableNativeMap();
+    if (hashMap != null) {
+      for (Map.Entry<String, String> entry : hashMap.entrySet()) {
+        map.putString(entry.getKey(), entry.getValue());
+      }
+    }
+    promise.resolve(map);
+  }
+}

package/android/src/main/java/com/ft/sdk/reactnative/utils/ReactNativeUtils.java

@@ -0,0 +1,59 @@
+package com.ft.sdk.reactnative.utils;
+
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+
+public class ReactNativeUtils {
+
+    private static final Pattern[] RN_DEV_INNER_URL_REGEX = {
+        Pattern.compile("^http://((10|172|192).[0-9]+.[0-9]+.[0-9]+|localhost|127.0.0.1):808[0-9]/logs$"), // expo
+        Pattern.compile("^http://localhost:808[0-9]/(hot|symbolicate|message|inspector).*$") // rn
+    };
+
+    private ReactNativeUtils() {
+        // Private constructor to prevent instantiation
+    }
+
+    /**
+     * Convert React Native number to int
+     */
+    public static Integer convertToNativeInt(Object value) {
+        if (value == null) {
+            return null;
+        }
+        try {
+            return (int) Double.parseDouble(value.toString());
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Convert React Native number to long
+     */
+    public static Long convertToNativeLong(Object value) {
+        if (value == null) {
+            return null;
+        }
+        try {
+            return (long) Double.parseDouble(value.toString());
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Check if it's a React Native debug stage generated URL request
+     * @param url
+     * @return
+     */
+    public static boolean isReactNativeDevUrl(String url) {
+        for (Pattern pattern : RN_DEV_INNER_URL_REGEX) {
+            Matcher matcher = pattern.matcher(url);
+            if (matcher.matches()) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/android/src/newarch/java/com/ft/sdk/reactnative/FTLogModule.java

@@ -0,0 +1,39 @@
+package com.ft.sdk.reactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+
+@ReactModule(name = FTLogModule.NAME)
+public class FTLogModule extends NativeFTLogSpec  {
+  private final FTLogInterface logImpl = new FTLogImpl();
+
+  public FTLogModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void logConfig(ReadableMap context, Promise promise) {
+    logImpl.logConfig(context, promise);
+  }
+
+  @ReactMethod
+  public void logging(String content, int logStatus, ReadableMap map, Promise promise) {
+    logImpl.logging(content, logStatus, map, promise);
+  }
+
+  @ReactMethod
+  public void logWithStatusString(String content, String logStatus, ReadableMap map, Promise promise) {
+    logImpl.logWithStatusString(content, logStatus, map, promise);
+  }
+}

package/android/src/newarch/java/com/ft/sdk/reactnative/FTMobileModule.java

@@ -0,0 +1,69 @@
+package com.ft.sdk.reactnative;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+
+@ReactModule(name = FTMobileModule.NAME)
+public class FTMobileModule extends NativeFTMobileSpec {
+  public static final String NAME = FTMobileImpl.NAME;
+  private final FTMobileImpl impl = new FTMobileImpl();
+
+  public FTMobileModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void sdkConfig(ReadableMap context, Promise promise) {
+    impl.sdkConfig(context, promise);
+  }
+
+  @ReactMethod
+  public void bindRUMUserData(String userId, String userName, String userEmail, ReadableMap extra, Promise promise) {
+    impl.bindRUMUserData(userId, userName, userEmail, extra, promise);
+  }
+
+  @ReactMethod
+  public void unbindRUMUserData(Promise promise) {
+    impl.unbindRUMUserData(promise);
+  }
+
+  @ReactMethod
+  public void flushSyncData(Promise promise) {
+    impl.flushSyncData(promise);
+  }
+
+  @ReactMethod
+  public void appendGlobalContext(ReadableMap extra, Promise promise) {
+    impl.appendGlobalContext(extra, promise);
+  }
+
+  @ReactMethod
+  public void appendLogGlobalContext(ReadableMap extra, Promise promise) {
+    impl.appendLogGlobalContext(extra, promise);
+  }
+
+  @ReactMethod
+  public void appendRUMGlobalContext(ReadableMap extra, Promise promise) {
+    impl.appendRUMGlobalContext(extra, promise);
+  }
+
+  @ReactMethod
+  public void shutDown(Promise promise) {
+    impl.shutDown(promise);
+  }
+
+  @ReactMethod
+  public void clearAllData(Promise promise) {
+    impl.clearAllData(promise);
+  }
+}

package/android/src/newarch/java/com/ft/sdk/reactnative/FTRUMModule.java

@@ -0,0 +1,84 @@
+package com.ft.sdk.reactnative;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReadableMap;
+
+@ReactModule(name = FTRUMModule.NAME)
+public class FTRUMModule extends NativeFTRUMSpec {
+  public static final String NAME = FTRUMImpl.NAME;
+  private final FTRUMImpl impl = new FTRUMImpl();
+
+  public FTRUMModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  @ReactMethod
+  public void setConfig(ReadableMap context, Promise promise) {
+    impl.setConfig(context, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void startAction(String actionName, String actionType, ReadableMap map, Promise promise) {
+    impl.startAction(actionName, actionType, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void addAction(String actionName, String actionType, ReadableMap map, Promise promise) {
+    impl.addAction(actionName, actionType, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void onCreateView(String viewName, Double duration, Promise promise) {
+    impl.onCreateView(viewName, duration, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void startView(String viewName, ReadableMap map, Promise promise) {
+    impl.startView(viewName, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void stopView(ReadableMap map, Promise promise) {
+    impl.stopView(map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void addError(String stack, String message, ReadableMap map, Promise promise) {
+    impl.addError(stack, message, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void addErrorWithType(String errorType, String stack, String message, ReadableMap map, Promise promise) {
+    impl.addErrorWithType(errorType, stack, message, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void startResource(String key, ReadableMap map, Promise promise) {
+    impl.startResource(key, map, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void stopResource(String key, ReadableMap map, Promise promise) {
+    impl.stopResource(key, map, promise);
+  }
+}

package/android/src/newarch/java/com/ft/sdk/reactnative/FTTraceModule.java

@@ -0,0 +1,34 @@
+package com.ft.sdk.reactnative;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+@ReactModule(name = FTTraceModule.NAME)
+public class FTTraceModule extends NativeFTTraceSpec{
+  public static final String NAME = FTTraceImpl.NAME;
+  private final FTTraceImpl impl = new FTTraceImpl();
+
+  public FTTraceModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  @ReactMethod
+  public void setConfig(ReadableMap context, Promise promise) {
+    impl.setConfig(context, promise);
+  }
+
+  @Override
+  @ReactMethod
+  public void getTraceHeaderFields(String url, String key, Promise promise) {
+    impl.getTraceHeaderFields(url, key, promise);
+  }
+}

package/android/src/oldarch/java/com/ft/sdk/reactnative/FTLogModule.java

@@ -0,0 +1,36 @@
+package com.ft.sdk.reactnative;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+public class FTLogModule extends ReactContextBaseJavaModule {
+  private final FTLogImpl logImpl = new FTLogImpl();
+
+  public FTLogModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public String getName() {
+    return FTLogImpl.NAME;
+  }
+
+  @ReactMethod
+  public void logConfig(ReadableMap context, Promise promise) {
+    logImpl.logConfig(context, promise);
+  }
+
+  @ReactMethod
+  public void logging(String content, int logStatus, ReadableMap map, Promise promise) {
+    logImpl.logging(content, logStatus, map, promise);
+  }
+
+  @ReactMethod
+  public void logWithStatusString(String content, String logStatus, ReadableMap map, Promise promise) {
+    logImpl.logWithStatusString(content, logStatus, map, promise);
+  }
+
+}