react-native-tvos 0.83.2-0 → 0.84.0-0

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

@@ -0,0 +1,144 @@
+/*
+ * 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 "HostTracingProfileSerializer.h"
+#include "RuntimeSamplingProfileTraceEventSerializer.h"
+#include "TraceEventGenerator.h"
+#include "TraceEventSerializer.h"
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+namespace {
+
+folly::dynamic generateNewChunk(uint16_t chunkSize) {
+  folly::dynamic chunk = folly::dynamic::array();
+  chunk.reserve(chunkSize);
+
+  return chunk;
+}
+
+/**
+ * Hardcoded layer tree ID for all recorded frames.
+ * https://chromedevtools.github.io/devtools-protocol/tot/LayerTree/
+ */
+constexpr int FALLBACK_LAYER_TREE_ID = 1;
+
+} // namespace
+
+/* static */ void HostTracingProfileSerializer::emitAsDataCollectedChunks(
+    HostTracingProfile&& hostTracingProfile,
+    const std::function<void(folly::dynamic&&)>& chunkCallback,
+    uint16_t traceEventsChunkSize,
+    uint16_t profileTraceEventsChunkSize) {
+  emitFrameTimings(
+      std::move(hostTracingProfile.frameTimings),
+      hostTracingProfile.processId,
+      hostTracingProfile.startTime,
+      chunkCallback,
+      traceEventsChunkSize);
+
+  auto instancesProfiles =
+      std::move(hostTracingProfile.instanceTracingProfiles);
+  IdGenerator profileIdGenerator;
+
+  for (auto& instanceProfile : instancesProfiles) {
+    emitPerformanceTraceEvents(
+        std::move(instanceProfile.performanceTraceEvents),
+        chunkCallback,
+        traceEventsChunkSize);
+  }
+
+  RuntimeSamplingProfileTraceEventSerializer::serializeAndDispatch(
+      std::move(hostTracingProfile.runtimeSamplingProfiles),
+      profileIdGenerator,
+      hostTracingProfile.startTime,
+      chunkCallback,
+      profileTraceEventsChunkSize);
+}
+
+/* static */ void HostTracingProfileSerializer::emitPerformanceTraceEvents(
+    std::vector<TraceEvent>&& events,
+    const std::function<void(folly::dynamic&&)>& chunkCallback,
+    uint16_t chunkSize) {
+  folly::dynamic chunk = generateNewChunk(chunkSize);
+
+  for (auto& event : events) {
+    if (chunk.size() == chunkSize) {
+      chunkCallback(std::move(chunk));
+      chunk = generateNewChunk(chunkSize);
+    }
+
+    chunk.push_back(TraceEventSerializer::serialize(std::move(event)));
+  }
+
+  if (!chunk.empty()) {
+    chunkCallback(std::move(chunk));
+  }
+}
+
+/* static */ void HostTracingProfileSerializer::emitFrameTimings(
+    std::vector<FrameTimingSequence>&& frameTimings,
+    ProcessId processId,
+    HighResTimeStamp recordingStartTimestamp,
+    const std::function<void(folly::dynamic&& chunk)>& chunkCallback,
+    uint16_t chunkSize) {
+  if (frameTimings.empty()) {
+    return;
+  }
+
+  folly::dynamic chunk = generateNewChunk(chunkSize);
+  auto setLayerTreeIdEvent = TraceEventGenerator::createSetLayerTreeIdEvent(
+      "", // Hardcoded frame name for the default (and only) layer.
+      FALLBACK_LAYER_TREE_ID,
+      processId,
+      frameTimings.front().threadId,
+      recordingStartTimestamp);
+  chunk.push_back(
+      TraceEventSerializer::serialize(std::move(setLayerTreeIdEvent)));
+
+  for (auto&& frameTimingSequence : frameTimings) {
+    if (chunk.size() >= chunkSize) {
+      chunkCallback(std::move(chunk));
+      chunk = generateNewChunk(chunkSize);
+    }
+
+    auto [beginDrawingEvent, commitEvent, endDrawingEvent] =
+        TraceEventGenerator::createFrameTimingsEvents(
+            frameTimingSequence.id,
+            FALLBACK_LAYER_TREE_ID,
+            frameTimingSequence.beginDrawingTimestamp,
+            frameTimingSequence.commitTimestamp,
+            frameTimingSequence.endDrawingTimestamp,
+            processId,
+            frameTimingSequence.threadId);
+
+    chunk.push_back(
+        TraceEventSerializer::serialize(std::move(beginDrawingEvent)));
+    chunk.push_back(TraceEventSerializer::serialize(std::move(commitEvent)));
+    chunk.push_back(
+        TraceEventSerializer::serialize(std::move(endDrawingEvent)));
+
+    if (frameTimingSequence.screenshot.has_value()) {
+      auto screenshotEvent = TraceEventGenerator::createScreenshotEvent(
+          frameTimingSequence.id,
+          FALLBACK_LAYER_TREE_ID,
+          std::move(frameTimingSequence.screenshot.value()),
+          frameTimingSequence.endDrawingTimestamp,
+          processId,
+          frameTimingSequence.threadId);
+
+      chunk.push_back(
+          TraceEventSerializer::serialize(std::move(screenshotEvent)));
+    }
+  }
+
+  if (!chunk.empty()) {
+    chunkCallback(std::move(chunk));
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/{TraceRecordingStateSerializer.h → HostTracingProfileSerializer.h}

@@ -7,8 +7,9 @@
 
 #pragma once
 
+#include "FrameTimingSequence.h"
+#include "HostTracingProfile.h"
 #include "TraceEvent.h"
-#include "TraceRecordingState.h"
 
 #include <folly/dynamic.h>
 #include <vector>
@@ -16,27 +17,34 @@
 namespace facebook::react::jsinspector_modern::tracing {
 
 /**
- * A serializer for TraceRecordingState that can be used for tranforming the
- * recording into sequence of serialized Trace Events.
+ * A serializer for HostTracingProfile that can be used for transforming the
+ * profile into sequence of serialized Trace Events.
  */
-class TraceRecordingStateSerializer {
+class HostTracingProfileSerializer {
  public:
   /**
-   * Transforms the recording into a sequence of serialized Trace Events, which
-   * is split in chunks of sizes \p performanceTraceEventsChunkSize or
+   * Transforms the profile into a sequence of serialized Trace Events, which
+   * is split in chunks of sizes \p traceEventsChunkSize or
    * \p profileTraceEventsChunkSize, depending on type, and sent with \p
    * chunkCallback.
    */
   static void emitAsDataCollectedChunks(
-      TraceRecordingState &&recording,
+      HostTracingProfile &&hostTracingProfile,
       const std::function<void(folly::dynamic &&chunk)> &chunkCallback,
-      uint16_t performanceTraceEventsChunkSize,
+      uint16_t traceEventsChunkSize,
       uint16_t profileTraceEventsChunkSize);
 
   static void emitPerformanceTraceEvents(
       std::vector<TraceEvent> &&events,
       const std::function<void(folly::dynamic &&chunk)> &chunkCallback,
       uint16_t chunkSize);
+
+  static void emitFrameTimings(
+      std::vector<FrameTimingSequence> &&frameTimings,
+      ProcessId processId,
+      HighResTimeStamp recordingStartTimestamp,
+      const std::function<void(folly::dynamic &&chunk)> &chunkCallback,
+      uint16_t chunkSize);
 };
 
 } // namespace facebook::react::jsinspector_modern::tracing

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

@@ -7,7 +7,9 @@
 
 #include "PerformanceTracer.h"
 #include "Timing.h"
+#include "TraceEventGenerator.h"
 #include "TraceEventSerializer.h"
+#include "TracingCategory.h"
 
 #include <jsinspector-modern/network/CdpNetwork.h>
 #include <jsinspector-modern/network/HttpUtils.h>
@@ -138,7 +140,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 +151,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 +189,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 +207,7 @@ void PerformanceTracer::reportMeasure(
           .duration = duration,
           .detail = std::move(detail),
           .threadId = getCurrentThreadId(),
+          .stackTrace = std::move(stackTrace),
       });
 }
 
@@ -214,7 +218,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 +238,7 @@ void PerformanceTracer::reportTimeStamp(
           .trackGroup = std::move(trackGroup),
           .color = std::move(color),
           .detail = std::move(detail),
+          .stackTrace = std::move(stackTrace),
           .threadId = getCurrentThreadId(),
       });
 }
@@ -306,6 +312,27 @@ void PerformanceTracer::reportResourceSendRequest(
       });
 }
 
+void PerformanceTracer::reportResourceReceivedData(
+    const std::string& devtoolsRequestId,
+    HighResTimeStamp start,
+    int encodedDataLength) {
+  if (!tracingAtomic_) {
+    return;
+  };
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracingAtomic_) {
+    return;
+  }
+
+  enqueueEvent(
+      PerformanceTracerResourceReceivedData{
+          .requestId = devtoolsRequestId,
+          .start = start,
+          .encodedDataLength = encodedDataLength,
+          .threadId = getCurrentThreadId()});
+}
+
 void PerformanceTracer::reportResourceReceiveResponse(
     const std::string& devtoolsRequestId,
     HighResTimeStamp start,
@@ -370,7 +397,7 @@ void PerformanceTracer::reportResourceFinish(
   return TraceEvent{
       .id = profileId,
       .name = "Profile",
-      .cat = "disabled-by-default-v8.cpu_profiler",
+      .cat = {Category::JavaScriptSampling},
       .ph = 'P',
       .ts = profileTimestamp,
       .pid = processId,
@@ -393,7 +420,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,
@@ -525,7 +552,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_,
@@ -537,7 +564,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "RunMicrotasks",
-                    .cat = "v8.execute",
+                    .cat = {Category::RuntimeExecution},
                     .ph = 'X',
                     .ts = event.start,
                     .pid = processId_,
@@ -557,7 +584,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_,
@@ -571,6 +598,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_;
 
@@ -578,7 +609,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
                 TraceEvent{
                     .id = eventId,
                     .name = event.name,
-                    .cat = "blink.user_timing",
+                    .cat = {Category::UserTiming},
                     .ph = 'b',
                     .ts = event.start,
                     .pid = processId_,
@@ -589,7 +620,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_,
@@ -629,7 +660,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
                 events.emplace_back(
                     TraceEvent{
                         .name = "TimeStamp",
-                        .cat = "devtools.timeline",
+                        .cat = {Category::Timeline},
                         .ph = 'I',
                         .ts = event.createdAt,
                         .pid = processId_,
@@ -660,11 +691,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_,
@@ -684,7 +718,24 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceSendRequest",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
+                    .ph = 'I',
+                    .ts = event.start,
+                    .pid = processId_,
+                    .s = 't',
+                    .tid = event.threadId,
+                    .args = folly::dynamic::object("data", std::move(data)),
+                });
+          },
+          [&](PerformanceTracerResourceReceivedData&& event) {
+            folly::dynamic data = folly::dynamic::object(
+                "encodedDataLength", event.encodedDataLength)(
+                "requestId", std::move(event.requestId));
+
+            events.emplace_back(
+                TraceEvent{
+                    .name = "ResourceReceivedData",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -710,7 +761,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceReceiveResponse",
-                    .cat = "devtools.timeline",
+                    .cat = {Category::Timeline},
                     .ph = 'I',
                     .ts = event.start,
                     .pid = processId_,
@@ -728,7 +779,7 @@ void PerformanceTracer::enqueueTraceEventsFromPerformanceTracerEvent(
             events.emplace_back(
                 TraceEvent{
                     .name = "ResourceFinish",
-                    .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
@@ -134,6 +136,12 @@ class PerformanceTracer {
       const std::string &requestMethod,
       const Headers &headers);
 
+  /**
+   * Record a "ResourceReceivedData" event.
+   * If not currently tracing, this is a no-op.
+   */
+  void reportResourceReceivedData(const std::string &devtoolsRequestId, HighResTimeStamp start, int encodedDataLength);
+
   /**
    * Record a "ResourceReceiveResponse" event. Paired with other "Resource*"
    * events, renders a network request timeline in the Performance panel Network
@@ -243,6 +251,7 @@ class PerformanceTracer {
     HighResDuration duration;
     folly::dynamic detail;
     ThreadId threadId;
+    std::optional<folly::dynamic> stackTrace;
     HighResTimeStamp createdAt = HighResTimeStamp::now();
   };
 
@@ -254,6 +263,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();
   };
@@ -277,6 +287,14 @@ class PerformanceTracer {
     HighResTimeStamp createdAt = HighResTimeStamp::now();
   };
 
+  struct PerformanceTracerResourceReceivedData {
+    std::string requestId;
+    HighResTimeStamp start;
+    int encodedDataLength;
+    ThreadId threadId;
+    HighResTimeStamp createdAt = HighResTimeStamp::now();
+  };
+
   struct PerformanceTracerResourceReceiveResponse {
     std::string requestId;
     HighResTimeStamp start;
@@ -298,6 +316,7 @@ class PerformanceTracer {
       PerformanceTracerEventMeasure,
       PerformanceTracerResourceSendRequest,
       PerformanceTracerResourceReceiveResponse,
+      PerformanceTracerResourceReceivedData,
       PerformanceTracerResourceFinish>;
 
 #pragma mark - Private fields and methods

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/TimeWindowedBuffer.h

@@ -0,0 +1,158 @@
+/*
+ * 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 <algorithm>
+#include <functional>
+#include <optional>
+#include <vector>
+
+#include <react/timing/primitives.h>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/**
+ * The currentBufferStartTime_ is initialized once first element is pushed.
+ */
+constexpr HighResTimeStamp kCurrentBufferStartTimeUninitialized = HighResTimeStamp::min();
+
+template <typename T>
+class TimeWindowedBuffer {
+ public:
+  using TimestampAccessor = std::function<HighResTimeStamp(const T &)>;
+
+  TimeWindowedBuffer() : timestampAccessor_(std::nullopt), windowSize_(std::nullopt) {}
+
+  TimeWindowedBuffer(TimestampAccessor timestampAccessor, HighResDuration windowSize)
+      : timestampAccessor_(std::move(timestampAccessor)), windowSize_(windowSize)
+  {
+  }
+
+  void push(const T &element)
+  {
+    if (timestampAccessor_) {
+      auto timestamp = (*timestampAccessor_)(element);
+      enqueueElement(element, timestamp);
+    } else {
+      enqueueElement(element, HighResTimeStamp::now());
+    }
+  }
+
+  void push(T &&element)
+  {
+    if (timestampAccessor_) {
+      auto timestamp = (*timestampAccessor_)(element);
+      enqueueElement(std::move(element), timestamp);
+    } else {
+      enqueueElement(std::move(element), HighResTimeStamp::now());
+    }
+  }
+
+  void clear()
+  {
+    primaryBuffer_.clear();
+    alternativeBuffer_.clear();
+    currentBufferIndex_ = BufferIndex::Primary;
+    currentBufferStartTime_ = kCurrentBufferStartTimeUninitialized;
+  }
+
+  /**
+   * Forces immediate removal of elements that are outside the time window.
+   * The right boundary of the window is the reference timestamp passed as an argument.
+   */
+  std::vector<T> pruneExpiredAndExtract(HighResTimeStamp windowRightBoundary = HighResTimeStamp::now())
+  {
+    std::vector<T> result;
+
+    for (auto &wrappedElement : getPreviousBuffer()) {
+      if (isInsideTimeWindow(wrappedElement, windowRightBoundary)) {
+        result.push_back(std::move(wrappedElement.element));
+      }
+    }
+
+    for (auto &wrappedElement : getCurrentBuffer()) {
+      if (isInsideTimeWindow(wrappedElement, windowRightBoundary)) {
+        result.push_back(std::move(wrappedElement.element));
+      }
+    }
+
+    clear();
+    return result;
+  }
+
+ private:
+  enum class BufferIndex { Primary, Alternative };
+
+  struct TimestampedElement {
+    T element;
+    HighResTimeStamp timestamp;
+  };
+
+  std::vector<TimestampedElement> &getCurrentBuffer()
+  {
+    return currentBufferIndex_ == BufferIndex::Primary ? primaryBuffer_ : alternativeBuffer_;
+  }
+
+  std::vector<TimestampedElement> &getPreviousBuffer()
+  {
+    return currentBufferIndex_ == BufferIndex::Primary ? alternativeBuffer_ : primaryBuffer_;
+  }
+
+  void enqueueElement(const T &element, HighResTimeStamp timestamp)
+  {
+    if (windowSize_) {
+      if (currentBufferStartTime_ == kCurrentBufferStartTimeUninitialized) {
+        currentBufferStartTime_ = timestamp;
+      } else if (timestamp > currentBufferStartTime_ + *windowSize_) {
+        // We moved past the current buffer. We need to switch the other buffer as current.
+        currentBufferIndex_ =
+            currentBufferIndex_ == BufferIndex::Primary ? BufferIndex::Alternative : BufferIndex::Primary;
+        getCurrentBuffer().clear();
+        currentBufferStartTime_ = timestamp;
+      }
+    }
+
+    getCurrentBuffer().push_back({element, timestamp});
+  }
+
+  void enqueueElement(T &&element, HighResTimeStamp timestamp)
+  {
+    if (windowSize_) {
+      if (currentBufferStartTime_ == kCurrentBufferStartTimeUninitialized) {
+        currentBufferStartTime_ = timestamp;
+      } else if (timestamp > currentBufferStartTime_ + *windowSize_) {
+        // We moved past the current buffer. We need to switch the other buffer as current.
+        currentBufferIndex_ =
+            currentBufferIndex_ == BufferIndex::Primary ? BufferIndex::Alternative : BufferIndex::Primary;
+        getCurrentBuffer().clear();
+        currentBufferStartTime_ = timestamp;
+      }
+    }
+
+    getCurrentBuffer().push_back({std::move(element), timestamp});
+  }
+
+  bool isInsideTimeWindow(const TimestampedElement &element, HighResTimeStamp windowRightBoundary) const
+  {
+    if (!windowSize_) {
+      return true;
+    }
+
+    return element.timestamp >= windowRightBoundary - *windowSize_ && element.timestamp <= windowRightBoundary;
+  }
+
+  std::optional<TimestampAccessor> timestampAccessor_;
+  std::optional<HighResDuration> windowSize_;
+
+  std::vector<TimestampedElement> primaryBuffer_;
+  std::vector<TimestampedElement> alternativeBuffer_;
+  BufferIndex currentBufferIndex_ = BufferIndex::Primary;
+  HighResTimeStamp currentBufferStartTime_{kCurrentBufferStartTimeUninitialized};
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

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