RUM Configuration¶

    // Enable RUM
    FTRumConfig *rumConfig = [[FTRumConfig alloc]initWithAppid:appid];
    rumConfig.enableTraceUserView = YES;
    rumConfig.deviceMetricsMonitorType = FTDeviceMetricsMonitorAll;
    rumConfig.monitorFrequency = FTMonitorFrequencyRare;
    rumConfig.enableTraceUserAction = YES;
    rumConfig.enableTraceUserResource = YES;
    rumConfig.enableTrackAppFreeze = YES;
    rumConfig.enableTrackAppCrash = YES;
    rumConfig.enableTrackAppANR = YES;
    rumConfig.errorMonitorType = FTErrorMonitorAll;
    [[FTMobileAgent sharedInstance] startRumWithConfigOptions:rumConfig];

    let rumConfig = FTRumConfig(appid: appid)
    rumConfig.enableTraceUserView = true
    rumConfig.deviceMetricsMonitorType = .all
    rumConfig.monitorFrequency = .rare
    rumConfig.enableTraceUserAction = true
    rumConfig.enableTraceUserResource = true
    rumConfig.enableTrackAppFreeze = true
    rumConfig.enableTrackAppCrash = true
    rumConfig.enableTrackAppANR = true
    rumConfig.errorMonitorType = .all
    FTMobileAgent.sharedInstance().startRum(withConfigOptions: rumConfig)

/// Create a page
///
/// Call this method before `-startViewWithName`. It is used to record the page load time. If load time is not available, this method can be omitted.
/// - Parameters:
///  - viewName: The page name
///  - loadTime: The page load time (nanoseconds)
-(void)onCreateView:(NSString *)viewName loadTime:(NSNumber *)loadTime;

/// Enter a page
/// - Parameters:
///  - viewName: The page name
///  - property: Custom attributes for the event (optional)
-(void)startViewWithName:(NSString *)viewName property:(nullable NSDictionary *)property;

/// Update the load time of the current RUM View.
/// Must be called between `-startView` and `-stopView` methods to take effect.
/// - Parameter duration: The load duration (nanoseconds).
-(void)updateViewLoadingTime:(NSNumber *)duration;

/// Leave a page
/// - Parameter property: Custom attributes for the event (optional)
-(void)stopViewWithProperty:(nullable NSDictionary *)property;

/// Create a page
///
/// Call this method before `-startViewWithName`. It is used to record the page load time. If load time is not available, this method can be omitted.
/// - Parameters:
///  - viewName: The page name
///  - loadTime: The page load time (ns)
open func onCreateView(_ viewName: String, loadTime: NSNumber)

/// Enter a page
/// - Parameters:
///  - viewName: The page name
///  - property: Custom attributes for the event (optional)
open func startView(withName viewName: String, property: [AnyHashable : Any]?)

/// Update the load time of the current RUM View.
/// Must be called between `-startView` and `-stopView` methods to take effect.
/// - Parameter duration: The load duration (nanoseconds).
open func updateViewLoadingTime(_ duration: NSNumber)

/// Leave a page
/// - Parameter property: Custom attributes for the event (optional)
open func stopView(withProperty property: [AnyHashable : Any]?)

- (void)viewDidAppear:(BOOL)animated{
  [super viewDidAppear:animated];
  // Scenario 1:
  [[FTExternalDataManager sharedManager] startViewWithName:@"TestVC"];

  // Scenario 2: Dynamic parameters
  [[FTExternalDataManager sharedManager] startViewWithName:@"TestVC" property:@{@"custom_key":@"custom_value"}];
}
-(void)viewDidDisappear:(BOOL)animated{
  [super viewDidDisappear:animated];
  // Scenario 1:
  [[FTExternalDataManager sharedManager] stopView];

  // Scenario 2: Dynamic parameters
  [[FTExternalDataManager sharedManager] stopViewWithProperty:@{@"custom_key":@"custom_value"}];
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    // Scenario 1:
    FTExternalDataManager.shared().startView(withName: "TestVC")
    // Scenario 2: Dynamic parameters
    FTExternalDataManager.shared().startView(withName: "TestVC",property: ["custom_key":"custom_value"])
}
override func viewDidDisappear(_ animated: Bool) {
    super.viewDidDisappear(animated)
    // Scenario 1:
    FTExternalDataManager.shared().stopView()
    // Scenario 2: Dynamic parameters
    FTExternalDataManager.shared().stopView(withProperty: ["custom_key":"custom_value"])
}

import SwiftUI
import GuanceSDK
struct HomeView: View {
    var body: some View {
        VStack {
            Text("Home")
        }
        .ftTrackRUMView(
            name: "Home",
            property: ["page_type": "home"]
        )
    }
}

/// Start a RUM Action.
///
/// RUM will bind any Resource, Error, or LongTask events that may be triggered by this Action. Avoid adding multiple actions within 0.1 seconds. At any given time, a View is associated with only one Action. If the previous Action is not finished, a new Action will be discarded.
/// This method does not interfere with the `addAction:actionType:property` method.
///
/// - Parameters:
///   - actionName: The event name
///   - actionType: The event type
///   - property: Custom attributes for the event (optional)
- (void)startAction:(NSString *)actionName actionType:(NSString *)actionType property:(nullable NSDictionary *)property;

/// Add an Action event. No discard logic. Does not bind Resource, Error, or LongTask events.
///
/// This method does not interfere with the RUM Action started by `startAction:actionType:property:`.
/// - Parameters:
///   - actionName: The event name
///   - actionType: The event type
///   - property: Custom attributes for the event (optional)
- (void)addAction:(NSString *)actionName actionType:(NSString *)actionType property:(nullable NSDictionary *)property;

/// Start a RUM Action.
///
/// RUM will bind any Resource, Error, or LongTask events that may be triggered by this Action. Avoid adding multiple actions within 0.1 seconds. At any given time, a View is associated with only one Action. If the previous Action is not finished, a new Action will be discarded.
/// This method does not interfere with the `addAction:actionType:property` method.
///
/// - Parameters:
///   - actionName: The event name
///   - actionType: The event type
///   - property: Custom attributes for the event (optional)
open func startAction(_ actionName: String, actionType: String, property: [AnyHashable : Any]?)

/// Add an Action event. No discard logic. Does not bind Resource, Error, or LongTask events.
///
/// This method does not interfere with the RUM Action started by `startAction:actionType:property:`.
/// - Parameters:
///   - actionName: The event name
///   - actionType: The event type
///   - property: Custom attributes for the event (optional)
open func addAction(_ actionName: String, actionType: String, property: [AnyHashable : Any]?)

// startAction
[[FTExternalDataManager sharedManager] startAction:@"action" actionType:@"click" property:@{@"action_property":@"testActionProperty1"}];
// addAction
[[FTExternalDataManager sharedManager] addAction:@"action" actionType:@"click" property:@{@"action_property":@"testActionProperty1"}];

// startAction
FTExternalDataManager.shared().startAction("custom_action", actionType: "click",property: nil)
// addAction
FTExternalDataManager.shared().addAction("custom_action", actionType: "click",property: nil)

import SwiftUI
import GuanceSDK
struct ProductView: View {
    var body: some View {
        Button("Buy") {
            FTRUMSwiftUI.trackTapAction(
                name: "buy_click",
                property: ["source": "product_detail"]
            )

            // Execute the business tap logic
            buy()
        }
    }

    private func buy() {
        // ...
    }
}

import SwiftUI
import GuanceSDK
struct ProductCard: View {
    var body: some View {
        Text("Buy")
            .ftTrackRUMTapAction(
                name: "buy_click",
                property: ["source": "product_card"]
            )
    }
}

/// Add an Error event
/// - Parameters:
///   - type: The error type
///   - message: The error message
///   - stack: The stack trace
///   - property: Custom attributes for the event (optional)
- (void)addErrorWithType:(NSString *)type message:(NSString *)message stack:(NSString *)stack property:(nullable NSDictionary *)property;

/// Add an Error event
/// - Parameters:
///   - type: The error type
///   - state: The application state
///   - message: The error message
///   - stack: The stack trace
///   - property: Custom attributes for the event (optional)
- (void)addErrorWithType:(NSString *)type state:(FTAppState)state  message:(NSString *)message stack:(NSString *)stack property:(nullable NSDictionary *)property;

/// Add an Error event
/// - Parameters:
///   - type: The error type
///   - message: The error message
///   - stack: The stack trace
///   - property: Custom attributes for the event (optional)
open func addError(withType: String, message: String, stack: String, property: [AnyHashable : Any]?)

/// Add an Error event
/// - Parameters:
///   - type: The error type
///   - state: The application state
///   - message: The error message
///   - stack: The stack trace
///   - property: Custom attributes for the event (optional)
open func addError(withType type: String, state: FTAppState, message: String, stack: String, property: [AnyHashable : Any]?)

// Scenario 1
[[FTExternalDataManager sharedManager] addErrorWithType:@"type" message:@"message" stack:@"stack"];
// Scenario 2: Dynamic parameters
[[FTExternalDataManager sharedManager] addErrorWithType:@"ios_crash" message:@"crash_message" stack:@"crash_stack" property:@{@"custom_key":@"custom_value"}];
// Scenario 3: Dynamic parameters
[[FTExternalDataManager sharedManager] addErrorWithType:@"ios_crash" state:FTAppStateUnknown message:@"crash_message" stack:@"crash_stack" property:@{@"custom_key":@"custom_value"}];

// Scenario 1
FTExternalDataManager.shared().addError(withType: "custom_type", message: "custom_message", stack: "custom_stack")
// Scenario 2: Dynamic parameters
FTExternalDataManager.shared().addError(withType: "custom_type", message: "custom_message", stack: "custom_stack",property: ["custom_key":"custom_value"])
// Scenario 3: Dynamic parameters
FTExternalDataManager.shared().addError(withType: "custom_type", state: .unknown, message: "custom_message", stack: "custom_stack", property: ["custom_key":"custom_value"])

/// Add a freeze event
/// - Parameters:
///   - stack: The freeze stack trace
///   - duration: The freeze duration (nanoseconds)
///   - property: Custom attributes for the event (optional)
- (void)addLongTaskWithStack:(NSString *)stack duration:(NSNumber *)duration property:(nullable NSDictionary *)property;

/// Add a freeze event
/// - Parameters:
///   - stack: The freeze stack trace
///   - duration: The freeze duration (nanoseconds)
///   - property: Custom attributes for the event (optional)
func addLongTask(withStack: String, duration: NSNumber, property: [AnyHashable : Any]?)

// Scenario 1
[[FTExternalDataManager sharedManager] addLongTaskWithStack:@"stack string" duration:@1000000000];
// Scenario 2: Dynamic parameters
[[FTExternalDataManager sharedManager] addLongTaskWithStack:@"stack string" duration:@1000000000 property:@{@"custom_key":@"custom_value"}];

// Scenario 1
FTExternalDataManager.shared().addLongTask(withStack: "stack string", duration: 1000000000)
// Scenario 2: Dynamic parameters
FTExternalDataManager.shared().addLongTask(withStack: "stack string", duration: 1000000000 ,property: [["custom_key":"custom_value"]])

/// Start an HTTP request
/// - Parameters:
///   - key: The request identifier
///   - property: Custom attributes for the event (optional)
- (void)startResourceWithKey:(NSString *)key property:(nullable NSDictionary *)property;

/// Add request data for HTTP
///
/// - Parameters:
///   - key: The request identifier
///   - metrics: Request-related performance metrics
///   - content: Request-related data
- (void)addResourceWithKey:(NSString *)key metrics:(nullable FTResourceMetricsModel *)metrics content:(FTResourceContentModel *)content;

/// End an HTTP request
/// - Parameters:
///   - key: The request identifier
///   - property: Custom attributes for the event (optional)
- (void)stopResourceWithKey:(NSString *)key property:(nullable NSDictionary *)property;

/// Start an HTTP request
/// - Parameters:
///   - key: The request identifier
///   - property: Custom attributes for the event (optional)
open func startResource(withKey key: String, property: [AnyHashable : Any]?)

/// End an HTTP request
/// - Parameters:
///   - key: The request identifier
///   - property: Custom attributes for the event (optional)
open func stopResource(withKey key: String, property: [AnyHashable : Any]?)

/// Add request data for HTTP
///
/// - Parameters:
///   - key: The request identifier
///   - metrics: Request-related performance metrics
///   - content: Request-related data
open func addResource(withKey key: String, metrics: FTResourceMetricsModel?, content: FTResourceContentModel)

// Step 1: Before the request starts
[[FTExternalDataManager sharedManager] startResourceWithKey:key];

// Step 2: After the request completes
[[FTExternalDataManager sharedManager] stopResourceWithKey:key];

// Step 3: Assemble Resource data
// FTResourceContentModel data
FTResourceContentModel *content = [[FTResourceContentModel alloc]init];
content.httpMethod = request.HTTPMethod;
content.requestHeader = request.allHTTPHeaderFields;
content.responseHeader = httpResponse.allHeaderFields;
content.httpStatusCode = httpResponse.statusCode;
content.responseBody = responseBody;
// iOS native
content.error = error;

// If timing data for each phase is available
// FTResourceMetricsModel
// For iOS native, use the NSURLSessionTaskMetrics data to initialize FTResourceMetricsModel
FTResourceMetricsModel *metricsModel = [[FTResourceMetricsModel alloc]initWithTaskMetrics:metrics];

// For other platforms, all time data is in nanoseconds
FTResourceMetricsModel *metricsModel = [[FTResourceMetricsModel alloc]init];

// Step 4: add resource. If there is no timing data, pass nil for metrics.
[[FTExternalDataManager sharedManager] addResourceWithKey:key metrics:metricsModel content:content];

// Step 1: Before the request starts
FTExternalDataManager.shared().startResource(withKey: key)

// Step 2: After the request completes
FTExternalDataManager.shared().stopResource(withKey: resource.key)

// Step 3: ① Assemble Resource data
let contentModel = FTResourceContentModel(request: task.currentRequest!, response: task.response as? HTTPURLResponse, data: resource.data, error: error)

// ② If timing data for each phase is available
// FTResourceMetricsModel
// For iOS native, use the NSURLSessionTaskMetrics data to initialize FTResourceMetricsModel
var metricsModel:FTResourceMetricsModel?
if let metrics = resource.metrics {
   metricsModel = FTResourceMetricsModel(taskMetrics:metrics)
}
// For other platforms, all time data is in nanoseconds
metricsModel = FTResourceMetricsModel()
...

// Step 4: add resource. If there is no timing data, pass nil for metrics.
FTExternalDataManager.shared().addResource(withKey: resource.key, metrics: metricsModel, content: contentModel)