콘텐츠로 이동

데이터 수집 사용자 정의 규칙

View

Activity

  • 먼저 FTRUMConfig.setEnableTraceUserView(true)를 통해 활성화해야 합니다.
FTSdk.initRUMWithConfig(new FTRUMConfig()
    .setViewActivityTrackingHandler(new FTViewActivityTrackingHandler() {
        @Override
        public HandlerView resolveHandlerView(Activity activity) {
            String activityName = activity.getClass().getSimpleName();

            // Activity 이름에 따라 View 이름 사용자 정의
            if (activityName.startsWith("Main")) {
                return new HandlerView("自定义主页面");
            } else if (activityName.startsWith("Detail")) {
                HashMap<String, Object> properties = new HashMap<>();
                properties.put("extra_key", "extra_value");
                return new HandlerView("自定义详情页面", properties);
            }

            // null 반환 시 추적 건너뛰기
            return null;
        }
    })
);
FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setViewActivityTrackingHandler(object : FTViewActivityTrackingHandler {
            override fun resolveHandlerView(activity: Activity): HandlerView? {
                val activityName = activity.javaClass.simpleName
                return when {
                    activityName.startsWith("Main") ->
                        HandlerView("自定义主页面")
                    activityName.startsWith("Detail") -> {
                        val properties = hashMapOf<String, Any>("extra_key" to "extra_value")
                        HandlerView("自定义详情页面", properties)
                    }
                    else -> null // 추적 건너뛰기
                }
            }
        })
)

Fragment

  • FTRUMConfig.setEnableTraceUserView(true)와 FTRUMConfig.setEnableTraceUserViewInFragment(true)를 동시에 활성화해야 합니다.
FTSdk.initRUMWithConfig(new FTRUMConfig()
    .setViewFragmentTrackingHandler(new FTViewFragmentTrackingHandler() {
        @Override
        public HandlerView resolveHandlerView(FragmentWrapper fragment) {
            String fragmentName = fragment.getSimpleClassName();

            // Fragment 이름에 따라 View 이름 사용자 정의
            if (fragmentName.equals("HomeFragment")) {
                return new HandlerView("自定义首页片段");
            } else if (fragmentName.startsWith("Detail")) {
                HashMap<String, Object> properties = new HashMap<>();
                properties.put("extra_key", "extra_value");
                return new HandlerView("自定义详情片段", properties);
            }

            // null 반환 시 추적 건너뛰기
            return null;
        }
    })
);
FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setViewFragmentTrackingHandler(object : FTViewFragmentTrackingHandler {
            override fun resolveHandlerView(fragment: FragmentWrapper): HandlerView? {
                val fragmentName = fragment.simpleClassName
                return when {
                    fragmentName == "HomeFragment" ->
                        HandlerView("自定义首页片段")
                    fragmentName.startsWith("Detail") -> {
                        val properties = hashMapOf<String, Any>("extra_key" to "extra_value")
                        HandlerView("自定义详情片段", properties)
                    }
                    else -> null // 추적 건너뛰기
                }
            }
        })
)

View 소요 시간 메트릭 사용자 정의 규칙

FTRUMConfig.setInitialResourceIdentifier와 setLastInteractionIdentifier를 통해 네이티브 View의 network_settled_time 및 interaction_to_next_view_time 판단 규칙을 사용자 정의합니다. 메트릭의 의미, 단위 및 기본 규칙은 View 소요 시간 메트릭을 참고하세요.

시간 범위 조정

FTSdk.initRUMWithConfig에 전달하는 구성에서 정책을 설정합니다. 다음 예시는 초기 Resource 범위를 500ms로, interaction_to_next_view_time 상한을 5000ms로 조정합니다. 생성자 매개변수의 단위는 밀리초이며, 0보다 커야 하고 시간 범위의 상한은 포함되지 않습니다.

FTSdk.initRUMWithConfig(
    new FTRUMConfig()
        .setRumAppId(RUM_APP_ID)
        .setEnableTraceUserView(true)
        .setEnableTraceUserAction(true)
        .setEnableTraceUserResource(true)
        .setInitialResourceIdentifier(new FTTimeBasedInitialResourceIdentifier(500))
        .setLastInteractionIdentifier(new FTTimeBasedInteractionIdentifier(5000))
);
FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setRumAppId(RUM_APP_ID)
        .setEnableTraceUserView(true)
        .setEnableTraceUserAction(true)
        .setEnableTraceUserResource(true)
        .setInitialResourceIdentifier(FTTimeBasedInitialResourceIdentifier(500))
        .setLastInteractionIdentifier(FTTimeBasedInteractionIdentifier(5000))
)

정책을 설정해도 View, Action 또는 Resource 수집이 자동으로 활성화되지는 않습니다. 자동 수집은 여전히 해당 설정을 활성화하고 기존 연동 요구 사항을 충족해야 하며, RUM 수동 계측 API와 함께 사용할 수도 있습니다.

사용자 정의 판단 규칙

두 정책 인터페이스 모두 validate(context) 메서드를 제공합니다. true를 반환하면 사용자 정의 필터를 통과했음을, false를 반환하면 해당 메트릭 계산에 참여하지 않음을 의미합니다. 필터를 통과해도 메트릭 생성이 보장되지는 않습니다. 아래의 메트릭 생성 제한도 충족해야 합니다. 판단 조건은 컨텍스트에서 제공하는 정보나 비즈니스 측에서 유지 관리하는 외부 상태를 사용할 수 있습니다.

사용자 정의 규칙은 해당 기본 시간 판단을 대체하며, 더 이상 100ms 또는 3000ms 제한을 추가로 적용하지 않습니다. interaction_to_next_view_time의 시간 차이가 0보다 커야 한다는 기본 요구 사항은 여전히 적용됩니다.

RUM 초기화 전에 이미 구성된 config에 규칙을 지정합니다. 다음 예시는 비즈니스 초기 로딩 단계에서 등록된 Resource만 네트워크 메트릭에 포함하고, 간격이 5초 미만인 마지막 click 인터랙션만 허용합니다.

import java.util.concurrent.atomic.AtomicBoolean;

// 비즈니스에서 유지 관리하며, 초기 로딩 단계가 끝날 때 initialLoading.set(false)를 호출합니다.
AtomicBoolean initialLoading = new AtomicBoolean(true);
FTLastInteractionIdentifier navigationWindow = new FTTimeBasedInteractionIdentifier(5000);

config.setInitialResourceIdentifier(context -> initialLoading.get())
    .setLastInteractionIdentifier(context ->
        "click".equals(context.getActionType()) && navigationWindow.validate(context));
import java.util.concurrent.atomic.AtomicBoolean

// 비즈니스에서 유지 관리하며, 초기 로딩 단계가 끝날 때 initialLoading.set(false)를 호출합니다.
val initialLoading = AtomicBoolean(true)
val navigationWindow = FTTimeBasedInteractionIdentifier(5000)

config.setInitialResourceIdentifier { context -> initialLoading.get() }
    .setLastInteractionIdentifier { context ->
        context.actionType == "click" && navigationWindow.validate(context)
    }

Java에서는 Lambda를 사용하지 않고 익명 내부 클래스로 FTInitialResourceIdentifier 또는 FTLastInteractionIdentifier를 구현할 수도 있습니다.

두 콜백의 컨텍스트는 모두 불변 객체이며 다음 메서드를 공개합니다. 시간 값은 System.nanoTime()과 동일한 프로세스 내 단조 시계를 사용하고 단위는 나노초입니다. Unix 타임스탬프가 아니며 System.currentTimeMillis()와 직접 비교할 수 없습니다.

컨텍스트 메서드 의미
FTNetworkSettledResourceContext getResourceId() 해당 SDK 등록에 사용된 Resource ID
FTNetworkSettledResourceContext getResourceStartTimeNanos() SDK가 기록한 원본 Resource 타이밍 시작점
FTNetworkSettledResourceContext getViewStartTimeNanos() 소속 View의 시작 시간
FTPreviousViewLastInteractionContext getActionType() 이전 View의 마지막 후보 인터랙션 유형
FTPreviousViewLastInteractionContext getInteractionTimeNanos() SDK가 기록한 인터랙션 시작 시간이며, 명시적으로 중지된 대기형 Action은 중지 시간을 사용합니다
FTPreviousViewLastInteractionContext getNextViewStartTimeNanos() 다음 View의 시작 시간

네트워크 컨텍스트에는 URL, 요청 메서드, 요청 헤더, 상태 코드 또는 사용자 정의 속성이 포함되지 않으므로 컨텍스트에서 직접 API 주소를 읽어 필터링할 수 없습니다. interaction_to_next_view_time 컨텍스트에는 Action 이름이나 비즈니스 속성이 포함되지 않습니다.

콜백 사용 시 주의 사항

  • 초기화 전에 규칙을 설정합니다. 초기화 후 FTRUMConfig의 정책을 수정해도 적용되지 않습니다. 콜백은 여전히 비즈니스 측에서 유지 관리하는 외부 상태를 읽을 수 있습니다.
  • 빠르게 반환하고 스레드 안전성에 주의합니다. 콜백에서 네트워크 요청, 파일 읽기/쓰기 등 차단 작업을 수행하지 마세요. 네트워크 규칙은 메인 스레드 또는 여러 수집 스레드에서 호출될 수 있으며, interaction_to_next_view_time 규칙은 SDK 이벤트 큐에서 호출됩니다.
  • 비즈니스 상태는 콜백 실행 시점을 기준으로 합니다. 네트워크 규칙은 SDK가 Resource를 등록할 때 동기적으로 호출되며, 등록할 때마다 한 번만 판단합니다. 등록은 요청 시작 시간보다 늦을 수 있으므로 시간으로 필터링할 때는 컨텍스트의 원본 시작 시간을 사용해야 합니다. 예시의 initialLoading은 콜백 실행 시점의 값을 사용하며, 이후 상태를 변경해도 해당 요청을 다시 판단하지 않습니다.
  • 메트릭 제외는 이벤트 수집에 영향을 주지 않습니다. false를 반환하거나 일반 예외를 발생시키면 이번 요청 또는 인터랙션이 메트릭에 기여하는 부분만 제외되며, 원본 Resource 또는 Action 이벤트가 이로 인해 삭제되지는 않습니다.

메트릭 생성 제한

network_settled_time:

  • 선택된 모든 요청의 처리가 완료된 후에만 SDK가 그중 성공적으로 기록된 요청을 기준으로 소요 시간을 계산할 수 있습니다. 유효한 요청이 없으면 필드를 생성하지 않으며, 필드가 누락되었다고 해서 소요 시간이 0이라는 의미는 아닙니다.
  • View가 종료될 때 결과가 확정됩니다. 이 시점에 선택된 요청이 아직 끝나지 않았거나 해당 로컬 캐시 쓰기가 완료되지 않았다면 필드는 누락된 상태로 유지되며, 이후 요청이 완료되어도 소급 계산하지 않습니다.

interaction_to_next_view_time:

  • click 유형의 Action만 허용합니다. 자동 수집되는 뒤로 가기 동작도 click 유형을 사용하며 이름은 back입니다. 사용자 정의 규칙으로 다른 Action 유형을 계산에 참여시킬 수는 없습니다.
  • 이전 View의 마지막으로 성공적으로 기록된 후보 인터랙션만 판단합니다. 규칙이 해당 인터랙션을 거부하면 이번 결과를 생성하지 않으며, 더 이전의 인터랙션을 계속 찾지도 않습니다.
데이터 쓰기와 콜백 시점의 상세 규칙
  • 요청 유효 여부: 선택된 요청의 Resource 또는 대응하는 Network Error가 최소 하나 이상 로컬 캐시에 성공적으로 기록되어야 network_settled_time에 포함됩니다. 관련 레코드가 모두 필터링, 폐기 또는 쓰기 실패되면 SDK는 해당 요청 대기를 중단하지만 그 소요 시간은 포함하지 않습니다. 유효한 0나노초 결과는 유지됩니다.
  • 인터랙션 순서: "마지막"은 SDK가 Action의 성공적인 쓰기 결과를 수신한 순서로 결정되며, 인터랙션 타임스탬프 기준으로 다시 정렬하지 않습니다.
  • 인터랙션 규칙 호출 시점: 이전 View의 후보 인터랙션과 다음 View가 모두 확정된 후 SDK가 interaction_to_next_view_time 규칙을 호출하며, 동일한 조합은 한 번만 판단합니다. 새 후보 인터랙션을 수신하면 다시 판단합니다. 일반적인 View 업데이트, 재시도, 업로드 및 캐시 복구는 이 두 규칙을 다시 호출하지 않습니다.
  • 인터랙션 결과 갱신 시점: SDK가 이전 View와 다음 View의 연관 정보를 여전히 보유하고 있을 때, 지연 도착한 이전 페이지 Action의 쓰기 결과가 다음 View의 interaction_to_next_view_time을 갱신할 수 있습니다. 이미 계산된 결과는 이전 View의 기록이 제거되어도 지워지지 않습니다.

메트릭 비활성화

config.setInitialResourceIdentifier(context -> false) // 어떤 Resource도 선택하지 않음
    .setLastInteractionIdentifier(null);             // 자동 interaction_to_next_view_time 비활성화
config.setInitialResourceIdentifier { _ -> false }
    .setLastInteractionIdentifier(null)

setInitialResourceIdentifier는 null을 허용하지 않습니다. 위 구성은 모두 FTSdk.initRUMWithConfig(config) 전에 설정해야 하며, 기존 View, Action 또는 Resource 이벤트 수집을 비활성화하지 않습니다.

Action

  • FTRUMConfig.setEnableTraceUserAction(true)가 활성화된 상태여야 합니다.
  • 용도: Action 이름, 속성을 사용자 정의하거나 특정 View에 따라 Action 수집을 필터링합니다.
FTSdk.initRUMWithConfig(new FTRUMConfig()
    .setActionTrackingHandler(new FTActionTrackingHandler() {
        @Override
        public HandlerAction resolveHandlerAction(ActionEventWrapper actionEventWrapper) {
            // 작업 유형 가져오기
            ActionSourceType actionType = actionEventWrapper.getSourceType();
            Object source = actionEventWrapper.getSource();

            // 지정된 View의 Action 필터링
            if (source instanceof View) {
                View view = (View) source;
                if (view.getId() == R.id.ignore_action_view) {
                    return null;
                }
            }

            // 작업 유형에 따라 추적 사용자 정의
            if (actionType == ActionSourceType.CLICK_VIEW) {
                HashMap<String, Object> properties = new HashMap<>();
                properties.put("extra_key", "extra_value");
                return new HandlerAction("自定义按钮点击", properties);
            } else if (actionType == ActionSourceType.CLICK_LIST_ITEM) {
                return new HandlerAction("自定义列表项点击");
            }

            // null 반환 시 추적 건너뛰기
            return null;
        }
    })
);
FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setActionTrackingHandler(object : FTActionTrackingHandler {
            override fun resolveHandlerAction(actionEventWrapper: ActionEventWrapper): HandlerAction? {
                val source = actionEventWrapper.source

                // 지정된 View의 Action 필터링
                if (source is View && source.id == R.id.ignore_action_view) {
                    return null
                }

                return when (actionEventWrapper.sourceType) {
                    ActionSourceType.CLICK_VIEW -> {
                        val properties = hashMapOf<String, Any>("extra_key" to "extra_value")
                        HandlerAction("自定义按钮点击", properties)
                    }
                    ActionSourceType.CLICK_LIST_ITEM ->
                        HandlerAction("自定义列表项点击")
                    else -> null // 추적 건너뛰기
                }
            }
        })
)
주의

ActionEventWrapper.getSource()를 통해 현재 작업의 소스 객체를 가져올 수 있습니다. 일반 클릭, 목록 항목 클릭, Tab 클릭 등 View에서 트리거된 Action의 source는 일반적으로 해당 View입니다. setActionTrackingHandler를 설정하면 SDK는 해당 핸들러의 반환 결과를 Action 수집 근거로 사용합니다. null을 반환한 Action은 건너뛰며, 계속 수집해야 하는 Action은 HandlerAction을 반환해야 합니다.

Resource

  • FTRUMConfig.setEnableTraceUserResource(true)가 활성화된 상태여야 합니다.

URL 기반 수집 필터링

FTSdk.initRUMWithConfig(new FTRUMConfig()
    .setResourceUrlHandler(new FTInTakeUrlHandler() {
        @Override
        public boolean isInTakeUrl(String url) {
            // true를 반환하면 수집하지 않음; false를 반환하면 수집함
            return url.startsWith("https://url.rule");
        }
    })
);
FTSdk.initRUMWithConfig(
    FTRUMConfig()
        .setResourceUrlHandler(object : FTInTakeUrlHandler {
            override fun isInTakeUrl(url: String): Boolean {
                // true를 반환하면 수집하지 않음; false를 반환하면 수집함
                return url.startsWith("https://url.rule")
            }
        })
)

사용자 정의 속성 추가

FTRUMConfig.setOkHttpResourceContentHandler(FTResourceInterceptor.ContentHandlerHelperEx)를 통해 설정할 수 있습니다.

new FTResourceInterceptor.ContentHandlerHelperEx() {
    @Override
    public void onRequest(Request request, HashMap<String, Object> extraData) {
        extraData.put("df_custom_key","custom_value");
    }

    @Override
    public void onResponse(Response response, HashMap<String, Object> extraData) throws IOException {
        extraData.put("df_custom_key","custom_value");
    }

    @Override
    public boolean onExceptionWithFilter(Exception e, HashMap<String, Object> extraData)  {
        extraData.put("df_custom_key","custom_value");
        return false;
    }
}
object : FTResourceInterceptor.ContentHandlerHelperEx() {

override fun onRequest(
    request: Request,
    extraData: HashMap<String, Any>
    ) {
        extraData["df_custom_key"] = "custom_value"
    }

    override fun onResponse(
        response: Response,
        extraData: HashMap<String, Any>
    ) {
        extraData["df_custom_key"] = "custom_value"
    }

    override fun onExceptionWithFilter(
        e: Exception,
        extraData: HashMap<String, Any>
    ): Boolean {
        extraData["df_custom_key"] = "custom_value"
        return false
    }
}   

네트워크 오류 필터링

로컬 네트워크 IOException 오류를 필터링할 수 있습니다. FTRUMConfig.setOkHttpResourceContentHandler(FTResourceInterceptor.ContentHandlerHelperEx)를 통해 설정하거나 사용자 정의 Resource를 사용할 수 있습니다.

new FTResourceInterceptor.ContentHandlerHelperEx() {
    //...

    /**
     * 네트워크 연결 과정에서 발생한 예외를 반환합니다.
     *
     * @param e         요청에서 발생한 IOException 데이터
     * @param extraData 추가 데이터
     * @return 로컬 네트워크 network_error 유형 오류를 필터링할지 여부입니다. true이면 필터링하여 수집하지 않음을 의미합니다.
     */
    @Override
    public boolean onExceptionWithFilter(Exception e, HashMap<String, Object> extraData) {
        if (e instanceof SocketTimeoutException) { //네트워크 시간 초과
            return true;
        }
        return super.onExceptionWithFilter(e, extraData);
    }
}
object : FTResourceInterceptor.ContentHandlerHelperEx() {
    //...

    /**
    * 네트워크 연결 과정에서 발생한 예외를 반환합니다.
    *
    * @param e         요청에서 발생한 IOException 데이터
    * @param extraData 추가 데이터
    * @return 로컬 네트워크 network_error 유형 오류를 필터링할지 여부입니다. true이면 필터링하여 수집하지 않음을 의미합니다.
    */
    override fun onExceptionWithFilter(e: Exception, extraData: HashMap<String, Any>): Boolean {
        return if (e is SocketTimeoutException) {
            true
        } else {
            super.onExceptionWithFilter(e, extraData)
        }
    }
}

Error

Crash/ANR 사용자 정의 필드

ft-sdk >= 1.7.5에서는 FTRUMConfig.setIssueDataProvider(FTIssueDataProvider)를 통해 자동 수집되는 Crash 및 ANR RUM Error에 사용자 정의 필드를 추가할 수 있습니다.

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

FTIssueDataProvider.provideAdditionalFields(FTIssueInfo)는 Error 구성 시 동기적으로 호출되며 동시에 실행될 수 있습니다. 구현은 스레드 안전성을 보장하고 I/O를 피하며 10ms 이내에 반환해야 합니다. Provider를 설정해도 Crash 또는 ANR 수집이 자동으로 활성화되지 않으며, 해당 수집 항목을 여전히 활성화해야 합니다.

  • 자동 수집되는 Java/Native Crash와 watchdog, native, ApplicationExitInfo ANR만 Provider를 트리거하며, 수동 Error, Network Error 및 WebView Error는 트리거하지 않습니다.
  • Native dump 또는 ApplicationExitInfo에서 복구된 데이터에서는 FTIssueInfo.isHistorical()가 true를 반환합니다.
  • 반환 값은 문자열, 불리언 및 유한 숫자 값을 지원하며 최대 50개 항목을 검사합니다. Key는 최대 100 UTF-8 바이트, 문자열 값은 최대 4096 UTF-8 바이트이며, 모든 필드의 합계는 25 KiB를 초과할 수 없습니다.
  • 유효하지 않거나 한도를 초과한 값, SDK 예약 필드, 그리고 error. 또는 error_로 시작하는 Key는 무시됩니다. 비즈니스 측은 필드 내용이 개인정보 보호 및 규정 준수 요구 사항을 충족하는지 직접 보장해야 합니다.

사용자 정의 TraceHeader

FTTraceConfig.setOkHttpTraceHeaderHandler(FTTraceInterceptor.HeaderHandler)를 통해 설정하거나 사용자 정의 Trace를 사용할 수 있으며, 아래는 w3c-traceContext를 예로 든 것입니다.

 new FTTraceInterceptor.HeaderHandler() {
        private String[] splits;

        @Override
        public HashMap<String, String> getTraceHeader(Request request) {
            HashMap<String, String> map = new HashMap<>();
            //header에서 사용자 정의 trace_id 가져오기
            String replaceTrace = request.header(CUSTOM_TRACE_HEADER);
            String headerString = FTTraceManager.get().
                    getTraceHeader(request.url().toString())
                    // header에서 propagation header 가져오기
                    .get(FTTraceHandler.W3C_TRACEPARENT_KEY); 
            splits = headerString.split("-");
            String originTraceId = splits[1];
            splits[1] = replaceTrace;
            map.put(FTTraceHandler.W3C_TRACEPARENT_KEY, headerString.replace(originTraceId, replaceTrace));
            return map;
        }

        @Override
        public String getSpanID() {
            if (splits != null) {
                return splits[2];
            }
            return null;
        }

        @Override
        public String getTraceID() {
            if (splits != null) {
                return splits[1];
            }
            return null;
        }
};
object : FTTraceInterceptor.HeaderHandler() {
    private var splits: List<String>? = null
    override fun getTraceHeader(request: Request): HashMap<String, String> {
        val map = HashMap<String, String>()

        // header에서 사용자 정의 trace_id 가져오기
        val replaceTrace = request.header(CUSTOM_TRACE_HEADER)
        val headerString = FTTraceManager.get()
            .getTraceHeader(request.url().toString())
            .get(FTTraceHandler.W3C_TRACEPARENT_KEY)

        splits = headerString?.split("-")
        val originTraceId = splits?.getOrNull(1)

        if (headerString != null && originTraceId != null && replaceTrace != null) {
            map[FTTraceHandler.W3C_TRACEPARENT_KEY] = 
                headerString.replace(originTraceId, replaceTrace)
        }

        return map
    }

    override fun getSpanID(): String? {
        return splits?.getOrNull(2)
    }

    override fun getTraceID(): String? {
        return splits?.getOrNull(1)
    }
}

사용자 정의 trace_id로 RUM Resource 연결

애플리케이션 측에 이미 사용자 정의 trace_id가 있는 경우(예: 요청 헤더 key가 custom_trace_id) SDK가 생성한 traceparent를 기반으로 trace_id를 업데이트하고, TraceContext.Simple을 통해 RUM Resource 연결에 사용할 trace_id를 지정할 수 있습니다.

new FTTraceInterceptor.HeaderHandler() {
    @Override
    public TraceContext getTraceContext(Request request) {
        HashMap<String, String> headers = FTTraceManager.get()
                .getTraceHeader(request.url().toString());

        // 요청 header에서 사용자 정의 trace_id 가져오기 (예: custom_trace_id)
        String customTraceId = request.header(CUSTOM_TRACE_HEADER);

        TraceContext.Simple sdkContext = TraceContext.Simple.fromTraceType(headers);
        if (customTraceId == null
                || customTraceId.length() == 0
                || sdkContext == null
                || sdkContext.getTraceId() == null) {
            return sdkContext;
        }

        String traceparent = headers.get(FTTraceHandler.W3C_TRACEPARENT_KEY);
        if (traceparent == null) {
            return sdkContext;
        }

        String newTraceparent = traceparent.replace(
                sdkContext.getTraceId(),
                customTraceId
        );

        // 요청에 주입되는 W3C trace header 업데이트
        headers.put(FTTraceHandler.W3C_TRACEPARENT_KEY, newTraceparent);

        // 선택 사항: 사용자 정의 비즈니스 header 유지
        headers.put(CUSTOM_TRACE_HEADER, customTraceId);

        // RUM Resource 연결에는 customTraceId를 사용하고, spanId는 계속 SDK가 생성한 spanId를 사용
        return new TraceContext.Simple(headers, customTraceId, sdkContext.getSpanId());
    }
};
object : FTTraceInterceptor.HeaderHandler() {
    override fun getTraceContext(request: Request): TraceContext? {
        val headers = FTTraceManager.get()
            .getTraceHeader(request.url().toString())

        // 요청 header에서 사용자 정의 trace_id 가져오기
        val customTraceId = request.header(CUSTOM_TRACE_HEADER)

        val sdkContext = TraceContext.Simple.fromTraceType(headers)
        val sdkTraceId = sdkContext?.traceId
        val sdkSpanId = sdkContext?.spanId
        if (customTraceId.isNullOrEmpty() || sdkTraceId.isNullOrEmpty()) {
            return sdkContext
        }

        val traceparent = headers[FTTraceHandler.W3C_TRACEPARENT_KEY] ?: return sdkContext
        val newTraceparent = traceparent.replace(sdkTraceId, customTraceId)

        // 요청에 주입되는 W3C trace header 업데이트
        headers[FTTraceHandler.W3C_TRACEPARENT_KEY] = newTraceparent

        // 선택 사항: 사용자 정의 비즈니스 header 유지
        headers[CUSTOM_TRACE_HEADER] = customTraceId

        // RUM Resource 연결에는 customTraceId를 사용하고, spanId는 계속 SDK가 생성한 spanId를 사용
        return TraceContext.Simple(headers, customTraceId, sdkSpanId)
    }
}

참고: W3C trace_id는 32자리 16진수 문자열이어야 하며, 모두 0이어서는 안 됩니다.

문서 평가

이 페이지가 도움이 되었나요?