Move xplat/quic from autosyncer to dirsync

Summary:
* remove quic from autosyncer
* set up dirsync for quic
* mirror source file for xplat/quic fbcode/quic

Reviewed By: JunqiWang

Differential Revision: D16254573

fbshipit-source-id: 24414d275de310b5d0cf6bb2702a203e5aed260c

quic/congestion_control/test/BbrBandwidthSamplerTest.cpp

@@ -122,35 +122,17 @@ TEST_F(BbrBandwidthSamplerTest, SampleExpiration) {
 
 TEST_F(BbrBandwidthSamplerTest, AppLimited) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
-
   BbrBandwidthSampler sampler(conn);
   EXPECT_FALSE(sampler.isAppLimited());
   sampler.onAppLimited();
   EXPECT_TRUE(sampler.isAppLimited());
   CongestionController::AckEvent ackEvent;
   ackEvent.largestAckedPacket = ++conn.lossState.largestSent;
-  auto packet =
+  auto packet = makeTestingWritePacket(
-      makeTestingWritePacket(*ackEvent.largestAckedPacket, 1000, 1000, false);
+      *ackEvent.largestAckedPacket, 1000, 1000, false);
   ackEvent.ackedPackets.push_back(std::move(packet));
   sampler.onPacketAcked(ackEvent, 0);
   EXPECT_FALSE(sampler.isAppLimited());
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 2);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, 0);
-  EXPECT_EQ(event->currentCwnd, 0);
-  EXPECT_EQ(event->congestionEvent, kCongestionAppLimited.str());
-
-  auto tmp2 = std::move(qLogger->logs[indices[1]]);
-  auto event2 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp2.get());
-  EXPECT_EQ(event2->bytesInFlight, 0);
-  EXPECT_EQ(event2->currentCwnd, 0);
-  EXPECT_EQ(event2->congestionEvent, kCongestionAppUnlimited.str());
 }
 
 TEST_F(BbrBandwidthSamplerTest, AppLimitedOutstandingPacket) {

quic/congestion_control/test/BbrTest.cpp

@@ -66,8 +66,6 @@ TEST_F(BbrTest, InitStates) {
 
 TEST_F(BbrTest, Recovery) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   conn.udpSendPacketLen = 1000;
   BbrCongestionController::BbrConfig config;
   conn.transportSettings.initCwndInMss = 500; // Make a really large initCwnd
@@ -93,22 +91,6 @@ TEST_F(BbrTest, Recovery) {
   EXPECT_TRUE(bbr.inRecovery());
   EXPECT_EQ(expectedRecoveryWindow, bbr.getCongestionWindow());
 
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, inflightBytes);
-  EXPECT_EQ(event->currentCwnd, 449900);
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketAck);
-  EXPECT_EQ(
-      event->state,
-      bbrStateToString(BbrCongestionController::BbrState::Startup));
-  EXPECT_EQ(
-      event->recoveryState,
-      bbrRecoveryStateToString(
-          BbrCongestionController::RecoveryState::CONSERVATIVE));
-
   // Sleep 1ms to make next now() a bit far from previous now().
   std::this_thread::sleep_for(1ms);
 
@@ -427,8 +409,6 @@ TEST_F(BbrTest, NoLargestAckedPacketNoCrash) {
 
 TEST_F(BbrTest, AckAggregation) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   conn.udpSendPacketLen = 1000;
   BbrCongestionController::BbrConfig config;
   BbrCongestionController bbr(conn, config);
@@ -466,23 +446,6 @@ TEST_F(BbrTest, AckAggregation) {
   };
 
   sendAckGrow(true);
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, 0);
-  EXPECT_EQ(event->currentCwnd, bbr.getCongestionWindow());
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketAck);
-  EXPECT_EQ(
-      event->state,
-      bbrStateToString(BbrCongestionController::BbrState::Startup));
-  EXPECT_EQ(
-      event->recoveryState,
-      bbrRecoveryStateToString(
-          BbrCongestionController::RecoveryState::NOT_RECOVERY));
-
   // kStartupSlowGrowRoundLimit consecutive slow growth to leave Startup
   for (int i = 0; i <= kStartupSlowGrowRoundLimit; i++) {
     sendAckGrow(false);
@@ -600,10 +563,6 @@ TEST_F(BbrTest, Pacing) {
   conn.udpSendPacketLen = 1000;
   conn.transportSettings.maxBurstPackets = std::numeric_limits<decltype(
       conn.transportSettings.maxBurstPackets)>::max();
-  conn.transportSettings.pacingEnabled = true;
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
-
   BbrCongestionController::BbrConfig config;
   BbrCongestionController bbr(conn, config);
   bbr.setMinimalPacingInterval(1ms);
@@ -661,22 +620,9 @@ TEST_F(BbrTest, Pacing) {
   };
 
   // Take it to ProbeBw first
-  std::vector<uint64_t> pacingRateVec;
+  for (size_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) {
-  for (uint32_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) {
     sendAckGrow(Clock::now());
-    pacingRateVec.push_back(bbr.getPacingRate(Clock::now()));
   }
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), kStartupSlowGrowRoundLimit + 2);
-  for (uint32_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) {
-    auto tmp = std::move(qLogger->logs[indices[i]]);
-    auto event = dynamic_cast<QLogPacingMetricUpdateEvent*>(tmp.get());
-    EXPECT_EQ(event->pacingBurstSize, pacingRateVec[i]);
-    EXPECT_EQ(event->pacingInterval, bbr.getPacingInterval());
-  }
-
   for (size_t i = 0; i < 5; i++) {
     sendFunc();
   }

quic/congestion_control/test/CopaTest.cpp

@@ -145,8 +145,6 @@ TEST_F(CopaTest, TestWritableBytes) {
 TEST_F(CopaTest, PersistentCongestion) {
   QuicServerConnectionState conn;
   Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   EXPECT_TRUE(copa.inSlowStart());
 
   conn.lossState.largestSent = 5;
@@ -154,16 +152,6 @@ TEST_F(CopaTest, PersistentCongestion) {
   uint32_t ackedSize = 10;
   auto pkt = createPacket(ackPacketNum, ackedSize, ackedSize);
   copa.onPacketSent(pkt);
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, 10);
-  EXPECT_EQ(event->currentCwnd, kDefaultCwnd);
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketSent.str());
-
   CongestionController::LossEvent loss;
   loss.persistentCongestion = true;
   loss.addLostPacket(pkt);
@@ -177,8 +165,6 @@ TEST_F(CopaTest, PersistentCongestion) {
 TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
   QuicServerConnectionState conn;
   Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   EXPECT_TRUE(copa.inSlowStart());
 
   auto originalWritableBytes = copa.getWritableBytes();
@@ -188,28 +174,11 @@ TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
   copa.onPacketSent(createPacket(ackPacketNum, ackedSize, ackedSize));
   copa.onRemoveBytesFromInflight(2);
   EXPECT_EQ(copa.getWritableBytes(), originalWritableBytes - ackedSize + 2);
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 2);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, ackedSize);
-  EXPECT_EQ(event->currentCwnd, kDefaultCwnd);
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketSent.str());
-
-  auto tmp2 = std::move(qLogger->logs[indices[1]]);
-  auto event2 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp2.get());
-  EXPECT_EQ(event2->bytesInFlight, ackedSize - 2);
-  EXPECT_EQ(event2->currentCwnd, kDefaultCwnd);
-  EXPECT_EQ(event2->congestionEvent, kRemoveInflight.str());
 }
 
 TEST_F(CopaTest, TestSlowStartAck) {
   QuicServerConnectionState conn;
   Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   EXPECT_TRUE(copa.inSlowStart());
   // initial cwnd = 10 packets
   EXPECT_EQ(
@@ -244,15 +213,6 @@ TEST_F(CopaTest, TestSlowStartAck) {
   numPacketsInFlight--;
   EXPECT_EQ(copa.getBytesInFlight(), numPacketsInFlight * packetSize);
 
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 11); // mostly congestionPacketSent logs
-  auto tmp = std::move(qLogger->logs[indices[10]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, copa.getBytesInFlight());
-  EXPECT_EQ(event->currentCwnd, kDefaultCwnd);
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketAck.str());
-
   now += 50ms;
   packetNumToAck++;
 
@@ -345,11 +305,6 @@ TEST_F(CopaTest, TestSteadyStateChanges) {
 TEST_F(CopaTest, TestVelocity) {
   QuicServerConnectionState conn;
   Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
-  conn.transportSettings.pacingEnabled = true;
-  copa.setMinimalPacingInterval(10ms);
-
   // lastCwnd = 9.8 packets
   auto now = Clock::now();
   auto lastCwnd = exitSlowStart(copa, conn, now);
@@ -364,23 +319,12 @@ TEST_F(CopaTest, TestVelocity) {
   now += 100ms;
   // velocity = 1, direction = 0
   copa.onPacketAckOrLoss(createAckEvent(30, packetSize, now), folly::none);
-  auto logNow = Clock::now();
-
   uint64_t cwndChange =
       cwndChangeSteadyState(lastCwnd, velocity, packetSize, 0.5, conn);
   // cwnd = 9.8 + 1 / (0.5 * 9.8) = 10 packets
   EXPECT_EQ(copa.getCongestionWindow(), lastCwnd + cwndChange);
   lastCwnd = copa.getCongestionWindow();
 
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 3);
-
-  auto tmp = std::move(qLogger->logs[indices[2]]);
-  auto event = dynamic_cast<QLogPacingMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->pacingBurstSize, copa.getPacingRate(logNow));
-  EXPECT_EQ(event->pacingInterval, copa.getPacingInterval());
-
   // another ack, velocity = 1, direction 0 -> 1
   now += 100ms;
   copa.onPacketAckOrLoss(createAckEvent(35, packetSize, now), folly::none);
@@ -449,21 +393,10 @@ TEST_F(CopaTest, TestVelocity) {
 TEST_F(CopaTest, NoLargestAckedPacketNoCrash) {
   QuicServerConnectionState conn;
   Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   CongestionController::LossEvent loss;
   loss.largestLostPacketNum = 0;
   CongestionController::AckEvent ack;
   copa.onPacketAckOrLoss(ack, loss);
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, copa.getBytesInFlight());
-  EXPECT_EQ(event->currentCwnd, kDefaultCwnd);
-  EXPECT_EQ(event->congestionEvent, kCongestionPacketLoss.str());
 }
 
 } // namespace test

quic/congestion_control/test/CubicStateTest.cpp

@@ -43,22 +43,12 @@ TEST_F(CubicStateTest, HystartAck) {
 
 TEST_F(CubicStateTest, HystartPace) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   conn.transportSettings.pacingEnabled = true;
   conn.lossState.srtt = 2000000us;
   TestingCubic cubic(conn);
   cubic.setMinimalPacingInterval(10ms);
   EXPECT_EQ(CubicStates::Hystart, cubic.state());
   EXPECT_TRUE(cubic.canBePaced());
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogPacingMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->pacingBurstSize, 1);
-  EXPECT_EQ(event->pacingInterval, 10ms);
 }
 
 // ======= Fast Recovery =======
@@ -144,24 +134,15 @@ TEST_F(CubicStateTest, SteadyLoss) {
 
 TEST_F(CubicStateTest, SteadyCanPace) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   conn.transportSettings.pacingEnabled = true;
   conn.lossState.srtt = 2000000us;
   TestingCubic cubic(conn);
   cubic.setStateForTest(CubicStates::Steady);
   EXPECT_FALSE(cubic.canBePaced());
-  cubic.setMinimalPacingInterval(15ms);
+  cubic.setMinimalPacingInterval(10ms);
   EXPECT_TRUE(cubic.canBePaced());
   conn.lossState.srtt = 1ms;
   EXPECT_FALSE(cubic.canBePaced());
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::PacingMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 1);
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogPacingMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->pacingBurstSize, 1);
-  EXPECT_EQ(event->pacingInterval, 15ms);
 }
 
 } // namespace test

quic/congestion_control/test/CubicTest.cpp

@@ -43,8 +43,6 @@ TEST_F(CubicTest, AckIncreaseWritable) {
 
 TEST_F(CubicTest, PersistentCongestion) {
   QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>();
-  conn.qLogger = qLogger;
   Cubic cubic(conn, std::numeric_limits<uint64_t>::max(), false);
   auto initCwnd = cubic.getWritableBytes();
   auto packet = makeTestingWritePacket(0, 1000, 1000);
@@ -76,83 +74,6 @@ TEST_F(CubicTest, PersistentCongestion) {
   cubic.onPacketSent(packet3);
   cubic.onPacketAckOrLoss(
       makeAck(2, 3000, Clock::now(), packet3.time), folly::none);
-
-  std::vector<int> indices =
-      getQLogEventIndices(QLogEventType::CongestionMetricUpdate, qLogger);
-  EXPECT_EQ(indices.size(), 9);
-
-  auto tmp = std::move(qLogger->logs[indices[0]]);
-  auto event = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp.get());
-  EXPECT_EQ(event->bytesInFlight, 0);
-  EXPECT_EQ(event->currentCwnd, initCwnd);
-  EXPECT_EQ(event->congestionEvent, kRemoveInflight.str());
-  EXPECT_EQ(event->state, cubicStateToString(CubicStates::Hystart));
-  EXPECT_EQ(event->recoveryState, "");
-
-  auto tmp2 = std::move(qLogger->logs[indices[1]]);
-  auto event2 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp2.get());
-  EXPECT_EQ(event2->bytesInFlight, 0);
-  EXPECT_EQ(event2->currentCwnd, 11088);
-  EXPECT_EQ(event2->congestionEvent, kCubicLoss.str());
-  EXPECT_EQ(event2->state, cubicStateToString(CubicStates::FastRecovery));
-  EXPECT_EQ(event2->recoveryState, "");
-
-  auto tmp3 = std::move(qLogger->logs[indices[2]]);
-  auto event3 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp3.get());
-  EXPECT_EQ(event3->bytesInFlight, 0);
-  EXPECT_EQ(event3->currentCwnd, 2464);
-  EXPECT_EQ(event3->congestionEvent, kPersistentCongestion.str());
-  EXPECT_EQ(event3->state, cubicStateToString(CubicStates::Hystart));
-  EXPECT_EQ(event3->recoveryState, "");
-
-  auto tmp4 = std::move(qLogger->logs[indices[3]]);
-  auto event4 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp4.get());
-  EXPECT_EQ(event4->bytesInFlight, 0);
-  EXPECT_EQ(event4->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event4->congestionEvent, kCongestionPacketAck.str());
-  EXPECT_EQ(event4->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event4->recoveryState, "");
-
-  auto tmp5 = std::move(qLogger->logs[indices[4]]);
-  auto event5 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp5.get());
-  EXPECT_EQ(event5->bytesInFlight, 0);
-  EXPECT_EQ(event5->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event5->congestionEvent, kResetTimeToOrigin.str());
-  EXPECT_EQ(event5->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event5->recoveryState, "");
-
-  auto tmp6 = std::move(qLogger->logs[indices[5]]);
-  auto event6 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp6.get());
-  EXPECT_EQ(event6->bytesInFlight, 0);
-  EXPECT_EQ(event6->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event6->congestionEvent, kResetLastReductionTime.str());
-  EXPECT_EQ(event6->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event6->recoveryState, "");
-
-  auto tmp7 = std::move(qLogger->logs[indices[6]]);
-  auto event7 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp7.get());
-  EXPECT_EQ(event7->bytesInFlight, 0);
-  EXPECT_EQ(event7->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event7->congestionEvent, kCubicSteadyCwnd.str());
-  EXPECT_EQ(event7->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event7->recoveryState, "");
-
-  auto tmp8 = std::move(qLogger->logs[indices[7]]);
-  auto event8 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp8.get());
-  EXPECT_EQ(event8->bytesInFlight, 0);
-  EXPECT_EQ(event8->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event8->congestionEvent, kCwndNoChange.str());
-  EXPECT_EQ(event8->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event8->recoveryState, "");
-
-  auto tmp9 = std::move(qLogger->logs[indices[8]]);
-  auto event9 = dynamic_cast<QLogCongestionMetricUpdateEvent*>(tmp9.get());
-  EXPECT_EQ(event9->bytesInFlight, 0);
-  EXPECT_EQ(event9->currentCwnd, cubic.getCongestionWindow());
-  EXPECT_EQ(event9->congestionEvent, kCongestionPacketAck.str());
-  EXPECT_EQ(event9->state, cubicStateToString(CubicStates::Steady));
-  EXPECT_EQ(event9->recoveryState, "");
-
   EXPECT_EQ(currentCwnd, cubic.getWritableBytes());
 }
 

quic/logging/FileQLogger.cpp

@@ -94,16 +94,6 @@ void FileQLogger::addCongestionMetricUpdate(
       refTime));
 }
 
-void FileQLogger::addPacingMetricUpdate(
-    uint64_t pacingBurstSizeIn,
-    std::chrono::microseconds pacingIntervalIn) {
-  auto refTime = std::chrono::duration_cast<std::chrono::microseconds>(
-      std::chrono::steady_clock::now() - refTimePoint);
-
-  logs.push_back(std::make_unique<quic::QLogPacingMetricUpdateEvent>(
-      pacingBurstSizeIn, pacingIntervalIn, refTime));
-}
-
 folly::dynamic FileQLogger::toDynamic() const {
   folly::dynamic d = folly::dynamic::object;
   d["traces"] = folly::dynamic::array();

quic/logging/FileQLogger.h

@@ -51,11 +51,8 @@ class FileQLogger : public QLogger {
       uint64_t bytesInFlight,
       uint64_t currentCwnd,
       std::string congestionEvent,
-      std::string state = "",
+      std::string state,
       std::string recoveryState = "") override;
-  void addPacingMetricUpdate(
-      uint64_t pacingBurstSizeIn,
-      std::chrono::microseconds pacingIntervalIn) override;
   void outputLogsToFile(const std::string& path, bool prettyJson);
   folly::dynamic toDynamic() const;
 };

quic/logging/test/QLoggerTest.cpp

@@ -117,7 +117,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
   q.addCongestionMetricUpdate(
       20,
       30,
-      kPersistentCongestion.str(),
+      cubicPersistentCongestion.str(),
       cubicStateToString(CubicStates::Steady).str(),
       bbrRecoveryStateToString(
           BbrCongestionController::RecoveryState::NOT_RECOVERY));
@@ -127,7 +127,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
 
   EXPECT_EQ(gotEvent->bytesInFlight, 20);
   EXPECT_EQ(gotEvent->currentCwnd, 30);
-  EXPECT_EQ(gotEvent->congestionEvent, kPersistentCongestion.str());
+  EXPECT_EQ(gotEvent->congestionEvent, cubicPersistentCongestion.str());
   EXPECT_EQ(gotEvent->state, cubicStateToString(CubicStates::Steady).str());
   EXPECT_EQ(
       gotEvent->recoveryState,
@@ -135,17 +135,6 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
           BbrCongestionController::RecoveryState::NOT_RECOVERY));
 }
 
-TEST_F(QLoggerTest, PacingMetricUpdateEvent) {
-  FileQLogger q;
-  q.addPacingMetricUpdate(10, 30us);
-
-  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
-  auto gotEvent = dynamic_cast<QLogPacingMetricUpdateEvent*>(p.get());
-
-  EXPECT_EQ(gotEvent->pacingBurstSize, 10);
-  EXPECT_EQ(gotEvent->pacingInterval, 30us);
-}
-
 TEST_F(QLoggerTest, RegularPacketFollyDynamic) {
   folly::dynamic expected = folly::parseJson(
       R"({
@@ -675,7 +664,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) {
         "DEFAULT",
         {
           "bytes_in_flight": 20,
-          "congestion_event": "persistent congestion",
+          "congestion_event": "cubic persistent congestion",
           "current_cwnd": 30,
           "recovery_state": "",
           "state": "Steady"
@@ -687,7 +676,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) {
   q.addCongestionMetricUpdate(
       20,
       30,
-      kPersistentCongestion.str(),
+      cubicPersistentCongestion.str(),
       cubicStateToString(CubicStates::Steady).str());
   folly::dynamic gotDynamic = q.toDynamic();
   gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -695,27 +684,4 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) {
   EXPECT_EQ(expected, gotEvents);
 }
 
-TEST_F(QLoggerTest, PacingMetricUpdateFollyDynamic) {
-  folly::dynamic expected = folly::parseJson(
-      R"([
-      [
-        "0",
-        "METRIC_UPDATE",
-        "PACING_METRIC_UPDATE",
-        "DEFAULT",
-        {
-         "pacing_burst_size": 20,
-         "pacing_interval": 30
-        }
-      ]
- ])");
-
-  FileQLogger q;
-  q.addPacingMetricUpdate(20, 30us);
-  folly::dynamic gotDynamic = q.toDynamic();
-  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
-  folly::dynamic gotEvents = gotDynamic["traces"][0]["events"];
-  EXPECT_EQ(expected, gotEvents);
-}
-
 } // namespace quic::test