Logging (SDK Layer)#

Combine Driver and SDK follow-up tags when configuring in AppDelegate.application(_:didFinishLaunchingWithOptions:):

HaapiLogger.followUpTags = DriverFollowUpTag.allCases + SdkFollowUpTag.allCases
HaapiLogger.setLogType(LogType.info)

SDK follow-up tags include HAAPI_SDK_FLOW, HAAPI_SDK_HTTP, HAAPI_SDK_MAPPING, and HAAPI_SDK_OAUTH. Adding only DriverFollowUpTag.allCases silently suppresses every SDK-emitted record — a common cause of “the SDK isn’t logging anything”.

Configure in Application.onCreate. There is no SDK-specific tag configuration: once the logger is enabled, SDK records flow through alongside Driver records, and you filter them at the sink or by LogCat tag prefix. HaapiLogger.LogLevel and enabled are the only emission gates — tags are labels attached to each record.

class ClientApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        HaapiLogger.enabled = true
        HaapiLogger.setLevel(HaapiLogger.LogLevel.INFO)
    }
}

SDK tag prefixes include HAAPI_SDK_FLOW, HAAPI_SDK_HTTP, HAAPI_SDK_MAPPING, HAAPI_SDK_OAUTH, and HAAPI_SDK_STORAGE. Filter LogCat with logcat -s 'HAAPI_SDK_*:V' (or any prefix subset) to focus on the SDK Layer.

getRNLogger is a singleton factory — call it once with the desired configuration; subsequent calls return the same instance. The configuration is forwarded to the native HaapiLogger atomically on first call. The bridge configures both native loggers so iOS tag emission is enabled in addition to the Android level/enabled gates; you do not configure followUpTags from JS.

import { getRNLogger, RNLogLevel } from 'identityserver.haapi.reactnative.sdk'

const logger = getRNLogger({
    logLevel: RNLogLevel.Info,           // Info | Debug | Trace | Warn | Error
    isSensitiveValueMasked: true,         // keep true outside local development
})

// Pass into the accessor factories so SDK records flow through this logger.
const accessor = await initializeForHaapi(haapiConfig, logger)

Records from both layers (iOS and Android) reach the JS side through a single event channel. Custom sinks (see below) receive every record regardless of which native layer emitted it; tag prefixes (HAAPI_SDK_*, HAAPI_DRIVER_*) survive the bridge so you can filter by layer in the sink.

final class MyLogSink: LogSink {
    func log(
        level: LogType,
        tag: FollowUpTag,
        message: String,
        file: String,
        line: Int
    ) {
        // Forward to the host app's crash reporter or analytics pipeline.
        // Keep this fast — sinks fire on the calling thread.
    }
}

HaapiLogger.add(sink: MyLogSink())

class MyLogSink : LogSink {
    override fun log(
        level: HaapiLogger.LogLevel,
        tag: String,
        message: String,
        file: String,
        line: Int
    ) {
        // Forward to the host app's crash reporter or analytics pipeline.
        // Keep this fast — sinks fire on the calling thread.
    }
}

HaapiLogger.addSink(MyLogSink())

Register an RNLogSinkHandler on the singleton logger. Each native log record is delivered as an RNLogEvent through the bridge — the sink receives the event with its level, tag, message, file, and line:

import { getRNLogger, RNLogLevel } from 'identityserver.haapi.reactnative.sdk'
import type { RNLogEvent } from 'identityserver.haapi.reactnative.sdk'

const logger = getRNLogger({ logLevel: RNLogLevel.Info, isSensitiveValueMasked: true })

const sinkHandle = logger.addSink((event: RNLogEvent) => {
    // Forward to the host app's crash reporter or analytics pipeline.
    // event.level (RNLogLevel), event.tag, event.message, event.file, event.line.
    // Keep this fast — sinks fire on the JS thread synchronously.
})

// Later: sinkHandle.remove() to detach the sink.

Unlike iOS / Android where sinks live on the native side, RN sinks run on the JS thread — keep them non-blocking. For heavy work, post to a worker or queue, then return.