iOS Application Access¶

platform :ios, '10.0' 
use_frameworks!
def shared_pods
pod 'FTMobileSDK', '[latest_version]'
# If you need to collect widget Extension data
pod 'FTMobileSDK/Extension', '[latest_version]'
end
//Main Project Target
target 'yourProjectName' do
shared_pods
end

//Widget Extension
target 'yourWidgetExtensionName' do
# If you need to collect widget Extension data
shared_pods
end

use_modular_headers!
//Main Project Target
target 'yourProjectName' do
pod 'FTMobileSDK', '[latest_version]'
end
//Widget Extension
target 'yourWidgetExtensionName' do
pod 'FTMobileSDK/Extension', '[latest_version]'
end

Pod::Spec.new do |s|
s.name         = "FTMobileSDK"
s.version      = "[latest_version]"  
s.source       = { :git => "https://github.com/GuanceCloud/datakit-ios.git", :tag => s.version }

github "GuanceCloud/datakit-ios" == [latest_version]

carthage update --platform iOS

carthage update --platform iOS --use-xcframeworks

//  main project
dependencies: [
.package(name: "FTMobileSDK", url: "https://github.com/GuanceCloud/datakit-ios.git",.upToNextMajor(from: "[latest_version]"))
]

//CocoaPods、SPM 
#import "FTMobileSDK.h"
//Carthage 
#import <FTMobileSDK/FTMobileSDK.h>

import FTMobileSDK

-(BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{
     // Use Datakit Address
     //FTMobileConfig *config = [[FTMobileConfig alloc]initWithDatakitUrl:datakitUrl];
     // Use DataWay Address
    FTMobileConfig *config = [[FTMobileConfig alloc]initWithDatawayUrl:datawayUrl clientToken:clientToken];
    config.enableSDKDebugLog = YES;
    //Start SDK
    [FTMobileAgent startWithConfigOptions:config];

   //...
    return YES;
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
       // Use Datakit Address
       //let config = FTMobileConfig(datakitUrl: url)
       // Use DataWay Address
     let config = FTMobileConfig(datawayUrl: datawayUrl, clientToken: clientToken)
     config.enableSDKDebugLog = true
     FTMobileAgent.start(withConfigOptions: config)
     //...
     return true
}

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

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

    FTLoggerConfig *loggerConfig = [[FTLoggerConfig alloc]init];
    loggerConfig.enableCustomLog = YES;
    loggerConfig.enableLinkRumData = YES;
    loggerConfig.logLevelFilter = @[@(FTStatusError),@(FTStatusCritical)];
    loggerConfig.discardType = FTDiscardOldest;
    [[FTMobileAgent sharedInstance] startLoggerWithConfigOptions:loggerConfig];

    let loggerConfig = FTLoggerConfig()
    loggerConfig.enableCustomLog = true
    loggerConfig.enableLinkRumData = true
    loggerConfig.logLevelFilter = [NSNumber(value: FTLogStatus.statusError.rawValue),NSNumber(value: FTLogStatus.statusCritical.rawValue)] // loggerConfig.logLevelFilter = [2,3]
    loggerConfig.discardType = .discardOldest
    FTMobileAgent.sharedInstance().startLogger(withConfigOptions: loggerConfig)

   //开启 trace
   FTTraceConfig *traceConfig = [[FTTraceConfig alloc]init];
   traceConfig.enableLinkRumData = YES;
     traceConfig.enableAutoTrace = YES;
   traceConfig.networkTraceType = FTNetworkTraceTypeDDtrace;
   [[FTMobileAgent sharedInstance] startTraceWithConfigOptions:traceConfig];

   let traceConfig = FTTraceConfig.init()
   traceConfig.enableLinkRumData = true
   traceConfig.enableAutoTrace = true
   FTMobileAgent.sharedInstance().startTrace(withConfigOptions: traceConfig)

/// Create View
///
/// Called before the '-startViewWithName' method, which is used to record the loading time of the page. If the loading time cannot be obtained, this method may not be called.
/// - Parameters:
///  - viewName: Current View Name
///  - loadTime: The loading time of this view（ns）
-(void)onCreateView:(NSString *)viewName loadTime:(NSNumber *)loadTime;

/// view start
///
/// - Parameters:
///  - viewName: Current View Name
-(void)startViewWithName:(NSString *)viewName;

/// view start
/// - Parameters:
///  - viewName: Current View Name
///  - property: Extra Property (optional)
-(void)startViewWithName:(NSString *)viewName property:(nullable NSDictionary *)property;

/// view stop
-(void)stopView;

/// view stop
/// - Parameter property: Extra Property (optional)
-(void)stopViewWithProperty:(nullable NSDictionary *)property;

/// Create View
///
/// Called before the '-startViewWithName' method, which is used to record the loading time of the page. If the loading time cannot be obtained, this method may not be called.
/// - Parameters:
///  - viewName: Current View Name
///  - loadTime: The loading time of this view （ns）
open func onCreateView(_ viewName: String, loadTime: NSNumber)

/// view start
///
/// - Parameters:
///  - viewName: Current View Name
open func startView(withName viewName: String)

/// view start
/// - Parameters:
///  - viewName: Current View Name
///  - property: Extra Property (optional)
open func startView(withName viewName: String, property: [AnyHashable : Any]?)

/// view stop
open func stopView() 

/// view stop
/// - Parameter property: Extra Property (optional)
open func stopView(withProperty property: [AnyHashable : Any]?)

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

  // Secne 2：  extra property
  [[FTExternalDataManager sharedManager] startViewWithName:@"TestVC" property:@{@"custom_key":@"custom_value"}];  
}
-(void)viewDidDisappear:(BOOL)animated{
  [super viewDidDisappear:animated];
  // Scene 1：
  [[FTExternalDataManager sharedManager] stopView];  

  // Secne 2：  extra property
  [[FTExternalDataManager sharedManager] stopViewWithProperty:@{@"custom_key":@"custom_value"}];
}

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

/// Start RUM Action.
///
/// RUM will bind the Resource, Error, and LongTask events that may be triggered by the Action. Avoid adding multiple times within 0.1 seconds. The same View will only be associated with one Action at the same time. If the previous Action is not completed, the newly added Action will be discarded.
/// This method has no effect on adding Actions with the `addAction:actionType:property` method.
///
/// - Parameters:
/// - actionName: action name
/// - actionType: action type
/// - property: extra property (optional)
- (void)startAction:(NSString *)actionName actionType:(NSString *)actionType property:(nullable NSDictionary *)property;

/// Add Action event. No duration, no discard logic
///
/// Does not affect the RUM Action started by `startAction:actionType:property:`.
/// - Parameters:
/// - actionName: action name
/// - actionType: action type
/// - property: extra property (optional)
- (void)addAction:(NSString *)actionName actionType:(NSString *)actionType property:(nullable NSDictionary *)property;

/// Start RUM Action.
///
/// RUM will bind the Resource, Error, and LongTask events that may be triggered by the Action. Avoid adding multiple times within 0.1 seconds. The same View will only be associated with one Action at the same time. If the previous Action is not completed, the newly added Action will be discarded.
/// This method has no effect on adding Actions with the `addAction:actionType:property` method.
///
/// - Parameters:
/// - actionName: action name
/// - actionType: action type
/// - property: extra property (optional)
open func startAction(_ actionName: String, actionType: String, property: [AnyHashable : Any]?)

/// Add Action event. No duration, no discard logic
///
/// Does not affect the RUM Action started by `startAction:actionType:property:`.
/// - Parameters:
/// - actionName: action name
/// - actionType: action type
/// - property: extra property (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)

/// add error data
///
/// - Parameters:
///   - type: error type
///   - message: error message detail
///   - stack: error log content
- (void)addErrorWithType:(NSString *)type message:(NSString *)message stack:(NSString *)stack;

/// add error data
/// - Parameters:
///   - type: error type
///   - message: error message detail
///   - stack: error log content
///   - property: extra property (optional)
- (void)addErrorWithType:(NSString *)type message:(NSString *)message stack:(NSString *)stack property:(nullable NSDictionary *)property;

/// add error data
/// - Parameters:
///   - type: error type
///   - state: application running state
///   - message: error message detail
///   - stack: error log content
///   - property: extra property (optional)
- (void)addErrorWithType:(NSString *)type state:(FTAppState)state  message:(NSString *)message stack:(NSString *)stack property:(nullable NSDictionary *)property;

/// add error data
///
/// - Parameters:
///   - type: error type
///   - message: error message detail
///   - stack: error log content
func addError(withType: String, message: String, stack: String)

/// add error data
/// - Parameters:
///   - type: error type
///   - message: error message detail
///   - stack: error log content
///   - property: extra property (optional)
func addError(withType: String, message: String, stack: String, property: [AnyHashable : Any]?)

/// add error data
/// - Parameters:
///   - type: error type
///   - state: application running state
///   - message: error message detail
///   - stack: error log content
///   - property: extra property (optional)
open func addError(withType type: String, state: FTAppState, message: String, stack: String, property: [AnyHashable : Any]?)

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

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

/// add long task data
///
/// - Parameters:
///   - stack: stack or log content
///   - duration: Duration, in nanoseconds.
- (void)addLongTaskWithStack:(NSString *)stack duration:(NSNumber *)duration;

/// add long task data
/// - Parameters:
///   - stack: stack or log content
///   - duration: Duration, in nanoseconds.
///   - property: extra property (optional)
- (void)addLongTaskWithStack:(NSString *)stack duration:(NSNumber *)duration property:(nullable NSDictionary *)property;

/// add long task data
///
/// - Parameters:
///   - stack: stack or log content
///   - duration: Duration, in nanoseconds.
func addLongTask(withStack: String, duration: NSNumber)

/// add long task data
/// - Parameters:
///   - stack: stack or log content
///   - duration: Duration, in nanoseconds.
///   - property: extra property (optional)
func addLongTask(withStack: String, duration: NSNumber, property: [AnyHashable : Any]?)

// Secne 1： 
[[FTExternalDataManager sharedManager] addLongTaskWithStack:@"stack string" duration:@1000000000];
// Secne 2：  extra property
[[FTExternalDataManager sharedManager] addLongTaskWithStack:@"stack string" duration:@1000000000 property:@{@"custom_key":@"custom_value"}];

// Secne 1： 
FTExternalDataManager.shared().addLongTask(withStack: "stack string", duration: 1000000000)
// Secne 2：  extra property
FTExternalDataManager.shared().addLongTask(withStack: "stack string", duration: 1000000000 ,property: [["custom_key":"custom_value"]])

/// resource start
///
/// - Parameters:
///   - key: resource Id ，unique every request
- (void)startResourceWithKey:(NSString *)key;

/// resource start
/// - Parameters:
///   - key: resource Id ，unique every request
///   - property: extra property
- (void)startResourceWithKey:(NSString *)key property:(nullable NSDictionary *)property;

/// resource stop
///
/// - Parameters:
///   - key: resource Id ，unique every request
- (void)stopResourceWithKey:(NSString *)key;

/// resource stop
/// - Parameters:
///   - key: resource Id ，unique every request
///   - property: extra property
- (void)stopResourceWithKey:(NSString *)key property:(nullable NSDictionary *)property;

/// append network metrics and content data
///
/// - Parameters:
///   - key: resource Id ，unique every request
///   - metrics: request performance attributes
///   - content: request data
- (void)addResourceWithKey:(NSString *)key metrics:(nullable FTResourceMetricsModel *)metrics content:(FTResourceContentModel *)content;

/// resource start
///
/// - Parameters:
///   - key: resource Id ，unique every request
open func startResource(withKey key: String)

/// resource start
/// - Parameters:
///   - key: resource Id ，unique every request
///   - property: extra property
open func startResource(withKey key: String, property: [AnyHashable : Any]?)

/// resource stop
///
/// - Parameters:
///   - key: resource Id ，unique every request
open func stopResource(withKey key: String)

/// resource stop
/// - Parameters:
///   - key: resource Id ，unique every request
///   - property: extra property
open func stopResource(withKey key: String, property: [AnyHashable : Any]?)

/// append network metrics and content data
///
/// - Parameters:
///   - key: resource Id ，unique every request
///   - metrics: request performance attributes
///   - content: request data
open func addResource(withKey key: String, metrics: FTResourceMetricsModel?, content: FTResourceContentModel)

//step 1： Before the network request starts
[[FTExternalDataManager sharedManager] startResourceWithKey:key];

//step 2：Request completed
[[FTExternalDataManager sharedManager] stopResourceWithKey:key];

//step 3：① Add resource data
//FTResourceContentModel 
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 the performance data of the network request can be obtained
//FTResourceMetricsModel
//ios native. Get NSURLSessionTaskMetrics data, directly use the initialization method of FTResourceMetricsModel
FTResourceMetricsModel *metricsModel = [[FTResourceMetricsModel alloc]initWithTaskMetrics:metrics];

//other platforms. All time data in nanoseconds
FTResourceMetricsModel *metricsModel = [[FTResourceMetricsModel alloc]init];

// step 4：add resource： If there is no performance data, the metrics parameter is set to nil
[[FTExternalDataManager sharedManager] addResourceWithKey:key metrics:metricsModel content:content];

//step 1： Before the network request starts
FTExternalDataManager.shared().startResource(withKey: key)

//step 2：Request completed
FTExternalDataManager.shared().stopResource(withKey: resource.key)

//step 3：① Add resource data
let contentModel = FTResourceContentModel(request: task.currentRequest!, response: task.response as? HTTPURLResponse, data: resource.data, error: error)

//② If the performance data of the network request can be obtained
//FTResourceMetricsModel
//ios native. Get NSURLSessionTaskMetrics data, directly use the initialization method of FTResourceMetricsModel
var metricsModel:FTResourceMetricsModel?
if let metrics = resource.metrics {
   metricsModel = FTResourceMetricsModel(taskMetrics:metrics)
}
//other platforms. All time data in nanoseconds
metricsModel = FTResourceMetricsModel()
...

// step 4：add resource： If there is no performance data, the metrics parameter is set to nil
FTExternalDataManager.shared().addResource(withKey: resource.key, metrics: metricsModel, content: contentModel)

//  FTMobileAgent.h
//  FTMobileSDK

/// add log
/// @param content Log content, which can be a json string
/// @param status  Log Level (info、warning、error、critical、ok). 
-(void)logging:(NSString *)content status:(FTStatus)status;

/// add log
/// @param content Log content, which can be a json string
/// @param status  Log Level (info、warning、error、critical、ok). 
/// @param property Extra Property (optional)
-(void)logging:(NSString *)content status:(FTLogStatus)status property:(nullable NSDictionary *)property;

//
//  FTLogger.h
//  FTMobileSDK

/// add info type log
/// - Parameters:
///   - content: Log content, which can be a json string
///   - property: Extra Property (optional)
-(void)info:(NSString *)content property:(nullable NSDictionary *)property;

/// add warning type log
/// - Parameters:
///   - content: Log content, which can be a json string
///   - property: Extra Property (optional)
-(void)warning:(NSString *)content property:(nullable NSDictionary *)property;

/// add error type log
/// - Parameters:
///   - content: Log content, which can be a json string
///   - property: Extra Property (optional)
-(void)error:(NSString *)content  property:(nullable NSDictionary *)property;

/// add critical type log
/// - Parameters:
///   - content: Log content, which can be a json string
///   - property: Extra Property (optional)
-(void)critical:(NSString *)content property:(nullable NSDictionary *)property;

/// add ok type log
/// - Parameters:
///   - content: Log content, which can be a json string
///   - property: Extra Property (optional)
-(void)ok:(NSString *)content property:(nullable NSDictionary *)property;

open class FTMobileAgent : NSObject {
/// add log
///
/// - Parameters:
///   - content: Log content, can be a json string
///   - status: Log Level (info、warning、error、critical、ok). 
open func logging(_ content: String, status: FTLogStatus)

/// add log
/// - Parameters:
///   - content: Log content, can be a json string
///   - status: Log Level (info、warning、error、critical、ok). 
///   - property: Extra Property (optional)
open func logging(_ content: String, status: FTLogStatus, property: [AnyHashable : Any]?)
}

open class FTLogger : NSObject, FTLoggerProtocol {}
public protocol FTLoggerProtocol : NSObjectProtocol {
/// add info type log
/// - Parameters:
///   - content: Log content, can be a json string
///   - property: Extra Property (optional)
optional func info(_ content: String, property: [AnyHashable : Any]?)

/// add warning type log
/// - Parameters:
///   - content: Log content, can be a json string
///   - property: Extra Property (optional)
optional func warning(_ content: String, property: [AnyHashable : Any]?)

/// add error type log
/// - Parameters:
///   - content:  Log content, can be a json string
///   - property: Extra Property (optional)
optional func error(_ content: String, property: [AnyHashable : Any]?)

/// add critical type log
/// - Parameters:
///   - content:  Log content, can be a json string
///   - property: Extra Property (optional)
optional func critical(_ content: String, property: [AnyHashable : Any]?)

/// add ok type log
/// - Parameters:
///   - content: Log content, can be a json string
///   - property: Extra Property (optional)
optional func ok(_ content: String, property: [AnyHashable : Any]?)
}

/// log level
typedef NS_ENUM(NSInteger, FTLogStatus) {
    /// info
    FTStatusInfo         = 0,
    /// warning
    FTStatusWarning,
    /// error
    FTStatusError,
    /// critical
    FTStatusCritical,
    /// ok
    FTStatusOk,
};

/// log level
public enum FTLogStatus : Int, @unchecked Sendable {
    /// info
    case statusInfo = 0
    /// warning
    case statusWarning = 1
    /// error
    case statusError = 2
    /// critical
    case statusCritical = 3
    /// ok
    case statusOk = 4
}

// Method 1：Use FTMobileAgent
// Note: Ensure that the SDK has been successfully initialized at the time of use, otherwise failure will be asserted in the test environment resulting in a crash.
[[FTMobileAgent sharedInstance] logging:@"test_custom" status:FTStatusInfo];

// Method 2：Use FTLogger （recommend）
// If the SDK is not initialized successfully, calling the methods in FTLogger to add custom logs will fail, but there will be no assertion failure crash.
[[FTLogger sharedInstance] info:@"test" property:@{@"custom_key":@"custom_value"}];

// Method 1：Use FTMobileAgent
// Note: Ensure that the SDK has been successfully initialized at the time of use, otherwise failure will be asserted in the test environment resulting in a crash.
FTMobileAgent.sharedInstance().logging("contentStr", status: .statusInfo, property:["custom_key":"custom_value"])

// Method 2：Use FTLogger （recommend）
// If the SDK is not initialized successfully, calling the methods in FTLogger to add custom logs will fail, but there will be no assertion failure crash.
FTLogger.shared().info("contentStr", property: ["custom_key":"custom_value"])

NSString *key = [[NSUUID UUID]UUIDString];
NSURL *url = [NSURL URLWithString:@"http://www.baidu.com"];
//manual operation required： Get trace header before the request and add it to the request header
NSDictionary *traceHeader = [[FTTraceManager sharedInstance] getTraceHeaderWithKey:key url:url];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
if (traceHeader && traceHeader.allKeys.count>0) {
    [traceHeader enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL * __unused stop) {
        [request setValue:value forHTTPHeaderField:field];
    }];
}
NSURLSession *session=[NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:self delegateQueue:[NSOperationQueue mainQueue]];

NSURLSessionTask *task = [session dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
   //your code
}];

[task resume];

let url:URL = NSURL.init(string: "https://www.baidu.com")! as URL
if let traceHeader = FTExternalDataManager.shared().getTraceHeader(withKey: NSUUID().uuidString, url: url) {
     let request = NSMutableURLRequest(url: url)
    //manual operation required： Get trace header before the request and add it to the request header
     for (a,b) in traceHeader {
         request.setValue(b as? String, forHTTPHeaderField: a as! String)
     }
     let task = URLSession.shared.dataTask(with: request as URLRequest) {  data,  response,  error in
        //your code
     }
     task.resume()
}

id<NSURLSessionDelegate> delegate = [[FTURLSessionDelegate alloc]init];
// To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
delegate.provider = ^NSDictionary * _Nullable(NSURLRequest *request, NSURLResponse *response, NSData *data, NSError *error) {
                NSString *body = [[NSString alloc] initWithData:request.HTTPBody encoding:NSUTF8StringEncoding];
                return @{@"df_requestbody":body};
            };
// Provide a block to modify a URL request.Can be used for custom link tracing.
delegate.requestInterceptor = ^NSURLRequest * _Nonnull(NSURLRequest * _Nonnull request) {
            NSDictionary *traceHeader = [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:request.URL];
            NSMutableURLRequest *newRequest = [request mutableCopy];
            if(traceHeader){
                for (NSString *key in traceHeader.allKeys) {
                    [newRequest setValue:traceHeader[key] forHTTPHeaderField:key];
                }
            }
            return newRequest;
        };            
NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:delegate delegateQueue:nil];

let delegate = FTURLSessionDelegate.init()
// To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
delegate.provider = { request,response,data,error in
            var extraData:Dictionary<String, Any> = Dictionary()
            if let data = data,let requestBody = String(data: data, encoding: .utf8) {
                extraData["df_requestBody"] = requestBody
            }
            if let error = error {
                extraData["df_error"] = error.localizedDescription
            }
            return extraData
        }
// Provide a block to modify a URL request.Can be used for custom link tracing.
delegate.requestInterceptor = { request in
            var mutableRequest = request
            if let traceHeader = FTExternalDataManager.shared().getTraceHeader(with: request.url!){
                for (key,value) in traceHeader {
                    mutableRequest.setValue(value as? String, forHTTPHeaderField: key as! String)
                }
            }
            return mutableRequest
        }        
let session =  URLSession.init(configuration: URLSessionConfiguration.default, delegate:delegate 
, delegateQueue: nil)

@interface InstrumentationInheritClass:FTURLSessionDelegate
@property (nonatomic, strong) NSURLSession *session;
@end
@implementation InstrumentationInheritClass
-(instancetype)init{
    self = [super init];
    if(self){
        _session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:self delegateQueue:nil];
        // To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
        self.provider = ^NSDictionary * _Nullable(NSURLRequest *request, NSURLResponse *response, NSData *data, NSError *error) {
        NSString *body = [[NSString alloc] initWithData:request.HTTPBody encoding:NSUTF8StringEncoding];
        return @{@"df_requestbody":body};
    };
        // Provide a block to modify a URL request.Can be used for custom link tracing.
       self.requestInterceptor = ^NSURLRequest * _Nonnull(NSURLRequest * _Nonnull request) {
            NSDictionary *traceHeader = [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:request.URL];
            NSMutableURLRequest *newRequest = [request mutableCopy];
            if(traceHeader){
                for (NSString *key in traceHeader.allKeys) {
                    [newRequest setValue:traceHeader[key] forHTTPHeaderField:key];
                }
            }
            return newRequest;
        }; 
    }
    return self;
}
-(void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didFinishCollectingMetrics:(NSURLSessionTaskMetrics *)metrics{
    // must call super
    [super URLSession:session task:task didFinishCollectingMetrics:metrics];
    // Your own logic
    // ......
}
@end

class InheritHttpEngine:FTURLSessionDelegate {
    var session:URLSession?
    override init(){
        session = nil
        super.init()
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 30
        session = URLSession.init(configuration: configuration, delegate:self, delegateQueue: nil)
        override init() {
        super.init()
        // To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
        provider = { request,response,data,error in
            var extraData:Dictionary<String, Any> = Dictionary()
            if let data = data,let requestBody = String(data: data, encoding: .utf8) {
                extraData["df_requestBody"] = requestBody
            }
            if let error = error {
                extraData["df_error"] = error.localizedDescription
            }
            return extraData
        }
        //Provide a block to modify a URL request .Can be used for custom link tracing.
        requestInterceptor = { request in
            var mutableRequest = request
            if let traceHeader = FTExternalDataManager.shared().getTraceHeader(with: request.url!){
                for (key,value) in traceHeader {
                    mutableRequest.setValue(value as? String, forHTTPHeaderField: key as! String)
                }
            }
            return mutableRequest
        }
    }
    }

    override func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
        // must call super
        super.urlSession(session, task: task, didFinishCollecting: metrics)
        // Your own logic
        // ......
    }
}

@interface InstrumentationPropertyClass:NSObject<NSURLSessionDataDelegate,FTURLSessionDelegateProviding>
@property (nonatomic, strong) FTURLSessionDelegate *ftURLSessionDelegate;
@end
@implementation InstrumentationPropertyClass

- (nonnull FTURLSessionDelegate *)ftURLSessionDelegate {
    if(!_ftURLSessionDelegate){
        _ftURLSessionDelegate = [[FTURLSessionDelegate alloc]init];
        //To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
        _ftURLSessionDelegate.provider =  ^NSDictionary * _Nullable(NSURLRequest *request, NSURLResponse *response, NSData *data, NSError *error) {
                NSString *body = [[NSString alloc] initWithData:request.HTTPBody encoding:NSUTF8StringEncoding];
                return @{@"df_requestbody":body};
            };
            // Tells the `ftURLSessionDelegate` to modify a URL request.Can be used for custom link tracing.
        _ftURLSessionDelegate.requestInterceptor = ^NSURLRequest * _Nonnull(NSURLRequest * _Nonnull request) {
            NSDictionary *traceHeader = [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:request.URL];
            NSMutableURLRequest *newRequest = [request mutableCopy];
            if(traceHeader){
                for (NSString *key in traceHeader.allKeys) {
                    [newRequest setValue:traceHeader[key] forHTTPHeaderField:key];
                }
            }
            return newRequest;
        }; 
    }
    return _ftURLSessionDelegate;
}
// The following methods must be implemented
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data{
    [self.ftURLSessionDelegate URLSession:session dataTask:dataTask didReceiveData:data];
}
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error{
    [self.ftURLSessionDelegate URLSession:session task:task didCompleteWithError:error];
}
-(void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didFinishCollectingMetrics:(NSURLSessionTaskMetrics *)metrics{
    [self.ftURLSessionDelegate URLSession:session task:task didFinishCollectingMetrics:metrics];
}
@end

class HttpEngine:NSObject,URLSessionDataDelegate,FTURLSessionDelegateProviding {
    var ftURLSessionDelegate: FTURLSessionDelegate = FTURLSessionDelegate()
    var session:URLSession?

    override init(){
        session = nil
        super.init()
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 30
        session = URLSession.init(configuration: configuration, delegate:self, delegateQueue: nil)
        // To add custom RUM resource properties, it is recommended that the tag name be prefixed with the project abbreviation, such as' df_tag_name '.
        ftURLSessionDelegate.provider = { request,response,data,error in
            var extraData:Dictionary<String, Any> = Dictionary()
            if let data = data,let requestBody = String(data: data, encoding: .utf8) {
                extraData["df_requestBody"] = requestBody
            }
            if let error = error {
                extraData["df_error"] = error.localizedDescription
            }
            return extraData
        }
        // Tells the `ftURLSessionDelegate` to modify a URL request.Can be used for custom link tracing.
        ftURLSessionDelegate.requestInterceptor = { request in
            var mutableRequest = request
            if let traceHeader = FTExternalDataManager.shared().getTraceHeader(with: request.url!){
                for (key,value) in traceHeader {
                    mutableRequest.setValue(value as? String, forHTTPHeaderField: key as! String)
                }
            }
            return mutableRequest
        }
    }
    // The following methods must be implemented
    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
        ftURLSessionDelegate.urlSession(session, dataTask: dataTask, didReceive: data)
    }

    func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {
        ftURLSessionDelegate.urlSession(session, task: task, didFinishCollecting: metrics)
    }

    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        ftURLSessionDelegate.urlSession(session, task: task, didCompleteWithError: error)
    }
}

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
- (void)bindUserWithUserID:(NSString *)userId;

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
///   - userName: user name
///   - userEmailL: user email
- (void)bindUserWithUserID:(NSString *)Id userName:(nullable NSString *)userName userEmail:(nullable NSString *)userEmail;

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
///   - userName: user name
///   - userEmail: user email
///   - extra: extar infomation
- (void)bindUserWithUserID:(NSString *)Id userName:(nullable NSString *)userName userEmail:(nullable NSString *)userEmail extra:(nullable NSDictionary *)extra;

/// Unbind user information
- (void)unbindUser;

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
open func bindUser(withUserID userId: String)

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
///   - userName: user name
///   - userEmailL: user email
open func bindUser(withUserID Id: String, userName: String?, userEmail: String?)

/// Bind user information
///
/// - Parameters:
///   - Id:  user id
///   - userName: user name
///   - userEmail: user email
///   - extra: extar infomation
open func bindUser(withUserID Id: String, userName: String?, userEmail: String?, extra: [AnyHashable : Any]?)

/// Unbind user information
open func unbindUser()

// bind user info after log in
[[FTMobileAgent sharedInstance] bindUserWithUserID:USERID];
// or
[[FTMobileAgent sharedInstance] bindUserWithUserID:USERID userName:USERNAME userEmail:USEREMAIL];
// or
[[FTMobileAgent sharedInstance] bindUserWithUserID:USERID userName:USERNAME userEmail:USEREMAIL extra:@{EXTRA_KEY:EXTRA_VALUE}];

// clear user data after log out
[[FTMobileAgent sharedInstance] unbindUser];

// bind user info after log in
FTMobileAgent.sharedInstance().bindUser(withUserID: USERID)
// or
FTMobileAgent.sharedInstance().bindUser(withUserID: USERID, userName: USERNAME, userEmail: USEREMAIL)
// or
FTMobileAgent.sharedInstance().bindUser(withUserID: USERID, userName: USERNAME, userEmail: USEREMAIL,extra:[EXTRA_KEY:EXTRA_VALUE])

// clear user data after log out
FTMobileAgent.sharedInstance().unbindUser()

/// Close the running object inside the SDK
+ (void)shutDown;

/// Close the running object inside the SDK
open class func shutDown()

//If you dynamically change the SDK configuration, you need to close it first to avoid the generation of wrong data
[FTMobileAgent  shutDown];

//If you dynamically change the SDK configuration, you need to close it first to avoid the generation of wrong data
FTMobileAgent.shutDown()

/// Clear all data that has not been uploaded to the server 
+ (void)clearAllData; 

/// Clear all data that has not been uploaded to the server 
open class func clearAllData() 

[FTMobileAgent clearAllData]; 

FTMobileAgent.clearAllData() 

/// Actively synchronize data 
- (void)flushSyncData; 

/// Actively synchronize data 
func flushSyncData() 

[[FTMobileAgent sharedInstance] flushSyncData]; 

//If you change the SDK configuration dynamically, you need to close it first to avoid the generation of incorrect data 
FTMobileAgent.sharedInstance().flushSyncData() 

/// Add SDK global tags, which act on RUM and Log data 
/// - Parameter context: custom data 
+ (void)appendGlobalContext:(NSDictionary <NSString*,id>*)context; 

/// Add RUM custom tag, acting on RUM data 
/// - Parameter context: custom data 
+ (void)appendRUMGlobalContext:(NSDictionary <NSString*,id>*)context; 

/// Add Log global tag, acting on Log data 
/// - Parameter context: custom data 
+ (void)appendLogGlobalContext:(NSDictionary <NSString*,id>*)context; 

/// Add SDK global tag, acting on RUM and Log data 
/// - Parameter context: custom dataopen 
class func appendGlobalContext(_ context: [String : Any]) 

/// Add RUM custom tag, acting on RUM data 
/// - Parameter context: custom dataopen 
class func appendRUMGlobalContext(_ context: [String : Any]) 

/// Add Log Global tag, applied to Log data 
/// - Parameter context: custom data 
open class func appendLogGlobalContext(_ context: [String : Any]) 

[FTMobileAgent appendGlobalContext:@{@"global_key":@"global_value"}]; 
[FTMobileAgent appendLogGlobalContext:@{@"log_key":@"log_value"}]; 
[FTMobileAgent appendRUMGlobalContext:@{@"rum_key":@"rum_value"}]; 

let globalContext = ["global_key":"global_value"] 
FTMobileAgent.appendGlobalContext(globalContext) 
let rumGlobalContext = = ["rum_key":"rum_value"]
FTMobileAgent.appendRUMGlobalContext(rumGlobalContext) 
let logGlobalContext = = ["log_key":"log_value"] 
FTMobileAgent.appendLogGlobalContext(logGlobalContext) 

// In the main project
 FTMobileConfig *config = [[FTMobileConfig alloc]initWithMetricsUrl:url];
 config.enableSDKDebugLog = YES;
 config.groupIdentifiers = @[@"group.com.ft.widget.demo"]; 

let config = FTMobileConfig.init(metricsUrl: url)
config.enableSDKDebugLog = true
config.groupIdentifiers = ["group.com.ft.widget.demo"]

//  In the main project
/// Track Widget Extension sdk cached data 
/// - Parameters:
///   - groupIdentifier: groupIdentifier
///   - completion: completion callback
- (void)trackEventFromExtensionWithGroupIdentifier:(NSString *)groupIdentifier completion:(nullable void (^)(NSString *groupIdentifier, NSArray *events)) completion;

/// Track Widget Extension sdk cached data 
/// - Parameters:
///   - groupIdentifier: groupIdentifier
///   - completion: completion callback
open func trackEventFromExtension(withGroupIdentifier groupIdentifier: String, completion: ((String, [Any]) -> Void)? = nil)

// In the main project
-(void)applicationDidBecomeActive:(UIApplication *)application{
    [[FTMobileAgent sharedInstance] trackEventFromExtensionWithGroupIdentifier:@"group.identifier" completion:nil];
}

func applicationDidBecomeActive(_ application: UIApplication) {
FTMobileAgent.sharedInstance().trackEventFromExtension(withGroupIdentifier: "group.identifier" )     
}