react-native 0.71.3 → 0.72.0-rc.0

package/Libraries/WebPerformance/NativePerformanceObserver.cpp

@@ -5,38 +5,96 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <memory>
+
 #include "NativePerformanceObserver.h"
-#include <glog/logging.h>
+#include "PerformanceEntryReporter.h"
+
+#include "Plugins.h"
+
+std::shared_ptr<facebook::react::TurboModule>
+NativePerformanceObserverModuleProvider(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+  return std::make_shared<facebook::react::NativePerformanceObserver>(
+      std::move(jsInvoker));
+}
 
 namespace facebook::react {
 
 NativePerformanceObserver::NativePerformanceObserver(
     std::shared_ptr<CallInvoker> jsInvoker)
-    : NativePerformanceObserverCxxSpec(std::move(jsInvoker)) {}
+    : NativePerformanceObserverCxxSpec(std::move(jsInvoker)) {
+  setEventLogger(&PerformanceEntryReporter::getInstance());
+}
+
+NativePerformanceObserver::~NativePerformanceObserver() {
+  setEventLogger(nullptr);
+}
 
 void NativePerformanceObserver::startReporting(
     jsi::Runtime &rt,
-    std::string entryType) {
-  LOG(INFO) << "Started reporting perf entry type: " << entryType;
+    int32_t entryType) {
+  PerformanceEntryReporter::getInstance().startReporting(
+      static_cast<PerformanceEntryType>(entryType));
 }
 
 void NativePerformanceObserver::stopReporting(
     jsi::Runtime &rt,
-    std::string entryType) {
-  LOG(INFO) << "Stopped reporting perf entry type: " << entryType;
+    int32_t entryType) {
+  PerformanceEntryReporter::getInstance().stopReporting(
+      static_cast<PerformanceEntryType>(entryType));
 }
 
-std::vector<RawPerformanceEntry> NativePerformanceObserver::getPendingEntries(
+GetPendingEntriesResult NativePerformanceObserver::popPendingEntries(
     jsi::Runtime &rt) {
-  return std::vector<RawPerformanceEntry>{};
+  return PerformanceEntryReporter::getInstance().popPendingEntries();
 }
 
 void NativePerformanceObserver::setOnPerformanceEntryCallback(
     jsi::Runtime &rt,
     std::optional<AsyncCallback<>> callback) {
-  callback_ = callback;
-  LOG(INFO) << "setOnPerformanceEntryCallback: "
-            << (callback ? "non-empty" : "empty");
+  PerformanceEntryReporter::getInstance().setReportingCallback(callback);
+}
+
+void NativePerformanceObserver::logRawEntry(
+    jsi::Runtime &rt,
+    RawPerformanceEntry entry) {
+  PerformanceEntryReporter::getInstance().logEntry(entry);
+}
+
+std::vector<std::pair<std::string, uint32_t>>
+NativePerformanceObserver::getEventCounts(jsi::Runtime &rt) {
+  const auto &eventCounts =
+      PerformanceEntryReporter::getInstance().getEventCounts();
+  return std::vector<std::pair<std::string, uint32_t>>(
+      eventCounts.begin(), eventCounts.end());
+}
+
+void NativePerformanceObserver::setDurationThreshold(
+    jsi::Runtime &rt,
+    int32_t entryType,
+    double durationThreshold) {
+  PerformanceEntryReporter::getInstance().setDurationThreshold(
+      static_cast<PerformanceEntryType>(entryType), durationThreshold);
+}
+
+void NativePerformanceObserver::clearEntries(
+    jsi::Runtime &rt,
+    int32_t entryType,
+    std::optional<std::string> entryName) {
+  PerformanceEntryReporter::getInstance().clearEntries(
+      static_cast<PerformanceEntryType>(entryType),
+      entryName ? entryName->c_str() : nullptr);
+}
+
+std::vector<RawPerformanceEntry> NativePerformanceObserver::getEntries(
+    jsi::Runtime &rt,
+    std::optional<int32_t> entryType,
+    std::optional<std::string> entryName) {
+  return PerformanceEntryReporter::getInstance().getEntries(
+      entryType ? static_cast<PerformanceEntryType>(*entryType)
+                : PerformanceEntryType::UNDEFINED,
+      entryName ? entryName->c_str() : nullptr);
 }
 
 } // namespace facebook::react

package/Libraries/WebPerformance/NativePerformanceObserver.h

@@ -9,12 +9,12 @@
 
 #include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
 #include <functional>
-#include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
 namespace facebook::react {
+class PerformanceEntryReporter;
 
 #pragma mark - Structs
 
@@ -26,7 +26,7 @@ using RawPerformanceEntry = NativePerformanceObserverCxxBaseRawPerformanceEntry<
     // For "event" entries only:
     std::optional<double>,
     std::optional<double>,
-    std::optional<double>>;
+    std::optional<uint32_t>>;
 
 template <>
 struct Bridging<RawPerformanceEntry>
@@ -37,7 +37,18 @@ struct Bridging<RawPerformanceEntry>
           double,
           std::optional<double>,
           std::optional<double>,
-          std::optional<double>> {};
+          std::optional<uint32_t>> {};
+
+using GetPendingEntriesResult =
+    NativePerformanceObserverCxxBaseGetPendingEntriesResult<
+        std::vector<RawPerformanceEntry>,
+        uint32_t>;
+
+template <>
+struct Bridging<GetPendingEntriesResult>
+    : NativePerformanceObserverCxxBaseGetPendingEntriesResultBridging<
+          std::vector<RawPerformanceEntry>,
+          uint32_t> {};
 
 #pragma mark - implementation
 
@@ -46,19 +57,39 @@ class NativePerformanceObserver
       std::enable_shared_from_this<NativePerformanceObserver> {
  public:
   NativePerformanceObserver(std::shared_ptr<CallInvoker> jsInvoker);
+  ~NativePerformanceObserver();
 
-  void startReporting(jsi::Runtime &rt, std::string entryType);
+  void startReporting(jsi::Runtime &rt, int32_t entryType);
 
-  void stopReporting(jsi::Runtime &rt, std::string entryType);
+  void stopReporting(jsi::Runtime &rt, int32_t entryType);
 
-  std::vector<RawPerformanceEntry> getPendingEntries(jsi::Runtime &rt);
+  GetPendingEntriesResult popPendingEntries(jsi::Runtime &rt);
 
   void setOnPerformanceEntryCallback(
       jsi::Runtime &rt,
       std::optional<AsyncCallback<>> callback);
 
+  void logRawEntry(jsi::Runtime &rt, RawPerformanceEntry entry);
+
+  std::vector<std::pair<std::string, uint32_t>> getEventCounts(
+      jsi::Runtime &rt);
+
+  void setDurationThreshold(
+      jsi::Runtime &rt,
+      int32_t entryType,
+      double durationThreshold);
+
+  void clearEntries(
+      jsi::Runtime &rt,
+      int32_t entryType,
+      std::optional<std::string> entryName);
+
+  std::vector<RawPerformanceEntry> getEntries(
+      jsi::Runtime &rt,
+      std::optional<int32_t> entryType,
+      std::optional<std::string> entryName);
+
  private:
-  std::optional<AsyncCallback<>> callback_;
 };
 
 } // namespace facebook::react

package/Libraries/WebPerformance/NativePerformanceObserver.js

@@ -12,10 +12,6 @@ import type {TurboModule} from '../TurboModule/RCTExport';
 
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
-export const RawPerformanceEntryTypeValues = {
-  UNDEFINED: 0,
-};
-
 export type RawPerformanceEntryType = number;
 
 export type RawPerformanceEntry = {|
@@ -29,11 +25,30 @@ export type RawPerformanceEntry = {|
   interactionId?: number,
 |};
 
+export type GetPendingEntriesResult = {|
+  entries: $ReadOnlyArray<RawPerformanceEntry>,
+  droppedEntriesCount: number,
+|};
+
 export interface Spec extends TurboModule {
-  +startReporting: (entryType: string) => void;
-  +stopReporting: (entryType: string) => void;
-  +getPendingEntries: () => $ReadOnlyArray<RawPerformanceEntry>;
+  +startReporting: (entryType: RawPerformanceEntryType) => void;
+  +stopReporting: (entryType: RawPerformanceEntryType) => void;
+  +popPendingEntries: () => GetPendingEntriesResult;
   +setOnPerformanceEntryCallback: (callback?: () => void) => void;
+  +logRawEntry: (entry: RawPerformanceEntry) => void;
+  +getEventCounts: () => $ReadOnlyArray<[string, number]>;
+  +setDurationThreshold: (
+    entryType: RawPerformanceEntryType,
+    durationThreshold: number,
+  ) => void;
+  +clearEntries: (
+    entryType: RawPerformanceEntryType,
+    entryName?: string,
+  ) => void;
+  +getEntries: (
+    entryType?: RawPerformanceEntryType,
+    entryName?: string,
+  ) => $ReadOnlyArray<RawPerformanceEntry>;
 }
 
 export default (TurboModuleRegistry.get<Spec>(

package/Libraries/WebPerformance/Performance.js

@@ -0,0 +1,312 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict
+ */
+
+// flowlint unsafe-getters-setters:off
+
+import type {HighResTimeStamp, PerformanceEntryType} from './PerformanceEntry';
+import type {PerformanceEntryList} from './PerformanceObserver';
+
+import warnOnce from '../Utilities/warnOnce';
+import EventCounts from './EventCounts';
+import MemoryInfo from './MemoryInfo';
+import NativePerformance from './NativePerformance';
+import NativePerformanceObserver from './NativePerformanceObserver';
+import {PerformanceEntry} from './PerformanceEntry';
+import {warnNoNativePerformanceObserver} from './PerformanceObserver';
+import {
+  performanceEntryTypeToRaw,
+  rawToPerformanceEntry,
+} from './RawPerformanceEntry';
+import {RawPerformanceEntryTypeValues} from './RawPerformanceEntry';
+import ReactNativeStartupTiming from './ReactNativeStartupTiming';
+
+type DetailType = mixed;
+
+export type PerformanceMarkOptions = {
+  detail?: DetailType,
+  startTime?: HighResTimeStamp,
+};
+
+declare var global: {
+  // This value is defined directly via JSI, if available.
+  +nativePerformanceNow?: ?() => number,
+};
+
+const getCurrentTimeStamp: () => HighResTimeStamp = global.nativePerformanceNow
+  ? global.nativePerformanceNow
+  : () => Date.now();
+
+export class PerformanceMark extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(markName: string, markOptions?: PerformanceMarkOptions) {
+    super({
+      name: markName,
+      entryType: 'mark',
+      startTime: markOptions?.startTime ?? getCurrentTimeStamp(),
+      duration: 0,
+    });
+
+    if (markOptions) {
+      this.detail = markOptions.detail;
+    }
+  }
+}
+
+export type TimeStampOrName = HighResTimeStamp | string;
+
+export type PerformanceMeasureOptions = {
+  detail?: DetailType,
+  start?: TimeStampOrName,
+  end?: TimeStampOrName,
+  duration?: HighResTimeStamp,
+};
+
+export class PerformanceMeasure extends PerformanceEntry {
+  detail: DetailType;
+
+  constructor(measureName: string, measureOptions?: PerformanceMeasureOptions) {
+    super({
+      name: measureName,
+      entryType: 'measure',
+      startTime: 0,
+      duration: measureOptions?.duration ?? 0,
+    });
+
+    if (measureOptions) {
+      this.detail = measureOptions.detail;
+    }
+  }
+}
+
+function warnNoNativePerformance() {
+  warnOnce(
+    'missing-native-performance',
+    'Missing native implementation of Performance',
+  );
+}
+
+/**
+ * Partial implementation of the Performance interface for RN,
+ * corresponding to the standard in
+ * https://www.w3.org/TR/user-timing/#extensions-performance-interface
+ */
+export default class Performance {
+  eventCounts: EventCounts = new EventCounts();
+
+  // Get the current JS memory information.
+  get memory(): MemoryInfo {
+    if (NativePerformance?.getSimpleMemoryInfo) {
+      // JSI API implementations may have different variants of names for the JS
+      // heap information we need here. We will parse the result based on our
+      // guess of the implementation for now.
+      const memoryInfo = NativePerformance.getSimpleMemoryInfo();
+      if (memoryInfo.hasOwnProperty('hermes_heapSize')) {
+        // We got memory information from Hermes
+        const {
+          hermes_heapSize: totalJSHeapSize,
+          hermes_allocatedBytes: usedJSHeapSize,
+        } = memoryInfo;
+
+        return new MemoryInfo({
+          jsHeapSizeLimit: null, // We don't know the heap size limit from Hermes.
+          totalJSHeapSize,
+          usedJSHeapSize,
+        });
+      } else {
+        // JSC and V8 has no native implementations for memory information in JSI::Instrumentation
+        return new MemoryInfo();
+      }
+    }
+
+    return new MemoryInfo();
+  }
+
+  // Startup metrics is not used in web, but only in React Native.
+  get reactNativeStartupTiming(): ReactNativeStartupTiming {
+    if (NativePerformance?.getReactNativeStartupTiming) {
+      return new ReactNativeStartupTiming(
+        NativePerformance.getReactNativeStartupTiming(),
+      );
+    }
+    return new ReactNativeStartupTiming();
+  }
+
+  mark(
+    markName: string,
+    markOptions?: PerformanceMarkOptions,
+  ): PerformanceMark {
+    const mark = new PerformanceMark(markName, markOptions);
+
+    if (NativePerformance?.mark) {
+      NativePerformance.mark(markName, mark.startTime, mark.duration);
+    } else {
+      warnNoNativePerformance();
+    }
+
+    return mark;
+  }
+
+  clearMarks(markName?: string): void {
+    if (!NativePerformanceObserver?.clearEntries) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+
+    NativePerformanceObserver?.clearEntries(
+      RawPerformanceEntryTypeValues.MARK,
+      markName,
+    );
+  }
+
+  measure(
+    measureName: string,
+    startMarkOrOptions?: string | PerformanceMeasureOptions,
+    endMark?: string,
+  ): PerformanceMeasure {
+    let options;
+    let startMarkName,
+      endMarkName = endMark,
+      duration,
+      startTime = 0,
+      endTime = 0;
+
+    if (typeof startMarkOrOptions === 'string') {
+      startMarkName = startMarkOrOptions;
+    } else if (startMarkOrOptions !== undefined) {
+      options = startMarkOrOptions;
+      if (endMark !== undefined) {
+        throw new TypeError(
+          "Performance.measure: Can't have both options and endMark",
+        );
+      }
+      if (options.start === undefined && options.end === undefined) {
+        throw new TypeError(
+          'Performance.measure: Must have at least one of start/end specified in options',
+        );
+      }
+      if (
+        options.start !== undefined &&
+        options.end !== undefined &&
+        options.duration !== undefined
+      ) {
+        throw new TypeError(
+          "Performance.measure: Can't have both start/end and duration explicitly in options",
+        );
+      }
+
+      if (typeof options.start === 'number') {
+        startTime = options.start;
+      } else {
+        startMarkName = options.start;
+      }
+
+      if (typeof options.end === 'number') {
+        endTime = options.end;
+      } else {
+        endMarkName = options.end;
+      }
+
+      duration = options.duration ?? duration;
+    }
+
+    const measure = new PerformanceMeasure(measureName, options);
+
+    if (NativePerformance?.measure) {
+      NativePerformance.measure(
+        measureName,
+        startTime,
+        endTime,
+        duration,
+        startMarkName,
+        endMarkName,
+      );
+    } else {
+      warnNoNativePerformance();
+    }
+
+    return measure;
+  }
+
+  clearMeasures(measureName?: string): void {
+    if (!NativePerformanceObserver?.clearEntries) {
+      warnNoNativePerformanceObserver();
+      return;
+    }
+
+    NativePerformanceObserver?.clearEntries(
+      RawPerformanceEntryTypeValues.MEASURE,
+      measureName,
+    );
+  }
+
+  /**
+   * Returns a double, measured in milliseconds.
+   * https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
+   */
+  now(): HighResTimeStamp {
+    return getCurrentTimeStamp();
+  }
+
+  /**
+   * An extension that allows to get back to JS all currently logged marks/measures
+   * (in our case, be it from JS or native), see
+   * https://www.w3.org/TR/performance-timeline/#extensions-to-the-performance-interface
+   */
+  getEntries(): PerformanceEntryList {
+    if (!NativePerformanceObserver?.clearEntries) {
+      warnNoNativePerformanceObserver();
+      return [];
+    }
+    return NativePerformanceObserver.getEntries().map(rawToPerformanceEntry);
+  }
+
+  getEntriesByType(entryType: PerformanceEntryType): PerformanceEntryList {
+    if (entryType !== 'mark' && entryType !== 'measure') {
+      console.log(
+        `Performance.getEntriesByType: Only valid for 'mark' and 'measure' entry types, got ${entryType}`,
+      );
+      return [];
+    }
+
+    if (!NativePerformanceObserver?.clearEntries) {
+      warnNoNativePerformanceObserver();
+      return [];
+    }
+    return NativePerformanceObserver.getEntries(
+      performanceEntryTypeToRaw(entryType),
+    ).map(rawToPerformanceEntry);
+  }
+
+  getEntriesByName(
+    entryName: string,
+    entryType?: PerformanceEntryType,
+  ): PerformanceEntryList {
+    if (
+      entryType !== undefined &&
+      entryType !== 'mark' &&
+      entryType !== 'measure'
+    ) {
+      console.log(
+        `Performance.getEntriesByName: Only valid for 'mark' and 'measure' entry types, got ${entryType}`,
+      );
+      return [];
+    }
+
+    if (!NativePerformanceObserver?.clearEntries) {
+      warnNoNativePerformanceObserver();
+      return [];
+    }
+    return NativePerformanceObserver.getEntries(
+      entryType != null ? performanceEntryTypeToRaw(entryType) : undefined,
+      entryName,
+    ).map(rawToPerformanceEntry);
+  }
+}

package/Libraries/WebPerformance/PerformanceEntry.js

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict
+ */
+
+export type HighResTimeStamp = number;
+export type PerformanceEntryType = 'mark' | 'measure' | 'event';
+
+export class PerformanceEntry {
+  name: string;
+  entryType: PerformanceEntryType;
+  startTime: HighResTimeStamp;
+  duration: HighResTimeStamp;
+
+  constructor(init: {
+    name: string,
+    entryType: PerformanceEntryType,
+    startTime: HighResTimeStamp,
+    duration: HighResTimeStamp,
+  }) {
+    this.name = init.name;
+    this.entryType = init.entryType;
+    this.startTime = init.startTime;
+    this.duration = init.duration;
+  }
+
+  toJSON(): {
+    name: string,
+    entryType: PerformanceEntryType,
+    startTime: HighResTimeStamp,
+    duration: HighResTimeStamp,
+  } {
+    return {
+      name: this.name,
+      entryType: this.entryType,
+      startTime: this.startTime,
+      duration: this.duration,
+    };
+  }
+}