Add QLOG macro for mobile binary size reduction

Summary:
This change introduces a QLOG() macro that wraps all QLogger calls.
On mobile builds (Android, iOS, macOS), this macro compiles to a no-op via Buck's
select() mechanism, eliminating the function call overhead and associated code.

The key changes are:
- New QLoggerMacros.h with QLOG macro for non-mobile builds
- New QLoggerMacrosMobile.h with no-op macro for mobile builds
- Updated ~200 call sites across client, server, congestion control, loss, and state files
- BUCK files updated with platform-conditional header selection
- Removed unnecessary qLogger parameter from QuicStreamManager::setStreamPriority

Reviewed By: jbeshay

Differential Revision: D89485388

fbshipit-source-id: 34fb59157788b36ed8bcc6663eb0f094eaf6013e

Author: Matt Joras

quic/api/BUCK

@@ -86,6 +86,7 @@ mvfst_cpp_library(
         "//quic/common:mvfst_logging",
         "//quic/common:time_util",
         "//quic/logging:qlogger_constants",
+        "//quic/logging:qlogger_macros",
         "//quic/loss:loss",
         "//quic/observer:socket_observer_macros",
         "//quic/state:pacing_functions",
@@ -144,6 +145,7 @@ mvfst_cpp_library(
         "//quic/congestion_control:ecn_l4s_tracker",
         "//quic/congestion_control:pacer_factory",
         "//quic/flowcontrol:flow_control",
+        "//quic/logging:qlogger_macros",
         "//quic/loss:loss",
         "//quic/observer:socket_observer_macros",
         "//quic/state:pacing_functions",
@@ -199,6 +201,7 @@ mvfst_cpp_library(
         "//quic/common:socket_util",
         "//quic/common:string_utils",
         "//quic/happyeyeballs:happyeyeballs",
+        "//quic/logging:qlogger_macros",
         "//quic/state:ack_frequency_functions",
         "//quic/state:ack_handler",
         "//quic/state:simple_frame_functions",

quic/api/QuicTransportBase.cpp

@@ -14,6 +14,7 @@
 #include <quic/common/Optional.h>
 #include <quic/common/TimeUtil.h>
 #include <quic/logging/QLoggerConstants.h>
+#include <quic/logging/QLoggerMacros.h>
 #include <quic/loss/QuicLossFunctions.h>
 #include <quic/observer/SocketObserverMacros.h>
 #include <quic/state/QuicPacingFunctions.h>
@@ -91,9 +92,7 @@ void QuicTransportBase::closeGracefully() {
   resetConnectionCallbacks();
   closeState_ = CloseState::GRACEFUL_CLOSING;
   updatePacingOnClose(*conn_);
-  if (conn_->qLogger) {
-    conn_->qLogger->addConnectionClose(kNoError, kGracefulExit, true, false);
-  }
+  QLOG(*conn_, addConnectionClose, kNoError, kGracefulExit, true, false);
 
   // Stop reads and cancel all the app callbacks.
   MVVLOG(10) << "Stopping read and peek loopers due to graceful close "

quic/api/QuicTransportBaseLite.cpp

@@ -13,6 +13,7 @@
 #include <quic/congestion_control/EcnL4sTracker.h>
 #include <quic/congestion_control/PacerFactory.h>
 #include <quic/flowcontrol/QuicFlowController.h>
+#include <quic/logging/QLoggerMacros.h>
 #include <quic/loss/QuicLossFunctions.h>
 #include <quic/observer/SocketObserverMacros.h>
 #include <quic/state/QuicPacingFunctions.h>
@@ -831,10 +832,7 @@ quic::Expected<void, LocalErrorCode> QuicTransportBaseLite::setStreamPriority(
   // It's not an error to prioritize a stream after it's sent its FIN - this
   // can reprioritize retransmissions.
   conn_->streamManager->setStreamPriority(
-      id,
-      priority,
-      getSendConnFlowControlBytesWire(*conn_) > 0,
-      conn_->qLogger);
+      id, priority, getSendConnFlowControlBytesWire(*conn_) > 0);
   return {};
 }
 
@@ -1397,8 +1395,8 @@ void QuicTransportBaseLite::closeImpl(
 
   drainConnection = drainConnection & conn_->transportSettings.shouldDrain;
 
-  uint64_t totalCryptoDataWritten = 0;
-  uint64_t totalCryptoDataRecvd = 0;
+  uint64_t totalCryptoDataWritten [[maybe_unused]] = 0;
+  uint64_t totalCryptoDataRecvd [[maybe_unused]] = 0;
   auto timeUntilLastInitialCryptoFrameReceived = std::chrono::milliseconds(0);
   if (conn_->cryptoState) {
     totalCryptoDataWritten +=
@@ -1418,36 +1416,36 @@ void QuicTransportBaseLite::closeImpl(
             conn_->connectionTime);
   }
 
-  if (conn_->qLogger) {
-    auto tlsSummary = conn_->handshakeLayer->getTLSSummary();
-    conn_->qLogger->addTransportSummary(
-        {conn_->lossState.totalBytesSent,
-         conn_->lossState.totalBytesRecvd,
-         conn_->flowControlState.sumCurWriteOffset,
-         conn_->flowControlState.sumMaxObservedOffset,
-         conn_->flowControlState.sumCurStreamBufferLen,
-         conn_->lossState.totalBytesRetransmitted,
-         conn_->lossState.totalStreamBytesCloned,
-         conn_->lossState.totalBytesCloned,
-         totalCryptoDataWritten,
-         totalCryptoDataRecvd,
-         conn_->congestionController
-             ? conn_->congestionController->getWritableBytes()
-             : std::numeric_limits<uint64_t>::max(),
-         getSendConnFlowControlBytesWire(*conn_),
-         conn_->lossState.totalPacketsSpuriouslyMarkedLost,
-         conn_->lossState.reorderingThreshold,
-         uint64_t(conn_->transportSettings.timeReorderingThreshDividend),
-         conn_->usedZeroRtt,
-         conn_->version.value_or(QuicVersion::MVFST_INVALID),
-         conn_->initialPacketsReceived,
-         conn_->uniqueInitialCryptoFramesReceived,
-         timeUntilLastInitialCryptoFrameReceived,
-         tlsSummary.alpn,
-         tlsSummary.namedGroup,
-         tlsSummary.pskType,
-         tlsSummary.echStatus});
-  }
+  [[maybe_unused]] auto tlsSummary = conn_->handshakeLayer->getTLSSummary();
+  QLOG(
+      *conn_,
+      addTransportSummary,
+      {conn_->lossState.totalBytesSent,
+       conn_->lossState.totalBytesRecvd,
+       conn_->flowControlState.sumCurWriteOffset,
+       conn_->flowControlState.sumMaxObservedOffset,
+       conn_->flowControlState.sumCurStreamBufferLen,
+       conn_->lossState.totalBytesRetransmitted,
+       conn_->lossState.totalStreamBytesCloned,
+       conn_->lossState.totalBytesCloned,
+       totalCryptoDataWritten,
+       totalCryptoDataRecvd,
+       conn_->congestionController
+           ? conn_->congestionController->getWritableBytes()
+           : std::numeric_limits<uint64_t>::max(),
+       getSendConnFlowControlBytesWire(*conn_),
+       conn_->lossState.totalPacketsSpuriouslyMarkedLost,
+       conn_->lossState.reorderingThreshold,
+       uint64_t(conn_->transportSettings.timeReorderingThreshDividend),
+       conn_->usedZeroRtt,
+       conn_->version.value_or(QuicVersion::MVFST_INVALID),
+       conn_->initialPacketsReceived,
+       conn_->uniqueInitialCryptoFramesReceived,
+       timeUntilLastInitialCryptoFrameReceived,
+       tlsSummary.alpn,
+       tlsSummary.namedGroup,
+       tlsSummary.pskType,
+       tlsSummary.echStatus});
 
   // TODO: truncate the error code string to be 1MSS only.
   closeState_ = CloseState::CLOSED;
@@ -1483,21 +1481,26 @@ void QuicTransportBaseLite::closeImpl(
                           << *this;
   if (errorCode) {
     conn_->localConnectionError = errorCode;
-    if (conn_->qLogger) {
-      conn_->qLogger->addConnectionClose(
-          conn_->localConnectionError->message,
-          errorCode->message,
-          drainConnection,
-          sendCloseImmediately);
-    }
-  } else if (conn_->qLogger) {
-    auto reason = fmt::format(
+    QLOG(
+        *conn_,
+        addConnectionClose,
+        conn_->localConnectionError->message,
+        errorCode->message,
+        drainConnection,
+        sendCloseImmediately);
+  } else {
+    [[maybe_unused]] auto reason = fmt::format(
         "Server: {}, Peer: isReset: {}, Peer: isAbandon: {}",
         kNoError,
         isReset,
         isAbandon);
-    conn_->qLogger->addConnectionClose(
-        kNoError, std::move(reason), drainConnection, sendCloseImmediately);
+    QLOG(
+        *conn_,
+        addConnectionClose,
+        kNoError,
+        std::move(reason),
+        drainConnection,
+        sendCloseImmediately);
   }
   cancelLossTimeout();
   cancelTimeout(&ackTimeout_);
@@ -2941,11 +2944,9 @@ void QuicTransportBaseLite::setCongestionControl(CongestionControlType type) {
     conn_->congestionController =
         conn_->congestionControllerFactory->makeCongestionController(
             *conn_, type);
-    if (conn_->qLogger) {
-      std::stringstream s;
-      s << "CCA set to " << congestionControlTypeToString(type);
-      conn_->qLogger->addTransportStateUpdate(s.str());
-    }
+    [[maybe_unused]] std::stringstream s;
+    s << "CCA set to " << congestionControlTypeToString(type);
+    QLOG(*conn_, addTransportStateUpdate, s.str());
   }
 }
 

quic/api/QuicTransportFunctions.cpp

@@ -19,6 +19,7 @@
 #include <quic/common/StringUtils.h>
 #include <quic/flowcontrol/QuicFlowController.h>
 #include <quic/happyeyeballs/QuicHappyEyeballsFunctions.h>
+#include <quic/logging/QLoggerMacros.h>
 
 #include <quic/state/AckHandlers.h>
 #include <quic/state/QuicAckFrequencyFunctions.h>
@@ -722,9 +723,7 @@ quic::Expected<void, QuicError> updateConnection(
   MVVLOG(10) << nodeToString(conn.nodeType) << " sent packetNum=" << packetNum
              << " in space=" << packetNumberSpace << " size=" << encodedSize
              << " bodySize: " << encodedBodySize << " " << conn;
-  if (conn.qLogger) {
-    conn.qLogger->addPacket(packet, encodedSize);
-  }
+  QLOG(conn, addPacket, packet, encodedSize);
   FOLLY_SDT(quic, update_connection_num_frames, packet.frames.size());
   for (const auto& frame : packet.frames) {
     switch (frame.type()) {
@@ -1487,9 +1486,7 @@ void writeCloseCommon(
   Buf packetBuf(std::move(packet.header));
   packetBuf.appendToChain(std::move(bufUniquePtr));
   auto packetSize = packetBuf.computeChainDataLength();
-  if (connection.qLogger) {
-    connection.qLogger->addPacket(packet.packet, packetSize);
-  }
+  QLOG(connection, addPacket, packet.packet, packetSize);
   MVVLOG(10) << nodeToString(connection.nodeType)
              << " sent close packetNum=" << packetNum << " in space=" << pnSpace
              << " " << connection;

quic/client/BUCK

@@ -43,6 +43,7 @@ mvfst_cpp_library(
         "//quic/handshake:handshake",
         "//quic/happyeyeballs:happyeyeballs",
         "//quic/logging:qlogger_constants",
+        "//quic/logging:qlogger_macros",
         "//quic/loss:loss",
         "//quic/state:ack_handler",
         "//quic/state:datagram_handler",
@@ -84,6 +85,7 @@ mvfst_cpp_library(
         "//quic/common:mvfst_logging",
         "//quic/common:time_util",
         "//quic/congestion_control:congestion_controller_factory",
+        "//quic/logging:qlogger_macros",
         "//quic/loss:loss",
         "//quic/state:quic_stream_utilities",
         "//quic/state:stream_functions",

quic/client/QuicClientTransportLite.cpp

@@ -22,6 +22,7 @@
 #include <quic/handshake/CryptoFactory.h>
 #include <quic/happyeyeballs/QuicHappyEyeballsFunctions.h>
 #include <quic/logging/QLoggerConstants.h>
+#include <quic/logging/QLoggerMacros.h>
 #include <quic/loss/QuicLossFunctions.h>
 #include <quic/state/AckHandlers.h>
 #include <quic/state/DatagramHandlers.h>
@@ -92,9 +93,7 @@ QuicClientTransportLite::QuicClientTransportLite(
       clientConn_->initialDestinationConnectionId;
   MVVLOG(4) << "initial dcid: "
             << clientConn_->initialDestinationConnectionId->hex();
-  if (conn_->qLogger) {
-    conn_->qLogger->setDcid(conn_->clientChosenDestConnectionId);
-  }
+  QLOG(*conn_, setDcid, conn_->clientChosenDestConnectionId);
 
   conn_->readCodec->setCodecParameters(CodecParameters(
       conn_->peerAckDelayExponent,
@@ -251,9 +250,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
 
   RetryPacket* retryPacket = parsedPacket.retryPacket();
   if (retryPacket) {
-    if (conn_->qLogger) {
-      conn_->qLogger->addPacket(*retryPacket, packetSize, true);
-    }
+    QLOG(*conn_, addPacket, *retryPacket, packetSize, true);
 
     // we reject retry packet if our initial has been processed or we've rx'd a
     // prior retry packet; note that initialAckState is reset to nullptr only
@@ -325,10 +322,11 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
             udpPacket.timings,
             udpPacket.tosValue),
         peerAddress);
-    if (conn_->qLogger) {
-      conn_->qLogger->addPacketBuffered(
-          cipherUnavailable->protectionType, packetSize);
-    }
+    QLOG(
+        *conn_,
+        addPacketBuffered,
+        cipherUnavailable->protectionType,
+        packetSize);
     // Packet buffered, not an error
     return {};
   }
@@ -358,9 +356,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
     MVVLOG(4) << "Packet parse error for " << *this;
     QUIC_STATS(
         statsCallback_, onPacketDropped, PacketDropReason::PARSE_ERROR_CLIENT);
-    if (conn_->qLogger) {
-      conn_->qLogger->addPacketDrop(packetSize, kParse);
-    }
+    QLOG(*conn_, addPacketDrop, packetSize, kParse);
     // If this was a protocol violation, we would return a codec error instead.
     // Ignore this case as something that caused a non-codec parse error.
     return {};
@@ -375,11 +371,11 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
         conn_->statsCallback,
         onPacketDropped,
         PacketDropReason::PROTOCOL_VIOLATION);
-    if (conn_->qLogger) {
-      conn_->qLogger->addPacketDrop(
-          packetSize,
-          PacketDropReason(PacketDropReason::PROTOCOL_VIOLATION)._to_string());
-    }
+    QLOG(
+        *conn_,
+        addPacketDrop,
+        packetSize,
+        PacketDropReason(PacketDropReason::PROTOCOL_VIOLATION)._to_string());
     return quic::make_unexpected(QuicError(
         TransportErrorCode::PROTOCOL_VIOLATION, "Packet has no frames"));
   }
@@ -399,9 +395,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
       protectionLevel == ProtectionType::KeyPhaseOne;
 
   auto& regularPacket = *regularOptional;
-  if (conn_->qLogger) {
-    conn_->qLogger->addPacket(regularPacket, packetSize);
-  }
+  QLOG(*conn_, addPacket, regularPacket, packetSize);
   if (!isProtectedPacket) {
     for (auto& quicFrame : regularPacket.frames) {
       auto isPadding = quicFrame.asPaddingFrame();
@@ -853,9 +847,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
       clientConn_->zeroRttRejected = handshakeLayer->getZeroRttRejected();
       if (clientConn_->zeroRttRejected.has_value() &&
           *clientConn_->zeroRttRejected) {
-        if (conn_->qLogger) {
-          conn_->qLogger->addTransportStateUpdate(kZeroRttRejected);
-        }
+        QLOG(*conn_, addTransportStateUpdate, kZeroRttRejected);
         QUIC_STATS(conn_->statsCallback, onZeroRttRejected);
         handshakeLayer->removePsk(hostname_);
         if (!handshakeLayer->getCanResendZeroRtt().value_or(false)) {
@@ -864,9 +856,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::processUdpPacketData(
               "Zero-rtt attempted but the early parameters do not match the handshake parameters"));
         }
       } else if (clientConn_->zeroRttRejected.has_value()) {
-        if (conn_->qLogger) {
-          conn_->qLogger->addTransportStateUpdate(kZeroRttAccepted);
-        }
+        QLOG(*conn_, addTransportStateUpdate, kZeroRttAccepted);
         QUIC_STATS(conn_->statsCallback, onZeroRttAccepted);
         conn_->usedZeroRtt = true;
       }
@@ -1048,9 +1038,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::onReadData(
     // If we are closed, then we shouldn't process new network data.
     QUIC_STATS(
         statsCallback_, onPacketDropped, PacketDropReason::CLIENT_STATE_CLOSED);
-    if (conn_->qLogger) {
-      conn_->qLogger->addPacketDrop(0, kAlreadyClosed);
-    }
+    QLOG(*conn_, addPacketDrop, 0, kAlreadyClosed);
     return {};
   }
   bool waitingForFirstPacket = !hasReceivedUdpPackets(*conn_);
@@ -1964,9 +1952,7 @@ void QuicClientTransportLite::start(
 
   CHECK(conn_->peerAddress.isInitialized());
 
-  if (conn_->qLogger) {
-    conn_->qLogger->addTransportStateUpdate(kStart);
-  }
+  QLOG(*conn_, addTransportStateUpdate, kStart);
 
   setConnectionSetupCallback(connSetupCb);
   setConnectionCallback(connCb);
@@ -2267,9 +2253,7 @@ quic::Expected<void, QuicError> QuicClientTransportLite::migrateConnection(
     return quic::make_unexpected(adjustResult.error());
   }
 
-  if (conn_->qLogger) {
-    conn_->qLogger->addConnectionMigrationUpdate(true);
-  }
+  QLOG(*conn_, addConnectionMigrationUpdate, true);
 
   QUIC_STATS(conn_->statsCallback, onConnectionMigration);
 
@@ -2307,9 +2291,7 @@ void QuicClientTransportLite::setTransportStatsCallback(
 }
 
 void QuicClientTransportLite::maybeQlogDatagram(size_t len) {
-  if (conn_->qLogger) {
-    conn_->qLogger->addDatagramReceived(len);
-  }
+  QLOG(*conn_, addDatagramReceived, len);
 }
 
 void QuicClientTransportLite::trackDatagramsReceived(