Add vantage point to qlog.

Summary: Landing an outstanding diff Reviewed By: yangchi Differential Revision: D19261395 fbshipit-source-id: 437461222ff04f5c3271567d3bb064bceaf80029
2025-08-05 11:21:09 +03:00 · 2020-01-07 11:17:41 -08:00
parent c610a8c512
commit 3f419b2eb2
24 changed files with 141 additions and 138 deletions
--- a/quic/QuicConstants.cpp
+++ b/quic/QuicConstants.cpp
@@ -116,4 +116,5 @@ folly::StringPiece writeNoWriteReasonString(NoWriteReason reason) {
  }
  folly::assume_unreachable();
 }
+
 } // namespace quic
--- a/quic/api/QuicTransportBase.h
+++ b/quic/api/QuicTransportBase.h
@@ -11,6 +11,7 @@
 #include <folly/ExceptionWrapper.h>
 #include <folly/io/async/AsyncUDPSocket.h>
 #include <folly/io/async/HHWheelTimer.h>
+#include <quic/QuicConstants.h>
 #include <quic/QuicException.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/common/FunctionLooper.h>
--- a/quic/api/test/QuicTransportBaseTest.cpp
+++ b/quic/api/test/QuicTransportBaseTest.cpp
@@ -1039,7 +1039,7 @@ TEST_F(QuicTransportImplTest, LossTimeoutNoLessThanTickInterval) {
 }

 TEST_F(QuicTransportImplTest, CloseStreamAfterReadError) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  transport->transportConn->qLogger = qLogger;
  auto stream1 = transport->createBidirectionalStream().value();

--- a/quic/api/test/QuicTransportFunctionsTest.cpp
+++ b/quic/api/test/QuicTransportFunctionsTest.cpp
@@ -182,7 +182,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {
  auto mockCongestionController = std::make_unique<MockCongestionController>();
  auto rawCongestionController = mockCongestionController.get();
  conn->congestionController = std::move(mockCongestionController);
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  // Builds a fake packet to test with.
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);

@@ -343,7 +343,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnection) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  conn->ackStates.initialAckState.nextPacketNum = 0;
  conn->ackStates.handshakeAckState.nextPacketNum = 1;
  conn->ackStates.appDataAckState.nextPacketNum = 2;
@@ -417,7 +417,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPacketSorting) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionFinOnly) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  auto stream1 = conn->streamManager->createNextBidirectionalStream().value();

@@ -458,7 +458,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionFinOnly) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionAllBytesExceptFin) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);

  auto stream1 = conn->streamManager->createNextUnidirectionalStream().value();
@@ -505,7 +505,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionAllBytesExceptFin) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionEmptyAckWriteResult) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  // None of the largestAckScheduled should be changed. But since
  // buildEmptyPacket() builds a Handshake packet, we use handshakeAckState to
@@ -534,7 +534,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionEmptyAckWriteResult) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto stream = conn->streamManager->createNextBidirectionalStream().value();
  writeDataToQuicStream(*stream, nullptr, true);
  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -584,7 +584,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionPureAckCounter) {

 TEST_F(QuicTransportFunctionsTest, TestPaddingPureAckPacketIsStillPureAck) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  auto packetEncodedSize =
      packet.header ? packet.header->computeChainDataLength() : 0;
@@ -614,7 +614,7 @@ TEST_F(QuicTransportFunctionsTest, TestPaddingPureAckPacketIsStillPureAck) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto stream = conn->streamManager->createNextBidirectionalStream().value();
  writeDataToQuicStream(*stream, nullptr, true);
  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -681,7 +681,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionHandshakeCounter) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto stream = conn->streamManager->createNextBidirectionalStream().value();
  writeDataToQuicStream(*stream, nullptr, true);
  EXPECT_EQ(0, conn->outstandingHandshakePacketsCount);
@@ -752,7 +752,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionForOneRttCryptoData) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  auto mockPacer = std::make_unique<MockPacer>();
  auto rawPacer = mockPacer.get();
@@ -789,7 +789,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithPureAck) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto stream = conn->streamManager->createNextBidirectionalStream().value();
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  // This is clearly not 555 bytes. I just need some data inside the packet.
@@ -845,7 +845,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithBytesStats) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto mockCongestionController = std::make_unique<MockCongestionController>();
  auto rawCongestionController = mockCongestionController.get();
  conn->congestionController = std::move(mockCongestionController);
@@ -900,7 +900,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionWithCloneResult) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  auto packetNum = packet.packet.header.getPacketSequenceNum();
  auto stream = conn->streamManager->createNextBidirectionalStream().value();
@@ -935,7 +935,7 @@ TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionStreamWindowUpdate) {

 TEST_F(QuicTransportFunctionsTest, TestUpdateConnectionConnWindowUpdate) {
  auto conn = createConn();
-  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::CLIENT);
+  conn->qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Client);
  auto packet = buildEmptyPacket(*conn, PacketNumberSpace::Handshake);
  auto packetNum = packet.packet.header.getPacketSequenceNum();
  conn->pendingEvents.connWindowUpdate = true;
--- a/quic/api/test/QuicTransportTest.cpp
+++ b/quic/api/test/QuicTransportTest.cpp
@@ -575,7 +575,7 @@ TEST_F(QuicTransportTest, WriteMultipleStreams) {

 TEST_F(QuicTransportTest, WriteFlowControl) {
  auto& conn = transport_->getConnectionState();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn.qLogger = qLogger;

  auto streamId = transport_->createBidirectionalStream().value();
--- a/quic/client/test/QuicClientTransportTest.cpp
+++ b/quic/client/test/QuicClientTransportTest.cpp
@@ -465,7 +465,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
  verifier = nullptr;
  client = createClient();

-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  EXPECT_CALL(clientConnCallback, onConnectionError(_))
      .WillOnce(Invoke([&](const auto& errorCode) {
@@ -486,7 +486,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
 }

 TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  // Point the client to a bad server.
  client->addNewPeerAddress(SocketAddress("127.0.0.1", 14114));
@@ -503,7 +503,7 @@ TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {

 TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) {
  expectTransportCallbacks();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  TransportSettings settings;
  settings.connectUDP = true;
@@ -525,7 +525,7 @@ TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) {

 TEST_P(QuicClientTransportIntegrationTest, SetTransportSettingsAfterStart) {
  expectTransportCallbacks();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  TransportSettings settings;
  settings.connectUDP = true;
@@ -600,7 +600,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttSuccess) {

 TEST_P(QuicClientTransportIntegrationTest, TestZeroRttRejection) {
  expectTransportCallbacks();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  auto cachedPsk = setupZeroRttOnClientCtx(*clientCtx, hostname, getVersion());
  pskCache_->putPsk(hostname, cachedPsk);
@@ -1739,7 +1739,7 @@ TEST_F(QuicClientTransportTest, AddNewPeerAddressSetsPacketSize) {

 TEST_F(QuicClientTransportTest, onNetworkSwitchNoReplace) {
  client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead();
-  auto mockQLogger = std::make_shared<MockQLogger>();
+  auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
  client->setQLogger(mockQLogger);

  EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0);
@@ -1749,7 +1749,7 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchNoReplace) {

 TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceAfterHandshake) {
  client->getNonConstConn().oneRttWriteCipher = test::createNoOpAead();
-  auto mockQLogger = std::make_shared<MockQLogger>();
+  auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
  client->setQLogger(mockQLogger);

  auto newSocket =
@@ -1771,7 +1771,7 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
  auto newSocket =
      std::make_unique<folly::test::MockAsyncUDPSocket>(eventbase_.get());
  auto newSocketPtr = newSocket.get();
-  auto mockQLogger = std::make_shared<MockQLogger>();
+  auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
  EXPECT_CALL(*mockQLogger, addConnectionMigrationUpdate(true)).Times(0);
  EXPECT_CALL(*newSocketPtr, bind(_)).Times(0);
  client->onNetworkSwitch(std::move(newSocket));
@@ -1862,7 +1862,7 @@ TEST_F(
    NetworkUnreachableIsFatalIfContinueAfterDeadline) {
  TransportSettings settings;
  settings.continueOnNetworkUnreachable = true;
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;

  client->setTransportSettings(settings);
@@ -1963,7 +1963,7 @@ TEST_F(QuicClientTransportTest, IdleTimerResetOnWritingFirstData) {

 TEST_F(QuicClientTransportTest, SetQLoggerDcid) {
  client->setQLogger(nullptr);
-  auto mockQLogger = std::make_shared<MockQLogger>();
+  auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Client);
  client->setQLogger(mockQLogger);
  EXPECT_EQ(client->getConn().clientConnectionId, mockQLogger->dcid);
  client->closeNow(folly::none);
@@ -2941,7 +2941,7 @@ TEST_P(QuicClientTransportAfterStartTest, ReadStreamCoalesced) {
  setConnectionIds();

  StreamId streamId = client->createBidirectionalStream().value();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;

  client->setReadCallback(streamId, &readCb);
@@ -3120,7 +3120,7 @@ bool verifyFramePresent(

 TEST_F(QuicClientTransportAfterStartTest, CloseConnectionWithStreamPending) {
  StreamId streamId = client->createBidirectionalStream().value();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  auto expected = IOBuf::copyBuffer("hello");
  client->setReadCallback(streamId, &readCb);
@@ -3255,7 +3255,7 @@ TEST_P(
    QuicClientTransportAfterStartTestClose,
    CloseConnectionWithErrorCleartext) {
  StreamId streamId = client->createBidirectionalStream().value();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  auto expected = IOBuf::copyBuffer("hello");
  client->setReadCallback(streamId, &readCb);
@@ -3540,7 +3540,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimerNotResetOnDuplicatePacket) {
 }

 TEST_P(QuicClientTransportAfterStartTestClose, TimeoutsNotSetAfterClose) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  StreamId streamId = client->createBidirectionalStream().value();

@@ -3640,7 +3640,7 @@ TEST_F(QuicClientTransportAfterStartTest, IdleTimeoutExpired) {
 }

 TEST_F(QuicClientTransportAfterStartTest, RecvDataAfterIdleTimeout) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  EXPECT_CALL(*sock, close());
  client->idleTimeout().timeoutExpired();
@@ -4070,7 +4070,7 @@ TEST_F(QuicClientTransportAfterStartTest, BadStatelessResetWontCloseTransport) {

 TEST_F(QuicClientTransportVersionAndRetryTest, RetryPacket) {
  // Create a stream and attempt to send some data to the server
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;

  StreamId streamId = *client->createBidirectionalStream();
@@ -4582,7 +4582,7 @@ TEST_F(QuicClientTransportAfterStartTest, ReceiveConnectionClose) {
 }

 TEST_F(QuicClientTransportAfterStartTest, ReceiveApplicationClose) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;

  ShortHeader header(
@@ -5279,7 +5279,7 @@ INSTANTIATE_TEST_CASE_P(
    ::Values(0, 8));

 TEST_F(QuicProcessDataTest, ProcessDataWithGarbageAtEnd) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  auto serverHello = IOBuf::copyBuffer("Fake SHLO");
  PacketNum nextPacketNum = initialPacketNum++;
@@ -5318,7 +5318,7 @@ TEST_P(QuicProcessDataTest, ProcessDataHeaderOnly) {
      ConnectionId(std::vector<uint8_t>(connIdSize, 1));
  setConnectionIds();

-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  client->getNonConstConn().qLogger = qLogger;
  auto serverHello = IOBuf::copyBuffer("Fake SHLO");
  PacketNum nextPacketNum = initialPacketNum++;
--- a/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp
+++ b/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp
@@ -136,7 +136,7 @@ TEST_F(BbrBandwidthSamplerTest, SampleExpiration) {

 TEST_F(BbrBandwidthSamplerTest, AppLimited) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;

  BbrBandwidthSampler sampler(conn);
--- a/quic/congestion_control/test/BbrTest.cpp
+++ b/quic/congestion_control/test/BbrTest.cpp
@@ -37,7 +37,7 @@ TEST_F(BbrTest, InitStates) {

 TEST_F(BbrTest, Recovery) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.udpSendPacketLen = 1000;
  conn.transportSettings.initCwndInMss = 500; // Make a really large initCwnd
@@ -374,7 +374,7 @@ TEST_F(BbrTest, NoLargestAckedPacketNoCrash) {

 TEST_F(BbrTest, AckAggregation) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.udpSendPacketLen = 1000;
  BbrCongestionController bbr(conn);
@@ -559,7 +559,7 @@ TEST_F(BbrTest, BytesCounting) {

 TEST_F(BbrTest, AppIdle) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  BbrCongestionController bbr(conn);

--- a/quic/congestion_control/test/CopaTest.cpp
+++ b/quic/congestion_control/test/CopaTest.cpp
@@ -145,7 +145,7 @@ TEST_F(CopaTest, TestWritableBytes) {
 TEST_F(CopaTest, PersistentCongestion) {
  QuicServerConnectionState conn;
  Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  EXPECT_TRUE(copa.inSlowStart());

@@ -177,7 +177,7 @@ TEST_F(CopaTest, PersistentCongestion) {
 TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
  QuicServerConnectionState conn;
  Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  EXPECT_TRUE(copa.inSlowStart());

@@ -208,7 +208,7 @@ TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
 TEST_F(CopaTest, TestSlowStartAck) {
  QuicServerConnectionState conn;
  Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  EXPECT_TRUE(copa.inSlowStart());
  // initial cwnd = 10 packets
@@ -346,7 +346,7 @@ TEST_F(CopaTest, TestVelocity) {
  QuicServerConnectionState conn;
  conn.transportSettings.pacingTimerTickInterval = 10ms;
  Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.transportSettings.pacingEnabled = true;

@@ -439,7 +439,7 @@ TEST_F(CopaTest, TestVelocity) {
 TEST_F(CopaTest, NoLargestAckedPacketNoCrash) {
  QuicServerConnectionState conn;
  Copa copa(conn);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  CongestionController::LossEvent loss;
  loss.largestLostPacketNum = 0;
--- a/quic/congestion_control/test/CubicTest.cpp
+++ b/quic/congestion_control/test/CubicTest.cpp
@@ -42,7 +42,7 @@ TEST_F(CubicTest, AckIncreaseWritable) {

 TEST_F(CubicTest, PersistentCongestion) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  Cubic cubic(conn, std::numeric_limits<uint64_t>::max(), false);
  auto initCwnd = cubic.getWritableBytes();
@@ -113,7 +113,7 @@ TEST_F(CubicTest, PersistentCongestion) {

 TEST_F(CubicTest, CwndIncreaseAfterReduction) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.udpSendPacketLen = 200;
  // initCwnd > initSsthresh: an ack will immediately make the state machine
@@ -176,7 +176,7 @@ TEST_F(CubicTest, CwndIncreaseAfterReduction) {

 TEST_F(CubicTest, AppIdle) {
  QuicConnectionStateBase conn(QuicNodeType::Client);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.udpSendPacketLen = 1500;
  TestingCubic cubic(conn);
@@ -242,7 +242,7 @@ TEST_F(CubicTest, PacingGain) {
  auto mockPacer = std::make_unique<MockPacer>();
  auto rawPacer = mockPacer.get();
  conn.pacer = std::move(mockPacer);
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;
  conn.udpSendPacketLen = 1500;
  Cubic cubic(conn);
--- a/quic/flowcontrol/test/QuicFlowControlTest.cpp
+++ b/quic/flowcontrol/test/QuicFlowControlTest.cpp
@@ -592,7 +592,7 @@ TEST_F(QuicFlowControlTest, UpdateBadFlowControlOnStreamData) {
 }

 TEST_F(QuicFlowControlTest, UpdateFlowControlOnRead) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn_.qLogger = qLogger;

  StreamId id = 3;
@@ -677,7 +677,7 @@ TEST_F(QuicFlowControlTest, HandleStreamWindowUpdate) {
  StreamId id = 3;
  QuicStreamState stream(id, conn_);
  stream.flowControlState.peerAdvertisedMaxOffset = 200;
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn_.qLogger = qLogger;

  handleStreamWindowUpdate(stream, 300, 2);
--- a/quic/logging/QLogger.h
+++ b/quic/logging/QLogger.h
@@ -34,7 +34,7 @@ class QLogger {
      std::chrono::steady_clock::now()};
  VantagePoint vantagePoint;
  std::string protocolType;
-  QLogger() = default;
+  QLogger() = delete;
  virtual ~QLogger() = default;
  virtual void addPacket(
      const RegularQuicPacket& regularPacket,
--- a/quic/logging/QLoggerConstants.cpp
+++ b/quic/logging/QLoggerConstants.cpp
@@ -11,9 +11,9 @@
 namespace quic {
 folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept {
  switch (vantagePoint) {
-    case VantagePoint::CLIENT:
+    case VantagePoint::Client:
      return kQLogClientVantagePoint;
-    case VantagePoint::SERVER:
+    case VantagePoint::Server:
      return kQLogServerVantagePoint;
  }
  folly::assume_unreachable();
--- a/quic/logging/QLoggerConstants.h
+++ b/quic/logging/QLoggerConstants.h
@@ -9,6 +9,7 @@
 #pragma once

 #include <folly/String.h>
+#include "quic/QuicConstants.h"

 namespace quic {
 constexpr folly::StringPiece kShortHeaderPacketType = "1RTT";
@@ -79,12 +80,10 @@ constexpr auto kOnHeaders = "on headers";
 constexpr auto kOnError = "on error";
 constexpr auto kPushPromise = "push promise";

-enum class VantagePoint : uint8_t {
-  CLIENT,
-  SERVER,
-};
-constexpr folly::StringPiece kQLogServerVantagePoint = "SERVER";
-constexpr folly::StringPiece kQLogClientVantagePoint = "CLIENT";
+constexpr folly::StringPiece kQLogServerVantagePoint = "Server";
+constexpr folly::StringPiece kQLogClientVantagePoint = "Client";
+
+using VantagePoint = QuicNodeType;

 folly::StringPiece vantagePointString(VantagePoint vantagePoint) noexcept;

--- a/quic/logging/QLoggerTypes.cpp
+++ b/quic/logging/QLoggerTypes.cpp
@@ -769,9 +769,9 @@ folly::dynamic QLogStreamStateUpdateEvent::toDynamic() const {
  data["id"] = id;
  data["update"] = update;
  if (timeSinceStreamCreation) {
-    if (update == kOnEOM && vantagePoint_ == VantagePoint::CLIENT) {
+    if (update == kOnEOM && vantagePoint_ == VantagePoint::Client) {
      data["ttlb"] = timeSinceStreamCreation->count();
-    } else if (update == kOnHeaders && vantagePoint_ == VantagePoint::CLIENT) {
+    } else if (update == kOnHeaders && vantagePoint_ == VantagePoint::Client) {
      data["ttfb"] = timeSinceStreamCreation->count();
    } else {
      data["ms_since_creation"] = timeSinceStreamCreation->count();
@@ -802,7 +802,7 @@ folly::dynamic QLogConnectionMigrationEvent::toDynamic() const {
  folly::dynamic data = folly::dynamic::object();

  data["intentional"] = intentionalMigration_;
-  if (vantagePoint_ == VantagePoint::CLIENT) {
+  if (vantagePoint_ == VantagePoint::Client) {
    data["type"] = "initiating";
  } else {
    data["type"] = "accepting";
@@ -831,7 +831,7 @@ folly::dynamic QLogPathValidationEvent::toDynamic() const {
  folly::dynamic data = folly::dynamic::object();

  data["success"] = success_;
-  if (vantagePoint_ == VantagePoint::CLIENT) {
+  if (vantagePoint_ == VantagePoint::Client) {
    data["vantagePoint"] = "client";
  } else {
    data["vantagePoint"] = "server";
--- a/quic/logging/test/Mocks.h
+++ b/quic/logging/test/Mocks.h
@@ -14,6 +14,8 @@
 namespace quic::test {
 class MockQLogger : public QLogger {
 public:
+  MockQLogger() = delete;
+  MockQLogger(VantagePoint vp) : QLogger(vp, kHTTP3ProtocolType){};
  ~MockQLogger() override = default;
  MOCK_METHOD2(addPacket, void(const RegularQuicPacket&, uint64_t));
  MOCK_METHOD3(
--- a/quic/logging/test/QLoggerTest.cpp
+++ b/quic/logging/test/QLoggerTest.cpp
@@ -32,8 +32,8 @@ TEST_F(QLoggerTest, TestRegularWritePacket) {
  RegularQuicWritePacket regularWritePacket =
      createRegularQuicWritePacket(streamId, offset, len, fin);

-  FileQLogger q(VantagePoint::CLIENT, fakeProtocolType);
-  EXPECT_EQ(q.vantagePoint, VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client, fakeProtocolType);
+  EXPECT_EQ(q.vantagePoint, VantagePoint::Client);
  EXPECT_EQ(q.protocolType, fakeProtocolType);
  q.addPacket(regularWritePacket, 10);

@@ -55,7 +55,7 @@ TEST_F(QLoggerTest, TestRegularPacket) {

  regularQuicPacket.frames.emplace_back(std::move(frame));

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacket(regularQuicPacket, 10);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -70,7 +70,7 @@ TEST_F(QLoggerTest, TestRegularPacket) {

 TEST_F(QLoggerTest, TestVersionNegotiationPacket) {
  bool isPacketRecvd = false;
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  auto packet = createVersionNegotiationPacket();
  q.addPacket(packet, 10, isPacketRecvd);

@@ -82,7 +82,7 @@ TEST_F(QLoggerTest, TestVersionNegotiationPacket) {
 }

 TEST_F(QLoggerTest, ConnectionCloseEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  auto error = toString(LocalErrorCode::CONNECTION_RESET);
  q.addConnectionClose(error.str(), "Connection close", true, false);

@@ -94,7 +94,7 @@ TEST_F(QLoggerTest, ConnectionCloseEvent) {
 }

 TEST_F(QLoggerTest, TransportSummaryEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addTransportSummary(8, 9, 5, 3, 2, 554, 100, 32, 134, 238);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -113,7 +113,7 @@ TEST_F(QLoggerTest, TransportSummaryEvent) {
 }

 TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addCongestionMetricUpdate(
      20,
      30,
@@ -136,7 +136,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateEvent) {
 }

 TEST_F(QLoggerTest, PacingMetricUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacingMetricUpdate(10, 30us);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -147,7 +147,7 @@ TEST_F(QLoggerTest, PacingMetricUpdateEvent) {
 }

 TEST_F(QLoggerTest, AppIdleUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addAppIdleUpdate(kAppIdle, false);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -158,7 +158,7 @@ TEST_F(QLoggerTest, AppIdleUpdateEvent) {
 }

 TEST_F(QLoggerTest, PacketDropEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketDrop(5, kCipherUnavailable);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -169,7 +169,7 @@ TEST_F(QLoggerTest, PacketDropEvent) {
 }

 TEST_F(QLoggerTest, DatagramReceivedEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addDatagramReceived(100);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -179,7 +179,7 @@ TEST_F(QLoggerTest, DatagramReceivedEvent) {
 }

 TEST_F(QLoggerTest, LossAlarmEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addLossAlarm(PacketNum{1}, 3983, 893, kPtoAlarm);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -192,7 +192,7 @@ TEST_F(QLoggerTest, LossAlarmEvent) {
 }

 TEST_F(QLoggerTest, PacketsLostEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketsLost(PacketNum{42}, 332, 89);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -204,7 +204,7 @@ TEST_F(QLoggerTest, PacketsLostEvent) {
 }

 TEST_F(QLoggerTest, TransportStateUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  std::string update = "start";
  q.addTransportStateUpdate(update);

@@ -215,7 +215,7 @@ TEST_F(QLoggerTest, TransportStateUpdateEvent) {
 }

 TEST_F(QLoggerTest, PacketBufferedEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -227,7 +227,7 @@ TEST_F(QLoggerTest, PacketBufferedEvent) {
 }

 TEST_F(QLoggerTest, MetricUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addMetricUpdate(10us, 11us, 12us, 13us);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -240,7 +240,7 @@ TEST_F(QLoggerTest, MetricUpdateEvent) {
 }

 TEST_F(QLoggerTest, StreamStateUpdateEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addStreamStateUpdate(streamId, kAbort, 20ms);

  std::unique_ptr<QLogEvent> p = std::move(q.logs[0]);
@@ -252,7 +252,7 @@ TEST_F(QLoggerTest, StreamStateUpdateEvent) {
 }

 TEST_F(QLoggerTest, PacketPaddingFrameEvent) {
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  auto packet = createPacketWithPaddingFrames();
  q.addPacket(packet, 100);

@@ -322,8 +322,8 @@ TEST_F(QLoggerTest, QLoggerFollyDynamic) {
       ],
       "title": "mvfst qlog from single connection",
       "vantage_point": {
-         "name": "SERVER",
-         "type": "SERVER"
+         "name": "Server",
+         "type": "Server"
       }
     }
   ]
@@ -336,7 +336,7 @@ TEST_F(QLoggerTest, QLoggerFollyDynamic) {

  regularQuicPacket.frames.emplace_back(std::move(frame));

-  FileQLogger q(VantagePoint::SERVER);
+  FileQLogger q(VantagePoint::Server);
  q.addPacket(regularQuicPacket, 10);

  q.logs[0]->refTime = 31us;
@@ -379,7 +379,7 @@ TEST_F(QLoggerTest, RegularPacketFollyDynamic) {

  regularQuicPacket.frames.emplace_back(std::move(frame));

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacket(regularQuicPacket, 10);

  folly::dynamic gotDynamic = q.toDynamic();
@@ -418,7 +418,7 @@ TEST_F(QLoggerTest, RegularWritePacketFollyDynamic) {
  RegularQuicWritePacket packet =
      createRegularQuicWritePacket(streamId, offset, len, fin);

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.dcid = getTestConnectionId(0);
  q.scid = getTestConnectionId(1);
  q.addPacket(packet, 10);
@@ -463,7 +463,7 @@ TEST_F(QLoggerTest, RegularPacketAckFrameFollyDynamic) {
       ])");

  RegularQuicWritePacket packet = createPacketWithAckFrames();
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacket(packet, 1001);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -493,7 +493,7 @@ TEST_F(QLoggerTest, VersionPacketFollyDynamic) {
   ])");

  auto packet = createVersionNegotiationPacket();
-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.dcid = getTestConnectionId(0);
  q.scid = getTestConnectionId(1);
  q.addPacket(packet, 10, isPacketRecvd);
@@ -607,14 +607,14 @@ TEST_F(QLoggerTest, AddingMultiplePacketEvents) {
       ],
       "title": "mvfst qlog from single connection",
       "vantage_point": {
-         "name": "SERVER",
-         "type": "SERVER"
+         "name": "Server",
+         "type": "Server"
       }
     }
   ]
 })");

-  FileQLogger q(VantagePoint::SERVER);
+  FileQLogger q(VantagePoint::Server);
  auto versionPacket = createVersionNegotiationPacket();
  RegularQuicWritePacket regPacket = createPacketWithAckFrames();
  auto packet = createStreamPacket(
@@ -687,7 +687,7 @@ TEST_F(QLoggerTest, AddingMultipleFrames) {
           ]
  ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  RegularQuicWritePacket packet =
      createNewPacket(100, PacketNumberSpace::Initial);

@@ -722,7 +722,7 @@ TEST_F(QLoggerTest, ConnectionCloseFollyDynamic) {
           }
         ]])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  auto error = toString(LocalErrorCode::CONNECTION_RESET);
  q.addConnectionClose(error.str(), "Connection changed", true, false);
  folly::dynamic gotDynamic = q.toDynamic();
@@ -754,7 +754,7 @@ TEST_F(QLoggerTest, TransportSummaryFollyDynamic) {
   ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addTransportSummary(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -780,7 +780,7 @@ TEST_F(QLoggerTest, CongestionMetricUpdateFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addCongestionMetricUpdate(
      20,
      30,
@@ -807,7 +807,7 @@ TEST_F(QLoggerTest, PacingMetricUpdateFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacingMetricUpdate(20, 30us);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -830,7 +830,7 @@ TEST_F(QLoggerTest, AppIdleFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addAppIdleUpdate(kAppIdle, true);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -853,7 +853,7 @@ TEST_F(QLoggerTest, PacketDropFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketDrop(100, kMaxBuffered);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -875,7 +875,7 @@ TEST_F(QLoggerTest, DatagramReceivedFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addDatagramReceived(8);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -900,7 +900,7 @@ TEST_F(QLoggerTest, LossAlarmFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addLossAlarm(PacketNum{100}, 14, 38, kHandshakeAlarm);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -924,7 +924,7 @@ TEST_F(QLoggerTest, PacketsLostFollyDynamic) {
      ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketsLost(PacketNum{10}, 9, 8);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -946,7 +946,7 @@ TEST_F(QLoggerTest, TransportStateUpdateFollyDynamic) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addTransportStateUpdate("transport ready");
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -970,7 +970,7 @@ TEST_F(QLoggerTest, PacketBufferedFollyDynamic) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addPacketBuffered(PacketNum{10}, ProtectionType::Handshake, 100);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -995,7 +995,7 @@ TEST_F(QLoggerTest, MetricUpdateFollyDynamic) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addMetricUpdate(10us, 11us, 12us, 13us);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1019,7 +1019,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamicTTFB) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addStreamStateUpdate(streamId, kOnHeaders, 20ms);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1043,7 +1043,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamicTTLB) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addStreamStateUpdate(streamId, kOnEOM, 20ms);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1068,7 +1068,7 @@ TEST_F(
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addStreamStateUpdate(streamId, kOnEOM, folly::none);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1092,7 +1092,7 @@ TEST_F(QLoggerTest, StreamStateUpdateFollyDynamic) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addStreamStateUpdate(streamId, kAbort, 20ms);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1124,7 +1124,7 @@ TEST_F(QLoggerTest, PaddingFramesFollyDynamic) {
   ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  auto packet = createPacketWithPaddingFrames();
  q.addPacket(packet, 100);
  folly::dynamic gotDynamic = q.toDynamic();
@@ -1148,7 +1148,7 @@ TEST_F(QLoggerTest, ConnectionMigration) {
    ]
 ])");

-  FileQLogger q(VantagePoint::CLIENT);
+  FileQLogger q(VantagePoint::Client);
  q.addConnectionMigrationUpdate(true);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
@@ -1171,7 +1171,7 @@ TEST_F(QLoggerTest, PathValidation) {
    ]
 ])");

-  FileQLogger q(VantagePoint::SERVER);
+  FileQLogger q(VantagePoint::Server);
  q.addPathValidationEvent(false);
  folly::dynamic gotDynamic = q.toDynamic();
  gotDynamic["traces"][0]["events"][0][0] = "0"; // hardcode reference time
--- a/quic/loss/test/QuicLossFunctionsTest.cpp
+++ b/quic/loss/test/QuicLossFunctionsTest.cpp
@@ -537,7 +537,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderingThreshold) {

 TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {
  auto conn = createConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn->qLogger = qLogger;
  conn->lossState.ptoCount = 100;
  conn->lossState.reorderingThreshold = 10;
@@ -581,7 +581,7 @@ TEST_F(QuicLossFunctionsTest, TestHandleAckForLoss) {

 TEST_F(QuicLossFunctionsTest, TestHandleAckedPacket) {
  auto conn = createConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn->qLogger = qLogger;
  conn->lossState.ptoCount = 10;
  conn->lossState.handshakeAlarmCount = 5;
@@ -857,7 +857,7 @@ TEST_F(
    QuicLossFunctionsTest,
    WhenHandshakeOutstandingAlarmMarksAllHandshakeAsLoss) {
  auto conn = createConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn->qLogger = qLogger;
  auto mockCongestionController = std::make_unique<MockCongestionController>();
  auto rawCongestionController = mockCongestionController.get();
@@ -910,7 +910,7 @@ TEST_F(

 TEST_F(QuicLossFunctionsTest, HandshakeAlarmWithOneRttCipher) {
  auto conn = createClientConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn->qLogger = qLogger;
  conn->oneRttWriteCipher = createNoOpAead();
  conn->lossState.currentAlarmMethod = LossState::AlarmMethod::Handshake;
@@ -1202,7 +1202,7 @@ TEST_F(QuicLossFunctionsTest, TestMarkPacketLossProcessedPacket) {

 TEST_F(QuicLossFunctionsTest, TestTotalPTOCount) {
  auto conn = createConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn->qLogger = qLogger;
  conn->lossState.totalPTOCount = 100;
  EXPECT_CALL(*transportInfoCb_, onPTO());
@@ -1222,7 +1222,7 @@ TEST_F(QuicLossFunctionsTest, TestTotalPTOCount) {

 TEST_F(QuicLossFunctionsTest, TestExceedsMaxPTOThrows) {
  auto conn = createConn();
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn->qLogger = qLogger;
  conn->transportSettings.maxNumPTOs = 3;
  EXPECT_CALL(*transportInfoCb_, onPTO()).Times(3);
--- a/quic/server/test/QuicServerTransportTest.cpp
+++ b/quic/server/test/QuicServerTransportTest.cpp
@@ -929,7 +929,7 @@ TEST_F(QuicServerTransportTest, TestCloseConnectionWithNoError) {
 }

 TEST_F(QuicServerTransportTest, TestClientAddressChanges) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  StreamId streamId = 4;
  clientAddr = folly::SocketAddress("127.0.0.1", 2000);
@@ -1028,7 +1028,7 @@ TEST_F(QuicServerTransportTest, ReceivePacketAfterLocalError) {
 }

 TEST_F(QuicServerTransportTest, ReceiveCloseAfterLocalError) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;

  ShortHeader header(
@@ -1735,7 +1735,7 @@ TEST_F(QuicServerTransportTest, StopSendingLossAfterStreamClosed) {

 TEST_F(QuicServerTransportTest, TestCloneStopSending) {
  auto streamId = server->createBidirectionalStream().value();
-  auto qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<quic::FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  server->getNonConstConn().streamManager->getStream(streamId);
  // knock every handshake outstanding packets out
@@ -1843,7 +1843,7 @@ TEST_F(QuicServerTransportTest, TestAckRstStream) {
 }

 TEST_F(QuicServerTransportTest, ReceiveConnectionClose) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;

  ShortHeader header(
@@ -1881,7 +1881,7 @@ TEST_F(QuicServerTransportTest, ReceiveConnectionClose) {
 }

 TEST_F(QuicServerTransportTest, ReceiveApplicationClose) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;

  ShortHeader header(
@@ -1923,7 +1923,7 @@ TEST_F(QuicServerTransportTest, ReceiveApplicationClose) {
 }

 TEST_F(QuicServerTransportTest, ReceiveConnectionCloseTwice) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  ShortHeader header(
      ProtectionType::KeyPhaseZero,
@@ -2149,7 +2149,7 @@ INSTANTIATE_TEST_CASE_P(
 TEST_P(
    QuicServerTransportAllowMigrationTest,
    ReceiveProbingPacketFromChangedPeerAddress) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  server->getNonConstConn().transportSettings.disableMigration = false;

@@ -2502,7 +2502,7 @@ TEST_P(
 }

 TEST_F(QuicServerTransportTest, TooManyMigrations) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  server->getNonConstConn().transportSettings.disableMigration = false;

@@ -3257,7 +3257,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedStream) {
 }

 TEST_F(QuicUnencryptedServerTransportTest, TestUnencryptedAck) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  WriteAckFrame::AckBlocks acks = {{1, 2}};
  auto expected = IOBuf::copyBuffer("hello");
@@ -3395,7 +3395,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestPendingOneRttData) {
 TEST_F(
    QuicUnencryptedServerTransportTest,
    TestReceiveClientFinishedFromChangedPeerAddress) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  recvClientHello();

@@ -3567,7 +3567,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestEncryptedDataBeforeCFIN) {
 TEST_F(
    QuicUnencryptedServerTransportTest,
    TestClearInFlightBytesLimitationAfterCFIN) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  getFakeHandshakeLayer()->allowZeroRttKeys();
  auto originalUdpSize = server->getConn().udpSendPacketLen;
@@ -3601,7 +3601,7 @@ TEST_F(
 TEST_F(
    QuicUnencryptedServerTransportTest,
    IncreaseLimitAfterReceivingNewPacket) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;
  getFakeHandshakeLayer()->allowZeroRttKeys();

@@ -3634,7 +3634,7 @@ TEST_F(
 }

 TEST_F(QuicUnencryptedServerTransportTest, TestGarbageData) {
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  server->getNonConstConn().qLogger = qLogger;

  auto data = IOBuf::copyBuffer("bad data");
@@ -3787,7 +3787,7 @@ TEST_P(
    QuicServerTransportPendingDataTest,
    TestNoCipherProcessPendingZeroRttData) {
  server->getNonConstConn().qLogger =
-      std::make_shared<quic::FileQLogger>(VantagePoint::SERVER);
+      std::make_shared<quic::FileQLogger>(VantagePoint::Server);
  recvClientHello(false);
  auto data = IOBuf::copyBuffer("bad data");
  StreamId streamId = 2;
@@ -3825,7 +3825,7 @@ TEST_P(
    QuicServerTransportPendingDataTest,
    TestNoCipherProcessPendingOneRttData) {
  server->getNonConstConn().qLogger =
-      std::make_shared<quic::FileQLogger>(VantagePoint::SERVER);
+      std::make_shared<quic::FileQLogger>(VantagePoint::Server);
  recvClientHello();
  auto data = IOBuf::copyBuffer("bad data");
  StreamId streamId = 2;
@@ -3857,7 +3857,7 @@ TEST_P(
    QuicServerTransportPendingDataTest,
    TestNoCipherProcessingZeroAndOneRttData) {
  server->getNonConstConn().qLogger =
-      std::make_shared<quic::FileQLogger>(VantagePoint::SERVER);
+      std::make_shared<quic::FileQLogger>(VantagePoint::Server);
  recvClientHello(false);
  auto data = IOBuf::copyBuffer("bad data");
  StreamId streamId = 2;
--- a/quic/state/stream/test/StreamStateFunctionsTest.cpp
+++ b/quic/state/stream/test/StreamStateFunctionsTest.cpp
@@ -185,7 +185,7 @@ TEST_F(StreamStateFunctionsTests, ResetNoFlowControlGenerated) {

 TEST_F(StreamStateFunctionsTests, ResetFlowControlGenerated) {
  QuicServerConnectionState conn;
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::CLIENT);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
  conn.qLogger = qLogger;

  StreamId id = 1;
--- a/quic/state/test/AckHandlersTest.cpp
+++ b/quic/state/test/AckHandlersTest.cpp
@@ -741,7 +741,7 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
 // Ack only acks packets aren't outstanding, but TimeReordering still finds loss
 TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
  QuicServerConnectionState conn;
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn.qLogger = qLogger;

  conn.lossState.srtt = 200ms;
--- a/quic/state/test/QuicStateFunctionsTest.cpp
+++ b/quic/state/test/QuicStateFunctionsTest.cpp
@@ -412,7 +412,7 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineStreamError) {

 TEST_F(QuicStateFunctionsTest, UpdateMinRtt) {
  QuicServerConnectionState conn;
-  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::SERVER);
+  auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
  conn.qLogger = qLogger;

  // First rtt sample, will be assign to both srtt and mrtt
--- a/quic/tools/tperf/test/PacingObserverTest.cpp
+++ b/quic/tools/tperf/test/PacingObserverTest.cpp
@@ -16,7 +16,7 @@ namespace quic::test {
 class QLogPacingObserverTest : public Test {
 public:
  void SetUp() override {
-    auto qlogger = std::make_shared<MockQLogger>();
+    auto qlogger = std::make_shared<MockQLogger>(VantagePoint::Client);
    mockQLogger_ = qlogger.get();
    qlogger_ = std::move(qlogger);
  }
--- a/quic/tools/tperf/tperf.cpp
+++ b/quic/tools/tperf/tperf.cpp
@@ -233,7 +233,7 @@ class TPerfServerTransportFactory : public quic::QuicServerTransportFactory {
        evb, std::move(sock), *serverHandler, ctx);
    if (!FLAGS_server_qlogger_path.empty()) {
      auto qlogger = std::make_shared<TperfQLogger>(
-          VantagePoint::SERVER, FLAGS_server_qlogger_path);
+          VantagePoint::Server, FLAGS_server_qlogger_path);
      setPacingObserver(qlogger, transport.get(), FLAGS_pacing_observer);
      transport->setQLogger(std::move(qlogger));
    }