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

package/README.md

@@ -112,10 +112,14 @@ Legacy flat replay keys are still supported in per-session overrides for backwar
 
 ## Replay Authentication Headers
 
-Replay uploads include both headers from the configured `apiKey`:
+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
 

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

@@ -103,6 +103,7 @@ class PosthogReactNativeSessionReplayModule(
             }
 
           PostHogAndroid.setup(context, config)
+          ensureReplayClientsAuthHeaders(apiKey)
           setIdentify(config.cachePreferences, distinctId, anonymousId)
         } catch (e: Throwable) {
           logError("start", e)
@@ -128,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 {
@@ -207,12 +209,67 @@ class PosthogReactNativeSessionReplayModule(
               .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,

package/ios/PosthogReactNativeSessionReplay.swift

@@ -1,14 +1,129 @@
 import Foundation
 import PostHog
 
-private func isPosthogHost(_ value: String) -> Bool {
-    let normalizedHost: String
+private func normalizedHost(from value: String) -> String {
     if let url = URL(string: value), let host = url.host {
-        normalizedHost = host.lowercased()
-    } else {
-        normalizedHost = value.lowercased()
+        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")
 }
 
@@ -56,11 +171,25 @@ class PosthogReactNativeSessionReplay: NSObject {
         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, *) {
@@ -88,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 ?? ""
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plushanalytics/react-native-session-replay",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "React Native SDK for Plush Analytics events + session replay ingestion.",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",