RUM 配置¶

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
        )
    }

/**
 * 添加 Action
 *
 * @param actionName action 名称
 * @param actionType action 类型
 * @param property   附加属性参数(可选)
 */
public void startAction(String actionName, String actionType, HashMap<String, Object> property)

/**
 * 添加 Action， 此类数据无法关联 Error，Resource，LongTask 数据
 *
 * @param actionName action 名称
 * @param actionType action 类型
 * @param duration   纳秒，持续时间(可选)
 * @param property   扩展属性(可选)
 */
public void addAction(String actionName, String actionType, long duration, HashMap<String, Object> property)

/**
 * 添加 action
 *
 * @param actionName action 名称
 * @param actionType action 类型
 * @param property   附加属性参数(可选)
 */
fun startAction(actionName: String, actionType: String, property: HashMap<String, Any>)

/**
 * 添加 Action
 *
 * @param actionName action 名称
 * @param actionType action 类型
 * @param duration   纳秒，持续时间(可选)
 * @param property   扩展属性(可选)
 */
fun addAction(actionName: String, actionType: String, duration: Long, property: HashMap<String, Any>)

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

// 场景2: 动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().startAction("login", "action_type", map);

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

// 场景2: 动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addAction("login", "action_type", map);

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

// 场景2: 动态参数
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().startAction("login", "action_type", map)

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

// 场景2: 动态参数
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addAction("login", "action_type", map)

/**
 * view 起始
 *
 * @param viewName 当前页面名称
 * @param property 附加属性参数(可选)
 */
public void startView(String viewName, HashMap<String, Object> property)

/**
 * view 结束
 *
 * @param property 附加属性参数(可选)
 */
public void stopView(HashMap<String, Object> property)

/**
 * 更新当前 view loading_time 指标，单位纳秒
 *
 * @param duration duration
 */
public void updateLoadTime(long duration)

/**
 * view 起始
 *
 * @param viewName 当前页面名称
 * @param property 附加属性参数(可选)
 */
fun startView(viewName: String, property: HashMap<String, Any>)

/**
 * view 结束
 *
 * @param property 附加属性参数(可选)
 */
fun stopView(property: HashMap<String, Any>)

/**
 * 更新当前 view loading_time 指标，单位纳秒
 *
 * @param duration duration
 */
fun updateLoadTime(duration: Long)

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

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

    // 场景 2: 动态参数
    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();

    // 场景 1
    FTRUMGlobalManager.get().stopView();

    // 场景 2 : 动态参数
    HashMap<String, Object> map = new HashMap<>();
    map.put("ft_key_will_change", "ft_value_change"); //ft_key_will_change 的值会在 stopView 时被更新为 ft_value_change
    FTRUMGlobalManager.get().stopView(map);

}

override fun onResume() {
    super.onResume()

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

    // 场景 2: 动态参数
    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()

    // 场景 1
    FTRUMGlobalManager.get().stopView()

    // 场景 2 : 动态参数
    val map = HashMap<String, Any>()
    map["ft_key_will_change"] = "ft_value_change" // ft_key_will_change 这个数值，会在 stopView 时候被修改为 ft_value_change
    FTRUMGlobalManager.get().stopView(map)
}

/**
 * 添加错误信息
 *
 * @param log       日志
 * @param message   消息
 * @param errorType 错误类型, ErrorType
 * @param state     程序运行状态
 * @param dateline  发生时间，纳秒(可选)
 * @param property  附加属性(可选)
 */
public void addError(String log, String message, long dateline, ErrorType errorType,
                     AppState state, HashMap<String, Object> property)

/**
 * 添加错误信息
 *
 * @param log       日志
 * @param message   消息
 * @param errorType 错误类型, String
 * @param state     程序运行状态
 * @param dateline  发生时间，纳秒(可选)
 * @param property  附加属性(可选)
 */
public void addError(String log, String message, long dateline, String errorType,
                     AppState state, HashMap<String, Object> property)

/**
 * 添加错误信息
 *
 * @param log       日志
 * @param message   消息
 * @param errorType 错误类型, ErrorType
 * @param state     程序运行状态
 * @param dateline  发生时间，纳秒(可选)
 * @param property  附加属性(可选)
 */
fun addError(log: String, message: String, dateline: Long, errorType: ErrorType, state: AppState, property: HashMap<String, Any>)

/**
 * 添加错误信息
 *
 * @param log       日志
 * @param message   消息
 * @param errorType 错误类型, String
 * @param state     程序运行状态
 * @param dateline  发生时间，纳秒(可选)
 * @param property  附加属性(可选)
 */
fun addError(log: String, message: String, dateline: Long, errorType: String, state: AppState, property: HashMap<String, Any>)

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

// 场景 2: 延迟记录发生的错误，这里的时间一般为错误发生的时间
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000L, ErrorType.JAVA, AppState.RUN);

// 场景 3：动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN, map);

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

// 场景 2: 延迟记录发生的错误，这里的时间一般为错误发生的时间
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000, ErrorType.JAVA, AppState.RUN)

// 场景 3：动态参数
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN, map)

/**
 * 添加长任务
 *
 * @param log      日志内容
 * @param duration 持续时间，纳秒
 * @param property 附加属性参数(可选)
 */
public void addLongTask(String log, long duration, HashMap<String, Object> property)

/**
 * 添加长任务
 *
 * @param log      日志内容
 * @param duration 持续时间，纳秒
 * @param property 附加属性参数(可选)
 */
fun addLongTask(log: String, duration: Long, property: HashMap<String, Any>)

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

// 场景 2: 动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addLongTask("", 1000000L, map);

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

// 场景 2: 动态参数
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addLongTask("", 1000000L, map)

/**
 * resource 起始
 *
 * @param resourceId 资源 Id
 * @param property   附加属性参数(可选)
 */
public void startResource(String resourceId, HashMap<String, Object> property)

/**
 * resource 终止
 *
 * @param resourceId 资源 Id
 * @param property   附加属性参数(可选)
 */
public void stopResource(final String resourceId, HashMap<String, Object> property)

/**
 * 设置网络传输内容
 *
 * @param resourceId resourceId
 * @param params params
 * @param netStatusBean netStatusBean
 */
public void addResource(String resourceId, ResourceParams params, NetStatusBean netStatusBean)

/**
 * resource 起始
 *
 * @param resourceId 资源 Id(可选)
 */
fun startResource(resourceId: String, property: HashMap<String, Any>)

/**
 * resource 终止
 *
 * @param resourceId 资源 Id
 * @param property   附加属性参数(可选)
 */
fun stopResource(resourceId: String, property: HashMap<String, Any>)

/**
 * 设置网络传输内容
 *
 * @param resourceId resourceId
 * @param params params
 * @param netStatusBean netStatusBean
 */
fun addResource(resourceId: String, params: ResourceParams, netStatusBean: NetStatusBean)

// 场景 1
// 请求开始
FTRUMGlobalManager.get().startResource("resourceId");

// ...

// 请求结束
FTRUMGlobalManager.get().stopResource("resourceId");

// 最后，在请求结束之后，发送请求相关的数据指标
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);

// 场景 2 ：动态参数使用
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"); // ft_key_will_change 这个数值，会在 stopResource 时候被修改为 ft_value_change
FTRUMGlobalManager.get().stopResource(uuid, map);

// 场景 1
// 请求开始
FTRUMGlobalManager.get().startResource("resourceId")

// 请求结束
FTRUMGlobalManager.get().stopResource("resourceId")

// 最后，在请求结束之后，发送请求相关的数据指标
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)

// 场景 2 ：动态参数使用
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"
)
// ft_key_will_change 这个数值，会在 stopResource 时候被修改为 ft_value_change

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

/**
 * 绑定用户信息
 *
 * @param id 用户 ID
 */
public static void bindRumUserData(@NonNull String id)

/**
 * 绑定用户信息
 */
public static void bindRumUserData(@NonNull UserData data)

/**
 * 解绑用户信息
 */
public static void unbindRumUserData()

/**
 * 绑定用户信息
 *
 * @param id 用户 ID
 */
fun bindRumUserData(id: String)

/**
 * 绑定用户信息
 *
 * @param data 用户信息
 */
fun bindRumUserData(data: UserData)

/**
 * 解绑用户信息
 */
fun unbindRumUserData()

// 可以在用户登录成功后调用此方法用来绑定用户信息
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);

// 可以在用户退出登录后调用此方法来解绑用户信息
FTSdk.unbindRumUserData();

// 可以在用户登录成功后调用此方法用来绑定用户信息
FTSdk.bindRumUserData("001")

// 绑定用户更多数据
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)

// 可以在用户退出登录后调用此方法来解绑用户信息
FTSdk.unbindRumUserData()