diff --git a/quic/QuicConstants.cpp b/quic/QuicConstants.cpp
index 7d7921512..a5097d82d 100644
--- a/quic/QuicConstants.cpp
+++ b/quic/QuicConstants.cpp
@@ -116,4 +116,5 @@ folly::StringPiece writeNoWriteReasonString(NoWriteReason reason) {
   }
   folly::assume_unreachable();
 }
+
 } // namespace quic
diff --git a/quic/api/QuicTransportBase.h b/quic/api/QuicTransportBase.h
index eb817758b..97c3784f7 100644
--- 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>
diff --git a/quic/api/test/QuicTransportBaseTest.cpp b/quic/api/test/QuicTransportBaseTest.cpp
index 87e327027..14e4a8315 100644
--- 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();
 
diff --git a/quic/api/test/QuicTransportFunctionsTest.cpp b/quic/api/test/QuicTransportFunctionsTest.cpp
index a24f948f1..063dc97c2 100644
--- 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;
diff --git a/quic/api/test/QuicTransportTest.cpp b/quic/api/test/QuicTransportTest.cpp
index 64a65fe14..4ed27d3ad 100644
--- 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();
diff --git a/quic/client/test/QuicClientTransportTest.cpp b/quic/client/test/QuicClientTransportTest.cpp
index d5ab81152..fa511a7c2 100644
--- 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++;
diff --git a/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp b/quic/congestion_control/test/BbrBandwidthSamplerTest.cpp
index f250e0e7a..886700d37 100644
--- 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);
diff --git a/quic/congestion_control/test/BbrTest.cpp b/quic/congestion_control/test/BbrTest.cpp
index 799d4c34c..c297abe51 100644
--- 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);
 
diff --git a/quic/congestion_control/test/CopaTest.cpp b/quic/congestion_control/test/CopaTest.cpp
index 4e50ecdb1..b507433f2 100644
--- 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;
diff --git a/quic/congestion_control/test/CubicTest.cpp b/quic/congestion_control/test/CubicTest.cpp
index f3905d3fa..645b88b99 100644
--- 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);
diff --git a/quic/flowcontrol/test/QuicFlowControlTest.cpp b/quic/flowcontrol/test/QuicFlowControlTest.cpp
index 653ae0156..5472fef17 100644
--- 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);
diff --git a/quic/logging/QLogger.h b/quic/logging/QLogger.h
index 6a9060fbe..52971e95a 100644
--- 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,
diff --git a/quic/logging/QLoggerConstants.cpp b/quic/logging/QLoggerConstants.cpp
index ba75559e8..b5d0fde51 100644
--- 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();
diff --git a/quic/logging/QLoggerConstants.h b/quic/logging/QLoggerConstants.h
index d7b2152f4..b7af702db 100644
--- 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;
 
diff --git a/quic/logging/QLoggerTypes.cpp b/quic/logging/QLoggerTypes.cpp
index 81bc7fcd8..42ee9b43c 100644
--- 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";
diff --git a/quic/logging/test/Mocks.h b/quic/logging/test/Mocks.h
index 9194e69e9..ed5058501 100644
--- 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(
diff --git a/quic/logging/test/QLoggerTest.cpp b/quic/logging/test/QLoggerTest.cpp
index 3054a069b..a4eae3b71 100644
--- 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
diff --git a/quic/loss/test/QuicLossFunctionsTest.cpp b/quic/loss/test/QuicLossFunctionsTest.cpp
index 89ab67868..97ba3c72c 100644
--- 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);
diff --git a/quic/server/test/QuicServerTransportTest.cpp b/quic/server/test/QuicServerTransportTest.cpp
index 35dc8936c..d1709c6c0 100644
--- 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;
diff --git a/quic/state/stream/test/StreamStateFunctionsTest.cpp b/quic/state/stream/test/StreamStateFunctionsTest.cpp
index b3e5ac906..e6f7f3c65 100644
--- 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;
diff --git a/quic/state/test/AckHandlersTest.cpp b/quic/state/test/AckHandlersTest.cpp
index 04bad9960..f15ecec12 100644
--- 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;
diff --git a/quic/state/test/QuicStateFunctionsTest.cpp b/quic/state/test/QuicStateFunctionsTest.cpp
index a7acb77d4..709f700dc 100644
--- 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
diff --git a/quic/tools/tperf/test/PacingObserverTest.cpp b/quic/tools/tperf/test/PacingObserverTest.cpp
index 0638b4598..e7c7ac43b 100644
--- 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);
   }
diff --git a/quic/tools/tperf/tperf.cpp b/quic/tools/tperf/tperf.cpp
index 4ce5a507f..7ac7b2697 100644
--- 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));
     }