데이터 수집 커스텀 규칙¶

rumConfig.viewTrackingHandler = [CustomViewTracker new];

#import "FTDefaultUIKitViewTrackingHandler.h"

// 프로토콜 구현 방식 예시
@interface CustomViewTracker : NSObject <FTUIKitViewTrackingHandler>
// SDK 기본 view 수집 규칙이 필요한 경우에만 추가
@property (nonatomic, strong) FTDefaultUIKitViewTrackingHandler defaultHandler;
@end

@implementation CustomViewTracker

// SDK 기본 view 수집 규칙이 필요한 경우에만 추가
-(FTDefaultUIKitViewTrackingHandler *)defaultHandler{
    if (!_defaultHandler) {
        _defaultHandler = [FTDefaultUIKitViewTrackingHandler new];
    }
    return _defaultHandler;
}

- (FTRUMView *)rumViewForViewController:(UIViewController *)viewController {
    // 클래스명으로 정확히 매칭
    if ([viewController isKindOfClass:[HomeViewController class]]) {
        return [[FTRUMView alloc] initWithViewName:@"main_home" property:@{@"page_type": @"home"}];
    }
    // 프리픽스로 필터링
    else if ([NSStringFromClass([viewController class]) hasPrefix:@"FT"]) {
        return [[FTRUMView alloc] initWithViewName:[NSString stringWithFormat:@"ft_%@", NSStringFromClass([viewController class])] property:nil];
    }
    // accessibilityLabel로 설정
    else if (viewController.view.accessibilityLabel) {
        return [[FTRUMView alloc] initWithViewName:viewController.view.accessibilityLabel property:nil];
    }
    // 일부 페이지를 커스텀한 후, 나머지 페이지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)
    return [self.defaultHandler rumViewForViewController:viewController];

    // 추적을 건너뛰려면 nil을 반환
    return nil;
}
@end

rumConfig.viewTrackingHandler = CustomViewTracker()

class CustomViewTracker: NSObject, FTUIKitViewTrackingHandler {

    // SDK 기본 view 수집 규칙이 필요한 경우에만 해당 속성 유지
    lazy var defaultHandler: FTDefaultUIKitViewTrackingHandler = {
        FTDefaultUIKitViewTrackingHandler() 
    }()

    func rumView(for viewController: UIViewController) -> FTRUMView? {
        // 클래스명으로 정확히 매칭
        if viewController is HomeViewController {
            let properties: [String: Any] = ["page_type": "home"]
            return FTRUMView(viewName: "main_home", property: properties)
        }

        // 클래스명 프리픽스로 필터링
        let vcClassName = String(describing: type(of: viewController))
        if vcClassName.hasPrefix("FT") {
            let viewName = "ft_\(vcClassName)"
            return FTRUMView(viewName: viewName, property: nil)
        }

        // accessibilityLabel로 설정
        if let accessibilityLabel = viewController.view.accessibilityLabel, !accessibilityLabel.isEmpty {
            return FTRUMView(viewName: accessibilityLabel, property: nil)
        }

        // 일부 페이지를 커스텀한 후, 나머지 페이지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)
        return defaultHandler.rumView(for: viewController)

        // 추적을 건너뛰려면 nil을 반환
        return nil
    }
}

rumConfig.enableTraceUserView = YES;
rumConfig.swiftUIViewTrackingHandler = [FTDefaultSwiftUIViewTrackingHandler new];

rumConfig.enableTraceUserView = true
rumConfig.swiftUIViewTrackingHandler = FTDefaultSwiftUIViewTrackingHandler()

rumConfig.swiftUIViewTrackingHandler = [CustomSwiftUIViewTracker new];

@interface CustomSwiftUIViewTracker : NSObject <FTSwiftUIViewTrackingHandler>
@end

@implementation CustomSwiftUIViewTracker
- (nullable FTRUMView *)rumViewForExtractedViewName:(NSString *)extractedViewName {
    if ([extractedViewName isEqualToString:@"HomeView"]) {
        return [[FTRUMView alloc] initWithViewName:@"main_home" property:@{@"page_type": @"home"}];
    }
    return nil;
}
@end

rumConfig.swiftUIViewTrackingHandler = CustomSwiftUIViewTracker()

class CustomSwiftUIViewTracker: NSObject, FTSwiftUIViewTrackingHandler {
    func rumView(forExtractedViewName extractedViewName: String) -> FTRUMView? {
        if extractedViewName == "HomeView" {
            return FTRUMView(
                viewName: "main_home",
                property: ["page_type": "home"]
            )
        }
        return nil
    }
}

rumConfig.actionTrackingHandler = [CustomActionTracker new];

#import "FTDefaultActionTrackingHandler.h"

// 프로토콜 구현 방식 예시
// iOS 환경에서는 `FTUIPressRUMActionsHandler` 프로토콜을 따라야 함
// tvOS 환경에서는 `FTUITouchRUMActionsHandler` 프로토콜을 따라야 함
@interface CustomActionTracker : NSObject <FTUIPressRUMActionsHandler,FTUITouchRUMActionsHandler>
// SDK 기본 Action 수집 규칙이 필요한 경우에만 추가
@property (nonatomic, strong) FTDefaultActionTrackingHandler defaultHandler;
@end
@implementation CustomActionTracker

// SDK 기본 Action 수집 규칙이 필요한 경우에만 추가
-(FTDefaultActionTrackingHandler *)defaultHandler{
    if (!_defaultHandler) {
        _defaultHandler = [FTDefaultActionTrackingHandler new];
    }
    return _defaultHandler;
}

// iOS와 tvOS 모두 구현해야 하는 프로토콜 메서드
- (nullable FTRUMAction *)rumLaunchActionWithLaunchType:(FTLaunchType)type {
    if(type == FTLaunchCold){
      return [[FTRUMAction alloc]initWithActionName:@"cold"];
    }
    // nil을 반환하여 추적 건너뜀
    return nil;
}

// iOS 환경에서 구현해야 하는 프로토콜 메서드
-(nullable FTRUMAction *)rumActionWithTargetView:(UIView *)targetView{
    if (view.accessibilityIdentifier){
       return [[FTRUMAction alloc] initWithActionName:view.accessibilityIdentifier];
    }

     // 일부 Action을 커스텀한 후, 나머지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)
    return [self.defaultHandler rumActionWithTargetView:targetView];

    // nil을 반환하여 추적 건너뜀
    return nil;
}
// tvOS 환경에서 구현해야 하는 프로토콜 메서드
- (nullable FTRUMAction *)rumActionWithPressType:(UIPressType)type targetView:(UIView *)targetView{
    if (type == UIPressTypeSelect && view.accessibilityIdentifier){
       return [[FTRUMAction alloc] initWithActionName:view.accessibilityIdentifier];
    }

    // 일부 Action을 커스텀한 후, 나머지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)
    return [self.defaultHandler rumActionWithPressType:type targetView:targetView];

        // nil을 반환하여 추적 건너뜀
    return nil;
}
@end

rumConfig.actionTrackingHandler = CustomActionTracker()

// 프로토콜 구현 방식 예시
// iOS 환경에서는 `FTUIPressRUMActionsHandler` 프로토콜을 따라야 함
// tvOS 환경에서는 `FTUITouchRUMActionsHandler` 프로토콜을 따라야 함
class CustomActionTracker: NSObject, FTUIPressRUMActionsHandler, FTUITouchRUMActionsHandler {

    // SDK 기본 Action 수집 규칙이 필요한 경우에만 추가
    lazy var defaultHandler: FTDefaultActionTrackingHandler = {
        FTDefaultActionTrackingHandler()
    }()

    // iOS와 tvOS 모두 구현해야 하는 프로토콜 메서드
    func rumLaunchAction(with type: FTLaunchType) -> FTRUMAction? {
        if type == .cold {
            return FTRUMAction(actionName: "cold")
        }
        // nil을 반환하여 추적 건너뜀
        return nil
    }

    // iOS 환경에서 구현해야 하는 프로토콜 메서드
    func rumAction(withTargetView targetView: UIView) -> FTRUMAction? {
        if let identifier = targetView.accessibilityIdentifier {
            return FTRUMAction(actionName: identifier)
        }

        // 일부 Action을 커스텀한 후, 나머지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)
        return defaultHandler.rumAction(withTargetView: targetView)

        // nil을 반환하여 추적 건너뜀
        return nil 
    }

    // tvOS 환경에서 구현해야 하는 프로토콜 메서드
    func rumAction(with pressType: UIPress.PressType, targetView: UIView) -> FTRUMAction? {
        if pressType == .select, let identifier = targetView.accessibilityIdentifier {
            return FTRUMAction(actionName: identifier)
        }

        // 일부 Action을 커스텀한 후, 나머지는 SDK 기본 수집 규칙 사용 (기본 핸들러의 처리 결과 반환)        
        return defaultHandler.rumAction(with: pressType, targetView: targetView)

        // nil을 반환하여 추적 건너뜀
        return nil
    }
}

rumConfig.resourceUrlHandler = ^(NSURL *url){
        // YES를 반환하면 수집하지 않음, NO를 반환하면 수집
        if ([url.host isEqualToString:@"example.com"]) {
            return YES;
        }
        return NO;
};

rumConfig.resourceUrlHandler = { url in 
     // true를 반환하면 수집하지 않음, false를 반환하면 수집
     return url.host == "example.com"
}

rumConfig.resourcePropertyProvider = ^NSDictionary *_Nullable(NSURLRequest *request, NSURLResponse *response,NSData *data, NSError *error) {
     NSString *body = @"";
     if (request.HTTPBody) {
        body = [[NSString alloc] initWithData:httpBody encoding:NSUTF8StringEncoding] ?: @"";
     }
     return @{@"request_body": body};
 }

rumConfig.resourcePropertyProvider = { request, response, data, error in
   let body = request.httpBody.flatMap { String(data: $0, encoding: .utf8) } ?? ""
   return ["request_body": body]
  }

rumConfig.sessionTaskErrorFilter = ^BOOL(NSError * _Nonnull error){
    return error.code == NSURLErrorCancelled;
}; 

rumConfig.sessionTaskErrorFilter = { error in
   return (error as? URLError)?.code == .cancelled
}

FTRumConfig *rumConfig = [[FTRumConfig alloc] initWithAppid:appid];
rumConfig.enableTrackAppCrash = YES;
rumConfig.enableTrackAppANR = YES;

// RUM 시작 전에 읽기 전용 비즈니스 스냅샷을 준비하여 콜백에서 시간이 오래 걸리는 작업을 피함
NSDictionary<NSString *, id> *businessContext = @{
    @"business_scene": @"checkout",
    @"release_channel": @"app_store"
};

rumConfig.issueDataProvider = ^NSDictionary<NSString *, id> * _Nullable(FTIssueInfo *issue) {
    NSMutableDictionary<NSString *, id> *fields = [businessContext mutableCopy];
    fields[@"issue_category"] =
        issue.category == FTIssueCategoryCrash ? @"crash" : @"anr";
    fields[@"historical_issue"] = @(issue.isHistorical);

    if (issue.threadName.length > 0) {
        fields[@"issue_thread_name"] = issue.threadName;
    }
    return fields;
};

[[FTMobileAgent sharedInstance] startRumWithConfigOptions:rumConfig];

let rumConfig = FTRumConfig(appid: appid)
rumConfig.enableTrackAppCrash = true
rumConfig.enableTrackAppANR = true

// RUM 시작 전에 읽기 전용 비즈니스 스냅샷을 준비하여 콜백에서 시간이 오래 걸리는 작업을 피함
let businessContext: [String: Any] = [
    "business_scene": "checkout",
    "release_channel": "app_store"
]

rumConfig.issueDataProvider = { issue in
    var fields = businessContext
    fields["issue_category"] =
        issue.category == .crash ? "crash" : "anr"
    fields["historical_issue"] = issue.isHistorical

    if let threadName = issue.threadName, !threadName.isEmpty {
        fields["issue_thread_name"] = threadName
    }
    return fields
}

FTMobileAgent.sharedInstance().startRum(withConfigOptions: rumConfig)

FTTraceConfig *traceConfig = [[FTTraceConfig alloc]init];
   traceConfig.traceInterceptor = ^FTTraceContext * _Nullable(NSURLRequest *request) {
    // 1. 비즈니스 커스텀 traceId 가져오기
    NSString *replaceTrace = [request.allHTTPHeaderFields valueForKey:CUSTOM_TRACE_HEADER];

    // 2. SDK 표준 W3C traceparent 요청 헤더 가져오기
    NSDictionary *traceHeaders = [[FTExternalDataManager sharedManager] getTraceHeaderWithUrl:request.URL];
    NSString *traceParentStr = traceHeaders[FT_NETWORK_TRACEPARENT_KEY];

    // 3. W3C traceparent 형식 파싱 후 인덱스 1의 traceId 교체
    NSArray *traceComponents = [traceParentStr componentsSeparatedByString:@"-"];
    if (traceComponents.count != 4) {
        return nil;
    }
    NSMutableArray *newComponents = [traceComponents mutableCopy];
    newComponents[1] = replaceTrace;
    NSString *newTraceParent = [newComponents componentsJoinedByString:@"-"];

    // 4. 커스텀 추적 컨텍스트 조립 및 반환
    FTTraceContext *context = [FTTraceContext new];
    context.traceHeader = @{FT_NETWORK_TRACEPARENT_KEY:newTraceParent};
    context.traceId = replaceTrace;
    // SDK가 생성한 spanId 유지 (인덱스 2 고정 위치)
    context.spanId = newComponents[2];
    return context;
};

let traceConfig = FTTraceConfig()
traceConfig.traceInterceptor = { (request: URLRequest) -> FTTraceContext? in
        // 1. 비즈니스 커스텀 traceId 가져오기
        guard let replaceTrace = request.allHTTPHeaderFields?[CUSTOM_TRACE_HEADER] else {
            return nil
        }

        // 2. SDK 표준 W3C traceparent 요청 헤더 가져오기
        guard let traceHeaders = FTExternalDataManager.shared().getTraceHeader(with: request.url!), let traceParentStr = traceHeaders[FT_NETWORK_TRACEPARENT_KEY] as? String else {
            return nil
        }

        // 3. W3C traceparent 형식 파싱 후 인덱스 1의 traceId 교체
        let traceComponents = traceParentStr.components(separatedBy: "-")
        guard traceComponents.count == 4 else {
            return nil
        }
        var newComponents = traceComponents
        newComponents[1] = replaceTrace
        let newTraceParent = newComponents.joined(separator: "-")

        // 4. 커스텀 추적 컨텍스트 조립 및 반환
        let context = FTTraceContext()
        context.traceHeader = [FT_NETWORK_TRACEPARENT_KEY: newTraceParent]
        context.traceId = replaceTrace
        // SDK가 생성한 spanId 유지 (인덱스 2 고정 위치)
        context.spanId = newComponents[2]
        return context
    }