RUM Configuration¶

FTSdk.initRUMWithConfig(
        new FTRUMConfig()
            .setRumAppId(RUM_APP_ID)
            .setEnableTraceUserView(true)
            .setDeviceMetricsMonitorType(DeviceMetricsMonitorType.ALL.getValue())
            .setEnableTraceUserAction(true)
            .setEnableTraceUserResource(true)
            .setEnableTrackAppUIBlock(true)
            .setEnableTrackAppCrash(true)
            .setEnableTrackAppANR(true)
            .setExtraMonitorTypeWithError(ErrorMonitorType.ALL.getValue())
);

FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setRumAppId(RUM_APP_ID)
        .setEnableTraceUserView(true)
        .setDeviceMetricsMonitorType(DeviceMetricsMonitorType.ALL.getValue())
        .setEnableTraceUserAction(true)
        .setEnableTraceUserResource(true)
        .setEnableTrackAppUIBlock(true)
        .setEnableTrackAppCrash(true)
        .setEnableTrackAppANR(true)
        .setExtraMonitorTypeWithError(ErrorMonitorType.ALL.getValue())
)

FTRUMConfig config = new FTRUMConfig()
    .setEnableTrackAppCrash(true)
    .setEnableTrackAppANR(true)
    .setIssueDataProvider(issue -> {
        Map<String, Object> fields = new HashMap<>();
        fields.put("business_scene", sceneStore.current());
        fields.put("historical_issue", issue.isHistorical());
        return fields;
    });

val config = FTRUMConfig()
    .setEnableTrackAppCrash(true)
    .setEnableTrackAppANR(true)
    .setIssueDataProvider { issue ->
        mapOf(
            "business_scene" to sceneStore.current(),
            "historical_issue" to issue.isHistorical
        )
    }

/**
 * Add an Action
 *
 * @param actionName Action name
 * @param actionType Action type
 * @param property   Additional attributes (optional)
 */
public void startAction(String actionName, String actionType, HashMap<String, Object> property)

/**
 * Add an Action. This type of data cannot be associated with Error, Resource, or LongTask data.
 *
 * @param actionName Action name
 * @param actionType Action type
 * @param duration   Duration in nanoseconds (optional)
 * @param property   Extended attributes (optional)
 */
public void addAction(String actionName, String actionType, long duration, HashMap<String, Object> property)

/**
 * Add an action
 *
 * @param actionName Action name
 * @param actionType Action type
 * @param property   Additional attributes (optional)
 */
fun startAction(actionName: String, actionType: String, property: HashMap<String, Any>)

/**
 * Add an Action
 *
 * @param actionName Action name
 * @param actionType Action type
 * @param duration   Duration in nanoseconds (optional)
 * @param property   Extended attributes (optional)
 */
fun addAction(actionName: String, actionType: String, duration: Long, property: HashMap<String, Any>)

// Scenario 1
FTRUMGlobalManager.get().startAction("login", "action_type");

// Scenario 2: Dynamic parameters
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().startAction("login", "action_type", map);

// Scenario 1
FTRUMGlobalManager.get().addAction("login", "action_type");

// Scenario 2: Dynamic parameters
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addAction("login", "action_type", map);

// Scenario 1
FTRUMGlobalManager.get().startAction("login", "action_type")

// Scenario 2: Dynamic parameters
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().startAction("login", "action_type", map)

// Scenario 1
FTRUMGlobalManager.get().addAction("login", "action_type")

// Scenario 2: Dynamic parameters
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addAction("login", "action_type", map)

/**
 * View start
 *
 * @param viewName Current page name
 * @param property Additional attributes (optional)
 */
public void startView(String viewName, HashMap<String, Object> property)

/**
 * View stop
 *
 * @param property Additional attributes (optional)
 */
public void stopView(HashMap<String, Object> property)

/**
 * Update the current view loading_time metric, in nanoseconds
 *
 * @param duration duration
 */
public void updateLoadTime(long duration)

/**
 * View start
 *
 * @param viewName Current page name
 * @param property Additional attributes (optional)
 */
fun startView(viewName: String, property: HashMap<String, Any>)

/**
 * View stop
 *
 * @param property Additional attributes (optional)
 */
fun stopView(property: HashMap<String, Any>)

/**
 * Update the current view loading_time metric, in nanoseconds
 *
 * @param duration duration
 */
fun updateLoadTime(duration: Long)

@Override
protected void onResume() {
    super.onResume();

    // Scenario 1
    FTRUMGlobalManager.get().startView("Current Page Name");

    // Scenario 2: Dynamic parameters
    HashMap<String, Object> map = new HashMap<>();
    map.put("ft_key", "ft_value");
    map.put("ft_key_will_change", "ft_value");
    FTRUMGlobalManager.get().startView("Current Page Name", map)
}

@Override
protected void onPause() {
    super.onPause();

    // Scenario 1
    FTRUMGlobalManager.get().stopView();

    // Scenario 2: Dynamic parameters
    HashMap<String, Object> map = new HashMap<>();
    map.put("ft_key_will_change", "ft_value_change"); // The value of ft_key_will_change will be updated to ft_value_change when stopView is called.
    FTRUMGlobalManager.get().stopView(map);

}

override fun onResume() {
    super.onResume()

    // Scenario 1
    FTRUMGlobalManager.get().startView("Current Page Name")

    // Scenario 2: Dynamic parameters
    val map = HashMap<String, Any>()
    map["ft_key"] = "ft_value"
    map["ft_key_will_change"] = "ft_value"
    FTRUMGlobalManager.get().startView("Current Page Name", map)
}

override fun onPause() {
    super.onPause()

    // Scenario 1
    FTRUMGlobalManager.get().stopView()

    // Scenario 2: Dynamic parameters
    val map = HashMap<String, Any>()
    map["ft_key_will_change"] = "ft_value_change" // The value of ft_key_will_change will be changed to ft_value_change when stopView is called.
    FTRUMGlobalManager.get().stopView(map)
}

/**
 * Add error information
 *
 * @param log       Log
 * @param message   Message
 * @param errorType Error type, ErrorType
 * @param state     App running state
 * @param dateline  Occurrence time in nanoseconds (optional)
 * @param property  Additional attributes (optional)
 */
public void addError(String log, String message, long dateline, ErrorType errorType,
                     AppState state, HashMap<String, Object> property)

/**
 * Add error information
 *
 * @param log       Log
 * @param message   Message
 * @param errorType Error type, String
 * @param state     App running state
 * @param dateline  Occurrence time in nanoseconds (optional)
 * @param property  Additional attributes (optional)
 */
public void addError(String log, String message, long dateline, String errorType,
                     AppState state, HashMap<String, Object> property)

/**
 * Add error information
 *
 * @param log       Log
 * @param message   Message
 * @param errorType Error type, ErrorType
 * @param state     App running state
 * @param dateline  Occurrence time in nanoseconds (optional)
 * @param property  Additional attributes (optional)
 */
fun addError(log: String, message: String, dateline: Long, errorType: ErrorType, state: AppState, property: HashMap<String, Any>)

/**
 * Add error information
 *
 * @param log       Log
 * @param message   Message
 * @param errorType Error type, String
 * @param state     App running state
 * @param dateline  Occurrence time in nanoseconds (optional)
 * @param property  Additional attributes (optional)
 */
fun addError(log: String, message: String, dateline: Long, errorType: String, state: AppState, property: HashMap<String, Any>)

// Scenario 1:
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN);

// Scenario 2: Record an error that occurred in the past; the time is usually the actual error occurrence time.
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000L, ErrorType.JAVA, AppState.RUN);

// Scenario 3: Dynamic parameters
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN, map);

// Scenario 1:
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN)

// Scenario 2: Record an error that occurred in the past; the time is usually the actual error occurrence time.
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000, ErrorType.JAVA, AppState.RUN)

// Scenario 3: Dynamic parameters
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN, map)

/**
 * Add a long task
 *
 * @param log      Log content
 * @param duration Duration in nanoseconds
 * @param property Additional attributes (optional)
 */
public void addLongTask(String log, long duration, HashMap<String, Object> property)

/**
 * Add a long task
 *
 * @param log      Log content
 * @param duration Duration in nanoseconds
 * @param property Additional attributes (optional)
 */
fun addLongTask(log: String, duration: Long, property: HashMap<String, Any>)

// Scenario 1
FTRUMGlobalManager.get().addLongTask("error log", 1000000L);

// Scenario 2: Dynamic parameters
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addLongTask("", 1000000L, map);

// Scenario 1
FTRUMGlobalManager.get().addLongTask("error log", 1000000L)

// Scenario 2: Dynamic parameters
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addLongTask("", 1000000L, map)

/**
 * Resource start
 *
 * @param resourceId Resource ID
 * @param property   Additional attributes (optional)
 */
public void startResource(String resourceId, HashMap<String, Object> property)

/**
 * Resource stop
 *
 * @param resourceId Resource ID
 * @param property   Additional attributes (optional)
 */
public void stopResource(final String resourceId, HashMap<String, Object> property)

/**
 * Set network transfer content
 *
 * @param resourceId   resourceId
 * @param params       params
 * @param netStatusBean netStatusBean
 */
public void addResource(String resourceId, ResourceParams params, NetStatusBean netStatusBean)

/**
 * Resource start
 *
 * @param resourceId Resource ID (optional)
 */
fun startResource(resourceId: String, property: HashMap<String, Any>)

/**
 * Resource stop
 *
 * @param resourceId Resource ID
 * @param property   Additional attributes (optional)
 */
fun stopResource(resourceId: String, property: HashMap<String, Any>)

/**
 * Set network transfer content
 *
 * @param resourceId   resourceId
 * @param params       params
 * @param netStatusBean netStatusBean
 */
fun addResource(resourceId: String, params: ResourceParams, netStatusBean: NetStatusBean)

// Scenario 1
// Request start
FTRUMGlobalManager.get().startResource("resourceId");

// ...

// Request end
FTRUMGlobalManager.get().stopResource("resourceId");

// Finally, after the request ends, send the request-related data metrics
ResourceParams params = new ResourceParams();
params.setUrl("https://guance.com");
params.setResponseContentType(response.header("Content-Type"));
params.setResponseConnection(response.header("Connection"));
params.setResponseContentEncoding(response.header("Content-Encoding"));
params.setResponseHeader(response.headers().toString());
params.setRequestHeader(request.headers().toString());
params.setResourceStatus(response.code());
params.setResourceMethod(request.method());

NetStatusBean bean = new NetStatusBean();
bean.setTcpStartTime(60000000);
// ...

FTRUMGlobalManager.get().addResource("resourceId", params, bean);

// Scenario 2: Dynamic parameters
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
map.put("ft_key_will_change", "ft_value");

FTRUMGlobalManager.get().startResource("resourceId", map);

// ...
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key_will_change", "ft_value_change"); // The value of ft_key_will_change will be changed to ft_value_change when stopResource is called.
FTRUMGlobalManager.get().stopResource(uuid, map);

// Scenario 1
// Request start
FTRUMGlobalManager.get().startResource("resourceId")

// Request end
FTRUMGlobalManager.get().stopResource("resourceId")

// Finally, after the request ends, send the request-related data metrics
val params = ResourceParams()
params.url = "https://guance.com"
params.responseContentType = response.header("Content-Type")
params.responseConnection = response.header("Connection")
params.responseContentEncoding = response.header("Content-Encoding")
params.responseHeader = response.headers.toString()
params.requestHeader = request.headers.toString()
params.resourceStatus = response.code
params.resourceMethod = request.method

val bean = NetStatusBean()
bean.tcpStartTime = 60000000
// ...
FTRUMGlobalManager.get().addResource("resourceId", params, bean)

// Scenario 2: Dynamic parameters
val map = hashMapOf<String, Any>(
    "ft_key" to "ft_value",
    "ft_key_will_change" to "ft_value"
)
FTRUMGlobalManager.get().startResource("resourceId", map)

// ...
val map = hashMapOf<String, Any>(
    "ft_key_will_change" to "ft_value_change"
)
// The value of ft_key_will_change will be changed to ft_value_change when stopResource is called.

FTRUMGlobalManager.get().stopResource(uuid, map)

/**
 * Bind user information
 *
 * @param id User ID
 */
public static void bindRumUserData(@NonNull String id)

/**
 * Bind user information
 */
public static void bindRumUserData(@NonNull UserData data)

/**
 * Unbind user information
 */
public static void unbindRumUserData()

/**
 * Bind user information
 *
 * @param id User ID
 */
fun bindRumUserData(id: String)

/**
 * Bind user information
 *
 * @param data User data
 */
fun bindRumUserData(data: UserData)

/**
 * Unbind user information
 */
fun unbindRumUserData()

// Call this method after the user logs in to bind user information
FTSdk.bindRumUserData("001");

UserData userData = new UserData();
userData.setName("test.user");
userData.setId("test.id");
userData.setEmail("test@mail.com");
Map<String, String> extMap = new HashMap<>();
extMap.put("ft_key", "ft_value");
userData.setExts(extMap);
FTSdk.bindRumUserData(userData);

// Call this method after the user logs out to unbind user information
FTSdk.unbindRumUserData();

// Call this method after the user logs in to bind user information
FTSdk.bindRumUserData("001")

// Bind more user data
val userData = UserData()
userData.name = "test.user"
userData.id = "test.id"
userData.email = "test@mail.com"
val extMap = HashMap<String, String>()
extMap["ft_key"] = "ft_value"
userData.setExts(extMap)
FTSdk.bindRumUserData(userData)

// Call this method after the user logs out to unbind user information
FTSdk.unbindRumUserData()