react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/jsinspector-modern/RuntimeTargetDebuggerSessionObserver.cpp

@@ -6,106 +6,17 @@
  */
 
 #include <jsinspector-modern/RuntimeTarget.h>
+#include <jsinspector-modern/RuntimeTargetGlobalStateObserver.h>
 
 namespace facebook::react::jsinspector_modern {
 
 void RuntimeTarget::installDebuggerSessionObserver() {
   jsExecutor_([](jsi::Runtime& runtime) {
-    auto globalObj = runtime.global();
-    try {
-      auto observer = jsi::Object(runtime);
-
-      observer.setProperty(runtime, "hasActiveSession", jsi::Value(false));
-
-      auto setFunction = globalObj.getPropertyAsFunction(runtime, "Set");
-      auto set = setFunction.callAsConstructor(runtime);
-      observer.setProperty(runtime, "subscribers", set);
-
-      observer.setProperty(
-          runtime,
-          "onSessionStatusChange",
-          jsi::Function::createFromHostFunction(
-              runtime,
-              jsi::PropNameID::forAscii(runtime, "onSessionStatusChange"),
-              1,
-              [](jsi::Runtime& onSessionStatusChangeRuntime,
-                 const jsi::Value& /* onSessionStatusChangeThisVal */,
-                 const jsi::Value* onSessionStatusChangeArgs,
-                 size_t onSessionStatusChangeArgsCount) {
-                if (onSessionStatusChangeArgsCount != 1 ||
-                    !onSessionStatusChangeArgs[0].isBool()) {
-                  throw jsi::JSError(
-                      onSessionStatusChangeRuntime,
-                      "Invalid arguments: onSessionStatusChange expects 1 boolean argument");
-                }
-
-                bool updatedStatus = onSessionStatusChangeArgs[0].getBool();
-
-                auto observerInstanceFromOnSessionStatusChange =
-                    onSessionStatusChangeRuntime.global().getPropertyAsObject(
-                        onSessionStatusChangeRuntime,
-                        "__DEBUGGER_SESSION_OBSERVER__");
-                auto subscribersToNotify =
-                    observerInstanceFromOnSessionStatusChange
-                        .getPropertyAsObject(
-                            onSessionStatusChangeRuntime, "subscribers");
-
-                observerInstanceFromOnSessionStatusChange.setProperty(
-                    onSessionStatusChangeRuntime,
-                    "hasActiveSession",
-                    updatedStatus);
-
-                if (subscribersToNotify
-                        .getProperty(onSessionStatusChangeRuntime, "size")
-                        .asNumber() == 0) {
-                  return jsi::Value::undefined();
-                }
-
-                auto forEachSubscriber =
-                    subscribersToNotify.getPropertyAsFunction(
-                        onSessionStatusChangeRuntime, "forEach");
-                auto forEachSubscriberCallback =
-                    jsi::Function::createFromHostFunction(
-                        onSessionStatusChangeRuntime,
-                        jsi::PropNameID::forAscii(
-                            onSessionStatusChangeRuntime, "forEachCallback"),
-                        1,
-                        [updatedStatus](
-                            jsi::Runtime& forEachCallbackRuntime,
-                            const jsi::Value& /* forEachCallbackThisVal */,
-                            const jsi::Value* forEachCallbackArgs,
-                            size_t forEachCallbackArgsCount) {
-                          if (forEachCallbackArgsCount < 1 ||
-                              !forEachCallbackArgs[0].isObject() ||
-                              !forEachCallbackArgs[0]
-                                   .getObject(forEachCallbackRuntime)
-                                   .isFunction(forEachCallbackRuntime)) {
-                            throw jsi::JSError(
-                                forEachCallbackRuntime,
-                                "Invalid arguments: forEachSubscriberCallback expects function as a first argument");
-                          }
-
-                          forEachCallbackArgs[0]
-                              .getObject(forEachCallbackRuntime)
-                              .asFunction(forEachCallbackRuntime)
-                              .call(forEachCallbackRuntime, updatedStatus);
-
-                          return jsi::Value::undefined();
-                        });
-
-                forEachSubscriber.callWithThis(
-                    onSessionStatusChangeRuntime,
-                    subscribersToNotify,
-                    forEachSubscriberCallback);
-
-                return jsi::Value::undefined();
-              }));
-
-      globalObj.setProperty(runtime, "__DEBUGGER_SESSION_OBSERVER__", observer);
-    } catch (jsi::JSError&) {
-      // Suppress any errors, they should not be visible to the user
-      // and should not affect runtime.
-    }
+    installGlobalStateObserver(
+        runtime,
+        "__DEBUGGER_SESSION_OBSERVER__",
+        "hasActiveSession",
+        "onSessionStatusChange");
   });
 }
 

package/ReactCommon/jsinspector-modern/RuntimeTargetGlobalStateObserver.cpp

@@ -0,0 +1,122 @@
+/*
+ * 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 "RuntimeTargetGlobalStateObserver.h"
+
+#include <string>
+
+namespace facebook::react::jsinspector_modern {
+
+void installGlobalStateObserver(
+    jsi::Runtime& runtime,
+    const char* globalName,
+    const char* statusProperty,
+    const char* callbackName) {
+  auto globalObj = runtime.global();
+  try {
+    auto observer = jsi::Object(runtime);
+
+    observer.setProperty(runtime, statusProperty, jsi::Value(false));
+
+    auto setFunction = globalObj.getPropertyAsFunction(runtime, "Set");
+    auto set = setFunction.callAsConstructor(runtime);
+    observer.setProperty(runtime, "subscribers", set);
+
+    std::string globalNameStr(globalName);
+    std::string statusPropertyStr(statusProperty);
+
+    observer.setProperty(
+        runtime,
+        callbackName,
+        jsi::Function::createFromHostFunction(
+            runtime,
+            jsi::PropNameID::forAscii(runtime, callbackName),
+            1,
+            [globalNameStr, statusPropertyStr](
+                jsi::Runtime& callbackRuntime,
+                const jsi::Value& /* thisVal */,
+                const jsi::Value* args,
+                size_t argsCount) {
+              if (argsCount != 1 || !args[0].isBool()) {
+                throw jsi::JSError(
+                    callbackRuntime,
+                    "Invalid arguments: state change callback expects 1 boolean argument");
+              }
+
+              bool updatedStatus = args[0].getBool();
+
+              auto observerInstance =
+                  callbackRuntime.global().getPropertyAsObject(
+                      callbackRuntime, globalNameStr.c_str());
+              auto subscribersToNotify = observerInstance.getPropertyAsObject(
+                  callbackRuntime, "subscribers");
+
+              observerInstance.setProperty(
+                  callbackRuntime, statusPropertyStr.c_str(), updatedStatus);
+
+              if (subscribersToNotify.getProperty(callbackRuntime, "size")
+                      .asNumber() == 0) {
+                return jsi::Value::undefined();
+              }
+
+              auto forEachSubscriber =
+                  subscribersToNotify.getPropertyAsFunction(
+                      callbackRuntime, "forEach");
+              auto forEachSubscriberCallback = jsi::Function::createFromHostFunction(
+                  callbackRuntime,
+                  jsi::PropNameID::forAscii(callbackRuntime, "forEachCallback"),
+                  1,
+                  [updatedStatus](
+                      jsi::Runtime& forEachCallbackRuntime,
+                      const jsi::Value& /* forEachCallbackThisVal */,
+                      const jsi::Value* forEachCallbackArgs,
+                      size_t forEachCallbackArgsCount) {
+                    if (forEachCallbackArgsCount < 1 ||
+                        !forEachCallbackArgs[0].isObject() ||
+                        !forEachCallbackArgs[0]
+                             .getObject(forEachCallbackRuntime)
+                             .isFunction(forEachCallbackRuntime)) {
+                      throw jsi::JSError(
+                          forEachCallbackRuntime,
+                          "Invalid arguments: forEachSubscriberCallback expects function as a first argument");
+                    }
+
+                    forEachCallbackArgs[0]
+                        .getObject(forEachCallbackRuntime)
+                        .asFunction(forEachCallbackRuntime)
+                        .call(forEachCallbackRuntime, updatedStatus);
+
+                    return jsi::Value::undefined();
+                  });
+
+              forEachSubscriber.callWithThis(
+                  callbackRuntime,
+                  subscribersToNotify,
+                  forEachSubscriberCallback);
+
+              return jsi::Value::undefined();
+            }));
+
+    globalObj.setProperty(runtime, globalName, observer);
+  } catch (jsi::JSError&) {
+    // Suppress any errors, they should not be visible to the user
+    // and should not affect runtime.
+  }
+}
+
+void emitGlobalStateObserverChange(
+    jsi::Runtime& runtime,
+    const char* globalName,
+    const char* callbackName,
+    bool value) {
+  auto globalObj = runtime.global();
+  auto observer = globalObj.getPropertyAsObject(runtime, globalName);
+  auto callback = observer.getPropertyAsFunction(runtime, callbackName);
+  callback.call(runtime, jsi::Value(value));
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/RuntimeTargetGlobalStateObserver.h

@@ -0,0 +1,42 @@
+/*
+ * 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 <jsi/jsi.h>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Installs a global state observer object on the JavaScript runtime's global
+ * object. The observer has a boolean status property, a Set of subscribers,
+ * and a callback that updates the status and notifies subscribers.
+ *
+ * @param globalName The name of the global object (e.g.,
+ *   "__DEBUGGER_SESSION_OBSERVER__").
+ * @param statusProperty The name of the boolean property (e.g.,
+ *   "hasActiveSession").
+ * @param callbackName The name of the state change callback (e.g.,
+ *   "onSessionStatusChange").
+ */
+void installGlobalStateObserver(
+    jsi::Runtime &runtime,
+    const char *globalName,
+    const char *statusProperty,
+    const char *callbackName);
+
+/**
+ * Emits a state change to an installed global state observer by calling its
+ * callback function.
+ *
+ * @param globalName The name of the global object.
+ * @param callbackName The name of the state change callback.
+ * @param value The new boolean state value.
+ */
+void emitGlobalStateObserverChange(jsi::Runtime &runtime, const char *globalName, const char *callbackName, bool value);
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/RuntimeTargetTracingStateObserver.cpp

@@ -0,0 +1,27 @@
+/*
+ * 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 "RuntimeTargetTracingStateObserver.h"
+
+#include <jsinspector-modern/RuntimeTargetGlobalStateObserver.h>
+
+namespace facebook::react::jsinspector_modern {
+
+void installTracingStateObserver(jsi::Runtime& runtime) {
+  installGlobalStateObserver(
+      runtime,
+      "__TRACING_STATE_OBSERVER__",
+      "isTracing",
+      "onTracingStateChange");
+}
+
+void emitTracingStateObserverChange(jsi::Runtime& runtime, bool isTracing) {
+  emitGlobalStateObserverChange(
+      runtime, "__TRACING_STATE_OBSERVER__", "onTracingStateChange", isTracing);
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/RuntimeTargetTracingStateObserver.h

@@ -0,0 +1,27 @@
+/*
+ * 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 <jsi/jsi.h>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Installs __TRACING_STATE_OBSERVER__ object on the JavaScript's global
+ * object, which can be referenced from JavaScript side for determining the
+ * status of performance tracing.
+ */
+void installTracingStateObserver(jsi::Runtime &runtime);
+
+/**
+ * Emits the tracing state change to JavaScript by calling onTracingStateChange
+ * on __TRACING_STATE_OBSERVER__.
+ */
+void emitTracingStateObserverChange(jsi::Runtime &runtime, bool isTracing);
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/TracingAgent.cpp

@@ -6,8 +6,8 @@
  */
 
 #include "TracingAgent.h"
+#include "HostTargetTracing.h"
 
-#include <jsinspector-modern/tracing/HostTracingProfileSerializer.h>
 #include <jsinspector-modern/tracing/PerformanceTracer.h>
 #include <jsinspector-modern/tracing/RuntimeSamplingProfileTraceEventSerializer.h>
 #include <jsinspector-modern/tracing/TraceEventSerializer.h>
@@ -15,22 +15,6 @@
 
 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;
-
-/**
- * The maximum number of ProfileChunk trace events
- * that will be sent in a single CDP Tracing.dataCollected message.
- */
-const uint16_t PROFILE_TRACE_EVENT_CHUNK_SIZE = 10;
-
-} // namespace
-
 TracingAgent::TracingAgent(
     FrontendChannel frontendChannel,
     SessionState& sessionState,
@@ -90,6 +74,8 @@ bool TracingAgent::handleRequest(const cdp::PreparsedRequest& req) {
     bool didNotHaveAlreadyRunningRecording = hostTargetController_.startTracing(
         tracing::Mode::CDP, std::move(enabledCategories));
     if (!didNotHaveAlreadyRunningRecording) {
+      // @cdp Tracing.start fails if there is a tracing session already running
+      // in the current target. This matches Chrome's behavior.
       frontendChannel_(
           cdp::jsonError(
               req.id,
@@ -110,38 +96,14 @@ bool TracingAgent::handleRequest(const cdp::PreparsedRequest& req) {
     // Send response to Tracing.end request.
     frontendChannel_(cdp::jsonResult(req.id));
 
-    emitHostTracingProfile(std::move(tracingProfile));
+    emitNotificationsForTracingProfile(
+        std::move(tracingProfile),
+        frontendChannel_,
+        /* isBackgroundTrace */ false);
     return true;
   }
 
   return false;
 }
 
-void TracingAgent::emitExternalHostTracingProfile(
-    tracing::HostTracingProfile tracingProfile) const {
-  frontendChannel_(
-      cdp::jsonNotification("ReactNativeApplication.traceRequested"));
-  emitHostTracingProfile(std::move(tracingProfile));
-}
-
-void TracingAgent::emitHostTracingProfile(
-    tracing::HostTracingProfile tracingProfile) const {
-  auto dataCollectedCallback = [this](folly::dynamic&& eventsChunk) {
-    frontendChannel_(
-        cdp::jsonNotification(
-            "Tracing.dataCollected",
-            folly::dynamic::object("value", std::move(eventsChunk))));
-  };
-  tracing::HostTracingProfileSerializer::emitAsDataCollectedChunks(
-      std::move(tracingProfile),
-      dataCollectedCallback,
-      TRACE_EVENT_CHUNK_SIZE,
-      PROFILE_TRACE_EVENT_CHUNK_SIZE);
-
-  frontendChannel_(
-      cdp::jsonNotification(
-          "Tracing.tracingComplete",
-          folly::dynamic::object("dataLossOccurred", false)));
-}
-
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/TracingAgent.h

@@ -41,11 +41,6 @@ class TracingAgent {
    */
   bool handleRequest(const cdp::PreparsedRequest &req);
 
-  /**
-   * Emits the HostTracingProfile that was stashed externally by the HostTarget.
-   */
-  void emitExternalHostTracingProfile(tracing::HostTracingProfile tracingProfile) const;
-
  private:
   /**
    * A channel used to send responses and events to the frontend.
@@ -55,12 +50,6 @@ class TracingAgent {
   SessionState &sessionState_;
 
   HostTargetController &hostTargetController_;
-
-  /**
-   * Emits captured HostTracingProfile in a series of
-   * Tracing.dataCollected events, followed by a Tracing.tracingComplete event.
-   */
-  void emitHostTracingProfile(tracing::HostTracingProfile tracingProfile) const;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/UniqueMonostate.h

@@ -22,10 +22,6 @@ struct UniqueMonostate {
   {
     return true;
   }
-  constexpr bool operator!=(const UniqueMonostate<key> & /*unused*/) const noexcept
-  {
-    return false;
-  }
   constexpr bool operator<(const UniqueMonostate<key> & /*unused*/) const noexcept
   {
     return false;

package/ReactCommon/jsinspector-modern/WeakList.h

@@ -30,7 +30,7 @@ class WeakList {
    * to destroyed elements) will be removed during iteration.
    */
   template <typename Fn>
-  void forEach(Fn &&fn) const
+  void forEach(Fn &&fn)
   {
     for (auto it = ptrs_.begin(); it != ptrs_.end();) {
       if (auto ptr = it->lock()) {
@@ -42,6 +42,65 @@ class WeakList {
     }
   }
 
+  /**
+   * Call the given function for every element in the list, ensuring the element
+   * is not destroyed for the duration of the call. Elements are visited in the
+   * order they were inserted.
+   *
+   * As a side effect, any null pointers in the underlying list (corresponding
+   * to destroyed elements) will be removed during iteration.
+   */
+  template <typename Fn>
+  void forEach(Fn &&fn) const
+  {
+    for (auto it = ptrs_.cbegin(); it != ptrs_.cend();) {
+      if (auto ptr = it->lock()) {
+        fn(*ptr);
+        ++it;
+      } else {
+        it = ptrs_.erase(it);
+      }
+    }
+  }
+
+  /**
+   * Returns true if the given function returns true for any element in the
+   * list, ensuring the element is not destroyed for the duration of the call.
+   *
+   * As a side effect, any null pointers in the underlying list (corresponding
+   * to destroyed elements) will be removed during iteration.
+   */
+  template <typename Fn>
+  bool anyOf(Fn &&fn)
+  {
+    bool found = false;
+    forEach([&](auto &element) {
+      if (!found && fn(element)) {
+        found = true;
+      }
+    });
+    return found;
+  }
+
+  /**
+   * Returns true if the given function returns true for any element in the
+   * list, ensuring the element is not destroyed for the duration of the call.
+   *
+   * As a side effect, any null pointers in the underlying list (corresponding
+   * to destroyed elements) will be removed during iteration.
+   */
+  template <typename Fn>
+  bool anyOf(Fn &&fn) const
+  {
+    bool found = false;
+    forEach([&](const auto &element) {
+      if (!found && fn(element)) {
+        found = true;
+      }
+    });
+    return found;
+  }
+
   /**
    * Returns the number of (non-null) elements in the list. The count will only
    * remain accurate as long as the list is not modified and elements are

package/ReactCommon/jsinspector-modern/network/NetworkHandler.cpp

@@ -37,27 +37,31 @@ NetworkHandler& NetworkHandler::getInstance() {
   return instance;
 }
 
-void NetworkHandler::setFrontendChannel(FrontendChannel frontendChannel) {
-  frontendChannel_ = std::move(frontendChannel);
+size_t NetworkHandler::enableAgent(FrontendChannel frontendChannel) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  size_t id = nextAgentId_++;
+  agents_.push_back({id, std::move(frontendChannel)});
+  enabled_.store(true, std::memory_order_release);
+  return id;
 }
 
-bool NetworkHandler::enable() {
-  if (enabled_.load(std::memory_order_acquire)) {
-    return false;
-  }
+void NetworkHandler::disableAgent(size_t agentId) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  agents_.remove_if(
+      [agentId](const AgentRecord& r) { return r.id == agentId; });
+  if (agents_.empty()) {
+    enabled_.store(false, std::memory_order_release);
 
-  enabled_.store(true, std::memory_order_release);
-  return true;
+    std::lock_guard<std::mutex> lock2(requestBodyMutex_);
+    responseBodyBuffer_.clear();
+  }
 }
 
-bool NetworkHandler::disable() {
-  if (!enabled_.load(std::memory_order_acquire)) {
-    return false;
+void NetworkHandler::sendToAllAgents(std::string_view message) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  for (auto& agent : agents_) {
+    agent.channel(message);
   }
-
-  enabled_.store(false, std::memory_order_release);
-  responseBodyBuffer_.clear();
-  return true;
 }
 
 void NetworkHandler::onRequestWillBeSent(
@@ -88,7 +92,7 @@ void NetworkHandler::onRequestWillBeSent(
       .redirectResponse = redirectResponse,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.requestWillBeSent", params.toDynamic()));
 }
 
@@ -105,7 +109,7 @@ void NetworkHandler::onRequestWillBeSentExtraInfo(
       .connectTiming = {.requestTime = getCurrentUnixTimestampSeconds()},
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification(
           "Network.requestWillBeSentExtraInfo", params.toDynamic()));
 }
@@ -132,7 +136,7 @@ void NetworkHandler::onResponseReceived(
       .hasExtraInfo = false,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.responseReceived", params.toDynamic()));
 }
 
@@ -151,7 +155,7 @@ void NetworkHandler::onDataReceived(
       .encodedDataLength = encodedDataLength,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.dataReceived", params.toDynamic()));
 }
 
@@ -168,7 +172,7 @@ void NetworkHandler::onLoadingFinished(
       .encodedDataLength = encodedDataLength,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.loadingFinished", params.toDynamic()));
 }
 
@@ -191,7 +195,7 @@ void NetworkHandler::onLoadingFailed(
         .canceled = cancelled,
     };
 
-    frontendChannel_(
+    sendToAllAgents(
         cdp::jsonNotification("Network.loadingFailed", params.toDynamic()));
   }
 }

package/ReactCommon/jsinspector-modern/network/NetworkHandler.h

@@ -13,6 +13,7 @@
 #include <folly/dynamic.h>
 
 #include <atomic>
+#include <list>
 #include <mutex>
 #include <string>
 #include <tuple>
@@ -36,24 +37,17 @@ class NetworkHandler {
   static NetworkHandler &getInstance();
 
   /**
-   * Set the channel used to send CDP events to the frontend. This should be
-   * supplied before calling `enable`.
+   * Register a frontend channel for receiving Network domain events.
+   * Implicitly enables the domain if this is the first agent.
+   * \returns An agent ID to be passed to disableAgent() on cleanup.
    */
-  void setFrontendChannel(FrontendChannel frontendChannel);
+  size_t enableAgent(FrontendChannel frontendChannel);
 
   /**
-   * Enable network debugging. Returns `false` if already enabled.
-   *
-   * @cdp Network.enable
-   */
-  bool enable();
-
-  /**
-   * Disable network debugging. Returns `false` if not initially enabled.
-   *
-   * @cdp Network.disable
+   * Unregister a frontend channel by its ID.
+   * Implicitly disables the domain if this was the last agent.
    */
-  bool disable();
+  void disableAgent(size_t agentId);
 
   /**
    * Returns whether network debugging is currently enabled.
@@ -134,7 +128,19 @@ class NetworkHandler {
 
   std::optional<folly::dynamic> consumeStoredRequestInitiator(const std::string &requestId);
 
-  FrontendChannel frontendChannel_;
+  /**
+   * Send a message to all registered frontend channels.
+   */
+  void sendToAllAgents(std::string_view message);
+
+  struct AgentRecord {
+    size_t id;
+    FrontendChannel channel;
+  };
+
+  std::list<AgentRecord> agents_;
+  size_t nextAgentId_{0};
+  std::mutex agentsMutex_;
 
   std::map<std::string, std::string> resourceTypeMap_{};
   std::map<std::string, folly::dynamic> requestInitiatorById_{};