react-native-tvos 0.78.0-0rc3 → 0.79.0-0

package/ReactCommon/jsinspector-modern/RuntimeAgent.h

@@ -12,6 +12,8 @@
 #include "RuntimeAgentDelegate.h"
 #include "RuntimeTarget.h"
 
+#include <jsinspector-modern/tracing/RuntimeSamplingProfile.h>
+
 namespace facebook::react::jsinspector_modern {
 
 class RuntimeTargetController;
@@ -81,6 +83,27 @@ class RuntimeAgent final {
    */
   ExportedState getExportedState();
 
+  /**
+   * Registers the corresponding RuntimeTarget for Tracing: might enable some
+   * capabilities that will be later used in Tracing Profile.
+   */
+  void registerForTracing();
+
+  /**
+   * Start sampling profiler for the corresponding RuntimeTarget.
+   */
+  void enableSamplingProfiler();
+
+  /**
+   * Stop sampling profiler for the corresponding RuntimeTarget.
+   */
+  void disableSamplingProfiler();
+
+  /**
+   * Return recorded sampling profile for the previous sampling session.
+   */
+  tracing::RuntimeSamplingProfile collectSamplingProfile();
+
  private:
   FrontendChannel frontendChannel_;
   RuntimeTargetController& targetController_;

package/ReactCommon/jsinspector-modern/RuntimeTarget.cpp

@@ -8,6 +8,7 @@
 #include "SessionState.h"
 
 #include <jsinspector-modern/RuntimeTarget.h>
+#include <jsinspector-modern/tracing/PerformanceTracer.h>
 
 using namespace facebook::jsi;
 
@@ -159,4 +160,39 @@ void RuntimeTargetController::notifyDebuggerSessionDestroyed() {
   target_.emitDebuggerSessionDestroyed();
 }
 
+void RuntimeTargetController::registerForTracing() {
+  target_.registerForTracing();
+}
+
+void RuntimeTargetController::enableSamplingProfiler() {
+  target_.enableSamplingProfiler();
+}
+
+void RuntimeTargetController::disableSamplingProfiler() {
+  target_.disableSamplingProfiler();
+}
+
+tracing::RuntimeSamplingProfile
+RuntimeTargetController::collectSamplingProfile() {
+  return target_.collectSamplingProfile();
+}
+
+void RuntimeTarget::registerForTracing() {
+  jsExecutor_([](auto& /*runtime*/) {
+    PerformanceTracer::getInstance().reportJavaScriptThread();
+  });
+}
+
+void RuntimeTarget::enableSamplingProfiler() {
+  delegate_.enableSamplingProfiler();
+}
+
+void RuntimeTarget::disableSamplingProfiler() {
+  delegate_.disableSamplingProfiler();
+}
+
+tracing::RuntimeSamplingProfile RuntimeTarget::collectSamplingProfile() {
+  return delegate_.collectSamplingProfile();
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/RuntimeTarget.h

@@ -7,8 +7,6 @@
 
 #pragma once
 
-#include <ReactCommon/RuntimeExecutor.h>
-
 #include "ConsoleMessage.h"
 #include "ExecutionContext.h"
 #include "InspectorInterfaces.h"
@@ -17,6 +15,9 @@
 #include "StackTrace.h"
 #include "WeakList.h"
 
+#include <ReactCommon/RuntimeExecutor.h>
+#include <jsinspector-modern/tracing/RuntimeSamplingProfile.h>
+
 #include <memory>
 
 #ifndef JSINSPECTOR_EXPORT
@@ -90,6 +91,21 @@ class RuntimeTargetDelegate {
   virtual std::unique_ptr<StackTrace> captureStackTrace(
       jsi::Runtime& runtime,
       size_t framesToSkip = 0) = 0;
+
+  /**
+   * Start sampling profiler.
+   */
+  virtual void enableSamplingProfiler() = 0;
+
+  /**
+   * Stop sampling profiler.
+   */
+  virtual void disableSamplingProfiler() = 0;
+
+  /**
+   * Return recorded sampling profile for the previous sampling session.
+   */
+  virtual tracing::RuntimeSamplingProfile collectSamplingProfile() = 0;
 };
 
 /**
@@ -118,6 +134,27 @@ class RuntimeTargetController {
    */
   void notifyDebuggerSessionDestroyed();
 
+  /**
+   * Registers the corresponding RuntimeTarget for Tracing: might enable some
+   * capabilities that will be later used in Tracing Profile.
+   */
+  void registerForTracing();
+
+  /**
+   * Start sampling profiler for the corresponding RuntimeTarget.
+   */
+  void enableSamplingProfiler();
+
+  /**
+   * Stop sampling profiler for the corresponding RuntimeTarget.
+   */
+  void disableSamplingProfiler();
+
+  /**
+   * Return recorded sampling profile for the previous sampling session.
+   */
+  tracing::RuntimeSamplingProfile collectSamplingProfile();
+
  private:
   RuntimeTarget& target_;
 };
@@ -171,6 +208,27 @@ class JSINSPECTOR_EXPORT RuntimeTarget
       FrontendChannel channel,
       SessionState& sessionState);
 
+  /**
+   * Registers this Runtime for Tracing: might enable some
+   * capabilities that will be later used in Tracing Profile.
+   */
+  void registerForTracing();
+
+  /**
+   * Start sampling profiler for a particular JavaScript runtime.
+   */
+  void enableSamplingProfiler();
+
+  /**
+   * Stop sampling profiler for a particular JavaScript runtime.
+   */
+  void disableSamplingProfiler();
+
+  /**
+   * Return recorded sampling profile for the previous sampling session.
+   */
+  tracing::RuntimeSamplingProfile collectSamplingProfile();
+
  private:
   /**
    * Constructs a new RuntimeTarget. The caller must call setExecutor

package/ReactCommon/jsinspector-modern/TracingAgent.cpp

@@ -8,53 +8,99 @@
 #include "TracingAgent.h"
 
 #include <jsinspector-modern/tracing/PerformanceTracer.h>
+#include <jsinspector-modern/tracing/RuntimeSamplingProfileTraceEventSerializer.h>
 
 namespace facebook::react::jsinspector_modern {
 
+namespace {
+
+/**
+ * Threshold for the size Trace Event chunk, that will be flushed out with
+ * Tracing.dataCollected event.
+ */
+const uint16_t TRACE_EVENT_CHUNK_SIZE = 1000;
+
+} // namespace
+
 bool TracingAgent::handleRequest(const cdp::PreparsedRequest& req) {
   if (req.method == "Tracing.start") {
     // @cdp Tracing.start support is experimental.
-    if (PerformanceTracer::getInstance().startTracing()) {
-      frontendChannel_(cdp::jsonResult(req.id));
-    } else {
+    if (!instanceAgent_) {
+      frontendChannel_(cdp::jsonError(
+          req.id,
+          cdp::ErrorCode::InternalError,
+          "Couldn't find instance available for Tracing"));
+
+      return true;
+    }
+
+    bool correctlyStartedPerformanceTracer =
+        PerformanceTracer::getInstance().startTracing();
+
+    if (!correctlyStartedPerformanceTracer) {
       frontendChannel_(cdp::jsonError(
           req.id,
           cdp::ErrorCode::InternalError,
           "Tracing session already started"));
+
+      return true;
     }
 
+    instanceAgent_->startTracing();
+    instanceTracingStartTimestamp_ = std::chrono::steady_clock::now();
+    frontendChannel_(cdp::jsonResult(req.id));
+
     return true;
   } else if (req.method == "Tracing.end") {
     // @cdp Tracing.end support is experimental.
-    bool firstChunk = true;
-    auto id = req.id;
-    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) {
+    if (!instanceAgent_) {
+      frontendChannel_(cdp::jsonError(
+          req.id,
+          cdp::ErrorCode::InternalError,
+          "Couldn't find instance available for Tracing"));
+
+      return true;
+    }
+    instanceAgent_->stopTracing();
+    tracing::RuntimeSamplingProfileTraceEventSerializer::serializeAndBuffer(
+        PerformanceTracer::getInstance(),
+        instanceAgent_->collectTracingProfile().getRuntimeSamplingProfile(),
+        instanceTracingStartTimestamp_);
+
+    bool correctlyStopped = PerformanceTracer::getInstance().stopTracing();
+    if (!correctlyStopped) {
       frontendChannel_(cdp::jsonError(
           req.id,
           cdp::ErrorCode::InternalError,
           "Tracing session not started"));
-    } else {
-      frontendChannel_(cdp::jsonNotification(
-          "Tracing.tracingComplete",
-          folly::dynamic::object("dataLossOccurred", false)));
+
+      return true;
     }
 
+    // Send response to Tracing.end request.
     frontendChannel_(cdp::jsonResult(req.id));
+
+    PerformanceTracer::getInstance().collectEvents(
+        [this](const folly::dynamic& eventsChunk) {
+          frontendChannel_(cdp::jsonNotification(
+              "Tracing.dataCollected",
+              folly::dynamic::object("value", eventsChunk)));
+        },
+        TRACE_EVENT_CHUNK_SIZE);
+
+    frontendChannel_(cdp::jsonNotification(
+        "Tracing.tracingComplete",
+        folly::dynamic::object("dataLossOccurred", false)));
+
     return true;
   }
 
   return false;
 }
 
+void TracingAgent::setCurrentInstanceAgent(
+    std::shared_ptr<InstanceAgent> instanceAgent) {
+  instanceAgent_ = std::move(instanceAgent);
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/TracingAgent.h

@@ -9,6 +9,7 @@
 
 #include "CdpJson.h"
 #include "InspectorInterfaces.h"
+#include "InstanceAgent.h"
 
 namespace facebook::react::jsinspector_modern {
 
@@ -31,11 +32,30 @@ class TracingAgent {
    */
   bool handleRequest(const cdp::PreparsedRequest& req);
 
+  /**
+   * Replace the current InstanceAgent with the given one.
+   * \param agent The new InstanceAgent. May be null to signify that there is
+   * currently no active instance.
+   */
+  void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> agent);
+
  private:
   /**
    * A channel used to send responses and events to the frontend.
    */
   FrontendChannel frontendChannel_;
+
+  /**
+   * Current InstanceAgent. May be null to signify that there is
+   * currently no active instance.
+   */
+  std::shared_ptr<InstanceAgent> instanceAgent_;
+
+  /**
+   * Timestamp of when we started tracing of an Instance, will be used as a
+   * a start of JavaScript samples recording.
+   */
+  std::chrono::steady_clock::time_point instanceTracingStartTimestamp_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/WebSocketInterfaces.h

@@ -15,7 +15,6 @@ namespace facebook::react::jsinspector_modern {
 
 /**
  * Simplified interface to a WebSocket connection.
- * The socket MUST be initially open when constructed.
  */
 class IWebSocket {
  public:
@@ -56,6 +55,13 @@ class IWebSocketDelegate {
    */
   virtual void didReceiveMessage(std::string_view message) = 0;
 
+  /**
+   * Called when the socket has been opened.
+   * This method must be called on the inspector queue, and the
+   * WebSocketDelegate may not be destroyed while it is executing.
+   */
+  virtual void didOpen() = 0;
+
   /**
    * Called when the socket has been closed. The call is not required if
    * didFailWithError was called instead.

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

@@ -19,6 +19,7 @@
 #include "FollyDynamicMatchers.h"
 #include "InspectorMocks.h"
 #include "UniquePtrFactory.h"
+#include "utils/InspectorFlagOverridesGuard.h"
 
 using namespace ::testing;
 
@@ -28,6 +29,7 @@ namespace {
 
 class HostTargetTest : public Test {
   folly::QueuedImmediateExecutor immediateExecutor_;
+  InspectorFlagOverridesGuard inspectorFlagsGuard_{{}};
 
  protected:
   HostTargetTest() {

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

@@ -161,6 +161,13 @@ class MockRuntimeTargetDelegate : public RuntimeTargetDelegate {
       captureStackTrace,
       (jsi::Runtime & runtime, size_t framesToSkip),
       (override));
+  MOCK_METHOD(void, enableSamplingProfiler, (), (override));
+  MOCK_METHOD(void, disableSamplingProfiler, (), (override));
+  MOCK_METHOD(
+      tracing::RuntimeSamplingProfile,
+      collectSamplingProfile,
+      (),
+      (override));
 };
 
 class MockRuntimeAgentDelegate : public RuntimeAgentDelegate {

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

@@ -16,7 +16,6 @@
 #include <jsinspector-modern/InspectorInterfaces.h>
 #include <jsinspector-modern/InspectorPackagerConnection.h>
 
-#include <functional>
 #include <memory>
 
 #include "FollyDynamicMatchers.h"
@@ -42,10 +41,15 @@ class InspectorPackagerConnectionTestBase : public testing::Test {
             "my-device",
             "my-app",
             packagerConnectionDelegates_.make_unique(asyncExecutor_)}) {
+    auto makeSocket = webSockets_.lazily_make_unique<
+        const std::string&,
+        std::weak_ptr<IWebSocketDelegate>>();
     ON_CALL(*packagerConnectionDelegate(), connectWebSocket(_, _))
-        .WillByDefault(webSockets_.lazily_make_unique<
-                       const std::string&,
-                       std::weak_ptr<IWebSocketDelegate>>());
+        .WillByDefault([makeSocket](auto&&... args) {
+          auto socket = makeSocket(std::forward<decltype(args)>(args)...);
+          socket->getDelegate().didOpen();
+          return std::move(socket);
+        });
   }
 
   void TearDown() override {

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

@@ -359,7 +359,8 @@ TYPED_TEST(JsiIntegrationPortableTest, ReactNativeApplicationEnable) {
                                           "method": "ReactNativeApplication.metadataUpdated",
                                           "params": {
                                             "integrationName": "JsiIntegrationTest",
-                                            "unstable_isProfilingBuild": false
+                                            "unstable_isProfilingBuild": false,
+                                            "unstable_networkInspectionEnabled": false
                                           }
                                         })"));
 
@@ -689,7 +690,7 @@ TYPED_TEST(JsiIntegrationHermesTest, ScriptParsedExactlyOnce) {
 
 TYPED_TEST(JsiIntegrationHermesTest, FunctionDescriptionIncludesName) {
   // See
-  // https://github.com/facebookexperimental/rn-chrome-devtools-frontend/blob/9a23d4c7c4c2d1a3d9e913af38d6965f474c4284/front_end/ui/legacy/components/object_ui/ObjectPropertiesSection.ts#L311-L391
+  // https://github.com/facebook/react-native-devtools-frontend/blob/9a23d4c7c4c2d1a3d9e913af38d6965f474c4284/front_end/ui/legacy/components/object_ui/ObjectPropertiesSection.ts#L311-L391
 
   this->connect();
 

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

@@ -31,6 +31,11 @@ class ReactNativeFeatureFlagsOverrides
         ReactNativeFeatureFlagsDefaults::fuseboxEnabledRelease());
   }
 
+  bool fuseboxNetworkInspectionEnabled() override {
+    return overrides_.networkInspectionEnabled.value_or(
+        ReactNativeFeatureFlagsDefaults::fuseboxNetworkInspectionEnabled());
+  }
+
  private:
   InspectorFlagOverrides overrides_;
 };

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

@@ -20,6 +20,7 @@ struct InspectorFlagOverrides {
   // NOTE: Keep these entries in sync with ReactNativeFeatureFlagsOverrides in
   // the implementation file.
   std::optional<bool> fuseboxEnabledRelease;
+  std::optional<bool> networkInspectionEnabled;
 };
 
 /**

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

@@ -23,4 +23,5 @@ target_include_directories(jsinspector_tracing PUBLIC ${REACT_COMMON_DIR})
 
 target_link_libraries(jsinspector_tracing
         folly_runtime
+        oscompat
 )

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

@@ -0,0 +1,49 @@
+/*
+ * 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 "EventLoopTaskReporter.h"
+
+#if defined(REACT_NATIVE_DEBUGGER_ENABLED)
+#include "PerformanceTracer.h"
+#endif
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+#if defined(REACT_NATIVE_DEBUGGER_ENABLED)
+namespace {
+
+inline uint64_t formatTimePointToUnixTimestamp(
+    std::chrono::steady_clock::time_point timestamp) {
+  return std::chrono::duration_cast<std::chrono::microseconds>(
+             timestamp.time_since_epoch())
+      .count();
+}
+
+} // namespace
+
+EventLoopTaskReporter::EventLoopTaskReporter()
+    : startTimestamp_(std::chrono::steady_clock::now()) {}
+
+EventLoopTaskReporter::~EventLoopTaskReporter() {
+  PerformanceTracer& performanceTracer = PerformanceTracer::getInstance();
+  if (performanceTracer.isTracing()) {
+    auto end = std::chrono::steady_clock::now();
+    performanceTracer.reportEventLoopTask(
+        formatTimePointToUnixTimestamp(startTimestamp_),
+        formatTimePointToUnixTimestamp(end));
+  }
+}
+
+#else
+
+EventLoopTaskReporter::EventLoopTaskReporter() {}
+
+EventLoopTaskReporter::~EventLoopTaskReporter() {}
+
+#endif
+
+} // namespace facebook::react::jsinspector_modern::tracing

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

@@ -0,0 +1,31 @@
+/*
+ * 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 <chrono>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+struct EventLoopTaskReporter {
+ public:
+  EventLoopTaskReporter();
+
+  EventLoopTaskReporter(const EventLoopTaskReporter&) = delete;
+  EventLoopTaskReporter(EventLoopTaskReporter&&) = delete;
+  EventLoopTaskReporter& operator=(const EventLoopTaskReporter&) = delete;
+  EventLoopTaskReporter& operator=(EventLoopTaskReporter&&) = delete;
+
+  ~EventLoopTaskReporter();
+
+ private:
+#if defined(REACT_NATIVE_DEBUGGER_ENABLED)
+  std::chrono::steady_clock::time_point startTimestamp_;
+#endif
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

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

@@ -0,0 +1,30 @@
+/*
+ * 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 "RuntimeSamplingProfile.h"
+
+#include <memory>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+struct InstanceTracingProfile {
+ public:
+  explicit InstanceTracingProfile(
+      const RuntimeSamplingProfile runtimeSamplingProfile)
+      : runtimeSamplingProfile_(runtimeSamplingProfile) {}
+
+  const RuntimeSamplingProfile& getRuntimeSamplingProfile() const {
+    return runtimeSamplingProfile_;
+  }
+
+ private:
+  RuntimeSamplingProfile runtimeSamplingProfile_;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing