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
2025-11-09 10:00:57 +03:00 · 2019-07-16 00:22:26 -07:00
parent e2977456f7
commit b4baf99a14
8 changed files with 9 additions and 293 deletions
--- a/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp
+++ b/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 =
-      makeTestingWritePacket(*ackEvent.largestAckedPacket, 1000, 1000, false);
+  auto packet = makeTestingWritePacket(
+      *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) {
--- a/quic/congestion_control/test/BbrTest.cpp
+++ b/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 (uint32_t i = 0; i < kStartupSlowGrowRoundLimit + 2; i++) {
+  for (size_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();
  }
--- a/quic/congestion_control/test/CopaTest.cpp
+++ b/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
--- a/quic/congestion_control/test/CubicStateTest.cpp
+++ b/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
--- a/quic/congestion_control/test/CubicTest.cpp
+++ b/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());
 }

--- a/quic/logging/FileQLogger.cpp
+++ b/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();
--- a/quic/logging/FileQLogger.h
+++ b/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;
 };
--- a/quic/logging/test/QLoggerTest.cpp
+++ b/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