react-native 0.84.0-nightly-20251106-de5141a3d → 0.84.0-nightly-20251108-7486a2bc5

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

@@ -0,0 +1,131 @@
+/*
+ * 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 <folly/executors/QueuedImmediateExecutor.h>
+
+#include "JsiIntegrationTest.h"
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+
+#include <jsinspector-modern/ConsoleTaskOrchestrator.h>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * A test fixture for the console.createTask API.
+ */
+class ConsoleCreateTaskTest : public JsiIntegrationPortableTestBase<
+                                  JsiIntegrationTestHermesEngineAdapter,
+                                  folly::QueuedImmediateExecutor> {};
+
+TEST_F(ConsoleCreateTaskTest, Installed) {
+  auto result = eval("typeof console.createTask");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "function");
+}
+
+TEST_F(ConsoleCreateTaskTest, ReturnsTaskObject) {
+  auto result = eval("typeof console.createTask('test-task')");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "object");
+}
+
+TEST_F(ConsoleCreateTaskTest, TaskObjectHasRunMethod) {
+  auto result = eval("typeof console.createTask('test-task').run");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "function");
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodExecutesFunction) {
+  auto result = eval(R"(
+    let executed = false;
+    const task = console.createTask('test-task');
+    task.run(() => { executed = true; });
+    executed;
+  )");
+  EXPECT_TRUE(result.getBool());
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodReturnsValue) {
+  auto result = eval(R"(
+    const task = console.createTask('test-task');
+    task.run(() => 42);
+  )");
+  EXPECT_EQ(result.getNumber(), 42);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnNoArguments) {
+  EXPECT_THROW(eval("console.createTask()"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnEmptyString) {
+  EXPECT_THROW(eval("console.createTask('')"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnNonStringArgument) {
+  EXPECT_THROW(eval("console.createTask(123)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask(null)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask(undefined)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask({})"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodThrowsOnNoArguments) {
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run();
+  )"),
+      facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodThrowsOnNonFunction) {
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run(123);
+  )"),
+      facebook::jsi::JSError);
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run('not a function');
+  )"),
+      facebook::jsi::JSError);
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run({});
+  )"),
+      facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, MultipleTasksCanBeCreated) {
+  auto result = eval(R"(
+    const task1 = console.createTask('task-1');
+    const task2 = console.createTask('task-2');
+    let count = 0;
+    task1.run(() => { count++; });
+    task2.run(() => { count++; });
+    count;
+  )");
+  EXPECT_EQ(result.getNumber(), 2);
+}
+
+TEST_F(ConsoleCreateTaskTest, TaskCanBeRunMultipleTimes) {
+  auto result = eval(R"(
+    const task = console.createTask('test-task');
+    let count = 0;
+    task.run(() => { count++; });
+    task.run(() => { count++; });
+    task.run(() => { count++; });
+    count;
+  )");
+  EXPECT_EQ(result.getNumber(), 3);
+}
+
+} // namespace facebook::react::jsinspector_modern

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

@@ -14,6 +14,7 @@
 #include <glog/logging.h>
 #include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/runtime/JSRuntimeBindings.h>
 #include <react/runtime/hermes/HermesInstance.h>
 
 using namespace ::testing;

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

@@ -0,0 +1,59 @@
+/*
+ * 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 "TracingTest.h"
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+
+#include <folly/executors/QueuedImmediateExecutor.h>
+#include <jsinspector-modern/InspectorFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/networking/NetworkReporter.h>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+class TracingTest : public TracingTestBase<
+                        JsiIntegrationTestHermesEngineAdapter,
+                        folly::QueuedImmediateExecutor> {
+ protected:
+  TracingTest() : TracingTestBase() {}
+
+  void SetUp() override {
+    JsiIntegrationPortableTestBase::SetUp();
+    connect();
+    EXPECT_CALL(
+        fromPage(),
+        onMessage(
+            JsonParsed(AllOf(AtJsonPtr("/method", "Debugger.scriptParsed")))))
+        .Times(AnyNumber());
+  }
+};
+
+TEST_F(TracingTest, EnablesSamplingProfilerOnlyCategoryIsSpecified) {
+  InSequence s;
+
+  startTracing({});
+  auto allTraceEvents = endTracingAndCollectEvents();
+
+  EXPECT_THAT(
+      allTraceEvents,
+      Not(Contains(AllOf(
+          AtJsonPtr("/name", "Profile"),
+          AtJsonPtr("/cat", "disabled-by-default-v8.cpu_profiler")))));
+
+  startTracing({tracing::Category::JavaScriptSampling});
+  allTraceEvents = endTracingAndCollectEvents();
+
+  EXPECT_THAT(
+      allTraceEvents,
+      Contains(AllOf(
+          AtJsonPtr("/name", "Profile"),
+          AtJsonPtr("/cat", "disabled-by-default-v8.cpu_profiler"))));
+}
+
+} // namespace facebook::react::jsinspector_modern

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

@@ -7,14 +7,16 @@
 
 #pragma once
 
+#include "FollyDynamicMatchers.h"
 #include "JsiIntegrationTest.h"
 
+#include <fmt/format.h>
 #include <folly/dynamic.h>
 #include <folly/json.h>
 #include <gmock/gmock.h>
-#include <vector>
 
-#include "FollyDynamicMatchers.h"
+#include <set>
+#include <vector>
 
 namespace facebook::react::jsinspector_modern {
 
@@ -29,17 +31,28 @@ class TracingTestBase : public JsiIntegrationPortableTestBase<EngineAdapter, Exe
   /**
    * Helper method to start tracing via Tracing.start CDP command.
    */
-  void startTracing()
+  void startTracing(
+      const std::set<tracing::Category> &enabledCategories = {
+          tracing::Category::HiddenTimeline,
+          tracing::Category::JavaScriptSampling,
+          tracing::Category::RuntimeExecution,
+          tracing::Category::Timeline,
+          tracing::Category::UserTiming,
+      })
   {
     this->expectMessageFromPage(JsonEq(R"({
                                           "id": 1,
                                           "result": {}
                                         })"));
 
-    this->toPage_->sendMessage(R"({
-                                  "id": 1,
-                                  "method": "Tracing.start"
-                                })");
+    this->toPage_->sendMessage(
+        fmt::format(
+            R"({{
+              "id": 1,
+              "method": "Tracing.start",
+              "params": {{ "categories": "{0}" }}
+            }})",
+            tracing::serializeTracingCategories(enabledCategories)));
   }
 
   /**

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

@@ -8,6 +8,7 @@
 #include "PerformanceTracer.h"
 #include "Timing.h"
 #include "TraceEventSerializer.h"
+#include "TracingCategory.h"
 
 #include <jsinspector-modern/network/CdpNetwork.h>
 #include <jsinspector-modern/network/HttpUtils.h>
@@ -138,7 +139,7 @@ std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
   events.emplace_back(
       TraceEvent{
           .name = "TracingStartedInPage",
-          .cat = "disabled-by-default-devtools.timeline",
+          .cat = {Category::HiddenTimeline},
           .ph = 'I',
           .ts = currentTraceStartTime,
           .pid = processId_,
@@ -149,7 +150,7 @@ std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
   events.emplace_back(
       TraceEvent{
           .name = "ReactNative-TracingStopped",
-          .cat = "disabled-by-default-devtools.timeline",
+          .cat = {Category::HiddenTimeline},
           .ph = 'I',
           .ts = currentTraceEndTime,
           .pid = processId_,
@@ -187,7 +188,8 @@ void PerformanceTracer::reportMeasure(
     const std::string& name,
     HighResTimeStamp start,
     HighResDuration duration,
-    folly::dynamic&& detail) {
+    folly::dynamic&& detail,
+    std::optional<folly::dynamic> stackTrace) {
   if (!tracingAtomic_) {
     return;
   }
@@ -204,6 +206,7 @@ void PerformanceTracer::reportMeasure(
           .duration = duration,
           .detail = std::move(detail),
           .threadId = getCurrentThreadId(),
+          .stackTrace = std::move(stackTrace),
       });
 }
 
@@ -214,7 +217,8 @@ void PerformanceTracer::reportTimeStamp(
     std::optional<std::string> trackName,
     std::optional<std::string> trackGroup,
     std::optional<ConsoleTimeStampColor> color,
-    std::optional<folly::dynamic> detail) {
+    std::optional<folly::dynamic> detail,
+    std::optional<folly::dynamic> stackTrace) {
   if (!tracingAtomic_) {
     return;
   }
@@ -233,6 +237,7 @@ void PerformanceTracer::reportTimeStamp(
           .trackGroup = std::move(trackGroup),
           .color = std::move(color),
           .detail = std::move(detail),
+          .stackTrace = std::move(stackTrace),
           .threadId = getCurrentThreadId(),
       });
 }
@@ -405,7 +410,7 @@ void PerformanceTracer::reportFrameTiming(
   return TraceEvent{
       .id = profileId,
       .name = "Profile",
-      .cat = "disabled-by-default-v8.cpu_profiler",
+      .cat = {Category::JavaScriptSampling},
       .ph = 'P',
       .ts = profileTimestamp,
       .pid = processId,
@@ -428,7 +433,7 @@ PerformanceTracer::constructRuntimeProfileChunkTraceEvent(
   return TraceEvent{
       .id = profileId,
       .name = "ProfileChunk",
-      .cat = "disabled-by-default-v8.cpu_profiler",
+      .cat = {Category::JavaScriptSampling},
       .ph = 'P',
       .ts = chunkTimestamp,
       .pid = processId,
@@ -560,7 +565,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "RunTask",
-                    .cat = "disabled-by-default-devtools.timeline",
+                    .cat = {Category::HiddenTimeline},
                     .ph = 'X',
                     .ts = event.start,
                     .pid = processId_,
@@ -572,7 +577,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "RunMicrotasks",
-                    .cat = "v8.execute",
+                    .cat = {Category::RuntimeExecution},
                     .ph = 'X',
                     .ts = event.start,
                     .pid = processId_,
@@ -592,7 +597,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = std::move(event.name),
-                    .cat = "blink.user_timing",
+                    .cat = {Category::UserTiming},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -606,6 +611,10 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
               beginEventArgs =
                   folly::dynamic::object("detail", folly::toJson(event.detail));
             }
+            if (event.stackTrace) {
+              beginEventArgs["data"] = folly::dynamic::object(
+                  "rnStackTrace", std::move(*event.stackTrace));
+            }
 
             auto eventId = ++performanceMeasureCount_;
 
@@ -613,7 +622,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
                 TraceEvent{
                     .id = eventId,
                     .name = event.name,
-                    .cat = "blink.user_timing",
+                    .cat = {Category::UserTiming},
                     .ph = 'b',
                     .ts = event.start,
                     .pid = processId_,
@@ -624,7 +633,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
                 TraceEvent{
                     .id = eventId,
                     .name = std::move(event.name),
-                    .cat = "blink.user_timing",
+                    .cat = {Category::UserTiming},
                     .ph = 'e',
                     .ts = event.start + event.duration,
                     .pid = processId_,
@@ -664,7 +673,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
                 events.emplace_back(
                     TraceEvent{
                         .name = "TimeStamp",
-                        .cat = "devtools.timeline",
+                        .cat = {Category::Timeline},
                         .ph = 'I',
                         .ts = event.createdAt,
                         .pid = processId_,
@@ -695,11 +704,14 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
               }
               data["devtools"] = folly::toJson(devtoolsDetail);
             }
+            if (event.stackTrace) {
+              data["rnStackTrace"] = std::move(*event.stackTrace);
+            }
 
             events.emplace_back(
                 TraceEvent{
                     .name = "TimeStamp",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.createdAt,
                     .pid = processId_,
@@ -719,7 +731,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceSendRequest",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -745,7 +757,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceReceiveResponse",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -763,7 +775,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceFinish",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -779,7 +791,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "SetLayerTreeId",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -795,7 +807,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "BeginFrame",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -811,7 +823,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "Commit",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -827,7 +839,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "DrawFrame",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,

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

@@ -81,7 +81,8 @@ class PerformanceTracer {
       const std::string &name,
       HighResTimeStamp start,
       HighResDuration duration,
-      folly::dynamic &&detail = nullptr);
+      folly::dynamic &&detail = nullptr,
+      std::optional<folly::dynamic> stackTrace = nullptr);
 
   /**
    * Record a "TimeStamp" Trace Event - a labelled entry on Performance
@@ -97,7 +98,8 @@ class PerformanceTracer {
       std::optional<std::string> trackName = std::nullopt,
       std::optional<std::string> trackGroup = std::nullopt,
       std::optional<ConsoleTimeStampColor> color = std::nullopt,
-      std::optional<folly::dynamic> detail = std::nullopt);
+      std::optional<folly::dynamic> detail = std::nullopt,
+      std::optional<folly::dynamic> stackTrace = std::nullopt);
 
   /**
    * Record an Event Loop tick, which will be represented as an Event Loop task
@@ -256,6 +258,7 @@ class PerformanceTracer {
     HighResDuration duration;
     folly::dynamic detail;
     ThreadId threadId;
+    std::optional<folly::dynamic> stackTrace;
     HighResTimeStamp createdAt = HighResTimeStamp::now();
   };
 
@@ -267,6 +270,7 @@ class PerformanceTracer {
     std::optional<std::string> trackGroup;
     std::optional<ConsoleTimeStampColor> color;
     std::optional<folly::dynamic> detail;
+    std::optional<folly::dynamic> stackTrace;
     ThreadId threadId;
     HighResTimeStamp createdAt = HighResTimeStamp::now();
   };

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

@@ -27,6 +27,11 @@ class TargetTracingAgent {
     (void)state_;
   }
 
+  bool isRunningInBackgroundMode()
+  {
+    return state_.mode == tracing::Mode::Background;
+  }
+
  protected:
   TraceRecordingState &state_;
 };

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <jsinspector-modern/tracing/TracingCategory.h>
 #include <react/timing/primitives.h>
 
 #include <folly/dynamic.h>
@@ -40,7 +41,7 @@ struct TraceEvent {
    * A comma separated list of categories for the event, configuring how
    * events are shown in the Trace Viewer UI.
    */
-  std::string cat;
+  Categories cat;
 
   /**
    * The event type. This is a single character which changes depending on the

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

@@ -7,6 +7,7 @@
 
 #include "TraceEventSerializer.h"
 #include "Timing.h"
+#include "TracingCategory.h"
 
 #include <react/timing/primitives.h>
 
@@ -22,7 +23,7 @@ namespace facebook::react::jsinspector_modern::tracing {
     result["id"] = buffer.data();
   }
   result["name"] = std::move(event.name);
-  result["cat"] = std::move(event.cat);
+  result["cat"] = serializeTracingCategories(event.cat);
   result["ph"] = std::string(1, event.ph);
   result["ts"] = highResTimeStampToTracingClockTimeStamp(event.ts);
   result["pid"] = event.pid;

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

@@ -34,6 +34,9 @@ struct TraceRecordingState {
 
   // All captures Instance Tracing Profiles during this Trace Recording.
   std::vector<InstanceTracingProfile> instanceTracingProfiles{};
+
+  // The list of categories that are enabled for this recording.
+  std::set<tracing::Category> enabledCategories;
 };
 
 } // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/TracingCategory.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 <folly/container/small_vector.h>
+
+#include <optional>
+#include <set>
+#include <string>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+enum class Category {
+  HiddenTimeline, /*     disabled-by-default-devtools.timeline */
+  JavaScriptSampling, /* disabled-by-default-v8.cpu_profiler   */
+  RuntimeExecution, /*   v8.execute                            */
+  Timeline, /*           devtools.timeline                     */
+  UserTiming, /*         blink.user_timing                     */
+};
+
+inline std::string tracingCategoryToString(const Category &category)
+{
+  switch (category) {
+    case Category::Timeline:
+      return "devtools.timeline";
+    case Category::HiddenTimeline:
+      return "disabled-by-default-devtools.timeline";
+    case Category::UserTiming:
+      return "blink.user_timing";
+    case Category::JavaScriptSampling:
+      return "disabled-by-default-v8.cpu_profiler";
+    case Category::RuntimeExecution:
+      return "v8.execute";
+  }
+}
+
+inline std::optional<Category> getTracingCategoryFromString(const std::string &str)
+{
+  if (str == "blink.user_timing") {
+    return Category::UserTiming;
+  } else if (str == "devtools.timeline") {
+    return Category::Timeline;
+  } else if (str == "disabled-by-default-devtools.timeline") {
+    return Category::HiddenTimeline;
+  } else if (str == "disabled-by-default-v8.cpu_profiler") {
+    return Category::JavaScriptSampling;
+  } else if (str == "v8.execute") {
+    return Category::RuntimeExecution;
+  } else {
+    return std::nullopt;
+  }
+}
+
+/**
+ * The Trace Event could have multiple categories, but this is extremely rare case.
+ */
+using Categories = folly::small_vector<Category, 1>;
+
+// { Timeline, UserTiming } => "devtools.timeline,blink.user_timing"
+inline std::string serializeTracingCategories(const Categories &categories)
+{
+  if (categories.size() == 1) {
+    return tracingCategoryToString(categories.front());
+  }
+
+  std::string serializedValue;
+  for (size_t i = 0; i < categories.size(); ++i) {
+    serializedValue += tracingCategoryToString(categories[i]);
+    if (i < categories.size() - 1) {
+      serializedValue += ",";
+    }
+  }
+  return serializedValue;
+}
+
+// { Timeline, UserTiming } => "devtools.timeline,blink.user_timing"
+inline std::string serializeTracingCategories(const std::set<Category> &categories)
+{
+  std::string serializedValue;
+
+  auto current = categories.begin();
+  while (current != categories.end()) {
+    serializedValue += tracingCategoryToString(*current);
+
+    ++current;
+    if (current != categories.end()) {
+      serializedValue += ",";
+    }
+  }
+
+  return serializedValue;
+}
+
+// "devtools.timeline,blink.user_timing" => { Timeline, UserTiming }
+inline std::set<Category> parseSerializedTracingCategories(const std::string &serializedCategories)
+{
+  std::set<Category> categories;
+  if (serializedCategories.empty()) {
+    return categories;
+  }
+
+  size_t start = 0;
+  size_t end = serializedCategories.find(',');
+  while (end != std::string::npos) {
+    std::string token = serializedCategories.substr(start, end - start);
+    if (auto category = getTracingCategoryFromString(token)) {
+      categories.insert(*category);
+    }
+    start = end + 1;
+    end = serializedCategories.find(',', start);
+  }
+
+  std::string lastToken = serializedCategories.substr(start);
+  if (auto category = getTracingCategoryFromString(lastToken)) {
+    categories.insert(*category);
+  }
+
+  return categories;
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing