@react-native-firebase/perf 26.3.3 → 27.0.0

package/ios/RNFBPerf/RNFBPerfHandleRegistry.m

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "RNFBPerfHandleRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+#if __has_include(<RNFBPerf/RNFBPerf-Swift.h>)
+#import <RNFBPerf/RNFBPerf-Swift.h>
+#elif __has_include("RNFBPerf-Swift.h")
+#import "RNFBPerf-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBPerfHandleRegistryStorage Swift interface not found"
+#endif
+
+@interface RNFBPerfHandleRegistry ()
+@property(nonatomic, strong) RNFBPerfHandleRegistryStorage *storage;
+@end
+
+@implementation RNFBPerfHandleRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _storage = [[RNFBPerfHandleRegistryStorage alloc] init];
+  }
+  return self;
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  if (![self.storage putOrDiscard:key value:value]) {
+    if (error != nil) {
+      NSString *message = [NSString stringWithFormat:@"Handle id already registered: %@", key];
+      *error = [NSError errorWithDomain:RNFBHandleMapErrorDomain
+                                   code:RNFBHandleMapErrorCollision
+                               userInfo:@{NSLocalizedDescriptionKey : message}];
+    }
+    return NO;
+  }
+  return YES;
+}
+
+- (BOOL)putOrDiscard:(id)key value:(id)value {
+  return [self.storage putOrDiscard:key value:value];
+}
+
+- (id)putReplacing:(id)key value:(id)value {
+  return [self.storage putReplacing:key value:value];
+}
+
+- (id)get:(id)key {
+  return [self.storage get:key];
+}
+
+- (id)take:(id)key {
+  return [self.storage take:key];
+}
+
+- (id)takeIf:(id)key when:(BOOL (^)(id))condition {
+  return [self.storage takeIf:key when:condition];
+}
+
+- (NSArray *)takeAll {
+  return [self.storage takeAll];
+}
+
+@end

package/ios/RNFBPerf/RNFBPerfHandleRegistryStorage.swift

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+#if canImport(RNFBApp)
+import RNFBApp
+#endif
+
+/// Perf registry storage. Composes `RNFBHandleMapStorage`; `putOrDiscard` is first-wins
+/// (`putIfAbsent`). Unique `put` collision errors stay on the ObjC façade.
+@objc(RNFBPerfHandleRegistryStorage)
+public final class RNFBPerfHandleRegistryStorage: NSObject {
+  private let storage = RNFBHandleMapStorage()
+
+  @objc(putOrDiscard:value:)
+  public func putOrDiscard(_ key: AnyObject, value: AnyObject) -> Bool {
+    storage.putIfAbsent(key, value: value)
+  }
+
+  @objc(putReplacing:value:)
+  public func putReplacing(_ key: AnyObject, value: AnyObject) -> AnyObject? {
+    storage.putReplacing(key, value: value)
+  }
+
+  @objc(get:)
+  public func get(_ key: AnyObject) -> AnyObject? {
+    storage.get(key)
+  }
+
+  @objc(take:)
+  public func take(_ key: AnyObject) -> AnyObject? {
+    storage.take(key)
+  }
+
+  @objc(takeIf:when:)
+  public func takeIf(_ key: AnyObject, when condition: (AnyObject) -> Bool) -> AnyObject? {
+    storage.takeIf(key, when: condition)
+  }
+
+  @objc
+  public func takeAll() -> [AnyObject] {
+    storage.takeAll()
+  }
+}

package/ios/RNFBPerf/RNFBPerfHelper.h

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+#import "RNFBPerfHandleRegistry.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Plain Objective-C helper (see docs/ios-spm.mdx and
+// okf-bundle/ios-spm-native-imports.md) that owns every call touching
+// Firebase Performance / metric types and the Swift stop appliers /
+// HTTP method mapper for RNFBPerfModule. This keeps RNFBPerfModule.mm free
+// of Firebase imports and `*-Swift.h`: under SPM an Objective-C++ (.mm)
+// TurboModule cannot `@import` Firebase (or parse a Swift-generated header
+// that uses module imports) when C++ modules are disabled (required by
+// React Native's JSI headers). On Mac Catalyst + SPM the upstream wrap
+// target omits the real module — see RNFBPerfHelper.m stubs and
+// https://github.com/firebase/firebase-ios-sdk/pull/16468.
+@interface RNFBPerfHelper : NSObject
+
++ (NSDictionary *)constantsDictionary;
+
++ (void)setPerformanceCollectionEnabled:(BOOL)enabled
+                                resolve:(RCTPromiseResolveBlock)resolve
+                                 reject:(RCTPromiseRejectBlock)reject;
+
++ (void)setInstrumentationEnabled:(BOOL)enabled
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject;
+
++ (void)startTraceWithId:(NSNumber *)traceId
+              identifier:(NSString *)identifier
+              inRegistry:(RNFBPerfHandleRegistry *)registry;
+
++ (void)stopTraceWithId:(NSNumber *)traceId
+                metrics:(nullable NSDictionary *)metrics
+             attributes:(nullable NSDictionary *)attributes
+             inRegistry:(RNFBPerfHandleRegistry *)registry;
+
++ (void)startHttpMetricWithId:(NSNumber *)metricId
+                          url:(NSString *)url
+                   httpMethod:(NSString *)httpMethod
+                   inRegistry:(RNFBPerfHandleRegistry *)registry;
+
++ (void)stopHttpMetricWithId:(NSNumber *)metricId
+                  attributes:(nullable NSDictionary *)attributes
+            httpResponseCode:(nullable NSNumber *)httpResponseCode
+          requestPayloadSize:(nullable NSNumber *)requestPayloadSize
+         responsePayloadSize:(nullable NSNumber *)responsePayloadSize
+         responseContentType:(nullable NSString *)responseContentType
+                  inRegistry:(RNFBPerfHandleRegistry *)registry;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBPerf/RNFBPerfHelper.m

@@ -0,0 +1,219 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#if __has_include(<Firebase/Firebase.h>)
+#import <Firebase/Firebase.h>
+#define RNFB_PERF_SDK_AVAILABLE 1
+#elif __has_include(<FirebasePerformance/FirebasePerformance.h>)
+#import <FirebaseCore/FirebaseCore.h>
+#import <FirebasePerformance/FirebasePerformance.h>
+#define RNFB_PERF_SDK_AVAILABLE 1
+#elif !TARGET_OS_MACCATALYST
+// SPM on iOS/tvOS when product headers are not visible as includes: use
+// @import in this plain .m (needs -fmodules only). Do not move @import into
+// the .mm TurboModule (that would require -fcxx-modules).
+@import FirebaseCore;
+@import FirebasePerformance;
+#define RNFB_PERF_SDK_AVAILABLE 1
+#else
+// Product headers/modules absent under Mac Catalyst + SPM. Upstream
+// Package.swift omits .macCatalyst from FirebasePerformanceTarget; CocoaPods
+// historically masked this via the Firebase umbrella. Temporary stubs pending
+// https://github.com/firebase/firebase-ios-sdk/pull/16468 (or permanent if
+// upstream declines). When that PR lands, drop the TARGET_OS_MACCATALYST
+// gate and use the @import path on Catalyst too.
+#define RNFB_PERF_SDK_AVAILABLE 0
+#endif
+
+#if __has_include(<RNFBPerf/RNFBPerf-Swift.h>)
+#import <RNFBPerf/RNFBPerf-Swift.h>
+#elif __has_include("RNFBPerf-Swift.h")
+#import "RNFBPerf-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBPerf Swift interface not found"
+#endif
+
+#import "RNFBApp/RNFBSharedUtils.h"
+#import "RNFBPerfHelper.h"
+
+@implementation RNFBPerfHelper
+
+#if !RNFB_PERF_SDK_AVAILABLE
++ (void)rejectUnavailable:(RCTPromiseRejectBlock)reject {
+  [RNFBSharedUtils rejectPromiseWithUserInfo:reject
+                                    userInfo:(NSMutableDictionary *)@{
+                                      @"code" : @"unsupported",
+                                      @"message" : @"Firebase Performance is not available on "
+                                                   @"this platform or dependency configuration.",
+                                    }];
+}
+#endif
+
++ (NSDictionary *)constantsDictionary {
+  NSMutableDictionary *constants = [NSMutableDictionary new];
+#if RNFB_PERF_SDK_AVAILABLE
+  constants[@"isPerformanceCollectionEnabled"] =
+      @([FIRPerformance sharedInstance].dataCollectionEnabled);
+  constants[@"isInstrumentationEnabled"] =
+      @([FIRPerformance sharedInstance].instrumentationEnabled);
+#else
+  constants[@"isPerformanceCollectionEnabled"] = @(NO);
+  constants[@"isInstrumentationEnabled"] = @(NO);
+#endif
+  return constants;
+}
+
++ (void)setPerformanceCollectionEnabled:(BOOL)enabled
+                                resolve:(RCTPromiseResolveBlock)resolve
+                                 reject:(RCTPromiseRejectBlock)reject {
+#if RNFB_PERF_SDK_AVAILABLE
+  [FIRPerformance sharedInstance].dataCollectionEnabled = enabled;
+  resolve([NSNull null]);
+#else
+  (void)enabled;
+  (void)resolve;
+  [self rejectUnavailable:reject];
+#endif
+}
+
++ (void)setInstrumentationEnabled:(BOOL)enabled
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject {
+#if RNFB_PERF_SDK_AVAILABLE
+  [FIRPerformance sharedInstance].instrumentationEnabled = enabled;
+  resolve([NSNull null]);
+#else
+  (void)enabled;
+  (void)resolve;
+  [self rejectUnavailable:reject];
+#endif
+}
+
++ (void)startTraceWithId:(NSNumber *)traceId
+              identifier:(NSString *)identifier
+              inRegistry:(RNFBPerfHandleRegistry *)registry {
+#if RNFB_PERF_SDK_AVAILABLE
+  FIRTrace *trace = [[FIRPerformance sharedInstance] traceWithName:identifier];
+  [trace start];
+
+  FIRTrace *displaced = [registry putReplacing:traceId value:trace];
+  if (displaced != nil) {
+    [displaced stop];
+  }
+#else
+  (void)traceId;
+  (void)identifier;
+  (void)registry;
+#endif
+}
+
++ (void)stopTraceWithId:(NSNumber *)traceId
+                metrics:(NSDictionary *)metrics
+             attributes:(NSDictionary *)attributes
+             inRegistry:(RNFBPerfHandleRegistry *)registry {
+#if RNFB_PERF_SDK_AVAILABLE
+  FIRTrace *trace = [registry get:traceId];
+  if (trace == nil) {
+    return;
+  }
+
+  id<RNFBPerfTraceApplying> traceTarget = (id<RNFBPerfTraceApplying>)trace;
+  [RNFBPerfTraceStopApplier applyMetrics:metrics attributes:attributes to:traceTarget];
+
+  FIRTrace *expected = trace;
+  trace = [registry takeIf:traceId
+                      when:^BOOL(NSObject *value) {
+                        return value == expected;
+                      }];
+  if (trace != nil) {
+    [trace stop];
+  }
+#else
+  (void)traceId;
+  (void)metrics;
+  (void)attributes;
+  (void)registry;
+#endif
+}
+
++ (void)startHttpMetricWithId:(NSNumber *)metricId
+                          url:(NSString *)url
+                   httpMethod:(NSString *)httpMethod
+                   inRegistry:(RNFBPerfHandleRegistry *)registry {
+#if RNFB_PERF_SDK_AVAILABLE
+  FIRHTTPMethod method =
+      (FIRHTTPMethod)[RNFBPerfHttpMethodMapper httpMethodRawValueForString:httpMethod];
+  NSURL *toNSURL = [NSURL URLWithString:url];
+
+  FIRHTTPMetric *httpMetric = [[FIRHTTPMetric alloc] initWithURL:toNSURL HTTPMethod:method];
+  [httpMetric start];
+
+  FIRHTTPMetric *displaced = [registry putReplacing:metricId value:httpMetric];
+  if (displaced != nil) {
+    [displaced stop];
+  }
+#else
+  (void)metricId;
+  (void)url;
+  (void)httpMethod;
+  (void)registry;
+#endif
+}
+
++ (void)stopHttpMetricWithId:(NSNumber *)metricId
+                  attributes:(NSDictionary *)attributes
+            httpResponseCode:(NSNumber *)httpResponseCode
+          requestPayloadSize:(NSNumber *)requestPayloadSize
+         responsePayloadSize:(NSNumber *)responsePayloadSize
+         responseContentType:(NSString *)responseContentType
+                  inRegistry:(RNFBPerfHandleRegistry *)registry {
+#if RNFB_PERF_SDK_AVAILABLE
+  FIRHTTPMetric *httpMetric = [registry get:metricId];
+  if (httpMetric == nil) {
+    return;
+  }
+
+  id<RNFBPerfHttpMetricApplying> httpMetricTarget = (id<RNFBPerfHttpMetricApplying>)httpMetric;
+  [RNFBPerfHttpMetricStopApplier applyAttributes:attributes
+                                httpResponseCode:httpResponseCode
+                              requestPayloadSize:requestPayloadSize
+                             responsePayloadSize:responsePayloadSize
+                             responseContentType:responseContentType
+                                              to:httpMetricTarget];
+
+  FIRHTTPMetric *expected = httpMetric;
+  httpMetric = [registry takeIf:metricId
+                           when:^BOOL(NSObject *value) {
+                             return value == expected;
+                           }];
+  if (httpMetric != nil) {
+    [httpMetric stop];
+  }
+#else
+  (void)metricId;
+  (void)attributes;
+  (void)httpResponseCode;
+  (void)requestPayloadSize;
+  (void)responsePayloadSize;
+  (void)responseContentType;
+  (void)registry;
+#endif
+}
+
+@end

package/ios/RNFBPerf/RNFBPerfHttpMethodMapper.swift

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/**
+ * HTTP method string → `FIRHTTPMethod` raw-value mapping previously inline in
+ * `-[RNFBPerfModule startHttpMetric:url:httpMethod:]`.
+ *
+ * Mirrors pre-port (case-insensitive `compare:`; successive ifs; default GET).
+ * Raw ints from Firebase Performance `FIRHTTPMethod` (`FIRHTTPMetric.h`):
+ * - GET = 0, PUT = 1, POST = 2, DELETE = 3, HEAD = 4
+ * - PATCH = 5, OPTIONS = 6, TRACE = 7, CONNECT = 8
+ *
+ * Unknown / empty / nil / `"get"` → GET (no explicit GET branch).
+ */
+@objc(RNFBPerfHttpMethodMapper)
+public final class RNFBPerfHttpMethodMapper: NSObject {
+  /// `FIRHTTPMethodGET`
+  private static let getMethod = 0
+  /// `FIRHTTPMethodPUT`
+  private static let putMethod = 1
+  /// `FIRHTTPMethodPOST`
+  private static let postMethod = 2
+  /// `FIRHTTPMethodDELETE`
+  private static let deleteMethod = 3
+  /// `FIRHTTPMethodHEAD`
+  private static let headMethod = 4
+  /// `FIRHTTPMethodPATCH`
+  private static let patchMethod = 5
+  /// `FIRHTTPMethodOPTIONS`
+  private static let optionsMethod = 6
+  /// `FIRHTTPMethodTRACE`
+  private static let traceMethod = 7
+  /// `FIRHTTPMethodCONNECT`
+  private static let connectMethod = 8
+
+  @objc(httpMethodRawValueForString:)
+  public static func httpMethodRawValue(forString httpMethod: String?) -> Int {
+    var method = getMethod
+    guard let httpMethod else {
+      return method
+    }
+
+    // Successive case-insensitive compares (not else-if) — same outcome for
+    // single method strings; preserves pre-port control flow.
+    if httpMethod.caseInsensitiveCompare("put") == .orderedSame {
+      method = putMethod
+    }
+    if httpMethod.caseInsensitiveCompare("post") == .orderedSame {
+      method = postMethod
+    }
+    if httpMethod.caseInsensitiveCompare("head") == .orderedSame {
+      method = headMethod
+    }
+    if httpMethod.caseInsensitiveCompare("trace") == .orderedSame {
+      method = traceMethod
+    }
+    if httpMethod.caseInsensitiveCompare("patch") == .orderedSame {
+      method = patchMethod
+    }
+    if httpMethod.caseInsensitiveCompare("delete") == .orderedSame {
+      method = deleteMethod
+    }
+    if httpMethod.caseInsensitiveCompare("options") == .orderedSame {
+      method = optionsMethod
+    }
+    if httpMethod.caseInsensitiveCompare("connect") == .orderedSame {
+      method = connectMethod
+    }
+    return method
+  }
+}

package/ios/RNFBPerf/RNFBPerfHttpMetricStopApplier.swift

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/**
+ * Subset of `FIRHTTPMetric` setters used by
+ * `-[RNFBPerfModule stopHttpMetric:metricData:]`. Protocol-shaped so unit tests
+ * can stub without linking FirebasePerformance.
+ */
+@objc public protocol RNFBPerfHttpMetricApplying: AnyObject {
+  @objc(setValue:forAttribute:)
+  func setValue(_ value: String, forAttribute attributeName: String)
+
+  @objc(setResponseCode:)
+  func setResponseCode(_ responseCode: Int)
+
+  @objc(setRequestPayloadSize:)
+  func setRequestPayloadSize(_ bytes: Int)
+
+  @objc(setResponsePayloadSize:)
+  func setResponsePayloadSize(_ bytes: Int)
+
+  @objc(setResponseContentType:)
+  func setResponseContentType(_ contentType: String)
+}
+
+/**
+ * Applies HTTP metric stop fields previously set inline in
+ * `-[RNFBPerfModule stopHttpMetric:metricData:]`.
+ *
+ * Pre-port contracts:
+ * - attributes first (`setValue:forAttribute:`), then optional responseCode,
+ *   requestPayloadSize, responsePayloadSize, responseContentType
+ * - missing optionals (nil NSNumber / nil content type) skipped
+ * - nil attributes dict → no crash
+ */
+@objc(RNFBPerfHttpMetricStopApplier)
+public final class RNFBPerfHttpMetricStopApplier: NSObject {
+  @objc(applyAttributes:httpResponseCode:requestPayloadSize:responsePayloadSize:responseContentType:to:)
+  public static func apply(
+    attributes: NSDictionary?,
+    httpResponseCode: NSNumber?,
+    requestPayloadSize: NSNumber?,
+    responsePayloadSize: NSNumber?,
+    responseContentType: String?,
+    to metric: RNFBPerfHttpMetricApplying
+  ) {
+    if let attributes {
+      attributes.enumerateKeysAndObjects { key, value, _ in
+        guard let attributeName = key as? String, let stringValue = value as? String else {
+          return
+        }
+        metric.setValue(stringValue, forAttribute: attributeName)
+      }
+    }
+
+    if let httpResponseCode {
+      metric.setResponseCode(httpResponseCode.intValue)
+    }
+
+    if let requestPayloadSize {
+      metric.setRequestPayloadSize(requestPayloadSize.intValue)
+    }
+
+    if let responsePayloadSize {
+      metric.setResponsePayloadSize(responsePayloadSize.intValue)
+    }
+
+    if let responseContentType {
+      metric.setResponseContentType(responseContentType)
+    }
+  }
+}