Always echo Artillery trace context on memcache-protocol replies

Summary:
UCache's memcache-protocol requests show up as INFERRED_BLOCKs in Artillery traces because the server never echoes trace context back — the echo was gated behind the expensive logging path (cost tracking + scribe flush) that UCache may not want to enable for cost reasons.

This adds a lightweight echo-only mode that returns trace context on replies without activating the logging path. A new gflag (`asmcs_trace_always_echo_context`) controls it, bridged into UCache via a live-observed folly setting for runtime kill-switch capability. Defaults off; existing behavior unchanged.

Questions for reviewer: Is this the best way to gate something like this? Is there a different preferred way?

Reviewed By: ghostonhuang

Differential Revision: D112132643

fbshipit-source-id: 7ef698073c92356bfa274118a9e6339b6b4eaad8

Author: John Hugg

mcrouter/lib/network/CarbonRequestHandler.h

@@ -72,12 +72,14 @@ class CarbonRequestHandler : public facebook::memcache::CarbonMessageDispatcher<
       const facebook::memcache::CaretMessageInfo* headerInfo,
       const folly::IOBuf* reqBuf,
       std::true_type) {
-    if (FOLLY_UNLIKELY(
-            !req.traceContext().empty() &&
-            facebook::mcrouter::traceCheckRateLimit())) {
-      onRequestImplWithTracingEnabled(
-          std::move(ctx), std::move(req), headerInfo, reqBuf);
-      return;
+    if (FOLLY_UNLIKELY(!req.traceContext().empty())) {
+      const bool loggingEnabled = facebook::mcrouter::traceCheckRateLimit();
+      if (loggingEnabled ||
+          facebook::mcrouter::traceShouldAlwaysEchoContext()) {
+        onRequestImplWithTracingEnabled(
+            std::move(ctx), std::move(req), headerInfo, reqBuf, loggingEnabled);
+        return;
+      }
     }
     callOnRequest(
         std::move(ctx),
@@ -104,17 +106,29 @@ class CarbonRequestHandler : public facebook::memcache::CarbonMessageDispatcher<
       facebook::memcache::McServerRequestContext&& ctx,
       Request&& req,
       const facebook::memcache::CaretMessageInfo* headerInfo,
-      const folly::IOBuf* reqBuf) {
+      const folly::IOBuf* reqBuf,
+      [[maybe_unused]] bool loggingEnabled) {
 #ifndef LIBMC_FBTRACE_DISABLE
     folly::RequestContextScopeGuard requestContextGuard;
-    auto tracingData = facebook::mcrouter::traceRequestReceived(
-        req.traceContext(), Request::name);
-    if (tracingData != nullptr) {
-      // Mark the context as being traced by Artillery
+    if (loggingEnabled) {
+      auto tracingData = facebook::mcrouter::traceRequestReceived(
+          req.traceContext(), Request::name);
+      if (tracingData != nullptr) {
+        // Mark the context as being traced by Artillery
+        markContextAsTraced(ctx);
+        facebook::mcrouter::extractAndSetCallerIdentities(
+            *tracingData, ctx.getThriftRequestContext());
+        tracingData->startCounters();
+      }
+    } else if (facebook::mcrouter::traceEchoOnlyRequestReceived(
+                   req.traceContext())) {
+      // Echo-only: the reply will carry the received trace context back, but
+      // no cost tracking or scribe flush happens. markContextAsTraced only
+      // sets ctx.isTraced_, whose sole reader is replyImpl2 -- it stamps the
+      // echoed context onto the reply via getCurrentTracer()->sendResponse()
+      // (the tracer set up by traceEchoOnlyRequestReceived above). It has no
+      // other side effects: no counters, logging, or scribe I/O.
       markContextAsTraced(ctx);
-      facebook::mcrouter::extractAndSetCallerIdentities(
-          *tracingData, ctx.getThriftRequestContext());
-      tracingData->startCounters();
     }
 #endif
     callOnRequest(

mcrouter/lib/network/FBTrace-inl.h

@@ -26,6 +26,10 @@ inline bool traceCheckRateLimit() {
   return false;
 }
 
+inline bool traceShouldAlwaysEchoContext() {
+  return false;
+}
+
 inline uint64_t traceGetCount() {
   return 0;
 }
@@ -37,6 +41,11 @@ inline std::nullptr_t traceRequestReceived(
   return nullptr;
 }
 
+inline bool traceEchoOnlyRequestReceived(const std::string& traceContext) {
+  // Do nothing by default.
+  return false;
+}
+
 #else
 
 // Fwd declaration
@@ -48,6 +57,13 @@ std::shared_ptr<TracingData> traceRequestReceived(
     const std::string& traceContext,
     folly::StringPiece requestType);
 
+// Set up a tracer for reply-side echo only, without the heavyweight logging
+// path (no cost counters, no scribe flush). Stores the tracer under the
+// response-context key so getCurrentTracer()/replyImpl echoes it back. Returns
+// true if a tracer was set up.
+// NOTE: this function does not exist if LIBMC_FBTRACE_DISABLE is defined.
+bool traceEchoOnlyRequestReceived(const std::string& traceContext);
+
 #endif
 
 } // namespace mcrouter

mcrouter/lib/network/FBTrace.h

@@ -19,6 +19,10 @@ namespace mcrouter {
 // Returns true if a rate limiting check passes and tracing can proceed.
 bool traceCheckRateLimit();
 
+// Returns true if received trace context should always be echoed back on the
+// reply, independent of the rate limit (which gates only the logging path).
+bool traceShouldAlwaysEchoContext();
+
 // Returns the cumulative number of traces logged.
 uint64_t traceGetCount();