@react-native-firebase/perf 25.1.0 → 26.1.0

package/ios/generated/ReactAppDependencyProvider.podspec

@@ -0,0 +1,34 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+version = "0.78.3"
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "ReactAppDependencyProvider"
+  s.version                = version
+  s.summary                = "The third party dependency provider for the app"
+  s.homepage               = "https://reactnative.dev/"
+  s.documentation_url      = "https://reactnative.dev/"
+  s.license                = "MIT"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = "**/RCTAppDependencyProvider.{h,mm}"
+
+  # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
+  s.pod_target_xcconfig    = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "DEFINES_MODULE" => "YES"
+  }
+
+  s.dependency "ReactCodegen"
+end

package/lib/HttpMetric.ts

@@ -87,18 +87,18 @@ export default class HttpMetric extends MetricWithAttributes {
     this._responseContentType = contentType;
   }
 
-  start(): Promise<null> {
+  start(): void {
     if (this._started) {
-      return Promise.resolve(null);
+      return;
     }
     this._started = true;
 
-    return this.native.startHttpMetric(this._id, this._url, this._httpMethod);
+    this.native.startHttpMetric(this._id, this._url, this._httpMethod);
   }
 
-  stop(): Promise<null> {
+  stop(): void {
     if (this._stopped) {
-      return Promise.resolve(null);
+      return;
     }
     this._stopped = true;
 
@@ -125,6 +125,6 @@ export default class HttpMetric extends MetricWithAttributes {
       metricData.responseContentType = this._responseContentType;
     }
 
-    return this.native.stopHttpMetric(this._id, metricData);
+    this.native.stopHttpMetric(this._id, metricData);
   }
 }

package/lib/ScreenTrace.ts

@@ -36,24 +36,24 @@ export default class ScreenTrace {
     this._stopped = false;
   }
 
-  start(): Promise<null> {
+  start(): void {
     if (isIOS) {
-      return Promise.reject(new Error('Custom screentraces are currently not supported on iOS.'));
+      throw new Error('Custom screentraces are currently not supported on iOS.');
     }
     if (this._started) {
-      return Promise.resolve(null);
+      return;
     }
     this._started = true;
 
-    return this.native.startScreenTrace(this._id, this._identifier);
+    this.native.startScreenTrace(this._id, this._identifier);
   }
 
-  stop(): Promise<null> {
+  stop(): void {
     if (!this._started || this._stopped) {
-      return Promise.resolve(null);
+      return;
     }
     this._stopped = true;
 
-    return this.native.stopScreenTrace(this._id);
+    this.native.stopScreenTrace(this._id);
   }
 }

package/lib/Trace.ts

@@ -87,18 +87,18 @@ export default class Trace extends MetricWithAttributes {
     delete this._metrics[metric];
   }
 
-  start(): Promise<null> {
+  start(): void {
     if (this._started) {
-      return Promise.resolve(null);
+      return;
     }
     this._started = true;
 
-    return this.native.startTrace(this._id, this._identifier);
+    this.native.startTrace(this._id, this._identifier);
   }
 
-  stop(): Promise<null> {
+  stop(): void {
     if (this._stopped) {
-      return Promise.resolve(null);
+      return;
     }
     this._stopped = true;
 
@@ -107,6 +107,6 @@ export default class Trace extends MetricWithAttributes {
       attributes: Object.assign({}, this._attributes),
     };
 
-    return this.native.stopTrace(this._id, traceData);
+    this.native.stopTrace(this._id, traceData);
   }
 }

package/lib/index.ts

@@ -15,11 +15,234 @@
  *
  */
 
-export type * from './types/perf';
+import { isBoolean, isOneOf, isString } from '@react-native-firebase/app/dist/module/common';
+import type { FirebaseApp } from '@react-native-firebase/app';
+import {
+  FirebaseModule,
+  getOrCreateModularInstance,
+} from '@react-native-firebase/app/dist/module/internal';
+import type { ModuleConfig } from '@react-native-firebase/app/dist/module/internal';
+import './types/internal';
+import { Platform } from 'react-native';
+
+import HttpMetricImpl from './HttpMetric';
+import ScreenTraceImpl from './ScreenTrace';
+import TraceImpl from './Trace';
+import { version } from './version';
+
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+import type {
+  FirebasePerformance,
+  HttpMetric,
+  HttpMethod,
+  PerformanceSettings,
+  PerformanceTrace,
+  ScreenTrace,
+} from './types/perf';
+import type { PerfInternal } from './types/internal';
+
+const nativeModuleName = 'NativeRNFBTurboPerf' as const;
+
+const VALID_HTTP_METHODS: HttpMethod[] = [
+  'CONNECT',
+  'DELETE',
+  'GET',
+  'HEAD',
+  'OPTIONS',
+  'PATCH',
+  'POST',
+  'PUT',
+  'TRACE',
+];
+
+class FirebasePerfModule extends FirebaseModule<typeof nativeModuleName> {
+  private _isPerformanceCollectionEnabled: boolean;
+  private _instrumentationEnabled: boolean;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) {
+    super(app, config, customUrlOrRegion);
+    this._isPerformanceCollectionEnabled = this.native.isPerformanceCollectionEnabled;
+    this._instrumentationEnabled = this.native.isInstrumentationEnabled;
+  }
+
+  get isPerformanceCollectionEnabled(): boolean {
+    return this._isPerformanceCollectionEnabled;
+  }
+
+  get instrumentationEnabled(): boolean {
+    return this._instrumentationEnabled;
+  }
+
+  set instrumentationEnabled(enabled: boolean) {
+    if (!isBoolean(enabled)) {
+      throw new Error("firebase.perf().instrumentationEnabled = 'enabled' must be a boolean.");
+    }
+    if (Platform.OS === 'ios') {
+      // We don't change for android as it cannot be set from code, it is set at gradle build time.
+      this._instrumentationEnabled = enabled;
+      // No need to await, as it only takes effect on the next app run.
+      this.native.instrumentationEnabled(enabled);
+    }
+  }
+
+  get dataCollectionEnabled(): boolean {
+    return this._isPerformanceCollectionEnabled;
+  }
+
+  set dataCollectionEnabled(enabled: boolean) {
+    if (!isBoolean(enabled)) {
+      throw new Error("firebase.perf().dataCollectionEnabled = 'enabled' must be a boolean.");
+    }
+    this._isPerformanceCollectionEnabled = enabled;
+    // Keep setter behavior fire-and-forget; callers that need completion should use setPerformanceCollectionEnabled().
+    void this.native.setPerformanceCollectionEnabled(enabled);
+  }
+
+  async setPerformanceCollectionEnabled(enabled: boolean): Promise<null> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.perf().setPerformanceCollectionEnabled(*) 'enabled' must be a boolean.",
+      );
+    }
+
+    if (Platform.OS === 'ios') {
+      // '_instrumentationEnabled' is updated here as well to maintain backward compatibility. See:
+      // https://github.com/invertase/react-native-firebase/commit/b705622e64d6ebf4ee026d50841e2404cf692f85
+      this._instrumentationEnabled = enabled;
+      await this.native.instrumentationEnabled(enabled);
+    }
+
+    this._isPerformanceCollectionEnabled = enabled;
+    return this.native.setPerformanceCollectionEnabled(enabled);
+  }
+
+  newTrace(identifier: string): TraceImpl {
+    // TODO(VALIDATION): identifier: no leading or trailing whitespace, no leading underscore '_'
+    if (!isString(identifier) || identifier.length > 100) {
+      throw new Error(
+        "firebase.perf().newTrace(*) 'identifier' must be a string with a maximum length of 100 characters.",
+      );
+    }
+
+    return new TraceImpl(this.native, identifier);
+  }
+
+  startTrace(identifier: string): TraceImpl {
+    const traceInstance = this.newTrace(identifier);
+    traceInstance.start();
+    return traceInstance;
+  }
+
+  newScreenTrace(identifier: string): ScreenTraceImpl {
+    if (!isString(identifier) || identifier.length > 100) {
+      throw new Error(
+        "firebase.perf().newScreenTrace(*) 'identifier' must be a string with a maximum length of 100 characters.",
+      );
+    }
 
-export * from './modular';
+    return new ScreenTraceImpl(this.native, identifier);
+  }
 
-export type { FirebasePerformanceTypes } from './types/namespaced';
+  startScreenTrace(identifier: string): ScreenTraceImpl {
+    const screenTrace = this.newScreenTrace(identifier);
+    screenTrace.start();
+    return screenTrace;
+  }
 
-export * from './namespaced';
-export { default } from './namespaced';
+  newHttpMetric(url: string, httpMethod: HttpMethod): HttpMetricImpl {
+    if (!isString(url)) {
+      throw new Error("firebase.perf().newHttpMetric(*, _) 'url' must be a string.");
+    }
+
+    if (!isOneOf(httpMethod, VALID_HTTP_METHODS)) {
+      throw new Error(
+        `firebase.perf().newHttpMetric(_, *) 'httpMethod' must be one of ${VALID_HTTP_METHODS.join(
+          ', ',
+        )}.`,
+      );
+    }
+
+    return new HttpMetricImpl(this.native, url, httpMethod);
+  }
+}
+
+const config: ModuleConfig = {
+  namespace: 'perf',
+  nativeModuleName,
+  nativeEvents: false,
+  hasMultiAppSupport: false,
+  hasCustomUrlOrRegionSupport: false,
+  turboModule: true,
+};
+
+export const SDK_VERSION = version;
+
+function perfInternal(performance: FirebasePerformance): PerfInternal {
+  return performance as PerfInternal;
+}
+
+export function getPerformance(app?: FirebaseApp): FirebasePerformance {
+  return getOrCreateModularInstance(
+    FirebasePerfModule,
+    config,
+    app,
+  ) as unknown as FirebasePerformance;
+}
+
+/**
+ * Creates a Performance Monitoring instance and applies optional settings.
+ *
+ * @remarks Returns **synchronously** on React Native Firebase (unlike some async firebase-js-sdk
+ * initialization paths). Settings are applied to the native Performance SDK instance.
+ */
+export function initializePerformance(
+  app: FirebaseApp,
+  settings?: PerformanceSettings,
+): FirebasePerformance {
+  const perf = getPerformance(app);
+
+  if (settings?.dataCollectionEnabled !== undefined) {
+    perf.dataCollectionEnabled = settings.dataCollectionEnabled;
+  }
+  if (settings?.instrumentationEnabled !== undefined) {
+    perf.instrumentationEnabled = settings.instrumentationEnabled;
+  }
+
+  return perf;
+}
+
+/**
+ * Creates a custom performance trace.
+ *
+ * @remarks On React Native Firebase, {@link PerformanceTrace.start} and
+ * {@link PerformanceTrace.stop} are **synchronous** (in-memory native calls via TurboModules),
+ * matching the firebase-js-sdk web `PerformanceTrace`.
+ */
+export function trace(performance: FirebasePerformance, name: string): PerformanceTrace {
+  return perfInternal(performance).newTrace(name) as unknown as PerformanceTrace;
+}
+
+export function httpMetric(
+  performance: FirebasePerformance,
+  url: string,
+  httpMethod: HttpMethod,
+): HttpMetric {
+  return perfInternal(performance).newHttpMetric(url, httpMethod) as unknown as HttpMetric;
+}
+
+export function newScreenTrace(performance: FirebasePerformance, screenName: string): ScreenTrace {
+  return perfInternal(performance).newScreenTrace(screenName) as unknown as ScreenTrace;
+}
+
+export function startScreenTrace(
+  performance: FirebasePerformance,
+  screenName: string,
+): ScreenTrace {
+  return perfInternal(performance).startScreenTrace(screenName) as unknown as ScreenTrace;
+}
+
+export type * from './types/perf';

package/lib/types/internal.ts

@@ -23,28 +23,16 @@ import type {
   ScreenTrace,
 } from './perf';
 
-export type PerfModularDeprecationArg = string;
-
-/**
- * Namespaced perf instance used by modular entrypoints; methods accept an optional modular deprecation token.
- */
 export interface PerfInternal extends FirebasePerformance {
   /**
    * @deprecated Prefer assigning {@link FirebasePerformance.dataCollectionEnabled}.
    */
   setPerformanceCollectionEnabled(enabled: boolean): Promise<null>;
-  newTrace(name: string, deprecationArg?: PerfModularDeprecationArg): PerformanceTrace;
-  startTrace(name: string, deprecationArg?: PerfModularDeprecationArg): Promise<PerformanceTrace>;
-  newScreenTrace(screenName: string, deprecationArg?: PerfModularDeprecationArg): ScreenTrace;
-  startScreenTrace(
-    screenName: string,
-    deprecationArg?: PerfModularDeprecationArg,
-  ): Promise<ScreenTrace>;
-  newHttpMetric(
-    url: string,
-    httpMethod: HttpMethod,
-    deprecationArg?: PerfModularDeprecationArg,
-  ): HttpMetric;
+  newTrace(name: string): PerformanceTrace;
+  startTrace(name: string): PerformanceTrace;
+  newScreenTrace(screenName: string): ScreenTrace;
+  startScreenTrace(screenName: string): ScreenTrace;
+  newHttpMetric(url: string, httpMethod: HttpMethod): HttpMetric;
 }
 
 export interface RNFBPerfTraceData {
@@ -65,16 +53,16 @@ export interface RNFBPerfNativeModule {
   isInstrumentationEnabled: boolean;
   setPerformanceCollectionEnabled(enabled: boolean): Promise<null>;
   instrumentationEnabled(enabled: boolean): Promise<null>;
-  startTrace(id: number, identifier: string): Promise<null>;
-  stopTrace(id: number, traceData: RNFBPerfTraceData): Promise<null>;
-  startHttpMetric(id: number, url: string, httpMethod: HttpMethod): Promise<null>;
-  stopHttpMetric(id: number, metricData: RNFBPerfHttpMetricData): Promise<null>;
-  startScreenTrace(id: number, identifier: string): Promise<null>;
-  stopScreenTrace(id: number): Promise<null>;
+  startTrace(id: number, identifier: string): void;
+  stopTrace(id: number, traceData: RNFBPerfTraceData): void;
+  startHttpMetric(id: number, url: string, httpMethod: HttpMethod): void;
+  stopHttpMetric(id: number, metricData: RNFBPerfHttpMetricData): void;
+  startScreenTrace(id: number, identifier: string): void;
+  stopScreenTrace(id: number): void;
 }
 
 declare module '@react-native-firebase/app/dist/module/internal/NativeModules' {
   interface ReactNativeFirebaseNativeModules {
-    RNFBPerfModule: RNFBPerfNativeModule;
+    NativeRNFBTurboPerf: RNFBPerfNativeModule;
   }
 }

package/lib/types/perf.ts

@@ -44,7 +44,7 @@ export type HttpMethod =
 /**
  * A performance trace (aligned with {@link https://firebase.google.com/docs/reference/js/performance.performancetrace | PerformanceTrace} in the Firebase JS SDK).
  *
- * @remarks React Native uses async `start`/`stop` (native bridge). The web SDK uses synchronous `start`/`stop`. React Native also exposes `getMetrics` and `removeMetric`, which are not on the web `PerformanceTrace` type.
+ * @remarks React Native uses synchronous `start`/`stop` (in-memory native calls via TurboModules), matching the firebase-js-sdk web `PerformanceTrace`. React Native also exposes `getMetrics` and `removeMetric`, which are not on the web `PerformanceTrace` type.
  */
 export interface PerformanceTrace {
   getAttribute(attr: string): string | undefined;
@@ -54,16 +54,16 @@ export interface PerformanceTrace {
   putMetric(metricName: string, num: number): void;
   incrementMetric(metricName: string, num?: number): void;
   removeMetric(metricName: string): void;
-  start(): Promise<null>;
-  stop(): Promise<null>;
+  start(): void;
+  stop(): void;
 }
 
 /**
  * Screen trace for slow/frozen frames (React Native).
  */
 export interface ScreenTrace {
-  start(): Promise<null>;
-  stop(): Promise<null>;
+  start(): void;
+  stop(): void;
 }
 
 /**
@@ -78,8 +78,8 @@ export interface HttpMetric {
   setRequestPayloadSize(bytes: number | null): void;
   setResponsePayloadSize(bytes: number | null): void;
   setResponseContentType(contentType: string | null): void;
-  start(): Promise<null>;
-  stop(): Promise<null>;
+  start(): void;
+  stop(): void;
 }
 
 /**

package/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '25.1.0';
+export const version = '26.1.0';

package/package.json

@@ -1,17 +1,34 @@
 {
   "name": "@react-native-firebase/perf",
-  "version": "25.1.0",
+  "version": "26.1.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Performance Monitoring to gain insight into key performance characteristics within your React Native application.",
   "main": "./dist/module/index.js",
   "types": "./dist/typescript/lib/index.d.ts",
+  "codegenConfig": {
+    "name": "RNFBPerfTurboModules",
+    "type": "modules",
+    "jsSrcsDir": "specs",
+    "includesGeneratedCode": true,
+    "android": {
+      "javaPackageName": "io.invertase.firebase.perf"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NativeRNFBTurboPerf": "RNFBPerfModule"
+      }
+    }
+  },
   "scripts": {
     "build": "genversion --esm --semi lib/version.ts",
     "build:clean": "rimraf android/build && rimraf ios/build",
     "build:plugin": "rimraf plugin/build && tsc --build plugin",
     "compile": "bob build",
     "lint:plugin": "eslint plugin/src/*",
-    "prepare": "yarn run build && yarn compile && yarn run build:plugin"
+    "prepare": "yarn run build && yarn compile && yarn run build:plugin",
+    "codegen": "yarn android:codegen && yarn ios:codegen",
+    "android:codegen": "npx @react-native-community/cli codegen --platform android --outputPath=./android/src/reactnative/java/io/invertase/firebase/perf/generated",
+    "ios:codegen": "npx @react-native-community/cli codegen --platform ios --outputPath=./ios/generated"
   },
   "repository": {
     "type": "git",
@@ -30,10 +47,11 @@
     "performance monitoring"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "25.1.0",
+    "@react-native-firebase/app": "26.1.0",
     "expo": ">=47.0.0"
   },
   "devDependencies": {
+    "@react-native-firebase/app": "26.1.0",
     "expo": "^55.0.18",
     "react-native-builder-bob": "^0.40.13"
   },
@@ -52,7 +70,14 @@
       "types": "./dist/typescript/lib/index.d.ts",
       "default": "./dist/module/index.js"
     },
-    "./app.plugin.js": "./app.plugin.js",
+    "./app.plugin": {
+      "types": "./plugin/build/app.plugin.d.ts",
+      "default": "./app.plugin.js"
+    },
+    "./app.plugin.js": {
+      "types": "./plugin/build/app.plugin.d.ts",
+      "default": "./app.plugin.js"
+    },
     "./package.json": "./package.json"
   },
   "react-native-builder-bob": {
@@ -77,5 +102,5 @@
     "node_modules/",
     "dist/"
   ],
-  "gitHead": "e0a565d8a73a9b103d140ffacfb8876b30d8bdc5"
+  "gitHead": "59d053eca14ab8aa80e5ac76887014925c67e52b"
 }

package/plugin/build/app.plugin.d.ts

@@ -0,0 +1,2 @@
+import plugin from './index';
+export = plugin;

package/plugin/build/app.plugin.js

@@ -0,0 +1,6 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const index_1 = __importDefault(require("./index"));
+module.exports = index_1.default;

package/plugin/src/app.plugin.ts

@@ -0,0 +1,3 @@
+import plugin from './index';
+
+export = plugin;

package/plugin/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/android/applyPlugin.ts","./src/android/buildscriptDependency.ts","./src/android/constants.ts","./src/android/index.ts"],"version":"6.0.3"}
+{"root":["./src/app.plugin.ts","./src/index.ts","./src/android/applyPlugin.ts","./src/android/buildscriptDependency.ts","./src/android/constants.ts","./src/android/index.ts"],"version":"6.0.3"}

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        cmakeListsPath:
+          './src/reactnative/java/io/invertase/firebase/perf/generated/jni/CMakeLists.txt',
+      },
+    },
+  },
+};

package/specs/NativeRNFBTurboPerf.ts

@@ -0,0 +1,44 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type HttpMethod =
+  | 'CONNECT'
+  | 'DELETE'
+  | 'GET'
+  | 'HEAD'
+  | 'OPTIONS'
+  | 'PATCH'
+  | 'POST'
+  | 'PUT'
+  | 'TRACE';
+
+export interface TraceData {
+  metrics: { [key: string]: number };
+  attributes: { [key: string]: string };
+}
+
+export interface HttpMetricData {
+  attributes: { [key: string]: string };
+  httpResponseCode?: number;
+  requestPayloadSize?: number;
+  responsePayloadSize?: number;
+  responseContentType?: string;
+}
+
+export interface Spec extends TurboModule {
+  getConstants(): {
+    isPerformanceCollectionEnabled: boolean;
+    isInstrumentationEnabled: boolean;
+  };
+
+  setPerformanceCollectionEnabled(enabled: boolean): Promise<void>;
+  instrumentationEnabled(enabled: boolean): Promise<void>;
+  startTrace(id: number, identifier: string): void;
+  stopTrace(id: number, traceData: TraceData): void;
+  startScreenTrace(id: number, identifier: string): void;
+  stopScreenTrace(id: number): void;
+  startHttpMetric(id: number, url: string, httpMethod: HttpMethod): void;
+  stopHttpMetric(id: number, metricData: HttpMetricData): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('NativeRNFBTurboPerf');

package/typedoc.json

@@ -1,5 +1,5 @@
 {
   "$schema": "https://typedoc.org/schema.json",
-  "entryPoints": ["lib/modular.ts", "lib/types/perf.ts"],
+  "entryPoints": ["lib/index.ts", "lib/types/perf.ts"],
   "tsconfig": "tsconfig.json"
 }