@plushanalytics/react-native-session-replay 3.0.0 → 3.0.4

package/README.md

@@ -41,7 +41,17 @@ export default function App(): JSX.Element {
       config={{
         apiKey: "plsh_live_...",
         projectId: "mobile_app",
-        context: { platform: "react-native" }
+        context: { platform: "react-native" },
+        sessionReplayConfig: {
+          enabled: true,
+          masking: {
+            textInputs: true,
+            images: true,
+            sandboxedViews: true,
+          },
+          captureNetworkTelemetry: true,
+          throttleDelayMs: 1000,
+        },
       }}
     >
       <CheckoutButton />
@@ -57,13 +67,60 @@ import { createPlushAnalyticsClient } from "@plushanalytics/react-native-session
 
 const analytics = createPlushAnalyticsClient({
   apiKey: "plsh_live_...",
-  projectId: "mobile_app"
+  projectId: "mobile_app",
+  sessionReplayConfig: {
+    enabled: true,
+    masking: {
+      textInputs: true,
+      images: true,
+      sandboxedViews: true,
+    },
+  },
 });
 
 await analytics.track("app_opened");
 await analytics.shutdown();
 ```
 
+## Session Replay Config
+
+Replay behavior is configured locally in the SDK. It does not depend on backend remote config.
+
+- `config.sessionReplayConfig.enabled`: defaults to `true`
+- `config.sessionReplayConfig.masking.textInputs`: defaults to `true`
+- `config.sessionReplayConfig.masking.images`: defaults to `true`
+- `config.sessionReplayConfig.masking.sandboxedViews`: defaults to `true`
+- `config.sessionReplayConfig.captureLog`: defaults to `true`
+- `config.sessionReplayConfig.captureNetworkTelemetry`: defaults to `true`
+- `config.sessionReplayConfig.throttleDelayMs`: defaults to `1000`
+
+Per-session overrides are supported via `startSessionRecording({ replayConfig })` / `startReplay({ replayConfig })`.
+
+```ts
+await analytics.startReplay({
+  replayConfig: {
+    enabled: true,
+    masking: {
+      images: false,
+    },
+  },
+});
+```
+
+Legacy flat replay keys are still supported in per-session overrides for backward compatibility:
+`maskAllTextInputs`, `maskAllImages`, `maskAllSandboxedViews`.
+
+## Replay Authentication Headers
+
+Replay uploads include these headers from the configured `apiKey`:
+
+- `x-api-key`
+- `x-plush-api-key`
+- `x-plushanalytics-key`
+- `Authorization: Bearer <apiKey>`
+
+Headers are injected natively on outgoing replay batch requests so they remain present even if underlying SDK session defaults are rewritten.
+
 ## Common Usage
 
 ```ts

package/android/src/main/java/com/posthogreactnativesessionreplay/PosthogReactNativeSessionReplayModule.kt

@@ -15,7 +15,10 @@ import com.posthog.internal.PostHogPreferences
 import com.posthog.internal.PostHogPreferences.Companion.ANONYMOUS_ID
 import com.posthog.internal.PostHogPreferences.Companion.DISTINCT_ID
 import com.posthog.internal.PostHogSessionManager
+import java.net.URI
 import java.util.UUID
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
 
 class PosthogReactNativeSessionReplayModule(
   reactContext: ReactApplicationContext,
@@ -39,13 +42,24 @@ class PosthogReactNativeSessionReplayModule(
           val context = this.reactApplicationContext
           val apiKey = runCatching { sdkOptions.getString("apiKey") }.getOrNull() ?: ""
           val host = runCatching { sdkOptions.getString("host") }.getOrNull() ?: PostHogConfig.DEFAULT_HOST
+          if (isPosthogHost(host)) {
+            val message = "Blocked replay host '$host' because posthog.com hosts are not allowed."
+            logError("start", IllegalArgumentException(message))
+            promise.reject("PLUSH_BLOCKED_REPLAY_HOST", message)
+            return@Runnable
+          }
+
           val debugValue = runCatching { sdkOptions.getBoolean("debug") }.getOrNull() ?: false
 
-          val maskAllTextInputs = runCatching { sdkReplayConfig.getBoolean("maskAllTextInputs") }.getOrNull() ?: DEFAULT_MASK_ALL_TEXT_INPUTS
-          val maskAllImages = runCatching { sdkReplayConfig.getBoolean("maskAllImages") }.getOrNull() ?: DEFAULT_MASK_ALL_IMAGES
-          val captureLog = runCatching { sdkReplayConfig.getBoolean("captureLog") }.getOrNull() ?: DEFAULT_CAPTURE_LOG
+          val maskAllTextInputs =
+            runCatching { sdkReplayConfig.getBoolean("maskAllTextInputs") }.getOrNull()
+              ?: DEFAULT_MASK_ALL_TEXT_INPUTS
+          val maskAllImages =
+            runCatching { sdkReplayConfig.getBoolean("maskAllImages") }.getOrNull() ?: DEFAULT_MASK_ALL_IMAGES
+          val captureLog =
+            runCatching { sdkReplayConfig.getBoolean("captureLog") }.getOrNull() ?: DEFAULT_CAPTURE_LOG
 
-          // read throttleDelayMs and use androidDebouncerDelayMs as a fallback for back compatibility
+          // Read throttleDelayMs and use androidDebouncerDelayMs as a fallback for back compatibility.
           val throttleDelayMs =
             if (sdkReplayConfig.hasKey("throttleDelayMs")) {
               sdkReplayConfig.getInt("throttleDelayMs")
@@ -56,24 +70,10 @@ class PosthogReactNativeSessionReplayModule(
             }
 
           val endpoint = decideReplayConfig.getString("endpoint")
-
-          val distinctId =
-            try {
-              sdkOptions.getString("distinctId") ?: ""
-            } catch (e: Throwable) {
-              logError("parse distinctId", e)
-              ""
-            }
-          val anonymousId =
-            try {
-              sdkOptions.getString("anonymousId") ?: ""
-            } catch (e: Throwable) {
-              logError("parse anonymousId", e)
-              ""
-            }
-          val theSdkVersion = runCatching { sdkOptions.getString("sdkVersion") }.getOrNull()
-
-          val theFlushAt = runCatching { sdkOptions.getInt("flushAt") }.getOrNull() ?: DEFAULT_FLUSH_AT
+          val distinctId = runCatching { sdkOptions.getString("distinctId") }.getOrNull() ?: ""
+          val anonymousId = runCatching { sdkOptions.getString("anonymousId") }.getOrNull() ?: ""
+          val sdkVersion = runCatching { sdkOptions.getString("sdkVersion") }.getOrNull()
+          val flushAt = runCatching { sdkOptions.getInt("flushAt") }.getOrNull() ?: DEFAULT_FLUSH_AT
 
           val config =
             PostHogAndroidConfig(apiKey, host).apply {
@@ -81,25 +81,29 @@ class PosthogReactNativeSessionReplayModule(
               captureDeepLinks = false
               captureApplicationLifecycleEvents = false
               captureScreenViews = false
-              flushAt = theFlushAt
+              preloadFeatureFlags = false
+              remoteConfig = false
+              this.flushAt = flushAt
               sessionReplay = true
               sessionReplayConfig.screenshot = true
               sessionReplayConfig.captureLogcat = captureLog
               sessionReplayConfig.throttleDelayMs = throttleDelayMs.toLong()
               sessionReplayConfig.maskAllImages = maskAllImages
               sessionReplayConfig.maskAllTextInputs = maskAllTextInputs
+              httpClient = buildApiKeyClient(apiKey)
 
               if (!endpoint.isNullOrEmpty()) {
                 snapshotEndpoint = endpoint
               }
 
-              if (!theSdkVersion.isNullOrEmpty()) {
+              if (!sdkVersion.isNullOrEmpty()) {
                 sdkName = "posthog-react-native"
-                sdkVersion = theSdkVersion
+                this.sdkVersion = sdkVersion
               }
             }
-          PostHogAndroid.setup(context, config)
 
+          PostHogAndroid.setup(context, config)
+          ensureReplayClientsAuthHeaders(apiKey)
           setIdentify(config.cachePreferences, distinctId, anonymousId)
         } catch (e: Throwable) {
           logError("start", e)
@@ -108,7 +112,7 @@ class PosthogReactNativeSessionReplayModule(
         }
       }
 
-    // forces the SDK to be initialized on the main thread
+    // Force the SDK to be initialized on the main thread.
     if (UiThreadUtil.isOnUiThread()) {
       initRunnable.run()
     } else {
@@ -125,6 +129,7 @@ class PosthogReactNativeSessionReplayModule(
       val uuid = UUID.fromString(sessionId)
       PostHogSessionManager.setSessionId(uuid)
       PostHog.startSession()
+      PostHog.startSessionReplay(false)
     } catch (e: Throwable) {
       logError("startSession", e)
     } finally {
@@ -153,6 +158,17 @@ class PosthogReactNativeSessionReplayModule(
     }
   }
 
+  @ReactMethod
+  fun flush(promise: Promise) {
+    try {
+      PostHog.flush()
+    } catch (e: Throwable) {
+      logError("flush", e)
+    } finally {
+      promise.resolve(null)
+    }
+  }
+
   @ReactMethod
   fun identify(
     distinctId: String,
@@ -183,6 +199,77 @@ class PosthogReactNativeSessionReplayModule(
     }
   }
 
+  private fun buildApiKeyClient(apiKey: String): OkHttpClient {
+    return OkHttpClient.Builder()
+      .addInterceptor(
+        Interceptor { chain ->
+          val original = chain.request()
+          val updated =
+            original
+              .newBuilder()
+              .header("x-api-key", apiKey)
+              .header("x-plush-api-key", apiKey)
+              .header("x-plushanalytics-key", apiKey)
+              .header("authorization", "Bearer $apiKey")
+              .build()
+          chain.proceed(updated)
+        }
+      ).build()
+  }
+
+  private fun ensureReplayClientsAuthHeaders(apiKey: String) {
+    try {
+      val sharedMethod = PostHog::class.java.getDeclaredMethod("access\$getShared\$cp")
+      sharedMethod.isAccessible = true
+      val sharedInstance = sharedMethod.invoke(null) ?: return
+
+      patchQueueApiClient(sharedInstance, "queue", apiKey)
+      patchQueueApiClient(sharedInstance, "replayQueue", apiKey)
+    } catch (e: Throwable) {
+      logError("ensureReplayClientsAuthHeaders", e)
+    }
+  }
+
+  private fun patchQueueApiClient(
+    sharedInstance: Any,
+    queueFieldName: String,
+    apiKey: String,
+  ) {
+    try {
+      val queueField = sharedInstance.javaClass.getDeclaredField(queueFieldName)
+      queueField.isAccessible = true
+      val queue = queueField.get(sharedInstance) ?: return
+
+      val apiField = queue.javaClass.getDeclaredField("api")
+      apiField.isAccessible = true
+      val api = apiField.get(queue) ?: return
+
+      val clientField = api.javaClass.getDeclaredField("client")
+      clientField.isAccessible = true
+      val originalClient = clientField.get(api) as? OkHttpClient ?: return
+
+      val patchedClient =
+        originalClient.newBuilder()
+          .addInterceptor(
+            Interceptor { chain ->
+              val updatedRequest =
+                chain.request()
+                  .newBuilder()
+                  .header("x-api-key", apiKey)
+                  .header("x-plush-api-key", apiKey)
+                  .header("x-plushanalytics-key", apiKey)
+                  .header("authorization", "Bearer $apiKey")
+                  .build()
+              chain.proceed(updatedRequest)
+            }
+          ).build()
+
+      clientField.set(api, patchedClient)
+    } catch (e: Throwable) {
+      logError("patchQueueApiClient", e)
+    }
+  }
+
   private fun logError(
     method: String,
     error: Throwable,
@@ -190,6 +277,17 @@ class PosthogReactNativeSessionReplayModule(
     Log.println(Log.ERROR, POSTHOG_TAG, "Method $method, error: $error")
   }
 
+  private fun isPosthogHost(value: String): Boolean {
+    val hostName =
+      try {
+        URI(value).host?.lowercase() ?: value.lowercase()
+      } catch (_: Throwable) {
+        value.lowercase()
+      }
+
+    return hostName == "posthog.com" || hostName.endsWith(".posthog.com")
+  }
+
   companion object {
     const val NAME = "PosthogReactNativeSessionReplay"
     const val POSTHOG_TAG = "PostHog"

package/ios/PosthogReactNativeSessionReplay.mm

@@ -19,6 +19,9 @@ RCT_EXTERN_METHOD(isEnabled:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(endSession:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(flush:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(identify:(NSString)distinctId
                   withAnonymousId:(NSString)anonymousId
                   withResolver:(RCTPromiseResolveBlock)resolve

package/ios/PosthogReactNativeSessionReplay.swift

@@ -1,8 +1,134 @@
+import Foundation
 import PostHog
 
-// Meant for internally logging PostHog related things
-private func hedgeLog(_ message: String) {
-    print("[PostHog] \(message)")
+private func normalizedHost(from value: String) -> String {
+    if let url = URL(string: value), let host = url.host {
+        return host.lowercased()
+    }
+    return value.lowercased()
+}
+
+private final class PlushReplayAuthURLProtocol: URLProtocol, URLSessionDataDelegate {
+    private static let handledKey = "PlushReplayAuthHandled"
+    private static var apiKey: String = ""
+    private static var allowedHost: String = ""
+    private static var allowedPathSuffixes: [String] = ["/v1/events/batch", "/batch"]
+
+    private var outboundDataTask: URLSessionDataTask?
+    private var outboundSession: URLSession?
+
+    static func configure(apiKey: String, host: String, snapshotPath: String) {
+        Self.apiKey = apiKey
+        Self.allowedHost = normalizedHost(from: host)
+
+        let trimmedPath = snapshotPath.trimmingCharacters(in: .whitespacesAndNewlines)
+        let normalizedPath: String
+        if trimmedPath.isEmpty {
+            normalizedPath = "/v1/events/batch"
+        } else {
+            normalizedPath = trimmedPath.hasPrefix("/") ? trimmedPath : "/\(trimmedPath)"
+        }
+
+        var suffixes = ["/v1/events/batch", "/batch"]
+        if !suffixes.contains(normalizedPath) {
+            suffixes.insert(normalizedPath, at: 0)
+        }
+        Self.allowedPathSuffixes = suffixes
+    }
+
+    override class func canInit(with request: URLRequest) -> Bool {
+        guard URLProtocol.property(forKey: handledKey, in: request) == nil else {
+            return false
+        }
+
+        guard let url = request.url else {
+            return false
+        }
+
+        let requestHost = url.host?.lowercased() ?? ""
+        if !Self.allowedHost.isEmpty && requestHost != Self.allowedHost {
+            return false
+        }
+
+        return Self.allowedPathSuffixes.contains { suffix in
+            url.path.hasSuffix(suffix)
+        }
+    }
+
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let mutableRequest = (request as NSURLRequest).mutableCopy() as? NSMutableURLRequest else {
+            client?.urlProtocol(self, didFailWithError: NSError(domain: "PlushReplayAuthURLProtocol", code: -1))
+            return
+        }
+
+        URLProtocol.setProperty(true, forKey: Self.handledKey, in: mutableRequest)
+
+        if !Self.apiKey.isEmpty {
+            mutableRequest.setValue(Self.apiKey, forHTTPHeaderField: "x-api-key")
+            mutableRequest.setValue(Self.apiKey, forHTTPHeaderField: "x-plush-api-key")
+            mutableRequest.setValue(Self.apiKey, forHTTPHeaderField: "x-plushanalytics-key")
+            mutableRequest.setValue("Bearer \(Self.apiKey)", forHTTPHeaderField: "authorization")
+        }
+
+        let outboundRequest = mutableRequest as URLRequest
+        let configuration = URLSessionConfiguration.default
+        configuration.protocolClasses = []
+
+        outboundSession = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        outboundDataTask = outboundSession?.dataTask(with: outboundRequest)
+        outboundDataTask?.resume()
+    }
+
+    override func stopLoading() {
+        outboundDataTask?.cancel()
+        outboundDataTask = nil
+        outboundSession?.invalidateAndCancel()
+        outboundSession = nil
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        dataTask: URLSessionDataTask,
+        didReceive response: URLResponse,
+        completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+    ) {
+        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+        completionHandler(.allow)
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        dataTask: URLSessionDataTask,
+        didReceive data: Data
+    ) {
+        client?.urlProtocol(self, didLoad: data)
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        task: URLSessionTask,
+        didCompleteWithError error: Error?
+    ) {
+        if let error {
+            client?.urlProtocol(self, didFailWithError: error)
+            return
+        }
+
+        client?.urlProtocolDidFinishLoading(self)
+    }
+}
+
+private func isPosthogHost(_ value: String) -> Bool {
+    let normalizedHost = normalizedHost(from: value)
+    return normalizedHost == "posthog.com" || normalizedHost.hasSuffix(".posthog.com")
+}
+
+private func logNativeError(_ message: String) {
+    NSLog("[Plush][RNReplay] %@", message)
 }
 
 @objc(PosthogReactNativeSessionReplay)
@@ -11,13 +137,15 @@ class PosthogReactNativeSessionReplay: NSObject {
 
     @objc(start:withSdkOptions:withSdkReplayConfig:withDecideReplayConfig:withResolver:withRejecter:)
     func start(
-        sessionId: String, sdkOptions: [String: Any], sdkReplayConfig: [String: Any],
-        decideReplayConfig: [String: Any], resolve: RCTPromiseResolveBlock,
-        reject _: RCTPromiseRejectBlock
+        sessionId: String,
+        sdkOptions: [String: Any],
+        sdkReplayConfig: [String: Any],
+        decideReplayConfig: [String: Any],
+        resolve: RCTPromiseResolveBlock,
+        reject: RCTPromiseRejectBlock
     ) {
-        // we've seen cases where distinctId and anonymousId are not strings, so we need to check and convert them
         guard let sessionIdStr = sessionId as? String else {
-            hedgeLog("Invalid sessionId provided: \(sessionId). Expected a string.")
+            logNativeError("Invalid sessionId provided. Expected a string.")
             resolve(nil)
             return
         }
@@ -26,15 +154,44 @@ class PosthogReactNativeSessionReplay: NSObject {
         let host = sdkOptions["host"] as? String ?? PostHogConfig.defaultHost
         let debug = sdkOptions["debug"] as? Bool ?? false
 
+        if isPosthogHost(host) {
+            let message = "Blocked replay host '\(host)' because posthog.com hosts are not allowed."
+            reject("PLUSH_BLOCKED_REPLAY_HOST", message, nil)
+            return
+        }
+
         PostHogSessionManager.shared.setSessionId(sessionIdStr)
 
         let config = PostHogConfig(apiKey: apiKey, host: host)
         config.sessionReplay = true
         config.captureApplicationLifecycleEvents = false
         config.captureScreenViews = false
+        config.preloadFeatureFlags = false
+        config.remoteConfig = false
         config.debug = debug
         config.sessionReplayConfig.screenshotMode = true
 
+        let endpoint = decideReplayConfig["endpoint"] as? String ?? ""
+        if !endpoint.isEmpty {
+            config.snapshotEndpoint = endpoint
+        }
+
+        PlushReplayAuthURLProtocol.configure(
+            apiKey: apiKey,
+            host: host,
+            snapshotPath: config.snapshotEndpoint
+        )
+
+        let sessionConfiguration = URLSessionConfiguration.default
+        sessionConfiguration.httpAdditionalHeaders = [
+            "x-api-key": apiKey,
+            "x-plush-api-key": apiKey,
+            "x-plushanalytics-key": apiKey,
+            "authorization": "Bearer \(apiKey)",
+        ]
+        sessionConfiguration.protocolClasses = [PlushReplayAuthURLProtocol.self]
+        config.urlSessionConfiguration = sessionConfiguration
+
         if #available(iOS 15.0, *) {
             config.surveys = false
         }
@@ -48,7 +205,7 @@ class PosthogReactNativeSessionReplay: NSObject {
         let maskAllSandboxedViews = sdkReplayConfig["maskAllSandboxedViews"] as? Bool ?? true
         config.sessionReplayConfig.maskAllSandboxedViews = maskAllSandboxedViews
 
-        // read throttleDelayMs and use iOSdebouncerDelayMs as a fallback for back compatibility
+        // Read throttleDelayMs and use iOSdebouncerDelayMs as a fallback for back compatibility.
         let throttleDelayMs =
             (sdkReplayConfig["throttleDelayMs"] as? Int)
                 ?? (sdkReplayConfig["iOSdebouncerDelayMs"] as? Int)
@@ -60,11 +217,6 @@ class PosthogReactNativeSessionReplay: NSObject {
         let captureNetworkTelemetry = sdkReplayConfig["captureNetworkTelemetry"] as? Bool ?? true
         config.sessionReplayConfig.captureNetworkTelemetry = captureNetworkTelemetry
 
-        let endpoint = decideReplayConfig["endpoint"] as? String ?? ""
-        if !endpoint.isEmpty {
-            config.snapshotEndpoint = endpoint
-        }
-
         let distinctId = sdkOptions["distinctId"] as? String ?? ""
         let anonymousId = sdkOptions["anonymousId"] as? String ?? ""
 
@@ -79,30 +231,30 @@ class PosthogReactNativeSessionReplay: NSObject {
         }
 
         PostHogSDK.shared.setup(config)
-
         self.config = config
 
         guard let storageManager = self.config?.storageManager else {
-            hedgeLog("Storage manager is not available in the config.")
+            logNativeError("Storage manager is not available in the config.")
             resolve(nil)
             return
         }
 
         setIdentify(storageManager, distinctId: distinctId, anonymousId: anonymousId)
-
         resolve(nil)
     }
 
     @objc(startSession:withResolver:withRejecter:)
     func startSession(
-        sessionId: String, resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock
+        sessionId: String,
+        resolve: RCTPromiseResolveBlock,
+        reject _: RCTPromiseRejectBlock
     ) {
-        // we've seen cases where distinctId and anonymousId are not strings, so we need to check and convert them
         guard let sessionIdStr = sessionId as? String else {
-            hedgeLog("Invalid sessionId provided: \(sessionId). Expected a string.")
+            logNativeError("Invalid sessionId provided. Expected a string.")
             resolve(nil)
             return
         }
+
         PostHogSessionManager.shared.setSessionId(sessionIdStr)
         PostHogSDK.shared.startSession()
         resolve(nil)
@@ -110,8 +262,7 @@ class PosthogReactNativeSessionReplay: NSObject {
 
     @objc(isEnabled:withRejecter:)
     func isEnabled(resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
-        let isEnabled = PostHogSDK.shared.isSessionReplayActive()
-        resolve(isEnabled)
+        resolve(PostHogSDK.shared.isSessionReplayActive())
     }
 
     @objc(endSession:withRejecter:)
@@ -120,33 +271,33 @@ class PosthogReactNativeSessionReplay: NSObject {
         resolve(nil)
     }
 
+    @objc(flush:withRejecter:)
+    func flush(resolve: RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        PostHogSDK.shared.flush()
+        resolve(nil)
+    }
+
     @objc(identify:withAnonymousId:withResolver:withRejecter:)
     func identify(
-        distinctId: String, anonymousId: String, resolve: RCTPromiseResolveBlock,
+        distinctId: String,
+        anonymousId: String,
+        resolve: RCTPromiseResolveBlock,
         reject _: RCTPromiseRejectBlock
     ) {
-        // we've seen cases where distinctId and anonymousId are not strings, so we need to check and convert them
-        guard let distinctIdStr = distinctId as? String,
-              let anonymousIdStr = anonymousId as? String
-        else {
-            hedgeLog(
-                "Invalid distinctId: \(distinctId) or anonymousId: \(anonymousId) provided. Expected strings."
-            )
-            resolve(nil)
-            return
-        }
         guard let storageManager = config?.storageManager else {
-            hedgeLog("Storage manager is not available in the config.")
+            logNativeError("Storage manager is not available in the config.")
             resolve(nil)
             return
         }
-        setIdentify(storageManager, distinctId: distinctIdStr, anonymousId: anonymousIdStr)
 
+        setIdentify(storageManager, distinctId: distinctId, anonymousId: anonymousId)
         resolve(nil)
     }
 
     private func setIdentify(
-        _ storageManager: PostHogStorageManager, distinctId: String, anonymousId: String
+        _ storageManager: PostHogStorageManager,
+        distinctId: String,
+        anonymousId: String
     ) {
         if !anonymousId.isEmpty {
             storageManager.setAnonymousId(anonymousId)