react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactCommon/jsinspector-modern/React-jsinspector.podspec

@@ -18,42 +18,53 @@ end
 
 folly_config = get_folly_config()
 folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
 
-use_frameworks = ENV['USE_FRAMEWORKS'] != nil
+header_search_paths = [
+  "\"$(PODS_ROOT)/boost\"",
+  "\"$(PODS_ROOT)/DoubleConversion\"",
+  "\"$(PODS_ROOT)/fast_float/include\"",
+  "\"$(PODS_ROOT)/fmt/include\"",
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+]
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/..\""
+end
 
 header_dir = 'jsinspector-modern'
 module_name = "jsinspector_modern"
+
 Pod::Spec.new do |s|
   s.name                   = "React-jsinspector"
   s.version                = version
-  s.summary                = "-"  # TODO
+  s.summary                = "React Native subsystem for modern debugging over the Chrome DevTools Protocol (CDP)"
   s.homepage               = "https://reactnative.dev/"
   s.license                = package["license"]
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "*.{cpp,h,def}"
-  s.header_dir             = 'jsinspector-modern'
+  s.source_files           = "*.{cpp,h}"
+  s.header_dir             = header_dir
   s.compiler_flags         = folly_compiler_flags
   s.pod_target_xcconfig    = {
-                               "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/..\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fast_float/include\" \"$(PODS_ROOT)/fmt/include\"",
-                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "DEFINES_MODULE" => "YES"
-  }.merge!(use_frameworks ? {
+  }.merge!(ENV['USE_FRAMEWORKS'] ? {
     "PUBLIC_HEADERS_FOLDER_PATH" => "#{module_name}.framework/Headers/#{header_dir}"
   } : {})
 
-  if use_frameworks
+  if ENV['USE_FRAMEWORKS']
     s.module_name = module_name
   end
 
   s.dependency "glog"
-  s.dependency "RCT-Folly", folly_version
+  s.dependency "RCT-Folly"
   s.dependency "React-featureflags"
   s.dependency "DoubleConversion"
   s.dependency "React-runtimeexecutor", version
   s.dependency "React-jsi"
+  add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
   s.dependency "React-perflogger", version
   if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
     s.dependency "hermes-engine"

package/ReactCommon/jsinspector-modern/TracingAgent.cpp

@@ -7,14 +7,14 @@
 
 #include "TracingAgent.h"
 
-#include <reactperflogger/fusebox/FuseboxTracer.h>
+#include <jsinspector-modern/tracing/PerformanceTracer.h>
 
 namespace facebook::react::jsinspector_modern {
 
 bool TracingAgent::handleRequest(const cdp::PreparsedRequest& req) {
   if (req.method == "Tracing.start") {
     // @cdp Tracing.start support is experimental.
-    if (FuseboxTracer::getFuseboxTracer().startTracing()) {
+    if (PerformanceTracer::getInstance().startTracing()) {
       frontendChannel_(cdp::jsonResult(req.id));
     } else {
       frontendChannel_(cdp::jsonError(
@@ -28,15 +28,16 @@ bool TracingAgent::handleRequest(const cdp::PreparsedRequest& req) {
     // @cdp Tracing.end support is experimental.
     bool firstChunk = true;
     auto id = req.id;
-    bool wasStopped = FuseboxTracer::getFuseboxTracer().stopTracing(
-        [this, firstChunk, id](const folly::dynamic& eventsChunk) {
-          if (firstChunk) {
-            frontendChannel_(cdp::jsonResult(id));
-          }
-          frontendChannel_(cdp::jsonNotification(
-              "Tracing.dataCollected",
-              folly::dynamic::object("value", eventsChunk)));
-        });
+    bool wasStopped =
+        PerformanceTracer::getInstance().stopTracingAndCollectEvents(
+            [this, firstChunk, id](const folly::dynamic& eventsChunk) {
+              if (firstChunk) {
+                frontendChannel_(cdp::jsonResult(id));
+              }
+              frontendChannel_(cdp::jsonNotification(
+                  "Tracing.dataCollected",
+                  folly::dynamic::object("value", eventsChunk)));
+            });
 
     if (!wasStopped) {
       frontendChannel_(cdp::jsonError(

package/ReactCommon/jsinspector-modern/tests/JsiIntegrationTest.cpp

@@ -348,21 +348,6 @@ TYPED_TEST(JsiIntegrationPortableTest, ExceptionDuringAddBindingIsIgnored) {
   EXPECT_TRUE(this->eval("globalThis.foo === 42").getBool());
 }
 
-TYPED_TEST(JsiIntegrationPortableTest, FuseboxSetClientMetadata) {
-  this->connect();
-
-  this->expectMessageFromPage(JsonEq(R"({
-                                          "id": 1,
-                                          "result": {}
-                                        })"));
-
-  this->toPage_->sendMessage(R"({
-                                 "id": 1,
-                                 "method": "FuseboxClient.setClientMetadata",
-                                 "params": {}
-                               })");
-}
-
 TYPED_TEST(JsiIntegrationPortableTest, ReactNativeApplicationEnable) {
   this->connect();
 
@@ -373,7 +358,8 @@ TYPED_TEST(JsiIntegrationPortableTest, ReactNativeApplicationEnable) {
   this->expectMessageFromPage(JsonEq(R"({
                                           "method": "ReactNativeApplication.metadataUpdated",
                                           "params": {
-                                            "integrationName": "JsiIntegrationTest"
+                                            "integrationName": "JsiIntegrationTest",
+                                            "unstable_isProfilingBuild": false
                                           }
                                         })"));
 

package/ReactCommon/jsinspector-modern/tests/ReactInstanceIntegrationTest.cpp

@@ -13,8 +13,6 @@
 #include <folly/json.h>
 #include <glog/logging.h>
 #include <jsinspector-modern/InspectorFlags.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
-#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 #include <react/runtime/hermes/HermesInstance.h>
 
 using namespace ::testing;
@@ -27,23 +25,27 @@ ReactInstanceIntegrationTest::ReactInstanceIntegrationTest()
     : runtime(nullptr),
       instance(nullptr),
       messageQueueThread(std::make_shared<MockMessageQueueThread>()),
-      errorHandler(std::make_shared<ErrorUtils>()) {}
+      errorHandler(std::make_shared<ErrorUtils>()),
+      testMode_(GetParam()) {}
 
 void ReactInstanceIntegrationTest::SetUp() {
+  if (testMode_ == ReactInstanceIntegrationTestMode::LEGACY_HERMES) {
+    InspectorFlags::getInstance().dangerouslyDisableFuseboxForTest();
+  }
+
   auto mockRegistry = std::make_unique<MockTimerRegistry>();
   auto timerManager =
       std::make_shared<react::TimerManager>(std::move(mockRegistry));
 
   auto onJsError = [](jsi::Runtime& /*runtime*/,
-                      const JsErrorHandler::ParsedError& error) noexcept {
+                      const JsErrorHandler::ProcessedError& error) noexcept {
     LOG(INFO) << "[jsErrorHandlingFunc called]";
     LOG(INFO) << error << std::endl;
   };
 
   auto jsRuntimeFactory = std::make_unique<react::HermesInstance>();
   std::unique_ptr<react::JSRuntime> runtime_ =
-      jsRuntimeFactory->createJSRuntime(
-          nullptr, nullptr, messageQueueThread, false);
+      jsRuntimeFactory->createJSRuntime(nullptr, messageQueueThread, false);
   jsi::Runtime* jsiRuntime = &runtime_->getRuntime();
 
   // Error handler:
@@ -129,7 +131,6 @@ void ReactInstanceIntegrationTest::TearDown() {
 
   // Expect the remote connection to have been destroyed.
   EXPECT_EQ(mockRemoteConnections_[0], nullptr);
-  ReactNativeFeatureFlags::dangerouslyReset();
 }
 
 void ReactInstanceIntegrationTest::initializeRuntime(std::string_view script) {
@@ -192,12 +193,12 @@ bool ReactInstanceIntegrationTest::verbose(bool isVerbose) {
 
 #pragma endregion
 
-TEST_F(ReactInstanceIntegrationTest, RuntimeEvalTest) {
+TEST_P(ReactInstanceIntegrationTest, RuntimeEvalTest) {
   auto val = run("1 + 2");
   EXPECT_EQ(val.asNumber(), 3);
 }
 
-TEST_P(ReactInstanceIntegrationTestWithFlags, ConsoleLog) {
+TEST_P(ReactInstanceIntegrationTest, ConsoleLog) {
   EXPECT_CALL(
       getRemoteConnection(),
       onMessage(JsonParsed(
@@ -221,11 +222,10 @@ TEST_P(ReactInstanceIntegrationTestWithFlags, ConsoleLog) {
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    ReactInstanceVaryingInspectorFlags,
-    ReactInstanceIntegrationTestWithFlags,
+    ReactInstanceVaryingInspectorBackend,
+    ReactInstanceIntegrationTest,
     ::testing::Values(
-        InspectorFlagOverrides{.fuseboxEnabledDebug = false},
-        InspectorFlagOverrides{.fuseboxEnabledDebug = false},
-        InspectorFlagOverrides{.fuseboxEnabledDebug = true}));
+        ReactInstanceIntegrationTestMode::LEGACY_HERMES,
+        ReactInstanceIntegrationTestMode::FUSEBOX));
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/ReactInstanceIntegrationTest.h

@@ -10,7 +10,6 @@
 #include "InspectorMocks.h"
 #include "ReactNativeMocks.h"
 #include "UniquePtrFactory.h"
-#include "utils/InspectorFlagOverridesGuard.h"
 
 #include <folly/executors/QueuedImmediateExecutor.h>
 #include <folly/json.h>
@@ -24,11 +23,14 @@ namespace facebook::react::jsinspector_modern {
 
 using namespace ::testing;
 
-struct FeatureFlags {
-  const bool fuseboxEnabledDebug = true;
+enum ReactInstanceIntegrationTestMode {
+  LEGACY_HERMES,
+  FUSEBOX,
 };
 
-class ReactInstanceIntegrationTest : public Test {
+class ReactInstanceIntegrationTest
+    : public Test,
+      public ::testing::WithParamInterface<ReactInstanceIntegrationTestMode> {
  protected:
   ReactInstanceIntegrationTest();
 
@@ -58,6 +60,7 @@ class ReactInstanceIntegrationTest : public Test {
  private:
   void initializeRuntime(std::string_view script);
 
+  ReactInstanceIntegrationTestMode testMode_;
   size_t id_ = 1;
   bool verbose_ = false;
   std::optional<int> pageId_;
@@ -66,13 +69,4 @@ class ReactInstanceIntegrationTest : public Test {
   folly::QueuedImmediateExecutor immediateExecutor_;
 };
 
-class ReactInstanceIntegrationTestWithFlags
-    : public ReactInstanceIntegrationTest,
-      public ::testing::WithParamInterface<InspectorFlagOverrides> {
- protected:
-  ReactInstanceIntegrationTestWithFlags() : inspectorFlagsGuard_(GetParam()) {}
-
- private:
-  InspectorFlagOverridesGuard inspectorFlagsGuard_;
-};
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/engines/JsiIntegrationTestGenericEngineAdapter.cpp

@@ -23,7 +23,7 @@ JsiIntegrationTestGenericEngineAdapter::JsiIntegrationTestGenericEngineAdapter(
 
 /* static */ InspectorFlagOverrides
 JsiIntegrationTestGenericEngineAdapter::getInspectorFlagOverrides() noexcept {
-  return {.fuseboxEnabledDebug = true};
+  return {};
 }
 
 RuntimeTargetDelegate&

package/ReactCommon/jsinspector-modern/tests/engines/JsiIntegrationTestHermesEngineAdapter.cpp

@@ -21,9 +21,7 @@ JsiIntegrationTestHermesEngineAdapter::JsiIntegrationTestHermesEngineAdapter(
 
 /* static */ InspectorFlagOverrides
 JsiIntegrationTestHermesEngineAdapter::getInspectorFlagOverrides() noexcept {
-  return {
-      .fuseboxEnabledDebug = true,
-  };
+  return {};
 }
 
 RuntimeTargetDelegate&

package/ReactCommon/jsinspector-modern/tests/utils/InspectorFlagOverridesGuard.cpp

@@ -26,9 +26,9 @@ class ReactNativeFeatureFlagsOverrides
       const InspectorFlagOverrides& overrides)
       : overrides_(overrides) {}
 
-  bool fuseboxEnabledDebug() override {
-    return overrides_.fuseboxEnabledDebug.value_or(
-        ReactNativeFeatureFlagsDefaults::fuseboxEnabledDebug());
+  bool fuseboxEnabledRelease() override {
+    return overrides_.fuseboxEnabledRelease.value_or(
+        ReactNativeFeatureFlagsDefaults::fuseboxEnabledRelease());
   }
 
  private:

package/ReactCommon/jsinspector-modern/tests/utils/InspectorFlagOverridesGuard.h

@@ -19,7 +19,7 @@ namespace facebook::react::jsinspector_modern {
 struct InspectorFlagOverrides {
   // NOTE: Keep these entries in sync with ReactNativeFeatureFlagsOverrides in
   // the implementation file.
-  std::optional<bool> fuseboxEnabledDebug;
+  std::optional<bool> fuseboxEnabledRelease;
 };
 
 /**

package/ReactCommon/jsinspector-modern/tracing/CMakeLists.txt

@@ -0,0 +1,26 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_ANDROID_DIR}/src/main/jni/first-party/jni-lib-merge/SoMerging-utils.cmake)
+
+add_compile_options(
+        -fexceptions
+        -std=c++20
+        -Wall
+        -Wpedantic)
+
+file(GLOB jsinspector_tracing_SRC CONFIGURE_DEPENDS *.cpp)
+
+add_library(jsinspector_tracing OBJECT ${jsinspector_tracing_SRC})
+target_merge_so(jsinspector_tracing)
+
+target_include_directories(jsinspector_tracing PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(jsinspector_tracing
+        folly_runtime
+)

package/ReactCommon/jsinspector-modern/tracing/CdpTracing.h

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * https://developer.chrome.com/docs/devtools/performance/extension?utm_source=devtools#devtools_object
+ */
+struct DevToolsTrackEntryPayload {
+  std::string track;
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.cpp

@@ -0,0 +1,187 @@
+/*
+ * 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.
+ */
+
+#include "PerformanceTracer.h"
+
+#include <folly/json.h>
+
+#include <mutex>
+#include <unordered_set>
+
+namespace facebook::react::jsinspector_modern {
+
+namespace {
+
+/** Process ID for all emitted events. */
+const uint64_t PID = 1000;
+
+/** Default/starting track ID for the "Timings" track. */
+const uint64_t USER_TIMINGS_DEFAULT_TRACK = 1000;
+
+} // namespace
+
+PerformanceTracer& PerformanceTracer::getInstance() {
+  static PerformanceTracer tracer;
+  return tracer;
+}
+
+bool PerformanceTracer::startTracing() {
+  std::lock_guard lock(mutex_);
+  if (tracing_) {
+    return false;
+  }
+  tracing_ = true;
+  return true;
+}
+
+bool PerformanceTracer::stopTracingAndCollectEvents(
+    const std::function<void(const folly::dynamic& eventsChunk)>&
+        resultCallback) {
+  std::lock_guard lock(mutex_);
+
+  if (!tracing_) {
+    return false;
+  }
+
+  tracing_ = false;
+  if (buffer_.empty()) {
+    customTrackIdMap_.clear();
+    return true;
+  }
+
+  // Register "Main" process
+  buffer_.push_back(TraceEvent{
+      .name = "process_name",
+      .cat = "__metadata",
+      .ph = 'M',
+      .ts = 0,
+      .pid = PID,
+      .tid = 0,
+      .args = folly::dynamic::object("name", "Main"),
+  });
+  // Register "Timings" track
+  // NOTE: This is a hack to make the Trace Viewer show a "Timings" track
+  // adjacent to custom tracks in our current build of Chrome DevTools.
+  // In future, we should align events exactly.
+  buffer_.push_back(TraceEvent{
+      .name = "thread_name",
+      .cat = "__metadata",
+      .ph = 'M',
+      .ts = 0,
+      .pid = PID,
+      .tid = USER_TIMINGS_DEFAULT_TRACK,
+      .args = folly::dynamic::object("name", "Timings"),
+  });
+
+  for (const auto& [trackName, trackId] : customTrackIdMap_) {
+    // Register custom tracks
+    buffer_.push_back(TraceEvent{
+        .name = "thread_name",
+        .cat = "__metadata",
+        .ph = 'M',
+        .ts = 0,
+        .pid = PID,
+        .tid = trackId,
+        .args = folly::dynamic::object("name", trackName),
+    });
+  }
+
+  auto traceEvents = folly::dynamic::array();
+
+  for (auto event : buffer_) {
+    // Emit trace events
+    traceEvents.push_back(serializeTraceEvent(event));
+
+    if (traceEvents.size() >= 1000) {
+      resultCallback(traceEvents);
+      traceEvents = folly::dynamic::array();
+    }
+  }
+  customTrackIdMap_.clear();
+  buffer_.clear();
+
+  if (traceEvents.size() >= 1) {
+    resultCallback(traceEvents);
+  }
+
+  return true;
+}
+
+void PerformanceTracer::reportMark(
+    const std::string_view& name,
+    uint64_t start) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  buffer_.push_back(TraceEvent{
+      .name = std::string(name),
+      .cat = "blink.user_timing",
+      .ph = 'I',
+      .ts = start,
+      .pid = PID, // FIXME: This should be the real process ID.
+      .tid = USER_TIMINGS_DEFAULT_TRACK, // FIXME: This should be the real
+                                         // thread ID.
+  });
+}
+
+void PerformanceTracer::reportMeasure(
+    const std::string_view& name,
+    uint64_t start,
+    uint64_t duration,
+    const std::optional<DevToolsTrackEntryPayload>& trackMetadata) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  // NOTE: We synthetically create custom tracks as a hack to render them in
+  // our current build of Chrome DevTools frontend.
+  // TODO: Remove and align with web.
+  uint64_t threadId = USER_TIMINGS_DEFAULT_TRACK;
+  if (trackMetadata.has_value()) {
+    std::string trackName = trackMetadata.value().track;
+
+    if (!customTrackIdMap_.contains(trackName)) {
+      uint64_t trackId =
+          USER_TIMINGS_DEFAULT_TRACK + customTrackIdMap_.size() + 1;
+      threadId = trackId;
+
+      customTrackIdMap_.emplace(trackName, trackId);
+    }
+  }
+
+  buffer_.push_back(TraceEvent{
+      .name = std::string(name),
+      .cat = "blink.user_timing",
+      .ph = 'X',
+      .ts = start,
+      .pid = PID, // FIXME: This should be the real process ID.
+      .tid = threadId, // FIXME: This should be the real thread ID.
+      .dur = duration,
+  });
+}
+
+folly::dynamic PerformanceTracer::serializeTraceEvent(TraceEvent event) const {
+  folly::dynamic result = folly::dynamic::object;
+
+  result["name"] = event.name;
+  result["cat"] = event.cat;
+  result["ph"] = std::string(1, event.ph);
+  result["ts"] = event.ts;
+  result["pid"] = event.pid;
+  result["tid"] = event.tid;
+  result["args"] = event.args;
+  if (event.dur.has_value()) {
+    result["dur"] = event.dur.value();
+  }
+
+  return result;
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.h

@@ -0,0 +1,126 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include "CdpTracing.h"
+
+#include <folly/dynamic.h>
+
+#include <functional>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::react::jsinspector_modern {
+
+// TODO: Review how this API is integrated into jsinspector_modern (singleton
+// design is copied from earlier FuseboxTracer prototype).
+
+namespace {
+
+/**
+ * A trace event to send to the debugger frontend, as defined by the Trace Event
+ * Format.
+ * https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview?pli=1&tab=t.0#heading=h.yr4qxyxotyw
+ */
+struct TraceEvent {
+  /** The name of the event, as displayed in the Trace Viewer. */
+  std::string name;
+
+  /**
+   * A comma separated list of categories for the event, configuring how
+   * events are shown in the Trace Viewer UI.
+   */
+  std::string cat;
+
+  /**
+   * The event type. This is a single character which changes depending on the
+   * type of event being output. See
+   * https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview?pli=1&tab=t.0#heading=h.puwqg050lyuy
+   */
+  char ph;
+
+  /** The tracing clock timestamp of the event, in microseconds (µs). */
+  uint64_t ts;
+
+  /** The process ID for the process that output this event. */
+  uint64_t pid;
+
+  /** The thread ID for the process that output this event. */
+  uint64_t tid;
+
+  /** Any arguments provided for the event. */
+  folly::dynamic args = folly::dynamic::object();
+
+  /**
+   * The duration of the event, in microseconds (µs). Only applicable to
+   * complete events ("ph": "X").
+   */
+  std::optional<uint64_t> dur;
+};
+
+} // namespace
+
+/**
+ * [Experimental] An interface for logging performance trace events to the
+ * modern debugger server.
+ */
+class PerformanceTracer {
+ public:
+  static PerformanceTracer& getInstance();
+
+  /**
+   * Mark trace session as started. Returns `false` if already tracing.
+   */
+  bool startTracing();
+
+  /**
+   * End tracing, and output chunked CDP trace events using the given
+   * callback.
+   *
+   * Returns `false` if tracing was not started.
+   */
+  bool stopTracingAndCollectEvents(
+      const std::function<void(const folly::dynamic& eventsChunk)>&
+          resultCallback);
+
+  /**
+   * Record a `Performance.mark()` event - a labelled timestamp. If not
+   * currently tracing, this is a no-op.
+   *
+   * See https://w3c.github.io/user-timing/#mark-method.
+   */
+  void reportMark(const std::string_view& name, uint64_t start);
+
+  /**
+   * Record a `Performance.measure()` event - a labelled duration. If not
+   * currently tracing, this is a no-op.
+   *
+   * See https://w3c.github.io/user-timing/#measure-method.
+   */
+  void reportMeasure(
+      const std::string_view& name,
+      uint64_t start,
+      uint64_t duration,
+      const std::optional<DevToolsTrackEntryPayload>& trackMetadata);
+
+ private:
+  PerformanceTracer() = default;
+  PerformanceTracer(const PerformanceTracer&) = delete;
+  PerformanceTracer& operator=(const PerformanceTracer&) = delete;
+  ~PerformanceTracer() = default;
+
+  folly::dynamic serializeTraceEvent(TraceEvent event) const;
+
+  bool tracing_{false};
+  std::unordered_map<std::string, uint64_t> customTrackIdMap_;
+  std::vector<TraceEvent> buffer_;
+  std::mutex mutex_;
+};
+
+} // namespace facebook::react::jsinspector_modern