react-native-tvos 0.81.4-0 → 0.82.0-0

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

@@ -7,17 +7,32 @@
 
 #include "PerformanceTracer.h"
 #include "Timing.h"
+#include "TraceEventSerializer.h"
 
 #include <oscompat/OSCompat.h>
 #include <react/timing/primitives.h>
 
 #include <folly/json.h>
 
-#include <array>
 #include <mutex>
 
 namespace facebook::react::jsinspector_modern::tracing {
 
+namespace {
+/**
+ * Instead of validating that the indicated duration is positive, we can ensure
+ * the value is sensible (less than 1 seccond doesn't make much sense).
+ */
+const HighResDuration MIN_VALUE_FOR_MAX_TRACE_DURATION_OPTION =
+    HighResDuration::fromMilliseconds(1000); // 1 second
+
+ThreadId getCurrentThreadId() {
+  static thread_local const auto CURRENT_THREAD_ID =
+      oscompat::getCurrentThreadId();
+  return CURRENT_THREAD_ID;
+}
+} // namespace
+
 PerformanceTracer& PerformanceTracer::getInstance() {
   static PerformanceTracer tracer;
   return tracer;
@@ -27,93 +42,91 @@ PerformanceTracer::PerformanceTracer()
     : processId_(oscompat::getCurrentProcessId()) {}
 
 bool PerformanceTracer::startTracing() {
-  {
-    std::lock_guard lock(mutex_);
-    if (tracingAtomic_) {
-      return false;
-    }
-    tracingAtomic_ = true;
+  return startTracingImpl();
+}
+
+bool PerformanceTracer::startTracing(HighResDuration maxDuration) {
+  return startTracingImpl(maxDuration);
+}
+
+bool PerformanceTracer::startTracingImpl(
+    std::optional<HighResDuration> maxDuration) {
+  std::lock_guard lock(mutex_);
+
+  if (tracingAtomic_) {
+    return false;
   }
 
-  reportProcess(processId_, "React Native");
+  tracingAtomic_ = true;
+
+  if (maxDuration && *maxDuration < MIN_VALUE_FOR_MAX_TRACE_DURATION_OPTION) {
+    throw std::invalid_argument("maxDuration should be at least 1 second");
+  }
+
+  currentTraceStartTime_ = HighResTimeStamp::now();
+  currentTraceMaxDuration_ = maxDuration;
+
+  return true;
+}
+
+std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
+  std::vector<TraceEvent> events;
+
+  auto currentTraceEndTime = HighResTimeStamp::now();
 
   {
     std::lock_guard lock(mutex_);
+
     if (!tracingAtomic_) {
-      return false;
+      return std::nullopt;
     }
-    buffer_.emplace_back(TraceEvent{
-        .name = "TracingStartedInPage",
-        .cat = "disabled-by-default-devtools.timeline",
-        .ph = 'I',
-        .ts = HighResTimeStamp::now(),
-        .pid = processId_,
-        .tid = oscompat::getCurrentThreadId(),
-        .args = folly::dynamic::object("data", folly::dynamic::object()),
-    });
-  }
 
-  return true;
-}
+    tracingAtomic_ = false;
+    performanceMeasureCount_ = 0;
 
-bool PerformanceTracer::stopTracing() {
-  std::lock_guard lock(mutex_);
-  if (!tracingAtomic_) {
-    return false;
+    events = collectEventsAndClearBuffers(currentTraceEndTime);
+  }
+
+  auto currentTraceStartTime = currentTraceStartTime_;
+  if (currentTraceMaxDuration_ &&
+      currentTraceEndTime - *currentTraceMaxDuration_ > currentTraceStartTime) {
+    currentTraceStartTime = currentTraceEndTime - *currentTraceMaxDuration_;
   }
-  tracingAtomic_ = false;
 
   // This is synthetic Trace Event, which should not be represented on a
   // timeline. CDT is not using Profile or ProfileChunk events for determining
   // trace timeline window, this is why trace that only contains JavaScript
-  // samples will be displayed as empty. We use this event to avoid that.
+  // samples will be displayed as empty. We use these events to avoid that.
   // This could happen for non-bridgeless apps, where Performance interface is
   // not supported and no spec-compliant Event Loop implementation.
-  buffer_.emplace_back(TraceEvent{
-      .name = "ReactNative-TracingStopped",
+
+  events.emplace_back(TraceEvent{
+      .name = "TracingStartedInPage",
       .cat = "disabled-by-default-devtools.timeline",
       .ph = 'I',
-      .ts = HighResTimeStamp::now(),
+      .ts = currentTraceStartTime,
       .pid = processId_,
-      .tid = oscompat::getCurrentThreadId(),
+      .tid = getCurrentThreadId(),
+      .args = folly::dynamic::object("data", folly::dynamic::object()),
   });
 
-  performanceMeasureCount_ = 0;
-  return true;
-}
-
-void PerformanceTracer::collectEvents(
-    const std::function<void(const folly::dynamic& eventsChunk)>&
-        resultCallback,
-    uint16_t chunkSize) {
-  std::vector<TraceEvent> localBuffer;
-  {
-    std::lock_guard lock(mutex_);
-    buffer_.swap(localBuffer);
-  }
-
-  if (localBuffer.empty()) {
-    return;
-  }
-
-  auto serializedTraceEvents = folly::dynamic::array();
-  for (auto&& event : localBuffer) {
-    // Emit trace events
-    serializedTraceEvents.push_back(serializeTraceEvent(std::move(event)));
+  events.emplace_back(TraceEvent{
+      .name = "ReactNative-TracingStopped",
+      .cat = "disabled-by-default-devtools.timeline",
+      .ph = 'I',
+      .ts = currentTraceEndTime,
+      .pid = processId_,
+      .tid = getCurrentThreadId(),
+  });
 
-    if (serializedTraceEvents.size() == chunkSize) {
-      resultCallback(serializedTraceEvents);
-      serializedTraceEvents = folly::dynamic::array();
-    }
-  }
-  if (!serializedTraceEvents.empty()) {
-    resultCallback(serializedTraceEvents);
-  }
+  currentTraceMaxDuration_ = std::nullopt;
+  return events;
 }
 
 void PerformanceTracer::reportMark(
     const std::string_view& name,
-    HighResTimeStamp start) {
+    HighResTimeStamp start,
+    folly::dynamic&& detail) {
   if (!tracingAtomic_) {
     return;
   }
@@ -123,13 +136,11 @@ void PerformanceTracer::reportMark(
     return;
   }
 
-  buffer_.emplace_back(TraceEvent{
+  enqueueEvent(PerformanceTracerEventMark{
       .name = std::string(name),
-      .cat = "blink.user_timing",
-      .ph = 'I',
-      .ts = start,
-      .pid = processId_,
-      .tid = oscompat::getCurrentThreadId(),
+      .start = start,
+      .detail = std::move(detail),
+      .threadId = getCurrentThreadId(),
   });
 }
 
@@ -137,46 +148,22 @@ void PerformanceTracer::reportMeasure(
     const std::string_view& name,
     HighResTimeStamp start,
     HighResDuration duration,
-    const std::optional<DevToolsTrackEntryPayload>& trackMetadata) {
+    folly::dynamic&& detail) {
   if (!tracingAtomic_) {
     return;
   }
 
-  folly::dynamic beginEventArgs = folly::dynamic::object();
-  if (trackMetadata.has_value()) {
-    folly::dynamic devtoolsObject = folly::dynamic::object(
-        "devtools",
-        folly::dynamic::object("track", trackMetadata.value().track));
-    beginEventArgs =
-        folly::dynamic::object("detail", folly::toJson(devtoolsObject));
-  }
-
-  auto currentThreadId = oscompat::getCurrentThreadId();
-
   std::lock_guard<std::mutex> lock(mutex_);
   if (!tracingAtomic_) {
     return;
   }
-  auto eventId = ++performanceMeasureCount_;
 
-  buffer_.emplace_back(TraceEvent{
-      .id = eventId,
+  enqueueEvent(PerformanceTracerEventMeasure{
       .name = std::string(name),
-      .cat = "blink.user_timing",
-      .ph = 'b',
-      .ts = start,
-      .pid = processId_,
-      .tid = currentThreadId,
-      .args = beginEventArgs,
-  });
-  buffer_.emplace_back(TraceEvent{
-      .id = eventId,
-      .name = std::string(name),
-      .cat = "blink.user_timing",
-      .ph = 'e',
-      .ts = start + duration,
-      .pid = processId_,
-      .tid = currentThreadId,
+      .start = start,
+      .duration = duration,
+      .detail = std::move(detail),
+      .threadId = getCurrentThreadId(),
   });
 }
 
@@ -191,107 +178,19 @@ void PerformanceTracer::reportTimeStamp(
     return;
   }
 
-  // `name` takes precedence over `message` in Chrome DevTools Frontend, no need
-  // to record both.
-  folly::dynamic data = folly::dynamic::object("name", std::move(name));
-  if (start) {
-    if (std::holds_alternative<HighResTimeStamp>(*start)) {
-      data["start"] = highResTimeStampToTracingClockTimeStamp(
-          std::get<HighResTimeStamp>(*start));
-    } else {
-      data["start"] = std::move(std::get<std::string>(*start));
-    }
-  }
-  if (end) {
-    if (std::holds_alternative<HighResTimeStamp>(*end)) {
-      data["end"] = highResTimeStampToTracingClockTimeStamp(
-          std::get<HighResTimeStamp>(*end));
-    } else {
-      data["end"] = std::move(std::get<std::string>(*end));
-    }
-  }
-  if (trackName) {
-    data["track"] = std::move(*trackName);
-  }
-  if (trackGroup) {
-    data["trackGroup"] = std::move(*trackGroup);
-  }
-  if (color) {
-    data["color"] = consoleTimeStampColorToString(*color);
-  }
-
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (!tracingAtomic_) {
-    return;
-  }
-  buffer_.emplace_back(TraceEvent{
-      .name = "TimeStamp",
-      .cat = "devtools.timeline",
-      .ph = 'I',
-      .ts = HighResTimeStamp::now(),
-      .pid = processId_,
-      .tid = oscompat::getCurrentThreadId(),
-      .args = folly::dynamic::object("data", std::move(data)),
-  });
-}
-
-void PerformanceTracer::reportProcess(uint64_t id, const std::string& name) {
-  if (!tracingAtomic_) {
-    return;
-  }
-
   std::lock_guard<std::mutex> lock(mutex_);
   if (!tracingAtomic_) {
     return;
   }
 
-  buffer_.emplace_back(TraceEvent{
-      .name = "process_name",
-      .cat = "__metadata",
-      .ph = 'M',
-      .ts = TRACING_TIME_ORIGIN,
-      .pid = id,
-      .tid = 0,
-      .args = folly::dynamic::object("name", name),
-  });
-}
-
-void PerformanceTracer::reportJavaScriptThread() {
-  reportThread(oscompat::getCurrentThreadId(), "JavaScript");
-}
-
-void PerformanceTracer::reportThread(uint64_t id, const std::string& name) {
-  if (!tracingAtomic_) {
-    return;
-  }
-
-  std::lock_guard<std::mutex> lock(mutex_);
-  if (!tracingAtomic_) {
-    return;
-  }
-
-  buffer_.emplace_back(TraceEvent{
-      .name = "thread_name",
-      .cat = "__metadata",
-      .ph = 'M',
-      .ts = TRACING_TIME_ORIGIN,
-      .pid = processId_,
-      .tid = id,
-      .args = folly::dynamic::object("name", name),
-  });
-
-  // This is synthetic Trace Event, which should not be represented on a
-  // timeline. CDT will filter out threads that only have JavaScript samples and
-  // no timeline events or user timings. We use this event to avoid that.
-  // This could happen for non-bridgeless apps, where Performance interface is
-  // not supported and no spec-compliant Event Loop implementation.
-  buffer_.emplace_back(TraceEvent{
-      .name = "ReactNative-ThreadRegistered",
-      .cat = "disabled-by-default-devtools.timeline",
-      .ph = 'I',
-      .ts = TRACING_TIME_ORIGIN,
-      .pid = processId_,
-      .tid = id,
+  enqueueEvent(PerformanceTracerEventTimeStamp{
+      .name = std::move(name),
+      .start = std::move(start),
+      .end = std::move(end),
+      .trackName = std::move(trackName),
+      .trackGroup = std::move(trackGroup),
+      .color = std::move(color),
+      .threadId = getCurrentThreadId(),
   });
 }
 
@@ -307,14 +206,10 @@ void PerformanceTracer::reportEventLoopTask(
     return;
   }
 
-  buffer_.emplace_back(TraceEvent{
-      .name = "RunTask",
-      .cat = "disabled-by-default-devtools.timeline",
-      .ph = 'X',
-      .ts = start,
-      .pid = oscompat::getCurrentProcessId(),
-      .tid = oscompat::getCurrentThreadId(),
-      .dur = end - start,
+  enqueueEvent(PerformanceTracerEventEventLoopTask{
+      .start = start,
+      .end = end,
+      .threadId = getCurrentThreadId(),
   });
 }
 
@@ -330,78 +225,288 @@ void PerformanceTracer::reportEventLoopMicrotasks(
     return;
   }
 
-  buffer_.emplace_back(TraceEvent{
-      .name = "RunMicrotasks",
-      .cat = "v8.execute",
-      .ph = 'X',
-      .ts = start,
-      .pid = oscompat::getCurrentProcessId(),
-      .tid = oscompat::getCurrentThreadId(),
-      .dur = end - start,
+  enqueueEvent(PerformanceTracerEventEventLoopMicrotask{
+      .start = start,
+      .end = end,
+      .threadId = getCurrentThreadId(),
   });
 }
 
-folly::dynamic PerformanceTracer::getSerializedRuntimeProfileTraceEvent(
-    uint64_t threadId,
-    uint16_t profileId,
+/* static */ TraceEvent PerformanceTracer::constructRuntimeProfileTraceEvent(
+    RuntimeProfileId profileId,
+    ProcessId processId,
+    ThreadId threadId,
     HighResTimeStamp profileTimestamp) {
   // CDT prioritizes event timestamp over startTime metadata field.
   // https://fburl.com/lo764pf4
-  return serializeTraceEvent(TraceEvent{
+  return TraceEvent{
       .id = profileId,
       .name = "Profile",
       .cat = "disabled-by-default-v8.cpu_profiler",
       .ph = 'P',
       .ts = profileTimestamp,
-      .pid = processId_,
+      .pid = processId,
       .tid = threadId,
       .args = folly::dynamic::object(
           "data",
           folly::dynamic::object(
               "startTime",
               highResTimeStampToTracingClockTimeStamp(profileTimestamp))),
-  });
+  };
 }
 
-folly::dynamic PerformanceTracer::getSerializedRuntimeProfileChunkTraceEvent(
-    uint16_t profileId,
-    uint64_t threadId,
+/* static */ TraceEvent
+PerformanceTracer::constructRuntimeProfileChunkTraceEvent(
+    RuntimeProfileId profileId,
+    ProcessId processId,
+    ProcessId threadId,
     HighResTimeStamp chunkTimestamp,
-    const tracing::TraceEventProfileChunk& traceEventProfileChunk) {
-  return serializeTraceEvent(TraceEvent{
+    TraceEventProfileChunk&& traceEventProfileChunk) {
+  return TraceEvent{
       .id = profileId,
       .name = "ProfileChunk",
       .cat = "disabled-by-default-v8.cpu_profiler",
       .ph = 'P',
       .ts = chunkTimestamp,
-      .pid = processId_,
+      .pid = processId,
       .tid = threadId,
-      .args =
-          folly::dynamic::object("data", traceEventProfileChunk.toDynamic()),
-  });
+      .args = folly::dynamic::object(
+          "data",
+          TraceEventSerializer::serializeProfileChunk(
+              std::move(traceEventProfileChunk))),
+  };
+}
+
+#pragma mark - Tracing window methods
+
+/**
+ * If a `maxDuration` value is set when starting a trace, we use 2 buffers
+ * for events. Each buffer can contain entries for a range up to `maxDuration`.
+ * When the current buffer is full, we clear the previous one and we start
+ * collecting events in a new buffer, which becomes current.
+ *
+ * Example:
+ *   - Start:
+ *     previousBuffer: null, currentBuffer: []
+ *   - As entries are added:
+ *     previousBuffer: null, currentBuffer: [a, b, c...]
+ *   - When now - currentBuffer start time > maxDuration:
+ *     previousBuffer: [a, b, c...], currentBuffer: []
+ *   - As entries are added:
+ *     previousbuffer: [a, b, c...], currentBuffer: [x, y, z...]
+ *   - When now - currentBuffer start time > maxDuration:
+ *     previousBuffer: [x, y, z...], currentBuffer: []
+ *   - When the trace finishes:
+ *     We collect all events in both buffers that are still within
+ *     `maxDuration`.
+ *
+ * This way, we ensure we keep all events in the `maxDuration` window, and
+ * clearing expired events is trivial (just clearing a vector).
+ */
+
+std::vector<TraceEvent> PerformanceTracer::collectEventsAndClearBuffers(
+    HighResTimeStamp currentTraceEndTime) {
+  std::vector<TraceEvent> events;
+
+  if (currentTraceMaxDuration_) {
+    // Collect non-expired entries from the previous buffer
+    if (previousBuffer_ != nullptr) {
+      collectEventsAndClearBuffer(
+          events, *previousBuffer_, currentTraceEndTime);
+    }
+
+    collectEventsAndClearBuffer(events, *currentBuffer_, currentTraceEndTime);
+
+    // Reset state.
+    currentBuffer_ = &buffer_;
+    previousBuffer_ = nullptr;
+  } else {
+    // Trivial case.
+    events.reserve(currentBuffer_->size());
+    for (auto&& event : *currentBuffer_) {
+      enqueueTraceEventsFromPerformanceTracerEvent(events, std::move(event));
+    }
+    currentBuffer_->clear();
+  }
+
+  return events;
 }
 
-folly::dynamic PerformanceTracer::serializeTraceEvent(
-    TraceEvent&& event) const {
-  folly::dynamic result = folly::dynamic::object;
+void PerformanceTracer::collectEventsAndClearBuffer(
+    std::vector<TraceEvent>& events,
+    std::vector<PerformanceTracerEvent>& buffer,
+    HighResTimeStamp currentTraceEndTime) {
+  for (auto&& event : buffer) {
+    if (isInTracingWindow(currentTraceEndTime, getCreatedAt(event))) {
+      enqueueTraceEventsFromPerformanceTracerEvent(events, std::move(event));
+    }
+  }
+
+  buffer.clear();
+  buffer.shrink_to_fit();
+}
 
-  if (event.id.has_value()) {
-    std::array<char, 16> buffer{};
-    snprintf(buffer.data(), buffer.size(), "0x%x", event.id.value());
-    result["id"] = buffer.data();
+bool PerformanceTracer::isInTracingWindow(
+    HighResTimeStamp now,
+    HighResTimeStamp timeStampToCheck) const {
+  if (!currentTraceMaxDuration_) {
+    return true;
   }
-  result["name"] = std::move(event.name);
-  result["cat"] = std::move(event.cat);
-  result["ph"] = std::string(1, event.ph);
-  result["ts"] = highResTimeStampToTracingClockTimeStamp(event.ts);
-  result["pid"] = event.pid;
-  result["tid"] = event.tid;
-  result["args"] = std::move(event.args);
-  if (event.dur.has_value()) {
-    result["dur"] = highResDurationToTracingClockDuration(event.dur.value());
+
+  return timeStampToCheck > now - *currentTraceMaxDuration_;
+}
+
+void PerformanceTracer::enqueueEvent(PerformanceTracerEvent&& event) {
+  if (currentTraceMaxDuration_) {
+    auto createdAt = getCreatedAt(event);
+    // Check if the current buffer is "full"
+    if (createdAt > currentBufferStartTime_ + *currentTraceMaxDuration_) {
+      // We moved past the current buffer. We need to switch the other buffer as
+      // current.
+      previousBuffer_ = currentBuffer_;
+      currentBuffer_ = currentBuffer_ == &buffer_ ? &altBuffer_ : &buffer_;
+      currentBuffer_->clear();
+      currentBufferStartTime_ = createdAt;
+    }
   }
 
-  return result;
+  currentBuffer_->emplace_back(std::move(event));
+}
+
+HighResTimeStamp PerformanceTracer::getCreatedAt(
+    const PerformanceTracerEvent& event) const {
+  return std::visit(
+      [](const auto& variant) { return variant.createdAt; }, event);
+}
+
+namespace {
+template <class... Ts>
+struct overloaded : Ts... {
+  using Ts::operator()...;
+};
+template <class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
+} // namespace
+
+void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
+    std::vector<TraceEvent>& events,
+    PerformanceTracerEvent&& event) {
+  std::visit(
+      overloaded{
+          [&](PerformanceTracerEventEventLoopTask&& event) {
+            events.emplace_back(TraceEvent{
+                .name = "RunTask",
+                .cat = "disabled-by-default-devtools.timeline",
+                .ph = 'X',
+                .ts = event.start,
+                .pid = processId_,
+                .tid = event.threadId,
+                .dur = event.end - event.start,
+            });
+          },
+          [&](PerformanceTracerEventEventLoopMicrotask&& event) {
+            events.emplace_back(TraceEvent{
+                .name = "RunMicrotasks",
+                .cat = "v8.execute",
+                .ph = 'X',
+                .ts = event.start,
+                .pid = processId_,
+                .tid = event.threadId,
+                .dur = event.end - event.start,
+            });
+          },
+          [&](PerformanceTracerEventMark&& event) {
+            folly::dynamic eventArgs = folly::dynamic::object();
+            if (event.detail != nullptr) {
+              eventArgs = folly::dynamic::object(
+                  "data",
+                  folly::dynamic::object(
+                      "detail", folly::toJson(event.detail)));
+            }
+
+            events.emplace_back(TraceEvent{
+                .name = std::move(event.name),
+                .cat = "blink.user_timing",
+                .ph = 'I',
+                .ts = event.start,
+                .pid = processId_,
+                .tid = event.threadId,
+                .args = std::move(eventArgs),
+            });
+          },
+          [&](PerformanceTracerEventMeasure&& event) {
+            folly::dynamic beginEventArgs = folly::dynamic::object();
+            if (event.detail != nullptr) {
+              beginEventArgs =
+                  folly::dynamic::object("detail", folly::toJson(event.detail));
+            }
+
+            auto eventId = ++performanceMeasureCount_;
+
+            events.emplace_back(TraceEvent{
+                .id = eventId,
+                .name = std::move(event.name),
+                .cat = "blink.user_timing",
+                .ph = 'b',
+                .ts = event.start,
+                .pid = processId_,
+                .tid = event.threadId,
+                .args = std::move(beginEventArgs),
+            });
+            events.emplace_back(TraceEvent{
+                .id = eventId,
+                .name = std::move(event.name),
+                .cat = "blink.user_timing",
+                .ph = 'e',
+                .ts = event.start + event.duration,
+                .pid = processId_,
+                .tid = event.threadId,
+            });
+          },
+          [&](PerformanceTracerEventTimeStamp&& event) {
+            // `name` takes precedence over `message` in Chrome DevTools
+            // Frontend, no need
+            // to record both.
+            folly::dynamic data =
+                folly::dynamic::object("name", std::move(event.name));
+            if (event.start) {
+              if (std::holds_alternative<HighResTimeStamp>(*event.start)) {
+                data["start"] = highResTimeStampToTracingClockTimeStamp(
+                    std::get<HighResTimeStamp>(*event.start));
+              } else {
+                data["start"] = std::move(std::get<std::string>(*event.start));
+              }
+            }
+            if (event.end) {
+              if (std::holds_alternative<HighResTimeStamp>(*event.end)) {
+                data["end"] = highResTimeStampToTracingClockTimeStamp(
+                    std::get<HighResTimeStamp>(*event.end));
+              } else {
+                data["end"] = std::move(std::get<std::string>(*event.end));
+              }
+            }
+            if (event.trackName) {
+              data["track"] = std::move(*event.trackName);
+            }
+            if (event.trackGroup) {
+              data["trackGroup"] = std::move(*event.trackGroup);
+            }
+            if (event.color) {
+              data["color"] = consoleTimeStampColorToString(*event.color);
+            }
+
+            events.emplace_back(TraceEvent{
+                .name = "TimeStamp",
+                .cat = "devtools.timeline",
+                .ph = 'I',
+                .ts = event.createdAt,
+                .pid = processId_,
+                .tid = event.threadId,
+                .args = folly::dynamic::object("data", std::move(data)),
+            });
+          },
+      },
+      std::move(event));
 }
 
 } // namespace facebook::react::jsinspector_modern::tracing