Clarify HostTracingProfile and HostTraceRecordingState (facebook#54677)

Summary:
Pull Request resolved: facebook#54677

# Changelog: [Internal]

Currently, `HostTraceRecordingState` is used everywhere and it is the final data struct that contains the tracing profile.

At the same time, the original idea for it was to be a global state for Tracing Agents, where they could:
1. Read the tracing configuration, like tracing mode, enabled categories, etc.
2. Stash corresponding target profiles on reloads. For example, if `RuntimeTarget` was reloaded during tracing, `RuntimeTracingAgent` would stop JavaScript sampling profiler, and then stash this profile on a state.

This change should clarify the data structures and when they are used.

Reviewed By: sbuggay

Differential Revision: D87830455

fbshipit-source-id: 15c48baede85a2d85744d9c3c3b7a419c1f1d299

Author: hoxyq

packages/react-native/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -192,7 +192,7 @@ bool JReactHostInspectorTarget::startBackgroundTrace() {
   }
 }
 
-tracing::TraceRecordingState JReactHostInspectorTarget::stopTracing() {
+tracing::HostTracingProfile JReactHostInspectorTarget::stopTracing() {
   if (inspectorTarget_) {
     return inspectorTarget_->stopTracing();
   } else {
@@ -205,29 +205,29 @@ tracing::TraceRecordingState JReactHostInspectorTarget::stopTracing() {
 jboolean JReactHostInspectorTarget::stopAndMaybeEmitBackgroundTrace() {
   auto capturedTrace = inspectorTarget_->stopTracing();
   if (inspectorTarget_->hasActiveSessionWithFuseboxClient()) {
-    inspectorTarget_->emitTraceRecordingForFirstFuseboxClient(
+    inspectorTarget_->emitTracingProfileForFirstFuseboxClient(
         std::move(capturedTrace));
     return jboolean(true);
   }
 
-  stashTraceRecordingState(std::move(capturedTrace));
+  stashTracingProfile(std::move(capturedTrace));
   return jboolean(false);
 }
 
 void JReactHostInspectorTarget::stopAndDiscardBackgroundTrace() {
   inspectorTarget_->stopTracing();
 }
 
-void JReactHostInspectorTarget::stashTraceRecordingState(
-    tracing::TraceRecordingState&& state) {
-  stashedTraceRecordingState_ = std::move(state);
+void JReactHostInspectorTarget::stashTracingProfile(
+    tracing::HostTracingProfile&& hostTracingProfile) {
+  stashedTracingProfile_ = std::move(hostTracingProfile);
 }
 
-std::optional<tracing::TraceRecordingState> JReactHostInspectorTarget::
-    unstable_getTraceRecordingThatWillBeEmittedOnInitialization() {
-  auto state = std::move(stashedTraceRecordingState_);
-  stashedTraceRecordingState_.reset();
-  return state;
+std::optional<tracing::HostTracingProfile> JReactHostInspectorTarget::
+    unstable_getHostTracingProfileThatWillBeEmittedOnInitialization() {
+  auto tracingProfile = std::move(stashedTracingProfile_);
+  stashedTracingProfile_.reset();
+  return tracingProfile;
 }
 
 void JReactHostInspectorTarget::registerNatives() {

packages/react-native/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -193,8 +193,8 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
   void loadNetworkResource(
       const jsinspector_modern::LoadNetworkResourceRequest &params,
       jsinspector_modern::ScopedExecutor<jsinspector_modern::NetworkRequestListener> executor) override;
-  std::optional<jsinspector_modern::tracing::TraceRecordingState>
-  unstable_getTraceRecordingThatWillBeEmittedOnInitialization() override;
+  std::optional<jsinspector_modern::tracing::HostTracingProfile>
+  unstable_getHostTracingProfileThatWillBeEmittedOnInitialization() override;
   jsinspector_modern::HostTargetTracingDelegate *getTracingDelegate() override;
 
  private:
@@ -213,20 +213,19 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
   std::optional<int> inspectorPageId_;
 
   /**
-   * Stops previously started trace recording and returns the captured trace.
+   * Stops previously started trace recording and returns the captured HostTracingProfile.
    */
-  jsinspector_modern::tracing::TraceRecordingState stopTracing();
+  jsinspector_modern::tracing::HostTracingProfile stopTracing();
   /**
-   * Stashes previously recorded trace recording state that will be emitted when
+   * Stashes previously recorded HostTracingProfile that will be emitted when
    * CDP session is created. Once emitted, the value will be cleared from this
    * instance.
    */
-  void stashTraceRecordingState(jsinspector_modern::tracing::TraceRecordingState &&state);
+  void stashTracingProfile(jsinspector_modern::tracing::HostTracingProfile &&hostTracingProfile);
   /**
-   * Previously recorded trace recording state that will be emitted when
-   * CDP session is created.
+   * Previously recorded HostTracingProfile that will be emitted when CDP session is created.
    */
-  std::optional<jsinspector_modern::tracing::TraceRecordingState> stashedTraceRecordingState_;
+  std::optional<jsinspector_modern::tracing::HostTracingProfile> stashedTracingProfile_;
   /**
    * Encapsulates the logic around tracing for this HostInspectorTarget.
    */

packages/react-native/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -238,9 +238,9 @@ class HostAgent::Impl final {
 
       auto stashedTraceRecording =
           targetController_.getDelegate()
-              .unstable_getTraceRecordingThatWillBeEmittedOnInitialization();
+              .unstable_getHostTracingProfileThatWillBeEmittedOnInitialization();
       if (stashedTraceRecording.has_value()) {
-        tracingAgent_.emitExternalTraceRecording(
+        tracingAgent_.emitExternalHostTracingProfile(
             std::move(stashedTraceRecording.value()));
       }
 
@@ -385,12 +385,12 @@ class HostAgent::Impl final {
     return fuseboxClientType_ == FuseboxClientType::Fusebox;
   }
 
-  void emitExternalTraceRecording(
-      tracing::TraceRecordingState traceRecording) const {
+  void emitExternalTracingProfile(
+      tracing::HostTracingProfile tracingProfile) const {
     assert(
         hasFuseboxClientConnected() &&
         "Attempted to emit a trace recording to a non-Fusebox client");
-    tracingAgent_.emitExternalTraceRecording(std::move(traceRecording));
+    tracingAgent_.emitExternalHostTracingProfile(std::move(tracingProfile));
   }
 
   void emitSystemStateChanged(bool isSingleHost) {
@@ -506,8 +506,7 @@ class HostAgent::Impl final {
   bool hasFuseboxClientConnected() const {
     return false;
   }
-  void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) {
-  }
+  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) {}
   void emitSystemStateChanged(bool isSingleHost) {}
 };
 
@@ -543,9 +542,9 @@ bool HostAgent::hasFuseboxClientConnected() const {
   return impl_->hasFuseboxClientConnected();
 }
 
-void HostAgent::emitExternalTraceRecording(
-    tracing::TraceRecordingState traceRecording) const {
-  impl_->emitExternalTraceRecording(std::move(traceRecording));
+void HostAgent::emitExternalTracingProfile(
+    tracing::HostTracingProfile tracingProfile) const {
+  impl_->emitExternalTracingProfile(std::move(tracingProfile));
 }
 
 void HostAgent::emitSystemStateChanged(bool isSingleHost) const {

packages/react-native/ReactCommon/jsinspector-modern/HostAgent.h

@@ -74,10 +74,10 @@ class HostAgent final {
   bool hasFuseboxClientConnected() const;
 
   /**
-   * Emits the trace recording that was captured externally, not via the
+   * Emits the HostTracingProfile that was captured externally, not via the
    * CDP-initiated request.
    */
-  void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) const;
+  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) const;
 
   /**
    * Emits a system state changed event when the number of ReactHost instances

packages/react-native/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -111,8 +111,9 @@ class HostTargetSession {
     return hostAgent_.hasFuseboxClientConnected();
   }
 
-  void emitTraceRecording(tracing::TraceRecordingState traceRecording) const {
-    hostAgent_.emitExternalTraceRecording(std::move(traceRecording));
+  void emitHostTracingProfile(
+      tracing::HostTracingProfile tracingProfile) const {
+    hostAgent_.emitExternalTracingProfile(std::move(tracingProfile));
   }
 
  private:
@@ -382,21 +383,21 @@ bool HostTarget::hasActiveSessionWithFuseboxClient() const {
   return hasActiveFuseboxSession;
 }
 
-void HostTarget::emitTraceRecordingForFirstFuseboxClient(
-    tracing::TraceRecordingState traceRecording) const {
+void HostTarget::emitTracingProfileForFirstFuseboxClient(
+    tracing::HostTracingProfile tracingProfile) const {
   bool emitted = false;
   sessions_.forEach([&](HostTargetSession& session) {
     if (emitted) {
       /**
-       * TraceRecordingState object is not copiable for performance reasons,
+       * HostTracingProfile object is not copiable for performance reasons,
        * because it could contain large Runtime sampling profile object.
        *
        * This approach would not work with multi-client debugger setup.
        */
       return;
     }
     if (session.hasFuseboxClient()) {
-      session.emitTraceRecording(std::move(traceRecording));
+      session.emitHostTracingProfile(std::move(tracingProfile));
       emitted = true;
     }
   });

packages/react-native/ReactCommon/jsinspector-modern/HostTarget.h

@@ -20,6 +20,8 @@
 #include <set>
 #include <string>
 
+#include <jsinspector-modern/tracing/HostTracingProfile.h>
+#include <jsinspector-modern/tracing/TraceRecordingState.h>
 #include <jsinspector-modern/tracing/TracingCategory.h>
 #include <jsinspector-modern/tracing/TracingMode.h>
 
@@ -183,10 +185,10 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
    * trace recording that may have been stashed by the Host from the previous
    * background session.
    *
-   * \return the trace recording state if there is one that needs to be
+   * \return the HostTracingProfile if there is one that needs to be
    * displayed, otherwise std::nullopt.
    */
-  virtual std::optional<tracing::TraceRecordingState> unstable_getTraceRecordingThatWillBeEmittedOnInitialization()
+  virtual std::optional<tracing::HostTracingProfile> unstable_getHostTracingProfileThatWillBeEmittedOnInitialization()
   {
     return std::nullopt;
   }
@@ -251,7 +253,7 @@ class HostTargetController final {
   /**
    * Stops previously started trace recording.
    */
-  tracing::TraceRecordingState stopTracing();
+  tracing::HostTracingProfile stopTracing();
 
  private:
   HostTarget &target_;
@@ -345,7 +347,7 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
   /**
    * Stops previously started trace recording.
    */
-  tracing::TraceRecordingState stopTracing();
+  tracing::HostTracingProfile stopTracing();
 
   /**
    * Returns whether there is an active session with the Fusebox client, i.e.
@@ -354,12 +356,12 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
   bool hasActiveSessionWithFuseboxClient() const;
 
   /**
-   * Emits the trace recording for the first active session with the Fusebox
+   * Emits the HostTracingProfile for the first active session with the Fusebox
    * client.
    *
    * @see \c hasActiveFrontendSession
    */
-  void emitTraceRecordingForFirstFuseboxClient(tracing::TraceRecordingState traceRecording) const;
+  void emitTracingProfileForFirstFuseboxClient(tracing::HostTracingProfile tracingProfile) const;
 
  private:
   /**

packages/react-native/ReactCommon/jsinspector-modern/HostTargetTraceRecording.cpp

@@ -8,6 +8,8 @@
 #include "HostTargetTraceRecording.h"
 #include "HostTarget.h"
 
+#include <oscompat/OSCompat.h>
+
 namespace facebook::react::jsinspector_modern {
 
 HostTargetTraceRecording::HostTargetTraceRecording(
@@ -32,15 +34,15 @@ void HostTargetTraceRecording::start() {
       hostTracingAgent_ == nullptr &&
       "Tracing Agent for the HostTarget was already initialized.");
 
+  startTime_ = HighResTimeStamp::now();
   state_ = tracing::TraceRecordingState{
       .mode = tracingMode_,
-      .startTime = HighResTimeStamp::now(),
       .enabledCategories = enabledCategories_,
   };
   hostTracingAgent_ = hostTarget_.createTracingAgent(*state_);
 }
 
-tracing::TraceRecordingState HostTargetTraceRecording::stop() {
+tracing::HostTracingProfile HostTargetTraceRecording::stop() {
   assert(
       hostTracingAgent_ != nullptr &&
       "TracingAgent for the HostTarget has not been initialized.");
@@ -52,7 +54,15 @@ tracing::TraceRecordingState HostTargetTraceRecording::stop() {
   auto state = std::move(*state_);
   state_.reset();
 
-  return state;
+  auto startTime = *startTime_;
+  startTime_.reset();
+
+  return tracing::HostTracingProfile{
+      .processId = oscompat::getCurrentProcessId(),
+      .startTime = startTime,
+      .instanceTracingProfiles = std::move(state.instanceTracingProfiles),
+      .runtimeSamplingProfiles = std::move(state.runtimeSamplingProfiles),
+  };
 }
 
 } // namespace facebook::react::jsinspector_modern

packages/react-native/ReactCommon/jsinspector-modern/HostTargetTraceRecording.h

@@ -11,6 +11,7 @@
 #include "HostTarget.h"
 #include "InstanceTarget.h"
 
+#include <jsinspector-modern/tracing/HostTracingProfile.h>
 #include <jsinspector-modern/tracing/TraceRecordingState.h>
 #include <jsinspector-modern/tracing/TracingCategory.h>
 
@@ -58,11 +59,11 @@ class HostTargetTraceRecording {
   void start();
 
   /**
-   * Stops the recording and drops the recording state.
+   * Stops the recording and returns the recorded HostTracingProfile.
    *
    * Will deallocate all Tracing Agents.
    */
-  tracing::TraceRecordingState stop();
+  tracing::HostTracingProfile stop();
 
  private:
   /**
@@ -75,6 +76,11 @@ class HostTargetTraceRecording {
    */
   tracing::Mode tracingMode_;
 
+  /**
+   * The timestamp at which this Trace Recording started.
+   */
+  std::optional<HighResTimeStamp> startTime_;
+
   /**
    * The state of the current Trace Recording.
    * Only allocated if the recording is enabled.

packages/react-native/ReactCommon/jsinspector-modern/HostTargetTracing.cpp

@@ -16,7 +16,7 @@ bool HostTargetController::startTracing(
   return target_.startTracing(tracingMode, std::move(enabledCategories));
 }
 
-tracing::TraceRecordingState HostTargetController::stopTracing() {
+tracing::HostTracingProfile HostTargetController::stopTracing() {
   return target_.stopTracing();
 }
 
@@ -54,17 +54,17 @@ bool HostTarget::startTracing(
   return true;
 }
 
-tracing::TraceRecordingState HostTarget::stopTracing() {
+tracing::HostTracingProfile HostTarget::stopTracing() {
   assert(traceRecording_ != nullptr && "No tracing in progress");
 
   if (auto tracingDelegate = delegate_.getTracingDelegate()) {
     tracingDelegate->onTracingStopped();
   }
 
-  auto state = traceRecording_->stop();
+  auto profile = traceRecording_->stop();
   traceRecording_.reset();
 
-  return state;
+  return profile;
 }
 
 } // namespace facebook::react::jsinspector_modern