@react-native-firebase/perf 26.4.0 → 27.1.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.1.0](https://github.com/invertase/react-native-firebase/compare/v27.0.0...v27.1.0) (2026-10-23)
+
+**Note:** Version bump only for package @react-native-firebase/perf
+
+## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
+
+### ⚠ BREAKING CHANGES
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13
+
+### Features
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13 ([0ca03d1](https://github.com/invertase/react-native-firebase/commit/0ca03d11b0c271fb37cfbee8a0c3074a21969f0b))
+
+### Bug Fixes
+
+- **perf, ios:** avoid id cast shadowed by TurboModule id param ([9556118](https://github.com/invertase/react-native-firebase/commit/955611850796e2589c0286ab4700a4eb6ec5d2a3))
+- **perf, ios:** typedef Swift protocol refs around TurboModule id shadowing ([db9cc60](https://github.com/invertase/react-native-firebase/commit/db9cc60e6eb2eb4331702393e2649f102b7cce70))
+- **perf, ios:** use id casts for Swift protocols in ObjC++ ([1d5c7ca](https://github.com/invertase/react-native-firebase/commit/1d5c7ca28d674d7c3bdd19d085911abccda2b20e))
+
 ## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
 
 ### Bug Fixes

package/RNFBPerf.podspec

@@ -29,16 +29,21 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = firebase_ios_target
   s.macos.deployment_target = firebase_macos_target
   s.tvos.deployment_target = firebase_tvos_target
+  s.swift_version       = '5.10'
   s.source_files        = 'ios/**/*.{h,m,mm,cpp,swift}'
   s.private_header_files = "ios/**/*.h"
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**'
+  # CocoaPods FileList uses FNM_PATHNAME: `ios/*UnitTests/**` does not match nested
+  # paths like `ios/RNFBPerfUnitTests/HostStubs/**` (those would compile into the pod).
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**/*'
 
   # Must be set before install_modules_dependencies so RN can append use_frameworks
   # HEADER_SEARCH_PATHS (React-debug etc.). Assigning after overwrites those paths
   # and breaks from-source builds: react/timing/primitives.h → react/debug/flags.h.
   # CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES is required so the
   # framework module validates when consumers build with use_frameworks!.
+  # DEFINES_MODULE is required for the generated RNFBPerf-Swift.h interface.
   s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
     "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES",
   }
 

package/android/build.gradle

@@ -15,6 +15,7 @@ buildscript {
 
     dependencies {
       classpath("com.android.tools.build:gradle:8.4.0")
+      classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.findProperty('kotlinVersion') ?: '2.4.0'}")
     }
   }
 }
@@ -23,6 +24,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: "org.jetbrains.kotlin.android"
+
 def appProject
 if (findProject(':@react-native-firebase_app')) {
   appProject = project(':@react-native-firebase_app')

package/android/src/main/java/io/invertase/firebase/perf/RNFBPerfHandleRegistry.kt

@@ -0,0 +1,71 @@
+package io.invertase.firebase.perf
+
+/*
+ * 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 io.invertase.firebase.common.RNFBHandleCollisionException
+import io.invertase.firebase.common.RNFBHandleMap
+import java.util.function.Predicate
+
+/**
+ * Perf id → metric handle map (traces, screen traces, HTTP metrics). Module start paths use
+ * [putReplacing] (last wins, stop displaced outside lock). Unique [put] / [putOrDiscard] remain for
+ * tests. Callers [get] then [take] then stop outside the HandleMap lock. Tear-down discards via
+ * [takeAll] without stopping (matches prior SparseArray clear).
+ */
+internal class RNFBPerfHandleRegistry<V> {
+  private val map = RNFBHandleMap<Int, V>()
+
+  @Throws(RNFBHandleCollisionException::class)
+  fun put(
+    id: Int,
+    handle: V,
+  ) {
+    map.put(id, handle)
+  }
+
+  /**
+   * Unique put. On collision, drop the incoming handle without stopping and leave the existing
+   * mapping.
+   *
+   * @return true if stored
+   */
+  fun putOrDiscard(
+    id: Int,
+    handle: V,
+  ): Boolean = map.putIfAbsent(id, handle)
+
+  /**
+   * Atomically replaces the mapping for [id] (last wins). Returns the displaced handle, or `null`
+   * if the id was free. Stop the displaced handle after this method returns.
+   */
+  fun putReplacing(
+    id: Int,
+    handle: V,
+  ): V? = map.putReplacing(id, handle)
+
+  fun get(id: Int): V? = map.get(id)
+
+  fun take(id: Int): V? = map.take(id)
+
+  fun takeIf(
+    id: Int,
+    shouldTake: Predicate<V>,
+  ): V? = map.takeIf(id, shouldTake)
+
+  fun takeAll(): List<V> = map.takeAll()
+}

package/android/src/test/java/io/invertase/firebase/perf/RNFBPerfHandleRegistryTest.java

@@ -114,6 +114,36 @@ public class RNFBPerfHandleRegistryTest {
     assertSame(second, registry.get(1));
   }
 
+  @Test
+  public void takeIf_whenMissing_returnsNullWithoutCallingPredicate() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    boolean[] called = {false};
+    assertNull(
+        registry.takeIf(
+            99,
+            value -> {
+              called[0] = true;
+              return true;
+            }));
+    assertFalse(called[0]);
+  }
+
+  @Test
+  public void takeIf_whenPredicateFalse_leavesMapping() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "trace");
+    assertNull(registry.takeIf(1, value -> false));
+    assertSame("trace", registry.get(1));
+  }
+
+  @Test
+  public void takeIf_whenPredicateTrue_removesAndReturns() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "trace");
+    assertSame("trace", registry.takeIf(1, value -> value == "trace"));
+    assertNull(registry.get(1));
+  }
+
   @Test
   public void get_whenFree_isNull() {
     RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.4.0';
+export const version = '27.1.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { FirebasePerformance, HttpMetric, HttpMethod, PerformanceSettings, PerformanceTrace, ScreenTrace } from './types/perf';
-export declare const SDK_VERSION = "26.4.0";
+export declare const SDK_VERSION = "27.1.0";
 export declare function getPerformance(app?: FirebaseApp): FirebasePerformance;
 /**
  * Creates a Performance Monitoring instance and applies optional settings.

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "26.4.0";
+export declare const version = "27.1.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBPerf/RNFBPerfHandleRegistry.m

@@ -23,8 +23,18 @@
 #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) RNFBHandleMap *map;
+@property(nonatomic, strong) RNFBPerfHandleRegistryStorage *storage;
 @end
 
 @implementation RNFBPerfHandleRegistry
@@ -32,37 +42,46 @@
 - (instancetype)init {
   self = [super init];
   if (self) {
-    _map = [[RNFBHandleMap alloc] init];
+    _storage = [[RNFBPerfHandleRegistryStorage alloc] init];
   }
   return self;
 }
 
 - (BOOL)put:(id)key value:(id)value error:(NSError **)error {
-  return [self.map put:key value:value error: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.map putIfAbsent:key value:value];
+  return [self.storage putOrDiscard:key value:value];
 }
 
 - (id)putReplacing:(id)key value:(id)value {
-  return [self.map putReplacing:key value:value];
+  return [self.storage putReplacing:key value:value];
 }
 
 - (id)get:(id)key {
-  return [self.map get:key];
+  return [self.storage get:key];
 }
 
 - (id)take:(id)key {
-  return [self.map take:key];
+  return [self.storage take:key];
 }
 
 - (id)takeIf:(id)key when:(BOOL (^)(id))condition {
-  return [self.map takeIf:key when:condition];
+  return [self.storage takeIf:key when:condition];
 }
 
 - (NSArray *)takeAll {
-  return [self.map 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