diff --git a/CMakeLists.txt b/CMakeLists.txt
index 75494ab26a..39086b8490 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -94,16 +94,54 @@ find_package(ZLIB REQUIRED)
 find_package(OpenSSL REQUIRED)
 find_package(Threads)
 find_package(Cares REQUIRED)
-find_package(Glog REQUIRED)
 
-# Propagate glog's required compile definition to all proxygen targets.
-# glog 0.7+ requires GLOG_USE_GLOG_EXPORT but since glog::glog is linked
-# PRIVATE on the monolithic library, OBJECT libraries don't inherit it.
-get_target_property(_glog_defs glog::glog INTERFACE_COMPILE_DEFINITIONS)
-if(_glog_defs)
-  add_compile_definitions(${_glog_defs})
+# Set install-dir defaults before any install() rule references them. The
+# matching defaults below (LIB_INSTALL_DIR / CMAKE_INSTALL_DIR) stay where they
+# are since nothing earlier in this file consumes them.
+if (NOT DEFINED INCLUDE_INSTALL_DIR)
+    set(INCLUDE_INSTALL_DIR "include")
+endif()
+
+# Logging backend selection. Default is glog (preserves historical behavior);
+# downstream builds can opt in to folly::xlog or fully disable logging.
+# Interpolated into lib/utils/proxygen-config.h.in as
+# `#define PRX_LOGGING_@PROXYGEN_LOGGING_BACKEND@ 1` and consumed from
+# proxygen/lib/utils/LogShim.h.
+set(PROXYGEN_LOGGING_BACKEND "GLOG" CACHE STRING
+  "Logging backend. Valid choices: GLOG, XLOG, DISABLED")
+set_property(CACHE PROXYGEN_LOGGING_BACKEND PROPERTY STRINGS GLOG XLOG DISABLED)
+if(NOT PROXYGEN_LOGGING_BACKEND MATCHES "^(GLOG|XLOG|DISABLED)$")
+  message(FATAL_ERROR
+    "PROXYGEN_LOGGING_BACKEND must be one of: GLOG, XLOG, DISABLED "
+    "(got '${PROXYGEN_LOGGING_BACKEND}')")
 endif()
 
+# Glog is only required in the default GLOG backend; XLOG routes through
+# folly::xlog and DISABLED strips logging entirely.
+if(PROXYGEN_LOGGING_BACKEND STREQUAL "GLOG")
+  find_package(Glog REQUIRED)
+
+  # Propagate glog's required compile definition to all proxygen targets.
+  # glog 0.7+ requires GLOG_USE_GLOG_EXPORT but since glog::glog is linked
+  # PRIVATE on the monolithic library, OBJECT libraries don't inherit it.
+  get_target_property(_glog_defs glog::glog INTERFACE_COMPILE_DEFINITIONS)
+  if(_glog_defs)
+    add_compile_definitions(${_glog_defs})
+  endif()
+endif()
+
+# Generate <proxygen/proxygen-config.h> for this build. The template
+# interpolates PROXYGEN_LOGGING_BACKEND into a
+# `#define PRX_LOGGING_<BACKEND> 1`, which proxygen/lib/utils/LogShim.h
+# consumes to pick the macro implementations.
+# Generated into PROXYGEN_GENERATED_ROOT which is already on every proxygen
+# target's include path (see ProxygenFunctions.cmake).
+configure_file(
+  proxygen/lib/utils/proxygen-config.h.in
+  ${PROXYGEN_GENERATED_ROOT}/proxygen/proxygen-config.h)
+install(FILES ${PROXYGEN_GENERATED_ROOT}/proxygen/proxygen-config.h
+  DESTINATION ${INCLUDE_INSTALL_DIR}/proxygen/)
+
 list(APPEND
     _PROXYGEN_COMMON_COMPILE_OPTIONS
     -Wall
@@ -173,6 +211,19 @@ set(PROXYGEN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/proxygen)
 
 add_subdirectory(proxygen)
 
+# The generated lib/utils/CMakeLists.txt lists both Folly::folly_glog and
+# Folly::folly_logging_logging as unconditional INTERFACE deps for the log
+# shim. Narrow that to match the selected backend so downstream code doesn't
+# pull in libraries it isn't actually using.
+if(PROXYGEN_LOGGING_BACKEND STREQUAL "XLOG")
+  set_target_properties(proxygen_utils_log_shim PROPERTIES
+    INTERFACE_LINK_LIBRARIES
+    "proxygen_utils_config;Folly::folly_logging_logging")
+elseif(PROXYGEN_LOGGING_BACKEND STREQUAL "DISABLED")
+  set_target_properties(proxygen_utils_log_shim PROPERTIES
+    INTERFACE_LINK_LIBRARIES "proxygen_utils_config")
+endif()
+
 # Resolve deferred dependencies for granular libraries
 # (monolithic proxygen target is manually maintained in proxygen/lib/CMakeLists.txt)
 proxygen_resolve_deferred_dependencies()
diff --git a/build/fbcode_builder/manifests/snappy b/build/fbcode_builder/manifests/snappy
index 4af86c1ece..693d5146ae 100644
--- a/build/fbcode_builder/manifests/snappy
+++ b/build/fbcode_builder/manifests/snappy
@@ -24,6 +24,12 @@ subdir = snappy-27ab5f7f518430a021239bc26a5b2fd64affbc7b
 [cmake.defines]
 SNAPPY_BUILD_TESTS = OFF
 SNAPPY_BUILD_BENCHMARKS = OFF
+# folly's Compression.cpp dynamic_casts snappy::Source/Sink and needs their
+# typeinfo. Snappy hardcodes -fno-rtti in CMAKE_CXX_FLAGS; override via the
+# per-config flags variable, which is appended after (last -f wins in gcc).
+CMAKE_CXX_FLAGS_RELWITHDEBINFO = -O2 -g -DNDEBUG -frtti
+CMAKE_CXX_FLAGS_RELEASE = -O3 -DNDEBUG -frtti
+CMAKE_CXX_FLAGS_DEBUG = -g -frtti
 
 # Avoid problems like `relocation R_X86_64_PC32 against symbol` on ELF systems
 # when linking rocksdb, which builds PIC even when building a static lib
diff --git a/proxygen/httpclient/samples/H3Datagram/H3DatagramClient.cpp b/proxygen/httpclient/samples/H3Datagram/H3DatagramClient.cpp
index 5ba983b7f0..972153b8e2 100644
--- a/proxygen/httpclient/samples/H3Datagram/H3DatagramClient.cpp
+++ b/proxygen/httpclient/samples/H3Datagram/H3DatagramClient.cpp
@@ -14,6 +14,7 @@
 #include <proxygen/httpserver/samples/hq/InsecureVerifierDangerousDoNotUseInProduction.h>
 #include <proxygen/lib/transport/ConnectUDPUtils.h>
 #include <proxygen/lib/transport/H3DatagramAsyncSocket.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -65,12 +66,12 @@ class DatagramClient
   }
 
   void start() {
-    CHECK(evb_->isInEventBaseThread());
+    PRX_CHECK(evb_->isInEventBaseThread());
     try {
       socket_.connect(SocketAddress(FLAGS_proxy_host, FLAGS_proxy_port));
     } catch (const std::system_error& e) {
-      LOG(ERROR) << "Failed to connect to " << FLAGS_proxy_host << ":"
-                 << FLAGS_proxy_port << ": " << e.what();
+      PRX_LOG(ERROR) << "Failed to connect to " << FLAGS_proxy_host << ":"
+                     << FLAGS_proxy_port << ": " << e.what();
       return;
     }
     socket_.resumeRead(this);
@@ -79,7 +80,7 @@ class DatagramClient
   }
 
   void shutdown() {
-    CHECK(evb_->isInEventBaseThread());
+    PRX_CHECK(evb_->isInEventBaseThread());
     socket_.pauseRead();
     socket_.close();
     closing_ = true;
@@ -96,11 +97,11 @@ class DatagramClient
   }
 
   virtual void writePing(std::unique_ptr<folly::IOBuf> buf) {
-    VLOG(2) << "Writing Datagram";
+    PRX_VLOG(2) << "Writing Datagram";
     auto res =
         socket_.write(SocketAddress(FLAGS_proxy_host, FLAGS_proxy_port), buf);
     if (res < 0) {
-      LOG(ERROR) << "Failure to write: errno=" << errno;
+      PRX_LOG(ERROR) << "Failure to write: errno=" << errno;
     }
   }
 
@@ -114,30 +115,30 @@ class DatagramClient
                        bool truncated,
                        OnDataAvailableParams) noexcept override {
     ++pongRecvd_;
-    VLOG(4) << "Read " << len << " bytes (trun:" << truncated << ") from "
-            << client.describe() << " - " << std::string(buf_.data(), len);
+    PRX_VLOG(4) << "Read " << len << " bytes (trun:" << truncated << ") from "
+                << client.describe() << " - " << std::string(buf_.data(), len);
     auto datagramString = std::string(buf_.data(), len);
     auto datagramInt = folly::tryTo<uint16_t>(datagramString);
     if (!datagramInt.hasValue()) {
-      VLOG(2) << "Received Datagram without Integer value. Stopping. len="
-              << datagramString.length();
+      PRX_VLOG(2) << "Received Datagram without Integer value. Stopping. len="
+                  << datagramString.length();
       return;
     }
-    VLOG(2) << "Received Datagram with Integer value (" << (int)*datagramInt
-            << ")";
+    PRX_VLOG(2) << "Received Datagram with Integer value (" << (int)*datagramInt
+                << ")";
     if (*datagramInt >= std::numeric_limits<uint16_t>::max()) {
-      VLOG(2) << "Received Datagram with large Integer value. Stopping";
+      PRX_VLOG(2) << "Received Datagram with large Integer value. Stopping";
       return;
     }
-    VLOG(2) << "Sending Datagram with Integer value ("
-            << (int)(*datagramInt + 1) << ")";
+    PRX_VLOG(2) << "Sending Datagram with Integer value ("
+                << (int)(*datagramInt + 1) << ")";
     n_ = (int)(*datagramInt + 1);
 
     scheduleTimeout(1000);
   }
 
   void onReadError(const folly::AsyncSocketException& ex) noexcept override {
-    LOG(ERROR) << ex.what();
+    PRX_LOG(ERROR) << ex.what();
   }
 
   void onReadClosed() noexcept override {
@@ -145,7 +146,7 @@ class DatagramClient
   }
 
   void timeoutExpired() noexcept override {
-    LOG(INFO) << "Timeout expired";
+    PRX_LOG(INFO) << "Timeout expired";
     if (!closing_) {
       sendPing();
     }
diff --git a/proxygen/httpclient/samples/curl/CurlClient.cpp b/proxygen/httpclient/samples/curl/CurlClient.cpp
index d477b64959..b39158804c 100644
--- a/proxygen/httpclient/samples/curl/CurlClient.cpp
+++ b/proxygen/httpclient/samples/curl/CurlClient.cpp
@@ -20,6 +20,7 @@
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/codec/HTTP2Codec.h>
 #include <proxygen/lib/http/session/HTTPUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -130,10 +131,10 @@ void CurlClient::sslHandshakeFollowup(HTTPUpstreamSession* session) noexcept {
   unsigned nextProtoLength = 0;
   sslSocket->getSelectedNextProtocol(&nextProto, &nextProtoLength);
   if (nextProto) {
-    VLOG(1) << "Client selected next protocol "
-            << string((const char*)nextProto, nextProtoLength);
+    PRX_VLOG(1) << "Client selected next protocol "
+                << string((const char*)nextProto, nextProtoLength);
   } else {
-    VLOG(1) << "Client did not select a next protocol";
+    PRX_VLOG(1) << "Client did not select a next protocol";
   }
 
   // Note: This ssl session can be used by defining a member and setting
@@ -181,7 +182,7 @@ void CurlClient::setupHeaders() {
 }
 
 void CurlClient::sendRequest(HTTPTransaction* txn) {
-  LOG_IF(INFO, loggingEnabled_)
+  PRX_LOG_IF(INFO, loggingEnabled_)
       << fmt::format("Sending request for {}", url_.getUrl());
   txn_ = txn;
   setupHeaders();
@@ -199,7 +200,7 @@ void CurlClient::sendRequest(HTTPTransaction* txn) {
 
 void CurlClient::sendBodyFromFile() {
   const uint16_t kReadSize = 4096;
-  CHECK(inputFile_);
+  PRX_CHECK(inputFile_);
   // Reading from the file by chunks
   // Important note: It's pretty bad to call a blocking i/o function like
   // ifstream::read() in an eventloop - but for the sake of this simple
@@ -231,7 +232,7 @@ void CurlClient::printMessageImpl(proxygen::HTTPMessage* msg,
 }
 
 void CurlClient::connectError(const folly::AsyncSocketException& ex) {
-  LOG_IF(ERROR, loggingEnabled_)
+  PRX_LOG_IF(ERROR, loggingEnabled_)
       << "Coudln't connect to " << url_.getHostAndPort() << ":" << ex.what();
 }
 
@@ -258,7 +259,7 @@ void CurlClient::onBody(std::unique_ptr<folly::IOBuf> chain) noexcept {
   if (!loggingEnabled_) {
     return;
   }
-  CHECK(outputStream_);
+  PRX_CHECK(outputStream_);
   if (chain) {
     const IOBuf* p = chain.get();
     do {
@@ -270,11 +271,11 @@ void CurlClient::onBody(std::unique_ptr<folly::IOBuf> chain) noexcept {
 }
 
 void CurlClient::onTrailers(std::unique_ptr<HTTPHeaders>) noexcept {
-  LOG_IF(INFO, loggingEnabled_) << "Discarding trailers";
+  PRX_LOG_IF(INFO, loggingEnabled_) << "Discarding trailers";
 }
 
 void CurlClient::onEOM() noexcept {
-  LOG_IF(INFO, loggingEnabled_)
+  PRX_LOG_IF(INFO, loggingEnabled_)
       << fmt::format("Got EOM for {}. Txn Time= {} ms",
                      url_.getUrl(),
                      std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -286,20 +287,20 @@ void CurlClient::onEOM() noexcept {
 }
 
 void CurlClient::onUpgrade(UpgradeProtocol) noexcept {
-  LOG_IF(INFO, loggingEnabled_) << "Discarding upgrade protocol";
+  PRX_LOG_IF(INFO, loggingEnabled_) << "Discarding upgrade protocol";
 }
 
 void CurlClient::onError(const HTTPException& error) noexcept {
-  LOG_IF(ERROR, loggingEnabled_) << "An error occurred: " << error.what();
+  PRX_LOG_IF(ERROR, loggingEnabled_) << "An error occurred: " << error.what();
 }
 
 void CurlClient::onEgressPaused() noexcept {
-  VLOG_IF(1, loggingEnabled_) << "Egress paused";
+  PRX_VLOG_IF(1, loggingEnabled_) << "Egress paused";
   egressPaused_ = true;
 }
 
 void CurlClient::onEgressResumed() noexcept {
-  VLOG_IF(1, loggingEnabled_) << "Egress resumed";
+  PRX_VLOG_IF(1, loggingEnabled_) << "Egress resumed";
   egressPaused_ = false;
   if (inputFile_) {
     sendBodyFromFile();
@@ -325,12 +326,12 @@ const string& CurlClient::getServerName() const {
 // CurlPushHandler methods
 void CurlClient::CurlPushHandler::setTransaction(
     proxygen::HTTPTransaction* txn) noexcept {
-  LOG_IF(INFO, parent_->loggingEnabled_) << "Received pushed transaction";
+  PRX_LOG_IF(INFO, parent_->loggingEnabled_) << "Received pushed transaction";
   pushedTxn_ = txn;
 }
 
 void CurlClient::CurlPushHandler::detachTransaction() noexcept {
-  LOG_IF(INFO, parent_->loggingEnabled_) << "Detached pushed transaction";
+  PRX_LOG_IF(INFO, parent_->loggingEnabled_) << "Detached pushed transaction";
 }
 
 void CurlClient::CurlPushHandler::onHeadersComplete(
@@ -351,7 +352,7 @@ void CurlClient::CurlPushHandler::onBody(
 }
 
 void CurlClient::CurlPushHandler::onEOM() noexcept {
-  LOG_IF(INFO, parent_->loggingEnabled_) << "Got PushTxn EOM";
+  PRX_LOG_IF(INFO, parent_->loggingEnabled_) << "Got PushTxn EOM";
 }
 
 void CurlClient::CurlPushHandler::onError(
diff --git a/proxygen/httpclient/samples/curl/CurlClientMain.cpp b/proxygen/httpclient/samples/curl/CurlClientMain.cpp
index d5edf7e044..7471e6a1e5 100644
--- a/proxygen/httpclient/samples/curl/CurlClientMain.cpp
+++ b/proxygen/httpclient/samples/curl/CurlClientMain.cpp
@@ -14,6 +14,7 @@
 #include <folly/portability/GFlags.h>
 #include <proxygen/httpclient/samples/curl/CurlClient.h>
 #include <proxygen/lib/http/HTTPConnector.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace CurlService;
 using namespace folly;
@@ -63,7 +64,7 @@ int main(int argc, char* argv[]) {
 
   auto httpMethod = stringToMethod(FLAGS_http_method);
   if (!httpMethod) {
-    LOG(ERROR) << "Unsupported http_method=" << FLAGS_http_method;
+    PRX_LOG(ERROR) << "Unsupported http_method=" << FLAGS_http_method;
     return EXIT_FAILURE;
   }
 
@@ -72,8 +73,8 @@ int main(int argc, char* argv[]) {
       File f(FLAGS_input_filename);
       (void)f;
     } catch (const std::system_error& se) {
-      LOG(ERROR) << "Couldn't open file for POST method";
-      LOG(ERROR) << se.what();
+      PRX_LOG(ERROR) << "Couldn't open file for POST method";
+      PRX_LOG(ERROR) << se.what();
       return EXIT_FAILURE;
     }
   }
@@ -97,7 +98,7 @@ int main(int argc, char* argv[]) {
   } else {
     addr = SocketAddress(url.getHost(), url.getPort(), true);
   }
-  LOG(INFO) << "Trying to connect to " << addr;
+  PRX_LOG(INFO) << "Trying to connect to " << addr;
 
   HTTPConnector connector(
       &curlClient,
diff --git a/proxygen/httpclient/samples/httperf2/Client.cpp b/proxygen/httpclient/samples/httperf2/Client.cpp
index 646dc53b36..f95e946888 100644
--- a/proxygen/httpclient/samples/httperf2/Client.cpp
+++ b/proxygen/httpclient/samples/httperf2/Client.cpp
@@ -16,6 +16,7 @@
 #include <folly/portability/OpenSSL.h>
 #include <proxygen/httpserver/samples/hq/HQLoggerHelper.h>
 #include <proxygen/httpserver/samples/hq/InsecureVerifierDangerousDoNotUseInProduction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/QuicConstants.h>
 
 using namespace folly;
@@ -88,7 +89,7 @@ Client::Client(EventBase* eventBase,
       connector_(this, transactionTimeouts),
       serverName_(serverName),
       plaintextProto_(plaintextProto) {
-  CHECK_GT(requests_, 0);
+  PRX_CHECK_GT(requests_, 0u);
   connector_.setPlaintextProtocol(plaintextProto);
 }
 
@@ -102,7 +103,7 @@ Client::~Client() {
     // drain() might cause synchronous destruction, protect ourselves
     // from it.
     DelayedDestructionBase::DestructorGuard guard(session_);
-    VLOG(4) << "shutting down session";
+    PRX_VLOG(4) << "shutting down session";
     session_->dropConnection("shutting down");
     // The above will destroy session_ and kill all the transactions
     // But we don't need any callbacks because we're toast
@@ -306,7 +307,7 @@ void Client::sendRequest() {
     // happen once the connect succeeds.
     return;
   }
-  CHECK(session_);
+  PRX_CHECK(session_);
   uint32_t requestsThisLoop = 0;
   while ((outstandingTransactions_ <
           uint32_t(FLAGS_max_outstanding_transactions)) &&
@@ -343,10 +344,10 @@ void Client::sendRequest() {
 }
 
 void Client::connectSuccess(proxygen::HQUpstreamSession* session) {
-  CHECK(!session_);
+  PRX_CHECK(!session_);
   const auto transport = session->getQuicSocket();
-  auto client =
-      CHECK_NOTNULL(dynamic_cast<const quic::QuicClientTransport*>(transport));
+  auto client = PRX_CHECK_NOTNULL(
+      dynamic_cast<const quic::QuicClientTransport*>(transport));
   if (client->isTLSResumed()) {
     stats_.addResume();
   } else {
@@ -360,7 +361,7 @@ void Client::connectError(const quic::QuicErrorCode&) {
 }
 
 void Client::connectSuccess(HTTPUpstreamSession* session) {
-  CHECK(!session_);
+  PRX_CHECK(!session_);
   session->setByteEventTracker(nullptr);
   if (sslContext_) {
     auto sslSocket = dynamic_cast<AsyncSSLSocket*>(session->getTransport());
@@ -368,10 +369,10 @@ void Client::connectSuccess(HTTPUpstreamSession* session) {
     unsigned nextProtoLength = 0;
     sslSocket->getSelectedNextProtocol(&nextProto, &nextProtoLength);
     if (nextProto) {
-      VLOG(4) << "Client selected next protocol "
-              << string((const char*)nextProto, nextProtoLength);
+      PRX_VLOG(4) << "Client selected next protocol "
+                  << string((const char*)nextProto, nextProtoLength);
     } else {
-      VLOG(4) << "Client did not select a next protocol";
+      PRX_VLOG(4) << "Client did not select a next protocol";
     }
     if (sslSocket->getSSLSessionReused()) {
       stats_.addResume();
@@ -397,7 +398,7 @@ void Client::connectError(const AsyncSocketException& /*ex*/) {
 }
 
 void Client::connectSuccessCommon(HTTPSessionBase* session) {
-  CHECK(!session_);
+  PRX_CHECK(!session_);
   session_ = session;
   session_->setInfoCallback(&collector_);
   session->setFlowControl(FLAGS_stream_flow_control,
@@ -424,14 +425,14 @@ void Client::connectErrorCommon() {
 // HTTPTransaction::Handler callbacks
 
 void Client::TransactionHandler::detachTransaction() noexcept {
-  DCHECK(!waitingForResponse_);
-  DCHECK(!inMessage_);
+  PRX_DCHECK(!waitingForResponse_);
+  PRX_DCHECK(!inMessage_);
   if (!parent_->inDestructor_) {
-    DCHECK_GT(parent_->outstandingTransactions_, 0);
+    PRX_DCHECK_GT(parent_->outstandingTransactions_, 0u);
     parent_->outstandingTransactions_--;
-    VLOG(3) << __func__ << " requestsSent=" << parent_->requestsSent_
-            << " requests=" << parent_->requests_
-            << " outstanding=" << parent_->outstandingTransactions_;
+    PRX_VLOG(3) << __func__ << " requestsSent=" << parent_->requestsSent_
+                << " requests=" << parent_->requests_
+                << " outstanding=" << parent_->outstandingTransactions_;
     if (!parent_->isLoopCallbackScheduled()) {
       parent_->Client::eventBase_->runInLoop(parent_);
     }
diff --git a/proxygen/httpclient/samples/httperf2/HTTPerf2.cpp b/proxygen/httpclient/samples/httperf2/HTTPerf2.cpp
index e2ba6dae3d..ed4e7f358e 100644
--- a/proxygen/httpclient/samples/httperf2/HTTPerf2.cpp
+++ b/proxygen/httpclient/samples/httperf2/HTTPerf2.cpp
@@ -33,6 +33,7 @@
 #include <csignal>
 #include <iostream>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 #include <random>
 
 using folly::SocketAddress;
@@ -217,7 +218,7 @@ int httperf2(folly::Optional<folly::SocketAddress> bindAddress,
 
   if (!FLAGS_data.empty()) {
     if (!folly::readFile(FLAGS_data.c_str(), gRequestData)) {
-      LOG(FATAL) << "Failed to read file";
+      PRX_LOG(FATAL) << "Failed to read file";
     }
   }
   std::cerr << "Running test against " << FLAGS_server << ":" << FLAGS_port
@@ -394,7 +395,7 @@ void ClientRunner::run() {
   sigset_t ss;
   sigemptyset(&ss);
   sigaddset(&ss, SIGPIPE);
-  PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
+  PRX_PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
 
   auto clients = std::min(remainingClients_, clientsAtOnce_);
   for (size_t i = 0; i < clients; i++) {
@@ -406,18 +407,18 @@ void ClientRunner::run() {
   }
   eventBase_.loop();
 
-  CHECK_EQ(clientsOutstanding_, 0);
+  PRX_CHECK_EQ(clientsOutstanding_, 0u);
   parentStats_.merge(stats_);
 }
 
 void ClientRunner::timeoutExpired() noexcept {
-  VLOG(3) << "Duration timeout expired";
+  PRX_VLOG(3) << "Duration timeout expired";
   Client::exitAllSoon();
   remainingClients_ = 0;
 }
 
 void ClientRunner::startClient() {
-  CHECK_GT(remainingClients_, 0);
+  PRX_CHECK_GT(remainingClients_, 0u);
   Client* client = nullptr;
   client = new Client(&eventBase_,
                       transactionTimeouts_,
@@ -473,8 +474,8 @@ void ClientRunner::clientFinished(Client* client) {
   }
   clientsOutstanding_--;
   delete client;
-  VLOG(3) << __func__ << " clientsOutstanding=" << clientsOutstanding_
-          << " remainingClients=" << remainingClients_;
+  PRX_VLOG(3) << __func__ << " clientsOutstanding=" << clientsOutstanding_
+              << " remainingClients=" << remainingClients_;
   if (remainingClients_ > 0 && clientsOutstanding_ < clientsAtOnce_) {
     startClient();
   }
diff --git a/proxygen/httpclient/samples/websocket/WebSocketClient.cpp b/proxygen/httpclient/samples/websocket/WebSocketClient.cpp
index 338a9633c7..65176c5a56 100644
--- a/proxygen/httpclient/samples/websocket/WebSocketClient.cpp
+++ b/proxygen/httpclient/samples/websocket/WebSocketClient.cpp
@@ -10,6 +10,7 @@
 
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/session/HTTPUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <utility>
 
 using namespace folly;
@@ -39,15 +40,15 @@ void WebSocketClient::setupRequest() {
 }
 
 void WebSocketClient::sendRequest(HTTPTransaction* txn) {
-  VLOG(4) << fmt::format("Connecting to {}", url_.getUrl());
+  PRX_VLOG(4) << fmt::format("Connecting to {}", url_.getUrl());
   txn_ = txn;
   setupRequest();
   txn_->sendHeaders(request_);
 }
 
 void WebSocketClient::connectError(const folly::AsyncSocketException& ex) {
-  LOG(ERROR) << "Failed to connect to " << url_.getHostAndPort() << ":"
-             << ex.what();
+  PRX_LOG(ERROR) << "Failed to connect to " << url_.getHostAndPort() << ":"
+                 << ex.what();
 }
 
 void WebSocketClient::setTransaction(HTTPTransaction*) noexcept {
@@ -61,27 +62,27 @@ void WebSocketClient::onHeadersComplete(unique_ptr<HTTPMessage> msg) noexcept {
 }
 
 void WebSocketClient::onBody(std::unique_ptr<folly::IOBuf> chain) noexcept {
-  LOG(INFO) << "got server reply: " << chain->moveToFbString();
+  PRX_LOG(INFO) << "got server reply: " << chain->moveToFbString();
   // Close the connection.
   txn_->sendEOM();
 }
 
 void WebSocketClient::onTrailers(std::unique_ptr<HTTPHeaders>) noexcept {
-  CHECK(false) << "unexpected trailers";
+  PRX_CHECK(false) << "unexpected trailers";
 }
 
 void WebSocketClient::onEOM() noexcept {
-  LOG(INFO) << "connection closed by server";
+  PRX_LOG(INFO) << "connection closed by server";
 }
 
 void WebSocketClient::onUpgrade(UpgradeProtocol) noexcept {
-  LOG(INFO) << "websocket connect successful; sending data";
+  PRX_LOG(INFO) << "websocket connect successful; sending data";
   auto data = folly::IOBuf::copyBuffer("websocket | framed | stream | data");
   txn_->sendBody(std::move(data));
 }
 
 void WebSocketClient::onError(const HTTPException& error) noexcept {
-  LOG(ERROR) << "An error occurred: " << error.what();
+  PRX_LOG(ERROR) << "An error occurred: " << error.what();
 }
 
 } // namespace websocketclient
diff --git a/proxygen/httpclient/samples/websocket/main.cpp b/proxygen/httpclient/samples/websocket/main.cpp
index bac360ee28..b7f5cd6e46 100644
--- a/proxygen/httpclient/samples/websocket/main.cpp
+++ b/proxygen/httpclient/samples/websocket/main.cpp
@@ -12,6 +12,7 @@
 #include <folly/io/async/EventBase.h>
 #include <proxygen/httpclient/samples/websocket/WebSocketClient.h>
 #include <proxygen/lib/http/HTTPConnector.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/URL.h>
 
 using namespace folly;
@@ -34,7 +35,7 @@ int main(int argc, char* argv[]) {
   WebSocketClient client(&evb, url);
 
   auto addr = SocketAddress(url.getHost(), url.getPort(), true);
-  LOG(INFO) << "Trying to connect to " << addr;
+  PRX_LOG(INFO) << "Trying to connect to " << addr;
 
   // Note: HHWheelTimer is a large object and should be created at most
   // once per thread
diff --git a/proxygen/httpserver/CMakeLists.txt b/proxygen/httpserver/CMakeLists.txt
index 3739e45b20..d00a0f7983 100644
--- a/proxygen/httpserver/CMakeLists.txt
+++ b/proxygen/httpserver/CMakeLists.txt
@@ -12,6 +12,7 @@ proxygen_add_library(proxygen_httpserver_httpserver_headers
   EXPORTED_DEPS
     proxygen_http_session_http_transaction
     proxygen_utils_compression_filter_utils
+    proxygen_utils_log_shim
     proxygen_utils_stream_decompressor
     Folly::folly_expected
     Folly::folly_function
@@ -39,6 +40,7 @@ proxygen_add_library(proxygen_httpserver
   DEPS
     proxygen_http_codec_codec_common
     proxygen_http_codec_http1x_codec
+    proxygen_utils_log_shim
     wangle::wangle_ssl_ssl_context_manager
     Folly::folly_exception_string
     Folly::folly_executors_thread_factory_named_thread_factory
@@ -64,6 +66,7 @@ proxygen_add_library(proxygen_httpserver_scoped_httpserver
   EXPORTED_DEPS
     proxygen_httpserver
     proxygen_httpserver_httpserver_headers
+    proxygen_utils_log_shim
     Folly::folly_io_async_ssl_context
     Folly::folly_system_thread_name
 )
diff --git a/proxygen/httpserver/HTTPServer.cpp b/proxygen/httpserver/HTTPServer.cpp
index ba8d12a644..1e357e3512 100644
--- a/proxygen/httpserver/HTTPServer.cpp
+++ b/proxygen/httpserver/HTTPServer.cpp
@@ -15,6 +15,7 @@
 #include <proxygen/httpserver/SignalHandler.h>
 #include <proxygen/httpserver/filters/CompressionFilter.h>
 #include <proxygen/httpserver/filters/RejectConnectFilter.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/ssl/SSLContextManager.h>
 
 using folly::EventBaseManager;
@@ -88,7 +89,7 @@ HTTPServer::HTTPServer(HTTPServerOptions options)
 }
 
 HTTPServer::~HTTPServer() {
-  CHECK(!mainEventBase_) << "Forgot to stop() server?";
+  PRX_CHECK(!mainEventBase_) << "Forgot to stop() server?";
 }
 
 void HTTPServer::bind(std::vector<IPConfig>&& addrs) {
diff --git a/proxygen/httpserver/HTTPServerAcceptor.cpp b/proxygen/httpserver/HTTPServerAcceptor.cpp
index eab6eae6ed..619174d701 100644
--- a/proxygen/httpserver/HTTPServerAcceptor.cpp
+++ b/proxygen/httpserver/HTTPServerAcceptor.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/httpserver/RequestHandlerFactory.h>
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
 #include <proxygen/lib/http/codec/HTTP2Constants.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::SocketAddress;
 
@@ -118,7 +119,8 @@ void HTTPServerAcceptor::onNewConnection(
       filter(sock.get(), address, nextProtocolName, secureTransportType, tinfo);
     } catch (const std::exception& e) {
       sock->closeWithReset();
-      LOG(INFO) << "Exception filtering new socket: " << folly::exceptionStr(e);
+      PRX_LOG(INFO) << "Exception filtering new socket: "
+                    << folly::exceptionStr(e);
       return;
     }
   }
diff --git a/proxygen/httpserver/PushHandler.h b/proxygen/httpserver/PushHandler.h
index 8273349f4a..c282adcf3a 100644
--- a/proxygen/httpserver/PushHandler.h
+++ b/proxygen/httpserver/PushHandler.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <proxygen/httpserver/RequestHandler.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -55,19 +56,19 @@ class PushHandler : public RequestHandler {
   };
 
   void onRequest(std::unique_ptr<HTTPMessage> /*headers*/) noexcept override {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> /*body*/) noexcept override {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   void onUpgrade(proxygen::UpgradeProtocol /*prot*/) noexcept override {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   void onEOM() noexcept override {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   InnerPushHandler innerHandler_;
diff --git a/proxygen/httpserver/RequestHandler.h b/proxygen/httpserver/RequestHandler.h
index a305bb5fda..b3c5064c73 100644
--- a/proxygen/httpserver/RequestHandler.h
+++ b/proxygen/httpserver/RequestHandler.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -30,7 +31,7 @@ class RequestHandler {
    *      mess with these things.
    */
   virtual void setResponseHandler(ResponseHandler* handler) noexcept {
-    downstream_ = CHECK_NOTNULL(handler);
+    downstream_ = PRX_CHECK_NOTNULL(handler);
   }
 
   /**
diff --git a/proxygen/httpserver/RequestHandlerAdaptor.cpp b/proxygen/httpserver/RequestHandlerAdaptor.cpp
index 3f27c38df5..c6c8444a31 100644
--- a/proxygen/httpserver/RequestHandlerAdaptor.cpp
+++ b/proxygen/httpserver/RequestHandlerAdaptor.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/httpserver/PushHandler.h>
 #include <proxygen/httpserver/RequestHandler.h>
 #include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -202,13 +203,13 @@ RequestHandlerAdaptor::newPushedResponse(PushHandler* pushHandler) noexcept {
   auto pushTxn = txn_->newPushedTransaction(pushHandler->getHandler(), &error);
   if (!pushTxn) {
     // Codec doesn't support push
-    VLOG(4) << "Failed to create newPushedResponse: "
-            << static_cast<uint8_t>(error) << " " << getErrorString(error);
+    PRX_VLOG(4) << "Failed to create newPushedResponse: "
+                << static_cast<uint8_t>(error) << " " << getErrorString(error);
     return folly::makeUnexpected(error);
   }
   auto pushHandlerAdaptor = new RequestHandlerAdaptor(pushHandler);
   if (!pushHandlerAdaptor) {
-    VLOG(4) << "Failed to create RequestHandlerAdaptor!";
+    PRX_VLOG(4) << "Failed to create RequestHandlerAdaptor!";
     return folly::makeUnexpected(kErrorUnknown);
   }
   pushHandlerAdaptor->setTransaction(pushTxn);
diff --git a/proxygen/httpserver/ResponseBuilder.h b/proxygen/httpserver/ResponseBuilder.h
index b16b507b3c..3a09c7244c 100644
--- a/proxygen/httpserver/ResponseBuilder.h
+++ b/proxygen/httpserver/ResponseBuilder.h
@@ -12,6 +12,7 @@
 #include <proxygen/httpserver/ResponseHandler.h>
 
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -93,14 +94,14 @@ class ResponseBuilder {
 
   template <typename T>
   ResponseBuilder& header(const std::string& headerIn, const T& value) {
-    CHECK(headers_) << "You need to call `status` before adding headers";
+    PRX_CHECK(headers_) << "You need to call `status` before adding headers";
     headers_->getHeaders().add(headerIn, value);
     return *this;
   }
 
   template <typename T>
   ResponseBuilder& header(HTTPHeaderCode code, const T& value) {
-    CHECK(headers_) << "You need to call `status` before adding headers";
+    PRX_CHECK(headers_) << "You need to call `status` before adding headers";
     headers_->getHeaders().add(code, value);
     return *this;
   }
@@ -200,7 +201,7 @@ class ResponseBuilder {
     if (upgradeType == UpgradeType::CONNECT_REQUEST) {
       headers_->constructDirectResponse({1, 1}, 200, "OK");
     } else {
-      CHECK(!upgradeProtocol.empty());
+      PRX_CHECK(!upgradeProtocol.empty());
       headers_->constructDirectResponse({1, 1}, 101, "Switching Protocols");
       headers_->getHeaders().add(HTTP_HEADER_UPGRADE, upgradeProtocol);
       headers_->getHeaders().add(HTTP_HEADER_CONNECTION, "Upgrade");
diff --git a/proxygen/httpserver/ResponseHandler.h b/proxygen/httpserver/ResponseHandler.h
index 775c4daf07..5e89932beb 100644
--- a/proxygen/httpserver/ResponseHandler.h
+++ b/proxygen/httpserver/ResponseHandler.h
@@ -10,6 +10,7 @@
 
 #include <folly/Expected.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -43,7 +44,7 @@ class PushHandler;
 class ResponseHandler {
  public:
   explicit ResponseHandler(RequestHandler* upstream)
-      : upstream_(CHECK_NOTNULL(upstream)) {
+      : upstream_(PRX_CHECK_NOTNULL(upstream)) {
   }
 
   virtual ~ResponseHandler() = default;
diff --git a/proxygen/httpserver/ScopedHTTPServer.h b/proxygen/httpserver/ScopedHTTPServer.h
index 3ce7bcf0cd..450c3aaf47 100644
--- a/proxygen/httpserver/ScopedHTTPServer.h
+++ b/proxygen/httpserver/ScopedHTTPServer.h
@@ -14,6 +14,7 @@
 #include <folly/system/ThreadName.h>
 #include <proxygen/httpserver/HTTPServer.h>
 #include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -125,7 +126,7 @@ class ScopedHTTPServer final {
    */
   [[nodiscard]] std::vector<HTTPServer::IPConfig> getAddresses() const {
     auto addresses = server_->addresses();
-    CHECK(!addresses.empty());
+    PRX_CHECK(!addresses.empty());
     return addresses;
   }
 
diff --git a/proxygen/httpserver/filters/CompressionFilter.h b/proxygen/httpserver/filters/CompressionFilter.h
index a986022e74..64281b74f5 100644
--- a/proxygen/httpserver/filters/CompressionFilter.h
+++ b/proxygen/httpserver/filters/CompressionFilter.h
@@ -11,6 +11,7 @@
 #include <proxygen/httpserver/Filters.h>
 #include <proxygen/httpserver/RequestHandlerFactory.h>
 #include <proxygen/lib/utils/CompressionFilterUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -33,8 +34,8 @@ class CompressionFilter : public Filter {
   CompressionFilter& operator=(CompressionFilter&&) = delete;
 
   void sendHeaders(HTTPMessage& msg) noexcept override {
-    DCHECK(compressor_ == nullptr);
-    DCHECK(header_ == false);
+    PRX_DCHECK(compressor_ == nullptr);
+    PRX_DCHECK(header_ == false);
 
     chunked_ = msg.getIsChunked();
     compress_ = CompressionFilterUtils::shouldCompress(msg, params_);
@@ -63,7 +64,7 @@ class CompressionFilter : public Filter {
 
   void sendChunkHeader(size_t len) noexcept override {
     // The headers should have always been sent since the message is chunked
-    DCHECK_EQ(header_, true) << "Headers should have already been sent.";
+    PRX_DCHECK_EQ(header_, true) << "Headers should have already been sent.";
 
     // If not compressing, pass downstream, otherwise "swallow" it
     // to send after compressing the body.
@@ -79,12 +80,12 @@ class CompressionFilter : public Filter {
   void sendBody(std::unique_ptr<folly::IOBuf> body) noexcept override {
     // If not compressing, pass the body through
     if (!compress_) {
-      DCHECK(header_ == true);
+      PRX_DCHECK(header_ == true);
       Filter::sendBody(std::move(body));
       return;
     }
 
-    CHECK(compressor_ && !compressor_->hasError());
+    PRX_CHECK(compressor_ && !compressor_->hasError());
 
     // If it's chunked, never write the trailer, it will be written on EOM
     auto compressed = compressor_->compress(body.get(), !chunked_);
@@ -99,8 +100,8 @@ class CompressionFilter : public Filter {
       Filter::sendChunkHeader(compressedBodyLength);
     } else {
       // Send the content length on compressed, non-chunked messages
-      DCHECK(header_ == false);
-      DCHECK(compress_ == true);
+      PRX_DCHECK(header_ == false);
+      PRX_DCHECK(compress_ == true);
       auto& headers = responseMessage_->getHeaders();
       headers.set(HTTP_HEADER_CONTENT_LENGTH,
                   folly::to<std::string>(compressedBodyLength));
@@ -117,7 +118,7 @@ class CompressionFilter : public Filter {
     // Need to send the trailer for compressed chunked messages
     if (compress_ && chunked_) {
       folly::IOBuf emptyBuf{};
-      CHECK(compressor_ && !compressor_->hasError());
+      PRX_CHECK(compressor_ && !compressor_->hasError());
       auto compressed = compressor_->compress(&emptyBuf, true);
 
       if (compressor_->hasError()) {
diff --git a/proxygen/httpserver/filters/RejectConnectFilter.h b/proxygen/httpserver/filters/RejectConnectFilter.h
index ff6e778346..9596b2c6ac 100644
--- a/proxygen/httpserver/filters/RejectConnectFilter.h
+++ b/proxygen/httpserver/filters/RejectConnectFilter.h
@@ -11,6 +11,7 @@
 #include <proxygen/httpserver/Filters.h>
 #include <proxygen/httpserver/RequestHandlerFactory.h>
 #include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -39,7 +40,7 @@ class RejectConnectFilter : public Filter {
   }
 
   void requestComplete() noexcept override {
-    CHECK(!upstream_);
+    PRX_CHECK(!upstream_);
     delete this;
   }
 
diff --git a/proxygen/httpserver/samples/echo/EchoServer.cpp b/proxygen/httpserver/samples/echo/EchoServer.cpp
index c2b6e49798..cfdd76cd3b 100644
--- a/proxygen/httpserver/samples/echo/EchoServer.cpp
+++ b/proxygen/httpserver/samples/echo/EchoServer.cpp
@@ -16,6 +16,7 @@
 
 #include "EchoHandler.h"
 #include "EchoStats.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace EchoService;
 using namespace proxygen;
@@ -62,7 +63,7 @@ int main(int argc, char* argv[]) {
 
   if (FLAGS_threads <= 0) {
     FLAGS_threads = folly::available_concurrency();
-    CHECK(FLAGS_threads > 0);
+    PRX_CHECK(FLAGS_threads > 0);
   }
 
   HTTPServerOptions options;
diff --git a/proxygen/httpserver/samples/hq/CMakeLists.txt b/proxygen/httpserver/samples/hq/CMakeLists.txt
index 947ad0ea20..f2cc9914af 100644
--- a/proxygen/httpserver/samples/hq/CMakeLists.txt
+++ b/proxygen/httpserver/samples/hq/CMakeLists.txt
@@ -30,6 +30,7 @@ proxygen_add_library(proxygen_hq_server
   DEPS
     proxygen_hq_logger_helper
     proxygen_http_session_hq_downstream_session
+    proxygen_utils_log_shim
     mvfst::mvfst_common_udpsocket_folly_async_udp_socket
     fizz::fizz
     Folly::folly_file_util
@@ -72,6 +73,7 @@ proxygen_add_library(proxygen_hq_samples
     proxygen_http_session_hq_session
     proxygen_webtransport
     proxygen_transport_persistent_quic_psk_cache
+    proxygen_utils_log_shim
     proxygen_utils_logging
     proxygen_utils_util_inl
     mvfst::mvfst_constants
diff --git a/proxygen/httpserver/samples/hq/ConnIdLogger.h b/proxygen/httpserver/samples/hq/ConnIdLogger.h
index d3a9155d90..0068512a8e 100644
--- a/proxygen/httpserver/samples/hq/ConnIdLogger.h
+++ b/proxygen/httpserver/samples/hq/ConnIdLogger.h
@@ -8,7 +8,7 @@
 
 #pragma once
 #include <gflags/gflags.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <cctype>
 #include <folly/Conv.h>
diff --git a/proxygen/httpserver/samples/hq/H1QDownstreamSession.h b/proxygen/httpserver/samples/hq/H1QDownstreamSession.h
index d1a8763d93..78542977d2 100644
--- a/proxygen/httpserver/samples/hq/H1QDownstreamSession.h
+++ b/proxygen/httpserver/samples/hq/H1QDownstreamSession.h
@@ -10,6 +10,7 @@
 
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
 #include <proxygen/lib/http/session/HTTPDownstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/api/QuicStreamAsyncTransport.h>
 #include <quic/common/events/FollyQuicEventBase.h>
@@ -39,7 +40,7 @@ class H1QDownstreamSession : public quic::QuicSocket::ConnectionCallback {
     auto streamTransport =
         quic::QuicStreamAsyncTransport::createWithExistingStream(sock_, id);
     if (!streamTransport) {
-      LOG(ERROR) << "Failed to create stream transport";
+      PRX_LOG(ERROR) << "Failed to create stream transport";
       sock_->stopSending(
           id,
           quic::ApplicationErrorCode(
@@ -81,15 +82,15 @@ class H1QDownstreamSession : public quic::QuicSocket::ConnectionCallback {
                      quic::ApplicationErrorCode) noexcept override {
   }
   void onConnectionEnd() noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
   void onConnectionError(quic::QuicError) noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
   void onConnectionEnd(quic::QuicError /* error */) noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
 
diff --git a/proxygen/httpserver/samples/hq/H1QUpstreamSession.h b/proxygen/httpserver/samples/hq/H1QUpstreamSession.h
index 187d62017b..fe2be2736a 100644
--- a/proxygen/httpserver/samples/hq/H1QUpstreamSession.h
+++ b/proxygen/httpserver/samples/hq/H1QUpstreamSession.h
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
 #include <proxygen/lib/http/session/HTTPUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/api/QuicStreamAsyncTransport.h>
 #include <quic/common/events/FollyQuicEventBase.h>
@@ -41,7 +42,7 @@ class H1QUpstreamSession
     auto streamTransport =
         quic::QuicStreamAsyncTransport::createWithNewStream(sock_);
     if (!streamTransport) {
-      LOG(ERROR) << "Failed to create stream transport";
+      PRX_LOG(ERROR) << "Failed to create stream transport";
       return nullptr;
     }
     auto codec = std::make_unique<proxygen::HTTP1xCodec>(
@@ -101,16 +102,16 @@ class H1QUpstreamSession
                      quic::ApplicationErrorCode) noexcept override {
   }
   void onConnectionEnd() noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
   using proxygen::HTTPSessionBase::InfoCallback::onConnectionError;
   void onConnectionError(quic::QuicError) noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
   void onConnectionEnd(quic::QuicError /* error */) noexcept override {
-    LOG(INFO) << __func__;
+    PRX_LOG(INFO) << __func__;
     delete this;
   }
 
diff --git a/proxygen/httpserver/samples/hq/HQClient.cpp b/proxygen/httpserver/samples/hq/HQClient.cpp
index 10f6819968..b23670c39a 100644
--- a/proxygen/httpserver/samples/hq/HQClient.cpp
+++ b/proxygen/httpserver/samples/hq/HQClient.cpp
@@ -21,6 +21,7 @@
 #include <proxygen/httpserver/samples/hq/H1QUpstreamSession.h>
 #include <proxygen/httpserver/samples/hq/HQLoggerHelper.h>
 #include <proxygen/httpserver/samples/hq/InsecureVerifierDangerousDoNotUseInProduction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/UtilInl.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/client/QuicClientTransport.h>
@@ -44,14 +45,15 @@ int HQClient::start(const folly::SocketAddress& localAddress) {
   initializeQLogger();
 
   // TODO: turn on cert verification
-  LOG(INFO) << "HQClient connecting to " << params_.remoteAddress->describe();
+  PRX_LOG(INFO) << "HQClient connecting to "
+                << params_.remoteAddress->describe();
   quicClient_->start(this, nullptr);
   evb_.loop();
   return failed_ ? -1 : 0;
 }
 
 void HQClient::onConnectionSetupError(quic::QuicError code) noexcept {
-  LOG(ERROR) << "Failed to establish QUIC connection: " << code.message;
+  PRX_LOG(ERROR) << "Failed to establish QUIC connection: " << code.message;
   quicClient_->setConnectionSetupCallback(nullptr);
   connectError(code);
 }
@@ -129,8 +131,8 @@ HQClient::sendRequest(const proxygen::URL& requestUrl) {
     filename = folly::to<std::string>(params_.outdir, "/", filename);
     canWrite = client->saveResponseToFile(filename);
     if (!canWrite) {
-      LOG(ERROR) << "Can not write output to file '" << filename
-                 << "' printing to stdout instead";
+      PRX_LOG(ERROR) << "Can not write output to file '" << filename
+                     << "' printing to stdout instead";
     }
   }
   client->sendRequest(txn);
@@ -152,7 +154,7 @@ void HQClient::drainSession() {
 }
 
 void HQClient::sendRequests(bool closeSession, uint64_t numOpenableStreams) {
-  VLOG(10) << "http-version:" << params_.httpVersion;
+  PRX_VLOG(10) << "http-version:" << params_.httpVersion;
   do {
     proxygen::URL requestUrl(httpPaths_.front().str(), /*secure=*/true);
     sendRequest(requestUrl);
@@ -174,10 +176,10 @@ void HQClient::sendRequests(bool closeSession, uint64_t numOpenableStreams) {
                                ? "0.0.0.0"
                                : "::";
         auto bindRes = newSock->bind(folly::SocketAddress(bindAddress, 0));
-        CHECK(!bindRes.hasError());
+        PRX_CHECK(!bindRes.hasError());
         auto startProbeRes =
             quicClient_->startPathProbe(std::move(newSock), this);
-        CHECK(!startProbeRes.hasError()) << startProbeRes.error();
+        PRX_CHECK(!startProbeRes.hasError()) << startProbeRes.error();
       }
       std::chrono::milliseconds gap = requestGaps_.front();
       requestGaps_.pop_front();
@@ -199,7 +201,7 @@ void HQClient::sendRequests(bool closeSession, uint64_t numOpenableStreams) {
         };
       }
     };
-    CHECK(!curls_.empty());
+    PRX_CHECK(!curls_.empty());
     curls_.back()->setEOMFunc(callSendRequestsAfterADelay);
   }
 }
@@ -211,7 +213,7 @@ void HQClient::connectSuccess() {
   }
   uint64_t numOpenableStreams =
       quicClient_->getNumOpenableBidirectionalStreams();
-  CHECK_GT(numOpenableStreams, 0);
+  PRX_CHECK_GT(numOpenableStreams, 0u);
   httpPaths_.insert(
       httpPaths_.end(), params_.httpPaths.begin(), params_.httpPaths.end());
   for (auto const& s : params_.requestGaps) {
@@ -250,7 +252,7 @@ void HQClient::connectSuccess() {
             std::max(rtt, std::chrono::milliseconds(1)));
       }
     };
-    CHECK(!curls_.empty());
+    PRX_CHECK(!curls_.empty());
     curls_.back()->setEOMFunc(selfSchedulingRequestRunner);
   }
 }
@@ -264,23 +266,24 @@ void HQClient::sendKnobFrame(const folly::StringPiece str) {
   BufPtr buf(folly::IOBuf::create(str.size()));
   memcpy(buf->writableData(), str.data(), str.size());
   buf->append(str.size());
-  VLOG(10) << "Sending Knob Frame to peer. KnobSpace: " << std::hex << knobSpace
-           << " KnobId: " << std::dec << knobId << " Knob Blob" << str;
+  PRX_VLOG(10) << "Sending Knob Frame to peer. KnobSpace: " << std::hex
+               << knobSpace << " KnobId: " << std::dec << knobId << " Knob Blob"
+               << str;
   const auto knobSent = quicClient_->setKnob(0xfaceb00c, 100, std::move(buf));
   if (knobSent.hasError()) {
-    LOG(ERROR) << "Failed to send Knob frame to peer. Received error: "
-               << knobSent.error();
+    PRX_LOG(ERROR) << "Failed to send Knob frame to peer. Received error: "
+                   << knobSent.error();
   }
 }
 
 void HQClient::onReplaySafe() noexcept {
-  VLOG(4) << "Transport replay safe";
+  PRX_VLOG(4) << "Transport replay safe";
   replaySafe_ = true;
 }
 
 void HQClient::connectError(const quic::QuicError& error) {
-  LOG(ERROR) << "HQClient failed to connect, error=" << toString(error.code)
-             << ", msg=" << error.message;
+  PRX_LOG(ERROR) << "HQClient failed to connect, error=" << toString(error.code)
+                 << ", msg=" << error.message;
   failed_ = true;
   evb_.terminateLoopSoon();
 }
@@ -348,20 +351,21 @@ void HQClient::initializeQLogger() {
 
 void HQClient::onPathValidationResult(const PathInfo& pathInfo) {
   if (pathInfo.status == PathStatus::Validated) {
-    LOG(INFO) << fmt::format(
+    PRX_LOG(INFO) << fmt::format(
         "Path probe successful. Migrating connection to: local address = {}, "
         "peer address = {}",
         pathInfo.localAddress.describe(),
         pathInfo.peerAddress.describe());
     auto migrationRes = quicClient_->migrateConnection(pathInfo.id);
     if (migrationRes.hasError()) {
-      LOG(ERROR) << "Failed to migrate connection: " << migrationRes.error();
+      PRX_LOG(ERROR) << "Failed to migrate connection: "
+                     << migrationRes.error();
     }
   } else {
-    LOG(ERROR) << "Path probe timed out. Deleting the path.";
+    PRX_LOG(ERROR) << "Path probe timed out. Deleting the path.";
     auto removeRes = quicClient_->removePath(pathInfo.id);
     if (removeRes.hasError()) {
-      LOG(ERROR) << "Failed to remove path: " << removeRes.error();
+      PRX_LOG(ERROR) << "Failed to remove path: " << removeRes.error();
       failed_ = true;
       evb_.terminateLoopSoon();
     }
diff --git a/proxygen/httpserver/samples/hq/HQClient.h b/proxygen/httpserver/samples/hq/HQClient.h
index e1d9447f4c..9a8daded7c 100644
--- a/proxygen/httpserver/samples/hq/HQClient.h
+++ b/proxygen/httpserver/samples/hq/HQClient.h
@@ -17,6 +17,7 @@
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
 #include <proxygen/lib/http/session/HQUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/common/events/HighResQuicTimer.h>
 
 namespace quic {
@@ -71,7 +72,7 @@ class HQClient
     }
 
     void onReplaySafe() override {
-      VLOG(4) << "Connect Callback Replay Safe";
+      PRX_VLOG(4) << "Connect Callback Replay Safe";
       client_.onReplaySafe();
     }
 
diff --git a/proxygen/httpserver/samples/hq/HQCommandLine.cpp b/proxygen/httpserver/samples/hq/HQCommandLine.cpp
index 6dfb0ea4c4..7a391f59e7 100644
--- a/proxygen/httpserver/samples/hq/HQCommandLine.cpp
+++ b/proxygen/httpserver/samples/hq/HQCommandLine.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/httpclient/samples/curl/CurlClient.h>
 #include <proxygen/lib/http/SynchronizedLruQuicPskCache.h>
 #include <proxygen/lib/transport/PersistentQuicPskCache.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/QuicConstants.h>
 
 DEFINE_string(host, "::1", "HQ server hostname/IP");
@@ -213,7 +214,7 @@ namespace {
 void initializeCommonSettings(HQToolParams& hqParams) {
   // General section
   if (FLAGS_mode == "server") {
-    CHECK(FLAGS_local_address.empty())
+    PRX_CHECK(FLAGS_local_address.empty())
         << "local_address only allowed in client mode";
     hqParams.setMode(HQMode::SERVER);
     hqParams.logprefix = "server";
@@ -301,7 +302,7 @@ void initializeTransportSettings(HQToolParams& hqUberParams) {
         quic::DataPathType::ContinuousMemory;
   }
   if (FLAGS_rate_limit >= 0) {
-    CHECK(hqUberParams.mode == HQMode::SERVER);
+    PRX_CHECK(hqUberParams.mode == HQMode::SERVER);
     std::get<HQToolServerParams>(hqUberParams.params).rateLimitPerThread =
         FLAGS_rate_limit;
 
@@ -320,8 +321,9 @@ void initializeTransportSettings(HQToolParams& hqUberParams) {
                                                 FLAGS_transport_knobs});
   }
   if (FLAGS_quic_experiment != 0) {
-    CHECK_GT(FLAGS_quic_experiment, 0) << "--quic_experiment must be positive";
-    CHECK_LE(FLAGS_quic_experiment, 65535)
+    PRX_CHECK_GT(FLAGS_quic_experiment, 0)
+        << "--quic_experiment must be positive";
+    PRX_CHECK_LE(FLAGS_quic_experiment, 65535)
         << "--quic_experiment must fit in uint16_t";
     hqParams.transportSettings.quicExperimentId =
         static_cast<uint16_t>(FLAGS_quic_experiment);
@@ -517,7 +519,8 @@ HQToolParamsBuilderFromCmdline::HQToolParamsBuilderFromCmdline(
   gflags::FlagSaver saver;
 
   for (auto& kv : initial) {
-    LOG(INFO) << "Overriding HQToolParams " << kv.first << " to " << kv.second;
+    PRX_LOG(INFO) << "Overriding HQToolParams " << kv.first << " to "
+                  << kv.second;
     gflags::SetCommandLineOptionWithMode(
         kv.first.c_str(),
         kv.second.c_str(),
diff --git a/proxygen/httpserver/samples/hq/HQCommandLine.h b/proxygen/httpserver/samples/hq/HQCommandLine.h
index 00ab19968d..d4d928afdb 100644
--- a/proxygen/httpserver/samples/hq/HQCommandLine.h
+++ b/proxygen/httpserver/samples/hq/HQCommandLine.h
@@ -10,6 +10,7 @@
 
 #include <proxygen/httpserver/HTTPServerOptions.h>
 #include <proxygen/httpserver/samples/hq/HQParams.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <variant>
 
 namespace quic::samples {
@@ -75,7 +76,7 @@ struct HQToolParams {
     } else if (mode == HQMode::SERVER) {
       return (HQBaseParams&)std::get<HQToolServerParams>(params);
     }
-    LOG(FATAL) << "Uninit";
+    PRX_LOG(FATAL) << "Uninit";
   }
 
   HQBaseParams& baseParams() {
@@ -84,7 +85,7 @@ struct HQToolParams {
     } else if (mode == HQMode::SERVER) {
       return (HQBaseParams&)std::get<HQToolServerParams>(params);
     }
-    LOG(FATAL) << "Uninit";
+    PRX_LOG(FATAL) << "Uninit";
   }
 
   HQMode mode{HQMode::INVALID};
diff --git a/proxygen/httpserver/samples/hq/HQParams.cpp b/proxygen/httpserver/samples/hq/HQParams.cpp
index 62711bab57..2c0a2db6cc 100644
--- a/proxygen/httpserver/samples/hq/HQParams.cpp
+++ b/proxygen/httpserver/samples/hq/HQParams.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/httpserver/samples/hq/HQParams.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace quic::samples {
 
@@ -22,8 +23,8 @@ bool HTTPVersion::parse(const std::string& verString) {
   std::string delimiter = ".";
   std::size_t pos = version.find(delimiter);
   if (pos == std::string::npos) {
-    LOG(ERROR) << "Invalid http-version string: " << version
-               << ", defaulting to HTTP/1.1";
+    PRX_LOG(ERROR) << "Invalid http-version string: " << version
+                   << ", defaulting to HTTP/1.1";
     major = 1;
     minor = 1;
     canonical = folly::to<std::string>(major, ".", minor);
@@ -38,8 +39,8 @@ bool HTTPVersion::parse(const std::string& verString) {
     canonical = folly::to<std::string>(major, ".", minor);
     return true;
   } catch (const folly::ConversionError&) {
-    LOG(ERROR) << "Invalid http-version string: " << version
-               << ", defaulting to HTTP/1.1";
+    PRX_LOG(ERROR) << "Invalid http-version string: " << version
+                   << ", defaulting to HTTP/1.1";
     major = 1;
     minor = 1;
     canonical = folly::to<std::string>(major, ".", minor);
diff --git a/proxygen/httpserver/samples/hq/HQServer.cpp b/proxygen/httpserver/samples/hq/HQServer.cpp
index e328b03488..8bddcf97b5 100644
--- a/proxygen/httpserver/samples/hq/HQServer.cpp
+++ b/proxygen/httpserver/samples/hq/HQServer.cpp
@@ -20,6 +20,7 @@
 #include <proxygen/httpserver/samples/hq/H1QDownstreamSession.h>
 #include <proxygen/httpserver/samples/hq/HQLoggerHelper.h>
 #include <proxygen/lib/http/session/HQDownstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/server/QuicSharedUDPSocketFactory.h>
 
 using fizz::server::FizzServerContext;
@@ -232,7 +233,7 @@ void HQServerTransportFactory::onQuicTransportReady(
 
 void HQServerTransportFactory::onConnectionSetupError(
     std::shared_ptr<quic::QuicSocket>, quic::QuicError code) {
-  LOG(ERROR) << "Failed to accept QUIC connection: " << code.message;
+  PRX_LOG(ERROR) << "Failed to accept QUIC connection: " << code.message;
 }
 
 wangle::ConnectionManager* HQServerTransportFactory::getConnectionManager(
@@ -319,8 +320,8 @@ HQServer::HQServer(
 
   server_->setQuicExperimentHandlerFn(
       [](quic::QuicConnectionStateBase& /* conn */, uint16_t experimentId) {
-        VLOG(2) << "quic_experiment handler fired: experimentId="
-                << experimentId;
+        PRX_VLOG(2) << "quic_experiment handler fired: experimentId="
+                    << experimentId;
       });
 
   // Apply UDP socket buffer size options if specified
@@ -363,7 +364,7 @@ void HQServer::start(const folly::SocketAddress& localAddress,
 const folly::SocketAddress HQServer::getAddress() const {
   server_->waitUntilInitialized();
   const auto& boundAddr = server_->getAddress();
-  LOG(INFO) << "HQ server started at: " << boundAddr.describe();
+  PRX_LOG(INFO) << "HQ server started at: " << boundAddr.describe();
   return boundAddr;
 }
 
diff --git a/proxygen/httpserver/samples/hq/HQServer.h b/proxygen/httpserver/samples/hq/HQServer.h
index 500017558b..6b3ee4bd9f 100644
--- a/proxygen/httpserver/samples/hq/HQServer.h
+++ b/proxygen/httpserver/samples/hq/HQServer.h
@@ -17,6 +17,7 @@
 #include <proxygen/httpserver/samples/hq/HQParams.h>
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/server/QuicHandshakeSocketHolder.h>
 #include <quic/server/QuicServer.h>
 #include <quic/state/EarlyDataAppParamsHandler.h>
@@ -65,7 +66,7 @@ class HQServer {
 
   void setStatsFactory(
       std::unique_ptr<quic::QuicTransportStatsCallbackFactory>&& statsFactory) {
-    CHECK(server_);
+    PRX_CHECK(server_);
     server_->setTransportStatsCallbackFactory(std::move(statsFactory));
   }
 
diff --git a/proxygen/httpserver/samples/hq/HQServerModule.cpp b/proxygen/httpserver/samples/hq/HQServerModule.cpp
index 099c4840dc..c6c4bc5e34 100644
--- a/proxygen/httpserver/samples/hq/HQServerModule.cpp
+++ b/proxygen/httpserver/samples/hq/HQServerModule.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/httpserver/samples/hq/HQServerModule.h>
 #include <proxygen/httpserver/samples/hq/SampleHandlers.h>
 #include <proxygen/lib/http/session/HQSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 
@@ -25,12 +26,13 @@ void sendKnobFrame(HQSession* session, const folly::StringPiece str) {
   quic::BufPtr buf(folly::IOBuf::create(str.size()));
   memcpy(buf->writableData(), str.data(), str.size());
   buf->append(str.size());
-  VLOG(10) << "Sending Knob Frame to peer. KnobSpace: " << std::hex << knobSpace
-           << " KnobId: " << std::dec << knobId << " Knob Blob" << str;
+  PRX_VLOG(10) << "Sending Knob Frame to peer. KnobSpace: " << std::hex
+               << knobSpace << " KnobId: " << std::dec << knobId << " Knob Blob"
+               << str;
   const auto knobSent = session->sendKnob(0xfaceb00c, 200, std::move(buf));
   if (knobSent.hasError()) {
-    LOG(ERROR) << "Failed to send Knob frame to peer. Received error: "
-               << knobSent.error();
+    PRX_LOG(ERROR) << "Failed to send Knob frame to peer. Received error: "
+                   << knobSent.error();
   }
 }
 } // namespace
diff --git a/proxygen/httpserver/samples/hq/SampleHandlers.cpp b/proxygen/httpserver/samples/hq/SampleHandlers.cpp
index 57fd27475c..c1b969f637 100644
--- a/proxygen/httpserver/samples/hq/SampleHandlers.cpp
+++ b/proxygen/httpserver/samples/hq/SampleHandlers.cpp
@@ -10,6 +10,7 @@
 #include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
 
 #include <folly/String.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Logging.h>
 #include <string>
 
@@ -26,7 +27,7 @@ namespace quic::samples {
 using namespace proxygen;
 
 HTTPTransactionHandler* Dispatcher::getRequestHandler(HTTPMessage* msg) {
-  DCHECK(msg);
+  PRX_DCHECK(msg);
   auto path = msg->getPathAsStringPiece();
   if (path == "/" || path == "/echo") {
     return new EchoHandler(params_);
@@ -97,7 +98,7 @@ std::mutex& WaitReleaseHandler::getMutex() {
 
 void WaitReleaseHandler::onHeadersComplete(
     std::unique_ptr<proxygen::HTTPMessage> msg) noexcept {
-  VLOG(10) << "WaitReleaseHandler::onHeadersComplete";
+  PRX_VLOG(10) << "WaitReleaseHandler::onHeadersComplete";
   msg->dumpMessage(2);
   path_ = msg->getPath();
   auto idstr = msg->getQueryParam("id");
@@ -157,20 +158,20 @@ class ServerPushHandler;
 
 void ServerPushHandler::onHeadersComplete(
     std::unique_ptr<proxygen::HTTPMessage> msg) noexcept {
-  VLOG(10) << "ServerPushHandler::" << __func__;
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__;
   msg->dumpMessage(2);
   path_ = msg->getPath();
 
   if (msg->getMethod() != proxygen::HTTPMethod::GET) {
-    LOG(ERROR) << "Method not supported";
+    PRX_LOG(ERROR) << "Method not supported";
     sendErrorResponse("bad request\n");
     return;
   }
 
-  VLOG(2) << "Received GET request for " << path_ << " at: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 std::chrono::steady_clock::now().time_since_epoch())
-                 .count();
+  PRX_VLOG(2) << "Received GET request for " << path_ << " at: "
+              << std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now().time_since_epoch())
+                     .count();
 
   std::string gPushResponseBody;
   std::vector<std::string> pathPieces;
@@ -182,7 +183,7 @@ void ServerPushHandler::onHeadersComplete(
     auto sizeFromPath = folly::tryTo<int>(pathPieces[2]);
     responseSize = sizeFromPath.value_or(0);
     if (responseSize != 0) {
-      VLOG(2) << "Requested a response size of " << responseSize;
+      PRX_VLOG(2) << "Requested a response size of " << responseSize;
       gPushResponseBody = std::string(responseSize, 'a');
     }
   }
@@ -190,11 +191,11 @@ void ServerPushHandler::onHeadersComplete(
   if (pathPieces.size() > 3) {
     auto numResponsesFromPath = folly::tryTo<int>(pathPieces[3]);
     numResponses = numResponsesFromPath.value_or(1);
-    VLOG(2) << "Requested a repeat count of " << numResponses;
+    PRX_VLOG(2) << "Requested a repeat count of " << numResponses;
   }
 
   for (int i = 0; i < numResponses; ++i) {
-    VLOG(2) << "Sending push txn " << i << "/" << numResponses;
+    PRX_VLOG(2) << "Sending push txn " << i << "/" << numResponses;
 
     // Create a URL for the pushed resource
     auto pushedResourceUrl =
@@ -204,7 +205,7 @@ void ServerPushHandler::onHeadersComplete(
     auto pushedTxn = txn_->newPushedTransaction(&pushTxnHandler_);
 
     if (!pushedTxn) {
-      LOG(ERROR) << "Could not create push txn; stop pushing";
+      PRX_LOG(ERROR) << "Could not create push txn; stop pushing";
       break;
     }
 
@@ -223,7 +224,7 @@ void ServerPushHandler::onHeadersComplete(
 
 void ServerPushHandler::sendPushPromise(proxygen::HTTPTransaction* txn,
                                         const std::string& pushedResourceUrl) {
-  VLOG(10) << "ServerPushHandler::" << __func__;
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__;
   proxygen::HTTPMessage promise;
   promise.setMethod("GET");
   promise.setURL(pushedResourceUrl);
@@ -231,17 +232,17 @@ void ServerPushHandler::sendPushPromise(proxygen::HTTPTransaction* txn,
   promise.setIsChunked(true);
   txn->sendHeaders(promise);
 
-  VLOG(2) << "Sent push promise for " << pushedResourceUrl << " at: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 std::chrono::steady_clock::now().time_since_epoch())
-                 .count();
+  PRX_VLOG(2) << "Sent push promise for " << pushedResourceUrl << " at: "
+              << std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now().time_since_epoch())
+                     .count();
 }
 
 void ServerPushHandler::sendPushResponse(proxygen::HTTPTransaction* pushTxn,
                                          const std::string& pushedResourceUrl,
                                          const std::string& pushedResourceBody,
                                          bool eom) {
-  VLOG(10) << "ServerPushHandler::" << __func__;
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__;
   proxygen::HTTPMessage resp = createHttpResponse(200, "OK");
   resp.setWantsKeepalive(true);
   resp.setIsChunked(true);
@@ -252,17 +253,17 @@ void ServerPushHandler::sendPushResponse(proxygen::HTTPTransaction* pushTxn,
       pushedResourceBody;
   pushTxn->sendBody(folly::IOBuf::copyBuffer(responseStr));
 
-  VLOG(2) << "Sent push response for " << pushedResourceUrl << " at: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 std::chrono::steady_clock::now().time_since_epoch())
-                 .count();
+  PRX_VLOG(2) << "Sent push response for " << pushedResourceUrl << " at: "
+              << std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now().time_since_epoch())
+                     .count();
 
   if (eom) {
     pushTxn->sendEOM();
-    VLOG(2) << "Sent EOM for " << pushedResourceUrl << " at: "
-            << std::chrono::duration_cast<std::chrono::microseconds>(
-                   std::chrono::steady_clock::now().time_since_epoch())
-                   .count();
+    PRX_VLOG(2) << "Sent EOM for " << pushedResourceUrl << " at: "
+                << std::chrono::duration_cast<std::chrono::microseconds>(
+                       std::chrono::steady_clock::now().time_since_epoch())
+                       .count();
   }
 }
 
@@ -275,8 +276,8 @@ void ServerPushHandler::sendErrorResponse(const std::string& body) {
 }
 
 void ServerPushHandler::sendOkResponse(const std::string& body, bool eom) {
-  VLOG(10) << "ServerPushHandler::" << __func__ << ": sending " << body.length()
-           << " bytes";
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__ << ": sending "
+               << body.length() << " bytes";
   proxygen::HTTPMessage resp = createHttpResponse(200, "OK");
   resp.setWantsKeepalive(true);
   resp.setIsChunked(true);
@@ -289,24 +290,24 @@ void ServerPushHandler::sendOkResponse(const std::string& body, bool eom) {
 
 void ServerPushHandler::onBody(
     std::unique_ptr<folly::IOBuf> /*chain*/) noexcept {
-  VLOG(10) << "ServerPushHandler::" << __func__ << " - ignoring";
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__ << " - ignoring";
 }
 
 void ServerPushHandler::onEOM() noexcept {
-  VLOG(10) << "ServerPushHandler::" << __func__ << " - ignoring";
+  PRX_VLOG(10) << "ServerPushHandler::" << __func__ << " - ignoring";
 }
 
 void ServerPushHandler::onError(const proxygen::HTTPException& error) noexcept {
-  VLOG(10) << "ServerPushHandler::onError error=" << error.what();
+  PRX_VLOG(10) << "ServerPushHandler::onError error=" << error.what();
 }
 
 void DeviousBatonHandler::onHeadersComplete(
     std::unique_ptr<proxygen::HTTPMessage> msg) noexcept {
-  VLOG(10) << "WebtransHandler::" << __func__;
+  PRX_VLOG(10) << "WebtransHandler::" << __func__;
   msg->dumpMessage(2);
 
   if (msg->getMethod() != proxygen::HTTPMethod::CONNECT) {
-    LOG(ERROR) << "Method not supported";
+    PRX_LOG(ERROR) << "Method not supported";
     proxygen::HTTPMessage resp;
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(400);
@@ -318,11 +319,11 @@ void DeviousBatonHandler::onHeadersComplete(
     return;
   }
 
-  VLOG(2) << "Received CONNECT request for " << msg->getPathAsStringPiece()
-          << " at: "
-          << std::chrono::duration_cast<std::chrono::microseconds>(
-                 std::chrono::steady_clock::now().time_since_epoch())
-                 .count();
+  PRX_VLOG(2) << "Received CONNECT request for " << msg->getPathAsStringPiece()
+              << " at: "
+              << std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::steady_clock::now().time_since_epoch())
+                     .count();
 
   auto status = 500;
   auto wt = txn_->getWebTransport();
@@ -368,7 +369,7 @@ void DeviousBatonHandler::onHeadersComplete(
       // param
       HTTPWebTransport::setWTProtocol(resp, wtProtocol.value());
     } else {
-      VLOG(4) << "Failed to negotiate WebTransport protocol";
+      PRX_VLOG(4) << "Failed to negotiate WebTransport protocol";
       resp.setStatusCode(400);
     }
   }
@@ -393,11 +394,11 @@ void DeviousBatonHandler::readHandler(
     uint64_t id,
     folly::Try<WebTransport::StreamData> streamData) {
   if (streamData.hasException()) {
-    VLOG(4) << "read error=" << streamData.exception().what();
+    PRX_VLOG(4) << "read error=" << streamData.exception().what();
     return;
   }
 
-  VLOG(4) << "read data id=" << id;
+  PRX_VLOG(4) << "read data id=" << id;
 
   devious_->onStreamData(
       id, streams_[id], std::move(streamData->data), streamData->fin);
@@ -415,7 +416,7 @@ void DeviousBatonHandler::readHandler(
 
 void DeviousBatonHandler::onWebTransportBidiStream(
     HTTPCodec::StreamID id, WebTransport::BidiStreamHandle stream) noexcept {
-  VLOG(4) << "New Bidi Stream=" << id;
+  PRX_VLOG(4) << "New Bidi Stream=" << id;
   stream.readHandle->awaitNextRead(
       evb_, [this](auto readHandle, auto id, auto streamData) {
         readHandler(readHandle, id, std::move(streamData));
@@ -425,7 +426,7 @@ void DeviousBatonHandler::onWebTransportBidiStream(
 void DeviousBatonHandler::onWebTransportUniStream(
     HTTPCodec::StreamID id,
     WebTransport::StreamReadHandle* readHandle) noexcept {
-  VLOG(4) << "New Uni Stream=" << id;
+  PRX_VLOG(4) << "New Uni Stream=" << id;
   readHandle->awaitNextRead(
       evb_, [this](auto readHandle, auto id, auto streamData) {
         readHandler(readHandle, id, std::move(streamData));
@@ -434,25 +435,25 @@ void DeviousBatonHandler::onWebTransportUniStream(
 
 void DeviousBatonHandler::onWebTransportSessionClose(
     folly::Optional<uint32_t> error) noexcept {
-  VLOG(4) << "Session Close error="
-          << (error ? folly::to<std::string>(*error) : std::string("none"));
+  PRX_VLOG(4) << "Session Close error="
+              << (error ? folly::to<std::string>(*error) : std::string("none"));
   devious_.reset();
 }
 
 void DeviousBatonHandler::onDatagram(
     std::unique_ptr<folly::IOBuf> datagram) noexcept {
-  VLOG(4) << "DeviousBatonHandler::" << __func__;
+  PRX_VLOG(4) << "DeviousBatonHandler::" << __func__;
 }
 
 void DeviousBatonHandler::onBody(std::unique_ptr<folly::IOBuf> body) noexcept {
-  VLOG(4) << "DeviousBatonHandler::" << __func__;
-  VLOG(3) << IOBufPrinter::printHexFolly(body.get(), true);
+  PRX_VLOG(4) << "DeviousBatonHandler::" << __func__;
+  PRX_VLOG(3) << IOBufPrinter::printHexFolly(body.get(), true);
   folly::io::Cursor cursor(body.get());
   auto leftToParse = body->computeChainDataLength();
   while (leftToParse > 0) {
     auto typeRes = quic::follyutils::decodeQuicInteger(cursor, leftToParse);
     if (!typeRes) {
-      LOG(ERROR) << "Failed to decode capsule type.";
+      PRX_LOG(ERROR) << "Failed to decode capsule type.";
       return;
     }
     auto [type, typeLen] = typeRes.value();
@@ -460,21 +461,21 @@ void DeviousBatonHandler::onBody(std::unique_ptr<folly::IOBuf> body) noexcept {
     auto capLengthRes =
         quic::follyutils::decodeQuicInteger(cursor, leftToParse);
     if (!capLengthRes) {
-      LOG(ERROR) << "Failed to decode capsule length: type=" << type;
+      PRX_LOG(ERROR) << "Failed to decode capsule length: type=" << type;
       return;
     }
     auto [capLength, capLengthLen] = capLengthRes.value();
     leftToParse -= capLengthLen;
     if (capLength > leftToParse) {
-      LOG(ERROR) << "Not enough data for capsule: type=" << type
-                 << " length=" << capLength;
+      PRX_LOG(ERROR) << "Not enough data for capsule: type=" << type
+                     << " length=" << capLength;
       return;
     }
   }
 }
 
 void DeviousBatonHandler::onEOM() noexcept {
-  VLOG(4) << "DeviousBatonHandler::" << __func__;
+  PRX_VLOG(4) << "DeviousBatonHandler::" << __func__;
   if (txn_ && !txn_->isEgressEOMSeen()) {
     txn_->sendEOM();
   }
@@ -482,6 +483,6 @@ void DeviousBatonHandler::onEOM() noexcept {
 
 void DeviousBatonHandler::onError(
     const proxygen::HTTPException& error) noexcept {
-  VLOG(4) << "DeviousBatonHandler::onError error=" << error.what();
+  PRX_VLOG(4) << "DeviousBatonHandler::onError error=" << error.what();
 }
 } // namespace quic::samples
diff --git a/proxygen/httpserver/samples/hq/SampleHandlers.h b/proxygen/httpserver/samples/hq/SampleHandlers.h
index 26ae2a82b3..3304ca2908 100644
--- a/proxygen/httpserver/samples/hq/SampleHandlers.h
+++ b/proxygen/httpserver/samples/hq/SampleHandlers.h
@@ -34,6 +34,7 @@
 #include <proxygen/httpserver/samples/hq/HQServer.h>
 #include <proxygen/httpserver/samples/hq/devious/DeviousBaton.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/SafePathUtils.h>
 
 namespace quic::samples {
@@ -195,7 +196,7 @@ class ChunkedHandler
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "ChunkedHandler::onHeadersComplete";
+    PRX_VLOG(10) << "ChunkedHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
     resp.setStatusCode(200);
     resp.setStatusMessage("Ok");
@@ -214,7 +215,7 @@ class ChunkedHandler
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "ChunkedHandler::onEOM";
+    PRX_VLOG(10) << "ChunkedHandler::onEOM";
     sleepFutureCallback();
   }
 
@@ -287,9 +288,9 @@ class EchoHandler : public BaseSampleHandler {
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "EchoHandler::onHeadersComplete";
+    PRX_VLOG(10) << "EchoHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     sendFooter_ =
         (msg->getHTTPVersion() == proxygen::HTTPMessage::kHTTPVersion09);
     resp.setVersionString(getHttpVersion());
@@ -305,12 +306,12 @@ class EchoHandler : public BaseSampleHandler {
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
-    VLOG(10) << "EchoHandler::onBody";
+    PRX_VLOG(10) << "EchoHandler::onBody";
     txn_->sendBody(std::move(chain));
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "EchoHandler::onEOM";
+    PRX_VLOG(10) << "EchoHandler::onEOM";
     if (sendFooter_) {
       auto& footer = getH1QFooter();
       txn_->sendBody(folly::IOBuf::copyBuffer(footer.data(), footer.length()));
@@ -368,9 +369,9 @@ class ContinueHandler : public EchoHandler {
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "ContinueHandler::onHeadersComplete";
+    PRX_VLOG(10) << "ContinueHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     if (msg->getHeaders().getSingleOrEmpty(proxygen::HTTP_HEADER_EXPECT) ==
         "100-continue") {
@@ -394,9 +395,9 @@ class RandBytesGenHandler : public BaseSampleHandler {
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
     auto path = msg->getPathAsStringPiece();
-    VLOG(10) << "RandBytesGenHandler::onHeadersComplete";
-    VLOG(1) << "Request path: " << path;
-    CHECK_GE(path.size(), 1);
+    PRX_VLOG(10) << "RandBytesGenHandler::onHeadersComplete";
+    PRX_VLOG(1) << "Request path: " << path;
+    PRX_CHECK_GE(path.size(), 1u);
     try {
       respBodyLen_ = folly::to<uint64_t>(path.subpiece(1));
     } catch (const folly::ConversionError&) {
@@ -404,7 +405,7 @@ class RandBytesGenHandler : public BaseSampleHandler {
           "Invalid URL: cannot extract requested response-length from url "
           "path: ",
           path);
-      LOG(ERROR) << errorMsg;
+      PRX_LOG(ERROR) << errorMsg;
       sendError(errorMsg);
       return;
     }
@@ -414,7 +415,7 @@ class RandBytesGenHandler : public BaseSampleHandler {
     }
 
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(200);
     resp.setStatusMessage("Ok");
@@ -426,16 +427,16 @@ class RandBytesGenHandler : public BaseSampleHandler {
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
-    VLOG(10) << "RandBytesGenHandler::onBody";
+    PRX_VLOG(10) << "RandBytesGenHandler::onBody";
     sendBodyInChunks();
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "RandBytesGenHandler::onEOM";
+    PRX_VLOG(10) << "RandBytesGenHandler::onEOM";
   }
 
   void onError(const proxygen::HTTPException& /*error*/) noexcept override {
-    VLOG(10) << "RandBytesGenHandler::onERROR";
+    PRX_VLOG(10) << "RandBytesGenHandler::onERROR";
     txn_->sendAbort();
   }
 
@@ -451,7 +452,7 @@ class RandBytesGenHandler : public BaseSampleHandler {
  private:
   void sendBodyInChunks() {
     if (error_) {
-      LOG(ERROR) << "sendBodyInChunks no-op, error_=true";
+      PRX_LOG(ERROR) << "sendBodyInChunks no-op, error_=true";
       txn_->sendAbort();
       return;
     }
@@ -459,15 +460,15 @@ class RandBytesGenHandler : public BaseSampleHandler {
     if (respBodyLen_ % kMaxChunkSize != 0) {
       ++iter;
     }
-    VLOG(10) << "Sending response in " << iter << " chunks";
+    PRX_VLOG(10) << "Sending response in " << iter << " chunks";
     for (uint64_t i = 0; i < iter && !paused_; i++) {
       uint64_t chunkSize = std::fmin(kMaxChunkSize, respBodyLen_);
-      VLOG(10) << "Sending " << chunkSize << " bytes of data";
+      PRX_VLOG(10) << "Sending " << chunkSize << " bytes of data";
       txn_->sendBody(genRandBytes(chunkSize));
       respBodyLen_ -= chunkSize;
     }
     if (!paused_ && !eomSent_ && respBodyLen_ == 0) {
-      VLOG(10) << "Sending response EOM";
+      PRX_VLOG(10) << "Sending response EOM";
       txn_->sendEOM();
       eomSent_ = true;
     }
@@ -524,9 +525,9 @@ class DummyHandler : public BaseSampleHandler {
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "DummyHandler::onHeadersComplete";
+    PRX_VLOG(10) << "DummyHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(200);
     resp.setStatusMessage("Ok");
@@ -539,12 +540,12 @@ class DummyHandler : public BaseSampleHandler {
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
-    VLOG(10) << "DummyHandler::onBody";
+    PRX_VLOG(10) << "DummyHandler::onBody";
     txn_->sendBody(folly::IOBuf::copyBuffer(kDummyMessage));
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "DummyHandler::onEOM";
+    PRX_VLOG(10) << "DummyHandler::onEOM";
     txn_->sendEOM();
   }
 
@@ -572,15 +573,15 @@ class DelayHandler
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "DelayHandler::onHeadersComplete";
+    PRX_VLOG(10) << "DelayHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(200);
     resp.setStatusMessage("Ok");
     resp.setWantsKeepalive(true);
     maybeAddAltSvcHeader(resp);
-    VLOG(10) << "DelayHandler::onHeadersComplete calling sendHeaders";
+    PRX_VLOG(10) << "DelayHandler::onHeadersComplete calling sendHeaders";
     txn_->sendHeaders(resp);
 
     auto duration = getQueryParamAsNumber(msg, "duration", 0);
@@ -590,11 +591,11 @@ class DelayHandler
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
-    VLOG(10) << "DelayHandler::onBody";
+    PRX_VLOG(10) << "DelayHandler::onBody";
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "DelayHandler::onEOM";
+    PRX_VLOG(10) << "DelayHandler::onEOM";
   }
 
   void onError(const proxygen::HTTPException& /*error*/) noexcept override {
@@ -618,9 +619,9 @@ class HealthCheckHandler : public BaseSampleHandler {
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "HealthCheckHandler::onHeadersComplete";
+    PRX_VLOG(10) << "HealthCheckHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     if (msg->getMethod() == proxygen::HTTPMethod::GET) {
       resp.setStatusCode(healthy_ ? 200 : 400);
@@ -638,12 +639,12 @@ class HealthCheckHandler : public BaseSampleHandler {
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
-    VLOG(10) << "HealthCheckHandler::onBody";
+    PRX_VLOG(10) << "HealthCheckHandler::onBody";
     assert(false);
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "HealthCheckHandler::onEOM";
+    PRX_VLOG(10) << "HealthCheckHandler::onEOM";
     txn_->sendEOM();
   }
 
@@ -663,9 +664,9 @@ class SimplePostHandler : public BaseSampleHandler {
 
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
-    VLOG(10) << "SimplePostHandler::onHeadersComplete";
+    PRX_VLOG(10) << "SimplePostHandler::onHeadersComplete";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     if (msg->getMethod() != proxygen::HTTPMethod::POST) {
       resp.setStatusCode(400);
@@ -676,14 +677,14 @@ class SimplePostHandler : public BaseSampleHandler {
   }
 
   void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
-    VLOG(10) << "SimplePostHandler::onBody";
+    PRX_VLOG(10) << "SimplePostHandler::onBody";
     numBodyBytesReceived_ += chain->computeChainDataLength();
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "SimplePostHandler::onEOM";
+    PRX_VLOG(10) << "SimplePostHandler::onEOM";
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(200);
     resp.setStatusMessage("Ok");
@@ -715,7 +716,7 @@ class WaitReleaseHandler : public BaseSampleHandler {
 
   void sendErrorResponse(const std::string& body) {
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(400);
     resp.setStatusMessage("ERROR");
@@ -728,7 +729,7 @@ class WaitReleaseHandler : public BaseSampleHandler {
 
   void sendOkResponse(const std::string& body, bool eom) {
     proxygen::HTTPMessage resp;
-    VLOG(10) << "Setting http-version to " << getHttpVersion();
+    PRX_VLOG(10) << "Setting http-version to " << getHttpVersion();
     resp.setVersionString(getHttpVersion());
     resp.setStatusCode(200);
     resp.setStatusMessage("OK");
@@ -752,11 +753,11 @@ class WaitReleaseHandler : public BaseSampleHandler {
   void maybeCleanup();
 
   void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
-    VLOG(10) << "WaitReleaseHandler::onBody - ignoring";
+    PRX_VLOG(10) << "WaitReleaseHandler::onBody - ignoring";
   }
 
   void onEOM() noexcept override {
-    VLOG(10) << "WaitReleaseHandler::onEOM";
+    PRX_VLOG(10) << "WaitReleaseHandler::onEOM";
   }
 
   void onError(const proxygen::HTTPException& /*error*/) noexcept override {
@@ -877,7 +878,7 @@ class StaticFileHandler : public BaseSampleHandler {
   }
 
   folly::EventBase* evb() {
-    return CHECK_NOTNULL(folly::EventBaseManager::get()->getEventBase());
+    return PRX_CHECK_NOTNULL(folly::EventBaseManager::get()->getEventBase());
   }
 
  public:
@@ -895,8 +896,8 @@ class StaticFileHandler : public BaseSampleHandler {
   void onHeadersComplete(
       std::unique_ptr<proxygen::HTTPMessage> msg) noexcept override {
     auto path = msg->getPathAsStringPiece();
-    VLOG(10) << "StaticFileHandler::onHeadersComplete";
-    VLOG(4) << "Request path: " << path;
+    PRX_VLOG(10) << "StaticFileHandler::onHeadersComplete";
+    PRX_VLOG(4) << "Request path: " << path;
     if (path.contains("..")) {
       sendError("Path cannot contain ..");
       return;
@@ -912,7 +913,7 @@ class StaticFileHandler : public BaseSampleHandler {
           "path: '",
           path,
           "'");
-      LOG(ERROR) << errorMsg << " file: '" << filepath << "'";
+      PRX_LOG(ERROR) << errorMsg << " file: '" << filepath << "'";
       sendError(errorMsg);
       return;
     }
@@ -931,17 +932,17 @@ class StaticFileHandler : public BaseSampleHandler {
   }
 
   void onError(const proxygen::HTTPException& /*error*/) noexcept override {
-    VLOG(10) << "StaticFileHandler::onError";
+    PRX_VLOG(10) << "StaticFileHandler::onError";
     txn_->sendAbort();
   }
 
   void onEgressPaused() noexcept override {
-    VLOG(10) << "StaticFileHandler::onEgressPaused";
+    PRX_VLOG(10) << "StaticFileHandler::onEgressPaused";
     paused_ = true;
   }
 
   void onEgressResumed() noexcept override {
-    VLOG(10) << "StaticFileHandler::onEgressResumed";
+    PRX_VLOG(10) << "StaticFileHandler::onEgressResumed";
     paused_ = false;
     folly::getUnsafeMutableGlobalCPUExecutor()->add(
         [this, evb = evb(), self = self_]() { readFile(evb, self); });
@@ -978,14 +979,14 @@ class StaticFileHandler : public BaseSampleHandler {
       auto rc = folly::readNoInt(file_->fd(), data.first, data.second);
       if (rc < 0) {
         // error
-        LOG(ERROR) << "Read error=" << rc;
+        PRX_LOG(ERROR) << "Read error=" << rc;
         file_.reset();
         evb->runInEventBaseThread([this] { sendAbort(); });
         break;
       } else if (rc == 0) {
         // done
         file_.reset();
-        VLOG(4) << "Read EOF";
+        PRX_VLOG(4) << "Read EOF";
         evb->runInEventBaseThread([this] { sendEom(); });
         break;
       } else {
diff --git a/proxygen/httpserver/samples/hq/devious/CMakeLists.txt b/proxygen/httpserver/samples/hq/devious/CMakeLists.txt
index c3fb7a9bc5..10ef8037e2 100644
--- a/proxygen/httpserver/samples/hq/devious/CMakeLists.txt
+++ b/proxygen/httpserver/samples/hq/devious/CMakeLists.txt
@@ -10,6 +10,7 @@ proxygen_add_library(proxygen_hq_devious_baton
   DEPS
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_message
     proxygen_webtransport
diff --git a/proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp b/proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp
index 3acffdc9a6..16a273c818 100644
--- a/proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp
+++ b/proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp
@@ -8,6 +8,7 @@
 
 #include "DeviousBaton.h"
 
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -37,11 +38,11 @@ namespace devious {
 folly::Expected<folly::Unit, uint16_t> DeviousBaton::onRequest(
     const HTTPMessage& request) {
   if (request.getMethod() != HTTPMethod::CONNECT) {
-    LOG(ERROR) << "Invalid method=" << request.getMethodString();
+    PRX_LOG(ERROR) << "Invalid method=" << request.getMethodString();
     return folly::makeUnexpected(uint16_t(400));
   }
   if (request.getPathAsStringPiece() != "/webtransport/devious-baton") {
-    LOG(ERROR) << "Invalid path=" << request.getPathAsStringPiece();
+    PRX_LOG(ERROR) << "Invalid path=" << request.getPathAsStringPiece();
     return folly::makeUnexpected(uint16_t(404));
   }
   try {
@@ -72,7 +73,7 @@ folly::Expected<folly::Unit, uint16_t> DeviousBaton::onRequest(
     activeBatons_ = count;
     return folly::unit;
   } catch (const std::exception& ex) {
-    LOG(ERROR) << "Invalid query parameters: " << ex.what();
+    PRX_LOG(ERROR) << "Invalid query parameters: " << ex.what();
     return folly::makeUnexpected(uint16_t(404));
   }
 }
@@ -148,7 +149,7 @@ DeviousBaton::onBatonMessageData(BatonMessageState& state,
         break;
       }
       state.baton = cursor.read<uint8_t>();
-      LOG(INFO) << "Parsed baton=" << uint64_t(state.baton);
+      PRX_LOG(INFO) << "Parsed baton=" << uint64_t(state.baton);
       consumed += 1;
       state.state = BatonMessageState::DONE;
       [[fallthrough]];
@@ -204,7 +205,7 @@ DeviousBaton::onBatonMessage(uint64_t inStreamId,
                              MessageSource arrivedOn,
                              uint8_t baton) {
   if (baton % 7 == ((mode_ == Mode::SERVER) ? 0 : 1)) {
-    LOG(INFO) << "Sending datagram on baton=" << uint64_t(baton);
+    PRX_LOG(INFO) << "Sending datagram on baton=" << uint64_t(baton);
     wt_->sendDatagram(makeBatonMessage(kDatagramPadLen, baton));
   }
   if (baton == 0) {
diff --git a/proxygen/httpserver/samples/hq/main.cpp b/proxygen/httpserver/samples/hq/main.cpp
index 86d28815fa..566a8d401c 100644
--- a/proxygen/httpserver/samples/hq/main.cpp
+++ b/proxygen/httpserver/samples/hq/main.cpp
@@ -16,6 +16,7 @@
 #include <proxygen/httpserver/samples/hq/HQParams.h>
 #include <proxygen/httpserver/samples/hq/HQServerModule.h>
 #include <proxygen/lib/transport/PersistentQuicPskCache.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace quic::samples;
 
@@ -39,7 +40,7 @@ int main(int argc, char* argv[]) {
     if (sink.isValid()) {
       AddLogSink(&sink);
     } else if (!params.logdir.empty()) {
-      LOG(ERROR) << "Cannot open " << params.logdir;
+      PRX_LOG(ERROR) << "Cannot open " << params.logdir;
     }
 
     switch (params.mode) {
@@ -50,22 +51,22 @@ int main(int argc, char* argv[]) {
         err = startClient(std::get<HQToolClientParams>(params.params));
         break;
       default:
-        LOG(ERROR) << "Unknown mode specified: ";
+        PRX_LOG(ERROR) << "Unknown mode specified: ";
         return -1;
     }
     if (params.logRuntime) {
-      LOG(INFO) << "Run time: "
-                << std::chrono::duration_cast<std::chrono::milliseconds>(
-                       std::chrono::steady_clock().now().time_since_epoch())
-                           .count() -
-                       startTime
-                << "ms";
+      PRX_LOG(INFO) << "Run time: "
+                    << std::chrono::duration_cast<std::chrono::milliseconds>(
+                           std::chrono::steady_clock().now().time_since_epoch())
+                               .count() -
+                           startTime
+                    << "ms";
     }
     return err;
   } else {
     for (auto& param : expectedParams.error()) {
-      LOG(ERROR) << "Invalid param: " << param.name << " " << param.value << " "
-                 << param.errorMsg;
+      PRX_LOG(ERROR) << "Invalid param: " << param.name << " " << param.value
+                     << " " << param.errorMsg;
     }
     return -1;
   }
diff --git a/proxygen/httpserver/samples/masque/MasqueClient.cpp b/proxygen/httpserver/samples/masque/MasqueClient.cpp
index 30e536582d..a4c31527cf 100644
--- a/proxygen/httpserver/samples/masque/MasqueClient.cpp
+++ b/proxygen/httpserver/samples/masque/MasqueClient.cpp
@@ -20,6 +20,7 @@
 #include <proxygen/httpserver/samples/hq/InsecureVerifierDangerousDoNotUseInProduction.h>
 #include <proxygen/lib/transport/ConnectUDPUtils.h>
 #include <proxygen/lib/transport/H3DatagramAsyncSocket.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -91,14 +92,14 @@ class MasqueInteropClient
   }
 
   void start() {
-    CHECK(evb_->isInEventBaseThread());
+    PRX_CHECK(evb_->isInEventBaseThread());
     try {
       proxyAddress_ = resolveAddress(FLAGS_proxy_host,
                                      static_cast<uint16_t>(FLAGS_proxy_port),
                                      FLAGS_ipv4_only);
       socket_.connect(proxyAddress_);
     } catch (const std::exception& e) {
-      LOG(ERROR) << "Failed to connect: " << e.what();
+      PRX_LOG(ERROR) << "Failed to connect: " << e.what();
       exitCode_ = 1;
       return;
     }
@@ -123,10 +124,10 @@ class MasqueInteropClient
     auto buf = folly::IOBuf::copyBuffer(sentPayload_.data(), payloadSize_);
     auto hexStr = folly::hexlify(folly::ByteRange(
         reinterpret_cast<const uint8_t*>(sentPayload_.data()), payloadSize_));
-    LOG(INFO) << "Sending " << payloadSize_ << " bytes: " << hexStr;
+    PRX_LOG(INFO) << "Sending " << payloadSize_ << " bytes: " << hexStr;
     auto res = socket_.write(proxyAddress_, buf);
     if (res < 0) {
-      LOG(ERROR) << "Failed to write: errno=" << errno;
+      PRX_LOG(ERROR) << "Failed to write: errno=" << errno;
       exitCode_ = 1;
       evb_->terminateLoopSoon();
       return;
@@ -137,7 +138,7 @@ class MasqueInteropClient
   }
 
   void timeoutExpired() noexcept override {
-    LOG(ERROR) << "Timeout waiting for echo response";
+    PRX_LOG(ERROR) << "Timeout waiting for echo response";
     exitCode_ = 1;
     evb_->terminateLoopSoon();
   }
@@ -155,20 +156,20 @@ class MasqueInteropClient
       cancelTimeout();
       auto hexStr = folly::hexlify(folly::ByteRange(
           reinterpret_cast<const uint8_t*>(readBuf_.data()), len));
-      LOG(INFO) << "Received " << len << " bytes: " << hexStr;
+      PRX_LOG(INFO) << "Received " << len << " bytes: " << hexStr;
 
       if (len == payloadSize_ &&
           memcmp(readBuf_.data(), sentPayload_.data(), payloadSize_) == 0) {
-        LOG(INFO) << "Echo payload verified - exact match";
+        PRX_LOG(INFO) << "Echo payload verified - exact match";
         exitCode_ = 0;
         verified_ = true;
       } else {
-        LOG(ERROR) << "Echo payload MISMATCH!";
+        PRX_LOG(ERROR) << "Echo payload MISMATCH!";
         exitCode_ = 1;
       }
       evb_->terminateLoopSoon();
     } catch (const std::exception& e) {
-      LOG(ERROR) << "Exception in onDataAvailable: " << e.what();
+      PRX_LOG(ERROR) << "Exception in onDataAvailable: " << e.what();
       exitCode_ = 1;
       evb_->terminateLoopSoon();
     }
@@ -176,7 +177,7 @@ class MasqueInteropClient
 
   void onReadError(const folly::AsyncSocketException& ex) noexcept override {
     cancelTimeout();
-    LOG(ERROR) << "Read error: " << ex.what();
+    PRX_LOG(ERROR) << "Read error: " << ex.what();
     if (!verified_) {
       exitCode_ = 1;
     }
@@ -185,7 +186,7 @@ class MasqueInteropClient
 
   void onReadClosed() noexcept override {
     cancelTimeout();
-    LOG(INFO) << "Read closed";
+    PRX_LOG(INFO) << "Read closed";
     if (!sent_ && !verified_) {
       exitCode_ = 1;
     }
@@ -214,8 +215,8 @@ int main(int argc, char* argv[]) {
 
   try {
     auto payloadSize = static_cast<size_t>(FLAGS_payload_size);
-    CHECK_GT(payloadSize, 0u) << "payload_size must be > 0";
-    CHECK_LE(payloadSize, kMaxPayloadSize)
+    PRX_CHECK_GT(payloadSize, 0u) << "payload_size must be > 0";
+    PRX_CHECK_LE(payloadSize, kMaxPayloadSize)
         << "payload_size must be <= " << kMaxPayloadSize;
 
     // Expand the URI template with proxy address for the template itself,
@@ -244,10 +245,10 @@ int main(int argc, char* argv[]) {
                                  FLAGS_target_host,
                                  static_cast<uint16_t>(FLAGS_target_port));
 
-    LOG(INFO) << "Extended CONNECT: :protocol=connect-udp"
-              << ", :scheme=" << target.scheme
-              << ", :authority=" << target.authority
-              << ", :path=" << target.path;
+    PRX_LOG(INFO) << "Extended CONNECT: :protocol=connect-udp"
+                  << ", :scheme=" << target.scheme
+                  << ", :authority=" << target.authority
+                  << ", :path=" << target.path;
 
     EventBase evb;
 
@@ -298,7 +299,7 @@ int main(int argc, char* argv[]) {
 
     return client.exitCode();
   } catch (const std::exception& e) {
-    LOG(ERROR) << "Fatal error: " << e.what();
+    PRX_LOG(ERROR) << "Fatal error: " << e.what();
     return 1;
   }
 }
diff --git a/proxygen/httpserver/samples/proxy/ProxyHandler.cpp b/proxygen/httpserver/samples/proxy/ProxyHandler.cpp
index 3d8e33dd37..2cb8acdf60 100644
--- a/proxygen/httpserver/samples/proxy/ProxyHandler.cpp
+++ b/proxygen/httpserver/samples/proxy/ProxyHandler.cpp
@@ -17,6 +17,7 @@
 #include <proxygen/lib/utils/URL.h>
 
 #include "ProxyStats.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using std::string;
@@ -40,7 +41,7 @@ ProxyHandler::ProxyHandler(ProxyStats* stats, folly::HHWheelTimer* timer)
 }
 
 ProxyHandler::~ProxyHandler() {
-  VLOG(4) << "deleting ProxyHandler";
+  PRX_VLOG(4) << "deleting ProxyHandler";
 }
 
 void ProxyHandler::onRequest(std::unique_ptr<HTTPMessage> headers) noexcept {
@@ -66,7 +67,7 @@ void ProxyHandler::onRequest(std::unique_ptr<HTTPMessage> headers) noexcept {
   }
 
   downstream_->pauseIngress();
-  LOG(INFO) << "Trying to connect to " << addr;
+  PRX_LOG(INFO) << "Trying to connect to " << addr;
   auto evb = folly::EventBaseManager::get()->getEventBase();
   if (request_->getMethod() == HTTPMethod::CONNECT) {
     upstreamSock_ = folly::AsyncSocket::newSocket(evb);
@@ -86,8 +87,9 @@ void ProxyHandler::onRequest(std::unique_ptr<HTTPMessage> headers) noexcept {
 void ProxyHandler::onBody(std::unique_ptr<folly::IOBuf> body) noexcept {
   DestructorGuard dg(this);
   if (txn_) {
-    LOG(INFO) << "Forwarding " << ((body) ? body->computeChainDataLength() : 0)
-              << " body bytes to server";
+    PRX_LOG(INFO) << "Forwarding "
+                  << ((body) ? body->computeChainDataLength() : 0)
+                  << " body bytes to server";
     txn_->sendBody(std::move(body));
   } else if (upstreamSock_) {
     upstreamEgressPaused_ = true;
@@ -97,38 +99,39 @@ void ProxyHandler::onBody(std::unique_ptr<folly::IOBuf> body) noexcept {
       onServerEgressPaused();
     }
   } else {
-    LOG(WARNING) << "Dropping " << ((body) ? body->computeChainDataLength() : 0)
-                 << " body bytes to server";
+    PRX_LOG(WARNING) << "Dropping "
+                     << ((body) ? body->computeChainDataLength() : 0)
+                     << " body bytes to server";
   }
 }
 
 void ProxyHandler::onEOM() noexcept {
   if (txn_) {
-    LOG(INFO) << "Forwarding client EOM to server";
+    PRX_LOG(INFO) << "Forwarding client EOM to server";
     txn_->sendEOM();
   } else if (upstreamSock_) {
-    LOG(INFO) << "Closing upgraded socket";
+    PRX_LOG(INFO) << "Closing upgraded socket";
     sockStatus_ |= WRITES_SHUTDOWN;
     upstreamSock_->shutdownWrite();
   } else {
-    LOG(INFO) << "Dropping client EOM to server";
+    PRX_LOG(INFO) << "Dropping client EOM to server";
   }
 }
 
 void ProxyHandler::connectSuccess(HTTPUpstreamSession* session) {
   DestructorGuard dg(this);
-  LOG(INFO) << "Established " << *session;
+  PRX_LOG(INFO) << "Established " << *session;
   session_ = std::make_unique<SessionWrapper>(session);
   txn_ = session->newTransaction(&serverHandler_);
-  LOG(INFO) << "Forwarding client request: " << request_->getURL()
-            << " to server";
+  PRX_LOG(INFO) << "Forwarding client request: " << request_->getURL()
+                << " to server";
   txn_->sendHeaders(*request_);
   downstream_->resumeIngress();
 }
 
 void ProxyHandler::connectError(const folly::AsyncSocketException& ex) {
   DestructorGuard dg(this);
-  LOG(ERROR) << "Failed to connect: " << folly::exceptionStr(ex);
+  PRX_LOG(ERROR) << "Failed to connect: " << folly::exceptionStr(ex);
   if (!clientTerminated_) {
     ResponseBuilder(downstream_).status(503, "Bad Gateway").sendWithEOM();
   } else {
@@ -139,21 +142,23 @@ void ProxyHandler::connectError(const folly::AsyncSocketException& ex) {
 
 void ProxyHandler::onServerHeadersComplete(
     unique_ptr<HTTPMessage> msg) noexcept {
-  CHECK(!clientTerminated_);
-  LOG(INFO) << "Forwarding " << msg->getStatusCode() << " response to client";
+  PRX_CHECK(!clientTerminated_);
+  PRX_LOG(INFO) << "Forwarding " << msg->getStatusCode()
+                << " response to client";
   downstream_->sendHeaders(*msg);
 }
 
 void ProxyHandler::onServerBody(std::unique_ptr<folly::IOBuf> chain) noexcept {
-  CHECK(!clientTerminated_);
-  LOG(INFO) << "Forwarding " << ((chain) ? chain->computeChainDataLength() : 0)
-            << " body bytes to client";
+  PRX_CHECK(!clientTerminated_);
+  PRX_LOG(INFO) << "Forwarding "
+                << ((chain) ? chain->computeChainDataLength() : 0)
+                << " body bytes to client";
   downstream_->sendBody(std::move(chain));
 }
 
 void ProxyHandler::onServerEOM() noexcept {
   if (!clientTerminated_) {
-    LOG(INFO) << "Forwarding server EOM to client";
+    PRX_LOG(INFO) << "Forwarding server EOM to client";
     downstream_->sendEOM();
   }
 }
@@ -164,7 +169,7 @@ void ProxyHandler::detachServerTransaction() noexcept {
 }
 
 void ProxyHandler::onServerError(const HTTPException& error) noexcept {
-  LOG(ERROR) << "Server error: " << error;
+  PRX_LOG(ERROR) << "Server error: " << error;
   abortDownstream();
 }
 
@@ -186,11 +191,11 @@ void ProxyHandler::requestComplete() noexcept {
 }
 
 void ProxyHandler::onError(ProxygenError err) noexcept {
-  LOG(ERROR) << "Client error: " << proxygen::getErrorString(err);
+  PRX_LOG(ERROR) << "Client error: " << proxygen::getErrorString(err);
   DestructorGuard dg(this);
   clientTerminated_ = true;
   if (txn_) {
-    LOG(ERROR) << "Aborting server txn: " << *txn_;
+    PRX_LOG(ERROR) << "Aborting server txn: " << *txn_;
     txn_->sendAbort();
   } else if (upstreamSock_) {
     upstreamSock_.reset();
@@ -230,7 +235,7 @@ bool ProxyHandler::checkForShutdown() {
 }
 
 void ProxyHandler::connectSuccess() noexcept {
-  LOG(INFO) << "Connected to upstream " << upstreamSock_;
+  PRX_LOG(INFO) << "Connected to upstream " << upstreamSock_;
   DestructorGuard dg(this);
   ResponseBuilder(downstream_).status(200, "OK").send();
   upstreamSock_->setReadCB(this);
@@ -260,7 +265,7 @@ void ProxyHandler::readEOF() noexcept {
 
 void ProxyHandler::readErr(const folly::AsyncSocketException& ex) noexcept {
   DestructorGuard dg(this);
-  LOG(ERROR) << "Server read error: " << folly::exceptionStr(ex);
+  PRX_LOG(ERROR) << "Server read error: " << folly::exceptionStr(ex);
   abortDownstream();
   upstreamSock_.reset();
   checkForShutdown();
@@ -278,7 +283,7 @@ void ProxyHandler::writeSuccess() noexcept {
 
 void ProxyHandler::writeErr(size_t /*bytesWritten*/,
                             const folly::AsyncSocketException& ex) noexcept {
-  LOG(ERROR) << "Server write error: " << folly::exceptionStr(ex);
+  PRX_LOG(ERROR) << "Server write error: " << folly::exceptionStr(ex);
   DestructorGuard dg(this);
   upstreamEgressPaused_ = false;
   abortDownstream();
diff --git a/proxygen/httpserver/samples/proxy/ProxyServer.cpp b/proxygen/httpserver/samples/proxy/ProxyServer.cpp
index 6703fac3b8..9d840c374f 100644
--- a/proxygen/httpserver/samples/proxy/ProxyServer.cpp
+++ b/proxygen/httpserver/samples/proxy/ProxyServer.cpp
@@ -15,6 +15,7 @@
 
 #include "ProxyHandler.h"
 #include "ProxyStats.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace ProxyService;
 using namespace proxygen;
@@ -75,7 +76,7 @@ int main(int argc, char* argv[]) {
 
   if (FLAGS_threads <= 0) {
     FLAGS_threads = folly::available_concurrency();
-    CHECK(FLAGS_threads > 0);
+    PRX_CHECK(FLAGS_threads > 0);
   }
 
   HTTPServerOptions options;
diff --git a/proxygen/httpserver/samples/push/PushRequestHandler.cpp b/proxygen/httpserver/samples/push/PushRequestHandler.cpp
index dd46b308c3..34aa6538dd 100644
--- a/proxygen/httpserver/samples/push/PushRequestHandler.cpp
+++ b/proxygen/httpserver/samples/push/PushRequestHandler.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/httpserver/PushHandler.h>
 #include <proxygen/httpserver/RequestHandler.h>
 #include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 
@@ -32,7 +33,7 @@ std::string createLargeBody() {
 
 PushRequestHandler::PushRequestHandler(PushStats* stats) : stats_(stats) {
   if (gPushBody.empty()) {
-    CHECK(folly::readFile(kPushFileName.c_str(), gPushBody))
+    PRX_CHECK(folly::readFile(kPushFileName.c_str(), gPushBody))
         << "Failed to read push file=" << kPushFileName;
   }
 }
@@ -43,13 +44,14 @@ void PushRequestHandler::onRequest(
   if (!headers->getHeaders().getSingleOrEmpty("X-PushIt").empty()) {
     const auto downstreamPush = downstream_->newPushedResponse(new PushHandler);
     if (downstreamPush.hasError()) {
-      LOG(ERROR) << "can't push: " << getErrorString(downstreamPush.error());
+      PRX_LOG(ERROR) << "can't push: "
+                     << getErrorString(downstreamPush.error());
       return;
     }
     downstreamPush_ = downstreamPush.value();
 
     if (headers->getPathAsStringPiece() == "/requestLargePush") {
-      LOG(INFO) << "sending large push ";
+      PRX_LOG(INFO) << "sending large push ";
 
       ResponseBuilder(downstreamPush_)
           .promise("/largePush",
@@ -62,7 +64,7 @@ void PushRequestHandler::onRequest(
           .body(createLargeBody())
           .sendWithEOM();
     } else {
-      LOG(INFO) << "sending small push ";
+      PRX_LOG(INFO) << "sending small push ";
 
       ResponseBuilder(downstreamPush_)
           .promise("/pusheen",
diff --git a/proxygen/httpserver/samples/push/PushServer.cpp b/proxygen/httpserver/samples/push/PushServer.cpp
index 34e5eb8769..18107c1042 100644
--- a/proxygen/httpserver/samples/push/PushServer.cpp
+++ b/proxygen/httpserver/samples/push/PushServer.cpp
@@ -16,6 +16,7 @@
 
 #include "PushRequestHandler.h"
 #include "PushStats.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace PushService;
 using namespace proxygen;
@@ -62,7 +63,7 @@ int main(int argc, char* argv[]) {
 
   if (FLAGS_threads <= 0) {
     FLAGS_threads = folly::available_concurrency();
-    CHECK(FLAGS_threads > 0);
+    PRX_CHECK(FLAGS_threads > 0);
   }
 
   HTTPServerOptions options;
diff --git a/proxygen/httpserver/samples/static/StaticHandler.cpp b/proxygen/httpserver/samples/static/StaticHandler.cpp
index 259e25de20..5b9a91668a 100644
--- a/proxygen/httpserver/samples/static/StaticHandler.cpp
+++ b/proxygen/httpserver/samples/static/StaticHandler.cpp
@@ -12,6 +12,7 @@
 #include <folly/executors/GlobalExecutor.h>
 #include <folly/io/async/EventBaseManager.h>
 #include <proxygen/httpserver/ResponseBuilder.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/SafePathUtils.h>
 
 using namespace proxygen;
@@ -67,17 +68,17 @@ void StaticHandler::readFile(folly::EventBase* evb) {
     auto rc = folly::readNoInt(file_->fd(), data.first, data.second);
     if (rc < 0) {
       // error
-      VLOG(4) << "Read error=" << rc;
+      PRX_VLOG(4) << "Read error=" << rc;
       file_.reset();
       evb->runInEventBaseThread([this] {
-        LOG(ERROR) << "Error reading file";
+        PRX_LOG(ERROR) << "Error reading file";
         downstream_->sendAbort();
       });
       break;
     } else if (rc == 0) {
       // done
       file_.reset();
-      VLOG(4) << "Read EOF";
+      PRX_VLOG(4) << "Read EOF";
       evb->runInEventBaseThread([this] {
         if (!error_) {
           ResponseBuilder(downstream_).sendWithEOM();
@@ -98,7 +99,7 @@ void StaticHandler::readFile(folly::EventBase* evb) {
   evb->runInEventBaseThread([this] {
     readFileScheduled_ = false;
     if (!checkForCompletion() && !paused_) {
-      VLOG(4) << "Resuming deferred readFile";
+      PRX_VLOG(4) << "Resuming deferred readFile";
       onEgressResumed();
     }
   });
@@ -106,12 +107,12 @@ void StaticHandler::readFile(folly::EventBase* evb) {
 
 void StaticHandler::onEgressPaused() noexcept {
   // This will terminate readFile soon
-  VLOG(4) << "StaticHandler paused";
+  PRX_VLOG(4) << "StaticHandler paused";
   paused_ = true;
 }
 
 void StaticHandler::onEgressResumed() noexcept {
-  VLOG(4) << "StaticHandler resumed";
+  PRX_VLOG(4) << "StaticHandler resumed";
   paused_ = false;
   // If readFileScheduled_, it will reschedule itself
   if (!readFileScheduled_ && file_) {
@@ -121,7 +122,7 @@ void StaticHandler::onEgressResumed() noexcept {
           readFile(evb);
         });
   } else {
-    VLOG(4) << "Deferred scheduling readFile";
+    PRX_VLOG(4) << "Deferred scheduling readFile";
   }
 }
 
@@ -151,7 +152,7 @@ void StaticHandler::onError(ProxygenError /*err*/) noexcept {
 
 bool StaticHandler::checkForCompletion() {
   if (finished_ && !readFileScheduled_) {
-    VLOG(4) << "deleting StaticHandler";
+    PRX_VLOG(4) << "deleting StaticHandler";
     delete this;
     return true;
   }
diff --git a/proxygen/httpserver/samples/static/StaticServer.cpp b/proxygen/httpserver/samples/static/StaticServer.cpp
index e229ce9011..642ce54749 100644
--- a/proxygen/httpserver/samples/static/StaticServer.cpp
+++ b/proxygen/httpserver/samples/static/StaticServer.cpp
@@ -18,6 +18,7 @@
 #include <proxygen/httpserver/RequestHandlerFactory.h>
 
 #include "StaticHandler.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace StaticService;
 using namespace proxygen;
@@ -61,7 +62,7 @@ int main(int argc, char* argv[]) {
 
   if (FLAGS_threads <= 0) {
     FLAGS_threads = folly::available_concurrency();
-    CHECK_GT(FLAGS_threads, 0);
+    PRX_CHECK_GT(FLAGS_threads, 0);
   }
 
   HTTPServerOptions options;
diff --git a/proxygen/httpserver/samples/websocket/WebSocketHandler.cpp b/proxygen/httpserver/samples/websocket/WebSocketHandler.cpp
index 8b40efefd2..0a7b59a440 100644
--- a/proxygen/httpserver/samples/websocket/WebSocketHandler.cpp
+++ b/proxygen/httpserver/samples/websocket/WebSocketHandler.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/httpserver/samples/websocket/WebSocketHandler.h>
 
 #include <folly/io/async/EventBaseManager.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 
@@ -26,12 +27,12 @@ const std::string kUpgradeTo = "Websocket";
 void WebSocketHandler::onRequest(
     std::unique_ptr<HTTPMessage> request) noexcept {
 
-  VLOG(4) << " New incoming request" << *request;
+  PRX_VLOG(4) << " New incoming request" << *request;
 
   // Check if Upgrade and Connection headers are present.
   if (!request->getHeaders().exists(HTTP_HEADER_UPGRADE) ||
       !request->getHeaders().exists(HTTP_HEADER_CONNECTION)) {
-    LOG(ERROR) << " Missing Upgrade/Connection header";
+    PRX_LOG(ERROR) << " Missing Upgrade/Connection header";
     ResponseBuilder(downstream_).rejectUpgradeRequest();
     return;
   }
@@ -40,8 +41,8 @@ void WebSocketHandler::onRequest(
   const std::string& proto =
       request->getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE);
   if (!caseInsensitiveEqual(proto, kUpgradeTo)) {
-    LOG(ERROR) << "Provided upgrade protocol: '" << proto << "', expected: '"
-               << kUpgradeTo << "'";
+    PRX_LOG(ERROR) << "Provided upgrade protocol: '" << proto
+                   << "', expected: '" << kUpgradeTo << "'";
     ResponseBuilder(downstream_).rejectUpgradeRequest();
     return;
   }
@@ -56,15 +57,15 @@ void WebSocketHandler::onRequest(
 }
 
 void WebSocketHandler::onEgressPaused() noexcept {
-  VLOG(4) << "WebSocketHandler egress paused";
+  PRX_VLOG(4) << "WebSocketHandler egress paused";
 }
 
 void WebSocketHandler::onEgressResumed() noexcept {
-  VLOG(4) << "WebSocketHandler resumed";
+  PRX_VLOG(4) << "WebSocketHandler resumed";
 }
 
 void WebSocketHandler::onBody(std::unique_ptr<folly::IOBuf> body) noexcept {
-  VLOG(4) << "WebsocketHandler::onBody";
+  PRX_VLOG(4) << "WebsocketHandler::onBody";
   auto res = wsStream_->onData(std::move(body));
   if (res.hasError()) {
     ResponseBuilder response(downstream_);
@@ -80,17 +81,17 @@ void WebSocketHandler::onEOM() noexcept {
 }
 
 void WebSocketHandler::onUpgrade(UpgradeProtocol /*protocol*/) noexcept {
-  VLOG(4) << "WebSocketHandler onUpgrade";
+  PRX_VLOG(4) << "WebSocketHandler onUpgrade";
   wsStream_ = std::make_unique<WebSocketStream>();
 }
 
 void WebSocketHandler::requestComplete() noexcept {
-  VLOG(4) << " WebSocketHandler::requestComplete";
+  PRX_VLOG(4) << " WebSocketHandler::requestComplete";
   delete this;
 }
 
 void WebSocketHandler::onError(ProxygenError err) noexcept {
-  VLOG(4) << " WebSocketHandler::onError: " << err;
+  PRX_VLOG(4) << " WebSocketHandler::onError: " << err;
   delete this;
 }
 
@@ -98,7 +99,8 @@ folly::Expected<std::unique_ptr<folly::IOBuf>,
                 WebSocketStream::WebSocketStreamError>
 WebSocketStream::onData(std::unique_ptr<folly::IOBuf> chain) {
   // Parse websocket framing here etc.
-  VLOG(4) << "WebSocketStream::onData: " << chain->clone()->moveToFbString();
+  PRX_VLOG(4) << "WebSocketStream::onData: "
+              << chain->clone()->moveToFbString();
   // We just echo the bytes back.
   return std::move(chain);
 }
diff --git a/proxygen/httpserver/samples/websocket/main.cpp b/proxygen/httpserver/samples/websocket/main.cpp
index c03bf700b8..517f269931 100644
--- a/proxygen/httpserver/samples/websocket/main.cpp
+++ b/proxygen/httpserver/samples/websocket/main.cpp
@@ -15,6 +15,7 @@
 #include <proxygen/httpserver/RequestHandlerFactory.h>
 
 #include <proxygen/httpserver/samples/websocket/WebSocketHandler.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace websockethandler;
 using namespace proxygen;
@@ -56,7 +57,7 @@ int main(int argc, char* argv[]) {
 
   if (FLAGS_threads <= 0) {
     FLAGS_threads = folly::available_concurrency();
-    CHECK_GT(FLAGS_threads, 0);
+    PRX_CHECK_GT(FLAGS_threads, 0);
   }
 
   HTTPServerOptions options;
@@ -78,7 +79,7 @@ int main(int argc, char* argv[]) {
   // Start HTTPServer mainloop in a separate thread
   std::thread t([&]() { server.start(); });
 
-  LOG(INFO) << "Started websocket server";
+  PRX_LOG(INFO) << "Started websocket server";
 
   t.join();
   return 0;
diff --git a/proxygen/httpserver/tests/HTTPServerTest.cpp b/proxygen/httpserver/tests/HTTPServerTest.cpp
index 07581f85f8..f3dc55eec8 100644
--- a/proxygen/httpserver/tests/HTTPServerTest.cpp
+++ b/proxygen/httpserver/tests/HTTPServerTest.cpp
@@ -26,6 +26,7 @@
 #include <proxygen/httpserver/ResponseBuilder.h>
 #include <proxygen/httpserver/ScopedHTTPServer.h>
 #include <proxygen/lib/http/HTTPConnector.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/TestUtils.h>
 #include <wangle/acceptor/Acceptor.h>
 #include <wangle/acceptor/ServerSocketConfig.h>
@@ -380,7 +381,7 @@ class TestHandlerFactory : public RequestHandlerFactory {
 
     void onEOM() noexcept override {
       std::string certHeader;
-      auto txn = CHECK_NOTNULL(downstream_->getTransaction());
+      auto txn = PRX_CHECK_NOTNULL(downstream_->getTransaction());
       auto& transport = txn->getTransport();
       if (auto cert =
               transport.getUnderlyingTransport()->getPeerCertificate()) {
diff --git a/proxygen/lib/dns/AsyncDNSStatsCollector.cpp b/proxygen/lib/dns/AsyncDNSStatsCollector.cpp
index 228859e9d9..c869a04837 100644
--- a/proxygen/lib/dns/AsyncDNSStatsCollector.cpp
+++ b/proxygen/lib/dns/AsyncDNSStatsCollector.cpp
@@ -11,6 +11,7 @@
 #include <folly/Conv.h>
 
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 using facebook::fb303::AVG;
 using facebook::fb303::COUNT;
@@ -107,8 +108,8 @@ void AsyncDNSStatsCollector::recordSuccess(
           break;
 
         default:
-          LOG(INFO) << "Ignoring unexpected address family "
-                    << ans.address.getFamily();
+          PRX_LOG(INFO) << "Ignoring unexpected address family "
+                        << ans.address.getFamily();
           break;
       }
     } else if (ans.type == DNSResolver::Answer::AT_CNAME) {
@@ -137,7 +138,7 @@ void AsyncDNSStatsCollector::recordError(
 
   ew.with_exception([&](const DNSResolver::Exception& ex) {
     status = ex.status();
-    LOG_EVERY_N(WARNING, 100) << status << " : " << ex.what();
+    PRX_LOG_EVERY_N(WARNING, 100) << status << " : " << ex.what();
   });
 
   reqs_.add(1);
@@ -167,7 +168,7 @@ void AsyncDNSStatsCollector::recordError(
 void AsyncDNSStatsCollector::recordQueryResult(uint8_t rcode) noexcept {
   // RFC1035 defines the range of rcode values as [0, 16).
   if (rcode > 15) {
-    LOG(DFATAL) << "Invalid rcode: " << rcode;
+    PRX_LOG(DFATAL) << "Invalid rcode: " << rcode;
     return;
   }
 
diff --git a/proxygen/lib/dns/CAresResolver.cpp b/proxygen/lib/dns/CAresResolver.cpp
index d8727a3714..5676c023fb 100644
--- a/proxygen/lib/dns/CAresResolver.cpp
+++ b/proxygen/lib/dns/CAresResolver.cpp
@@ -11,7 +11,7 @@
 #include <folly/Conv.h>
 #include <folly/io/async/EventHandler.h>
 #include <folly/portability/Sockets.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Time.h>
 
 using namespace proxygen;
@@ -87,8 +87,8 @@ CAresResolver::Query::Query(CAresResolver* resolver,
 
 void CAresResolver::Query::resolve(ResolutionCallback* cb,
                                    std::chrono::milliseconds timeout) {
-  CHECK(callback_ == nullptr);
-  CHECK(cb != nullptr);
+  PRX_CHECK(callback_ == nullptr);
+  PRX_CHECK(cb != nullptr);
 
   dnsEvent_.start(*timeUtil_);
 
@@ -96,8 +96,8 @@ void CAresResolver::Query::resolve(ResolutionCallback* cb,
   callback_->insertQuery(this);
   startTime_ = getCurrentTime();
   if (timeout.count() > 0 && !scheduleTimeout(timeout.count())) {
-    LOG(DFATAL) << "Failed to schedule timeout for query " << name_
-                << " with type " << static_cast<int>(type_);
+    PRX_LOG(DFATAL) << "Failed to schedule timeout for query " << name_
+                    << " with type " << static_cast<int>(type_);
   }
   resolver_->query(name_, type_, Query::queryCallback, this);
 }
@@ -416,9 +416,9 @@ void CAresResolver::Query::queryCallback(
     }
 
     default:
-      LOG(ERROR) << "Couldn't handle answer for query type "
-                 << static_cast<int>(self->type_) << ", during resolving "
-                 << self->name_;
+      PRX_LOG(ERROR) << "Couldn't handle answer for query type "
+                     << static_cast<int>(self->type_) << ", during resolving "
+                     << self->name_;
       self->fail(
           PARSE_ERROR,
           folly::to<std::string>("Failed to parse answer for query type: ",
@@ -482,9 +482,9 @@ class CAresResolver::MultiQuery
   void resolve(ResolutionCallback* callback,
                const std::list<Query*>& queries,
                std::chrono::milliseconds timeout) {
-    CHECK(callback_ == nullptr);
-    CHECK(callback != nullptr);
-    CHECK_EQ(0, queries_);
+    PRX_CHECK(callback_ == nullptr);
+    PRX_CHECK(callback != nullptr);
+    PRX_CHECK_EQ(0, queries_);
 
     callback_ = callback;
     callback_->insertQuery(this);
@@ -631,12 +631,12 @@ CAresResolver::~CAresResolver() {
 
   // Once ares_destroy() has run, it should have invoked dnsSocketReady() on
   // all of our sockets to clean them up
-  LOG_IF(DFATAL, !socketHandlers_.empty())
+  PRX_LOG_IF(DFATAL, !socketHandlers_.empty())
       << "Found orphaned sockets after ares_destroy()";
 }
 
 void CAresResolver::attachEventBase(EventBase* base) {
-  LOG_IF(DFATAL, base_ != nullptr)
+  PRX_LOG_IF(DFATAL, base_ != nullptr)
       << "Overwriting existing non-nullptr EventBase";
 
   base_ = base;
@@ -676,8 +676,8 @@ void CAresResolver::noteCAresQueryStarted() {
 
 void CAresResolver::noteCAresQueryCompleted() {
   if (caresActiveQueries_ == 0) {
-    LOG(ERROR) << "Invalid c-ares active query count in "
-                  "`CAresResolver::queryCallback()`";
+    PRX_LOG(ERROR) << "Invalid c-ares active query count in "
+                      "`CAresResolver::queryCallback()`";
     return;
   }
   --caresActiveQueries_;
@@ -711,7 +711,7 @@ void CAresResolver::recordSocketClosed() {
   getStatsCollector()->recordCAresSocketClose();
 }
 void CAresResolver::init() {
-  CHECK(base_ != nullptr);
+  PRX_CHECK(base_ != nullptr);
 
   // Initialize our channel
   int optmask = 0;
@@ -745,7 +745,7 @@ void CAresResolver::init() {
 
   int err = ares_init_options(&channel_, &opts, optmask);
   if (err != ARES_SUCCESS) {
-    LOG(DFATAL) << "ares_init_options() failed: " << ares_strerror(err);
+    PRX_LOG(DFATAL) << "ares_init_options() failed: " << ares_strerror(err);
     return;
   }
 
@@ -777,8 +777,8 @@ void CAresResolver::init() {
         }
 
         default:
-          LOG(DFATAL) << "Unknown address type " << ares_addr->family
-                      << "; failing to change nameservers";
+          PRX_LOG(DFATAL) << "Unknown address type " << ares_addr->family
+                          << "; failing to change nameservers";
           return;
       }
 
@@ -787,7 +787,7 @@ void CAresResolver::init() {
 
     err = ares_set_servers(channel_, ares_addrs.get());
     if (err != ARES_SUCCESS) {
-      LOG(DFATAL) << "ares_set_servers() failed: " << ares_strerror(err);
+      PRX_LOG(DFATAL) << "ares_set_servers() failed: " << ares_strerror(err);
       return;
     }
   }
@@ -797,14 +797,14 @@ void CAresResolver::resolveAddress(DNSResolver::ResolutionCallback* cb,
                                    const SocketAddress& address,
                                    std::chrono::milliseconds timeout) {
   if (timeout > kMaxTimeout) {
-    LOG(WARNING) << "Attempt to resolve " << address.getAddressStr()
-                 << " specified with " << "timeout of " << timeout.count()
-                 << "ms; " << "clamping to " << kMaxTimeout.count() << "ms";
+    PRX_LOG(WARNING) << "Attempt to resolve " << address.getAddressStr()
+                     << " specified with " << "timeout of " << timeout.count()
+                     << "ms; " << "clamping to " << kMaxTimeout.count() << "ms";
     timeout = kMaxTimeout;
   }
 
   if (address.getFamily() != AF_INET && address.getFamily() != AF_INET6) {
-    LOG(ERROR) << "Unsupported address family " << address.getFamily();
+    PRX_LOG(ERROR) << "Unsupported address family " << address.getFamily();
     auto ew = folly::make_exception_wrapper<Exception>(
         INVALID,
         folly::to<std::string>("Unsupported address family: ",
@@ -892,9 +892,9 @@ void CAresResolver::resolveHostname(DNSResolver::ResolutionCallback* cb,
   }
 
   if (timeout > kMaxTimeout) {
-    LOG(WARNING) << "Attempt to resolve " << host << " specified with "
-                 << "timeout of " << timeout.count() << "ms; clamping to "
-                 << kMaxTimeout.count() << "ms";
+    PRX_LOG(WARNING) << "Attempt to resolve " << host << " specified with "
+                     << "timeout of " << timeout.count() << "ms; clamping to "
+                     << kMaxTimeout.count() << "ms";
     timeout = kMaxTimeout;
   }
 
@@ -961,7 +961,7 @@ void CAresResolver::resolveHostname(DNSResolver::ResolutionCallback* cb,
                 std::chrono::milliseconds(timeout));
     issuedQuery = true;
   } else {
-    LOG(DFATAL) << "Unsupported family specified: " << family;
+    PRX_LOG(DFATAL) << "Unsupported family specified: " << family;
     auto ew = folly::make_exception_wrapper<Exception>(
         INVALID,
         folly::to<std::string>("Unsupported address family: ", family));
@@ -977,9 +977,9 @@ void CAresResolver::resolveMailExchange(DNSResolver::ResolutionCallback* cb,
                                         const std::string& domain,
                                         std::chrono::milliseconds timeout) {
   if (timeout > kMaxTimeout) {
-    LOG(WARNING) << "Attempt to resolve mail exchange info for " << domain
-                 << " specified with " << "timeout of " << timeout.count()
-                 << "ms; " << "clamping to " << kMaxTimeout.count() << "ms";
+    PRX_LOG(WARNING) << "Attempt to resolve mail exchange info for " << domain
+                     << " specified with " << "timeout of " << timeout.count()
+                     << "ms; " << "clamping to " << kMaxTimeout.count() << "ms";
     timeout = kMaxTimeout;
   }
 
@@ -1047,7 +1047,8 @@ void CAresResolver::query(const std::string& name,
 
 void CAresResolver::queryFinished() {
   if (channelRefcnt_ == 0) {
-    LOG(ERROR) << "Invalid channel refcount in CAresResolver::queryFinished()";
+    PRX_LOG(ERROR)
+        << "Invalid channel refcount in CAresResolver::queryFinished()";
     return;
   }
   if (--channelRefcnt_ == 0) {
@@ -1066,7 +1067,7 @@ void CAresResolver::dnsSocketReady(void* data,
 
   // Ares is done with this socket; stop watching it
   if (!read && !write) {
-    LOG_IF(DFATAL, it == self->socketHandlers_.end())
+    PRX_LOG_IF(DFATAL, it == self->socketHandlers_.end())
         << "dnsSocketReady() asked to close a socket that we don't kow about";
     if (it != self->socketHandlers_.end()) {
       self->socketHandlers_.erase(it);
@@ -1095,7 +1096,7 @@ void CAresResolver::dnsSocketReady(void* data,
   events |= (read) ? EventHandler::READ : 0;
   events |= (write) ? EventHandler::WRITE : 0;
   if (!shp->registerHandler(events)) {
-    LOG(DFATAL) << "Failed to register SocketHandler";
+    PRX_LOG(DFATAL) << "Failed to register SocketHandler";
   }
   if (inserted) {
     self->recordSocketOpened();
@@ -1105,7 +1106,7 @@ void CAresResolver::dnsSocketReady(void* data,
 
 void CAresResolver::initGlobal() {
   int err = ares_library_init(ARES_LIB_INIT_ALL);
-  LOG_IF(FATAL, err != 0) << "ares_library_init() failed";
+  PRX_LOG_IF(FATAL, err != 0) << "ares_library_init() failed";
 }
 
 void CAresResolver::destroyGlobal() {
diff --git a/proxygen/lib/dns/CMakeLists.txt b/proxygen/lib/dns/CMakeLists.txt
index 527b5a4fc2..c0d73a9d54 100644
--- a/proxygen/lib/dns/CMakeLists.txt
+++ b/proxygen/lib/dns/CMakeLists.txt
@@ -11,8 +11,8 @@ proxygen_add_library(proxygen_dns_dns_base
     DNSResolver.cpp
     NaiveResolutionCallback.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_conv
-    glog::glog
   EXPORTED_DEPS
     proxygen_utils_trace
     Folly::folly_exception_wrapper
@@ -58,11 +58,11 @@ proxygen_add_library(proxygen_dns_cares_dns
   SRCS
     CAresResolver.cpp
   DEPS
+    proxygen_utils_log_shim
     proxygen_utils_time_util
     Folly::folly_conv
     Folly::folly_portability_sockets
     cares
-    glog::glog
   EXPORTED_DEPS
     proxygen_dns_dns_base
     Folly::folly_expected
@@ -75,6 +75,8 @@ proxygen_add_library(proxygen_dns_cares_dns
 proxygen_add_library(proxygen_dns_future_dns
   SRCS
     FutureDNSResolver.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_dns_dns_base
     Folly::folly_futures_core
diff --git a/proxygen/lib/dns/DNSResolver.cpp b/proxygen/lib/dns/DNSResolver.cpp
index 7f68c6718e..f0d283bc2a 100644
--- a/proxygen/lib/dns/DNSResolver.cpp
+++ b/proxygen/lib/dns/DNSResolver.cpp
@@ -9,7 +9,7 @@
 #include "proxygen/lib/dns/DNSResolver.h"
 
 #include <folly/Conv.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::SocketAddress;
 using proxygen::DNSResolver;
@@ -128,8 +128,8 @@ std::string DNSResolver::getPtrName(const SocketAddress& address) {
     }
 
     default:
-      LOG(FATAL) << "Unsupported address family " << address.getFamily()
-                 << " could not be turned into a PTR name";
+      PRX_LOG(FATAL) << "Unsupported address family " << address.getFamily()
+                     << " could not be turned into a PTR name";
   }
 
   return std::string(buf);
diff --git a/proxygen/lib/dns/FutureDNSResolver.cpp b/proxygen/lib/dns/FutureDNSResolver.cpp
index 5e73b3eab5..ff60a2c66e 100644
--- a/proxygen/lib/dns/FutureDNSResolver.cpp
+++ b/proxygen/lib/dns/FutureDNSResolver.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/dns/FutureDNSResolver.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 namespace {
@@ -36,9 +37,9 @@ class FutureDNSResolutionCallback : public DNSResolver::ResolutionCallback {
 FutureDNSResolver::FutureDNSResolver(folly::EventBase* evb,
                                      DNSResolver::UniquePtr resolver)
     : evb_{evb}, resolver_{std::move(resolver)} {
-  CHECK_NE(static_cast<folly::EventBase*>(nullptr), evb_)
+  PRX_CHECK_NE(static_cast<folly::EventBase*>(nullptr), evb_)
       << "EventBase must not be null";
-  CHECK_NE(static_cast<DNSResolver*>(nullptr), resolver_.get())
+  PRX_CHECK_NE(static_cast<DNSResolver*>(nullptr), resolver_.get())
       << "DNS resolver must not be null";
 }
 
diff --git a/proxygen/lib/dns/test/CachingDNSResolverTest.cpp b/proxygen/lib/dns/test/CachingDNSResolverTest.cpp
index 4a19b53df4..6aa60ea9ad 100644
--- a/proxygen/lib/dns/test/CachingDNSResolverTest.cpp
+++ b/proxygen/lib/dns/test/CachingDNSResolverTest.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/utils/test/MockTime.h>
 
 #include "proxygen/lib/dns/test/Dummies.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace std;
@@ -34,7 +35,7 @@ class CachingDNSResolverFixture : public testing::Test {
     DNSResolver::UniquePtr p(new DummyDNSResolver());
     auto timeUtil = std::make_unique<MockTimeUtil>();
     underlyingResolver_ = dynamic_cast<DummyDNSResolver*>(p.get());
-    CHECK(underlyingResolver_);
+    PRX_CHECK(underlyingResolver_);
     timeUtil_ = timeUtil.get();
 
     cachingResolver_ =
diff --git a/proxygen/lib/dns/test/FutureDNSResolverTest.cpp b/proxygen/lib/dns/test/FutureDNSResolverTest.cpp
index 3dc5022cb5..9ea835d9f9 100644
--- a/proxygen/lib/dns/test/FutureDNSResolverTest.cpp
+++ b/proxygen/lib/dns/test/FutureDNSResolverTest.cpp
@@ -15,6 +15,7 @@
 #include <folly/io/async/EventBase.h>
 #include <folly/io/async/EventBaseManager.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::string;
 
@@ -48,7 +49,7 @@ class FakeDNSResolver : public DNSResolver {
         addrToHostMap_{addrToHostMap},
         hostToAddrMap_{invert(addrToHostMap)},
         mailExchangeMap_{std::move(domainToMailExchangeMap)} {
-    CHECK_EQ(addrToHostMap_.size(), hostToAddrMap_.size());
+    PRX_CHECK_EQ(addrToHostMap_.size(), hostToAddrMap_.size());
   }
 
   ~FakeDNSResolver() override = default;
diff --git a/proxygen/lib/http/CMakeLists.txt b/proxygen/lib/http/CMakeLists.txt
index 1f63b33298..d87a76eeeb 100644
--- a/proxygen/lib/http/CMakeLists.txt
+++ b/proxygen/lib/http/CMakeLists.txt
@@ -40,6 +40,7 @@ proxygen_add_library(proxygen_http_http_message_filters
   EXPORTED_DEPS
     proxygen_http_session_http_transaction
     proxygen_http_sink_client_sink_interface
+    proxygen_utils_log_shim
     Folly::folly_io_async_destructor_check
     Folly::folly_memory
 )
@@ -52,9 +53,9 @@ proxygen_add_library(proxygen_http_client
     proxygen_http_codec_http2_codec
     proxygen_http_session_http_transaction
     proxygen_http_session_http_upstream_session
+    proxygen_utils_log_shim
     wangle::wangle_ssl_ssl_util
     Folly::folly_io_async_async_ssl_socket
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     proxygen_http_codec_codec_factory
@@ -78,6 +79,7 @@ proxygen_add_library(proxygen_http_http_connector_with_fizz
     HTTPConnectorWithFizz.cpp
   DEPS
     proxygen_http_session_http_upstream_session
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_client
     fizz::fizz
@@ -90,10 +92,10 @@ proxygen_add_library(proxygen_http_hq_connector
   DEPS
     proxygen_http_codec_h3_early_data_handler
     proxygen_http_session_hq_session
+    proxygen_utils_log_shim
     mvfst::mvfst_common_udpsocket_folly_async_udp_socket
     mvfst::mvfst_congestion_control_congestion_controller_factory
     mvfst::mvfst_fizz_client_handshake
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_session_hq_upstream_session
     mvfst::mvfst_api_loop_detector_callback
@@ -110,7 +112,7 @@ proxygen_add_library(proxygen_http_window
   SRCS
     Window.cpp
   DEPS
-    glog::glog
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_http_common
@@ -139,6 +141,7 @@ proxygen_add_library(proxygen_http_http_utils
     proxygen_http_h3_errors
     proxygen_http_message
     proxygen_utils_exception
+    proxygen_utils_log_shim
     Folly::folly_memory
 )
 
@@ -149,9 +152,9 @@ proxygen_add_library(proxygen_http_http_headers
     RFC2616.cpp
   DEPS
     proxygen_http_http_common_headers
+    proxygen_utils_log_shim
     Folly::folly_indestructible
     Folly::folly_thread_local
-    glog::glog
   EXPORTED_DEPS
     proxygen_utils_export
     proxygen_utils_util_inl
@@ -182,13 +185,13 @@ proxygen_add_library(proxygen_http_message
     proxygen_http_http_header_size
     proxygen_http_http_headers
     proxygen_http_types
+    proxygen_utils_log_shim
     proxygen_utils_parse_url
     proxygen_utils_time_util
     Folly::folly_conv
     Folly::folly_io_iobuf
     Folly::folly_network_address
     Folly::folly_optional
-    glog::glog
 )
 
 proxygen_add_library(proxygen_http_priority_functions
@@ -196,6 +199,7 @@ proxygen_add_library(proxygen_http_priority_functions
     HTTPPriorityFunctions.cpp
   DEPS
     proxygen_http_structuredheaders_decoder
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_message
     Folly::folly_optional
@@ -206,12 +210,14 @@ proxygen_add_library(proxygen_http_h3_errors
   SRCS
     HTTP3ErrorCode.cpp
   DEPS
-    glog::glog
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_synchronized_quic_lrucache
   SRCS
     SynchronizedLruQuicPskCache.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     mvfst::mvfst_fizz_client_handshake_psk_cache
     Folly::folly_container_evicting_cache_map
@@ -222,7 +228,7 @@ proxygen_add_library(proxygen_http_proxy_status
   SRCS
     ProxyStatus.cpp
   DEPS
-    glog::glog
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_status_type
     proxygen_http_structuredheaders_encoder
diff --git a/proxygen/lib/http/HQConnector.cpp b/proxygen/lib/http/HQConnector.cpp
index 971ccfc1af..f48a7011bd 100644
--- a/proxygen/lib/http/HQConnector.cpp
+++ b/proxygen/lib/http/HQConnector.cpp
@@ -9,9 +9,9 @@
 #include <proxygen/lib/http/HQConnector.h>
 
 #include <folly/io/SocketOptionMap.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
 #include <proxygen/lib/http/session/HQSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/common/events/FollyQuicEventBase.h>
 #include <quic/common/udpsocket/FollyQuicAsyncUDPSocket.h>
@@ -26,14 +26,14 @@ namespace proxygen {
 HQConnector::HQConnector(Callback* callback,
                          std::chrono::milliseconds transactionTimeout,
                          bool useConnectionEndWithErrorCallback)
-    : cb_(CHECK_NOTNULL(callback)),
+    : cb_(PRX_CHECK_NOTNULL(callback)),
       transactionTimeout_(transactionTimeout),
       useConnectionEndWithErrorCallback_(useConnectionEndWithErrorCallback) {
-  XLOG(DBG5) << "HQConnector";
+  PRX_VLOG(5) << "HQConnector";
 }
 
 HQConnector::~HQConnector() {
-  XLOG(DBG5) << "~HQConnector";
+  PRX_VLOG(5) << "~HQConnector";
   reset();
 }
 
@@ -45,7 +45,7 @@ std::chrono::microseconds HQConnector::timeElapsed() {
 }
 
 void HQConnector::reset() {
-  XLOG(DBG5) << "reset";
+  PRX_VLOG(5) << "reset";
   if (session_) {
     // This destroys the session
     session_->dropConnection();
@@ -76,8 +76,8 @@ void HQConnector::connect(
     std::shared_ptr<quic::LoopDetectorCallback> quicLoopDetectorCallback,
     std::shared_ptr<quic::QuicTransportStatsCallback>
         quicTransportStatsCallback) {
-  XLOG(DBG5) << "connect, timeout=" << connectTimeout.count() << "ms";
-  DCHECK(!isBusy());
+  PRX_VLOG(5) << "connect, timeout=" << connectTimeout.count() << "ms";
+  PRX_DCHECK(!isBusy());
   auto qEvb = std::make_shared<quic::FollyQuicEventBase>(eventBase);
   auto sock = std::make_unique<quic::FollyQuicAsyncUDPSocket>(qEvb);
   auto quicClient = quic::QuicClientTransport::newClient(
@@ -125,13 +125,13 @@ void HQConnector::connect(
   session_->setEarlyDataHandler(std::move(earlyDataHandler));
   session_->startNow();
 
-  VLOG(4) << "connecting to " << connectAddr.describe();
+  PRX_VLOG(4) << "connecting to " << connectAddr.describe();
   connectStart_ = getCurrentTime();
   quicClient->start(session_, session_);
 }
 
 void HQConnector::onReplaySafe() noexcept {
-  CHECK(session_);
+  PRX_CHECK(session_);
   if (cb_) {
     auto session = session_;
     session_ = nullptr;
@@ -140,8 +140,8 @@ void HQConnector::onReplaySafe() noexcept {
 }
 
 void HQConnector::connectError(quic::QuicError error) noexcept {
-  XLOG(DBG4) << "connectError, error=" << error.code;
-  CHECK(session_);
+  PRX_VLOG(4) << "connectError, error=" << error.code;
+  PRX_CHECK(session_);
   reset();
   if (cb_) {
     cb_->connectError(error.code);
diff --git a/proxygen/lib/http/HTTP3ErrorCode.cpp b/proxygen/lib/http/HTTP3ErrorCode.cpp
index 2e61636e5f..fa075460e3 100644
--- a/proxygen/lib/http/HTTP3ErrorCode.cpp
+++ b/proxygen/lib/http/HTTP3ErrorCode.cpp
@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <glog/logging.h>
 #include <proxygen/lib/http/HTTP3ErrorCode.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -56,7 +56,7 @@ std::string toString(HTTP3::ErrorCode code) {
     case HTTP3::ErrorCode::GIVEUP_ZERO_RTT:
       return "Give up Zero RTT";
   }
-  LOG(WARNING)
+  PRX_LOG(WARNING)
       << "toString has unhandled ErrorCode: "
       << static_cast<std::underlying_type<HTTP3::ErrorCode>::type>(code);
   return "Unknown error";
diff --git a/proxygen/lib/http/HTTPConnector.cpp b/proxygen/lib/http/HTTPConnector.cpp
index 3a605929a5..45576f47ca 100644
--- a/proxygen/lib/http/HTTPConnector.cpp
+++ b/proxygen/lib/http/HTTPConnector.cpp
@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/HTTPConnector.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/io/SocketOptionMap.h>
 #include <folly/io/async/AsyncSSLSocket.h>
@@ -30,25 +30,25 @@ HTTPConnector::HTTPConnector(Callback* callback,
 
 HTTPConnector::HTTPConnector(Callback* callback,
                              const WheelTimerInstance& timeout)
-    : cb_(CHECK_NOTNULL(callback)),
+    : cb_(PRX_CHECK_NOTNULL(callback)),
       timeout_(timeout),
       httpCodecFactory_(std::make_unique<DefaultHTTPCodecFactory>()) {
-  XLOG(DBG4) << "HTTPConnector";
+  PRX_VLOG(4) << "HTTPConnector";
 }
 
 HTTPConnector::~HTTPConnector() {
-  XLOG(DBG4) << "~HTTPConnector";
+  PRX_VLOG(4) << "~HTTPConnector";
   reset(false);
 }
 
 void HTTPConnector::reset(bool invokeCallbacks) {
-  XLOG(DBG4) << "reset invokeCallbacks=" << invokeCallbacks;
+  PRX_VLOG(4) << "reset invokeCallbacks=" << invokeCallbacks;
   if (socket_) {
     auto cb = cb_;
     if (!invokeCallbacks) {
       cb_ = nullptr;
     }
-    XLOG(DBG4) << "socket_.reset()";
+    PRX_VLOG(4) << "socket_.reset()";
     socket_.reset(); // This invokes connectError() but will be ignored
     cb_ = cb;
   }
@@ -68,8 +68,8 @@ void HTTPConnector::connect(EventBase* eventBase,
                             const SocketOptionMap& socketOptions,
                             const folly::SocketAddress& bindAddr) {
 
-  XLOG(DBG4) << "connect";
-  DCHECK(!isBusy());
+  PRX_VLOG(4) << "connect";
+  PRX_DCHECK(!isBusy());
   transportInfo_ = wangle::TransportInfo();
   transportInfo_.secure = false;
   auto sock = new AsyncSocket(eventBase);
@@ -88,8 +88,8 @@ void HTTPConnector::connectSSL(EventBase* eventBase,
                                const folly::SocketAddress& bindAddr,
                                const std::string& serverName) {
 
-  XLOG(DBG4) << "connectSSL";
-  DCHECK(!isBusy());
+  PRX_VLOG(4) << "connectSSL";
+  PRX_DCHECK(!isBusy());
   transportInfo_ = wangle::TransportInfo();
   transportInfo_.secure = true;
   auto sslSock = new AsyncSSLSocket(context, eventBase);
@@ -148,7 +148,7 @@ void HTTPConnector::connectSuccess() noexcept {
     proto = &plaintextProtocol_;
   }
 
-  CHECK(proto);
+  PRX_CHECK(proto);
   codec = httpCodecFactory_->getCodec(
       *proto, TransportDirection::UPSTREAM, transportInfo_.secure);
 
@@ -169,12 +169,12 @@ void HTTPConnector::connectSuccess() noexcept {
                                           transportInfo_,
                                           nullptr);
 
-  XLOG(DBG5) << " connectSuccess, HTTPUpstreamSession " << session;
+  PRX_VLOG(5) << " connectSuccess, HTTPUpstreamSession " << session;
   cb_->connectSuccess(session);
 }
 
 void HTTPConnector::connectErr(const AsyncSocketException& ex) noexcept {
-  XLOG(DBG3) << " connectErr " << ex.what();
+  PRX_VLOG(3) << " connectErr " << ex.what();
   socket_.reset();
   if (cb_) {
     cb_->connectError(ex);
diff --git a/proxygen/lib/http/HTTPConnectorWithFizz.cpp b/proxygen/lib/http/HTTPConnectorWithFizz.cpp
index b5a5ef9aa6..21e6196af8 100644
--- a/proxygen/lib/http/HTTPConnectorWithFizz.cpp
+++ b/proxygen/lib/http/HTTPConnectorWithFizz.cpp
@@ -8,6 +8,7 @@
 
 #include <proxygen/lib/http/HTTPConnectorWithFizz.h>
 #include <proxygen/lib/http/session/HTTPUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace fizz::client;
 
@@ -24,7 +25,7 @@ void HTTPConnectorWithFizz::connectFizz(
     const folly::SocketAddress& bindAddr,
     folly::Optional<std::string> sni,
     folly::Optional<std::string> pskIdentity) {
-  DCHECK(!isBusy());
+  PRX_DCHECK(!isBusy());
   transportInfo_ = wangle::TransportInfo();
   transportInfo_.secure = true;
 
diff --git a/proxygen/lib/http/HTTPException.cpp b/proxygen/lib/http/HTTPException.cpp
index 513baf3328..6fb08af2e4 100644
--- a/proxygen/lib/http/HTTPException.cpp
+++ b/proxygen/lib/http/HTTPException.cpp
@@ -9,6 +9,7 @@
 #include <sstream>
 
 #include <proxygen/lib/http/HTTPException.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -21,7 +22,7 @@ HTTP3::ErrorCode toHTTP3ErrorCode(proxygen::ErrorCode err) {
     case ErrorCode::INTERNAL_ERROR:
       return HTTP3::ErrorCode::HTTP_INTERNAL_ERROR;
     case ErrorCode::FLOW_CONTROL_ERROR:
-      DCHECK(false) << "ErrorCode::FLOW_CONTROL_ERROR for QUIC";
+      PRX_DCHECK(false) << "ErrorCode::FLOW_CONTROL_ERROR for QUIC";
 #ifdef NDEBUG
       [[fallthrough]];
 #endif
diff --git a/proxygen/lib/http/HTTPException.h b/proxygen/lib/http/HTTPException.h
index c60edd22fe..906eca3096 100644
--- a/proxygen/lib/http/HTTPException.h
+++ b/proxygen/lib/http/HTTPException.h
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/codec/ErrorCode.h>
 #include <proxygen/lib/utils/Exception.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -97,7 +98,7 @@ class HTTPException : public proxygen::Exception {
     codecStatusCode_ = statusCode;
   }
   [[nodiscard]] ErrorCode getCodecStatusCode() const {
-    CHECK(hasCodecStatusCode());
+    PRX_CHECK(hasCodecStatusCode());
     return *codecStatusCode_;
   }
 
diff --git a/proxygen/lib/http/HTTPHeaders.cpp b/proxygen/lib/http/HTTPHeaders.cpp
index db7c9dc94f..efe483ce02 100644
--- a/proxygen/lib/http/HTTPHeaders.cpp
+++ b/proxygen/lib/http/HTTPHeaders.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/HTTPHeaders.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::bitset;
 using std::string;
@@ -312,8 +312,8 @@ void HTTPHeaders::stripPerHopHeaders(HTTPHeaders& strippedHeaders,
             if (len > 0) {
               string hdr(str, len);
               if (transferHeaderIfPresent(hdr, strippedHeaders)) {
-                VLOG(3) << "Stripped connection-named hop-by-hop header "
-                        << hdr;
+                PRX_VLOG(3)
+                    << "Stripped connection-named hop-by-hop header " << hdr;
               }
             }
             break;
@@ -327,7 +327,8 @@ void HTTPHeaders::stripPerHopHeaders(HTTPHeaders& strippedHeaders,
             // non-empty token
             string hdr(str, len);
             if (transferHeaderIfPresent(hdr, strippedHeaders)) {
-              VLOG(3) << "Stripped connection-named hop-by-hop header " << hdr;
+              PRX_VLOG(3) << "Stripped connection-named hop-by-hop header "
+                          << hdr;
             }
           } // else empty token, no-op
           str = pos + 1;
@@ -357,7 +358,7 @@ void HTTPHeaders::stripPerHopHeaders(HTTPHeaders& strippedHeaders,
       strippedHeaders.emplace_back(code, names()[i], std::move(values()[i]));
       code = HTTP_HEADER_NONE;
       ++deletedCount_;
-      VLOG(5) << "Stripped hop-by-hop header " << *names()[i];
+      PRX_VLOG(5) << "Stripped hop-by-hop header " << *names()[i];
     }
   }
 }
diff --git a/proxygen/lib/http/HTTPMessage.cpp b/proxygen/lib/http/HTTPMessage.cpp
index cf8683f290..d62ee1a6f1 100644
--- a/proxygen/lib/http/HTTPMessage.cpp
+++ b/proxygen/lib/http/HTTPMessage.cpp
@@ -13,6 +13,7 @@
 #include <folly/SingletonThreadLocal.h>
 #include <folly/String.h>
 #include <mutex>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::StringPiece;
 using std::pair;
@@ -245,7 +246,7 @@ void HTTPMessage::setMethod(HTTPMethod method) {
 }
 
 void HTTPMessage::setMethod(folly::StringPiece method) {
-  VLOG(9) << "setMethod: " << method;
+  PRX_VLOG(9) << "setMethod: " << method;
   Request& req = request();
   folly::Optional<HTTPMethod> result = stringToMethod(method);
   if (result) {
@@ -401,7 +402,7 @@ void HTTPMessage::constructDirectResponse(const pair<uint8_t, uint8_t>& version,
 }
 
 void HTTPMessage::parseCookies() const {
-  DCHECK(!parsedCookies_);
+  PRX_DCHECK(!parsedCookies_);
   parsedCookies_ = true;
 
   headers_.forEachValueOfHeader(
@@ -476,7 +477,7 @@ void HTTPMessage::removeCookie(const string& name) {
 }
 
 void HTTPMessage::parseQueryParams() const {
-  DCHECK(!parsedQueryParams_);
+  PRX_DCHECK(!parsedQueryParams_);
   const Request& req = request();
 
   parsedQueryParams_ = true;
@@ -555,7 +556,8 @@ std::string HTTPMessage::getDecodedQueryParam(const std::string& name) const {
   try {
     folly::uriUnescape(val, result, folly::UriEscapeMode::QUERY);
   } catch (const std::exception& ex) {
-    LOG(WARNING) << "Invalid escaped query param: " << folly::exceptionStr(ex);
+    PRX_LOG(WARNING) << "Invalid escaped query param: "
+                     << folly::exceptionStr(ex);
   }
   return result;
 }
@@ -590,7 +592,7 @@ bool HTTPMessage::setQueryStringImpl(const std::string& query,
     return !strict || res.valid();
   }
 
-  DVLOG(4) << "Error parsing URL during setQueryString: " << request().url_;
+  PRX_DVLOG(4) << "Error parsing URL during setQueryString: " << request().url_;
   return false;
 }
 
@@ -750,7 +752,7 @@ std::ostream& operator<<(std::ostream& os, const HTTPMessage& msg) {
 }
 
 void HTTPMessage::dumpMessage(int vlogLevel) const {
-  DVLOG(vlogLevel) << *this;
+  PRX_DVLOG_LEVEL(vlogLevel) << *this;
 }
 
 void HTTPMessage::describe(std::ostream& os) const {
@@ -995,14 +997,14 @@ ParseURL HTTPMessage::setURLImplInternal(bool unparse, bool strict) {
   auto& req = request();
   auto u = ParseURL::parseURLMaybeInvalid(req.url_, strict);
   if (u.valid()) {
-    DVLOG(9) << "set path: " << u.path() << " query:" << u.query();
+    PRX_DVLOG(9) << "set path: " << u.path() << " query:" << u.query();
     req.path_ = u.path();
     req.query_ = u.query();
     if (req.path_.empty()) {
       req.path_.reset("/", 1);
     }
   } else {
-    DVLOG(4) << "Error in parsing URL: " << req.url_;
+    PRX_DVLOG(4) << "Error in parsing URL: " << req.url_;
     req.path_.clear();
     req.query_.clear();
   }
diff --git a/proxygen/lib/http/HTTPMessage.h b/proxygen/lib/http/HTTPMessage.h
index 5d79c19cbb..982f3761bb 100644
--- a/proxygen/lib/http/HTTPMessage.h
+++ b/proxygen/lib/http/HTTPMessage.h
@@ -12,13 +12,13 @@
 #include <folly/Optional.h>
 #include <folly/SocketAddress.h>
 #include <folly/io/IOBufQueue.h>
-#include <glog/logging.h>
 #include <map>
 #include <proxygen/lib/http/HTTPHeaderSize.h>
 #include <proxygen/lib/http/HTTPHeaders.h>
 #include <proxygen/lib/http/HTTPMethod.h>
 #include <proxygen/lib/http/HeaderConstants.h>
 #include <proxygen/lib/http/Types.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/ParseURL.h>
 #include <proxygen/lib/utils/Time.h>
 #include <string>
@@ -662,7 +662,7 @@ class HTTPMessage {
                           const HTTPHeaders* customHeaders = nullptr);
 
   const HTTPHeaders& getStrippedPerHopHeaders() const {
-    CHECK(strippedPerHopHeaders_) << "call stripPerHopHeaders first";
+    PRX_CHECK(strippedPerHopHeaders_) << "call stripPerHopHeaders first";
     return *strippedPerHopHeaders_;
   }
 
@@ -904,7 +904,7 @@ class HTTPMessage {
 
   template <typename T> // T = string
   ParseURL setURLImpl(T&& url, bool unparse, bool strict) {
-    DVLOG(9) << "setURL: " << std::forward<T>(url);
+    PRX_DVLOG(9) << "setURL: " << std::forward<T>(url);
 
     // Set the URL, path, and query string parameters
     request().url_ = std::forward<T>(url);
@@ -1071,8 +1071,8 @@ class HTTPMessage {
   } fields_;
 
   Request& request() {
-    DCHECK(fields_.which_ == MessageType::NONE ||
-           fields_.which_ == MessageType::REQUEST)
+    PRX_DCHECK(fields_.which_ == MessageType::NONE ||
+               fields_.which_ == MessageType::REQUEST)
         << int(fields_.which_);
     if (fields_.which_ == MessageType::NONE) {
       fields_.which_ = MessageType::REQUEST;
@@ -1090,8 +1090,8 @@ class HTTPMessage {
   }
 
   Response& response() {
-    DCHECK(fields_.which_ == MessageType::NONE ||
-           fields_.which_ == MessageType::RESPONSE)
+    PRX_DCHECK(fields_.which_ == MessageType::NONE ||
+               fields_.which_ == MessageType::RESPONSE)
         << int(fields_.which_);
     if (fields_.which_ == MessageType::NONE) {
       fields_.which_ = MessageType::RESPONSE;
diff --git a/proxygen/lib/http/HTTPMessageFilters.h b/proxygen/lib/http/HTTPMessageFilters.h
index 08ec27028f..ccc03bb2be 100644
--- a/proxygen/lib/http/HTTPMessageFilters.h
+++ b/proxygen/lib/http/HTTPMessageFilters.h
@@ -14,6 +14,7 @@
 
 #include <proxygen/lib/http/sink/HTTPSink.h>
 
+#include <proxygen/lib/utils/LogShim.h>
 #include <string_view>
 #include <variant>
 
@@ -26,21 +27,21 @@ class HTTPMessageFilter
     , public folly::DestructorCheck {
  public:
   void setNextTransactionHandler(HTTPTransaction::Handler* next) {
-    nextTransactionHandler_ = CHECK_NOTNULL(next);
+    nextTransactionHandler_ = PRX_CHECK_NOTNULL(next);
   }
   virtual void setPrevFilter(HTTPMessageFilter* prev) noexcept {
     if (prev_.index() == 0 && std::get<HTTPMessageFilter*>(prev_) != prev &&
         prev && nextElementIsPaused_) {
       prev->pause();
     }
-    prev_ = CHECK_NOTNULL(prev);
+    prev_ = PRX_CHECK_NOTNULL(prev);
   }
   virtual void setPrevSink(HTTPSink* prev) noexcept {
     if (prev_.index() == 1 && std::get<HTTPSink*>(prev_) != prev && prev &&
         nextElementIsPaused_) {
       prev->pauseIngress();
     }
-    prev_ = CHECK_NOTNULL(prev);
+    prev_ = PRX_CHECK_NOTNULL(prev);
   }
   HTTPTransaction::Handler* getNextTransactionHandler() {
     return nextTransactionHandler_;
@@ -113,12 +114,12 @@ class HTTPMessageFilter
 
   // Doesn't need to propagate down a chain, call on head filter
   void detachHandlerFromSink(std::unique_ptr<HTTPSink> sink) noexcept {
-    CHECK_EQ(prev_.index(), 1);
+    PRX_CHECK_EQ(prev_.index(), 1u);
     auto prev = std::get<HTTPSink*>(prev_);
     if (prev) {
       // prev points to the transaction, detach the handler from the
       // transaction.
-      CHECK_EQ(prev, sink.get());
+      PRX_CHECK_EQ(prev, sink.get());
       prev->detachAndAbortIfIncomplete(std::move(sink));
       // Set the pointer to nullptr. It is not safe to use the pointer since
       // after this the transaction can be destroyed without notifying the
diff --git a/proxygen/lib/http/HTTPPriorityFunctions.cpp b/proxygen/lib/http/HTTPPriorityFunctions.cpp
index 3f4e60f0f2..28e318d3cd 100644
--- a/proxygen/lib/http/HTTPPriorityFunctions.cpp
+++ b/proxygen/lib/http/HTTPPriorityFunctions.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/HTTPPriorityFunctions.h>
 
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersDecoder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -48,7 +49,7 @@ folly::Optional<HTTPPriority> httpPriorityFromString(
   bool logBadHeader = false;
   SCOPE_EXIT {
     if (logBadHeader) {
-      LOG_EVERY_N(ERROR, 100)
+      PRX_LOG_EVERY_N(ERROR, 100)
           << "Received ill-formated priority header=" << priority;
     }
   };
diff --git a/proxygen/lib/http/ProxyStatus.cpp b/proxygen/lib/http/ProxyStatus.cpp
index b0ad7dcaa9..060cefaae5 100644
--- a/proxygen/lib/http/ProxyStatus.cpp
+++ b/proxygen/lib/http/ProxyStatus.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/ProxyStatus.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
diff --git a/proxygen/lib/http/SynchronizedLruQuicPskCache.cpp b/proxygen/lib/http/SynchronizedLruQuicPskCache.cpp
index 9107c7b02b..224b43dfce 100644
--- a/proxygen/lib/http/SynchronizedLruQuicPskCache.cpp
+++ b/proxygen/lib/http/SynchronizedLruQuicPskCache.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/SynchronizedLruQuicPskCache.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -21,10 +22,10 @@ quic::Optional<quic::QuicCachedPsk> SynchronizedLruQuicPskCache::getPsk(
   if (result != cacheMap->end()) {
     if (std::chrono::system_clock::now() >
         result->second.cachedPsk.ticketExpirationTime) {
-      VLOG(1) << "PSK expired: " << identity << ", id: "
-              << (result->second.cachedPsk.serverCert
-                      ? result->second.cachedPsk.serverCert->getIdentity()
-                      : "none");
+      PRX_VLOG(1) << "PSK expired: " << identity << ", id: "
+                  << (result->second.cachedPsk.serverCert
+                          ? result->second.cachedPsk.serverCert->getIdentity()
+                          : "none");
       cacheMap->erase(result);
       return std::nullopt;
     }
diff --git a/proxygen/lib/http/Window.cpp b/proxygen/lib/http/Window.cpp
index c9593ca8de..47be59e68d 100644
--- a/proxygen/lib/http/Window.cpp
+++ b/proxygen/lib/http/Window.cpp
@@ -8,13 +8,13 @@
 
 #include <proxygen/lib/http/Window.h>
 
-#include <glog/logging.h>
 #include <limits>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
 Window::Window(uint32_t capacity) {
-  CHECK(setCapacity(capacity));
+  PRX_CHECK(setCapacity(capacity));
 }
 
 int32_t Window::getSize() const {
@@ -37,20 +37,20 @@ uint32_t Window::getOutstanding() const {
 
 bool Window::reserve(const uint32_t amount, bool strict) {
   if (amount > std::numeric_limits<int32_t>::max()) {
-    VLOG(3) << "Cannot shrink window by more than 2^31 - 1. "
-            << "Attempted decrement of " << amount;
+    PRX_VLOG(3) << "Cannot shrink window by more than 2^31 - 1. "
+                << "Attempted decrement of " << amount;
     return false;
   }
   const int32_t limit =
       std::numeric_limits<int32_t>::max() - static_cast<int32_t>(amount);
   if (outstanding_ > 0 && limit < outstanding_) {
-    VLOG(3) << "Overflow detected. Window change failed.";
+    PRX_VLOG(3) << "Overflow detected. Window change failed.";
     return false;
   }
   const int32_t newOutstanding = outstanding_ + amount;
   if (strict && newOutstanding > capacity_) {
-    VLOG(3) << "Outstanding bytes (" << newOutstanding << ") exceeded "
-            << "window capacity (" << capacity_ << ")";
+    PRX_VLOG(3) << "Outstanding bytes (" << newOutstanding << ") exceeded "
+                << "window capacity (" << capacity_ << ")";
     return false;
   }
   outstanding_ = newOutstanding;
@@ -59,19 +59,19 @@ bool Window::reserve(const uint32_t amount, bool strict) {
 
 bool Window::free(const uint32_t amount) {
   if (amount > std::numeric_limits<int32_t>::max()) {
-    VLOG(3) << "Cannot expand window by more than 2^31 - 1. "
-            << "Attempted increment of " << amount;
+    PRX_VLOG(3) << "Cannot expand window by more than 2^31 - 1. "
+                << "Attempted increment of " << amount;
     return false;
   }
   const int32_t limit =
       std::numeric_limits<int32_t>::min() + static_cast<int32_t>(amount);
   if (outstanding_ < 0 && limit > outstanding_) {
-    VLOG(3) << "Underflow detected. Window change failed.";
+    PRX_VLOG(3) << "Underflow detected. Window change failed.";
     return false;
   }
   const int32_t newOutstanding = outstanding_ - amount;
   if (newOutstanding < capacity_ - std::numeric_limits<int32_t>::max()) {
-    VLOG(3) << "Window exceeded 2^31 - 1. Window change failed.";
+    PRX_VLOG(3) << "Window exceeded 2^31 - 1. Window change failed.";
     return false;
   }
   outstanding_ = newOutstanding;
@@ -80,7 +80,7 @@ bool Window::free(const uint32_t amount) {
 
 bool Window::setCapacity(const uint32_t capacity) {
   if (capacity > std::numeric_limits<int32_t>::max()) {
-    VLOG(3) << "Cannot set initial window > 2^31 -1.";
+    PRX_VLOG(3) << "Cannot set initial window > 2^31 -1.";
     return false;
   }
 
@@ -88,7 +88,7 @@ bool Window::setCapacity(const uint32_t capacity) {
   if (diff > 0) {
     const int32_t size = getSize();
     if (size > 0 && diff > (std::numeric_limits<int32_t>::max() - size)) {
-      VLOG(3) << "Increasing the capacity overflowed the window";
+      PRX_VLOG(3) << "Increasing the capacity overflowed the window";
       return false;
     }
   }
diff --git a/proxygen/lib/http/codec/CMakeLists.txt b/proxygen/lib/http/codec/CMakeLists.txt
index b64780804b..7e60e7be07 100644
--- a/proxygen/lib/http/codec/CMakeLists.txt
+++ b/proxygen/lib/http/codec/CMakeLists.txt
@@ -14,8 +14,8 @@ proxygen_add_library(proxygen_http_codec_direction
 proxygen_add_library(proxygen_http_codec_error_code
   SRCS
     ErrorCode.cpp
-  DEPS
-    glog::glog
+  EXPORTED_DEPS
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_codec_util
@@ -23,6 +23,7 @@ proxygen_add_library(proxygen_http_codec_util
     CodecUtil.cpp
   DEPS
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_string
   EXPORTED_DEPS
     proxygen_http_codec_compress_header_codec
@@ -44,7 +45,6 @@ proxygen_add_library(proxygen_http_codec_codec_common
   DEPS
     Folly::folly_conv
     Folly::folly_string
-    glog::glog
   EXPORTED_DEPS
     proxygen_error
     proxygen_http_codec_compress_fast_header_name
@@ -60,6 +60,7 @@ proxygen_add_library(proxygen_http_codec_codec_common
     proxygen_http_message
     proxygen_utils_export
     proxygen_utils_filter_chain
+    proxygen_utils_log_shim
     Folly::folly_io_iobuf
     Folly::folly_lang_assume
     Folly::folly_optional
@@ -74,6 +75,7 @@ proxygen_add_library(proxygen_http_codec_http1x_codec
   DEPS
     proxygen_http_codec_util
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_base64
     Folly::folly_random
     Folly::folly_ssl_openssl_hash
@@ -92,6 +94,7 @@ proxygen_add_library(proxygen_http_codec_http2_codec
   DEPS
     proxygen_http_codec_util
     proxygen_http_priority_functions
+    proxygen_utils_log_shim
     proxygen_utils_logging
     Folly::folly_base64
     Folly::folly_conv
@@ -116,12 +119,14 @@ proxygen_add_library(proxygen_http_codec_rate_limit_filters
     proxygen_http_codec_codec_common
     proxygen_http_codec_http2_codec
     proxygen_http_session_stats
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_base
 )
 
 proxygen_add_library(proxygen_http_codec_debug_filter
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
+    proxygen_utils_log_shim
     proxygen_utils_logging
     Folly::folly_container_evicting_cache_map
 )
@@ -139,6 +144,7 @@ proxygen_add_library(proxygen_http_codec_codec_factory
   DEPS
     proxygen_http_codec_http1x_codec
     proxygen_http_codec_http2_codec
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     proxygen_http_codec_direction
@@ -149,10 +155,10 @@ proxygen_add_library(proxygen_http_codec_h3_early_data_handler
     H3EarlyDataHandler.cpp
   DEPS
     proxygen_http_codec_hq_codec
+    proxygen_utils_log_shim
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
     Folly::folly_io_iobuf
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     mvfst::mvfst_state_early_data_app_params_handler
@@ -181,6 +187,7 @@ proxygen_add_library(proxygen_http_codec_hq_codec
     proxygen_http_codec_util
     proxygen_http_h3_errors
     proxygen_http_http_utils
+    proxygen_utils_log_shim
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
     Folly::folly_function
@@ -194,6 +201,7 @@ proxygen_add_library(proxygen_http_codec_http_binary_codec
   SRCS
     HTTPBinaryCodec.cpp
   DEPS
+    proxygen_utils_log_shim
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
   EXPORTED_DEPS
@@ -212,8 +220,8 @@ proxygen_add_library(proxygen_http_codec_capsule_codec
   SRCS
     CapsuleCodec.cpp
   DEPS
+    proxygen_utils_log_shim
     mvfst::mvfst_folly_utils
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     Folly::folly_expected
     Folly::folly_io_iobuf
diff --git a/proxygen/lib/http/codec/CapsuleCodec.cpp b/proxygen/lib/http/codec/CapsuleCodec.cpp
index b445d0dce0..dc0bc5bfdb 100644
--- a/proxygen/lib/http/codec/CapsuleCodec.cpp
+++ b/proxygen/lib/http/codec/CapsuleCodec.cpp
@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/CapsuleCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/folly_utils/Utils.h>
 
 namespace proxygen {
@@ -87,7 +87,7 @@ void CapsuleCodec::onIngress(std::unique_ptr<folly::IOBuf> data, bool eom) {
       if (callback_) {
         callback_->onConnectionError(connError_.value());
       }
-      XLOG(ERR) << "Connection error=" << uint32_t(*connError_);
+      PRX_LOG(ERROR) << "Connection error=" << uint32_t(*connError_);
     }
   }
   ingress_.move();
diff --git a/proxygen/lib/http/codec/CodecProtocol.cpp b/proxygen/lib/http/codec/CodecProtocol.cpp
index d2235ef617..3e32938881 100644
--- a/proxygen/lib/http/codec/CodecProtocol.cpp
+++ b/proxygen/lib/http/codec/CodecProtocol.cpp
@@ -12,7 +12,7 @@
 #include <proxygen/lib/http/codec/HTTP2Constants.h>
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -65,7 +65,7 @@ extern const std::string& getCodecProtocolString(CodecProtocol proto) {
     case CodecProtocol::TUNNEL_LITE:
       return tunnel_lite;
   }
-  LOG(FATAL) << "Unreachable";
+  PRX_LOG(FATAL) << "Unreachable";
 }
 
 extern bool isValidCodecProtocolStr(folly::StringPiece protocolStr) {
diff --git a/proxygen/lib/http/codec/CodecUtil.cpp b/proxygen/lib/http/codec/CodecUtil.cpp
index 7b17191a65..a1f2ef48a2 100644
--- a/proxygen/lib/http/codec/CodecUtil.cpp
+++ b/proxygen/lib/http/codec/CodecUtil.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/String.h>
 #include <proxygen/lib/http/RFC2616.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -91,15 +92,15 @@ bool CodecUtil::appendHeaders(const HTTPHeaders& inputHeaders,
     const auto& s_disallowedModernHTTPFields = disallowedModernHTTPFields();
     if (s_disallowedModernHTTPFields[code] || name.size() == 0 ||
         name[0] == ':') {
-      DCHECK_GT(name.size(), 0) << "Empty header";
-      DCHECK_NE(name[0], ':') << "Invalid header=" << name;
+      PRX_DCHECK_GT(name.size(), 0u) << "Empty header";
+      PRX_DCHECK_NE(name[0], ':') << "Invalid header=" << name;
       return;
     }
     // Note this code will not drop headers named by Connection.  That's the
     // caller's job
 
     // see HTTP/2 spec, 8.1.2
-    DCHECK(name != "TE" || value == "trailers");
+    PRX_DCHECK(name != "TE" || value == "trailers");
     if ((name.size() > 0 && name[0] != ':') && code != HTTP_HEADER_HOST) {
       headers.emplace_back(code, name, value);
     }
@@ -168,8 +169,9 @@ void CodecUtil::logIfFieldSectionExceedsPeerMax(
     // The remote side told us they don't want headers this large, but try
     // anyways
     debugStr += CodecUtil::debugString(fields, debugLevel);
-    LOG(ERROR) << "generating HEADERS frame larger than peer maximum nHeaders="
-               << fields.size() << " all headers=" << debugStr;
+    PRX_LOG(ERROR)
+        << "generating HEADERS frame larger than peer maximum nHeaders="
+        << fields.size() << " all headers=" << debugStr;
   }
 }
 
diff --git a/proxygen/lib/http/codec/DebugFilter.h b/proxygen/lib/http/codec/DebugFilter.h
index b8f1a4b330..3078856caa 100644
--- a/proxygen/lib/http/codec/DebugFilter.h
+++ b/proxygen/lib/http/codec/DebugFilter.h
@@ -10,6 +10,7 @@
 
 #include <folly/container/EvictingCacheMap.h>
 #include <proxygen/lib/http/codec/HTTPCodecFilter.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Logging.h>
 
 namespace proxygen {
@@ -45,8 +46,8 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
                            StreamID streamID,
                            ErrorCode code) override {
     if (shouldDumpStream(streamID)) {
-      VLOG(2) << "generateRstStream, streamID=" << streamID
-              << " error=" << getErrorCodeString(code);
+      PRX_VLOG(2) << "generateRstStream, streamID=" << streamID
+                  << " error=" << getErrorCodeString(code);
       dump();
     }
     return call_->generateRstStream(writeBuf, streamID, code);
@@ -58,8 +59,8 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
       ErrorCode code = ErrorCode::NO_ERROR,
       std::unique_ptr<folly::IOBuf> debugData = nullptr) override {
     if (code != ErrorCode::NO_ERROR) {
-      VLOG(2) << "generateGoaway, lastStream=" << lastStream
-              << " error=" << getErrorCodeString(code);
+      PRX_VLOG(2) << "generateGoaway, lastStream=" << lastStream
+                  << " error=" << getErrorCodeString(code);
       dump();
     }
     return call_->generateGoaway(
@@ -77,8 +78,8 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
 
   void onAbort(StreamID streamID, ErrorCode code) override {
     if (shouldDumpStream(streamID)) {
-      VLOG(2) << "onAbort, streamID=" << streamID
-              << " error=" << getErrorCodeString(code);
+      PRX_VLOG(2) << "onAbort, streamID=" << streamID
+                  << " error=" << getErrorCodeString(code);
       dump();
     }
     callback_->onAbort(streamID, code);
@@ -90,7 +91,8 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
     // newTxn
     if (shouldDumpStream(streamID) ||
         (error.getPartialMsg() && shouldTrackStream(*error.getPartialMsg()))) {
-      VLOG(2) << "onError, streamID=" << streamID << " error=" << error.what();
+      PRX_VLOG(2) << "onError, streamID=" << streamID
+                  << " error=" << error.what();
       dump();
     }
     callback_->onError(streamID, error, newTxn);
@@ -100,9 +102,9 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
                 ErrorCode code,
                 std::unique_ptr<folly::IOBuf> debugData) override {
     if (code != ErrorCode::NO_ERROR) {
-      VLOG(2) << "onGoaway, lastStream=" << lastStream
-              << " error=" << getErrorCodeString(code)
-              << " debugData=" << IOBufPrinter::printHexFolly(debugData.get());
+      PRX_VLOG(2) << "onGoaway, lastStream=" << lastStream
+                  << " error=" << getErrorCodeString(code) << " debugData="
+                  << IOBufPrinter::printHexFolly(debugData.get());
       dump();
     }
     callback_->onGoaway(lastStream, code, std::move(debugData));
@@ -114,7 +116,7 @@ class DebugFilter : public PassThroughHTTPCodecFilter {
       if (dumpFn_) {
         dumpFn_(std::move(ingress));
       } else {
-        VLOG(2) << IOBufPrinter::printHexFolly(ingress.get());
+        PRX_VLOG(2) << IOBufPrinter::printHexFolly(ingress.get());
       }
     }
   }
diff --git a/proxygen/lib/http/codec/DefaultHTTPCodecFactory.cpp b/proxygen/lib/http/codec/DefaultHTTPCodecFactory.cpp
index a93d459118..ac03e147a2 100644
--- a/proxygen/lib/http/codec/DefaultHTTPCodecFactory.cpp
+++ b/proxygen/lib/http/codec/DefaultHTTPCodecFactory.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/CodecProtocol.h>
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
 #include <proxygen/lib/http/codec/HTTP2Codec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -35,17 +36,17 @@ std::unique_ptr<HTTPCodec> DefaultHTTPCodecFactory::getCodec(
     }
     case CodecProtocol::HQ:
     case CodecProtocol::HTTP_3: {
-      LOG(WARNING) << __func__ << " doesn't yet support H3";
+      PRX_LOG(WARNING) << __func__ << " doesn't yet support H3";
       return nullptr;
     }
     case CodecProtocol::HTTP_BINARY:
-      LOG(WARNING) << __func__ << " doesn't yet support HTTPBinaryCodec";
+      PRX_LOG(WARNING) << __func__ << " doesn't yet support HTTPBinaryCodec";
       return nullptr;
     case CodecProtocol::HTTP_1_1: {
       if (!chosenProto.empty() &&
           !HTTP1xCodec::supportsNextProtocol(chosenProto)) {
-        LOG(ERROR) << "Chosen protocol \"" << chosenProto
-                   << "\" is unimplemented. ";
+        PRX_LOG(ERROR) << "Chosen protocol \"" << chosenProto
+                       << "\" is unimplemented. ";
         return nullptr;
       }
 
@@ -53,7 +54,7 @@ std::unique_ptr<HTTPCodec> DefaultHTTPCodecFactory::getCodec(
           direction, config.h1.forceHTTP1xCodecTo1_1, config.strictValidation);
     }
     case CodecProtocol::TUNNEL_LITE:
-      LOG(WARNING) << __func__ << " doesn't support TUNNEL_LITE";
+      PRX_LOG(WARNING) << __func__ << " doesn't support TUNNEL_LITE";
       return nullptr;
     default:
       // should be unreachable, getCodecProtocolFromStr returns HTTP_1_1 by
diff --git a/proxygen/lib/http/codec/ErrorCode.cpp b/proxygen/lib/http/codec/ErrorCode.cpp
index 185a6f348b..41e538b5eb 100644
--- a/proxygen/lib/http/codec/ErrorCode.cpp
+++ b/proxygen/lib/http/codec/ErrorCode.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/codec/ErrorCode.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -45,7 +45,7 @@ const char* getErrorCodeString(ErrorCode error) {
     case ErrorCode::MAX:
       return "MAX";
   }
-  LOG(FATAL) << "Unreachable";
+  PRX_LOG(FATAL) << "Unreachable";
 }
 
 } // namespace proxygen
diff --git a/proxygen/lib/http/codec/ErrorCode.h b/proxygen/lib/http/codec/ErrorCode.h
index f350fb431d..a7921dfa05 100644
--- a/proxygen/lib/http/codec/ErrorCode.h
+++ b/proxygen/lib/http/codec/ErrorCode.h
@@ -9,12 +9,13 @@
 #pragma once
 
 #include <cstdint>
+#include <proxygen/lib/utils/LogShim.h>
 
-#define RETURN_IF_ERROR(err)                                       \
-  if (err != ErrorCode::NO_ERROR) {                                \
-    VLOG(4) << "Returning with error=" << getErrorCodeString(err); \
-    return err;                                                    \
-  }                                                                \
+#define RETURN_IF_ERROR(err)                                           \
+  if (err != ErrorCode::NO_ERROR) {                                    \
+    PRX_VLOG(4) << "Returning with error=" << getErrorCodeString(err); \
+    return err;                                                        \
+  }                                                                    \
   static_assert(true, "semicolon required")
 
 namespace proxygen {
diff --git a/proxygen/lib/http/codec/FlowControlFilter.cpp b/proxygen/lib/http/codec/FlowControlFilter.cpp
index 8ed49dc1ab..2ce199d10b 100644
--- a/proxygen/lib/http/codec/FlowControlFilter.cpp
+++ b/proxygen/lib/http/codec/FlowControlFilter.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/codec/FlowControlFilter.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -30,11 +31,12 @@ FlowControlFilter::FlowControlFilter(Callback& callback,
       sendsBlocked_(false) {
   if (recvCapacity > 0) {
     if (recvCapacity < codec->getDefaultWindowSize()) {
-      VLOG(4) << "Ignoring low conn-level recv window size of " << recvCapacity;
+      PRX_VLOG(4) << "Ignoring low conn-level recv window size of "
+                  << recvCapacity;
     } else if (recvCapacity > codec->getDefaultWindowSize()) {
       auto delta = recvCapacity - codec->getDefaultWindowSize();
-      VLOG(4) << "Incrementing default conn-level recv window by " << delta;
-      CHECK(recvWindow_.setCapacity(recvCapacity));
+      PRX_VLOG(4) << "Incrementing default conn-level recv window by " << delta;
+      PRX_CHECK(recvWindow_.setCapacity(recvCapacity));
       codec->generateWindowUpdate(writeBuf, 0, delta);
     }
   }
@@ -43,19 +45,20 @@ FlowControlFilter::FlowControlFilter(Callback& callback,
 void FlowControlFilter::setReceiveWindowSize(folly::IOBufQueue& writeBuf,
                                              uint32_t capacity) {
   if (capacity < recvWindow_.getCapacity()) {
-    VLOG(4) << "Ignoring low conn-level recv window size of " << capacity;
+    PRX_VLOG(4) << "Ignoring low conn-level recv window size of " << capacity;
     return;
   }
   int32_t delta = capacity - recvWindow_.getCapacity();
   if (delta < 0) {
     // For now, we're disallowing shrinking the window, since it can lead
     // to FLOW_CONTROL_ERRORs if there is data in flight.
-    VLOG(4) << "Refusing to shrink the recv window";
+    PRX_VLOG(4) << "Refusing to shrink the recv window";
     return;
   }
-  VLOG(4) << "Incrementing default conn-level recv window by " << delta;
+  PRX_VLOG(4) << "Incrementing default conn-level recv window by " << delta;
   if (!recvWindow_.setCapacity(capacity)) {
-    VLOG(2) << "Failed setting conn-level recv window capacity to " << capacity;
+    PRX_VLOG(2) << "Failed setting conn-level recv window capacity to "
+                << capacity;
     return;
   }
   toAck_ += delta;
@@ -70,10 +73,10 @@ bool FlowControlFilter::ingressBytesProcessed(folly::IOBufQueue& writeBuf,
   toAck_ += delta;
   bool willAck =
       (toAck_ > 0 && uint32_t(toAck_) > recvWindow_.getCapacity() / 2);
-  VLOG(4) << "processed " << delta << " toAck_=" << toAck_
-          << " bytes, will ack=" << willAck;
+  PRX_VLOG(4) << "processed " << delta << " toAck_=" << toAck_
+              << " bytes, will ack=" << willAck;
   if (willAck) {
-    CHECK(recvWindow_.free(toAck_));
+    PRX_CHECK(recvWindow_.free(toAck_));
     call_->generateWindowUpdate(writeBuf, 0, toAck_);
     toAck_ = 0;
     return true;
@@ -105,11 +108,11 @@ void FlowControlFilter::onBody(StreamID stream,
                                amount));
     callback_->onError(0, ex, false);
   } else {
-    if (VLOG_IS_ON(4) && recvWindow_.getSize() == 0) {
-      VLOG(4) << "recvWindow full";
+    if (PRX_VLOG_IS_ON(4) && recvWindow_.getSize() == 0) {
+      PRX_VLOG(4) << "recvWindow full";
     }
     toAck_ += padding;
-    CHECK(recvWindow_.free(padding));
+    PRX_CHECK(recvWindow_.free(padding));
     callback_->onBody(stream, std::move(chain), padding);
   }
 }
@@ -117,11 +120,11 @@ void FlowControlFilter::onBody(StreamID stream,
 void FlowControlFilter::onWindowUpdate(StreamID stream, uint32_t amount) {
   if (!stream) {
     bool success = sendWindow_.free(amount);
-    VLOG(4) << "Remote side ack'd " << amount
-            << " bytes, sendWindow=" << sendWindow_.getSize();
+    PRX_VLOG(4) << "Remote side ack'd " << amount
+                << " bytes, sendWindow=" << sendWindow_.getSize();
     if (!success) {
-      LOG(WARNING) << "Remote side sent connection-level WINDOW_UPDATE "
-                   << "that could not be applied. Aborting session.";
+      PRX_LOG(WARNING) << "Remote side sent connection-level WINDOW_UPDATE "
+                       << "that could not be applied. Aborting session.";
       // If something went wrong applying the flow control change, abort
       // the entire session.
       error_ = true;
@@ -133,7 +136,7 @@ void FlowControlFilter::onWindowUpdate(StreamID stream, uint32_t amount) {
       callback_->onError(stream, ex, false);
     }
     if (sendsBlocked_ && sendWindow_.getNonNegativeSize()) {
-      VLOG(4) << "Send window opened";
+      PRX_VLOG(4) << "Send window opened";
       sendsBlocked_ = false;
       notify_.onConnectionSendWindowOpen();
     }
@@ -150,16 +153,16 @@ size_t FlowControlFilter::generateBody(folly::IOBufQueue& writeBuf,
                                        bool eom) {
   uint8_t padLen = padding ? *padding : 0;
   bool success = sendWindow_.reserve(chain->computeChainDataLength() + padLen);
-  VLOG(5) << "Sending " << chain->computeChainDataLength()
-          << " bytes, sendWindow=" << sendWindow_.getSize();
+  PRX_VLOG(5) << "Sending " << chain->computeChainDataLength()
+              << " bytes, sendWindow=" << sendWindow_.getSize();
 
   // In the future, maybe make this DCHECK
-  CHECK(success) << "Session-level send window underflowed! "
-                 << "Too much data sent without WINDOW_UPDATES!";
+  PRX_CHECK(success) << "Session-level send window underflowed! "
+                     << "Too much data sent without WINDOW_UPDATES!";
 
   if (sendWindow_.getNonNegativeSize() == 0) {
     // Need to inform when the send window is no longer full
-    VLOG(4) << "Send window closed";
+    PRX_VLOG(4) << "Send window closed";
     sendsBlocked_ = true;
     notify_.onConnectionSendWindowClosed();
   }
@@ -170,7 +173,8 @@ size_t FlowControlFilter::generateBody(folly::IOBufQueue& writeBuf,
 size_t FlowControlFilter::generateWindowUpdate(folly::IOBufQueue& writeBuf,
                                                StreamID stream,
                                                uint32_t delta) {
-  CHECK(stream) << " someone tried to manually manipulate a conn-level window";
+  PRX_CHECK(stream)
+      << " someone tried to manually manipulate a conn-level window";
   return call_->generateWindowUpdate(writeBuf, stream, delta);
 }
 
diff --git a/proxygen/lib/http/codec/H3EarlyDataHandler.cpp b/proxygen/lib/http/codec/H3EarlyDataHandler.cpp
index ea946d14ad..f57eaa955f 100644
--- a/proxygen/lib/http/codec/H3EarlyDataHandler.cpp
+++ b/proxygen/lib/http/codec/H3EarlyDataHandler.cpp
@@ -10,8 +10,8 @@
 
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -28,7 +28,7 @@ void writeVarint(folly::IOBufQueue& buf, uint64_t val) {
     appender.writeBE(folly::tag<decltype(v)>, v);
   };
   auto res = quic::encodeQuicInteger(val, appenderOp);
-  DCHECK(res.has_value());
+  PRX_DCHECK(res.has_value());
 }
 
 auto readVarint(folly::io::Cursor& cursor) {
@@ -85,7 +85,7 @@ quic::BufPtr H3EarlyDataHandler::get() {
     }
   }
 
-  XLOG(DBG4) << "H3EarlyDataHandler::get called, numSettings=" << count;
+  PRX_VLOG(4) << "H3EarlyDataHandler::get called, numSettings=" << count;
 
   folly::IOBufQueue buf{folly::IOBufQueue::cacheChainLength()};
 
@@ -103,9 +103,9 @@ quic::BufPtr H3EarlyDataHandler::get() {
 
 bool H3EarlyDataHandler::validate(const quic::Optional<std::string>& /*alpn*/,
                                   const quic::BufPtr& appParams) {
-  XLOG(DBG4) << "H3EarlyDataHandler::validate called, appParams="
-             << (appParams ? "non-null" : "null")
-             << " settingsInitialized=" << settingsInitialized_;
+  PRX_VLOG(4) << "H3EarlyDataHandler::validate called, appParams="
+              << (appParams ? "non-null" : "null")
+              << " settingsInitialized=" << settingsInitialized_;
   if (!appParams) {
     return false;
   }
@@ -114,7 +114,7 @@ bool H3EarlyDataHandler::validate(const quic::Optional<std::string>& /*alpn*/,
 
   auto countResult = readVarint(cursor);
   if (!countResult) {
-    XLOG(DBG2) << "Failed to decode settings count";
+    PRX_VLOG(2) << "Failed to decode settings count";
     return false;
   }
   auto count = countResult->first;
@@ -126,12 +126,12 @@ bool H3EarlyDataHandler::validate(const quic::Optional<std::string>& /*alpn*/,
   for (uint64_t i = 0; i < count; ++i) {
     auto idResult = readVarint(cursor);
     if (!idResult) {
-      XLOG(DBG2) << "Failed to decode setting id at index " << i;
+      PRX_VLOG(2) << "Failed to decode setting id at index " << i;
       return false;
     }
     auto valResult = readVarint(cursor);
     if (!valResult) {
-      XLOG(DBG2) << "Failed to decode setting value at index " << i;
+      PRX_VLOG(2) << "Failed to decode setting value at index " << i;
       return false;
     }
 
@@ -162,9 +162,9 @@ bool H3EarlyDataHandler::validate(const quic::Optional<std::string>& /*alpn*/,
       // Per RFC 9114, if the cached value is non-default (non-zero for H3
       // settings), this is incompatible.
       if (cachedValue != 0) {
-        XLOG(DBG2) << "Cached setting " << idResult->first
-                   << " has non-default value " << cachedValue
-                   << " but is absent from current settings";
+        PRX_VLOG(2) << "Cached setting " << idResult->first
+                    << " has non-default value " << cachedValue
+                    << " but is absent from current settings";
         return false;
       }
       continue;
@@ -173,15 +173,15 @@ bool H3EarlyDataHandler::validate(const quic::Optional<std::string>& /*alpn*/,
     if (isLimitSetting(cachedHqId)) {
       // For limits: cached must be <= current
       if (cachedValue > currentSetting->value) {
-        XLOG(DBG2) << "Cached setting " << idResult->first << " value "
-                   << cachedValue << " > current " << currentSetting->value;
+        PRX_VLOG(2) << "Cached setting " << idResult->first << " value "
+                    << cachedValue << " > current " << currentSetting->value;
         return false;
       }
     } else {
       // For boolean/enable: if cached was enabled, current must also be enabled
       if (cachedValue != 0 && currentSetting->value == 0) {
-        XLOG(DBG2) << "Cached setting " << idResult->first
-                   << " was enabled but current is disabled";
+        PRX_VLOG(2) << "Cached setting " << idResult->first
+                    << " was enabled but current is disabled";
         return false;
       }
     }
diff --git a/proxygen/lib/http/codec/HQControlCodec.cpp b/proxygen/lib/http/codec/HQControlCodec.cpp
index b5305bd139..9a47ee2ed8 100644
--- a/proxygen/lib/http/codec/HQControlCodec.cpp
+++ b/proxygen/lib/http/codec/HQControlCodec.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/HQUtils.h>
 
 #include <folly/Random.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 using namespace proxygen::hq;
@@ -79,17 +80,17 @@ ParseResult HQControlCodec::parseCancelPush(Cursor& cursor,
 
 ParseResult HQControlCodec::parseSettings(Cursor& cursor,
                                           const FrameHeader& header) {
-  VLOG(4) << "parsing SETTINGS frame length=" << header.length;
-  CHECK(isIngress());
+  PRX_VLOG(4) << "parsing SETTINGS frame length=" << header.length;
+  PRX_CHECK(isIngress());
   std::deque<SettingPair> outSettings;
   receivedSettings_ = true;
   auto res = hq::parseSettings(cursor, header, outSettings);
-  VLOG(4) << "Received n=" << outSettings.size() << " settings";
+  PRX_VLOG(4) << "Received n=" << outSettings.size() << " settings";
   if (res) {
     return res;
   }
 
-  CHECK(isIngress());
+  PRX_CHECK(isIngress());
   auto& ingressSettings = settings_;
   SettingsList settingsList;
   for (auto& setting : outSettings) {
@@ -202,19 +203,20 @@ size_t HQControlCodec::generateGoaway(
     // Non-draining goaway, caller supplied ID
     sentFinalGoaway_ = true;
   }
-  VLOG(4) << "generating GOAWAY minUnseenId=" << minUnseenId
-          << " statusCode=" << uint32_t(statusCode);
+  PRX_VLOG(4) << "generating GOAWAY minUnseenId=" << minUnseenId
+              << " statusCode=" << uint32_t(statusCode);
 
-  DCHECK_GE(egressGoawayAck_, minUnseenId);
+  PRX_DCHECK_GE(egressGoawayAck_, minUnseenId);
   egressGoawayAck_ = minUnseenId;
   auto writeRes = hq::writeGoaway(writeBuf, minUnseenId);
-  LOG_IF(FATAL, !writeRes) << "::writeGoaway err minUnseenId=" << minUnseenId;
+  PRX_LOG_IF(FATAL, !writeRes)
+      << "::writeGoaway err minUnseenId=" << minUnseenId;
   sentGoaway_ = true;
   return *writeRes;
 }
 
 size_t HQControlCodec::generateSettings(folly::IOBufQueue& writeBuf) {
-  CHECK(!sentSettings_);
+  PRX_CHECK(!sentSettings_);
   sentSettings_ = true;
   std::deque<hq::SettingPair> settings;
   for (auto& setting : getEgressSettings()->getAllSettings()) {
@@ -242,7 +244,7 @@ size_t HQControlCodec::generateSettings(folly::IOBufQueue& writeBuf) {
       static_cast<SettingId>(*getGreaseId(folly::Random::rand32(16))),
       static_cast<SettingValue>(0xFACEB00C));
   auto writeRes = writeSettings(writeBuf, settings);
-  LOG_IF(FATAL, !writeRes) << "error writing settings frame";
+  PRX_LOG_IF(FATAL, !writeRes) << "error writing settings frame";
   return *writeRes;
 }
 
@@ -250,16 +252,17 @@ size_t HQControlCodec::generatePriority(folly::IOBufQueue& writeBuf,
                                         StreamID stream,
                                         HTTPPriority priority) {
   if (priority.urgency > quic::kDefaultMaxPriority) {
-    LOG(ERROR) << "Attempt to generate invalid priority update with urgency="
-               << (uint64_t)priority.urgency;
+    PRX_LOG(ERROR)
+        << "Attempt to generate invalid priority update with urgency="
+        << (uint64_t)priority.urgency;
     return 0;
   }
   auto updateString = folly::to<std::string>(
       "u=", priority.urgency, (priority.incremental ? ",i" : ""));
   auto writeRet = hq::writePriorityUpdate(writeBuf, stream, updateString);
   if (!writeRet) {
-    LOG(ERROR) << "error writing priority update, stream=" << stream
-               << ", priority=" << updateString;
+    PRX_LOG(ERROR) << "error writing priority update, stream=" << stream
+                   << ", priority=" << updateString;
     return 0;
   }
   return *writeRet;
@@ -269,7 +272,7 @@ size_t HQControlCodec::generatePushPriority(folly::IOBufQueue& writeBuf,
                                             StreamID pushId,
                                             HTTPPriority priority) {
   if (priority.urgency > quic::kDefaultMaxPriority) {
-    LOG(ERROR)
+    PRX_LOG(ERROR)
         << "Attempt to generate invalid push priority update with urgency="
         << (uint64_t)priority.urgency;
     return 0;
@@ -278,8 +281,8 @@ size_t HQControlCodec::generatePushPriority(folly::IOBufQueue& writeBuf,
       "u=", priority.urgency, (priority.incremental ? ",i" : ""));
   auto writeRet = hq::writePushPriorityUpdate(writeBuf, pushId, updateString);
   if (!writeRet) {
-    LOG(ERROR) << "error writing push priority update, pushId=" << pushId
-               << ", priority=" << updateString;
+    PRX_LOG(ERROR) << "error writing push priority update, pushId=" << pushId
+                   << ", priority=" << updateString;
     return 0;
   }
   return *writeRet;
diff --git a/proxygen/lib/http/codec/HQControlCodec.h b/proxygen/lib/http/codec/HQControlCodec.h
index 75d8469f2e..4dc594154c 100644
--- a/proxygen/lib/http/codec/HQControlCodec.h
+++ b/proxygen/lib/http/codec/HQControlCodec.h
@@ -17,6 +17,7 @@
 
 #include <folly/io/IOBuf.h>
 #include <folly/lang/Assume.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -34,8 +35,8 @@ class HQControlCodec
       : HQUnidirectionalCodec(streamType, streamDir),
         HQFramedCodec(streamId, direction),
         settings_(settings) {
-    VLOG(4) << "creating " << getTransportDirectionString(direction)
-            << " HQ Control codec for stream " << streamId_;
+    PRX_VLOG(4) << "creating " << getTransportDirectionString(direction)
+                << " HQ Control codec for stream " << streamId_;
     egressGoawayAck_ = direction == TransportDirection::UPSTREAM
                            ? kMaxPushId + 1
                            : kMaxClientBidiStreamId;
@@ -46,7 +47,7 @@ class HQControlCodec
   // HQ Unidirectional Codec API
   std::unique_ptr<folly::IOBuf> onUnidirectionalIngress(
       std::unique_ptr<folly::IOBuf> buf) override {
-    CHECK(buf);
+    PRX_CHECK(buf);
     auto consumed = onFramedIngress(*buf);
     folly::IOBufQueue q;
     q.append(std::move(buf));
@@ -55,7 +56,7 @@ class HQControlCodec
   }
 
   void onUnidirectionalIngressEOF() override {
-    LOG(ERROR) << "Unexpected control stream EOF";
+    PRX_LOG(ERROR) << "Unexpected control stream EOF";
     if (callback_) {
       HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                        "Control stream EOF");
@@ -72,7 +73,7 @@ class HQControlCodec
   }
 
   size_t onIngress(const folly::IOBuf& /*buf*/) override {
-    LOG(FATAL) << __func__ << " not supported";
+    PRX_LOG(FATAL) << __func__ << " not supported";
     folly::assume_unreachable();
   }
 
@@ -97,17 +98,17 @@ class HQControlCodec
                               HTTPPriority priority) override;
 
   const HTTPSettings* getIngressSettings() const override {
-    CHECK(isIngress());
+    PRX_CHECK(isIngress());
     return &settings_;
   }
 
   HTTPSettings* getEgressSettings() override {
-    CHECK(isEgress());
+    PRX_CHECK(isEgress());
     return &settings_;
   }
 
   const HTTPSettings* getEgressSettings() const {
-    CHECK(isEgress());
+    PRX_CHECK(isEgress());
     return &settings_;
   }
 
@@ -120,16 +121,16 @@ class HQControlCodec
   }
 
   uint32_t getDefaultWindowSize() const override {
-    CHECK(false) << __func__ << " not supported";
+    PRX_CHECK(false) << __func__ << " not supported";
     folly::assume_unreachable();
   }
 
   void setHeaderCodecStats(HeaderCodec::Stats* /*hcStats*/) override {
-    CHECK(false) << __func__ << " not supported";
+    PRX_CHECK(false) << __func__ << " not supported";
   }
 
   CompressionInfo getCompressionInfo() const override {
-    CHECK(false) << __func__ << " not supported";
+    PRX_CHECK(false) << __func__ << " not supported";
     folly::assume_unreachable();
   }
 
diff --git a/proxygen/lib/http/codec/HQFramedCodec.cpp b/proxygen/lib/http/codec/HQFramedCodec.cpp
index 2c7f671815..4dcd6aadac 100644
--- a/proxygen/lib/http/codec/HQFramedCodec.cpp
+++ b/proxygen/lib/http/codec/HQFramedCodec.cpp
@@ -15,6 +15,7 @@
 #include <folly/tracing/ScopedTraceSection.h>
 
 #include <iomanip>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -52,7 +53,7 @@ ParseResult HQFramedCodec::parseFrame(Cursor& cursor) {
       break;
   }
 
-  VLOG(3) << "Skipping frame (type=" << (uint64_t)curHeader_.type << ")";
+  PRX_VLOG(3) << "Skipping frame (type=" << (uint64_t)curHeader_.type << ")";
   cursor.skip(curHeader_.length);
   return folly::none;
 }
@@ -78,9 +79,10 @@ size_t HQFramedCodec::onFramedIngress(const IOBuf& buf) {
       parsed += type->second;
       auto res = checkFrameAllowed(curHeader_.type);
       if (res) {
-        VLOG(4) << "Frame not allowed: 0x" << std::setfill('0')
-                << std::setw(sizeof(uint64_t) * 2) << std::hex
-                << (uint64_t)curHeader_.type << " on streamID=" << streamId_;
+        PRX_VLOG(4) << "Frame not allowed: 0x" << std::setfill('0')
+                    << std::setw(sizeof(uint64_t) * 2) << std::hex
+                    << (uint64_t)curHeader_.type
+                    << " on streamID=" << streamId_;
         connError_ = res;
         break;
       }
@@ -140,7 +142,7 @@ size_t HQFramedCodec::onFramedIngress(const IOBuf& buf) {
         frameState_ = FrameState::FRAME_HEADER_TYPE;
       }
     }
-    CHECK_GE(bufLen, parsed);
+    PRX_CHECK_GE(bufLen, parsed);
     bufLen -= parsed;
     parsedTot += parsed;
     totalBytesParsed_ += parsed;
@@ -156,7 +158,8 @@ bool HQFramedCodec::onFramedIngressEOF() {
     deferredEOF_ = true;
     return false;
   } else if (frameState_ != FrameState::FRAME_HEADER_TYPE) {
-    VLOG(3) << "Stream ended in the middle of a frame type=" << curHeader_.type;
+    PRX_VLOG(3) << "Stream ended in the middle of a frame type="
+                << curHeader_.type;
     connError_ = HTTP3::ErrorCode::HTTP_FRAME_ERROR;
     checkConnectionError(connError_, nullptr);
     return false;
@@ -168,9 +171,9 @@ bool HQFramedCodec::onFramedIngressEOF() {
 bool HQFramedCodec::checkConnectionError(ParseResult err,
                                          const folly::IOBuf* buf) {
   if (err != folly::none) {
-    LOG(ERROR) << "Connection error with ingress=";
+    PRX_LOG(ERROR) << "Connection error with ingress=";
     if (buf) {
-      VLOG(3) << IOBufPrinter::printHexFolly(buf, true);
+      PRX_VLOG(3) << IOBufPrinter::printHexFolly(buf, true);
     }
     setParserPaused(true);
     if (callback_) {
diff --git a/proxygen/lib/http/codec/HQFramedCodec.h b/proxygen/lib/http/codec/HQFramedCodec.h
index 8f5870f57a..f5d7ab3846 100644
--- a/proxygen/lib/http/codec/HQFramedCodec.h
+++ b/proxygen/lib/http/codec/HQFramedCodec.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 
 #include <folly/lang/Assume.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -38,13 +39,13 @@ class HQFramedCodec : public HTTPCodec {
 
   // Only implemented in the Stream Codec
   CodecProtocol getProtocol() const override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // Only implemented in the Stream Codec
   const std::string& getUserAgent() const override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -54,7 +55,7 @@ class HQFramedCodec : public HTTPCodec {
 
   // Stream multiplexing handled at the transport
   HTTPCodec::StreamID createStream() override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -99,7 +100,7 @@ class HQFramedCodec : public HTTPCodec {
 
   // no connection preface for HQ
   size_t generateConnectionPreface(folly::IOBufQueue& /*writeBuf*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -110,7 +111,7 @@ class HQFramedCodec : public HTTPCodec {
                       bool /*eom = false*/,
                       HTTPHeaderSize* /*size = nullptr*/,
                       const folly::Optional<HTTPHeaders>&) override {
-    LOG(FATAL) << __func__ << " must be implemented in child class";
+    PRX_LOG(FATAL) << __func__ << " must be implemented in child class";
     folly::assume_unreachable();
   }
 
@@ -121,7 +122,7 @@ class HQFramedCodec : public HTTPCodec {
                            StreamID /*assocStream*/,
                            bool /*eom = false*/,
                            HTTPHeaderSize* /*size = nullptr*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -131,7 +132,7 @@ class HQFramedCodec : public HTTPCodec {
                       std::unique_ptr<folly::IOBuf> /*chain*/,
                       folly::Optional<uint8_t> /*padding*/,
                       bool /*eom*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -139,35 +140,35 @@ class HQFramedCodec : public HTTPCodec {
   size_t generateChunkHeader(folly::IOBufQueue& /*writeBuf*/,
                              StreamID /*stream*/,
                              size_t /*length*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // HQ has no chunk terminators
   size_t generateChunkTerminator(folly::IOBufQueue& /*writeBuf*/,
                                  StreamID /*stream*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   size_t generateTrailers(folly::IOBufQueue& /*writeBuf*/,
                           StreamID /*stream*/,
                           const HTTPHeaders& /*trailers*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   size_t generatePadding(folly::IOBufQueue& /*writeBuf*/,
                          StreamID /*stream*/,
                          uint16_t /*bytes*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // Only valid for the Stream Codec
   size_t generateEOM(folly::IOBufQueue& /*writeBuf*/,
                      StreamID /*stream*/) override {
-    LOG(FATAL) << __func__ << " must be implemented in child class";
+    PRX_LOG(FATAL) << __func__ << " must be implemented in child class";
     folly::assume_unreachable();
   }
 
@@ -175,7 +176,7 @@ class HQFramedCodec : public HTTPCodec {
   size_t generateRstStream(folly::IOBufQueue& /*writeBuf*/,
                            StreamID /*stream*/,
                            ErrorCode /*statusCode*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -185,7 +186,7 @@ class HQFramedCodec : public HTTPCodec {
       StreamID /*lastStream*/,
       ErrorCode /*statusCode*/,
       std::unique_ptr<folly::IOBuf> /*debugData = nullptr*/) override {
-    LOG(FATAL) << __func__ << " must be implemented in child class";
+    PRX_LOG(FATAL) << __func__ << " must be implemented in child class";
     folly::assume_unreachable();
   }
 
@@ -193,26 +194,26 @@ class HQFramedCodec : public HTTPCodec {
   size_t generatePingRequest(
       folly::IOBufQueue& /*writeBuf*/,
       folly::Optional<uint64_t> /* data */ = folly::none) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // Handled at the transport layer
   size_t generatePingReply(folly::IOBufQueue& /*writeBuf*/,
                            uint64_t /* data */) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // only valid for the Control Codec
   size_t generateSettings(folly::IOBufQueue& /*writeBuf*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // No Settings ACK in HQ
   size_t generateSettingsAck(folly::IOBufQueue& /*writeBuf*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -220,25 +221,25 @@ class HQFramedCodec : public HTTPCodec {
   size_t generateWindowUpdate(folly::IOBufQueue& /*writeBuf*/,
                               StreamID /*stream*/,
                               uint32_t /*delta*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // only valid for the Control Codec
   const HTTPSettings* getIngressSettings() const override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // only valid for the Control Codec
   HTTPSettings* getEgressSettings() override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // Flow Control Handled at the transport layer
   uint32_t getDefaultWindowSize() const override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -247,19 +248,19 @@ class HQFramedCodec : public HTTPCodec {
   }
 
   void setHeaderCodecStats(HeaderCodec::Stats* /*hcStats*/) override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
   }
 
   // only valid on the Stream Codec
   bool isRequest(StreamID /*id*/) const {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   // HTTPCodec has a default implementation, override that here to fail.
   // StreamCodec returns the QPACK table info
   CompressionInfo getCompressionInfo() const override {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
@@ -268,55 +269,55 @@ class HQFramedCodec : public HTTPCodec {
 
   virtual ParseResult parseData(folly::io::Cursor& /*cursor*/,
                                 const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parseHeaders(folly::io::Cursor& /*cursor*/,
                                    const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parseCancelPush(folly::io::Cursor& /*cursor*/,
                                       const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parseSettings(folly::io::Cursor& /*cursor*/,
                                     const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parsePushPromise(folly::io::Cursor& /*cursor*/,
                                        const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parseGoaway(folly::io::Cursor& /*cursor*/,
                                   const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parseMaxPushId(folly::io::Cursor& /*cursor*/,
                                      const FrameHeader& /*header*/) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parsePushPriorityUpdate(folly::io::Cursor&,
                                               const FrameHeader&) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
   virtual ParseResult parsePriorityUpdate(folly::io::Cursor&,
                                           const FrameHeader&) {
-    LOG(FATAL) << __func__ << " not supported on this codec";
+    PRX_LOG(FATAL) << __func__ << " not supported on this codec";
     folly::assume_unreachable();
   }
 
diff --git a/proxygen/lib/http/codec/HQFramer.cpp b/proxygen/lib/http/codec/HQFramer.cpp
index 467a27f2c1..0aa87c6aaf 100644
--- a/proxygen/lib/http/codec/HQFramer.cpp
+++ b/proxygen/lib/http/codec/HQFramer.cpp
@@ -11,6 +11,7 @@
 #include <folly/Random.h>
 #include <proxygen/lib/http/HTTPPriorityFunctions.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -43,7 +44,7 @@ folly::Optional<uint64_t> getGreaseId(uint64_t n) {
 ParseResult parseData(folly::io::Cursor& cursor,
                       const FrameHeader& header,
                       std::unique_ptr<folly::IOBuf>& outBuf) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   cursor.clone(outBuf, header.length);
   return folly::none;
 }
@@ -51,7 +52,7 @@ ParseResult parseData(folly::io::Cursor& cursor,
 ParseResult parseHeaders(folly::io::Cursor& cursor,
                          const FrameHeader& header,
                          std::unique_ptr<folly::IOBuf>& outBuf) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   // for HEADERS frame, zero-length is allowed
   cursor.clone(outBuf, header.length);
   return folly::none;
@@ -60,7 +61,7 @@ ParseResult parseHeaders(folly::io::Cursor& cursor,
 static ParseResult parseIdOnlyFrame(folly::io::Cursor& cursor,
                                     const FrameHeader& header,
                                     uint64_t& outId) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   auto frameLength = header.length;
 
   auto id = quic::follyutils::decodeQuicInteger(cursor, frameLength);
@@ -116,7 +117,7 @@ decodeSettingValue(folly::io::Cursor& cursor,
 ParseResult parseSettings(folly::io::Cursor& cursor,
                           const FrameHeader& header,
                           std::deque<SettingPair>& settings) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   folly::IOBuf buf;
   auto frameLength = header.length;
 
@@ -146,7 +147,7 @@ ParseResult parsePushPromise(folly::io::Cursor& cursor,
                              const FrameHeader& header,
                              PushId& outPushId,
                              std::unique_ptr<folly::IOBuf>& outBuf) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   folly::IOBuf buf;
   auto frameLength = header.length;
 
@@ -177,7 +178,7 @@ ParseResult parsePriorityUpdate(folly::io::Cursor& cursor,
                                 const FrameHeader& header,
                                 HTTPCodec::StreamID& outId,
                                 HTTPPriority& priorityUpdate) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   auto length = header.length;
   auto id = quic::follyutils::decodeQuicInteger(cursor, length);
   if (!id) {
@@ -219,7 +220,7 @@ static WriteResult writeSimpleFrame(
     IOBufQueue& queue,
     FrameType type,
     std::unique_ptr<folly::IOBuf> data) noexcept {
-  DCHECK(data);
+  PRX_DCHECK(data);
   auto payloadSize = data->computeChainDataLength();
   auto headerSize = writeFrameHeader(queue, type, payloadSize);
   if (!headerSize) {
@@ -293,7 +294,7 @@ WriteResult writeSettings(IOBufQueue& queue,
 WriteResult writePushPromise(IOBufQueue& queue,
                              PushId pushId,
                              std::unique_ptr<folly::IOBuf> data) noexcept {
-  DCHECK(data);
+  PRX_DCHECK(data);
   auto pushIdSize = quic::getQuicIntegerSize(pushId);
   ret_if_err(pushIdSize);
   size_t payloadSize = *pushIdSize + data->computeChainDataLength();
@@ -416,7 +417,7 @@ static const char* getFrameTypeString(FrameType type) {
       // can happen when type was cast from uint8_t
       return "Unknown";
   }
-  LOG(FATAL) << "Unreachable";
+  PRX_LOG(FATAL) << "Unreachable";
 }
 
 std::ostream& operator<<(std::ostream& os, FrameType type) {
@@ -442,8 +443,8 @@ WriteResult writeWTStreamPreface(folly::IOBufQueue& writeBuf,
       folly::to_underlying(UnidirectionalStreamType::WEBTRANSPORT),
       folly::to_underlying(BidirectionalStreamType::WEBTRANSPORT)};
   auto idx = folly::to_underlying(streamType);
-  CHECK_GE(idx, 0);
-  CHECK_LT(idx, streamTypes.size());
+  PRX_CHECK_GE(idx, 0);
+  PRX_CHECK_LT(idx, streamTypes.size());
   QueueAppender appender(&writeBuf, 64);
   size_t prefaceSize = 0;
   auto res = quic::encodeQuicInteger(streamTypes[idx], [&appender](auto val) {
diff --git a/proxygen/lib/http/codec/HQMultiCodec.h b/proxygen/lib/http/codec/HQMultiCodec.h
index 04c2bdad7f..263e7a75f6 100644
--- a/proxygen/lib/http/codec/HQMultiCodec.h
+++ b/proxygen/lib/http/codec/HQMultiCodec.h
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/HQControlCodec.h>
 #include <proxygen/lib/http/codec/HQStreamCodec.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -36,8 +37,8 @@ class HQMultiCodec : public HQControlCodec {
                        StreamDirection::INGRESS, /* to match settings */
                        ingressSettings_,
                        UnidirectionalStreamType::CONTROL) {
-    VLOG(4) << "creating " << getTransportDirectionString(direction)
-            << " HQMultiCodec for stream " << streamId_;
+    PRX_VLOG(4) << "creating " << getTransportDirectionString(direction)
+                << " HQMultiCodec for stream " << streamId_;
     // Has to be explicitly enabled
     doubleGoaway_ = false;
     minUnseenStreamID_ = 0;
@@ -67,14 +68,14 @@ class HQMultiCodec : public HQControlCodec {
   }
 
   bool isStreamIngressEgressAllowed(StreamID streamId) const {
-    CHECK(transportDirection_ == TransportDirection::DOWNSTREAM);
+    PRX_CHECK(transportDirection_ == TransportDirection::DOWNSTREAM);
     return streamId < egressGoawayAck_;
   }
 
   HTTPCodec& addCodec(StreamID streamId) {
     if (transportDirection_ == TransportDirection::DOWNSTREAM &&
         (streamId & 0x3) == 0 && streamId >= minUnseenStreamID_) {
-      CHECK_LT(streamId, egressGoawayAck_)
+      PRX_CHECK_LT(streamId, egressGoawayAck_)
           << "Don't addCodec for refused stream";
       // only bump for client initiated bidi streams, for now
       minUnseenStreamID_ = streamId + 4;
@@ -242,7 +243,7 @@ class HQMultiCodec : public HQControlCodec {
   }
 
   uint64_t nextPushID() {
-    CHECK_EQ(transportDirection_, TransportDirection::DOWNSTREAM);
+    PRX_CHECK_EQ(transportDirection_, TransportDirection::DOWNSTREAM);
     return nextPushID_++;
   }
 
@@ -266,13 +267,13 @@ class HQMultiCodec : public HQControlCodec {
 
   HQStreamCodec& getCodec(StreamID stream) {
     auto it = codecs_.find(stream);
-    CHECK(it != codecs_.end()) << "stream=" << stream;
+    PRX_CHECK(it != codecs_.end()) << "stream=" << stream;
     return *it->second;
   }
 
   const HQStreamCodec& getCodec(StreamID stream) const {
     auto it = codecs_.find(stream);
-    CHECK(it != codecs_.end()) << "stream=" << stream;
+    PRX_CHECK(it != codecs_.end()) << "stream=" << stream;
     return *it->second;
   }
 
diff --git a/proxygen/lib/http/codec/HQStreamCodec.cpp b/proxygen/lib/http/codec/HQStreamCodec.cpp
index b14e04555c..21cbed0a49 100644
--- a/proxygen/lib/http/codec/HQStreamCodec.cpp
+++ b/proxygen/lib/http/codec/HQStreamCodec.cpp
@@ -15,6 +15,7 @@
 #include <proxygen/lib/http/codec/CodecUtil.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -34,8 +35,8 @@ HQStreamCodec::HQStreamCodec(StreamID streamId,
       qpackDecoderWriteBuf_(decoderWriteBuf),
       qpackEncoderMaxDataFn_(std::move(qpackEncoderMaxData)),
       ingressSettings_(ingressSettings) {
-  VLOG(4) << "creating " << getTransportDirectionString(direction)
-          << " HQ stream codec for stream " << streamId_;
+  PRX_VLOG(4) << "creating " << getTransportDirectionString(direction)
+              << " HQ stream codec for stream " << streamId_;
 }
 
 HQStreamCodec::~HQStreamCodec() = default;
@@ -73,10 +74,10 @@ ParseResult HQStreamCodec::parseData(Cursor& cursor,
   // It's possible the data is in the wrong place per HTTP semantics, but it
   // will be caught by HTTPTransaction
   std::unique_ptr<IOBuf> outData;
-  VLOG(10) << "parsing all frame DATA bytes for stream=" << streamId_
-           << " length=" << header.length;
+  PRX_VLOG(10) << "parsing all frame DATA bytes for stream=" << streamId_
+               << " length=" << header.length;
   auto res = hq::parseData(cursor, header, outData);
-  CHECK(!res);
+  PRX_CHECK(!res);
 
   // no need to do deliverCallbackIfAllowed
   // the HQSession can trap this and stop reading.
@@ -93,7 +94,7 @@ ParseResult HQStreamCodec::parseHeaders(Cursor& cursor,
   setParserPaused(true);
   if (finalIngressHeadersSeen_) {
     if (parsingTrailers_) {
-      VLOG(4) << "Unexpected HEADERS frame for stream=" << streamId_;
+      PRX_VLOG(4) << "Unexpected HEADERS frame for stream=" << streamId_;
       if (callback_) {
         HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                          "Invalid HEADERS frame");
@@ -108,11 +109,11 @@ ParseResult HQStreamCodec::parseHeaders(Cursor& cursor,
   std::unique_ptr<IOBuf> outHeaderData;
   auto res = hq::parseHeaders(cursor, header, outHeaderData);
   if (res) {
-    VLOG(4) << "Invalid HEADERS frame for stream=" << streamId_;
+    PRX_VLOG(4) << "Invalid HEADERS frame for stream=" << streamId_;
     return res;
   }
-  VLOG(4) << "Parsing HEADERS frame for stream=" << streamId_
-          << " length=" << outHeaderData->computeChainDataLength();
+  PRX_VLOG(4) << "Parsing HEADERS frame for stream=" << streamId_
+              << " length=" << outHeaderData->computeChainDataLength();
   if (callback_ && !parsingTrailers_) {
     // H2 performs the decompression/semantic validation first.  Also, this
     // should really only be called once per this whole codec, not per header
@@ -175,26 +176,26 @@ void HQStreamCodec::onHeader(const HPACKHeaderName& name,
       userAgent_ = value.toStdString();
     }
   } else {
-    VLOG(4) << "dir=" << uint32_t(transportDirection_)
-            << decodeInfo_.parsingError << " codec=" << headerCodec_;
+    PRX_VLOG(4) << "dir=" << uint32_t(transportDirection_)
+                << decodeInfo_.parsingError << " codec=" << headerCodec_;
   }
 }
 
 void HQStreamCodec::onHeadersComplete(HTTPHeaderSize decodedSize,
                                       bool acknowledge) {
-  CHECK(parserPaused_);
+  PRX_CHECK(parserPaused_);
   decodeInfo_.onHeadersComplete(decodedSize);
   auto resumeParser = folly::makeGuard([this] { setParserPaused(false); });
   auto g2 = folly::makeGuard(activationHook_());
 
   // Check parsing error
-  DCHECK_EQ(decodeInfo_.decodeError, HPACK::DecodeError::NONE);
+  PRX_DCHECK_EQ(decodeInfo_.decodeError, HPACK::DecodeError::NONE);
   // Leave msg in decodeInfo_ for now, to keep the parser paused
   if (!decodeInfo_.parsingError.empty()) {
-    LOG(ERROR) << "Failed parsing header list for stream=" << streamId_
-               << ", error=" << decodeInfo_.parsingError;
+    PRX_LOG(ERROR) << "Failed parsing header list for stream=" << streamId_
+                   << ", error=" << decodeInfo_.parsingError;
     if (!decodeInfo_.headerErrorValue.empty()) {
-      DVLOG(4) << " value=" << decodeInfo_.headerErrorValue;
+      PRX_DVLOG(4) << " value=" << decodeInfo_.headerErrorValue;
     }
     HTTPException err(
         HTTPException::Direction::INGRESS,
@@ -246,18 +247,18 @@ void HQStreamCodec::onHeadersComplete(HTTPHeaderSize decodedSize,
 
 void HQStreamCodec::onDecodeError(HPACK::DecodeError decodeError) {
   // the parser may be paused, but this codec is dead.
-  CHECK(parserPaused_);
+  PRX_CHECK(parserPaused_);
   decodeInfo_.decodeError = decodeError;
-  DCHECK_NE(decodeInfo_.decodeError, HPACK::DecodeError::NONE);
-  LOG(ERROR) << "Failed decoding header block for stream=" << streamId_
-             << " decodeError=" << uint32_t(decodeError);
+  PRX_DCHECK_NE(decodeInfo_.decodeError, HPACK::DecodeError::NONE);
+  PRX_LOG(ERROR) << "Failed decoding header block for stream=" << streamId_
+                 << " decodeError=" << uint32_t(decodeError);
 
   auto& msg = decodeInfo_.msg;
   if (decodeInfo_.decodeError == HPACK::DecodeError::HEADERS_TOO_LARGE &&
       debugLevel_ > 0 && msg) {
-    LOG(ERROR) << "QPACK Headers too large"
-               << CodecUtil::debugString(*msg, debugLevel_)
-               << CodecUtil::debugString(msg->getHeaders(), debugLevel_);
+    PRX_LOG(ERROR) << "QPACK Headers too large"
+                   << CodecUtil::debugString(*msg, debugLevel_)
+                   << CodecUtil::debugString(msg->getHeaders(), debugLevel_);
   }
 
   if (msg) {
@@ -289,7 +290,7 @@ void HQStreamCodec::generateHeader(
     bool /*eom*/,
     HTTPHeaderSize* size,
     const folly::Optional<HTTPHeaders>& extraHeaders) {
-  DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK_EQ(stream, streamId_);
   generateHeaderImpl(writeBuf, msg, folly::none, size, extraHeaders);
 
   // For requests, set final header seen flag right away.
@@ -305,8 +306,8 @@ void HQStreamCodec::generatePushPromise(folly::IOBufQueue& writeBuf,
                                         StreamID pushId,
                                         bool /*eom*/,
                                         HTTPHeaderSize* size) {
-  DCHECK_EQ(stream, streamId_);
-  DCHECK(transportDirection_ == TransportDirection::DOWNSTREAM);
+  PRX_DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK(transportDirection_ == TransportDirection::DOWNSTREAM);
   generateHeaderImpl(
       writeBuf, msg, pushId, size, folly::none /* extraHeaders */);
 }
@@ -345,8 +346,8 @@ void HQStreamCodec::generateHeaderImpl(
     }
   }();
 
-  LOG_IF(ERROR, !res) << __func__ << ": failed to write "
-                      << ((pushId) ? "push promise" : "headers");
+  PRX_LOG_IF(ERROR, !res) << __func__ << ": failed to write "
+                          << ((pushId) ? "push promise" : "headers");
 }
 
 size_t HQStreamCodec::generateBodyImpl(folly::IOBufQueue& writeBuf,
@@ -355,7 +356,7 @@ size_t HQStreamCodec::generateBodyImpl(folly::IOBufQueue& writeBuf,
   if (result) {
     return *result;
   }
-  LOG(FATAL) << "frame exceeded 2^62-1 limit";
+  PRX_LOG(FATAL) << "frame exceeded 2^62-1 limit";
 }
 
 size_t HQStreamCodec::generateBody(folly::IOBufQueue& writeBuf,
@@ -363,7 +364,7 @@ size_t HQStreamCodec::generateBody(folly::IOBufQueue& writeBuf,
                                    std::unique_ptr<folly::IOBuf> chain,
                                    folly::Optional<uint8_t> /*padding*/,
                                    bool /*eom*/) {
-  DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK_EQ(stream, streamId_);
 
   size_t bytesWritten = generateBodyImpl(writeBuf, std::move(chain));
 
@@ -373,7 +374,7 @@ size_t HQStreamCodec::generateBody(folly::IOBufQueue& writeBuf,
 size_t HQStreamCodec::generateTrailers(folly::IOBufQueue& writeBuf,
                                        StreamID stream,
                                        const HTTPHeaders& trailers) {
-  DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK_EQ(stream, streamId_);
   std::vector<compress::Header> allTrailers;
   CodecUtil::appendHeaders(trailers, allTrailers, HTTP_HEADER_NONE);
   auto encodeRes =
@@ -392,7 +393,7 @@ size_t HQStreamCodec::generateTrailers(folly::IOBufQueue& writeBuf,
   }();
 
   if (!res) {
-    LOG(ERROR) << __func__ << ": failed to write trailers";
+    PRX_LOG(ERROR) << __func__ << ": failed to write trailers";
     return 0;
   }
   return *res;
@@ -401,11 +402,11 @@ size_t HQStreamCodec::generateTrailers(folly::IOBufQueue& writeBuf,
 size_t HQStreamCodec::generatePadding(folly::IOBufQueue& writeBuf,
                                       StreamID stream,
                                       uint16_t padding) {
-  DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK_EQ(stream, streamId_);
   auto buf = CodecUtil::zeroedBuffer(padding);
   auto res = hq::writePadding(writeBuf, std::move(buf));
   if (!res) {
-    LOG(ERROR) << __func__ << ": failed to write padding";
+    PRX_LOG(ERROR) << __func__ << ": failed to write padding";
     return 0;
   }
   return *res;
@@ -414,7 +415,7 @@ size_t HQStreamCodec::generatePadding(folly::IOBufQueue& writeBuf,
 size_t HQStreamCodec::generateEOM(folly::IOBufQueue& /*writeBuf*/,
                                   StreamID stream) {
   // Generate EOM is a no-op
-  DCHECK_EQ(stream, streamId_);
+  PRX_DCHECK_EQ(stream, streamId_);
   return 0;
 }
 
diff --git a/proxygen/lib/http/codec/HQStreamCodec.h b/proxygen/lib/http/codec/HQStreamCodec.h
index 82a4a1dcb5..bc38635d77 100644
--- a/proxygen/lib/http/codec/HQStreamCodec.h
+++ b/proxygen/lib/http/codec/HQStreamCodec.h
@@ -15,6 +15,7 @@
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 #include <proxygen/lib/http/codec/HeaderDecodeInfo.h>
 #include <proxygen/lib/http/codec/compress/HPACKStreamingCallback.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -128,11 +129,11 @@ class HQStreamCodec
   size_t generateEOM(folly::IOBufQueue& writeBuf, StreamID stream) override;
 
   uint32_t getDefaultWindowSize() const override {
-    CHECK(false) << __func__ << " not supported";
+    PRX_CHECK(false) << __func__ << " not supported";
   }
 
   bool isRequest(StreamID /*id*/) const {
-    CHECK(false) << __func__ << " not implemented yet";
+    PRX_CHECK(false) << __func__ << " not implemented yet";
   }
 
   CompressionInfo getCompressionInfo() const override;
diff --git a/proxygen/lib/http/codec/HTTP1xCodec.cpp b/proxygen/lib/http/codec/HTTP1xCodec.cpp
index 19ffbf8935..df62531208 100644
--- a/proxygen/lib/http/codec/HTTP1xCodec.cpp
+++ b/proxygen/lib/http/codec/HTTP1xCodec.cpp
@@ -13,6 +13,7 @@
 #include <folly/ssl/OpenSSLHash.h>
 #include <proxygen/lib/http/RFC2616.h>
 #include <proxygen/lib/http/codec/CodecUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using folly::IOBufQueue;
@@ -82,7 +83,7 @@ bool validateContentLen(const HTTPHeaders& hdrs) noexcept {
         }
         return *contentLen != value; // stop if different
       });
-  LOG_IF(ERROR, !ok) << "Invalid message, multiple Content-Length headers";
+  PRX_LOG_IF(ERROR, !ok) << "Invalid message, multiple Content-Length headers";
   return ok;
 }
 
@@ -91,7 +92,7 @@ bool validateTransferEncoding(const HTTPHeaders& hdrs) noexcept {
   bool ok = !hdrs.forEachValueOfHeader(
       HTTP_HEADER_TRANSFER_ENCODING, [&](folly::StringPiece value) -> bool {
         bool err = !value.equals(kChunked, folly::AsciiCaseInsensitive{});
-        LOG_IF(ERROR, err) << "invalid transfer-encoding val=" << value;
+        PRX_LOG_IF(ERROR, err) << "invalid transfer-encoding val=" << value;
         return err; // stop on err
       });
   return ok;
@@ -143,7 +144,7 @@ HTTP1xCodec::HTTP1xCodec(TransportDirection direction,
       http_parser_init(&parser_, HTTP_RESPONSE);
       break;
     default:
-      LOG(FATAL) << "Unknown transport direction.";
+      PRX_LOG(FATAL) << "Unknown transport direction.";
   }
   parser_.data = this;
 }
@@ -161,8 +162,8 @@ HTTPCodec::StreamID HTTP1xCodec::createStream() {
 void HTTP1xCodec::setParserPaused(bool paused) {
   if ((paused == parserPaused_) || parserError_) {
     // If we're bailing early, we better be paused already
-    DCHECK(parserError_ ||
-           (HTTP_PARSER_ERRNO(&parser_) == HPE_PAUSED) == paused);
+    PRX_DCHECK(parserError_ ||
+               (HTTP_PARSER_ERRNO(&parser_) == HPE_PAUSED) == paused);
     return;
   }
   if (paused) {
@@ -226,7 +227,7 @@ size_t HTTP1xCodec::onIngressImpl(const IOBuf& buf) {
     return buf.computeChainDataLength();
   } else {
     // Callers responsibility to prevent calling onIngress from a callback
-    CHECK(!parserActive_);
+    PRX_CHECK(!parserActive_);
     parserActive_ = true;
     currentIngressBuf_ = &buf;
     if (isUpstream(transportDirection_) && parser_.http_major == 0 &&
@@ -388,7 +389,7 @@ void HTTP1xCodec::serializeWebsocketHeader(IOBufQueue& writeBuf,
     appendLiteral(writeBuf, len, "Sec-WebSocket-Key: ");
     appendString(writeBuf, len, key);
     appendLiteral(writeBuf, len, CRLF);
-    DCHECK(websockAcceptKey_.empty());
+    PRX_DCHECK(websockAcceptKey_.empty());
     websockAcceptKey_ = generateWebsocketAccept(key);
   } else {
     appendLiteral(writeBuf, len, "Upgrade: ");
@@ -414,7 +415,7 @@ void HTTP1xCodec::generateHeader(
   const bool upstream = isUpstream(transportDirection_);
   const bool downstream = !upstream;
   if (upstream) {
-    DCHECK_EQ(txn, egressTxnID_);
+    PRX_DCHECK_EQ(txn, egressTxnID_);
     requestPending_ = true;
     responsePending_ = true;
     connectRequest_ = (msg.getMethod() == HTTPMethod::CONNECT);
@@ -427,7 +428,7 @@ void HTTP1xCodec::generateHeader(
     // be > ingressTxnID_
     if ((txn != egressTxnID_ + 1 && !(txn == egressTxnID_ && is1xxResponse_)) ||
         (txn > ingressTxnID_)) {
-      LOG(DFATAL) << "Out of order, duplicate or premature HTTP response";
+      PRX_LOG(DFATAL) << "Out of order, duplicate or premature HTTP response";
     }
     if (!is1xxResponse_) {
       ++egressTxnID_;
@@ -485,7 +486,7 @@ void HTTP1xCodec::generateHeader(
   size_t len = 0;
   switch (transportDirection_) {
     case TransportDirection::DOWNSTREAM:
-      DCHECK_NE(statusCode, 0);
+      PRX_DCHECK_NE(statusCode, 0);
       if (version == HTTPMessage::kHTTPVersion09) {
         return;
       }
@@ -525,7 +526,7 @@ void HTTP1xCodec::generateHeader(
       }
       mayChunkEgress_ = (version.first == 1) && (version.second >= 1);
       if (!upgradeHeader_.empty()) {
-        LOG(DFATAL)
+        PRX_LOG(DFATAL)
             << "Attempted to pipeline HTTP request with pending upgrade";
         upgradeHeader_.clear();
       }
@@ -626,7 +627,7 @@ void HTTP1xCodec::generateHeader(
     dst += value.size();
     *dst++ = '\r';
     *dst = '\n';
-    DCHECK_EQ(size_t(++dst - (char*)writable.first), lineLen);
+    PRX_DCHECK_EQ(size_t(++dst - (char*)writable.first), lineLen);
     writeBuf.postallocate(lineLen);
     len += lineLen;
   };
@@ -669,7 +670,7 @@ void HTTP1xCodec::generateHeader(
         lastConnectionToken++;
       }
     } else {
-      LOG(ERROR) << folly::to<string>(
+      PRX_LOG(ERROR) << folly::to<string>(
           "Not serializing headers. "
           "Upgrade headers present/txn: ",
           hasUpgradeHeader,
@@ -718,7 +719,7 @@ size_t HTTP1xCodec::generateBody(IOBufQueue& writeBuf,
                                  unique_ptr<IOBuf> chain,
                                  folly::Optional<uint8_t> /*padding*/,
                                  bool eom) {
-  DCHECK_EQ(txn, egressTxnID_);
+  PRX_DCHECK_EQ(txn, egressTxnID_);
   size_t buflen = 0;
   size_t totLen = 0;
   if (chain) {
@@ -735,8 +736,8 @@ size_t HTTP1xCodec::generateBody(IOBufQueue& writeBuf,
   if (egressChunked_ && !inChunk_) {
     char chunkLenBuf[32];
     int rc = snprintf(chunkLenBuf, sizeof(chunkLenBuf), "%zx\r\n", buflen);
-    CHECK_GT(rc, 0);
-    CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
+    PRX_CHECK_GT(rc, 0);
+    PRX_CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
 
     writeBuf.append(chunkLenBuf, rc);
     totLen += rc;
@@ -760,16 +761,16 @@ size_t HTTP1xCodec::generateChunkHeader(IOBufQueue& writeBuf,
   // TODO: Format directly into the IOBuf, rather than copying after the fact.
   // IOBufQueue::append() currently forces us to copy.
 
-  CHECK(length) << "use sendEOM to terminate the message using the "
-                << "standard zero-length chunk. Don't "
-                << "send zero-length chunks using this API.";
+  PRX_CHECK(length) << "use sendEOM to terminate the message using the "
+                    << "standard zero-length chunk. Don't "
+                    << "send zero-length chunks using this API.";
   if (egressChunked_) {
-    CHECK(!inChunk_);
+    PRX_CHECK(!inChunk_);
     inChunk_ = true;
     char chunkLenBuf[32];
     int rc = snprintf(chunkLenBuf, sizeof(chunkLenBuf), "%zx\r\n", length);
-    CHECK_GT(rc, 0);
-    CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
+    PRX_CHECK_GT(rc, 0);
+    PRX_CHECK_LT(size_t(rc), sizeof(chunkLenBuf));
 
     writeBuf.append(chunkLenBuf, rc);
     return rc;
@@ -792,10 +793,10 @@ size_t HTTP1xCodec::generateChunkTerminator(IOBufQueue& writeBuf,
 size_t HTTP1xCodec::generateTrailers(IOBufQueue& writeBuf,
                                      StreamID txn,
                                      const HTTPHeaders& trailers) {
-  DCHECK_EQ(txn, egressTxnID_);
+  PRX_DCHECK_EQ(txn, egressTxnID_);
   size_t len = 0;
   if (egressChunked_) {
-    CHECK(!inChunk_);
+    PRX_CHECK(!inChunk_);
     appendLiteral(writeBuf, len, "0\r\n");
     lastChunkWritten_ = true;
     trailers.forEach([&](const string& trailer, const string& value) {
@@ -810,10 +811,10 @@ size_t HTTP1xCodec::generateTrailers(IOBufQueue& writeBuf,
 }
 
 size_t HTTP1xCodec::generateEOM(IOBufQueue& writeBuf, StreamID txn) {
-  DCHECK_EQ(txn, egressTxnID_);
+  PRX_DCHECK_EQ(txn, egressTxnID_);
   size_t len = 0;
   if (egressChunked_) {
-    CHECK(!inChunk_);
+    PRX_CHECK(!inChunk_);
     if (headRequest_ && isDownstream(transportDirection_)) {
       lastChunkWritten_ = true;
     } else {
@@ -907,11 +908,11 @@ bool HTTP1xCodec::pushHeaderNameAndValue(HTTPHeaders& hdrs) {
             compatValidate ? CodecUtil::CtlEscapeMode::STRICT_COMPAT
                            : CodecUtil::CtlEscapeMode::STRICT)) {
       validationError_ = kErrorHeaderContentValidation;
-      LOG(ERROR) << "Invalid header name=" << headerName;
-      DVLOG(4) << " value=" << currentHeaderValue_;
+      PRX_LOG(ERROR) << "Invalid header name=" << headerName;
+      PRX_DVLOG(4) << " value=" << currentHeaderValue_;
       // Hexlify the value for debuggability in case it contains non-printable
       // characters like \n, \t, etc.
-      DVLOG(4) << " value in hex=" << folly::hexlify(currentHeaderValue_);
+      PRX_DVLOG(4) << " value in hex=" << folly::hexlify(currentHeaderValue_);
       return false;
     }
   }
@@ -1019,7 +1020,7 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
 
     ParseURL parseUrl = msg_->setURL(std::move(url_), strictValidation_);
     if (strictValidation_ && !parseUrl.valid()) {
-      LOG(ERROR) << "Invalid URL: " << msg_->getURL();
+      PRX_LOG(ERROR) << "Invalid URL: " << msg_->getURL();
       return -1;
     }
     url_.clear();
@@ -1029,7 +1030,7 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
       // is part of the Request-URI. Any Host header field value in the
       // request MUST be ignored."
       auto hostAndPort = parseUrl.hostAndPort();
-      VLOG(4) << "Adding inferred host header: " << hostAndPort;
+      PRX_VLOG(4) << "Adding inferred host header: " << hostAndPort;
       msg_->getHeaders().set(HTTP_HEADER_HOST, hostAndPort);
     }
 
@@ -1060,9 +1061,10 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
       const std::string& serverUpgrade =
           msg_->getHeaders().getSingleOrEmpty(HTTP_HEADER_UPGRADE);
       if (!serverAcceptedUpgrade(upgradeHeader_, serverUpgrade)) {
-        LOG(ERROR) << "Invalid 101 response, client/server upgrade mismatch "
-                      "client="
-                   << upgradeHeader_ << " server=" << serverUpgrade;
+        PRX_LOG(ERROR)
+            << "Invalid 101 response, client/server upgrade mismatch "
+               "client="
+            << upgradeHeader_ << " server=" << serverUpgrade;
         return -1;
       }
       ingressUpgrade_ = egressUpgrade_ = true;
@@ -1092,8 +1094,8 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
       const std::string& accept =
           hdrs.getSingleOrEmpty(HTTP_HEADER_SEC_WEBSOCKET_ACCEPT);
       if (accept != websockAcceptKey_) {
-        LOG(ERROR) << "Mismatch in expected ws accept key: " << "upstream: "
-                   << accept << " expected: " << websockAcceptKey_;
+        PRX_LOG(ERROR) << "Mismatch in expected ws accept key: " << "upstream: "
+                       << accept << " expected: " << websockAcceptKey_;
         return -1;
       }
     } else {
@@ -1106,8 +1108,8 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
       // may want to change this to clear the websockAcceptKey if
       // the request doesn't succeed keeping the connection usable.
       if (!websockAcceptKey_.empty()) {
-        LOG(ERROR) << "ws accept key already set: '" << websockAcceptKey_
-                   << "'";
+        PRX_LOG(ERROR) << "ws accept key already set: '" << websockAcceptKey_
+                       << "'";
         return -1;
       }
       auto key = hdrs.getSingleOrEmpty(HTTP_HEADER_SEC_WEBSOCKET_KEY);
@@ -1163,17 +1165,17 @@ int HTTP1xCodec::onHeadersComplete(size_t len) {
 }
 
 int HTTP1xCodec::onBody(const char* buf, size_t len) {
-  DCHECK(!isParsingHeaders());
-  DCHECK(!inRecvLastChunk_);
-  CHECK_NOTNULL(currentIngressBuf_);
+  PRX_DCHECK(!isParsingHeaders());
+  PRX_DCHECK(!inRecvLastChunk_);
+  PRX_CHECK_NOTNULL(currentIngressBuf_);
   const char* dataStart = (const char*)currentIngressBuf_->data();
   const char* dataEnd = dataStart + currentIngressBuf_->length();
-  DCHECK_GE(buf, dataStart);
-  DCHECK_LE(buf + len, dataEnd);
+  PRX_DCHECK_GE(buf, dataStart);
+  PRX_DCHECK_LE(buf + len, dataEnd);
   unique_ptr<IOBuf> clone(currentIngressBuf_->cloneOne());
   clone->trimStart(buf - dataStart);
   clone->trimEnd(dataEnd - (buf + len));
-  DCHECK_EQ(len, clone->computeChainDataLength());
+  PRX_DCHECK_EQ(len, clone->computeChainDataLength());
   callback_->onBody(ingressTxnID_, std::move(clone), 0);
   return 0;
 }
@@ -1182,8 +1184,8 @@ int HTTP1xCodec::onChunkHeader(size_t len) {
   if (len > 0) {
     callback_->onChunkHeader(ingressTxnID_, len);
   } else {
-    VLOG(5) << "Suppressed onChunkHeader callback for final zero length "
-            << "chunk";
+    PRX_VLOG(5) << "Suppressed onChunkHeader callback for final zero length "
+                << "chunk";
     inRecvLastChunk_ = true;
   }
   return 0;
@@ -1199,8 +1201,8 @@ int HTTP1xCodec::onChunkComplete() {
 }
 
 int HTTP1xCodec::onMessageComplete() {
-  DCHECK(!isParsingHeaders());
-  DCHECK(!inRecvLastChunk_);
+  PRX_DCHECK(!isParsingHeaders());
+  PRX_DCHECK(!inRecvLastChunk_);
   if (headerParseState_ == HeaderParseState::kParsingTrailerValue) {
     if (!trailers_) {
       trailers_ = std::make_unique<HTTPHeaders>();
@@ -1242,8 +1244,8 @@ int HTTP1xCodec::onMessageComplete() {
 
 int HTTP1xCodec::onMessageBeginCB(http_parser* parser) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onMessageBegin();
@@ -1255,8 +1257,8 @@ int HTTP1xCodec::onMessageBeginCB(http_parser* parser) {
 
 int HTTP1xCodec::onUrlCB(http_parser* parser, const char* buf, size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onURL(buf, len);
@@ -1268,8 +1270,8 @@ int HTTP1xCodec::onUrlCB(http_parser* parser, const char* buf, size_t len) {
 
 int HTTP1xCodec::onReasonCB(http_parser* parser, const char* buf, size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onReason(buf, len);
@@ -1283,8 +1285,8 @@ int HTTP1xCodec::onHeaderFieldCB(http_parser* parser,
                                  const char* buf,
                                  size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeaderField(buf, len);
@@ -1298,8 +1300,8 @@ int HTTP1xCodec::onHeaderValueCB(http_parser* parser,
                                  const char* buf,
                                  size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeaderValue(buf, len);
@@ -1313,8 +1315,8 @@ int HTTP1xCodec::onHeadersCompleteCB(http_parser* parser,
                                      const char* /*buf*/,
                                      size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onHeadersComplete(len);
@@ -1326,8 +1328,8 @@ int HTTP1xCodec::onHeadersCompleteCB(http_parser* parser,
 
 int HTTP1xCodec::onBodyCB(http_parser* parser, const char* buf, size_t len) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onBody(buf, len);
@@ -1345,8 +1347,8 @@ int HTTP1xCodec::onBodyCB(http_parser* parser, const char* buf, size_t len) {
 
 int HTTP1xCodec::onChunkHeaderCB(http_parser* parser) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onChunkHeader(parser->content_length);
@@ -1358,8 +1360,8 @@ int HTTP1xCodec::onChunkHeaderCB(http_parser* parser) {
 
 int HTTP1xCodec::onChunkCompleteCB(http_parser* parser) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onChunkComplete();
@@ -1371,8 +1373,8 @@ int HTTP1xCodec::onChunkCompleteCB(http_parser* parser) {
 
 int HTTP1xCodec::onMessageCompleteCB(http_parser* parser) {
   auto* codec = static_cast<HTTP1xCodec*>(parser->data);
-  DCHECK(codec != nullptr);
-  DCHECK_EQ(&codec->parser_, parser);
+  PRX_DCHECK(codec != nullptr);
+  PRX_DCHECK_EQ(&codec->parser_, parser);
 
   try {
     return codec->onMessageComplete();
diff --git a/proxygen/lib/http/codec/HTTP2Codec.cpp b/proxygen/lib/http/codec/HTTP2Codec.cpp
index 8484d2823b..69c20a4123 100644
--- a/proxygen/lib/http/codec/HTTP2Codec.cpp
+++ b/proxygen/lib/http/codec/HTTP2Codec.cpp
@@ -18,6 +18,7 @@
 #include <folly/Try.h>
 #include <folly/io/Cursor.h>
 #include <folly/tracing/ScopedTraceSection.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly::io;
 using namespace folly;
@@ -43,8 +44,8 @@ HTTP2Codec::HTTP2Codec(TransportDirection direction)
     headerCodec_.setMaxUncompressed(maxHeaderListSize->value);
   }
 
-  VLOG(4) << "creating " << getTransportDirectionString(direction)
-          << " HTTP/2 codec";
+  PRX_VLOG(4) << "creating " << getTransportDirectionString(direction)
+              << " HTTP/2 codec";
 }
 
 HTTP2Codec::~HTTP2Codec() = default;
@@ -67,7 +68,7 @@ size_t HTTP2Codec::onIngress(const folly::IOBuf& buf) noexcept {
         parsed += http2::kConnectionPreface.length();
         if (test != http2::kConnectionPreface) {
           goawayErrorMessage_ = "missing connection preface";
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           connError = ErrorCode::PROTOCOL_ERROR;
         }
         frameState_ = FrameState::EXPECT_FIRST_SETTINGS;
@@ -90,11 +91,11 @@ size_t HTTP2Codec::onIngress(const folly::IOBuf& buf) noexcept {
               ")",
               " for streamID=",
               curHeader_.stream);
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           connError = ErrorCode::PROTOCOL_ERROR;
         }
         if (curHeader_.length > maxRecvFrameSize()) {
-          VLOG(4) << "Excessively large frame len=" << curHeader_.length;
+          PRX_VLOG(4) << "Excessively large frame len=" << curHeader_.length;
           connError = ErrorCode::FRAME_SIZE_ERROR;
         }
 
@@ -162,7 +163,7 @@ ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
         curHeader_.stream,
         " of type=",
         getFrameTypeString(curHeader_.type));
-    VLOG(4) << goawayErrorMessage_;
+    PRX_VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (expectedContinuationStream_ == 0 &&
@@ -170,7 +171,7 @@ ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: unexpected CONTINUATION received with streamID=",
         curHeader_.stream);
-    VLOG(4) << goawayErrorMessage_;
+    PRX_VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (frameAffectsCompression(curHeader_.type) &&
@@ -187,7 +188,7 @@ ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
     // 10.3)
     goawayErrorMessage_ = folly::to<string>(
         "Failing connection due to excessively large headers");
-    LOG(ERROR) << goawayErrorMessage_;
+    PRX_LOG(ERROR) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
 
@@ -196,7 +197,7 @@ ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
       goawayErrorMessage_ = folly::to<string>(
           "GOAWAY error: too many CONTINUATION frames for stream=",
           curHeader_.stream);
-      LOG(ERROR) << goawayErrorMessage_;
+      PRX_LOG(ERROR) << goawayErrorMessage_;
       return ErrorCode::ENHANCE_YOUR_CALM;
     }
     --continuationFramesLeftInHeaderBlock_;
@@ -250,8 +251,8 @@ ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
   // PRIORITY frames are deprecated in RFC 9113/9218 but still sent by legacy H2
   // implementations. Skip logging these frames to reduce noise.
   if (curHeader_.type != http2::FrameType::PRIORITY) {
-    VLOG(2) << "Skipping frame (type=" << static_cast<int>(curHeader_.type)
-            << ")";
+    PRX_VLOG(2) << "Skipping frame (type=" << static_cast<int>(curHeader_.type)
+                << ")";
   }
   cursor.skip(curHeader_.length);
   return ErrorCode::NO_ERROR;
@@ -292,8 +293,8 @@ ErrorCode HTTP2Codec::handleEndStream() {
 ErrorCode HTTP2Codec::parseAllData(Cursor& cursor) {
   std::unique_ptr<IOBuf> outData;
   uint16_t padding = 0;
-  VLOG(10) << "parsing all frame DATA bytes for stream=" << curHeader_.stream
-           << " length=" << curHeader_.length;
+  PRX_VLOG(10) << "parsing all frame DATA bytes for stream="
+               << curHeader_.stream << " length=" << curHeader_.length;
   auto ret = http2::parseData(cursor, curHeader_, outData, padding);
   RETURN_IF_ERROR(ret);
 
@@ -315,17 +316,18 @@ ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
                                          size_t& parsed) {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseDataFrameData");
   if (bufLen == 0) {
-    VLOG(10) << "No data to parse";
+    PRX_VLOG(10) << "No data to parse";
     return ErrorCode::NO_ERROR;
   }
 
   std::unique_ptr<IOBuf> outData;
   uint16_t padding = 0;
-  VLOG(10) << "parsing DATA frame data for stream=" << curHeader_.stream
-           << " frame data length=" << curHeader_.length
-           << " pendingDataFrameBytes_=" << pendingDataFrameBytes_
-           << " pendingDataFramePaddingBytes_=" << pendingDataFramePaddingBytes_
-           << " bufLen=" << bufLen << " parsed=" << parsed;
+  PRX_VLOG(10)
+      << "parsing DATA frame data for stream=" << curHeader_.stream
+      << " frame data length=" << curHeader_.length
+      << " pendingDataFrameBytes_=" << pendingDataFrameBytes_
+      << " pendingDataFramePaddingBytes_=" << pendingDataFramePaddingBytes_
+      << " bufLen=" << bufLen << " parsed=" << parsed;
   // Parse the padding information only the first time
   if (pendingDataFrameBytes_ == curHeader_.length &&
       pendingDataFramePaddingBytes_ == 0) {
@@ -342,7 +344,7 @@ ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
       bufLen--;
       parsed++;
     }
-    VLOG(10)
+    PRX_VLOG(10)
         << "out padding=" << padding
         << " pendingDataFrameBytes_=" << pendingDataFrameBytes_
         << " pendingDataFramePaddingBytes_=" << pendingDataFramePaddingBytes_
@@ -358,10 +360,11 @@ ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
       bufLen -= toClone;
       pendingDataFrameBytes_ -= toClone;
       parsed += toClone;
-      VLOG(10) << "parsed some app data, pendingDataFrameBytes_="
-               << pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_="
-               << pendingDataFramePaddingBytes_ << " bufLen=" << bufLen
-               << " parsed=" << parsed;
+      PRX_VLOG(10)
+          << "parsed some app data, pendingDataFrameBytes_="
+          << pendingDataFrameBytes_
+          << " pendingDataFramePaddingBytes_=" << pendingDataFramePaddingBytes_
+          << " bufLen=" << bufLen << " parsed=" << parsed;
     }
     // Check if we have padding bytes to parse
     if (bufLen > 0 && pendingDataFramePaddingBytes_ > 0) {
@@ -372,10 +375,11 @@ ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
       pendingDataFrameBytes_ -= toSkip;
       pendingDataFramePaddingBytes_ -= toSkip;
       parsed += toSkip;
-      VLOG(10) << "parsed some padding, pendingDataFrameBytes_="
-               << pendingDataFrameBytes_ << " pendingDataFramePaddingBytes_="
-               << pendingDataFramePaddingBytes_ << " bufLen=" << bufLen
-               << " parsed=" << parsed;
+      PRX_VLOG(10)
+          << "parsed some padding, pendingDataFrameBytes_="
+          << pendingDataFrameBytes_
+          << " pendingDataFramePaddingBytes_=" << pendingDataFramePaddingBytes_
+          << " bufLen=" << bufLen << " parsed=" << parsed;
     }
   }
 
@@ -395,8 +399,8 @@ ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
 ErrorCode HTTP2Codec::parseHeaders(Cursor& cursor) {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Codec - parseHeaders");
   std::unique_ptr<IOBuf> headerBuf;
-  VLOG(4) << "parsing HEADERS frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing HEADERS frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   auto err = http2::parseHeaders(cursor, curHeader_, headerBuf);
   RETURN_IF_ERROR(err);
   if (isDownstream(transportDirection_)) {
@@ -409,8 +413,8 @@ ErrorCode HTTP2Codec::parseHeaders(Cursor& cursor) {
 
 ErrorCode HTTP2Codec::parseContinuation(Cursor& cursor) {
   std::unique_ptr<IOBuf> headerBuf;
-  VLOG(4) << "parsing CONTINUATION frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing CONTINUATION frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   auto err = http2::parseContinuation(cursor, curHeader_, headerBuf);
   RETURN_IF_ERROR(err);
   err = parseHeadersImpl(cursor, std::move(headerBuf), folly::none);
@@ -445,7 +449,7 @@ ErrorCode HTTP2Codec::parseHeadersImpl(
       parsingReq_ = isDownstream(transportDirection_);
     }
   } else if (headerBlockFrameType_ == http2::FrameType::PUSH_PROMISE) {
-    CHECK(promisedStream_.hasValue());
+    PRX_CHECK(promisedStream_.hasValue());
     headersCompleteStream = *promisedStream_;
   }
 
@@ -481,7 +485,7 @@ ErrorCode HTTP2Codec::parseHeadersImpl(
                              curHeader_.stream,
                              msg.get());
   } else if (curHeader_.type == http2::FrameType::PUSH_PROMISE) {
-    DCHECK(promisedStream);
+    PRX_DCHECK(promisedStream);
     deliverCallbackIfAllowed(&HTTPCodec::Callback::onPushMessageBegin,
                              "onPushMessageBegin",
                              *promisedStream,
@@ -501,8 +505,8 @@ ErrorCode HTTP2Codec::parseHeadersImpl(
       msg->setIsChunked(true);
     }
     if (trailers) {
-      VLOG(4) << "Trailers complete for streamId=" << headersCompleteStream
-              << " direction=" << transportDirection_;
+      PRX_VLOG(4) << "Trailers complete for streamId=" << headersCompleteStream
+                  << " direction=" << transportDirection_;
       auto trailerHeaders =
           std::make_unique<HTTPHeaders>(msg->extractHeaders());
       msg.reset();
@@ -515,7 +519,7 @@ ErrorCode HTTP2Codec::parseHeadersImpl(
           curHeader_.stream >= nextEgressStreamID_) {
         goawayErrorMessage_ = folly::to<std::string>(
             "HEADERS on idle upstream stream=", curHeader_.stream);
-        LOG(ERROR) << goawayErrorMessage_;
+        PRX_LOG(ERROR) << goawayErrorMessage_;
         return ErrorCode::PROTOCOL_ERROR;
       }
       deliverCallbackIfAllowed(&HTTPCodec::Callback::onHeadersComplete,
@@ -559,16 +563,17 @@ HTTP2Codec::parseHeadersDecodeFrames() {
                                  curHeader_.stream,
                                  ": decompression error=",
                                  uint32_t(decodeInfo_.decodeError));
-      LOG(ERROR) << goawayErrorMessage_
-                 << (VLOG_IS_ON(3) ? ", header block=" : "");
-      VLOG(3) << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
+      PRX_LOG(ERROR) << goawayErrorMessage_
+                     << (PRX_VLOG_IS_ON(3) ? ", header block=" : "");
+      PRX_VLOG(3) << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
     } else {
       goawayErrorMessage_ = folly::to<std::string>(
           kDecodeErrorMessage, curHeader_.stream, ": headers too large");
       if (debugLevel_ > 0 && msg) {
-        LOG(ERROR) << "HPACK Headers too large"
-                   << CodecUtil::debugString(*msg, debugLevel_)
-                   << CodecUtil::debugString(msg->getHeaders(), debugLevel_);
+        PRX_LOG(ERROR)
+            << "HPACK Headers too large"
+            << CodecUtil::debugString(*msg, debugLevel_)
+            << CodecUtil::debugString(msg->getHeaders(), debugLevel_);
       }
     }
 
@@ -583,13 +588,14 @@ HTTP2Codec::parseHeadersDecodeFrames() {
   // Check parsing error
   if (!decodeInfo_.parsingError.empty()) {
     // This is "malformed" per the RFC
-    LOG(ERROR) << "Failed parsing header list for stream=" << curHeader_.stream
-               << ", error=" << decodeInfo_.parsingError;
+    PRX_LOG(ERROR)
+        << "Failed parsing header list for stream=" << curHeader_.stream
+        << ", error=" << decodeInfo_.parsingError;
     if (!decodeInfo_.headerErrorValue.empty()) {
-      DVLOG(4) << " value=" << decodeInfo_.headerErrorValue;
+      PRX_DVLOG(4) << " value=" << decodeInfo_.headerErrorValue;
     }
-    VLOG(3) << "Header block="
-            << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
+    PRX_VLOG(3) << "Header block="
+                << IOBufPrinter::printHexFolly(curHeaderBlock_.front(), true);
     if (isDownstream(transportDirection_) && parsingHeaders() &&
         !parsingTrailers()) {
       return folly::makeUnexpected(
@@ -620,7 +626,7 @@ HTTP2Codec::parseHeadersDecodeFrames() {
 
 void HTTP2Codec::deliverDeferredParseError(
     const DeferredParseError& parseError) {
-  CHECK(!parseError.connectionError);
+  PRX_CHECK(!parseError.connectionError);
   if (parseError.errorCode != ErrorCode::NO_ERROR) {
     streamError(parseError.errorMessage,
                 parseError.errorCode,
@@ -673,8 +679,8 @@ void HTTP2Codec::onHeader(const HPACKHeaderName& name,
       userAgent_ = value.toStdString();
     }
   } else {
-    VLOG(4) << "dir=" << uint32_t(transportDirection_)
-            << decodeInfo_.parsingError << " codec=" << headerCodec_;
+    PRX_VLOG(4) << "dir=" << uint32_t(transportDirection_)
+                << decodeInfo_.parsingError << " codec=" << headerCodec_;
   }
 }
 
@@ -708,8 +714,8 @@ void HTTP2Codec::onDecodeError(HPACK::DecodeError decodeError) {
 }
 
 ErrorCode HTTP2Codec::parseRFC9218Priority(Cursor& cursor) {
-  VLOG(4) << "parsing RFC 9218 PRIORITY_UPDATE frame for stream="
-          << curHeader_.stream << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing RFC 9218 PRIORITY_UPDATE frame for stream="
+              << curHeader_.stream << " length=" << curHeader_.length;
   std::string pri;
   uint32_t priStream = 0;
   auto err = http2::parseRFC9218Priority(cursor, curHeader_, priStream, pri);
@@ -725,16 +731,16 @@ ErrorCode HTTP2Codec::parseRFC9218Priority(Cursor& cursor) {
 
 ErrorCode HTTP2Codec::parseRstStream(Cursor& cursor) {
   // rst for stream in idle state - protocol error
-  VLOG(4) << "parsing RST_STREAM frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing RST_STREAM frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   upgradedStreams_.erase(curHeader_.stream);
   ErrorCode statusCode = ErrorCode::NO_ERROR;
   auto err = http2::parseRstStream(cursor, curHeader_, statusCode);
   RETURN_IF_ERROR(err);
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
-    VLOG(3) << "RST_STREAM with code=" << getErrorCodeString(statusCode)
-            << " for streamID=" << curHeader_.stream
-            << " user-agent=" << userAgent_;
+    PRX_VLOG(3) << "RST_STREAM with code=" << getErrorCodeString(statusCode)
+                << " for streamID=" << curHeader_.stream
+                << " user-agent=" << userAgent_;
   }
   deliverCallbackIfAllowed(
       &HTTPCodec::Callback::onAbort, "onAbort", curHeader_.stream, statusCode);
@@ -742,8 +748,8 @@ ErrorCode HTTP2Codec::parseRstStream(Cursor& cursor) {
 }
 
 ErrorCode HTTP2Codec::parseSettings(Cursor& cursor) {
-  VLOG(4) << "parsing SETTINGS frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing SETTINGS frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   std::deque<SettingPair> settings;
   auto err = http2::parseSettings(cursor, curHeader_, settings);
   RETURN_IF_ERROR(err);
@@ -771,8 +777,8 @@ ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& settings) {
       case SettingsId::HEADER_TABLE_SIZE: {
         uint32_t tableSize = setting.second;
         if (setting.second > http2::kMaxHeaderTableSize) {
-          VLOG(2) << "Limiting table size from " << tableSize << " to "
-                  << http2::kMaxHeaderTableSize;
+          PRX_VLOG(2) << "Limiting table size from " << tableSize << " to "
+                      << http2::kMaxHeaderTableSize;
           tableSize = http2::kMaxHeaderTableSize;
         }
         headerCodec_.setEncoderHeaderTableSize(tableSize);
@@ -785,7 +791,7 @@ ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& settings) {
                                 setting.second,
                                 " for streamID=",
                                 curHeader_.stream);
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
@@ -798,7 +804,7 @@ ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& settings) {
               setting.second,
               " for streamID=",
               curHeader_.stream);
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
@@ -810,7 +816,7 @@ ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& settings) {
                                 setting.second,
                                 " for streamID=",
                                 curHeader_.stream);
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         ingressSettings_.setSetting(SettingsId::MAX_FRAME_SIZE, setting.second);
@@ -824,7 +830,7 @@ ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& settings) {
               setting.second,
               " for streamID=",
               curHeader_.stream);
-          VLOG(4) << goawayErrorMessage_;
+          PRX_VLOG(4) << goawayErrorMessage_;
           return ErrorCode::PROTOCOL_ERROR;
         }
         break;
@@ -863,17 +869,17 @@ ErrorCode HTTP2Codec::parsePushPromise(Cursor& cursor) {
   if (isDownstream(transportDirection_)) {
     goawayErrorMessage_ =
         folly::to<string>("Received PUSH_PROMISE on DOWNSTREAM codec");
-    VLOG(2) << goawayErrorMessage_;
+    PRX_VLOG(2) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   if (egressSettings_.getSetting(SettingsId::ENABLE_PUSH, -1) != 1) {
     goawayErrorMessage_ =
         folly::to<string>("Received PUSH_PROMISE on codec with push disabled");
-    VLOG(2) << goawayErrorMessage_;
+    PRX_VLOG(2) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
-  VLOG(4) << "parsing PUSH_PROMISE frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing PUSH_PROMISE frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   uint32_t promisedStream;
   std::unique_ptr<IOBuf> headerBlockFragment;
   auto err = http2::parsePushPromise(
@@ -886,7 +892,7 @@ ErrorCode HTTP2Codec::parsePushPromise(Cursor& cursor) {
 }
 
 ErrorCode HTTP2Codec::parsePing(Cursor& cursor) {
-  VLOG(4) << "parsing PING frame length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing PING frame length=" << curHeader_.length;
   uint64_t opaqueData = 0;
   auto err = http2::parsePing(cursor, curHeader_, opaqueData);
   RETURN_IF_ERROR(err);
@@ -901,7 +907,7 @@ ErrorCode HTTP2Codec::parsePing(Cursor& cursor) {
 }
 
 ErrorCode HTTP2Codec::parseGoaway(Cursor& cursor) {
-  VLOG(4) << "parsing GOAWAY frame length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing GOAWAY frame length=" << curHeader_.length;
   uint32_t lastGoodStream = 0;
   ErrorCode statusCode = ErrorCode::NO_ERROR;
   std::unique_ptr<IOBuf> debugData;
@@ -909,10 +915,10 @@ ErrorCode HTTP2Codec::parseGoaway(Cursor& cursor) {
   auto err = http2::parseGoaway(
       cursor, curHeader_, lastGoodStream, statusCode, debugData);
   if (statusCode != ErrorCode::NO_ERROR) {
-    VLOG(3) << "Goaway error statusCode=" << getErrorCodeString(statusCode)
-            << " lastStream=" << lastGoodStream << " user-agent=" << userAgent_
-            << " debugData="
-            << ((debugData) ? debugData->to<std::string>() : empty_string);
+    PRX_VLOG(3) << "Goaway error statusCode=" << getErrorCodeString(statusCode)
+                << " lastStream=" << lastGoodStream
+                << " user-agent=" << userAgent_ << " debugData="
+                << ((debugData) ? debugData->to<std::string>() : empty_string);
   }
   RETURN_IF_ERROR(err);
   if (lastGoodStream < ingressGoawayAck_) {
@@ -923,19 +929,19 @@ ErrorCode HTTP2Codec::parseGoaway(Cursor& cursor) {
       callback_->onGoaway(lastGoodStream, statusCode, std::move(debugData));
     }
   } else {
-    LOG(WARNING) << "Received multiple GOAWAY with increasing ack";
+    PRX_LOG(WARNING) << "Received multiple GOAWAY with increasing ack";
   }
   return ErrorCode::NO_ERROR;
 }
 
 ErrorCode HTTP2Codec::parseWindowUpdate(Cursor& cursor) {
-  VLOG(4) << "parsing WINDOW_UPDATE frame for stream=" << curHeader_.stream
-          << " length=" << curHeader_.length;
+  PRX_VLOG(4) << "parsing WINDOW_UPDATE frame for stream=" << curHeader_.stream
+              << " length=" << curHeader_.length;
   uint32_t delta = 0;
   auto err = http2::parseWindowUpdate(cursor, curHeader_, delta);
   RETURN_IF_ERROR(err);
   if (delta == 0) {
-    VLOG(4) << "Invalid 0 length delta for stream=" << curHeader_.stream;
+    PRX_VLOG(4) << "Invalid 0 length delta for stream=" << curHeader_.stream;
     if (curHeader_.stream == 0) {
       goawayErrorMessage_ = folly::to<string>(
           "GOAWAY error: invalid/0 length delta for streamID=",
@@ -946,7 +952,7 @@ ErrorCode HTTP2Codec::parseWindowUpdate(Cursor& cursor) {
       // and send a rst stream
       goawayErrorMessage_ = folly::to<std::string>(
           "streamID=", curHeader_.stream, " with window update delta=", delta);
-      VLOG(4) << goawayErrorMessage_;
+      PRX_VLOG(4) << goawayErrorMessage_;
       streamError(goawayErrorMessage_, ErrorCode::PROTOCOL_ERROR);
       // Stream error and protocol error
       return ErrorCode::PROTOCOL_ERROR;
@@ -969,12 +975,12 @@ ErrorCode HTTP2Codec::checkNewStream(uint32_t streamId, bool trailersAllowed) {
                           streamId,
                           " as invalid new stream for lastStreamID_=",
                           lastStreamID_);
-    VLOG(4) << goawayErrorMessage_;
+    PRX_VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   }
   parsingDownstreamTrailers_ = trailersAllowed && existingStream;
   if (parsingDownstreamTrailers_) {
-    VLOG(4) << "Parsing downstream trailers streamId=" << streamId;
+    PRX_VLOG(4) << "Parsing downstream trailers streamId=" << streamId;
   }
 
   if (sessionClosing_ != ClosingState::CLOSED && !existingStream) {
@@ -985,7 +991,7 @@ ErrorCode HTTP2Codec::checkNewStream(uint32_t streamId, bool trailersAllowed) {
     // this stream should be initiated by us, not by peer
     goawayErrorMessage_ = folly::to<string>(
         "GOAWAY error: invalid new stream received with streamID=", streamId);
-    VLOG(4) << goawayErrorMessage_;
+    PRX_VLOG(4) << goawayErrorMessage_;
     return ErrorCode::PROTOCOL_ERROR;
   } else {
     return ErrorCode::NO_ERROR;
@@ -994,7 +1000,7 @@ ErrorCode HTTP2Codec::checkNewStream(uint32_t streamId, bool trailersAllowed) {
 
 size_t HTTP2Codec::generateConnectionPreface(folly::IOBufQueue& writeBuf) {
   if (isUpstream(transportDirection_)) {
-    VLOG(4) << "generating connection preface";
+    PRX_VLOG(4) << "generating connection preface";
     writeBuf.append(http2::kConnectionPreface);
     return http2::kConnectionPreface.length();
   }
@@ -1036,7 +1042,7 @@ size_t HTTP2Codec::splitCompressed(size_t compressed,
                                    uint32_t remainingFrameSize,
                                    folly::IOBufQueue& writeBuf,
                                    folly::IOBufQueue& queue) {
-  CHECK_GT(compressed, 0) << "compressed block must be at least 1 byte";
+  PRX_CHECK_GT(compressed, 0u) << "compressed block must be at least 1 byte";
   auto chunkLen = compressed;
   if (chunkLen > remainingFrameSize) {
     // There's more here than fits in one frame.  Put the remainder in queue
@@ -1062,14 +1068,14 @@ void HTTP2Codec::generateHeaderImpl(
     size = &localSize;
   }
   if (assocStream) {
-    VLOG(4) << "generating PUSH_PROMISE for stream=" << stream;
+    PRX_VLOG(4) << "generating PUSH_PROMISE for stream=" << stream;
   } else {
-    VLOG(4) << "generating HEADERS for stream=" << stream;
+    PRX_VLOG(4) << "generating HEADERS for stream=" << stream;
   }
 
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "Suppressing HEADERS/PROMISE for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "Suppressing HEADERS/PROMISE for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     if (size) {
       size->uncompressed = 0;
       size->compressed = 0;
@@ -1078,12 +1084,12 @@ void HTTP2Codec::generateHeaderImpl(
   }
 
   if (msg.isRequest()) {
-    DCHECK(isUpstream(transportDirection_) || assocStream);
+    PRX_DCHECK(isUpstream(transportDirection_) || assocStream);
     if (msg.isEgressWebsocketUpgrade()) {
       upgradedStreams_.insert(stream);
     }
   } else {
-    DCHECK(isDownstream(transportDirection_));
+    PRX_DCHECK(isDownstream(transportDirection_));
   }
 
   auto headerSize =
@@ -1108,8 +1114,8 @@ void HTTP2Codec::generateHeaderImpl(
       splitCompressed(size->compressed, remainingFrameSize, writeBuf, queue);
   bool endHeaders = queue.chainLength() == 0;
   if (assocStream) {
-    DCHECK_EQ(transportDirection_, TransportDirection::DOWNSTREAM);
-    DCHECK(!eom);
+    PRX_DCHECK_EQ(transportDirection_, TransportDirection::DOWNSTREAM);
+    PRX_DCHECK(!eom);
     generateHeaderCallbackWrapper(
         stream,
         http2::FrameType::PUSH_PROMISE,
@@ -1149,7 +1155,7 @@ void HTTP2Codec::generateContinuation(folly::IOBufQueue& writeBuf,
   while (!endHeaders) {
     auto chunk = queue.split(std::min(maxFrameSize, queue.chainLength()));
     endHeaders = (queue.chainLength() == 0);
-    VLOG(4) << "generating CONTINUATION for stream=" << stream;
+    PRX_VLOG(4) << "generating CONTINUATION for stream=" << stream;
     generateHeaderCallbackWrapper(
         stream,
         http2::FrameType::CONTINUATION,
@@ -1193,12 +1199,12 @@ size_t HTTP2Codec::generateBody(folly::IOBufQueue& writeBuf,
   // todo: generate random padding for everything?
   size_t written = 0;
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "Suppressing DATA for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "Suppressing DATA for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
-  VLOG(4) << "generating DATA for stream=" << stream
-          << " size=" << (chain ? chain->computeChainDataLength() : 0);
+  PRX_VLOG(4) << "generating DATA for stream=" << stream
+              << " size=" << (chain ? chain->computeChainDataLength() : 0);
   IOBufQueue queue(IOBufQueue::cacheChainLength());
   queue.append(std::move(chain));
   size_t maxFrameSize = maxSendFrameSize();
@@ -1242,7 +1248,7 @@ size_t HTTP2Codec::generateChunkTerminator(folly::IOBufQueue& /*writeBuf*/,
 size_t HTTP2Codec::generateTrailers(folly::IOBufQueue& writeBuf,
                                     StreamID stream,
                                     const HTTPHeaders& trailers) {
-  VLOG(4) << "generating TRAILERS for stream=" << stream;
+  PRX_VLOG(4) << "generating TRAILERS for stream=" << stream;
   std::vector<compress::Header> allHeaders;
   CodecUtil::appendHeaders(trailers, allHeaders, HTTP_HEADER_NONE);
   if (allHeaders.size() == 0) {
@@ -1289,7 +1295,7 @@ size_t HTTP2Codec::generatePadding(folly::IOBufQueue& writeBuf,
   // range. We will have plenty of heads up before this frame type is used.
   // HTTP/2 frame types aren't added very frequently.
   size_t written = 0;
-  VLOG(4) << "generating padding=" << padding << " for stream=" << stream;
+  PRX_VLOG(4) << "generating padding=" << padding << " for stream=" << stream;
   auto maxFrameSizeFull = maxSendFrameSize();
   auto maxFrameSize = static_cast<uint16_t>(std::min<std::size_t>(
       maxFrameSizeFull, (std::numeric_limits<uint16_t>::max)()));
@@ -1304,11 +1310,11 @@ size_t HTTP2Codec::generatePadding(folly::IOBufQueue& writeBuf,
 }
 
 size_t HTTP2Codec::generateEOM(folly::IOBufQueue& writeBuf, StreamID stream) {
-  VLOG(4) << "sending EOM for stream=" << stream;
+  PRX_VLOG(4) << "sending EOM for stream=" << stream;
   upgradedStreams_.erase(stream);
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "suppressed EOM for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "suppressed EOM for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   return generateHeaderCallbackWrapper(
@@ -1325,11 +1331,11 @@ size_t HTTP2Codec::generateEOM(folly::IOBufQueue& writeBuf, StreamID stream) {
 size_t HTTP2Codec::generateRstStream(folly::IOBufQueue& writeBuf,
                                      StreamID stream,
                                      ErrorCode statusCode) {
-  VLOG(4) << "sending RST_STREAM for stream=" << stream
-          << " with code=" << getErrorCodeString(statusCode);
+  PRX_VLOG(4) << "sending RST_STREAM for stream=" << stream
+              << " with code=" << getErrorCodeString(statusCode);
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "suppressed RST_STREAM for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "suppressed RST_STREAM for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   // Suppress any EOM callback for the current frame.
@@ -1341,8 +1347,9 @@ size_t HTTP2Codec::generateRstStream(folly::IOBufQueue& writeBuf,
   upgradedStreams_.erase(stream);
 
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
-    VLOG(2) << "sending RST_STREAM with code=" << getErrorCodeString(statusCode)
-            << " for stream=" << stream << " user-agent=" << userAgent_;
+    PRX_VLOG(2)
+        << "sending RST_STREAM with code=" << getErrorCodeString(statusCode)
+        << " for stream=" << stream << " user-agent=" << userAgent_;
   }
   return generateHeaderCallbackWrapper(
       stream,
@@ -1355,7 +1362,7 @@ size_t HTTP2Codec::generateGoaway(folly::IOBufQueue& writeBuf,
                                   ErrorCode statusCode,
                                   std::unique_ptr<folly::IOBuf> debugData) {
   if (sessionClosing_ == ClosingState::CLOSED) {
-    VLOG(4) << "Not sending GOAWAY for closed session";
+    PRX_VLOG(4) << "Not sending GOAWAY for closed session";
     return 0;
   }
 
@@ -1369,7 +1376,8 @@ size_t HTTP2Codec::generateGoaway(folly::IOBufQueue& writeBuf,
       lastStream = http2::kMaxStreamID;
     }
   }
-  DCHECK_LE(lastStream, egressGoawayAck_) << "Cannot increase last good stream";
+  PRX_DCHECK_LE(lastStream, egressGoawayAck_)
+      << "Cannot increase last good stream";
   egressGoawayAck_ = lastStream;
   switch (sessionClosing_) {
     case ClosingState::OPEN:
@@ -1387,17 +1395,17 @@ size_t HTTP2Codec::generateGoaway(folly::IOBufQueue& writeBuf,
       sessionClosing_ = ClosingState::CLOSED;
       break;
     case ClosingState::CLOSED:
-      LOG(FATAL) << "unreachable";
+      PRX_LOG(FATAL) << "unreachable";
     default:
-      LOG(FATAL) << "unhandled state";
+      PRX_LOG(FATAL) << "unhandled state";
   }
 
-  VLOG(4) << "Sending GOAWAY with last acknowledged stream=" << lastStream
-          << " with code=" << getErrorCodeString(statusCode);
+  PRX_VLOG(4) << "Sending GOAWAY with last acknowledged stream=" << lastStream
+              << " with code=" << getErrorCodeString(statusCode);
   if (statusCode == ErrorCode::PROTOCOL_ERROR) {
-    VLOG(2) << "sending GOAWAY with last acknowledged stream=" << lastStream
-            << " with code=" << getErrorCodeString(statusCode)
-            << " user-agent=" << userAgent_;
+    PRX_VLOG(2) << "sending GOAWAY with last acknowledged stream=" << lastStream
+                << " with code=" << getErrorCodeString(statusCode)
+                << " user-agent=" << userAgent_;
   }
 
   return generateHeaderCallbackWrapper(
@@ -1414,7 +1422,7 @@ size_t HTTP2Codec::generatePingRequest(folly::IOBufQueue& writeBuf,
   if (!data.has_value()) {
     data = folly::Random::rand64();
   }
-  VLOG(4) << "Generating ping request with data=" << *data;
+  PRX_VLOG(4) << "Generating ping request with data=" << *data;
   return generateHeaderCallbackWrapper(
       0,
       http2::FrameType::PING,
@@ -1423,7 +1431,7 @@ size_t HTTP2Codec::generatePingRequest(folly::IOBufQueue& writeBuf,
 
 size_t HTTP2Codec::generatePingReply(folly::IOBufQueue& writeBuf,
                                      uint64_t data) {
-  VLOG(4) << "Generating ping reply with data=" << data;
+  PRX_VLOG(4) << "Generating ping reply with data=" << data;
   return generateHeaderCallbackWrapper(
       0,
       http2::FrameType::PING,
@@ -1436,7 +1444,8 @@ size_t HTTP2Codec::generateSettings(folly::IOBufQueue& writeBuf) {
     switch (setting.id) {
       case SettingsId::HEADER_TABLE_SIZE:
         if (pendingTableMaxSize_) {
-          LOG(ERROR) << "Can't have more than one settings in flight, skipping";
+          PRX_LOG(ERROR)
+              << "Can't have more than one settings in flight, skipping";
           continue;
         } else {
           pendingTableMaxSize_ = setting.value;
@@ -1448,7 +1457,7 @@ size_t HTTP2Codec::generateSettings(folly::IOBufQueue& writeBuf) {
           // HTTP2Codec uses it to determine if push features are enabled
           continue;
         } else {
-          CHECK(setting.value == 0 || setting.value == 1);
+          PRX_CHECK(setting.value == 0 || setting.value == 1);
         }
         break;
       case SettingsId::MAX_CONCURRENT_STREAMS:
@@ -1472,16 +1481,16 @@ size_t HTTP2Codec::generateSettings(folly::IOBufQueue& writeBuf) {
       case SettingsId::WT_INITIAL_MAX_DATA:
         // These are not handled, fall through to default
       default:
-        LOG(ERROR) << "ignore unknown settingsId="
-                   << std::underlying_type<SettingsId>::type(setting.id)
-                   << " value=" << setting.value;
+        PRX_LOG(ERROR) << "ignore unknown settingsId="
+                       << std::underlying_type<SettingsId>::type(setting.id)
+                       << " value=" << setting.value;
         continue;
     }
 
     settings.emplace_back(setting.id, setting.value);
   }
-  VLOG(4) << getTransportDirectionString(getTransportDirection())
-          << " generating " << (unsigned)settings.size() << " settings";
+  PRX_VLOG(4) << getTransportDirectionString(getTransportDirection())
+              << " generating " << (unsigned)settings.size() << " settings";
   return generateHeaderCallbackWrapper(
       0, http2::FrameType::SETTINGS, http2::writeSettings(writeBuf, settings));
 }
@@ -1492,8 +1501,8 @@ size_t HTTP2Codec::generateDefaultSettings(folly::IOBufQueue& writeBuf) {
 }
 
 size_t HTTP2Codec::generateSettingsAck(folly::IOBufQueue& writeBuf) {
-  VLOG(4) << getTransportDirectionString(getTransportDirection())
-          << " generating settings ack";
+  PRX_VLOG(4) << getTransportDirectionString(getTransportDirection())
+              << " generating settings ack";
   return generateHeaderCallbackWrapper(
       0, http2::FrameType::SETTINGS, http2::writeSettingsAck(writeBuf));
 }
@@ -1501,11 +1510,11 @@ size_t HTTP2Codec::generateSettingsAck(folly::IOBufQueue& writeBuf) {
 size_t HTTP2Codec::generateWindowUpdate(folly::IOBufQueue& writeBuf,
                                         StreamID stream,
                                         uint32_t delta) {
-  VLOG(4) << "generating window update for stream=" << stream << ": Processed "
-          << delta << " bytes";
+  PRX_VLOG(4) << "generating window update for stream=" << stream
+              << ": Processed " << delta << " bytes";
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "suppressed WINDOW_UPDATE for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "suppressed WINDOW_UPDATE for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   return generateHeaderCallbackWrapper(
@@ -1517,10 +1526,10 @@ size_t HTTP2Codec::generateWindowUpdate(folly::IOBufQueue& writeBuf,
 size_t HTTP2Codec::generatePriority(folly::IOBufQueue& writeBuf,
                                     StreamID stream,
                                     HTTPPriority pri) {
-  VLOG(4) << "generating priority for stream=" << stream;
+  PRX_VLOG(4) << "generating priority for stream=" << stream;
   if (!isStreamIngressEgressAllowed(stream)) {
-    VLOG(2) << "suppressed PRIORITY for stream=" << stream
-            << " ingressGoawayAck_=" << ingressGoawayAck_;
+    PRX_VLOG(2) << "suppressed PRIORITY for stream=" << stream
+                << " ingressGoawayAck_=" << ingressGoawayAck_;
     return 0;
   }
   auto httpPri = httpPriorityToString(pri);
@@ -1534,9 +1543,9 @@ bool HTTP2Codec::checkConnectionError(ErrorCode err, const folly::IOBuf* buf) {
   if (err != ErrorCode::NO_ERROR) {
     std::string errorDescription =
         goawayErrorMessage_.empty() ? "Connection error" : goawayErrorMessage_;
-    LOG(ERROR) << "Connection error " << getErrorCodeString(err) << " "
-               << errorDescription << " with ingress=";
-    VLOG(3) << IOBufPrinter::printHexFolly(buf, true);
+    PRX_LOG(ERROR) << "Connection error " << getErrorCodeString(err) << " "
+                   << errorDescription << " with ingress=";
+    PRX_VLOG(3) << IOBufPrinter::printHexFolly(buf, true);
     if (callback_) {
       HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                        errorDescription);
diff --git a/proxygen/lib/http/codec/HTTP2Framer.cpp b/proxygen/lib/http/codec/HTTP2Framer.cpp
index d0ddc6dca8..14c480e452 100644
--- a/proxygen/lib/http/codec/HTTP2Framer.cpp
+++ b/proxygen/lib/http/codec/HTTP2Framer.cpp
@@ -11,6 +11,7 @@
 #include <array>
 #include <folly/tracing/ScopedTraceSection.h>
 #include <proxygen/lib/http/codec/CodecUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly::io;
 using namespace folly;
@@ -54,22 +55,22 @@ size_t computeLengthAndType(uint32_t length,
                             folly::Optional<uint8_t> padding,
                             size_t& headerSize) {
   // the acceptable length is now conditional based on state :(
-  DCHECK_EQ(0, ~kLengthMask & length);
-  DCHECK_EQ(0, ~kUint31Mask & stream);
+  PRX_DCHECK_EQ(0u, ~kLengthMask & length);
+  PRX_DCHECK_EQ(0u, ~kUint31Mask & stream);
 
   // Add or remove padding flags
   if (padding) {
     flags |= PADDED;
-    DCHECK(FrameType::HEADERS == type || FrameType::DATA == type ||
-           FrameType::PUSH_PROMISE == type);
+    PRX_DCHECK(FrameType::HEADERS == type || FrameType::DATA == type ||
+               FrameType::PUSH_PROMISE == type);
     length += *padding + 1;
     headerSize += 1;
   } else {
     flags &= ~PADDED;
   }
 
-  DCHECK_EQ(0, ~kLengthMask & length);
-  DCHECK_EQ(true, isValidFrameType(type));
+  PRX_DCHECK_EQ(0u, ~kLengthMask & length);
+  PRX_DCHECK_EQ(true, isValidFrameType(type));
   return ((kLengthMask & length) << 8) | static_cast<uint8_t>(type);
 }
 
@@ -128,7 +129,7 @@ size_t writeFrameHeader(uint8_t* buf,
   uint32_t lengthAndType =
       computeLengthAndType(length, type, flags, stream, padding, headerSize);
 
-  CHECK_GE(bufLen, headerSize);
+  PRX_CHECK_GE(bufLen, headerSize);
   lengthAndType = htonl(lengthAndType);
   memcpy(buf, &lengthAndType, sizeof(lengthAndType));
   buf += sizeof(lengthAndType);
@@ -141,7 +142,7 @@ size_t writeFrameHeader(uint8_t* buf,
   bufLen -= kFrameHeaderSize;
 
   if (padding) {
-    CHECK_GE(bufLen, 1);
+    PRX_CHECK_GE(bufLen, 1u);
     *buf = *padding;
     buf++;
     bufLen--;
@@ -183,8 +184,9 @@ ErrorCode parsePadding(Cursor& cursor,
                        const FrameHeader& header,
                        uint8_t& padding,
                        uint32_t& lefttoparse) noexcept {
-  DCHECK(header.type == FrameType::DATA || header.type == FrameType::HEADERS ||
-         header.type == FrameType::PUSH_PROMISE);
+  PRX_DCHECK(header.type == FrameType::DATA ||
+             header.type == FrameType::HEADERS ||
+             header.type == FrameType::PUSH_PROMISE);
   lefttoparse = header.length;
   if (frameHasPadding(header)) {
     if (lefttoparse < 1) {
@@ -268,7 +270,7 @@ bool frameHasPadding(const FrameHeader& header) {
 
 ErrorCode parseFrameHeader(Cursor& cursor, FrameHeader& header) noexcept {
   FOLLY_SCOPED_TRACE_SECTION("HTTP2Framer - parseFrameHeader");
-  DCHECK_LE(kFrameHeaderSize, cursor.totalLength());
+  PRX_DCHECK_LE(kFrameHeaderSize, cursor.totalLength());
 
   // MUST ignore the 2 bits before the length
   auto lengthAndType = cursor.readBE<uint32_t>();
@@ -284,7 +286,7 @@ ErrorCode parseData(Cursor& cursor,
                     const FrameHeader& header,
                     std::unique_ptr<IOBuf>& outBuf,
                     uint16_t& outPadding) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -325,7 +327,7 @@ ErrorCode parseDataEnd(Cursor& cursor,
 ErrorCode parseHeaders(Cursor& cursor,
                        const FrameHeader& header,
                        std::unique_ptr<IOBuf>& outBuf) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -348,7 +350,7 @@ ErrorCode parseRFC9218Priority(Cursor& cursor,
                                const FrameHeader& header,
                                uint32_t& priStream,
                                std::string& outPriority) {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -365,7 +367,7 @@ ErrorCode parseRFC9218Priority(Cursor& cursor,
 ErrorCode parseRstStream(Cursor& cursor,
                          const FrameHeader& header,
                          ErrorCode& outCode) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length != kFrameRstStreamSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -378,7 +380,7 @@ ErrorCode parseRstStream(Cursor& cursor,
 ErrorCode parseSettings(Cursor& cursor,
                         const FrameHeader& header,
                         std::deque<SettingPair>& settings) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream != 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -404,7 +406,7 @@ ErrorCode parsePushPromise(Cursor& cursor,
                            const FrameHeader& header,
                            uint32_t& outPromisedStream,
                            std::unique_ptr<IOBuf>& outBuf) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -432,7 +434,7 @@ ErrorCode parsePushPromise(Cursor& cursor,
 ErrorCode parsePing(Cursor& cursor,
                     const FrameHeader& header,
                     uint64_t& outOpaqueData) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
 
   if (header.length != kFramePingSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
@@ -450,7 +452,7 @@ ErrorCode parseGoaway(Cursor& cursor,
                       uint32_t& outLastStreamID,
                       ErrorCode& outCode,
                       std::unique_ptr<IOBuf>& outDebugData) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameGoawaySize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -471,7 +473,7 @@ ErrorCode parseGoaway(Cursor& cursor,
 ErrorCode parseWindowUpdate(Cursor& cursor,
                             const FrameHeader& header,
                             uint32_t& outAmount) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length != kFrameWindowUpdateSize) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -482,8 +484,8 @@ ErrorCode parseWindowUpdate(Cursor& cursor,
 ErrorCode parseContinuation(Cursor& cursor,
                             const FrameHeader& header,
                             std::unique_ptr<IOBuf>& outBuf) noexcept {
-  DCHECK(header.type == FrameType::CONTINUATION);
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK(header.type == FrameType::CONTINUATION);
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.stream == 0) {
     return ErrorCode::PROTOCOL_ERROR;
   }
@@ -498,7 +500,7 @@ ErrorCode parseAltSvc(Cursor& cursor,
                       std::string& outProtocol,
                       std::string& outHost,
                       std::string& outOrigin) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameAltSvcSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -528,7 +530,7 @@ ErrorCode parseCertificateRequest(
     const FrameHeader& header,
     uint16_t& outRequestId,
     std::unique_ptr<folly::IOBuf>& outAuthRequest) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameCertificateRequestSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -549,7 +551,7 @@ ErrorCode parseCertificate(
     const FrameHeader& header,
     uint16_t& outCertId,
     std::unique_ptr<folly::IOBuf>& outAuthenticator) noexcept {
-  DCHECK_LE(header.length, cursor.totalLength());
+  PRX_DCHECK_LE(header.length, cursor.totalLength());
   if (header.length < kFrameCertificateSizeBase) {
     return ErrorCode::FRAME_SIZE_ERROR;
   }
@@ -573,7 +575,7 @@ size_t writeData(IOBufQueue& queue,
                  folly::Optional<uint8_t> padding,
                  bool endStream,
                  bool reuseIOBufHeadroom) noexcept {
-  DCHECK_NE(0, stream);
+  PRX_DCHECK_NE(0u, stream);
   uint8_t flags = 0;
   if (endStream) {
     flags |= END_STREAM;
@@ -635,7 +637,7 @@ size_t writeHeaders(uint8_t* header,
                     folly::Optional<uint8_t> padding,
                     bool endStream,
                     bool endHeaders) noexcept {
-  DCHECK_NE(0, stream);
+  PRX_DCHECK_NE(0u, stream);
   uint32_t flags = 0;
   if (endStream) {
     flags |= END_STREAM;
@@ -658,7 +660,7 @@ size_t writeHeaders(uint8_t* header,
 size_t writeRFC9218Priority(IOBufQueue& queue,
                             uint32_t stream,
                             std::string& priority) {
-  CHECK_NE(0, stream);
+  PRX_CHECK_NE(0u, stream);
   QueueAppender appender(&queue, sizeof(stream) + priority.size());
   appender.writeBE<uint32_t>(stream);
   appender.pushAtMost((const uint8_t*)(priority.data()), priority.size());
@@ -677,7 +679,7 @@ size_t writeRFC9218Priority(IOBufQueue& queue,
 size_t writeRstStream(IOBufQueue& queue,
                       uint32_t stream,
                       ErrorCode errorCode) noexcept {
-  DCHECK_NE(0, stream);
+  PRX_DCHECK_NE(0u, stream);
   const auto frameLen = writeFrameHeader(queue,
                                          kFrameRstStreamSize,
                                          FrameType::RST_STREAM,
@@ -697,8 +699,8 @@ size_t writeSettings(IOBufQueue& queue,
       queue, settingsSize, FrameType::SETTINGS, 0, 0, kNoPadding, nullptr);
   QueueAppender appender(&queue, settingsSize);
   for (const auto& setting : settings) {
-    DCHECK_LE(static_cast<uint32_t>(setting.first),
-              std::numeric_limits<uint16_t>::max());
+    PRX_DCHECK_LE(static_cast<uint32_t>(setting.first),
+                  std::numeric_limits<uint16_t>::max());
     appender.writeBE<uint16_t>(static_cast<uint16_t>(setting.first));
     appender.writeBE<uint32_t>(setting.second);
   }
@@ -718,11 +720,11 @@ size_t writePushPromise(uint8_t* header,
                         size_t headersLen,
                         folly::Optional<uint8_t> padding,
                         bool endHeaders) noexcept {
-  DCHECK_NE(0, promisedStream);
-  DCHECK_NE(0, associatedStream);
-  DCHECK_EQ(0, 0x1 & promisedStream);
-  DCHECK_EQ(1, 0x1 & associatedStream);
-  DCHECK_EQ(0, ~kUint31Mask & promisedStream);
+  PRX_DCHECK_NE(0u, promisedStream);
+  PRX_DCHECK_NE(0u, associatedStream);
+  PRX_DCHECK_EQ(0u, 0x1 & promisedStream);
+  PRX_DCHECK_EQ(1u, 0x1 & associatedStream);
+  PRX_DCHECK_EQ(0u, ~kUint31Mask & promisedStream);
 
   const auto frameLen = writeFrameHeader(header,
                                          headerLen,
@@ -758,7 +760,7 @@ size_t writeGoaway(IOBufQueue& queue,
                    ErrorCode errorCode,
                    std::unique_ptr<IOBuf> debugData) noexcept {
   uint32_t debugLen = debugData ? debugData->computeChainDataLength() : 0;
-  DCHECK_EQ(0, ~kLengthMask & debugLen);
+  PRX_DCHECK_EQ(0u, ~kLengthMask & debugLen);
   const auto frameLen = writeFrameHeader(queue,
                                          kFrameGoawaySize + debugLen,
                                          FrameType::GOAWAY,
@@ -783,8 +785,8 @@ size_t writeWindowUpdate(IOBufQueue& queue,
                                          stream,
                                          kNoPadding,
                                          nullptr);
-  DCHECK_EQ(0, ~kUint31Mask & amount);
-  DCHECK_LT(0, amount);
+  PRX_DCHECK_EQ(0u, ~kUint31Mask & amount);
+  PRX_DCHECK_LT(0u, amount);
   QueueAppender appender(&queue, kFrameWindowUpdateSize);
   appender.writeBE<uint32_t>(amount);
   return kFrameHeaderSize + frameLen;
@@ -794,7 +796,7 @@ size_t writeContinuation(IOBufQueue& queue,
                          uint32_t stream,
                          bool endHeaders,
                          std::unique_ptr<IOBuf> headers) noexcept {
-  DCHECK_NE(0, stream);
+  PRX_DCHECK_NE(0u, stream);
   const auto dataLen = headers->computeChainDataLength();
   const auto frameLen = writeFrameHeader(queue,
                                          dataLen,
@@ -912,6 +914,6 @@ const char* getFrameTypeString(FrameType type) {
       // can happen when type was cast from uint8_t
       return "Unknown";
   }
-  LOG(FATAL) << "Unreachable";
+  PRX_LOG(FATAL) << "Unreachable";
 }
 } // namespace proxygen::http2
diff --git a/proxygen/lib/http/codec/HTTPBinaryCodec.cpp b/proxygen/lib/http/codec/HTTPBinaryCodec.cpp
index 5b1b24496d..b5a47af749 100644
--- a/proxygen/lib/http/codec/HTTPBinaryCodec.cpp
+++ b/proxygen/lib/http/codec/HTTPBinaryCodec.cpp
@@ -8,6 +8,7 @@
 
 #include <proxygen/lib/http/codec/HTTPBinaryCodec.h>
 
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -178,7 +179,7 @@ ParseResult HTTPBinaryCodec::parseRequestControlData(folly::io::Cursor& cursor,
   }
   parsed += pathRes.bytesParsed_;
   remaining -= pathRes.bytesParsed_;
-  CHECK(remaining >= 0);
+  PRX_CHECK(remaining >= 0);
 
   return ParseResult(parsed);
 }
@@ -483,7 +484,7 @@ size_t HTTPBinaryCodec::onIngress(const folly::IOBuf& buf) {
         break;
 
       case ParseState::HEADERS_SECTION:
-        CHECK(decodeInfo_.msg);
+        PRX_CHECK(decodeInfo_.msg);
         parseResult = parseHeaders(
             cursor, bufLen - parsedTot, decodeInfo_, knownIngressLength_);
         HANDLE_ERROR_OR_WAITING_PARSE_RESULT(parseResult);
@@ -534,7 +535,7 @@ size_t HTTPBinaryCodec::onIngress(const folly::IOBuf& buf) {
         break;
 
       default:
-        CHECK(false);
+        PRX_CHECK(false);
     }
     parsedTot += parsed;
   }
diff --git a/proxygen/lib/http/codec/HTTPChecks.cpp b/proxygen/lib/http/codec/HTTPChecks.cpp
index 2bdfab8b18..7b8a5b38bd 100644
--- a/proxygen/lib/http/codec/HTTPChecks.cpp
+++ b/proxygen/lib/http/codec/HTTPChecks.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/codec/HTTPChecks.h>
 
 #include <proxygen/lib/http/RFC2616.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -40,8 +41,8 @@ void HTTPChecks::generateHeader(
     HTTPHeaderSize* sizeOut,
     const folly::Optional<HTTPHeaders>& extraHeaders) {
   if (msg.isRequest() && RFC2616::bodyImplied(msg.getHeaders())) {
-    CHECK(RFC2616::isRequestBodyAllowed(msg.getMethod()) !=
-          RFC2616::BodyAllowed::NOT_ALLOWED);
+    PRX_CHECK(RFC2616::isRequestBodyAllowed(msg.getMethod()) !=
+              RFC2616::BodyAllowed::NOT_ALLOWED);
     // We could also add a "strict" mode that disallows sending body on GET
     // requests here too.
   }
diff --git a/proxygen/lib/http/codec/HTTPCodec.h b/proxygen/lib/http/codec/HTTPCodec.h
index 87be14ddf5..ffbf5f1f59 100644
--- a/proxygen/lib/http/codec/HTTPCodec.h
+++ b/proxygen/lib/http/codec/HTTPCodec.h
@@ -19,6 +19,7 @@
 #include <proxygen/lib/http/codec/TransportDirection.h>
 #include <proxygen/lib/http/codec/compress/HPACKCodec.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -304,7 +305,7 @@ class HTTPCodec {
                                 HTTPCodec::StreamID id) {
     switch (protocol) {
       case CodecProtocol::HTTP_1_1:
-        DCHECK_NE(id, 0);
+        PRX_DCHECK_NE(id, 0u);
         return id - 1;
       case CodecProtocol::HTTP_2:
         return id / 2;
@@ -317,7 +318,7 @@ class HTTPCodec {
       case CodecProtocol::TUNNEL_LITE:
         [[fallthrough]];
       default:
-        LOG(FATAL) << "Unreachable";
+        PRX_LOG(FATAL) << "Unreachable";
     }
   }
 
diff --git a/proxygen/lib/http/codec/HTTPCodecFactory.cpp b/proxygen/lib/http/codec/HTTPCodecFactory.cpp
index c7dede6192..9a72fd2944 100644
--- a/proxygen/lib/http/codec/HTTPCodecFactory.cpp
+++ b/proxygen/lib/http/codec/HTTPCodecFactory.cpp
@@ -10,6 +10,7 @@
 
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
 #include <proxygen/lib/http/codec/HTTP2Codec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -32,7 +33,7 @@ std::unique_ptr<HTTPCodec> HTTPCodecFactory::getCodec(
     case CodecProtocol::HTTP_BINARY:
     case CodecProtocol::TUNNEL_LITE:
     default:
-      LOG(FATAL) << "Unreachable";
+      PRX_LOG(FATAL) << "Unreachable";
   }
 }
 
diff --git a/proxygen/lib/http/codec/HTTPParallelCodec.cpp b/proxygen/lib/http/codec/HTTPParallelCodec.cpp
index 45e5473173..4201076d3d 100644
--- a/proxygen/lib/http/codec/HTTPParallelCodec.cpp
+++ b/proxygen/lib/http/codec/HTTPParallelCodec.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/codec/HTTPParallelCodec.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -22,7 +22,7 @@ HTTPParallelCodec::HTTPParallelCodec(TransportDirection direction)
       nextEgressStreamID_ = 1;
       break;
     default:
-      LOG(FATAL) << "Unknown transport direction.";
+      PRX_LOG(FATAL) << "Unknown transport direction.";
   }
 }
 
@@ -50,8 +50,8 @@ void HTTPParallelCodec::enableDoubleGoawayDrain() {
   if (sessionClosing_ == ClosingState::OPEN) {
     sessionClosing_ = ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED;
   } else {
-    VLOG(3) << "Cannot enable double goaway because the session is already "
-               "draining or closed";
+    PRX_VLOG(3) << "Cannot enable double goaway because the session is already "
+                   "draining or closed";
   }
 }
 
@@ -59,8 +59,8 @@ void HTTPParallelCodec::disableDoubleGoawayDrain() {
   if (sessionClosing_ == ClosingState::OPEN_WITH_GRACEFUL_DRAIN_ENABLED) {
     sessionClosing_ = ClosingState::OPEN;
   } else {
-    VLOG(3) << "Cannot enable double goaway because the session is already "
-               "draining or closed, or never enabled GRACEFUL_DRAIN";
+    PRX_VLOG(3) << "Cannot enable double goaway because the session is already "
+                   "draining or closed, or never enabled GRACEFUL_DRAIN";
   }
 }
 
diff --git a/proxygen/lib/http/codec/HTTPParallelCodec.h b/proxygen/lib/http/codec/HTTPParallelCodec.h
index aab31b1903..8453244144 100644
--- a/proxygen/lib/http/codec/HTTPParallelCodec.h
+++ b/proxygen/lib/http/codec/HTTPParallelCodec.h
@@ -15,6 +15,7 @@
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 #include <proxygen/lib/http/codec/HTTPSettings.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace folly::io {
 class Cursor;
@@ -119,8 +120,8 @@ class HTTPParallelCodec : public HTTPCodec {
       }
       return true;
     } else {
-      VLOG(3) << "Suppressing " << cbName << " for stream=" << stream
-              << " egressGoawayAck_=" << egressGoawayAck_;
+      PRX_VLOG(3) << "Suppressing " << cbName << " for stream=" << stream
+                  << " egressGoawayAck_=" << egressGoawayAck_;
     }
     return false;
   }
diff --git a/proxygen/lib/http/codec/HeaderDecodeInfo.cpp b/proxygen/lib/http/codec/HeaderDecodeInfo.cpp
index 5a538cbdcd..70aacbaa49 100644
--- a/proxygen/lib/http/codec/HeaderDecodeInfo.cpp
+++ b/proxygen/lib/http/codec/HeaderDecodeInfo.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/Conv.h>
 #include <proxygen/lib/http/codec/CodecUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::string;
 
@@ -19,11 +20,11 @@ bool HeaderDecodeInfo::onHeader(const HPACKHeaderName& name,
                                 const folly::fbstring& value) {
   // Refuse decoding other headers if an error is already found
   if (decodeError != HPACK::DecodeError::NONE || !parsingError.empty()) {
-    VLOG(4) << "Ignoring header=" << name << " value=" << value
-            << " due to parser error=" << parsingError;
+    PRX_VLOG(4) << "Ignoring header=" << name << " value=" << value
+                << " due to parser error=" << parsingError;
     return true;
   }
-  DVLOG(5) << "Processing header=" << name << " value=" << value;
+  PRX_DVLOG(5) << "Processing header=" << name << " value=" << value;
   auto headerCode = name.getHeaderCode();
   folly::StringPiece nameSp(name.get());
   folly::StringPiece valueSp(value);
diff --git a/proxygen/lib/http/codec/HeaderDecodeInfo.h b/proxygen/lib/http/codec/HeaderDecodeInfo.h
index d0f5315fdc..a98231c04a 100644
--- a/proxygen/lib/http/codec/HeaderDecodeInfo.h
+++ b/proxygen/lib/http/codec/HeaderDecodeInfo.h
@@ -14,6 +14,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKHeaderName.h>
 
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -26,7 +27,7 @@ class HeaderDecodeInfo {
             bool validate,
             bool strictValidation,
             bool allowEmptyPath) {
-    CHECK(!msg);
+    PRX_CHECK(!msg);
     msg = std::make_unique<HTTPMessage>();
     isRequest_ = isRequestIn;
     isRequestTrailers_ = isRequestTrailers;
diff --git a/proxygen/lib/http/codec/QPACKDecoderCodec.h b/proxygen/lib/http/codec/QPACKDecoderCodec.h
index d9575dbc86..b13e181d5b 100644
--- a/proxygen/lib/http/codec/QPACKDecoderCodec.h
+++ b/proxygen/lib/http/codec/QPACKDecoderCodec.h
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/HQUnidirectionalCodec.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -29,7 +30,7 @@ class QPACKDecoderCodec : public HQUnidirectionalCodec {
       std::unique_ptr<folly::IOBuf> buf) override {
     auto err = qpackCodec_.decodeDecoderStream(std::move(buf));
     if (err != HPACK::DecodeError::NONE) {
-      LOG(ERROR) << "QPACK decoder stream decode error err=" << err;
+      PRX_LOG(ERROR) << "QPACK decoder stream decode error err=" << err;
       HTTPException ex(
           HTTPException::Direction::INGRESS_AND_EGRESS,
           folly::to<std::string>("Compression error on decoder stream err=",
@@ -41,7 +42,7 @@ class QPACKDecoderCodec : public HQUnidirectionalCodec {
   }
 
   void onUnidirectionalIngressEOF() override {
-    LOG(ERROR) << "Unexpected QPACK encoder stream EOF";
+    PRX_LOG(ERROR) << "Unexpected QPACK encoder stream EOF";
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                      "Encoder stream EOF");
     ex.setHttp3ErrorCode(HTTP3::ErrorCode::HTTP_CLOSED_CRITICAL_STREAM);
diff --git a/proxygen/lib/http/codec/QPACKEncoderCodec.h b/proxygen/lib/http/codec/QPACKEncoderCodec.h
index 6ab58fe33a..9e89e0bcab 100644
--- a/proxygen/lib/http/codec/QPACKEncoderCodec.h
+++ b/proxygen/lib/http/codec/QPACKEncoderCodec.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/HQUnidirectionalCodec.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::hq {
 
@@ -30,7 +31,7 @@ class QPACKEncoderCodec : public HQUnidirectionalCodec {
       std::unique_ptr<folly::IOBuf> buf) override {
     auto err = qpackCodec_.decodeEncoderStream(std::move(buf));
     if (err != HPACK::DecodeError::NONE) {
-      LOG(ERROR) << "QPACK encoder stream decode error err=" << err;
+      PRX_LOG(ERROR) << "QPACK encoder stream decode error err=" << err;
       HTTPException ex(
           HTTPException::Direction::INGRESS_AND_EGRESS,
           folly::to<std::string>("Compression error on encoder stream err=",
@@ -41,7 +42,7 @@ class QPACKEncoderCodec : public HQUnidirectionalCodec {
     return nullptr;
   }
   void onUnidirectionalIngressEOF() override {
-    LOG(ERROR) << "Unexpected QPACK encoder stream EOF";
+    PRX_LOG(ERROR) << "Unexpected QPACK encoder stream EOF";
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                      "Encoder stream EOF");
     ex.setHttp3ErrorCode(HTTP3::ErrorCode::HTTP_CLOSED_CRITICAL_STREAM);
diff --git a/proxygen/lib/http/codec/RateLimitFilter.cpp b/proxygen/lib/http/codec/RateLimitFilter.cpp
index a8b41d91c8..3bd86a5ace 100644
--- a/proxygen/lib/http/codec/RateLimitFilter.cpp
+++ b/proxygen/lib/http/codec/RateLimitFilter.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/HeadersRateLimitFilter.h>
 #include <proxygen/lib/http/codec/RateLimitFilter.h>
 #include <proxygen/lib/http/codec/ResetsRateLimitFilter.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -50,7 +51,7 @@ bool RateLimiter::incrementNumEventsInCurrentInterval() {
   if (numEventsInCurrentInterval_ == 0) {
     // The first control message (or first after a reset) schedules the next
     // reset timer
-    CHECK(timer_);
+    PRX_CHECK(timer_);
     timer_->scheduleTimeout(this, timeoutDuration_);
   }
 
diff --git a/proxygen/lib/http/codec/RateLimitFilter.h b/proxygen/lib/http/codec/RateLimitFilter.h
index 11c98acd3b..021e0a2182 100644
--- a/proxygen/lib/http/codec/RateLimitFilter.h
+++ b/proxygen/lib/http/codec/RateLimitFilter.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/HTTP2Framer.h>
 #include <proxygen/lib/http/codec/HTTPCodecFilter.h>
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -89,14 +90,14 @@ class RateLimitFilter : public PassThroughHTTPCodecFilter {
   }
 
   void addRateLimiter(RateLimiter::Type type) {
-    CHECK_LT(folly::to_underlying(type),
-             folly::to_underlying(RateLimiter::Type::MAX))
+    PRX_CHECK_LT(folly::to_underlying(type),
+                 folly::to_underlying(RateLimiter::Type::MAX))
         << "Received a rate limit type that exceeded the specified maximum";
     auto index = folly::to_underlying(type);
     if (!rateLimiters_[index]) {
       rateLimiters_[index] =
           RateLimiter::createRateLimiter(type, timer_, httpSessionStats_);
-      CHECK(rateLimiters_[index])
+      PRX_CHECK(rateLimiters_[index])
           << "Unable to construct a rate limit filter of type "
           << RateLimiter::toStr(type);
     }
@@ -106,16 +107,16 @@ class RateLimitFilter : public PassThroughHTTPCodecFilter {
                           uint32_t maxEventsPerInterval,
                           std::chrono::milliseconds intervalDuration) {
     uint32_t typeIndex = folly::to_underlying(type);
-    CHECK_LT(typeIndex, folly::to_underlying(RateLimiter::Type::MAX))
+    PRX_CHECK_LT(typeIndex, folly::to_underlying(RateLimiter::Type::MAX))
         << "Out of bounds access to rate limit filter array";
     auto& rateLimiter = rateLimiters_.at(typeIndex);
     if (rateLimiter) {
       uint32_t maxEventsPerIntervalLowerBound =
           rateLimiter->getMaxEventsPerInvervalLowerBound();
       if (maxEventsPerInterval < maxEventsPerIntervalLowerBound) {
-        LOG(WARNING) << "Invalid maxEventsPerInterval for event "
-                     << RateLimiter::toStr(type) << ": "
-                     << maxEventsPerInterval;
+        PRX_LOG(WARNING) << "Invalid maxEventsPerInterval for event "
+                         << RateLimiter::toStr(type) << ": "
+                         << maxEventsPerInterval;
         maxEventsPerInterval = maxEventsPerIntervalLowerBound;
       }
       rateLimiter->setParams(maxEventsPerInterval, intervalDuration);
diff --git a/proxygen/lib/http/codec/compress/CMakeLists.txt b/proxygen/lib/http/codec/compress/CMakeLists.txt
index a7f4a9319d..3d859a5552 100644
--- a/proxygen/lib/http/codec/compress/CMakeLists.txt
+++ b/proxygen/lib/http/codec/compress/CMakeLists.txt
@@ -9,8 +9,8 @@
 proxygen_add_library(proxygen_http_codec_compress_fast_header_name
   EXPORTED_DEPS
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_string
-    glog::glog
 )
 
 proxygen_add_library(proxygen_http_codec_compress_hpack
@@ -46,12 +46,12 @@ proxygen_add_library(proxygen_http_codec_compress_hpack
     proxygen_http_codec_compress_header_codec
     proxygen_http_codec_direction
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_container_f14_hash
     Folly::folly_conv
     Folly::folly_fbstring
     Folly::folly_io_iobuf
     Folly::folly_small_vector
-    glog::glog
 )
 
 proxygen_add_library(proxygen_http_codec_compress_qpack
@@ -72,9 +72,9 @@ proxygen_add_library(proxygen_http_codec_compress_qpack
     proxygen_http_codec_compress_hpack
     proxygen_http_codec_direction
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_io_async_destructor_check
     Folly::folly_io_iobuf
-    glog::glog
 )
 
 proxygen_add_library(proxygen_http_codec_compress_compression_info)
@@ -83,10 +83,10 @@ proxygen_add_library(proxygen_http_codec_compress_header_codec
   EXPORTED_DEPS
     proxygen_http_http_header_size
     proxygen_http_http_headers
+    proxygen_utils_log_shim
     Folly::folly_expected
     Folly::folly_fbstring
     Folly::folly_range
-    glog::glog
 )
 
 if(BUILD_TESTS)
diff --git a/proxygen/lib/http/codec/compress/HPACKCodec.cpp b/proxygen/lib/http/codec/compress/HPACKCodec.cpp
index 83956751ce..b3e401bde4 100644
--- a/proxygen/lib/http/codec/compress/HPACKCodec.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKCodec.cpp
@@ -14,6 +14,7 @@
 #include <proxygen/lib/http/HeaderConstants.h>
 #include <proxygen/lib/http/codec/CodecUtil.h>
 #include <proxygen/lib/http/codec/compress/HPACKHeader.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using folly::io::Cursor;
@@ -119,15 +120,15 @@ void HPACKCodec::encodeHTTP(
                                 const std::string& value) {
     if (CodecUtil::disallowedModernHTTPFields()[code] || name.empty() ||
         name[0] == ':') {
-      DCHECK(!name.empty()) << "Empty header";
-      DCHECK_NE(name[0], ':') << "Invalid header=" << name;
+      PRX_DCHECK(!name.empty()) << "Empty header";
+      PRX_DCHECK_NE(name[0], ':') << "Invalid header=" << name;
       return;
     }
     // Note this code will not drop headers named by Connection.  That's the
     // caller's job
 
     // see HTTP/2 spec, 8.1.2
-    DCHECK(name != "TE" || value == "trailers");
+    PRX_DCHECK(name != "TE" || value == "trailers");
     if ((!name.empty() && name[0] != ':') && code != HTTP_HEADER_HOST) {
       if (code == HTTP_HEADER_OTHER) {
         uncompressed += encoder_.encodeHeader(name, value);
diff --git a/proxygen/lib/http/codec/compress/HPACKContext.cpp b/proxygen/lib/http/codec/compress/HPACKContext.cpp
index 3e7ee208bf..f15b142401 100644
--- a/proxygen/lib/http/codec/compress/HPACKContext.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKContext.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/codec/compress/HPACKContext.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -108,7 +109,7 @@ const HPACKHeader& HPACKContext::getHeader(uint32_t index) {
 
 void HPACKContext::seedHeaderTable(std::vector<HPACKHeader>& headers) {
   for (auto& header : headers) {
-    CHECK(table_.add(std::move(header)));
+    PRX_CHECK(table_.add(std::move(header)));
   }
 }
 
diff --git a/proxygen/lib/http/codec/compress/HPACKDecodeBuffer.cpp b/proxygen/lib/http/codec/compress/HPACKDecodeBuffer.cpp
index 0b5ff36bcb..fbd07b4462 100644
--- a/proxygen/lib/http/codec/compress/HPACKDecodeBuffer.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKDecodeBuffer.cpp
@@ -11,6 +11,7 @@
 #include <limits>
 #include <memory>
 #include <proxygen/lib/http/codec/compress/Huffman.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using proxygen::HPACK::DecodeError;
@@ -20,9 +21,9 @@ namespace proxygen {
 
 void HPACKDecodeBuffer::EOB_LOG(std::string msg, DecodeError code) const {
   if (endOfBufferIsError_ || code != DecodeError::BUFFER_UNDERFLOW) {
-    LOG(ERROR) << msg;
+    PRX_LOG(ERROR) << msg;
   } else {
-    VLOG(4) << msg;
+    PRX_VLOG(4) << msg;
   }
 }
 
@@ -31,7 +32,7 @@ bool HPACKDecodeBuffer::empty() {
 }
 
 uint8_t HPACKDecodeBuffer::next() {
-  CHECK_GT(remainingBytes_, 0);
+  PRX_CHECK_GT(remainingBytes_, 0u);
   // in case we are the end of an IOBuf, peek() will move to the next one
   uint8_t byte = peek();
   cursor_.skip(1);
@@ -41,7 +42,7 @@ uint8_t HPACKDecodeBuffer::next() {
 }
 
 uint8_t HPACKDecodeBuffer::peek() {
-  CHECK_GT(remainingBytes_, 0);
+  PRX_CHECK_GT(remainingBytes_, 0u);
   if (cursor_.length() == 0) {
     cursor_.peek();
   }
@@ -75,7 +76,7 @@ DecodeError HPACKDecodeBuffer::decodeLiteral(uint8_t nbit,
     return DecodeError::BUFFER_UNDERFLOW;
   }
   if (size > maxLiteralSize_) {
-    LOG(ERROR) << "Literal too large, size=" << size;
+    PRX_LOG(ERROR) << "Literal too large, size=" << size;
     return DecodeError::LITERAL_TOO_LARGE;
   }
   const uint8_t* data;
@@ -129,13 +130,13 @@ DecodeError HPACKDecodeBuffer::decodeInteger(uint8_t nbit, uint64_t& integer) {
     byte = next();
     if (fexp > 64) {
       // overflow in factorizer, f > 2^64
-      LOG(ERROR) << "overflow fexp=" << fexp;
+      PRX_LOG(ERROR) << "overflow fexp=" << fexp;
       return DecodeError::INTEGER_OVERFLOW;
     }
     uint64_t add = (byte & 127) * f;
     if (std::numeric_limits<uint64_t>::max() - integer <= add) {
       // overflow detected - we disallow uint64_t max.
-      LOG(ERROR) << "overflow integer=" << integer << " add=" << add;
+      PRX_LOG(ERROR) << "overflow integer=" << integer << " add=" << add;
       return DecodeError::INTEGER_OVERFLOW;
     }
     integer += add;
diff --git a/proxygen/lib/http/codec/compress/HPACKDecoder.cpp b/proxygen/lib/http/codec/compress/HPACKDecoder.cpp
index 3a7d630379..c003df5090 100644
--- a/proxygen/lib/http/codec/compress/HPACKDecoder.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKDecoder.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKDecoder.h>
 
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::io::Cursor;
 
@@ -24,8 +25,8 @@ void HPACKDecoder::decodeStreaming(Cursor& cursor,
     emittedSize += decodeHeader(dbuf, streamingCb, nullptr);
 
     if (emittedSize > maxUncompressed_) {
-      LOG(ERROR) << "exceeded uncompressed size limit of " << maxUncompressed_
-                 << " bytes";
+      PRX_LOG(ERROR) << "exceeded uncompressed size limit of "
+                     << maxUncompressed_ << " bytes";
       err_ = HPACK::DecodeError::HEADERS_TOO_LARGE;
       break;
     }
@@ -58,12 +59,12 @@ uint32_t HPACKDecoder::decodeLiteralHeader(
     uint64_t index;
     err_ = dbuf.decodeInteger(length, index);
     if (err_ != HPACK::DecodeError::NONE) {
-      LOG(ERROR) << "Decode error decoding index err_=" << err_;
+      PRX_LOG(ERROR) << "Decode error decoding index err_=" << err_;
       return 0;
     }
     // validate the index
     if (!isValid(index)) {
-      LOG(ERROR) << "received invalid index: " << index;
+      PRX_LOG(ERROR) << "received invalid index: " << index;
       err_ = HPACK::DecodeError::INVALID_INDEX;
       return 0;
     }
@@ -75,15 +76,15 @@ uint32_t HPACKDecoder::decodeLiteralHeader(
     err_ = dbuf.decodeLiteral(headerName);
     header.name = HPACKHeaderName{headerName};
     if (err_ != HPACK::DecodeError::NONE) {
-      LOG(ERROR) << "Error decoding header name err_=" << err_;
+      PRX_LOG(ERROR) << "Error decoding header name err_=" << err_;
       return 0;
     }
   }
   // value
   err_ = dbuf.decodeLiteral(header.value);
   if (err_ != HPACK::DecodeError::NONE) {
-    LOG(ERROR) << "Error decoding header value name=" << header.name
-               << " err_=" << err_;
+    PRX_LOG(ERROR) << "Error decoding header value name=" << header.name
+                   << " err_=" << err_;
     return 0;
   }
 
@@ -95,7 +96,7 @@ uint32_t HPACKDecoder::decodeLiteralHeader(
       // The only way add can return false is clearing the table with a large
       // entry.  Any other failure would result in compression contexts out of
       // sync.
-      CHECK_GT(headerBytes, table_.capacity());
+      PRX_CHECK_GT(headerBytes, table_.capacity());
     }
   }
 
@@ -109,12 +110,12 @@ uint32_t HPACKDecoder::decodeIndexedHeader(
   uint64_t index;
   err_ = dbuf.decodeInteger(HPACK::INDEX_REF.prefixLength, index);
   if (err_ != HPACK::DecodeError::NONE) {
-    LOG(ERROR) << "Decode error decoding index err_=" << err_;
+    PRX_LOG(ERROR) << "Decode error decoding index err_=" << err_;
     return 0;
   }
   // validate the index
   if (index == 0 || !isValid(index)) {
-    LOG(ERROR) << "received invalid index: " << index;
+    PRX_LOG(ERROR) << "received invalid index: " << index;
     err_ = HPACK::DecodeError::INVALID_INDEX;
     return 0;
   }
diff --git a/proxygen/lib/http/codec/compress/HPACKDecoderBase.cpp b/proxygen/lib/http/codec/compress/HPACKDecoderBase.cpp
index 02725a17a5..2156d40849 100644
--- a/proxygen/lib/http/codec/compress/HPACKDecoderBase.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKDecoderBase.cpp
@@ -8,6 +8,7 @@
 
 #include <proxygen/lib/http/codec/compress/HPACKDecoderBase.h>
 #include <proxygen/lib/http/codec/compress/HeaderTable.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -58,7 +59,7 @@ void HPACKDecoderBase::setHeaderTableMaxSize(HeaderTable& table,
                                              uint32_t maxSize) {
   maxTableSize_ = maxSize;
   if (maxTableSize_ < table.capacity()) {
-    CHECK(table.setCapacity(maxTableSize_));
+    PRX_CHECK(table.setCapacity(maxTableSize_));
   }
 }
 
@@ -69,18 +70,18 @@ void HPACKDecoderBase::handleTableSizeUpdate(HPACKDecodeBuffer& dbuf,
   err_ = dbuf.decodeInteger(HPACK::TABLE_SIZE_UPDATE.prefixLength, arg);
   if (err_ != HPACK::DecodeError::NONE) {
     if (!isQpack || err_ != HPACK::DecodeError::BUFFER_UNDERFLOW) {
-      LOG(ERROR) << "Decode error decoding maxSize err_=" << err_;
+      PRX_LOG(ERROR) << "Decode error decoding maxSize err_=" << err_;
     }
     return;
   }
 
   if (arg > maxTableSize_) {
-    LOG(ERROR) << "Tried to increase size of the header table to " << arg
-               << " maxTableSize_=" << maxTableSize_;
+    PRX_LOG(ERROR) << "Tried to increase size of the header table to " << arg
+                   << " maxTableSize_=" << maxTableSize_;
     err_ = HPACK::DecodeError::INVALID_TABLE_SIZE;
     return;
   }
-  VLOG(5) << "Received table size update, new size=" << arg;
+  PRX_VLOG(5) << "Received table size update, new size=" << arg;
   table.setCapacity(arg);
 }
 
diff --git a/proxygen/lib/http/codec/compress/HPACKEncodeBuffer.cpp b/proxygen/lib/http/codec/compress/HPACKEncodeBuffer.cpp
index e4f6e87609..ebe915a9fa 100644
--- a/proxygen/lib/http/codec/compress/HPACKEncodeBuffer.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKEncodeBuffer.cpp
@@ -10,6 +10,7 @@
 
 #include <memory>
 #include <proxygen/lib/http/codec/compress/HPACKConstants.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Logging.h>
 
 using folly::IOBuf;
@@ -31,7 +32,7 @@ HPACKEncodeBuffer::HPACKEncodeBuffer(uint32_t growthSize)
 
 void HPACKEncodeBuffer::addHeadroom(uint32_t headroom) {
   // we expect that this function is called before any encoding happens
-  CHECK(bufQueuePtr_->front() == nullptr);
+  PRX_CHECK(bufQueuePtr_->front() == nullptr);
   // create a custom IOBuf and add it to the queue
   unique_ptr<IOBuf> buf = IOBuf::create(std::max(headroom, growthSize_));
   buf->advance(headroom);
@@ -54,11 +55,11 @@ uint32_t HPACKEncodeBuffer::encodeInteger(
 uint32_t HPACKEncodeBuffer::encodeInteger(uint64_t value,
                                           uint8_t instruction,
                                           uint8_t nbit) {
-  CHECK(nbit > 0 && nbit <= 8);
+  PRX_CHECK(nbit > 0 && nbit <= 8);
   uint32_t count = 0;
   uint8_t mask = HPACK::NBIT_MASKS[nbit];
   // The instruction should not extend into mask
-  DCHECK_EQ(instruction & mask, 0);
+  PRX_DCHECK_EQ(instruction & mask, 0);
 
   // write the first byte
   uint8_t byte = instruction;
@@ -106,9 +107,9 @@ uint32_t HPACKEncodeBuffer::encodeHuffman(uint8_t instruction,
   static const auto& huffmanTree = huffman::huffTree();
   uint32_t size = huffmanTree.getEncodeSize(literal);
   // add the length
-  DCHECK_LE(nbit, 7);
+  PRX_DCHECK_LE(nbit, 7);
   auto huffmanOn = uint8_t(1 << nbit);
-  DCHECK_EQ(instruction & huffmanOn, 0);
+  PRX_DCHECK_EQ(instruction & huffmanOn, 0);
   uint32_t count = encodeInteger(size, instruction | huffmanOn, nbit);
   // ensure we have enough bytes before performing the encoding
   count += huffmanTree.encode(literal, buf_);
diff --git a/proxygen/lib/http/codec/compress/HPACKEncoder.cpp b/proxygen/lib/http/codec/compress/HPACKEncoder.cpp
index dc0dda4ec5..aef83bb7a5 100644
--- a/proxygen/lib/http/codec/compress/HPACKEncoder.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKEncoder.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKEncoder.h>
 
 #include <folly/CPortability.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::vector;
 
@@ -47,7 +48,7 @@ void HPACKEncoder::completeEncode() {
 
 size_t HPACKEncoder::encodeHeader(HTTPHeaderCode code,
                                   const std::string& value) {
-  DCHECK_NE(code, HTTP_HEADER_OTHER);
+  PRX_DCHECK_NE(code, HTTP_HEADER_OTHER);
   HPACKHeaderName name(code);
   size_t uncompressed = name.size() + value.size() + 2;
   encodeHeader(name, value); // const, string piece
@@ -56,7 +57,7 @@ size_t HPACKEncoder::encodeHeader(HTTPHeaderCode code,
 
 size_t HPACKEncoder::encodeHeader(HTTPHeaderCode code,
                                   folly::fbstring&& value) {
-  DCHECK_NE(code, HTTP_HEADER_OTHER);
+  PRX_DCHECK_NE(code, HTTP_HEADER_OTHER);
   HPACKHeaderName name(code);
   size_t uncompressed = name.size() + value.size() + 2;
   encodeHeader(std::move(name), std::move(value));
@@ -98,7 +99,7 @@ FOLLY_ALWAYS_INLINE bool HPACKEncoder::encodeAsLiteral(
   encodeAsLiteralImpl(name, nameIndex, value, indexing);
   // indexed ones need to get added to the header table
   if (indexing) {
-    CHECK(table_.add(HPACKHeader(name, value)));
+    PRX_CHECK(table_.add(HPACKHeader(name, value)));
   }
   return true;
 }
@@ -110,7 +111,7 @@ FOLLY_ALWAYS_INLINE bool HPACKEncoder::encodeAsLiteral(HPACKHeaderName&& name,
   encodeAsLiteralImpl(name, nameIndex, value, indexing);
   // indexed ones need to get added to the header table
   if (indexing) {
-    CHECK(table_.add(HPACKHeader(std::move(name), std::move(value))));
+    PRX_CHECK(table_.add(HPACKHeader(std::move(name), std::move(value))));
   }
   return true;
 }
@@ -122,7 +123,7 @@ FOLLY_ALWAYS_INLINE bool HPACKEncoder::encodeAsLiteral(HPACKHeaderName&& name,
   encodeAsLiteralImpl(name, nameIndex, value, indexing);
   // indexed ones need to get added to the header table
   if (indexing) {
-    CHECK(table_.add(HPACKHeader(std::move(name), value)));
+    PRX_CHECK(table_.add(HPACKHeader(std::move(name), value)));
   }
   return true;
 }
@@ -134,7 +135,7 @@ FOLLY_ALWAYS_INLINE void HPACKEncoder::encodeLiteral(
     const HPACK::Instruction& instruction) {
   // name
   if (nameIndex) {
-    VLOG(10) << "encoding name index=" << nameIndex;
+    PRX_VLOG(10) << "encoding name index=" << nameIndex;
     streamBuffer_.encodeInteger(nameIndex, instruction);
   } else {
     streamBuffer_.encodeInteger(0, instruction);
@@ -145,7 +146,7 @@ FOLLY_ALWAYS_INLINE void HPACKEncoder::encodeLiteral(
 }
 
 FOLLY_ALWAYS_INLINE void HPACKEncoder::encodeAsIndex(uint32_t index) {
-  VLOG(10) << "encoding index=" << index;
+  PRX_VLOG(10) << "encoding index=" << index;
   streamBuffer_.encodeInteger(index, HPACK::INDEX_REF);
 }
 
diff --git a/proxygen/lib/http/codec/compress/HPACKEncoderBase.cpp b/proxygen/lib/http/codec/compress/HPACKEncoderBase.cpp
index dc6cefc0ed..be4ad6448c 100644
--- a/proxygen/lib/http/codec/compress/HPACKEncoderBase.cpp
+++ b/proxygen/lib/http/codec/compress/HPACKEncoderBase.cpp
@@ -7,16 +7,17 @@
  */
 
 #include <proxygen/lib/http/codec/compress/HPACKEncoderBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
 uint32_t HPACKEncoderBase::handlePendingContextUpdate(HPACKEncodeBuffer& buf,
                                                       uint32_t tableCapacity) {
-  CHECK_EQ(HPACK::TABLE_SIZE_UPDATE.code, HPACK::Q_TABLE_SIZE_UPDATE.code)
+  PRX_CHECK_EQ(HPACK::TABLE_SIZE_UPDATE.code, HPACK::Q_TABLE_SIZE_UPDATE.code)
       << "Code assumes these are equal";
   uint32_t encoded = 0;
   if (pendingContextUpdate_) {
-    VLOG(5) << "Encoding table size update size=" << tableCapacity;
+    PRX_VLOG(5) << "Encoding table size update size=" << tableCapacity;
     encoded = buf.encodeInteger(tableCapacity, HPACK::TABLE_SIZE_UPDATE);
     pendingContextUpdate_ = false;
   }
diff --git a/proxygen/lib/http/codec/compress/HPACKEncoderBase.h b/proxygen/lib/http/codec/compress/HPACKEncoderBase.h
index 52cd52b2d9..69bd63329a 100644
--- a/proxygen/lib/http/codec/compress/HPACKEncoderBase.h
+++ b/proxygen/lib/http/codec/compress/HPACKEncoderBase.h
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKContext.h>
 #include <proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h>
 #include <proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -35,7 +36,7 @@ class HPACKEncoderBase {
 
   void setHeaderTableSize(HeaderTable& table, uint32_t size) {
     if (size != table.capacity()) {
-      CHECK(table.setCapacity(size));
+      PRX_CHECK(table.setCapacity(size));
       pendingContextUpdate_ = true;
     }
   }
diff --git a/proxygen/lib/http/codec/compress/HPACKHeader.h b/proxygen/lib/http/codec/compress/HPACKHeader.h
index ed6d6651c2..52fd5a1ed5 100644
--- a/proxygen/lib/http/codec/compress/HPACKHeader.h
+++ b/proxygen/lib/http/codec/compress/HPACKHeader.h
@@ -10,9 +10,9 @@
 
 #include <folly/Conv.h>
 #include <folly/FBString.h>
-#include <glog/logging.h>
 #include <ostream>
 #include <proxygen/lib/http/codec/compress/HPACKHeaderName.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <string_view>
 
 namespace proxygen {
@@ -64,7 +64,7 @@ class HPACKHeader {
   }
 
   static uint32_t realBytes(uint64_t nameSize, uint64_t valueSize) {
-    DCHECK_LE(nameSize + valueSize, std::numeric_limits<uint32_t>::max());
+    PRX_DCHECK_LE(nameSize + valueSize, std::numeric_limits<uint32_t>::max());
     return folly::tryTo<uint32_t>(nameSize + valueSize)
         .value_or(std::numeric_limits<uint32_t>::max());
   }
@@ -77,8 +77,8 @@ class HPACKHeader {
   }
 
   static uint32_t bytes(uint64_t nameSize, uint64_t valueSize) {
-    DCHECK_LE(kMinLength + nameSize + valueSize,
-              std::numeric_limits<uint32_t>::max());
+    PRX_DCHECK_LE(kMinLength + nameSize + valueSize,
+                  std::numeric_limits<uint32_t>::max());
     return folly::tryTo<uint32_t>(kMinLength + realBytes(nameSize, valueSize))
         .value_or(std::numeric_limits<uint32_t>::max());
   }
diff --git a/proxygen/lib/http/codec/compress/HPACKHeaderName.h b/proxygen/lib/http/codec/compress/HPACKHeaderName.h
index 7e16df4c0e..5507160481 100644
--- a/proxygen/lib/http/codec/compress/HPACKHeaderName.h
+++ b/proxygen/lib/http/codec/compress/HPACKHeaderName.h
@@ -11,9 +11,9 @@
 #include <cstdint>
 #include <folly/String.h>
 #include <functional>
-#include <glog/logging.h>
 #include <iostream>
 #include <proxygen/lib/http/HTTPCommonHeaders.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <string>
 #include <string_view>
 
@@ -32,8 +32,8 @@ class HPACKHeaderName {
     storeAddress(name);
   }
   explicit HPACKHeaderName(HTTPHeaderCode headerCode) {
-    CHECK_NE(headerCode, HTTPHeaderCode::HTTP_HEADER_NONE);
-    CHECK_NE(headerCode, HTTPHeaderCode::HTTP_HEADER_OTHER);
+    PRX_CHECK_NE(headerCode, HTTPHeaderCode::HTTP_HEADER_NONE);
+    PRX_CHECK_NE(headerCode, HTTPHeaderCode::HTTP_HEADER_OTHER);
     address_ = HTTPCommonHeaders::getPointerToName(
         headerCode, HTTPCommonHeaderTableType::TABLE_LOWERCASE);
   }
diff --git a/proxygen/lib/http/codec/compress/HeaderPiece.h b/proxygen/lib/http/codec/compress/HeaderPiece.h
index f57007f241..8cd5997b5b 100644
--- a/proxygen/lib/http/codec/compress/HeaderPiece.h
+++ b/proxygen/lib/http/codec/compress/HeaderPiece.h
@@ -10,7 +10,7 @@
 
 #include <deque>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/Range.h>
 
@@ -38,7 +38,7 @@ class HeaderPiece {
 
   ~HeaderPiece() {
     if (owner) {
-      CHECK_NOTNULL(str.data());
+      PRX_CHECK_NOTNULL(str.data());
       delete[] str.data();
     }
   }
diff --git a/proxygen/lib/http/codec/compress/HeaderTable.cpp b/proxygen/lib/http/codec/compress/HeaderTable.cpp
index 7ec65bd4aa..20339af106 100644
--- a/proxygen/lib/http/codec/compress/HeaderTable.cpp
+++ b/proxygen/lib/http/codec/compress/HeaderTable.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/codec/compress/HeaderTable.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -77,7 +77,7 @@ std::pair<uint32_t, uint32_t> HeaderTable::getIndexImpl(
     const HPACKHeaderName& headerName,
     folly::StringPiece value,
     bool nameOnly) const {
-  CHECK(indexNames_);
+  PRX_CHECK(indexNames_);
   auto it = names_.find(headerName);
   if (it == names_.end()) {
     return {0, 0};
@@ -93,7 +93,7 @@ std::pair<uint32_t, uint32_t> HeaderTable::getIndexImpl(
 }
 
 bool HeaderTable::hasName(const HPACKHeaderName& headerName) {
-  CHECK(indexNames_);
+  PRX_CHECK(indexNames_);
   return names_.find(headerName) != names_.end();
 }
 
@@ -103,7 +103,7 @@ uint32_t HeaderTable::nameIndex(const HPACKHeaderName& headerName) const {
 }
 
 const HPACKHeader& HeaderTable::getHeader(uint32_t index) const {
-  CHECK(isValid(index));
+  PRX_CHECK(isValid(index));
   return table_[toInternal(index)];
 }
 
@@ -119,9 +119,9 @@ uint32_t HeaderTable::removeLast() {
   // remove the first element from the names index
   if (indexNames_) {
     auto names_it = names_.find(table_[t].name);
-    DCHECK(names_it != names_.end());
+    PRX_DCHECK(names_it != names_.end());
     auto& ilist = names_it->second;
-    DCHECK_EQ(ilist.front(), t);
+    PRX_DCHECK_EQ(ilist.front(), t);
     ilist.erase(ilist.begin());
 
     // remove the name if there are no indices associated with it
@@ -132,8 +132,8 @@ uint32_t HeaderTable::removeLast() {
   const auto& header = table_[t];
   uint32_t headerBytes = header.bytes();
   bytes_ -= headerBytes;
-  DVLOG(10) << "Removing local idx=" << t << " name=" << header.name
-            << " value=" << header.value;
+  PRX_DVLOG(10) << "Removing local idx=" << t << " name=" << header.name
+                << " value=" << header.value;
   --size_;
   return headerBytes;
 }
@@ -171,7 +171,7 @@ bool HeaderTable::setCapacity(uint32_t newCapacity) {
 }
 
 void HeaderTable::increaseTableLengthTo(uint32_t newLength) {
-  DCHECK_GE(newLength, length());
+  PRX_DCHECK_GE(newLength, length());
   uint32_t oldTail = (size_ > 0) ? tail() : 0;
   auto oldLength = length();
   resizeTable(newLength);
@@ -186,7 +186,7 @@ void HeaderTable::increaseTableLengthTo(uint32_t newLength) {
       for (auto& names_it : names_) {
         for (auto& idx : names_it.second) {
           if (idx >= oldTail) {
-            DCHECK_LT(idx + (length() - oldLength), length());
+            PRX_DCHECK_LT(idx + (length() - oldLength), length());
             idx += (length() - oldLength);
           } else {
             // remaining indecies in the list were smaller than oldTail, so
@@ -223,7 +223,7 @@ bool HeaderTable::isValid(uint32_t index) const {
   bool result = false;
   result = 0 < index && index <= size_;
   if (!result) {
-    LOG(ERROR) << "Invalid index=" << index << " size_=" << size_;
+    PRX_LOG(ERROR) << "Invalid index=" << index << " size_=" << size_;
   }
   return result;
 }
@@ -235,7 +235,7 @@ uint32_t HeaderTable::next(uint32_t i) const {
 uint32_t HeaderTable::tail() const {
   // tail is private, and only called in the encoder, where head_ is always
   // valid
-  DCHECK_GT(size_, 0) << "tail() undefined";
+  PRX_DCHECK_GT(size_, 0u) << "tail() undefined";
   return (head_ + length() - size_ + 1) % length();
 }
 
diff --git a/proxygen/lib/http/codec/compress/QPACKCodec.cpp b/proxygen/lib/http/codec/compress/QPACKCodec.cpp
index 6637f0df1d..841b69f409 100644
--- a/proxygen/lib/http/codec/compress/QPACKCodec.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKCodec.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/codec/CodecUtil.h>
 #include <proxygen/lib/http/codec/compress/HPACKCodec.h> // for prepareHeaders
 #include <proxygen/lib/http/codec/compress/HPACKHeader.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using proxygen::compress::Header;
 using std::vector;
@@ -138,15 +139,15 @@ std::unique_ptr<folly::IOBuf> QPACKCodec::encodeHTTP(
                                 folly::StringPiece value) {
     if (CodecUtil::disallowedModernHTTPFields()[code] || name.empty() ||
         name[0] == ':') {
-      DCHECK(!name.empty()) << "Empty header";
-      DCHECK_NE(name[0], ':') << "Invalid header=" << name;
+      PRX_DCHECK(!name.empty()) << "Empty header";
+      PRX_DCHECK_NE(name[0], ':') << "Invalid header=" << name;
       return;
     }
     // Note this code will not drop headers named by Connection.  That's the
     // caller's job
 
     // see HTTP/2 spec, 8.1.2
-    DCHECK(name != "TE" || value == "trailers");
+    PRX_DCHECK(name != "TE" || value == "trailers");
     if ((!name.empty() && name[0] != ':') && code != HTTP_HEADER_HOST) {
       if (code == HTTP_HEADER_OTHER) {
         uncompressed += encoder_.encodeHeaderQ(
diff --git a/proxygen/lib/http/codec/compress/QPACKCodec.h b/proxygen/lib/http/codec/compress/QPACKCodec.h
index 056d53eb9d..c71b90fd0d 100644
--- a/proxygen/lib/http/codec/compress/QPACKCodec.h
+++ b/proxygen/lib/http/codec/compress/QPACKCodec.h
@@ -15,6 +15,7 @@
 #include <proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h>
 #include <proxygen/lib/http/codec/compress/QPACKDecoder.h>
 #include <proxygen/lib/http/codec/compress/QPACKEncoder.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <vector>
 
 namespace folly::io {
@@ -73,7 +74,7 @@ class QPACKCodec : public HeaderCodec {
   //
   // Returns false if it was previously called with a different non-zero value.
   bool setEncoderHeaderTableSize(uint32_t size, bool updateMax = true) {
-    VLOG(4) << __func__ << " size=" << size;
+    PRX_VLOG(4) << __func__ << " size=" << size;
     return encoder_.setHeaderTableSize(size, updateMax);
   }
 
diff --git a/proxygen/lib/http/codec/compress/QPACKContext.cpp b/proxygen/lib/http/codec/compress/QPACKContext.cpp
index af7b7e5da5..570df00263 100644
--- a/proxygen/lib/http/codec/compress/QPACKContext.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKContext.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/codec/compress/QPACKContext.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -25,7 +25,7 @@ const HPACKHeader& QPACKContext::getHeader(bool isStatic,
     return getStaticTable().getHeader(index);
   }
   if (aboveBase) {
-    CHECK_LE(base, std::numeric_limits<uint32_t>::max() - index);
+    PRX_CHECK_LE(base, std::numeric_limits<uint32_t>::max() - index);
     base += index;
     index = 1;
   }
@@ -34,7 +34,7 @@ const HPACKHeader& QPACKContext::getHeader(bool isStatic,
 
 void QPACKContext::seedHeaderTable(std::vector<HPACKHeader>& headers) {
   for (auto& header : headers) {
-    CHECK(table_.add(std::move(header)));
+    PRX_CHECK(table_.add(std::move(header)));
   }
 }
 
diff --git a/proxygen/lib/http/codec/compress/QPACKDecoder.cpp b/proxygen/lib/http/codec/compress/QPACKDecoder.cpp
index 9db3441fb5..56c9da06c1 100644
--- a/proxygen/lib/http/codec/compress/QPACKDecoder.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKDecoder.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/codec/compress/QPACKDecoder.h>
 
 #include <proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::io::Cursor;
 
@@ -28,11 +29,11 @@ void QPACKDecoder::decodeStreaming(uint64_t streamID,
   err_ = HPACK::DecodeError::NONE;
   uint32_t requiredInsertCount = decodePrefix(dbuf);
   if (requiredInsertCount > table_.getInsertCount()) {
-    VLOG(5) << "requiredInsertCount=" << requiredInsertCount
-            << " > insertCount=" << table_.getInsertCount() << ", queuing";
+    PRX_VLOG(5) << "requiredInsertCount=" << requiredInsertCount
+                << " > insertCount=" << table_.getInsertCount() << ", queuing";
     if (queue_.size() >= maxBlocking_) {
-      VLOG(2) << "QPACK queue full size=" << queue_.size()
-              << " maxBlocking_=" << maxBlocking_;
+      PRX_VLOG(2) << "QPACK queue full size=" << queue_.size()
+                  << " maxBlocking_=" << maxBlocking_;
       err_ = HPACK::DecodeError::TOO_MANY_BLOCKING;
       completeDecode(HeaderCodec::Type::QPACK, streamingCb, 0, 0, 0, false);
     } else {
@@ -60,14 +61,14 @@ uint32_t QPACKDecoder::decodePrefix(HPACKDecodeBuffer& dbuf) {
 
   err_ = dbuf.decodeInteger(wireRIC);
   if (err_ != HPACK::DecodeError::NONE) {
-    LOG(ERROR) << "Decode error decoding requiredInsertCount err_=" << err_;
+    PRX_LOG(ERROR) << "Decode error decoding requiredInsertCount err_=" << err_;
     return 0;
   }
   if (wireRIC == 0) {
     requiredInsertCount = 0;
   } else if (maxEntries == 0) {
-    LOG(ERROR) << "Encoder used dynamic table when not permitted, wireRIC="
-               << wireRIC;
+    PRX_LOG(ERROR) << "Encoder used dynamic table when not permitted, wireRIC="
+                   << wireRIC;
     err_ = HPACK::DecodeError::INVALID_INDEX;
     return 0;
   } else {
@@ -84,52 +85,52 @@ uint32_t QPACKDecoder::decodePrefix(HPACKDecodeBuffer& dbuf) {
     // wrapped one fewer time
     if (requiredInsertCount > maxValue) {
       if (requiredInsertCount < fullRange) {
-        LOG(ERROR) << "Decode error RIC out of range=" << wireRIC;
+        PRX_LOG(ERROR) << "Decode error RIC out of range=" << wireRIC;
         err_ = HPACK::DecodeError::INVALID_INDEX;
         return 0;
       }
       requiredInsertCount -= fullRange;
     }
   }
-  VLOG(5) << "Decoded requiredInsertCount=" << requiredInsertCount;
+  PRX_VLOG(5) << "Decoded requiredInsertCount=" << requiredInsertCount;
   uint64_t delta = 0;
   if (dbuf.empty()) {
-    LOG(ERROR) << "Invalid prefix, no delta-base";
+    PRX_LOG(ERROR) << "Invalid prefix, no delta-base";
     err_ = HPACK::DecodeError::BUFFER_UNDERFLOW;
     return 0;
   }
   bool neg = dbuf.peek() & HPACK::Q_DELTA_BASE_NEG;
   err_ = dbuf.decodeInteger(HPACK::Q_DELTA_BASE.prefixLength, delta);
   if (err_ != HPACK::DecodeError::NONE) {
-    LOG(ERROR) << "Decode error decoding delta base=" << err_;
+    PRX_LOG(ERROR) << "Decode error decoding delta base=" << err_;
     return 0;
   }
   if (neg) {
     // delta must be smaller than RIC
     if (delta >= requiredInsertCount) {
-      LOG(ERROR) << "Received invalid delta=" << delta
-                 << " requiredInsertCount=" << requiredInsertCount;
+      PRX_LOG(ERROR) << "Received invalid delta=" << delta
+                     << " requiredInsertCount=" << requiredInsertCount;
       err_ = HPACK::DecodeError::INVALID_INDEX;
       return 0;
     }
     // The largest table we support is 2^32 - 1 / 32 entries, so
     // requiredInsertCount (less any delta, etc) must be < 2^32.
-    CHECK_LE(requiredInsertCount - delta - 1,
-             std::numeric_limits<uint32_t>::max());
+    PRX_CHECK_LE(requiredInsertCount - delta - 1,
+                 std::numeric_limits<uint32_t>::max());
     baseIndex_ = requiredInsertCount - delta - 1;
   } else {
     // base must be < 2^32
     if (delta > std::numeric_limits<uint32_t>::max() ||
         requiredInsertCount >=
             uint64_t(std::numeric_limits<uint32_t>::max()) - delta) {
-      LOG(ERROR) << "Invalid delta=" << delta
-                 << " requiredInsertCount=" << requiredInsertCount;
+      PRX_LOG(ERROR) << "Invalid delta=" << delta
+                     << " requiredInsertCount=" << requiredInsertCount;
       err_ = HPACK::DecodeError::INVALID_INDEX;
       return 0;
     }
     baseIndex_ = requiredInsertCount + delta;
   }
-  VLOG(5) << "Decoded baseIndex_=" << baseIndex_;
+  PRX_VLOG(5) << "Decoded baseIndex_=" << baseIndex_;
   return requiredInsertCount;
 }
 
@@ -142,8 +143,8 @@ void QPACKDecoder::decodeStreamingImpl(uint32_t requiredInsertCount,
   while (!hasError() && !dbuf.empty()) {
     emittedSize += decodeHeaderQ(dbuf, streamingCb);
     if (emittedSize > maxUncompressed_) {
-      LOG(ERROR) << "Exceeded uncompressed size limit of " << maxUncompressed_
-                 << " bytes";
+      PRX_LOG(ERROR) << "Exceeded uncompressed size limit of "
+                     << maxUncompressed_ << " bytes";
       err_ = HPACK::DecodeError::HEADERS_TOO_LARGE;
       break;
     }
@@ -205,7 +206,7 @@ HPACK::DecodeError QPACKDecoder::decodeEncoderStream(
                          maxUncompressed_,
                          /* endOfBufferIsError=*/false);
 
-  VLOG(6) << "Decoding control block";
+  PRX_VLOG(6) << "Decoding control block";
   baseIndex_ = 0;
   err_ = HPACK::DecodeError::NONE;
   while (!hasError() && !dbuf.empty()) {
@@ -266,11 +267,11 @@ void QPACKDecoder::decodeEncoderStreamInstruction(HPACKDecodeBuffer& dbuf) {
     decodeIndexedHeaderQ(
         dbuf, HPACK::Q_DUPLICATE.prefixLength, false, nullptr, &emitted);
     if (!hasError()) {
-      CHECK(!emitted.empty());
+      PRX_CHECK(!emitted.empty());
       if (!table_.add(std::move(emitted[0]))) {
         // the only case is the header was > table capacity.  But how can we
         // duplicate such a header?
-        LOG(DFATAL) << "Encoder duplicated a header larger than capacity";
+        PRX_LOG(DFATAL) << "Encoder duplicated a header larger than capacity";
         err_ = HPACK::DecodeError::INSERT_TOO_LARGE;
       } else {
         duplications_++;
@@ -298,13 +299,13 @@ uint32_t QPACKDecoder::decodeLiteralHeaderQ(
         return 0;
       }
       if (err_ != HPACK::DecodeError::NONE) {
-        LOG(ERROR) << "Decode error decoding index err_=" << err_;
+        PRX_LOG(ERROR) << "Decode error decoding index err_=" << err_;
         return 0;
       }
       nameIndex++;
       // validate the index
       if (!isValid(isStaticName, nameIndex, aboveBase)) {
-        LOG(ERROR) << "Received invalid index=" << nameIndex;
+        PRX_LOG(ERROR) << "Received invalid index=" << nameIndex;
         err_ = HPACK::DecodeError::INVALID_INDEX;
         return 0;
       }
@@ -317,7 +318,7 @@ uint32_t QPACKDecoder::decodeLiteralHeaderQ(
         return 0;
       }
       if (err_ != HPACK::DecodeError::NONE) {
-        LOG(ERROR) << "Error decoding header name err_=" << err_;
+        PRX_LOG(ERROR) << "Error decoding header name err_=" << err_;
         return 0;
       }
       partial->header.name = HPACKHeaderName{headerName};
@@ -331,8 +332,8 @@ uint32_t QPACKDecoder::decodeLiteralHeaderQ(
     return 0;
   }
   if (err_ != HPACK::DecodeError::NONE) {
-    LOG(ERROR) << "Error decoding header value name=" << partial->header.name
-               << " err_=" << err_;
+    PRX_LOG(ERROR) << "Error decoding header value name="
+                   << partial->header.name << " err_=" << err_;
     return 0;
   }
   partial->state = Partial::NAME;
@@ -342,7 +343,7 @@ uint32_t QPACKDecoder::decodeLiteralHeaderQ(
   if (indexing) {
     if (!table_.add(std::move(partial->header))) {
       // the only case is the header was > table capacity
-      LOG(ERROR) << "Encoder inserted a header larger than capacity";
+      PRX_LOG(ERROR) << "Encoder inserted a header larger than capacity";
       err_ = HPACK::DecodeError::INSERT_TOO_LARGE;
     }
   }
@@ -361,15 +362,15 @@ uint32_t QPACKDecoder::decodeIndexedHeaderQ(
   err_ = dbuf.decodeInteger(prefixLength, index);
   if (err_ != HPACK::DecodeError::NONE) {
     if (streamingCb || err_ != HPACK::DecodeError::BUFFER_UNDERFLOW) {
-      LOG(ERROR) << "Decode error decoding index err_=" << err_;
+      PRX_LOG(ERROR) << "Decode error decoding index err_=" << err_;
     }
     return 0;
   }
-  CHECK_LT(index, std::numeric_limits<uint64_t>::max());
+  PRX_CHECK_LT(index, std::numeric_limits<uint64_t>::max());
   index++;
   // validate the index
   if (index == 0 || !isValid(isStatic, index, aboveBase)) {
-    LOG(ERROR) << "received invalid index: " << index;
+    PRX_LOG(ERROR) << "received invalid index: " << index;
     err_ = HPACK::DecodeError::INVALID_INDEX;
     return 0;
   }
@@ -400,7 +401,7 @@ bool QPACKDecoder::isValid(bool isStatic, uint64_t index, bool aboveBase) {
 std::unique_ptr<folly::IOBuf> QPACKDecoder::encodeInsertCountInc() {
   uint32_t toAck = table_.getInsertCount() - lastAcked_;
   if (toAck > 0) {
-    VLOG(6) << "encodeInsertCountInc toAck=" << toAck;
+    PRX_VLOG(6) << "encodeInsertCountInc toAck=" << toAck;
     HPACKEncodeBuffer ackEncoder(kGrowth, false);
     ackEncoder.encodeInteger(toAck, HPACK::Q_INSERT_COUNT_INC);
     lastAcked_ = table_.getInsertCount();
@@ -413,7 +414,7 @@ std::unique_ptr<folly::IOBuf> QPACKDecoder::encodeInsertCountInc() {
 std::unique_ptr<folly::IOBuf> QPACKDecoder::encodeHeaderAck(
     uint64_t streamId) const {
   HPACKEncodeBuffer ackEncoder(kGrowth, false);
-  VLOG(6) << "encodeHeaderAck id=" << streamId;
+  PRX_VLOG(6) << "encodeHeaderAck id=" << streamId;
   ackEncoder.encodeInteger(streamId, HPACK::Q_HEADER_ACK);
   return ackEncoder.release();
 }
@@ -421,7 +422,7 @@ std::unique_ptr<folly::IOBuf> QPACKDecoder::encodeHeaderAck(
 std::unique_ptr<folly::IOBuf> QPACKDecoder::encodeCancelStream(
     uint64_t streamId) {
   // Remove this stream from the queue
-  VLOG(6) << "encodeCancelStream id=" << streamId;
+  PRX_VLOG(6) << "encodeCancelStream id=" << streamId;
   auto it = queue_.begin();
   while (it != queue_.end()) {
     if (it->second.streamID == streamId) {
@@ -443,7 +444,7 @@ void QPACKDecoder::enqueueHeaderBlock(uint64_t streamID,
                                       size_t length,
                                       HPACK::StreamingCallback* streamingCb) {
   // TDOO: this queue is currently unbounded and has no timeouts
-  CHECK_GT(requiredInsertCount, table_.getInsertCount());
+  PRX_CHECK_GT(requiredInsertCount, table_.getInsertCount());
   queue_.emplace(std::piecewise_construct,
                  std::forward_as_tuple(requiredInsertCount),
                  std::forward_as_tuple(streamID,
@@ -453,17 +454,17 @@ void QPACKDecoder::enqueueHeaderBlock(uint64_t streamID,
                                        std::move(block),
                                        streamingCb));
   holBlockCount_++;
-  VLOG(5) << "queued block=" << requiredInsertCount << " len=" << length;
+  PRX_VLOG(5) << "queued block=" << requiredInsertCount << " len=" << length;
   queuedBytes_ += length;
 }
 
 bool QPACKDecoder::decodeBlock(uint32_t requiredInsertCount,
                                const PendingBlock& pending) {
   if (pending.length > 0) {
-    VLOG(5) << "decodeBlock len=" << pending.length;
+    PRX_VLOG(5) << "decodeBlock len=" << pending.length;
     folly::io::Cursor cursor(pending.block.get());
     HPACKDecodeBuffer dbuf(cursor, pending.length, maxUncompressed_);
-    DCHECK_LE(pending.length, queuedBytes_);
+    PRX_DCHECK_LE(pending.length, queuedBytes_);
     queuedBytes_ -= pending.length;
     baseIndex_ = pending.baseIndex;
     folly::DestructorCheck::Safety safety(*this);
diff --git a/proxygen/lib/http/codec/compress/QPACKDecoder.h b/proxygen/lib/http/codec/compress/QPACKDecoder.h
index b0ddf17c76..2f44ac383d 100644
--- a/proxygen/lib/http/codec/compress/QPACKDecoder.h
+++ b/proxygen/lib/http/codec/compress/QPACKDecoder.h
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKDecoderBase.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
 #include <proxygen/lib/http/codec/compress/QPACKContext.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -59,7 +60,7 @@ class QPACKDecoder
   }
 
   void setHeaderTableMaxSize(uint32_t maxSize) {
-    CHECK(maxTableSize_ == 0 || maxTableSize_ == maxSize)
+    PRX_CHECK(maxTableSize_ == 0 || maxTableSize_ == maxSize)
         << "Cannot change non-zero max header table size, "
            "maxTableSize_="
         << maxTableSize_ << " maxSize=" << maxSize;
diff --git a/proxygen/lib/http/codec/compress/QPACKEncoder.cpp b/proxygen/lib/http/codec/compress/QPACKEncoder.cpp
index a350063da3..f82ab2ae86 100644
--- a/proxygen/lib/http/codec/compress/QPACKEncoder.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKEncoder.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/codec/compress/QPACKEncoder.h>
 
 #include <proxygen/lib/http/codec/compress/HPACKDecodeBuffer.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::vector;
 
@@ -89,7 +90,7 @@ std::unique_ptr<folly::IOBuf> QPACKEncoder::completeEncode(
   if (curOutstanding_.minInUseIndex != std::numeric_limits<uint32_t>::max()) {
     outstandingMins_.push_back(curOutstanding_.minInUseIndex);
     if (curOutstanding_.vulnerable) {
-      DCHECK(allowVulnerable());
+      PRX_DCHECK(allowVulnerable());
       numVulnerable_++;
     }
     numOutstandingBlocks_++;
@@ -146,7 +147,7 @@ size_t QPACKEncoder::encodeHeaderQ(HPACKHeaderName name,
     if (indexable) {
       if (table_.canIndex(name, value)) {
         encodeInsertQ(name, value, isStaticName, nameIndex);
-        CHECK(table_.add(HPACKHeader(std::move(name), value)));
+        PRX_CHECK(table_.add(HPACKHeader(std::move(name), value)));
         if (allowVulnerable() && lastEntryAvailable()) {
           index = table_.getInsertCount();
           // name is invalid on this branch, but index must be non-zero since
@@ -182,7 +183,7 @@ size_t QPACKEncoder::encodeHeaderQ(HPACKHeaderName name,
   }
 
   // Encoding a dynamic index reference
-  DCHECK_NE(index, 0);
+  PRX_DCHECK_NE(index, 0u);
   trackReference(index, requiredInsertCount);
   if (index > baseIndex) {
     streamBuffer_.encodeInteger(index - baseIndex - 1, HPACK::Q_INDEXED_POST);
@@ -206,14 +207,14 @@ bool QPACKEncoder::dynamicReferenceAllowed() const {
 std::pair<bool, uint32_t> QPACKEncoder::maybeDuplicate(uint32_t relativeIndex) {
   auto res = table_.maybeDuplicate(relativeIndex, allowVulnerable());
   if (res.first) {
-    VLOG(4) << "Encoded duplicate index=" << relativeIndex;
+    PRX_VLOG(4) << "Encoded duplicate index=" << relativeIndex;
     duplications_++;
     encodeDuplicate(relativeIndex);
     // Note we will emit duplications even when we are out of flow control,
     // but we won't reference them (eg: like we were at vulnerable max).
     if (!lastEntryAvailable()) {
-      VLOG(4) << "Duplicate is not usable because it overran encoder flow "
-                 "control";
+      PRX_VLOG(4) << "Duplicate is not usable because it overran encoder flow "
+                     "control";
       return {true, 0};
     }
   }
@@ -252,7 +253,7 @@ size_t QPACKEncoder::encodeStreamLiteralQ(const HPACKHeaderName& name,
                                           uint32_t& requiredInsertCount) {
   if (absoluteNameIndex > 0) {
     // Dynamic name reference, vulnerability checks already done
-    CHECK(absoluteNameIndex <= baseIndex || allowVulnerable());
+    PRX_CHECK(absoluteNameIndex <= baseIndex || allowVulnerable());
     trackReference(absoluteNameIndex, requiredInsertCount);
   }
   if (absoluteNameIndex > baseIndex) {
@@ -275,7 +276,7 @@ size_t QPACKEncoder::encodeStreamLiteralQ(const HPACKHeaderName& name,
 
 void QPACKEncoder::trackReference(uint32_t absoluteIndex,
                                   uint32_t& requiredInsertCount) {
-  CHECK_NE(absoluteIndex, 0);
+  PRX_CHECK_NE(absoluteIndex, 0u);
   if (absoluteIndex > requiredInsertCount) {
     requiredInsertCount = absoluteIndex;
     curOutstanding_.maxInUseIndex = requiredInsertCount;
@@ -293,7 +294,7 @@ void QPACKEncoder::trackReference(uint32_t absoluteIndex,
 }
 
 void QPACKEncoder::encodeDuplicate(uint32_t index) {
-  DCHECK_GT(index, 0);
+  PRX_DCHECK_GT(index, 0u);
   maxEncoderStreamBytes_ -=
       controlBuffer_.encodeInteger(index - 1, HPACK::Q_DUPLICATE);
 }
@@ -319,7 +320,7 @@ size_t QPACKEncoder::encodeLiteralQ(const HPACKHeaderName& name,
                                     bool postBase,
                                     uint32_t nameIndex,
                                     const HPACK::Instruction& idxInstr) {
-  DCHECK(!isStaticName || !postBase);
+  PRX_DCHECK(!isStaticName || !postBase);
   return encodeLiteralQHelper(streamBuffer_,
                               name,
                               value,
@@ -342,8 +343,8 @@ uint32_t QPACKEncoder::encodeLiteralQHelper(
   uint32_t encoded = 0;
   // name
   if (nameIndex) {
-    VLOG(10) << "encoding name index=" << nameIndex;
-    DCHECK_NE(nameIndex, QPACKHeaderTable::UNACKED);
+    PRX_VLOG(10) << "encoding name index=" << nameIndex;
+    PRX_DCHECK_NE(nameIndex, QPACKHeaderTable::UNACKED);
     nameIndex -= 1; // we already know it's not 0
     uint8_t byte = idxInstr.code;
     if (isStaticName) {
@@ -385,7 +386,7 @@ HPACK::DecodeError QPACKEncoder::decodeDecoderStream(
       if (err == HPACK::DecodeError::NONE) {
         err = onInsertCountIncrement(numInserts);
       } else if (err != HPACK::DecodeError::BUFFER_UNDERFLOW) {
-        LOG(ERROR) << "Failed to decode numInserts, err=" << err;
+        PRX_LOG(ERROR) << "Failed to decode numInserts, err=" << err;
       }
     }
   } // while
@@ -413,7 +414,7 @@ HPACK::DecodeError QPACKEncoder::decodeHeaderAck(HPACKDecodeBuffer& dbuf,
   if (err == HPACK::DecodeError::NONE) {
     err = onHeaderAck(streamId, all);
   } else if (err != HPACK::DecodeError::BUFFER_UNDERFLOW) {
-    LOG(ERROR) << "Failed to decode streamId, err=" << err;
+    PRX_LOG(ERROR) << "Failed to decode streamId, err=" << err;
   }
   return err;
 }
@@ -429,8 +430,9 @@ HPACK::DecodeError QPACKEncoder::onHeaderAck(uint64_t streamId, bool all) {
   auto it = outstanding_.find(streamId);
   if (it == outstanding_.end()) {
     if (!all) {
-      LOG(ERROR) << "Received an ack with no outstanding header blocks stream="
-                 << streamId;
+      PRX_LOG(ERROR)
+          << "Received an ack with no outstanding header blocks stream="
+          << streamId;
       return HPACK::DecodeError::INVALID_ACK;
     } else {
       // all implies a reset, meaning it's not an error if there are no
@@ -438,10 +440,10 @@ HPACK::DecodeError QPACKEncoder::onHeaderAck(uint64_t streamId, bool all) {
       return HPACK::DecodeError::NONE;
     }
   }
-  DCHECK(!it->second.empty()) << "Invariant violation: no blocks in stream "
-                                 "record";
-  VLOG(5) << ((all) ? "onCancelStream" : "onHeaderAck")
-          << " streamId=" << streamId;
+  PRX_DCHECK(!it->second.empty()) << "Invariant violation: no blocks in stream "
+                                     "record";
+  PRX_VLOG(5) << ((all) ? "onCancelStream" : "onHeaderAck")
+              << " streamId=" << streamId;
   if (all) {
     // Happens when a stream is reset (should be rare)
     for (auto& block : it->second) {
@@ -459,24 +461,24 @@ HPACK::DecodeError QPACKEncoder::onHeaderAck(uint64_t streamId, bool all) {
     if (block.vulnerable) {
       numVulnerable_--;
     }
-    CHECK_NE(block.minInUseIndex, std::numeric_limits<uint32_t>::max());
+    PRX_CHECK_NE(block.minInUseIndex, std::numeric_limits<uint32_t>::max());
     removeFromMinOutstanding(block.minInUseIndex);
     // Up through maxInUseIndex is implicitly acknowledged
-    VLOG(5) << "Implicitly acknowledging requiredInsertCount="
-            << block.maxInUseIndex;
+    PRX_VLOG(5) << "Implicitly acknowledging requiredInsertCount="
+                << block.maxInUseIndex;
     table_.setAcknowledgedInsertCount(block.maxInUseIndex);
   }
   if (it->second.empty()) {
     outstanding_.erase(it);
   }
-  VLOG(6) << "New min use index=" << minOutstandingMin_;
+  PRX_VLOG(6) << "New min use index=" << minOutstandingMin_;
   table_.setMinInUseIndex(minOutstandingMin_);
   return HPACK::DecodeError::NONE;
 }
 
 void QPACKEncoder::removeFromMinOutstanding(uint32_t valToRemove) {
-  CHECK(!outstandingMins_.empty());
-  VLOG(10) << "mins remove val=" << valToRemove;
+  PRX_CHECK(!outstandingMins_.empty());
+  PRX_VLOG(10) << "mins remove val=" << valToRemove;
   bool recomputeMin = (valToRemove == minOutstandingMin_);
   uint32_t newMin = std::numeric_limits<uint32_t>::max();
   size_t i = 0;
diff --git a/proxygen/lib/http/codec/compress/QPACKEncoder.h b/proxygen/lib/http/codec/compress/QPACKEncoder.h
index 77d5bad149..504d530269 100644
--- a/proxygen/lib/http/codec/compress/QPACKEncoder.h
+++ b/proxygen/lib/http/codec/compress/QPACKEncoder.h
@@ -14,6 +14,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h>
 #include <proxygen/lib/http/codec/compress/HPACKEncoderBase.h>
 #include <proxygen/lib/http/codec/compress/QPACKContext.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <unordered_map>
 #include <vector>
 
@@ -63,16 +64,16 @@ class QPACKEncoder
     if (updateMax) {
       // The peer's max is used whenn encoding RequiredInsertCouunt
       if (maxTableSize_ != 0 && maxTableSize_ != tableSize) {
-        LOG(ERROR) << "Cannot change non-zero max header table size, "
-                      "maxTableSize_="
-                   << maxTableSize_ << " tableSize=" << tableSize;
+        PRX_LOG(ERROR) << "Cannot change non-zero max header table size, "
+                          "maxTableSize_="
+                       << maxTableSize_ << " tableSize=" << tableSize;
         return false;
       }
       maxTableSize_ = tableSize;
     }
     if (tableSize > kMaxHeaderTableSize) {
-      VLOG(2) << "Limiting table size from " << tableSize << " to "
-              << kMaxHeaderTableSize;
+      PRX_VLOG(2) << "Limiting table size from " << tableSize << " to "
+                  << kMaxHeaderTableSize;
       tableSize = kMaxHeaderTableSize;
     }
     HPACKEncoderBase::setHeaderTableSize(table_, tableSize);
diff --git a/proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp b/proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp
index e7c7499c59..b6781e8211 100644
--- a/proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/codec/compress/QPACKHeaderTable.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 // For tables 0..384     minFree = 48
@@ -44,23 +44,26 @@ QPACKHeaderTable::QPACKHeaderTable(uint32_t capacityVal, bool trackReferences)
 
 bool QPACKHeaderTable::add(HPACKHeader header) {
   if (insertCount_ == std::numeric_limits<uint32_t>::max()) {
-    LOG(ERROR) << "Cowardly refusing to add more entries since insertCount_ "
-                  " would wrap";
+    PRX_LOG(ERROR)
+        << "Cowardly refusing to add more entries since insertCount_ "
+           " would wrap";
     return false;
   }
 
-  DVLOG(6) << "Adding header=" << header << " absIndex=" << insertCount_ + 1;
+  PRX_DVLOG(6) << "Adding header=" << header
+               << " absIndex=" << insertCount_ + 1;
   if (!HeaderTable::add(std::move(header))) {
     return false;
   }
-  DCHECK_EQ(internalToAbsolute(head_), insertCount_);
+  PRX_DCHECK_EQ(internalToAbsolute(head_), insertCount_);
   // Increase minUsable_ until the free space + drainedBytes is >= minFree.
   // For HPACK, minFree is 0 and this is a no-op.
   while (capacity_ - bytes_ + drainedBytes_ < minFree_ &&
          minUsable_ <= insertCount_) {
     auto bytes = table_[absoluteToInternal(minUsable_)].bytes();
-    VLOG(5) << "Draining absolute index " << minUsable_ << " bytes=" << bytes
-            << " drainedBytes_= " << (drainedBytes_ + bytes);
+    PRX_VLOG(5) << "Draining absolute index " << minUsable_
+                << " bytes=" << bytes
+                << " drainedBytes_= " << (drainedBytes_ + bytes);
     drainedBytes_ += bytes;
     minUsable_++;
   }
@@ -126,23 +129,23 @@ uint32_t QPACKHeaderTable::nameIndex(const HPACKHeaderName& headerName,
 
 const HPACKHeader& QPACKHeaderTable::getHeader(uint32_t index,
                                                uint32_t base) const {
-  CHECK(isValid(index, base));
+  PRX_CHECK(isValid(index, base));
   return table_[toInternal(index, base)];
 }
 
 uint32_t QPACKHeaderTable::removeLast() {
   auto idx = tail();
   if (trackReferences_) {
-    CHECK_LT(internalToAbsolute(idx), minInUseIndex_)
+    PRX_CHECK_LT(internalToAbsolute(idx), minInUseIndex_)
         << "Removed in use header";
   }
   auto removedBytes = HeaderTable::removeLast();
   // Only non-zero when minUsable_ > insertCount_ - size_.
   if (drainedBytes_ > 0) {
-    VLOG(5) << "Removing draining entry=" << idx << " size=" << removedBytes
-            << " drainedBytes_=" << drainedBytes_
-            << " new drainedBytes_=" << (int32_t(drainedBytes_) - removedBytes);
-    CHECK_GE(drainedBytes_, removedBytes);
+    PRX_VLOG(5) << "Removing draining entry=" << idx << " size=" << removedBytes
+                << " drainedBytes_=" << drainedBytes_ << " new drainedBytes_="
+                << (int32_t(drainedBytes_) - removedBytes);
+    PRX_CHECK_GE(drainedBytes_, removedBytes);
     drainedBytes_ -= removedBytes;
   } else {
     // Keep minUsable_ as a valid index when evicting an undrained header
@@ -158,8 +161,8 @@ uint32_t QPACKHeaderTable::removeLast() {
 void QPACKHeaderTable::increaseTableLengthTo(uint32_t newLength) {
   HeaderTable::increaseTableLengthTo(newLength);
   if (size_ > 0) {
-    DCHECK_EQ(internalToAbsolute(head_), insertCount_);
-    DCHECK_EQ(internalToAbsolute(tail()), insertCount_ - size_ + 1);
+    PRX_DCHECK_EQ(internalToAbsolute(head_), insertCount_);
+    PRX_DCHECK_EQ(internalToAbsolute(tail()), insertCount_ - size_ + 1);
   }
 }
 
@@ -186,8 +189,8 @@ bool QPACKHeaderTable::canEvict(uint32_t needed) {
     i = next(i);
   }
   if (freeable < needed) {
-    DVLOG(5) << "header=" << table_[i].name << ":" << table_[i].value
-             << " blocked eviction, minInUseIndex_=" << minInUseIndex_;
+    PRX_DVLOG(5) << "header=" << table_[i].name << ":" << table_[i].value
+                 << " blocked eviction, minInUseIndex_=" << minInUseIndex_;
     return false;
   }
   return true;
@@ -214,14 +217,14 @@ std::pair<bool, uint32_t> QPACKHeaderTable::maybeDuplicate(
   if (relativeIndex == UNACKED) {
     return {false, 0};
   }
-  DCHECK(isValid(relativeIndex));
+  PRX_DCHECK(isValid(relativeIndex));
   uint32_t absIndex = relativeToAbsolute(relativeIndex);
-  DCHECK(!isVulnerable(absIndex) || allowVulnerable);
+  PRX_DCHECK(!isVulnerable(absIndex) || allowVulnerable);
   if (absIndex < minUsable_) {
     // draining
     const HPACKHeader& header = getHeader(relativeIndex);
     if (canIndex(header.name, header.value)) {
-      CHECK(add(header.copy()));
+      PRX_CHECK(add(header.copy()));
       if (allowVulnerable) {
         return {true, insertCount_};
       } else {
diff --git a/proxygen/lib/http/codec/compress/QPACKHeaderTable.h b/proxygen/lib/http/codec/compress/QPACKHeaderTable.h
index 94c6a7eb6e..d4835d3a8a 100644
--- a/proxygen/lib/http/codec/compress/QPACKHeaderTable.h
+++ b/proxygen/lib/http/codec/compress/QPACKHeaderTable.h
@@ -10,7 +10,7 @@
 
 #include <limits>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/http/codec/compress/HPACKHeader.h>
 #include <proxygen/lib/http/codec/compress/HeaderTable.h>
@@ -127,13 +127,13 @@ class QPACKHeaderTable : public HeaderTable {
     // compare this way to avoid overflow
     if (numInserts > insertCount_ ||
         ackedInsertCount_ > insertCount_ - numInserts) {
-      LOG(ERROR)
+      PRX_LOG(ERROR)
           << "Decoder ack'd too much: ackedInsertCount_=" << ackedInsertCount_
           << " insertCount_=" << insertCount_ << " numInserts=" << numInserts;
       return false;
     }
     ackedInsertCount_ += numInserts;
-    CHECK_LE(ackedInsertCount_, insertCount_);
+    PRX_CHECK_LE(ackedInsertCount_, insertCount_);
     return true;
   }
 
@@ -141,7 +141,7 @@ class QPACKHeaderTable : public HeaderTable {
     if (ackInsertCount < ackedInsertCount_) {
       return;
     }
-    CHECK_LE(ackInsertCount, insertCount_);
+    PRX_CHECK_LE(ackInsertCount, insertCount_);
     ackedInsertCount_ = ackInsertCount;
   }
 
@@ -149,7 +149,7 @@ class QPACKHeaderTable : public HeaderTable {
    * Convert a relative index to an absolute index
    */
   [[nodiscard]] uint32_t relativeToAbsolute(uint32_t relativeIndex) const {
-    DCHECK(isValid(relativeIndex, 0));
+    PRX_DCHECK(isValid(relativeIndex, 0));
     return insertCount_ - relativeIndex + 1;
   }
 
@@ -157,7 +157,7 @@ class QPACKHeaderTable : public HeaderTable {
    * Convert an absolute index to a relative index
    */
   [[nodiscard]] uint32_t absoluteToRelative(uint32_t absIndex) const {
-    CHECK_LE(absIndex, insertCount_);
+    PRX_CHECK_LE(absIndex, insertCount_);
     return insertCount_ - absIndex + 1;
   }
 
diff --git a/proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.cpp b/proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.cpp
index 871a29c76a..280fa3b4b5 100644
--- a/proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.cpp
+++ b/proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.cpp
@@ -10,7 +10,7 @@
 
 #include <folly/Indestructible.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -140,7 +140,7 @@ namespace proxygen {
  */
 bool QPACKStaticHeaderTable::isHeaderCodeInTableWithNonEmptyValue(
     HTTPHeaderCode /*headerCode*/) {
-  LOG(FATAL) << __func__ << " not supported for QPACK";
+  PRX_LOG(FATAL) << __func__ << " not supported for QPACK";
 }
 
 const StaticHeaderTable& QPACKStaticHeaderTable::get() {
diff --git a/proxygen/lib/http/codec/compress/StaticHeaderTable.cpp b/proxygen/lib/http/codec/compress/StaticHeaderTable.cpp
index fc3d8f0c0b..55596b2413 100644
--- a/proxygen/lib/http/codec/compress/StaticHeaderTable.cpp
+++ b/proxygen/lib/http/codec/compress/StaticHeaderTable.cpp
@@ -10,8 +10,8 @@
 
 #include <folly/Indestructible.h>
 
-#include <glog/logging.h>
 #include <list>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::list;
 
@@ -116,7 +116,7 @@ StaticHeaderTable::StaticHeaderTable(const char* entries[][2], int size)
   init(byteCount);
   hlist.reverse();
   for (auto& header : hlist) {
-    CHECK(add(std::move(header)));
+    PRX_CHECK(add(std::move(header)));
   }
 }
 
diff --git a/proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp b/proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp
index 05df779584..135fde5314 100644
--- a/proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp
+++ b/proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/test/HTTPArchive.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::compress;
@@ -91,9 +92,10 @@ void encodeBlocks(QPACKCodec& decoder,
     bytesOut += writevFull(outputF.fd(), iov.data(), iov.size());
     streamId++;
   }
-  LOG(INFO) << "Encoded " << (streamId - 1) << " streams.  Bytes in=" << bytesIn
-            << " Bytes out=" << bytesOut
-            << " Ratio=" << int32_t(100 * (1 - (bytesOut / double(bytesIn))));
+  PRX_LOG(INFO)
+      << "Encoded " << (streamId - 1) << " streams.  Bytes in=" << bytesIn
+      << " Bytes out=" << bytesOut
+      << " Ratio=" << int32_t(100 * (1 - (bytesOut / double(bytesIn))));
 }
 
 void encodeHar(QPACKCodec& decoder, const proxygen::HTTPArchive& har) {
@@ -122,14 +124,14 @@ class Reader {
       auto pre = inbuf.preallocate(4096, 4096);
       rc = readNoInt(inputF.fd(), pre.first, pre.second);
       if (rc < 0) {
-        LOG(ERROR) << "Read failed on " << FLAGS_input;
+        PRX_LOG(ERROR) << "Read failed on " << FLAGS_input;
         return 1;
       }
       inbuf.postallocate(rc);
       onIngress(inbuf);
     } while (rc != 0);
     if (!inbuf.empty()) {
-      LOG(ERROR) << "Premature end of file";
+      PRX_LOG(ERROR) << "Premature end of file";
       return 1;
     }
 
@@ -182,8 +184,8 @@ int decodeAndVerify(QPACKCodec& decoder, const proxygen::HTTPArchive& har) {
                                uint32_t length,
                                std::unique_ptr<folly::IOBuf> buf) {
     if (streamId == 0) {
-      CHECK_EQ(decoder.decodeEncoderStream(std::move(buf)),
-               HPACK::DecodeError::NONE);
+      PRX_CHECK_EQ(decoder.decodeEncoderStream(std::move(buf)),
+                   HPACK::DecodeError::NONE);
     } else {
       auto res = streams.emplace(
           std::piecewise_construct,
@@ -199,17 +201,17 @@ int decodeAndVerify(QPACKCodec& decoder, const proxygen::HTTPArchive& har) {
   size_t i = 0;
   for (const auto& req : streams) {
     if (req.second.error != HPACK::DecodeError::NONE) {
-      LOG(ERROR) << "request=" << req.first
-                 << " failed to decode error=" << req.second.error;
+      PRX_LOG(ERROR) << "request=" << req.first
+                     << " failed to decode error=" << req.second.error;
       return 1;
     }
     if (!(req.second.msg == har.requests[i])) {
-      LOG(ERROR) << "requests are not equal, got=" << req.second.msg
-                 << " expected=" << har.requests[i];
+      PRX_LOG(ERROR) << "requests are not equal, got=" << req.second.msg
+                     << " expected=" << har.requests[i];
     }
     i++;
   }
-  LOG(INFO) << "Verified " << i << " streams.";
+  PRX_LOG(INFO) << "Verified " << i << " streams.";
   return 0;
 }
 
@@ -232,7 +234,8 @@ class QIFCallback : public HPACK::StreamingCallback {
     complete = true;
   }
   void onDecodeError(HPACK::DecodeError decodeError) override {
-    LOG(FATAL) << "Decode error with stream=" << id << " err=" << decodeError;
+    PRX_LOG(FATAL) << "Decode error with stream=" << id
+                   << " err=" << decodeError;
   }
 
   uint64_t id{0};
@@ -249,8 +252,8 @@ int decodeToQIF(QPACKCodec& decoder) {
                                uint32_t length,
                                std::unique_ptr<folly::IOBuf> buf) {
     if (streamId == 0) {
-      CHECK_EQ(decoder.decodeEncoderStream(std::move(buf)),
-               HPACK::DecodeError::NONE);
+      PRX_CHECK_EQ(decoder.decodeEncoderStream(std::move(buf)),
+                   HPACK::DecodeError::NONE);
       encoderStreamBytes += length;
     } else {
       auto res = streams.emplace(std::piecewise_construct,
@@ -265,10 +268,10 @@ int decodeToQIF(QPACKCodec& decoder) {
   }
 
   for (const auto& stream : streams) {
-    CHECK(stream.second.complete)
+    PRX_CHECK(stream.second.complete)
         << "Stream " << stream.first << " didn't complete";
   }
-  LOG(INFO) << "encoderStreamBytes=" << encoderStreamBytes;
+  PRX_LOG(INFO) << "encoderStreamBytes=" << encoderStreamBytes;
   return 0;
 }
 
@@ -277,7 +280,7 @@ int interopHAR(QPACKCodec& decoder) {
       (FLAGS_public) ? HTTPArchive::fromPublicFile(FLAGS_har)
                      : HTTPArchive::fromFile(FLAGS_har);
   if (!har) {
-    LOG(ERROR) << "Failed to read har file='" << FLAGS_har << "'";
+    PRX_LOG(ERROR) << "Failed to read har file='" << FLAGS_har << "'";
     return 1;
   }
   if (FLAGS_mode == "encode") {
@@ -285,7 +288,7 @@ int interopHAR(QPACKCodec& decoder) {
   } else if (FLAGS_mode == "decode") {
     return decodeAndVerify(decoder, *har);
   } else {
-    LOG(ERROR) << "Usage" << std::endl;
+    PRX_LOG(ERROR) << "Usage" << std::endl;
     return 1;
   }
   return 0;
@@ -307,7 +310,7 @@ struct QIFReader : public Reader {
     if (rc != 0) {
       return rc;
     }
-    CHECK(blocks.back().empty());
+    PRX_CHECK(blocks.back().empty());
     blocks.pop_back();
     return 0;
   }
@@ -370,7 +373,7 @@ struct QIFReader : public Reader {
         case VALUE:
           strings.back() += c.readWhile([](uint8_t ch) { return !iseol(ch); });
           if (!c.isAtEnd()) {
-            CHECK_GE(strings.size(), 2);
+            PRX_CHECK_GE(strings.size(), 2u);
             blocks.back().emplace_back(compress::Header::makeHeaderForTest(
                 *(strings.rbegin() + 1), *strings.rbegin()));
             state_ = EOL;
@@ -386,14 +389,14 @@ int interopQIF(QPACKCodec& decoder) {
   if (FLAGS_mode == "encode") {
     QIFReader reader;
     if (reader.read() != 0) {
-      LOG(ERROR) << "Failed to read QIF file='" << FLAGS_input << "'";
+      PRX_LOG(ERROR) << "Failed to read QIF file='" << FLAGS_input << "'";
       return 1;
     }
     encodeBlocks(decoder, reader.blocks);
   } else if (FLAGS_mode == "decode") {
     decodeToQIF(decoder);
   } else {
-    LOG(ERROR) << "Usage" << std::endl;
+    PRX_LOG(ERROR) << "Usage" << std::endl;
     return 1;
   }
 
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.cpp b/proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.cpp
index 12c31e5a5d..6e67d22b8e 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.cpp
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.h>
@@ -38,7 +39,7 @@ bool CompressionSimulator::readInputFromFileAndSchedule(
   try {
     har = HTTPArchive::fromFile(kTestDir + filename);
   } catch (const std::exception& ex) {
-    LOG(ERROR) << folly::exceptionStr(ex);
+    PRX_LOG(ERROR) << folly::exceptionStr(ex);
   }
   if (!har || har->requests.size() == 0) {
     return false;
@@ -72,36 +73,36 @@ bool CompressionSimulator::readInputFromFileAndSchedule(
 void CompressionSimulator::run() {
 #ifndef HAVE_REAL_QMIN
   if (params_.type == SchemeType::QMIN) {
-    LOG(INFO) << "QMIN not available";
+    PRX_LOG(INFO) << "QMIN not available";
     return;
   }
 #endif
 
-  LOG(INFO) << "Starting run";
+  PRX_LOG(INFO) << "Starting run";
   eventBase_.loop();
   uint32_t holBlockCount = 0;
   for (auto& scheme : domains_) {
     holBlockCount += scheme.second->getHolBlockCount();
   }
-  LOG(INFO) << "Complete"
-            << "\nStats:"
-               "\nSeed: "
-            << params_.seed << "\nBlocks sent: " << requests_.size()
-            << "\nAllowed OOO: " << stats_.allowedOOO
-            << "\nPackets: " << stats_.packets
-            << "\nPacket Losses: " << stats_.packetLosses
-            << "\nHOL Block Count: " << holBlockCount
-            << "\nHOL Delay (ms): " << stats_.holDelay.count()
-            << "\nMax Queue Buffer Bytes: " << stats_.maxQueueBufferBytes
-            << "\nUncompressed Bytes: " << stats_.uncompressed
-            << "\nCompressed Bytes: " << stats_.compressed
-            << "\nCompression Ratio: "
-            << int(100 - double(100 * stats_.compressed) / stats_.uncompressed);
+  PRX_LOG(INFO)
+      << "Complete"
+      << "\nStats:"
+         "\nSeed: "
+      << params_.seed << "\nBlocks sent: " << requests_.size()
+      << "\nAllowed OOO: " << stats_.allowedOOO
+      << "\nPackets: " << stats_.packets
+      << "\nPacket Losses: " << stats_.packetLosses
+      << "\nHOL Block Count: " << holBlockCount
+      << "\nHOL Delay (ms): " << stats_.holDelay.count()
+      << "\nMax Queue Buffer Bytes: " << stats_.maxQueueBufferBytes
+      << "\nUncompressed Bytes: " << stats_.uncompressed
+      << "\nCompressed Bytes: " << stats_.compressed << "\nCompression Ratio: "
+      << int(100 - double(100 * stats_.compressed) / stats_.uncompressed);
 }
 
 void CompressionSimulator::flushRequests(CompressionScheme* scheme) {
-  VLOG(5) << "schedule encode for " << scheme->packetIndices.size()
-          << " blocks at " << scheme->prev.count();
+  PRX_VLOG(5) << "schedule encode for " << scheme->packetIndices.size()
+              << " blocks at " << scheme->prev.count();
   // Flush previous train
   scheduleEvent(
       [this, scheme, indices = std::move(scheme->packetIndices)]() mutable {
@@ -149,12 +150,12 @@ void CompressionSimulator::setupRequest(uint16_t index,
   auto decodeCompleteCB =
       [index, this, scheme](std::chrono::milliseconds holDelay) {
         // record processed timestamp
-        CHECK(!callbacks_[index].getResult().hasError());
-        DCHECK_EQ(requests_[index], *callbacks_[index].getResult().value());
+        PRX_CHECK(!callbacks_[index].getResult().hasError());
+        PRX_DCHECK_EQ(requests_[index], *callbacks_[index].getResult().value());
         stats_.holDelay += holDelay;
-        VLOG(1) << "Finished decoding request=" << index
-                << " with holDelay=" << holDelay.count()
-                << " cumulative HoL delay=" << stats_.holDelay.count();
+        PRX_VLOG(1) << "Finished decoding request=" << index
+                    << " with holDelay=" << holDelay.count()
+                    << " cumulative HoL delay=" << stats_.holDelay.count();
         if (callbacks_[index].acknowledge) {
           sendAck(scheme, scheme->getAck(callbacks_[index].seqn));
         }
@@ -167,7 +168,8 @@ void CompressionSimulator::setupRequest(uint16_t index,
   // start such trains.
   if (scheme->packetIndices.size() > 0) {
     auto delayFromPrevious = encodeDelay - scheme->prev;
-    VLOG(1) << "request " << index << " delay " << delayFromPrevious.count();
+    PRX_VLOG(1) << "request " << index << " delay "
+                << delayFromPrevious.count();
     if (delayFromPrevious > std::chrono::milliseconds(1)) {
       flushRequests(scheme);
     }
@@ -188,8 +190,8 @@ void CompressionSimulator::flushPacket(CompressionScheme* scheme) {
   }
 
   stats_.packets++;
-  VLOG(1) << "schedule decode for " << scheme->packetBlocks.size()
-          << " blocks at " << scheme->decodeDelay.count();
+  PRX_VLOG(1) << "schedule decode for " << scheme->packetBlocks.size()
+              << " blocks at " << scheme->decodeDelay.count();
   scheduleEvent(
       {[this, scheme, blocks = std::move(scheme->packetBlocks)]() mutable {
         decodePacket(scheme, blocks);
@@ -199,8 +201,8 @@ void CompressionSimulator::flushPacket(CompressionScheme* scheme) {
 }
 
 void CompressionSimulator::flushSchemePackets(CompressionScheme* scheme) {
-  CHECK(!scheme->encodedBlocks.empty());
-  VLOG(2) << "Flushing " << scheme->encodedBlocks.size() << " requests";
+  PRX_CHECK(!scheme->encodedBlocks.empty());
+  PRX_VLOG(2) << "Flushing " << scheme->encodedBlocks.size() << " requests";
   // tracks the number of bytes in the current simulated packet
   auto encodeRes = &scheme->encodedBlocks.front();
   bool newPacket = std::get<1>(*encodeRes);
@@ -216,7 +218,7 @@ void CompressionSimulator::flushSchemePackets(CompressionScheme* scheme) {
     // precondition packetBytes < kMTU
     if (scheme->packetBytes + headerBlockBytesRemaining >= kMTU) {
       // Header block filled current packet, triggering a flush
-      VLOG(2) << "Request(s) spanned multiple packets";
+      PRX_VLOG(2) << "Request(s) spanned multiple packets";
       newPacket = true;
     } else {
       scheme->packetBytes += headerBlockBytesRemaining;
@@ -245,7 +247,7 @@ void CompressionSimulator::flushSchemePackets(CompressionScheme* scheme) {
     }
   }
   flushPacket(scheme);
-  CHECK(scheme->encodedBlocks.empty());
+  PRX_CHECK(scheme->encodedBlocks.empty());
 }
 
 CompressionScheme* CompressionSimulator::getScheme(StringPiece domain) {
@@ -258,7 +260,7 @@ CompressionScheme* CompressionSimulator::getScheme(StringPiece domain) {
   auto it = domains_.find(domain.str());
   CompressionScheme* scheme = nullptr;
   if (it == domains_.end()) {
-    LOG(INFO) << "Creating scheme for domain=" << domain;
+    PRX_LOG(INFO) << "Creating scheme for domain=" << domain;
     auto schemePtr = makeScheme();
     scheme = schemePtr.get();
     domains_.emplace(domain.str(), std::move(schemePtr));
@@ -278,12 +280,12 @@ unique_ptr<CompressionScheme> CompressionSimulator::makeScheme() {
     case SchemeType::HPACK:
       return make_unique<HPACKScheme>(this, params_.tableSize);
   }
-  LOG(FATAL) << "Bad scheme";
+  PRX_LOG(FATAL) << "Bad scheme";
 }
 
 std::pair<FrameFlags, unique_ptr<IOBuf>> CompressionSimulator::encode(
     CompressionScheme* scheme, bool newPacket, uint16_t index) {
-  VLOG(1) << "Start encoding request=" << index;
+  PRX_VLOG(1) << "Start encoding request=" << index;
   // vector to hold cookie crumbs
   vector<string> cookies;
   vector<compress::Header> allHeaders =
@@ -291,13 +293,14 @@ std::pair<FrameFlags, unique_ptr<IOBuf>> CompressionSimulator::encode(
 
   auto before = stats_.uncompressed;
   auto res = scheme->encode(newPacket, std::move(allHeaders), stats_);
-  VLOG(1) << "Encoded request=" << index << " for host="
-          << requests_[index].getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST)
-          << " orig size=" << (stats_.uncompressed - before)
-          << " block size=" << res.second->computeChainDataLength()
-          << " cumulative bytes=" << stats_.compressed
-          << " cumulative compression ratio="
-          << int(100 - double(100 * stats_.compressed) / stats_.uncompressed);
+  PRX_VLOG(1)
+      << "Encoded request=" << index << " for host="
+      << requests_[index].getHeaders().getSingleOrEmpty(HTTP_HEADER_HOST)
+      << " orig size=" << (stats_.uncompressed - before)
+      << " block size=" << res.second->computeChainDataLength()
+      << " cumulative bytes=" << stats_.compressed
+      << " cumulative compression ratio="
+      << int(100 - double(100 * stats_.compressed) / stats_.uncompressed);
   return res;
 }
 
@@ -311,7 +314,7 @@ void CompressionSimulator::decode(CompressionScheme* scheme,
 void CompressionSimulator::decodePacket(
     CompressionScheme* scheme,
     std::list<CompressionScheme::BlockInfo>& blocks) {
-  VLOG(1) << "decode packet with " << blocks.size() << " blocks";
+  PRX_VLOG(1) << "decode packet with " << blocks.size() << " blocks";
   while (!blocks.empty()) {
     auto encodeRes = &blocks.front();
     // TODO(ckrasic) - to get packet coordination correct, could plumb
@@ -353,18 +356,18 @@ std::chrono::milliseconds CompressionSimulator::deliveryDelay() {
   std::chrono::milliseconds delay = one_half_rtt();
   while (loss()) {
     stats_.packetLosses++;
-    scheduleEvent([] { VLOG(4) << "Packet lost!"; }, delay);
+    scheduleEvent([] { PRX_VLOG(4) << "Packet lost!"; }, delay);
     std::chrono::milliseconds rxmit = rxmitDelay();
     delay += rxmit;
     scheduleEvent(
         [rxmit] {
-          VLOG(4) << "Packet loss detected, retransmitting with additional "
-                  << rxmit.count();
+          PRX_VLOG(4) << "Packet loss detected, retransmitting with additional "
+                      << rxmit.count();
         },
         delay - one_half_rtt());
   }
   if (delayed()) {
-    scheduleEvent([] { VLOG(4) << "Packet delayed in network"; }, delay);
+    scheduleEvent([] { PRX_VLOG(4) << "Packet delayed in network"; }, delay);
     delay += extraDelay();
   }
   return delay;
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.cpp b/proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.cpp
index 8a0a287009..3d8c9c357e 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.cpp
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.cpp
@@ -10,6 +10,7 @@
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.h>
 
 #include <proxygen/lib/http/HeaderConstants.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::string;
 using std::vector;
@@ -38,8 +39,8 @@ bool containsAllHeaders(const HTTPHeaders& h1, const HTTPHeaders& h2) {
           verifyCookies = true;
           return;
         }
-        DCHECK(h2HasValue) << "h2 does not contain name=" << name
-                           << " value=" << value1;
+        PRX_DCHECK(h2HasValue)
+            << "h2 does not contain name=" << name << " value=" << value1;
         allValuesPresent &= h2HasValue;
       });
 
@@ -63,10 +64,10 @@ bool containsAllHeaders(const HTTPHeaders& h1, const HTTPHeaders& h2) {
       cookies[i] = combineCookieCrumbsSorted(crumbs);
     }
     if (cookies[0] == cookies[1]) {
-      LOG(INFO) << "Cookie crumbs are reordered";
+      PRX_LOG(INFO) << "Cookie crumbs are reordered";
     } else {
-      LOG(INFO) << "Cookies are not equal: `" << cookies[0] << "' vs. `"
-                << cookies[1] << "'";
+      PRX_LOG(INFO) << "Cookies are not equal: `" << cookies[0] << "' vs. `"
+                    << cookies[1] << "'";
       return false;
     }
   }
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h b/proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h
index ca4e90eb81..4d35384678 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h
@@ -13,6 +13,7 @@
 
 #include <deque>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 #include <tuple>
 
 namespace proxygen {
@@ -66,8 +67,8 @@ class HPACKQueue : public folly::DestructorCheck {
       } else {
         holBlockCount_++;
       }
-      VLOG(5) << "queued block=" << seqn << " len=" << length
-              << " placeholder=" << int32_t(oooOk);
+      PRX_VLOG(5) << "queued block=" << seqn << " len=" << length
+                  << " placeholder=" << int32_t(oooOk);
       queuedBytes_ += length;
       queue_.emplace(it, seqn, std::move(block), length, streamingCb);
     }
@@ -90,7 +91,7 @@ class HPACKQueue : public folly::DestructorCheck {
                    HPACK::StreamingCallback* cb,
                    bool ooo) {
     if (length > 0) {
-      VLOG(5) << "decodeBlock for block=" << seqn << " len=" << length;
+      PRX_VLOG(5) << "decodeBlock for block=" << seqn << " len=" << length;
       folly::io::Cursor c(block.get());
       folly::DestructorCheck::Safety safety(*this);
       codec_.decodeStreaming(c, length, cb);
@@ -115,7 +116,7 @@ class HPACKQueue : public folly::DestructorCheck {
                       false /* in order */)) {
         return;
       }
-      DCHECK_LE(length, queuedBytes_);
+      PRX_DCHECK_LE(length, queuedBytes_);
       queuedBytes_ -= length;
       queue_.pop_front();
     }
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h b/proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h
index ecd04011fe..9619590d84 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/compress/NoPathIndexingStrategy.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionScheme.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::compress {
 
@@ -31,7 +32,7 @@ class HPACKScheme : public CompressionScheme {
   }
 
   ~HPACKScheme() override {
-    CHECK_EQ(serverQueue_.getQueuedBytes(), 0);
+    PRX_CHECK_EQ(serverQueue_.getQueuedBytes(), 0u);
   }
 
   // HPACK has no ACKs
@@ -63,8 +64,8 @@ class HPACKScheme : public CompressionScheme {
     folly::io::Cursor cursor(encodedReq.get());
     auto seqn = cursor.readBE<uint16_t>();
     callback.seqn = seqn;
-    VLOG(1) << "Decoding request=" << callback.requestIndex
-            << " header seqn=" << seqn;
+    PRX_VLOG(1) << "Decoding request=" << callback.requestIndex
+                << " header seqn=" << seqn;
     auto len = cursor.totalLength();
     encodedReq->trimStart(sizeof(uint16_t));
     serverQueue_.enqueueHeaderBlock(
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/Main.cpp b/proxygen/lib/http/codec/compress/experimental/simulator/Main.cpp
index d17f5e6f60..8cee4d4203 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/Main.cpp
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/Main.cpp
@@ -11,6 +11,7 @@
 
 #include <proxygen/lib/http/codec/compress/HPACKEncoder.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 DEFINE_string(input, "", "File containing requests");
 DEFINE_string(scheme, "qpack", "Scheme: <qpack|qmin|hpack>");
@@ -36,26 +37,26 @@ using namespace proxygen::compress;
 int main(int argc, char* argv[]) {
   const folly::Init init(&argc, &argv, true);
   if (FLAGS_same_packet_compression) {
-    LOG(WARNING) << "Same packet compression no longer supported";
+    PRX_LOG(WARNING) << "Same packet compression no longer supported";
   }
 
   if (FLAGS_input.empty()) {
-    LOG(ERROR) << "Must supply a filename";
+    PRX_LOG(ERROR) << "Must supply a filename";
     return 1;
   }
 
   SchemeType t = SchemeType::QPACK;
   if (FLAGS_scheme == "qpack") {
-    LOG(INFO) << "Using QPACK";
+    PRX_LOG(INFO) << "Using QPACK";
     t = SchemeType::QPACK;
   } else if (FLAGS_scheme == "qmin") {
-    LOG(INFO) << "Using QMIN";
+    PRX_LOG(INFO) << "Using QMIN";
     t = SchemeType::QMIN;
   } else if (FLAGS_scheme == "hpack") {
-    LOG(INFO) << "Using HPACK with table size=" << FLAGS_table_size;
+    PRX_LOG(INFO) << "Using HPACK with table size=" << FLAGS_table_size;
     t = SchemeType::HPACK;
   } else {
-    LOG(ERROR) << "Unsupported scheme";
+    PRX_LOG(ERROR) << "Unsupported scheme";
     return 1;
   }
 
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/QMINScheme.h b/proxygen/lib/http/codec/compress/experimental/simulator/QMINScheme.h
index 2aa5905a91..f79b661d08 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/QMINScheme.h
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/QMINScheme.h
@@ -19,6 +19,7 @@
 #include "qmin_common.h" // @manual
 #include "qmin_dec.h"    // @manual
 #include "qmin_enc.h"    // @manual
+#include <proxygen/lib/utils/LogShim.h>
 #else
 /* Stub implementation for when you don't have QMIN */
 extern "C" {
@@ -204,8 +205,9 @@ class QMINScheme : public CompressionScheme {
     if (qms_ctl[1].sz) {
       auto ack = std::make_unique<QMINAck>(
           qms_ctl[1].write_off, qms_ctl[1].buf, qms_ctl[1].sz);
-      VLOG(4) << "sent ACK for instance " << qms_idstr
-              << " off: " << qms_ctl[1].write_off << "; sz: " << qms_ctl[1].sz;
+      PRX_VLOG(4) << "sent ACK for instance " << qms_idstr
+                  << " off: " << qms_ctl[1].write_off
+                  << "; sz: " << qms_ctl[1].sz;
       qms_ctl[1].write_off += qms_ctl[1].sz;
       qms_ctl[1].sz = 0;
       return std::move(ack);
@@ -218,12 +220,12 @@ class QMINScheme : public CompressionScheme {
   void recvAck(std::unique_ptr<Ack> generic_ack) override {
     struct stream_chunk *chunk = nullptr;
 
-    CHECK(generic_ack);
+    PRX_CHECK(generic_ack);
     auto ack = dynamic_cast<QMINAck *>(generic_ack.get());
-    CHECK_NOTNULL(ack);
+    PRX_CHECK_NOTNULL(ack);
 
-    VLOG(4) << "received ACK for instance " << qms_idstr
-            << " off: " << ack->qma_off << "; sz: " << ack->qma_sz;
+    PRX_VLOG(4) << "received ACK for instance " << qms_idstr
+                << " off: " << ack->qma_off << "; sz: " << ack->qma_sz;
 
     chunk = stream_chunk_new(ack->qma_off, ack->qma_buf, ack->qma_sz);
     insert_chunk(&qms_streams[0], chunk);
@@ -231,7 +233,7 @@ class QMINScheme : public CompressionScheme {
     while ((chunk = maybe_pop_chunk(&qms_streams[0]))) {
       ssize_t nread = qmin_enc_cmds_in(qms_enc, chunk->sc_buf, chunk->sc_sz);
       if (nread < 0 || (size_t)nread != chunk->sc_sz) {
-        VLOG(1) << "error: qmin_enc_cmds_in failed";
+        PRX_VLOG(1) << "error: qmin_enc_cmds_in failed";
         assert(0);
       }
       free(chunk);
@@ -275,11 +277,11 @@ class QMINScheme : public CompressionScheme {
           comp_sz += nw;
           break;
         case QES_NOBUFS:
-          VLOG(1) << "compressed header does not fit into temporary "
-                     "output buffer";
+          PRX_VLOG(1) << "compressed header does not fit into temporary "
+                         "output buffer";
           return {flags, nullptr};
         case QES_ERR:
-          VLOG(1) << "error: " << strerror(errno);
+          PRX_VLOG(1) << "error: " << strerror(errno);
           assert(0);
           return {flags, nullptr};
       }
@@ -288,12 +290,12 @@ class QMINScheme : public CompressionScheme {
     {
       size_t sz = 0;
       char *state = qmin_enc_to_str(qms_enc, &sz);
-      VLOG(4) << "encoder state: " << state;
+      PRX_VLOG(4) << "encoder state: " << state;
       free(state);
     }
 
     if (0 != qmin_enc_end_stream_headers(qms_enc)) {
-      VLOG(1) << "error: qmin_enc_end_stream_headers failed";
+      PRX_VLOG(1) << "error: qmin_enc_end_stream_headers failed";
       assert(0);
     }
 
@@ -371,7 +373,7 @@ class QMINScheme : public CompressionScheme {
       while ((chunk = maybe_pop_chunk(&qms_streams[1]))) {
         nread = qmin_dec_cmds_in(qms_dec, chunk->sc_buf, chunk->sc_sz);
         if (nread < 0 || (size_t)nread != chunk->sc_sz) {
-          VLOG(1) << "error: qmin_dec_cmds_in failed";
+          PRX_VLOG(1) << "error: qmin_dec_cmds_in failed";
           assert(0);
         }
         free(chunk);
@@ -385,7 +387,7 @@ class QMINScheme : public CompressionScheme {
       nread = qmin_dec_decode(
           qms_dec, buf, end - buf, outbuf, sizeof(outbuf), &name_len, &val_len);
       if (nread < 0) {
-        VLOG(1) << "error: decoder failed!";
+        PRX_VLOG(1) << "error: decoder failed!";
         assert(0);
         return;
       }
@@ -399,7 +401,7 @@ class QMINScheme : public CompressionScheme {
 
     if (0 != qmin_dec_stream_done(qms_dec, stream_id)) {
       assert(0);
-      VLOG(1) << "error: qmin_dec_stream_done failed";
+      PRX_VLOG(1) << "error: qmin_dec_stream_done failed";
     }
 
     proxygen::HTTPHeaderSize sz;
@@ -420,13 +422,13 @@ class QMINScheme : public CompressionScheme {
     size_t avail = sizeof(qms_ctl[idx].buf) - qms_ctl[idx].sz;
     assert(avail >= sz);
     if (avail < sz) {
-      VLOG(1) << "Truncating control message from " << sz << " to " << avail
-              << "bytes";
+      PRX_VLOG(1) << "Truncating control message from " << sz << " to " << avail
+                  << "bytes";
       sz = avail;
     }
     memcpy(qms_ctl[idx].buf + qms_ctl[idx].sz, buf, sz);
     qms_ctl[idx].sz += sz;
-    VLOG(4) << "Wrote " << sz << " bytes to control channel";
+    PRX_VLOG(4) << "Wrote " << sz << " bytes to control channel";
   }
 
   static void write_enc2dec(void *ctx, const void *buf, size_t sz) {
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h b/proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h
index a5a36698f5..d283c3aec5 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/codec/compress/NoPathIndexingStrategy.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
 #include <proxygen/lib/http/codec/compress/experimental/simulator/CompressionScheme.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::compress {
 
@@ -29,7 +30,7 @@ class QPACKScheme : public CompressionScheme {
   }
 
   ~QPACKScheme() override {
-    CHECK_EQ(server_.getQueuedBytes(), 0);
+    PRX_CHECK_EQ(server_.getQueuedBytes(), 0u);
   }
 
   struct QPACKAck : public CompressionScheme::Ack {
@@ -49,7 +50,7 @@ class QPACKScheme : public CompressionScheme {
   };
 
   std::unique_ptr<Ack> getAck(uint16_t seqn) override {
-    VLOG(4) << "Sending ack for seqn=" << seqn;
+    PRX_VLOG(4) << "Sending ack for seqn=" << seqn;
     auto res = std::make_unique<QPACKAck>(seqn,
                                           sendAck_++,
                                           server_.encodeHeaderAck(seqn),
@@ -57,11 +58,11 @@ class QPACKScheme : public CompressionScheme {
     return std::move(res);
   }
   void recvAck(std::unique_ptr<Ack> ack) override {
-    CHECK(ack);
+    PRX_CHECK(ack);
     auto qpackAck = dynamic_cast<QPACKAck*>(ack.get());
-    CHECK_NOTNULL(qpackAck);
-    VLOG(4) << "Received ack for seqn=" << qpackAck->seqn;
-    CHECK(qpackAck->headerAck);
+    PRX_CHECK_NOTNULL(qpackAck);
+    PRX_VLOG(4) << "Received ack for seqn=" << qpackAck->seqn;
+    PRX_CHECK(qpackAck->headerAck);
     if (qpackAck->controlAck) {
       qpackAck->headerAck->prependChain(std::move(qpackAck->controlAck));
     }
@@ -72,8 +73,8 @@ class QPACKScheme : public CompressionScheme {
       if (it->first != recvAck_) {
         break;
       }
-      CHECK_EQ(client_.decodeDecoderStream(std::move(it->second)),
-               HPACK::DecodeError::NONE);
+      PRX_CHECK_EQ(client_.decodeDecoderStream(std::move(it->second)),
+                   HPACK::DecodeError::NONE);
       recvAck_++;
       acks_.erase(it);
     } while (!acks_.empty());
@@ -90,7 +91,7 @@ class QPACKScheme : public CompressionScheme {
     static const uint32_t growth = 1400; // chosen arbitrarily
     folly::io::QueueAppender cursor(&queue, growth);
     if (result.control) {
-      VLOG(5) << "Writing encodeControlIndex_=" << encodeControlIndex_;
+      PRX_VLOG(5) << "Writing encodeControlIndex_=" << encodeControlIndex_;
       len = result.control->computeChainDataLength();
       cursor.writeBE<uint16_t>(len);
       cursor.writeBE<uint16_t>(encodeControlIndex_++);
@@ -128,13 +129,13 @@ class QPACKScheme : public CompressionScheme {
       cursor.clone(control, len);
       if (controlIndex == decodeControlIndex_) {
         // next expected control block, decode
-        VLOG(5) << "decode controlIndex=" << controlIndex;
+        PRX_VLOG(5) << "decode controlIndex=" << controlIndex;
         server_.decodeEncoderStream(std::move(control));
         decodeControlIndex_++;
         while (!controlQueue_.empty() &&
                controlQueue_.begin()->first == decodeControlIndex_) {
           // drain the queue
-          VLOG(5) << "decode controlIndex=" << controlQueue_.begin()->first;
+          PRX_VLOG(5) << "decode controlIndex=" << controlQueue_.begin()->first;
           auto it = controlQueue_.begin();
           server_.decodeEncoderStream(std::move(it->second));
           decodeControlIndex_++;
@@ -148,9 +149,9 @@ class QPACKScheme : public CompressionScheme {
     }
     auto seqn = cursor.readBE<uint16_t>();
     callback.seqn = seqn;
-    VLOG(1) << "Decoding request=" << callback.requestIndex
-            << " header seqn=" << seqn
-            << " allowOOO=" << uint32_t(flags.allowOOO);
+    PRX_VLOG(1) << "Decoding request=" << callback.requestIndex
+                << " header seqn=" << seqn
+                << " allowOOO=" << uint32_t(flags.allowOOO);
     len = cursor.readBE<uint16_t>();
     folly::IOBufQueue queue;
     queue.append(std::move(encodedReq));
diff --git a/proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h b/proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h
index 53c7757204..9f58bf450b 100644
--- a/proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h
+++ b/proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/HeaderConstants.h>
 #include <proxygen/lib/http/codec/compress/HPACKStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::compress {
 class SimStreamingCallback : public HPACK::StreamingCallback {
@@ -48,7 +49,7 @@ class SimStreamingCallback : public HPACK::StreamingCallback {
       } else if (name == headers::kStatus) {
         msg.setStatusCode(folly::to<uint16_t>(value.toStdString()));
       } else {
-        DCHECK(false) << "Bad header name=" << name << " value=" << value;
+        PRX_DCHECK(false) << "Bad header name=" << name << " value=" << value;
       }
     } else {
       msg.getHeaders().add(name, value.toStdString());
@@ -73,7 +74,7 @@ class SimStreamingCallback : public HPACK::StreamingCallback {
 
   void onDecodeError(HPACK::DecodeError decodeError) override {
     error = decodeError;
-    DCHECK(false) << "Unexpected error in simulator";
+    PRX_DCHECK(false) << "Unexpected error in simulator";
   }
 
   folly::Expected<proxygen::HTTPMessage*, HPACK::DecodeError> getResult() {
diff --git a/proxygen/lib/http/codec/compress/test/EncoderBenchmark.cpp b/proxygen/lib/http/codec/compress/test/EncoderBenchmark.cpp
index 13f1abb8fb..41c2e8b15f 100644
--- a/proxygen/lib/http/codec/compress/test/EncoderBenchmark.cpp
+++ b/proxygen/lib/http/codec/compress/test/EncoderBenchmark.cpp
@@ -11,6 +11,7 @@
 #include <iostream>
 #include <proxygen/lib/http/HTTPHeaders.h>
 #include <proxygen/lib/http/codec/compress/HPACKEncoder.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <string>
 
 using namespace proxygen;
@@ -24,12 +25,12 @@ const HTTPHeaders& getHeaders() {
 
       std::vector<folly::StringPiece> pieces;
       folly::split(' ', line, pieces);
-      CHECK_EQ(pieces[3][0], 'n');
+      PRX_CHECK_EQ(pieces[3][0], 'n');
       std::string name(pieces[3].begin() + 2, pieces[3].size() - 2);
       auto valueOff = pieces[3].end() + 1 - line.data();
       folly::StringPiece valuePiece(line.data() + valueOff,
                                     line.size() - valueOff);
-      CHECK_EQ(valuePiece[0], 'v');
+      PRX_CHECK_EQ(valuePiece[0], 'v');
       std::string value(valuePiece.begin() + 2, valuePiece.size() - 2);
       headers.add(name, value);
     }
@@ -70,7 +71,7 @@ void encoderBenchmark(uint32_t iters, bool huffman, uint32_t tableSize) {
     compressed += writeBuf.chainLength();
     encoder.completeEncode();
   }
-  LOG(INFO) << "compressed=" << compressed / iters;
+  PRX_LOG(INFO) << "compressed=" << compressed / iters;
 }
 
 BENCHMARK(EncoderHuffman4096, iters) {
diff --git a/proxygen/lib/http/codec/compress/test/HPACKBenchmark.cpp b/proxygen/lib/http/codec/compress/test/HPACKBenchmark.cpp
index c054c9a471..a997e11494 100644
--- a/proxygen/lib/http/codec/compress/test/HPACKBenchmark.cpp
+++ b/proxygen/lib/http/codec/compress/test/HPACKBenchmark.cpp
@@ -10,6 +10,7 @@
 #include <folly/Range.h>
 #include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/test/TestUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace std;
 using namespace folly;
@@ -24,11 +25,11 @@ void encodeDecode(vector<HPACKHeader>& headers,
                   HPACKEncoder& encoder,
                   HPACKDecoder& decoder) {
   unique_ptr<IOBuf> encoded = encode(headers, encoder);
-  CHECK(encoded);
+  PRX_CHECK(encoded);
   TestStreamingCallback cb;
   folly::io::Cursor c(encoded.get());
   decoder.decodeStreaming(c, c.totalLength(), &cb);
-  CHECK(!cb.hasError());
+  PRX_CHECK(!cb.hasError());
 }
 
 vector<HPACKHeader> getHeaders() {
diff --git a/proxygen/lib/http/codec/compress/test/HPACKBufferTests.cpp b/proxygen/lib/http/codec/compress/test/HPACKBufferTests.cpp
index 7d13714c0b..d840d6591a 100644
--- a/proxygen/lib/http/codec/compress/test/HPACKBufferTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HPACKBufferTests.cpp
@@ -12,6 +12,7 @@
 #include <memory>
 #include <proxygen/lib/http/codec/compress/HPACKDecodeBuffer.h>
 #include <proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly::io;
 using namespace folly;
@@ -144,24 +145,24 @@ TEST_F(HPACKBufferTests, DecodeSingleByte) {
   *wdata = 67;
   resetDecoder();
   uint64_t integer;
-  CHECK_EQ(decoder_.decodeInteger(7, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 67);
+  PRX_CHECK_EQ(decoder_.decodeInteger(7, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 67u);
 
   resetDecoder();
 
-  CHECK_EQ(decoder_.decodeInteger(6, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 3);
+  PRX_CHECK_EQ(decoder_.decodeInteger(6, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 3u);
 
   // set a bit in the prefix - it should not affect the decoded value
   *wdata = 195; // 195 = 128 + 67
   resetDecoder();
-  CHECK_EQ(decoder_.decodeInteger(7, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 67);
+  PRX_CHECK_EQ(decoder_.decodeInteger(7, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 67u);
 
   // 8-bit prefix - the entire byte
   resetDecoder();
-  CHECK_EQ(decoder_.decodeInteger(8, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 195);
+  PRX_CHECK_EQ(decoder_.decodeInteger(8, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 195u);
 }
 
 TEST_F(HPACKBufferTests, DecodeMultiByte) {
@@ -173,33 +174,33 @@ TEST_F(HPACKBufferTests, DecodeMultiByte) {
   wdata[1] = 0;
   resetDecoder();
   uint64_t integer;
-  CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 3);
-  CHECK_EQ(decoder_.cursor().length(), 0);
+  PRX_CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 3u);
+  PRX_CHECK_EQ(decoder_.cursor().length(), 0u);
   // edge case - encode 130 = 127 + 3 on 2-bit prefix
   wdata[0] = 3;
   wdata[1] = 127;
   resetDecoder();
-  CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 130);
-  CHECK_EQ(decoder_.cursor().length(), 0);
+  PRX_CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 130u);
+  PRX_CHECK_EQ(decoder_.cursor().length(), 0u);
   // edge case - encode 131 = 128 + 3
   buf_->append(1);
   wdata[0] = 3;
   wdata[1] = 128;
   wdata[2] = 1;
   resetDecoder();
-  CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 131);
-  CHECK_EQ(decoder_.cursor().length(), 0);
+  PRX_CHECK_EQ(decoder_.decodeInteger(2, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 131u);
+  PRX_CHECK_EQ(decoder_.cursor().length(), 0u);
   // encode the value from the RFC example - 1337
   wdata[0] = 31;
   wdata[1] = 154;
   wdata[2] = 10;
   resetDecoder();
-  CHECK_EQ(decoder_.decodeInteger(5, integer), DecodeError::NONE);
-  CHECK_EQ(integer, 1337);
-  CHECK_EQ(decoder_.cursor().length(), 0);
+  PRX_CHECK_EQ(decoder_.decodeInteger(5, integer), DecodeError::NONE);
+  PRX_CHECK_EQ(integer, 1337u);
+  PRX_CHECK_EQ(decoder_.cursor().length(), 0u);
 }
 
 TEST_F(HPACKBufferTests, DecodeIntegerError) {
@@ -207,7 +208,8 @@ TEST_F(HPACKBufferTests, DecodeIntegerError) {
   resetDecoder();
   // empty buffer
   uint64_t integer;
-  CHECK_EQ(decoder_.decodeInteger(5, integer), DecodeError::BUFFER_UNDERFLOW);
+  PRX_CHECK_EQ(decoder_.decodeInteger(5, integer),
+               DecodeError::BUFFER_UNDERFLOW);
 
   // incomplete buffer
   buf_->append(2);
@@ -215,7 +217,8 @@ TEST_F(HPACKBufferTests, DecodeIntegerError) {
   wdata[0] = 31;
   wdata[1] = 154;
   // wdata[2] = 10 missing
-  CHECK_EQ(decoder_.decodeInteger(5, integer), DecodeError::BUFFER_UNDERFLOW);
+  PRX_CHECK_EQ(decoder_.decodeInteger(5, integer),
+               DecodeError::BUFFER_UNDERFLOW);
 }
 
 TEST_F(HPACKBufferTests, DecodeLiteralError) {
@@ -228,7 +231,7 @@ TEST_F(HPACKBufferTests, DecodeLiteralError) {
   wdata[1] = 'a';
   wdata[2] = 'b';
   folly::fbstring literal;
-  CHECK_EQ(decoder_.decodeLiteral(literal), DecodeError::BUFFER_UNDERFLOW);
+  PRX_CHECK_EQ(decoder_.decodeLiteral(literal), DecodeError::BUFFER_UNDERFLOW);
 
   resetDecoder();
   // error decoding the size of the literal
@@ -336,7 +339,7 @@ TEST_F(HPACKBufferTests, DecodePlainLiteral) {
 
   resetDecoder();
   decoder_.decodeLiteral(literal);
-  CHECK_EQ(literal, gzip);
+  PRX_CHECK_EQ(literal, gzip);
 }
 
 TEST_F(HPACKBufferTests, DecodePlainLiteralN) {
@@ -351,7 +354,7 @@ TEST_F(HPACKBufferTests, DecodePlainLiteralN) {
 
   resetDecoder();
   decoder_.decodeLiteral(4, literal);
-  CHECK_EQ(literal, gzip);
+  PRX_CHECK_EQ(literal, gzip);
 }
 
 TEST_F(HPACKBufferTests, IntegerEncodeDecode) {
diff --git a/proxygen/lib/http/codec/compress/test/HPACKCodecTests.cpp b/proxygen/lib/http/codec/compress/test/HPACKCodecTests.cpp
index d738aaed94..ee12e1afe6 100644
--- a/proxygen/lib/http/codec/compress/test/HPACKCodecTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HPACKCodecTests.cpp
@@ -10,12 +10,12 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/codec/compress/HPACKCodec.h>
 #include <proxygen/lib/http/codec/compress/Header.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
 #include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/test/TestUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <vector>
 
 using namespace folly::io;
@@ -46,7 +46,7 @@ folly::Expected<DecodeResult, HPACK::DecodeError> decode(
   TestStreamingCallback cb;
   codec.decodeStreaming(cursor, length, &cb);
   if (cb.hasError()) {
-    LOG(ERROR) << "decoder state: " << codec;
+    PRX_LOG(ERROR) << "decoder state: " << codec;
     return folly::makeUnexpected(cb.error);
   }
   return DecodeResult{.headers = std::move(cb.getResult()->headers),
@@ -112,7 +112,7 @@ TEST_F(HPACKCodecTests, LowercasingHeaderNames) {
   auto result = encodeDecode(server, client, headersFromArray(headers));
   EXPECT_TRUE(!result.hasError());
   auto& decoded = result->headers;
-  CHECK_EQ(decoded.size(), 6);
+  PRX_CHECK_EQ(decoded.size(), 6u);
   for (int i = 0; i < 6; i += 2) {
     EXPECT_TRUE(isLowercase(decoded[i].str));
   }
@@ -130,7 +130,7 @@ TEST_F(HPACKCodecTests, MultivalueHeaders) {
   auto result = encodeDecode(server, client, headersFromArray(headers));
   EXPECT_TRUE(!result.hasError());
   auto& decoded = result->headers;
-  CHECK_EQ(decoded.size(), 8);
+  PRX_CHECK_EQ(decoded.size(), 8u);
   uint32_t count = 0;
   for (int i = 0; i < 8; i += 2) {
     if (decoded[i].str == "x-fb-dup") {
@@ -192,7 +192,7 @@ TEST_F(HPACKCodecTests, HeaderCodecStats) {
   auto result = decode(client, cursor, cursor.totalLength());
   EXPECT_TRUE(!result.hasError());
   auto& decoded = result->headers;
-  CHECK_EQ(decoded.size(), 3 * 2);
+  PRX_CHECK_EQ(decoded.size(), 3u * 2);
   EXPECT_EQ(stats.decodes, 1);
   EXPECT_EQ(stats.encodes, 0);
   EXPECT_GT(stats.decodedBytesCompr, 0);
diff --git a/proxygen/lib/http/codec/compress/test/HPACKContextTests.cpp b/proxygen/lib/http/codec/compress/test/HPACKContextTests.cpp
index 7b85b0e31e..d1a4d7b8f5 100644
--- a/proxygen/lib/http/codec/compress/test/HPACKContextTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HPACKContextTests.cpp
@@ -8,7 +8,6 @@
 
 #include <folly/Conv.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
 #include <memory>
 #include <proxygen/lib/http/codec/compress/HPACKContext.h>
 #include <proxygen/lib/http/codec/compress/HPACKDecoder.h>
@@ -17,6 +16,7 @@
 #include <proxygen/lib/http/codec/compress/QPACKDecoder.h>
 #include <proxygen/lib/http/codec/compress/QPACKEncoder.h>
 #include <proxygen/lib/http/codec/compress/test/TestUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -40,7 +40,7 @@ TEST_F(HPACKContextTests, GetIndex) {
   HPACKHeader method(":method", "POST");
 
   // this will get it from the static table
-  CHECK_EQ(context.getIndex(method).first, 3);
+  PRX_CHECK_EQ(context.getIndex(method).first, 3u);
 }
 
 TEST_F(HPACKContextTests, IsStatic) {
@@ -67,10 +67,10 @@ TEST_F(HPACKContextTests, StaticTable) {
   const HPACKHeader& last = table.getHeader(table.size());
 
   // there are 61 entries in the spec
-  CHECK_EQ(table.size(), 61);
-  CHECK_EQ(methodPost, HPACKHeader(":method", "POST"));
-  CHECK_EQ(first.name.get(), ":authority");
-  CHECK_EQ(last.name.get(), "www-authenticate");
+  PRX_CHECK_EQ(table.size(), 61u);
+  PRX_CHECK_EQ(methodPost, HPACKHeader(":method", "POST"));
+  PRX_CHECK_EQ(first.name.get(), ":authority");
+  PRX_CHECK_EQ(last.name.get(), "www-authenticate");
 }
 
 TEST_F(HPACKContextTests, StaticTableHeaderNamesAreCommon) {
@@ -283,8 +283,8 @@ TEST_F(HPACKContextTests, ExcludeHeadersLargerThanTable) {
   HPACKHeader header1(longer, "header");
   HPACKHeader header2("Short", "header");
 
-  CHECK_GT(header1.bytes(), 128);
-  CHECK_LT(header2.bytes(), 128);
+  PRX_CHECK_GT(header1.bytes(), 128u);
+  PRX_CHECK_LT(header2.bytes(), 128u);
 
   vector<HPACKHeader> headers;
   headers.push_back(std::move(header2));
@@ -292,8 +292,8 @@ TEST_F(HPACKContextTests, ExcludeHeadersLargerThanTable) {
 
   encoder.encode(headers);
 
-  CHECK_EQ(encoder.getIndex(headers[1]).first, 0);
-  CHECK_EQ(encoder.getIndex(headers[0]).first, 62);
+  PRX_CHECK_EQ(encoder.getIndex(headers[1]).first, 0u);
+  PRX_CHECK_EQ(encoder.getIndex(headers[0]).first, 62u);
 }
 
 TEST_F(HPACKContextTests, EncodeToWriteBuf) {
diff --git a/proxygen/lib/http/codec/compress/test/HPACKHeaderTests.cpp b/proxygen/lib/http/codec/compress/test/HPACKHeaderTests.cpp
index 95bebde28f..48c01e6019 100644
--- a/proxygen/lib/http/codec/compress/test/HPACKHeaderTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HPACKHeaderTests.cpp
@@ -9,7 +9,7 @@
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/http/codec/compress/HPACKHeader.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h>
 #include <sstream>
@@ -162,14 +162,14 @@ TEST_F(HPACKHeaderNameTest, TestOperators) {
   HPACKHeaderName name2("bbb");
   HPACKHeaderName name3("aaa");
   HPACKHeaderName name4("bbb");
-  CHECK(name1 == name3);
-  CHECK(name1 != name2);
-  CHECK(name1 < name2);
-  CHECK(name2 > name1);
-  CHECK(name1 >= name3);
-  CHECK(name2 >= name1);
-  CHECK(name2 <= name4);
-  CHECK(name1 <= name2);
+  PRX_CHECK(name1 == name3);
+  PRX_CHECK(name1 != name2);
+  PRX_CHECK(name1 < name2);
+  PRX_CHECK(name2 > name1);
+  PRX_CHECK(name1 >= name3);
+  PRX_CHECK(name2 >= name1);
+  PRX_CHECK(name2 <= name4);
+  PRX_CHECK(name1 <= name2);
 }
 
 TEST_F(HPACKHeaderNameTest, TestIsCommonHeader) {
diff --git a/proxygen/lib/http/codec/compress/test/HTTPArchive.cpp b/proxygen/lib/http/codec/compress/test/HTTPArchive.cpp
index 4c8cb59b94..e98e4b1b51 100644
--- a/proxygen/lib/http/codec/compress/test/HTTPArchive.cpp
+++ b/proxygen/lib/http/codec/compress/test/HTTPArchive.cpp
@@ -12,8 +12,8 @@
 #include <folly/io/IOBuf.h>
 #include <folly/json/json.h>
 #include <fstream>
-#include <glog/logging.h>
 #include <ios>
+#include <proxygen/lib/utils/LogShim.h>
 #include <string>
 
 using folly::IOBuf;
@@ -121,13 +121,13 @@ std::unique_ptr<IOBuf> readFileToIOBuf(const std::string& filename) {
   // read the contents of the file
   ifstream file(filename);
   if (!file.is_open()) {
-    LOG(ERROR) << "could not open file '" << filename << "'";
+    PRX_LOG(ERROR) << "could not open file '" << filename << "'";
     return nullptr;
   }
   file.seekg(0, ios::end);
   int64_t size = file.tellg();
   if (size < 0) {
-    LOG(ERROR) << "failed to fetch the position at the end of the file";
+    PRX_LOG(ERROR) << "failed to fetch the position at the end of the file";
     return nullptr;
   }
   file.seekg(0, ios::beg);
@@ -136,8 +136,8 @@ std::unique_ptr<IOBuf> readFileToIOBuf(const std::string& filename) {
   buffer->writableData()[size] = 0;
   buffer->append(size + 1);
   if (!file) {
-    LOG(ERROR) << "error occurred, was able to read only " << file.gcount()
-               << " bytes out of " << size;
+    PRX_LOG(ERROR) << "error occurred, was able to read only " << file.gcount()
+                   << " bytes out of " << size;
     return nullptr;
   }
   return buffer;
diff --git a/proxygen/lib/http/codec/compress/test/HeaderPieceTests.cpp b/proxygen/lib/http/codec/compress/test/HeaderPieceTests.cpp
index 14534ccfca..ceed614edc 100644
--- a/proxygen/lib/http/codec/compress/test/HeaderPieceTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HeaderPieceTests.cpp
@@ -7,8 +7,8 @@
  */
 
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/codec/compress/HeaderPiece.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen::compress;
 
diff --git a/proxygen/lib/http/codec/compress/test/HeaderTableTests.cpp b/proxygen/lib/http/codec/compress/test/HeaderTableTests.cpp
index fcef7570fe..8418dc891d 100644
--- a/proxygen/lib/http/codec/compress/test/HeaderTableTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HeaderTableTests.cpp
@@ -10,6 +10,7 @@
 #include <proxygen/lib/http/codec/compress/HeaderTable.h>
 #include <proxygen/lib/http/codec/compress/Logging.h>
 #include <proxygen/lib/http/codec/compress/QPACKHeaderTable.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <sstream>
 
 using namespace std;
@@ -295,13 +296,13 @@ TEST_F(HeaderTableTests, IncreaseLengthOfFullTable) {
   HPACKHeader smallHeader("Accept", "All-Content");
 
   HeaderTable table(448);
-  CHECK_EQ(table.length(), 7);
+  PRX_CHECK_EQ(table.length(), 7u);
 
   for (uint8_t count = 0; count < 3; count++) {
     table.add(largeHeader.copy());
     table.add(smallHeader.copy());
   } // tail is at index 0
-  CHECK_EQ(table.length(), 7);
+  PRX_CHECK_EQ(table.length(), 7u);
 
   table.add(smallHeader.copy());
   table.add(smallHeader.copy()); // tail is at index 1
@@ -309,14 +310,14 @@ TEST_F(HeaderTableTests, IncreaseLengthOfFullTable) {
   EXPECT_EQ(table.length(), 11);
 
   // Check table is correct after resize
-  CHECK_EQ(table.getHeader(1), smallHeader);
-  CHECK_EQ(table.getHeader(2), smallHeader);
-  CHECK_EQ(table.getHeader(3), smallHeader);
-  CHECK_EQ(table.getHeader(4), smallHeader);
-  CHECK_EQ(table.getHeader(5), largeHeader);
-  CHECK_EQ(table.getHeader(6), smallHeader);
-  CHECK_EQ(table.getHeader(7), largeHeader);
-  CHECK_EQ(table.getHeader(8), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(1), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(2), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(3), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(4), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(5), largeHeader);
+  PRX_CHECK_EQ(table.getHeader(6), smallHeader);
+  PRX_CHECK_EQ(table.getHeader(7), largeHeader);
+  PRX_CHECK_EQ(table.getHeader(8), smallHeader);
 }
 
 TEST_F(HeaderTableTests, SmallTable) {
diff --git a/proxygen/lib/http/codec/compress/test/HuffmanTests.cpp b/proxygen/lib/http/codec/compress/test/HuffmanTests.cpp
index b64e063f01..f181f3435e 100644
--- a/proxygen/lib/http/codec/compress/test/HuffmanTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/HuffmanTests.cpp
@@ -14,6 +14,7 @@
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/http/codec/compress/Huffman.h>
 #include <proxygen/lib/http/codec/compress/Logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly::io;
 using namespace folly;
@@ -137,7 +138,7 @@ TEST_F(HuffmanTests, ExampleCom) {
 
   folly::fbstring decoded;
   tree_.decode(bufQueue.front()->data(), size, decoded);
-  CHECK_EQ(example, decoded);
+  PRX_CHECK_EQ(example, decoded);
 }
 
 TEST_F(HuffmanTests, UserAgent) {
@@ -159,7 +160,7 @@ TEST_F(HuffmanTests, UserAgent) {
 
   folly::fbstring decoded;
   tree.decode(bufQueue.front()->data(), size, decoded);
-  CHECK_EQ(user_agent, decoded);
+  PRX_CHECK_EQ(user_agent, decoded);
 }
 
 /*
@@ -178,7 +179,7 @@ TEST_F(HuffmanTests, FitInBuffer) {
   appender.append(appender.length() - 1);
   literal = "g";
   tree_.encode(literal, appender);
-  CHECK_EQ(appender.length(), 0);
+  PRX_CHECK_EQ(appender.length(), 0u);
 }
 
 /*
diff --git a/proxygen/lib/http/codec/compress/test/QPACKCodecTests.cpp b/proxygen/lib/http/codec/compress/test/QPACKCodecTests.cpp
index 3cf034973f..37104b5ba7 100644
--- a/proxygen/lib/http/codec/compress/test/QPACKCodecTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/QPACKCodecTests.cpp
@@ -10,12 +10,12 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/codec/compress/Header.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
 #include <proxygen/lib/http/codec/compress/QPACKCodec.h>
 #include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/test/TestUtil.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <vector>
 
 using namespace folly;
@@ -106,8 +106,8 @@ TEST_F(QPACKTests, TestAbsoluteIndex) {
       EXPECT_EQ(encodeResult.control.get(), nullptr);
     } else {
       ASSERT_NE(encodeResult.control.get(), nullptr);
-      CHECK_EQ(server.decodeEncoderStream(std::move(encodeResult.control)),
-               HPACK::DecodeError::NONE);
+      PRX_CHECK_EQ(server.decodeEncoderStream(std::move(encodeResult.control)),
+                   HPACK::DecodeError::NONE);
     }
     TestStreamingCallback cb;
     auto length = encodeResult.stream->computeChainDataLength();
@@ -143,7 +143,7 @@ TEST_F(QPACKTests, TestWithQueue) {
         reqI.emplace_back(HTTP_HEADER_CONNECTION,
                           values[std::max(f * 4 + i - j * 8, 0)]);
       }
-      VLOG(4) << "Encoding req=" << f * 4 + i;
+      PRX_VLOG(4) << "Encoding req=" << f * 4 + i;
       auto res = client.encode(reqI, f * 4 + i);
       if (res.control && res.control->computeChainDataLength() > 0) {
         controlFrames.emplace_back(std::move(res.control));
@@ -180,7 +180,7 @@ TEST_F(QPACKTests, TestWithQueue) {
       headerAck(f * 4 + i);
       i++;
     }
-    VLOG(4) << "getHolBlockCount=" << server.getHolBlockCount();
+    PRX_VLOG(4) << "getHolBlockCount=" << server.getHolBlockCount();
   }
   // Skipping redundant table adds reduces the HOL block count
   EXPECT_EQ(server.getHolBlockCount(), 30);
@@ -220,7 +220,7 @@ TEST_F(QPACKTests, HeaderCodecStats) {
   auto result = cb.getResult();
   EXPECT_TRUE(!result.hasError());
   auto& decoded = result->headers;
-  CHECK_EQ(decoded.size(), 3 * 2);
+  PRX_CHECK_EQ(decoded.size(), 3u * 2);
   EXPECT_EQ(stats.decodes, 1);
   EXPECT_EQ(stats.encodes, 0);
   EXPECT_GT(stats.decodedBytesCompr, 0);
diff --git a/proxygen/lib/http/codec/compress/test/QPACKContextTests.cpp b/proxygen/lib/http/codec/compress/test/QPACKContextTests.cpp
index fdf3c7639e..120777265f 100644
--- a/proxygen/lib/http/codec/compress/test/QPACKContextTests.cpp
+++ b/proxygen/lib/http/codec/compress/test/QPACKContextTests.cpp
@@ -9,14 +9,13 @@
 #include <folly/Conv.h>
 #include <folly/Format.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
-#include <limits>
 #include <memory>
 #include <proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h>
 #include <proxygen/lib/http/codec/compress/Logging.h>
 #include <proxygen/lib/http/codec/compress/QPACKDecoder.h>
 #include <proxygen/lib/http/codec/compress/QPACKEncoder.h>
 #include <proxygen/lib/http/codec/compress/test/TestStreamingCallback.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -75,7 +74,7 @@ HPACK::DecodeError cancelStream(QPACKDecoder& decoder,
 }
 
 std::string toFixedLengthString(uint32_t i) {
-  CHECK_LT(i, 1000);
+  PRX_CHECK_LT(i, 1000u);
   return fmt::format("{:3}", i);
 }
 } // namespace
@@ -753,8 +752,8 @@ TEST(QPACKContextTests, WrapRICBehind) {
     if (decoderIC > 0) {
       // add one more header to decoder
       vector<HPACKHeader> req;
-      VLOG(5) << "priming decoder with h=" << decoderIC
-              << " decoderIC=" << decoderIC;
+      PRX_VLOG(5) << "priming decoder with h=" << decoderIC
+                  << " decoderIC=" << decoderIC;
       req.emplace_back(toFixedLengthString(decoderIC), "");
       auto result = encoder.encode(req, 10, 1);
       EXPECT_NE(result.control, nullptr)
@@ -767,8 +766,8 @@ TEST(QPACKContextTests, WrapRICBehind) {
              std::max<int64_t>(0, int64_t(decoderIC) - realMaxEntries + 1);
          requiredIC <= decoderIC;
          requiredIC++) {
-      VLOG(5) << "WrapRIC test decoderIC=" << decoderIC
-              << " requiredIC=" << requiredIC;
+      PRX_VLOG(5) << "WrapRIC test decoderIC=" << decoderIC
+                  << " requiredIC=" << requiredIC;
 
       // Now send encode a request for the given RIC.
       vector<HPACKHeader> req;
@@ -778,8 +777,8 @@ TEST(QPACKContextTests, WrapRICBehind) {
         req.emplace_back(":scheme", "https");
       }
       auto result = encoder.encode(req, 10, 2);
-      EXPECT_EQ(result.control, nullptr);                   // no inserts
-      CHECK_EQ(result.stream->computeChainDataLength(), 3); // prefix + 1
+      EXPECT_EQ(result.control, nullptr);                        // no inserts
+      PRX_CHECK_EQ(result.stream->computeChainDataLength(), 3u); // prefix + 1
       // the decoder should be able to immediately decode it
       EXPECT_TRUE(*verifyDecode(decoder, std::move(result), req));
       encoder.decodeDecoderStream(decoder.encodeHeaderAck(2));
@@ -799,7 +798,7 @@ TEST(QPACKContextTests, WrapRICAhead) {
   // bytes.  Each loop of decoderIC is expensive, so start it at maxEntries,
   // and only run it until it actually would have made a difference in
   // the encoded size of required IC.
-  CHECK_LE(realMaxEntries, 256);
+  PRX_CHECK_LE(realMaxEntries, 256u);
   for (uint32_t decoderIC = maxEntries; decoderIC < (256 - realMaxEntries);
        decoderIC++) {
     QPACKEncoder encoder(true, tableSize);
@@ -810,7 +809,8 @@ TEST(QPACKContextTests, WrapRICAhead) {
     for (uint32_t i = 1; i <= decoderIC; i++) {
       vector<HPACKHeader> req;
       // populate the encoder and decode table to decoderIC.
-      VLOG(5) << "priming decoder with h=" << i << " decoderIC=" << decoderIC;
+      PRX_VLOG(5) << "priming decoder with h=" << i
+                  << " decoderIC=" << decoderIC;
       req.emplace_back(toFixedLengthString(i), "");
       auto result = encoder.encode(req, 10, 1);
       EXPECT_NE(result.control, nullptr)
@@ -828,8 +828,8 @@ TEST(QPACKContextTests, WrapRICAhead) {
     for (auto requiredIC = decoderIC + 1;
          requiredIC <= decoderIC + realMaxEntries;
          requiredIC++) {
-      VLOG(5) << "WrapRIC test decoderIC=" << decoderIC
-              << " requiredIC=" << requiredIC;
+      PRX_VLOG(5) << "WrapRIC test decoderIC=" << decoderIC
+                  << " requiredIC=" << requiredIC;
       reqs.emplace_back();
       auto& req = reqs.back();
       req.emplace_back(toFixedLengthString(requiredIC), "");
@@ -837,7 +837,7 @@ TEST(QPACKContextTests, WrapRICAhead) {
       EXPECT_NE(result.control, nullptr)
           << "Every encode should produce an insert";
       controlQueue.append(std::move(result.control));
-      CHECK_EQ(result.stream->computeChainDataLength(), 3); // prefix + 1
+      PRX_CHECK_EQ(result.stream->computeChainDataLength(), 3u); // prefix + 1
       // the decoder has to block because the control stream is pending.
       // This verifies the whole batch of encodes against the same decoderIC
       allDone.emplace_back(verifyDecode(decoder, std::move(result), req));
@@ -886,50 +886,50 @@ TEST(QPACKContextTests, DecodeErrors) {
   QPACKDecoder decoder(128);
   unique_ptr<IOBuf> buf = IOBuf::create(128);
 
-  VLOG(10) << "Required IC underflow";
+  PRX_VLOG(10) << "Required IC underflow";
   buf->writableData()[0] = 0xFF;
   buf->append(1);
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Required IC > 2*ME";
+  PRX_VLOG(10) << "Required IC > 2*ME";
   buf->writableData()[0] = 0x09;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Required IC invalid encoding";
+  PRX_VLOG(10) << "Required IC invalid encoding";
   buf->writableData()[0] = 0x06;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Base delta missing";
+  PRX_VLOG(10) << "Base delta missing";
   buf->writableData()[0] = 0x01;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Base delta invalid";
+  PRX_VLOG(10) << "Base delta invalid";
   buf->writableData()[1] = 0xFF;
   buf->append(1);
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Base delta too negative";
+  PRX_VLOG(10) << "Base delta too negative";
   buf->writableData()[0] = 0x02;
   buf->writableData()[1] = 0x83;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Base delta = LR";
+  PRX_VLOG(10) << "Base delta = LR";
   buf->writableData()[1] = 0x81;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "LR + deltaBase >= 2^32";
+  PRX_VLOG(10) << "LR + deltaBase >= 2^32";
   HPACKEncodeBuffer encBuf(128, true);
   encBuf.encodeInteger(2);
   encBuf.encodeInteger((uint64_t(1) << 32) - 1, HPACK::Q_DELTA_BASE);
   checkQError(decoder, encBuf.release(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Exceeds blocking max";
+  PRX_VLOG(10) << "Exceeds blocking max";
   decoder.setMaxBlocking(0);
   buf->writableData()[0] = 0x02;
   buf->writableData()[1] = 0x00;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::TOO_MANY_BLOCKING);
 
-  VLOG(10) << "Non-zero insert count when decoder disabled dynamic table";
+  PRX_VLOG(10) << "Non-zero insert count when decoder disabled dynamic table";
   QPACKDecoder zeroDecoder(0);
   checkQError(zeroDecoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
@@ -937,50 +937,50 @@ TEST(QPACKContextTests, DecodeErrors) {
   buf->writableData()[0] = 0x00;
   buf->writableData()[1] = 0x00;
 
-  VLOG(10) << "Literal bad name index";
+  PRX_VLOG(10) << "Literal bad name index";
   buf->writableData()[2] = 0x4F;
   buf->append(1);
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Invalid literal name index";
+  PRX_VLOG(10) << "Invalid literal name index";
   buf->writableData()[2] = 0x41;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Literal name index == 2^32 - 1";
+  PRX_VLOG(10) << "Literal name index == 2^32 - 1";
   encBuf.encodeInteger(0);
   encBuf.encodeInteger(0);
   encBuf.encodeInteger(std::numeric_limits<uint32_t>::max(),
                        HPACK::Q_LITERAL_NAME_REF);
   checkQError(decoder, encBuf.release(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Post-base index > 2^32 - 1";
+  PRX_VLOG(10) << "Post-base index > 2^32 - 1";
   encBuf.encodeInteger(std::numeric_limits<uint32_t>::max() - 5);
   encBuf.encodeInteger(0);
   encBuf.encodeInteger(5, HPACK::Q_INDEXED);
   checkQError(decoder, encBuf.release(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "Literal bad name length";
+  PRX_VLOG(10) << "Literal bad name length";
   buf->writableData()[2] = 0x27;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Literal invalid value length";
+  PRX_VLOG(10) << "Literal invalid value length";
   buf->writableData()[2] = 0x51;
   buf->writableData()[3] = 0xFF;
   buf->append(1);
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
   buf->trimEnd(1);
-  VLOG(10) << "Bad Index";
+  PRX_VLOG(10) << "Bad Index";
   buf->writableData()[2] = 0xBF;
   checkQError(decoder, buf->clone(), HPACK::DecodeError::BUFFER_UNDERFLOW);
 
-  VLOG(10) << "Index static index";
+  PRX_VLOG(10) << "Index static index";
   buf->writableData()[2] = 0xFF;
   buf->writableData()[3] = 0x7E;
   buf->append(1);
   checkQError(decoder, buf->clone(), HPACK::DecodeError::INVALID_INDEX);
 
-  VLOG(10) << "No error after previous error";
+  PRX_VLOG(10) << "No error after previous error";
   buf->writableData()[0] = 0xC1;
   buf->writableData()[1] = 0x01;
   buf->writableData()[2] = 0x41;
@@ -988,7 +988,7 @@ TEST(QPACKContextTests, DecodeErrors) {
   EXPECT_EQ(decoder.decodeEncoderStream(buf->clone()),
             HPACK::DecodeError::NONE);
 
-  VLOG(10) << "Control decode error";
+  PRX_VLOG(10) << "Control decode error";
   QPACKDecoder decoder2(64);
   buf->writableData()[0] = 0x01; // duplicate dynamic index 1
   buf->trimEnd(2);
@@ -1009,11 +1009,11 @@ TEST(QPACKContextTests, DecodeErrors) {
   buf->writableData()[10] = 0x7F;
   buf->append(10);
 
-  VLOG(10) << "Bad header ack";
+  PRX_VLOG(10) << "Bad header ack";
   EXPECT_EQ(encoder.decodeDecoderStream(buf->clone()),
             HPACK::DecodeError::INTEGER_OVERFLOW);
 
-  VLOG(10) << "Bad cancel";
+  PRX_VLOG(10) << "Bad cancel";
   buf->writableData()[0] = 0x7F;
   buf->writableData()[10] = 0xFF;
   buf->writableData()[11] = 0x01;
@@ -1021,12 +1021,12 @@ TEST(QPACKContextTests, DecodeErrors) {
   EXPECT_EQ(encoder.decodeDecoderStream(buf->clone()),
             HPACK::DecodeError::INTEGER_OVERFLOW);
 
-  VLOG(10) << "Bad table state sync";
+  PRX_VLOG(10) << "Bad table state sync";
   buf->writableData()[0] = 0x3F;
   EXPECT_EQ(encoder.decodeDecoderStream(buf->clone()),
             HPACK::DecodeError::INTEGER_OVERFLOW);
 
-  VLOG(10) << "Insert too large";
+  PRX_VLOG(10) << "Insert too large";
   vector<HPACKHeader> req;
   req.emplace_back("X-Header-Too-Big", "aaaaaaaaaaaaaaaaa");
   auto result = encoder.encode(req, 10, 1);
diff --git a/proxygen/lib/http/codec/compress/test/TestStreamingCallback.h b/proxygen/lib/http/codec/compress/test/TestStreamingCallback.h
index 0c0f0f0184..6bb7bdc820 100644
--- a/proxygen/lib/http/codec/compress/test/TestStreamingCallback.h
+++ b/proxygen/lib/http/codec/compress/test/TestStreamingCallback.h
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/codec/compress/HPACKHeader.h>
 #include <proxygen/lib/http/codec/compress/HPACKStreamingCallback.h>
 #include <proxygen/lib/http/codec/compress/HeaderCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -53,7 +54,7 @@ class TestStreamingCallback : public HPACK::StreamingCallback {
   }
 
   std::unique_ptr<std::vector<HPACKHeader>> hpackHeaders() const {
-    CHECK(!hasError());
+    PRX_CHECK(!hasError());
     auto result = std::make_unique<std::vector<HPACKHeader>>();
     for (size_t i = 0; i < headers.size(); i += 2) {
       result->emplace_back(headers[i].str, headers[i + 1].str);
@@ -65,7 +66,7 @@ class TestStreamingCallback : public HPACK::StreamingCallback {
   compress::HeaderPieceList headers;
   HPACK::DecodeError error{HPACK::DecodeError::NONE};
   char* duplicate(const folly::fbstring& str) {
-    char* res = CHECK_NOTNULL(new char[str.length() + 1]);
+    char* res = PRX_CHECK_NOTNULL(new char[str.length() + 1]);
     memcpy(res, str.data(), str.length() + 1);
     return res;
   }
diff --git a/proxygen/lib/http/codec/compress/test/TestUtil.cpp b/proxygen/lib/http/codec/compress/test/TestUtil.cpp
index 581cf3f779..f5a7451a7b 100644
--- a/proxygen/lib/http/codec/compress/test/TestUtil.cpp
+++ b/proxygen/lib/http/codec/compress/test/TestUtil.cpp
@@ -13,8 +13,8 @@
 #include <folly/io/Cursor.h>
 #include <folly/portability/GTest.h>
 #include <fstream>
-#include <glog/logging.h>
 #include <proxygen/lib/http/codec/compress/Logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using std::ofstream;
@@ -43,12 +43,12 @@ void verifyHeaders(vector<HPACKHeader>& headers,
   std::sort(headers.begin(), headers.end());
   if (headers.size() != decodedHeaders.size()) {
     std::cerr << printDelta(decodedHeaders, headers);
-    CHECK(false) << "Mismatched headers size";
+    PRX_CHECK(false) << "Mismatched headers size";
   }
   EXPECT_EQ(headers, decodedHeaders);
   if (headers != decodedHeaders) {
     std::cerr << printDelta(headers, decodedHeaders);
-    CHECK(false) << "Mismatched headers";
+    PRX_CHECK(false) << "Mismatched headers";
   }
 }
 
@@ -57,12 +57,12 @@ unique_ptr<IOBuf> encodeDecode(vector<HPACKHeader>& headers,
                                HPACKDecoder& decoder) {
   unique_ptr<IOBuf> encoded = encoder.encode(headers);
   auto decodedHeaders = hpack::decode(decoder, encoded.get());
-  CHECK(!decoder.hasError());
+  PRX_CHECK(!decoder.hasError());
 
   verifyHeaders(headers, *decodedHeaders);
 
   // header tables should look the same
-  CHECK(encoder.getTable() == decoder.getTable());
+  PRX_CHECK(encoder.getTable() == decoder.getTable());
   EXPECT_EQ(encoder.getTable(), decoder.getTable());
 
   return encoded;
@@ -77,16 +77,16 @@ void encodeDecode(vector<HPACKHeader>& headers,
     decoder.decodeEncoderStream(std::move(encoded.control));
     encoder.decodeDecoderStream(decoder.encodeInsertCountInc());
   }
-  CHECK(encoded.stream);
+  PRX_CHECK(encoded.stream);
   auto length = encoded.stream->computeChainDataLength();
   decoder.decodeStreaming(1, std::move(encoded.stream), length, &cb);
-  CHECK(!cb.hasError());
+  PRX_CHECK(!cb.hasError());
   auto decodedHeaders = cb.hpackHeaders();
   verifyHeaders(headers, *decodedHeaders);
   encoder.decodeDecoderStream(decoder.encodeHeaderAck(1));
 
   // header tables should look the same
-  CHECK(encoder.getTable() == decoder.getTable());
+  PRX_CHECK(encoder.getTable() == decoder.getTable());
   EXPECT_EQ(encoder.getTable(), decoder.getTable());
 }
 
diff --git a/proxygen/lib/http/codec/test/CapsuleCodecTest.cpp b/proxygen/lib/http/codec/test/CapsuleCodecTest.cpp
index 68fea9d392..4d868f146b 100644
--- a/proxygen/lib/http/codec/test/CapsuleCodecTest.cpp
+++ b/proxygen/lib/http/codec/test/CapsuleCodecTest.cpp
@@ -10,6 +10,7 @@
 #include <folly/portability/GTest.h>
 #include <gmock/gmock.h>
 #include <proxygen/lib/http/codec/CapsuleCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/common/BufUtil.h>
 
@@ -63,10 +64,10 @@ quic::BufQueue generateStringCapsule(uint64_t type,
   quic::BufAppender appender(buf.get(), 1024);
   auto typeResult =
       quic::encodeQuicInteger(type, [&](auto val) { appender.writeBE(val); });
-  CHECK(typeResult.has_value());
+  PRX_CHECK(typeResult.has_value());
   auto lengthResult =
       quic::encodeQuicInteger(length, [&](auto val) { appender.writeBE(val); });
-  CHECK(lengthResult.has_value());
+  PRX_CHECK(lengthResult.has_value());
   quic::BufQueue queue(std::move(buf));
   auto str = folly::IOBuf::copyBuffer(value);
   queue.append(std::move(str));
@@ -118,7 +119,7 @@ TEST_F(CapsuleCodecTest, ParseUnderflowLength) {
   quic::BufAppender appender(buf.get(), 1024);
   auto typeResult =
       quic::encodeQuicInteger(0x01, [&](auto val) { appender.writeBE(val); });
-  CHECK(typeResult.has_value());
+  PRX_CHECK(typeResult.has_value());
   quic::BufQueue capsule(std::move(buf));
   EXPECT_CALL(*callback_, onCapsule(_, _)).Times(0);
   EXPECT_CALL(*callback_,
@@ -152,10 +153,10 @@ TEST_F(CapsuleCodecTest, ParseUnderflowAndNotEom) {
   quic::BufAppender appender(buf.get(), 1024);
   auto typeResult =
       quic::encodeQuicInteger(0x01, [&](auto val) { appender.writeBE(val); });
-  CHECK(typeResult.has_value());
+  PRX_CHECK(typeResult.has_value());
   auto lengthResult =
       quic::encodeQuicInteger(3, [&](auto val) { appender.writeBE(val); });
-  CHECK(lengthResult.has_value());
+  PRX_CHECK(lengthResult.has_value());
   quic::BufQueue capsule1(std::move(buf));
   EXPECT_CALL(*callback_, onCapsule(0x01, 3));
   EXPECT_CALL(*callback_, onConnectionError(_)).Times(0);
diff --git a/proxygen/lib/http/codec/test/HQCodecTest.cpp b/proxygen/lib/http/codec/test/HQCodecTest.cpp
index 1fc9f64b52..8a0a9168ab 100644
--- a/proxygen/lib/http/codec/test/HQCodecTest.cpp
+++ b/proxygen/lib/http/codec/test/HQCodecTest.cpp
@@ -17,6 +17,7 @@
 #include <proxygen/lib/http/codec/compress/test/TestUtil.h>
 #include <proxygen/lib/http/codec/test/HQFramerTest.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace proxygen;
@@ -87,7 +88,7 @@ class HQCodecTestFixture : public T {
         codec = &downstreamControlCodec_;
         break;
       default:
-        LOG(FATAL) << "Unknown Control Codec type";
+        PRX_LOG(FATAL) << "Unknown Control Codec type";
         break;
     }
     auto ret = codec->onUnidirectionalIngress(queueCtrl_.move());
@@ -340,7 +341,7 @@ void HQCodecTestFixture<T>::qpackTest(bool blocked) {
     EXPECT_EQ(callbacks_.sessionErrors, 0);
   }
   TestStreamingCallback cb;
-  CHECK(!queue_.empty());
+  PRX_CHECK(!queue_.empty());
   upstreamCodec_->generateBody(
       queue_, streamId, folly::IOBuf::copyBuffer("ohai"), 0, false);
   upstreamCodec_->generateEOM(queue_, streamId);
@@ -355,7 +356,7 @@ void HQCodecTestFixture<T>::qpackTest(bool blocked) {
     EXPECT_EQ(callbacks_.sessionErrors, 0);
   }
   EXPECT_EQ(callbacks_.headersComplete, 1);
-  CHECK(callbacks_.msg);
+  PRX_CHECK(callbacks_.msg);
   if (blocked) {
     EXPECT_FALSE(queue_.empty());
     EXPECT_EQ(callbacks_.bodyCalls, 0);
@@ -904,7 +905,7 @@ std::string frameParamsToTestName(
       testName = "Downstream";
       break;
     default:
-      LOG(FATAL) << "Unknown Codec Type";
+      PRX_LOG(FATAL) << "Unknown Codec Type";
   }
   switch (info.param.frameType) {
     case FrameType::DATA:
@@ -980,7 +981,7 @@ TEST_P(HQCodecTestFrameAllowed, FrameAllowedOnCodec) {
       parse();
       break;
     default:
-      CHECK(false);
+      PRX_CHECK(false);
   }
   expectedFrames += GetParam().allowed ? 1 : 0;
   EXPECT_EQ(callbacks_.headerFrames, expectedFrames);
@@ -989,7 +990,7 @@ TEST_P(HQCodecTestFrameAllowed, FrameAllowedOnCodec) {
   // If an error was triggered, check that any additional parse call does not
   // raise another error, and that no new bytes are parsed
   if (!GetParam().allowed) {
-    CHECK(queueCtrl_.chainLength() != 0 || queue_.chainLength() != 0);
+    PRX_CHECK(queueCtrl_.chainLength() != 0 || queue_.chainLength() != 0);
     EXPECT_EQ(callbacks_.lastParseError->getHttp3ErrorCode(),
               HTTP3::ErrorCode::HTTP_FRAME_UNEXPECTED);
     auto lenBefore = 0;
@@ -1012,7 +1013,7 @@ TEST_P(HQCodecTestFrameAllowed, FrameAllowedOnCodec) {
         lenAfter = queue_.chainLength();
         break;
       default:
-        CHECK(false);
+        PRX_CHECK(false);
     }
     EXPECT_EQ(lenBefore, lenAfter);
     EXPECT_EQ(callbacks_.headerFrames, expectedFrames);
diff --git a/proxygen/lib/http/codec/test/HQFramerTest.cpp b/proxygen/lib/http/codec/test/HQFramerTest.cpp
index fc8d01a5d1..d24585e39c 100644
--- a/proxygen/lib/http/codec/test/HQFramerTest.cpp
+++ b/proxygen/lib/http/codec/test/HQFramerTest.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/codec/HQFramer.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/folly_utils/Utils.h>
 
 using namespace folly;
@@ -31,12 +32,12 @@ bool comparePushId(PushId lhs, PushId rhs) {
 // Validate the given push ID.
 bool isValidPushId(folly::Optional<PushId> maxAllowedPushId, PushId pushId) {
   if (!maxAllowedPushId.has_value()) {
-    VLOG(3) << __func__ << "maximum push ID value has not been set";
+    PRX_VLOG(3) << __func__ << "maximum push ID value has not been set";
     return false;
   } else if (!comparePushId(maxAllowedPushId.value(), pushId)) {
-    VLOG(3) << __func__ << "given pushid=" << pushId
-            << "exceeds possible push ID value "
-            << "maxAllowedPushId_=" << maxAllowedPushId.value();
+    PRX_VLOG(3) << __func__ << "given pushid=" << pushId
+                << "exceeds possible push ID value "
+                << "maxAllowedPushId_=" << maxAllowedPushId.value();
     return false;
   }
   return true;
diff --git a/proxygen/lib/http/codec/test/HQFramerTest.h b/proxygen/lib/http/codec/test/HQFramerTest.h
index 8a3e59c3e9..fd98fb4343 100644
--- a/proxygen/lib/http/codec/test/HQFramerTest.h
+++ b/proxygen/lib/http/codec/test/HQFramerTest.h
@@ -11,6 +11,7 @@
 #include <folly/io/IOBufQueue.h>
 #include <proxygen/lib/http/codec/HQFramer.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -21,9 +22,9 @@ size_t writeFrameHeaderManual(folly::IOBufQueue& queue,
   folly::io::QueueAppender appender(&queue, proxygen::hq::kMaxFrameHeaderSize);
   auto appenderOp = [&](auto val) { appender.writeBE<decltype(val)>(val); };
   auto typeRes = quic::encodeQuicInteger(decodedType, appenderOp);
-  CHECK(typeRes.has_value());
+  PRX_CHECK(typeRes.has_value());
   auto lengthRes = quic::encodeQuicInteger(decodedLength, appenderOp);
-  CHECK(lengthRes.has_value());
+  PRX_CHECK(lengthRes.has_value());
   return *typeRes + *lengthRes;
 }
 
@@ -56,7 +57,7 @@ void writeValidFrame(folly::IOBufQueue& queue, proxygen::hq::FrameType type) {
       folly::io::QueueAppender appender(&queue, *idSize);
       auto appenderOp = [&](auto val) { appender.writeBE<decltype(val)>(val); };
       auto idResult = quic::encodeQuicInteger(id, appenderOp);
-      CHECK(idResult.has_value());
+      PRX_CHECK(idResult.has_value());
       if (type == proxygen::hq::FrameType::PUSH_PROMISE) {
         // header data for push-promise
         uint8_t simplePushPromise[] = {0x00, 0x00, 0xC0, 0xC1, 0xD1, 0xD7};
@@ -87,7 +88,7 @@ void writeValidFrame(folly::IOBufQueue& queue, proxygen::hq::FrameType type) {
       auto appenderOp = [&](auto val) { appender.writeBE<decltype(val)>(val); };
       auto prioritizedIdResult =
           quic::encodeQuicInteger(prioritizedId, appenderOp);
-      CHECK(prioritizedIdResult.has_value());
+      PRX_CHECK(prioritizedIdResult.has_value());
       queue.append(std::move(data));
       break;
     }
diff --git a/proxygen/lib/http/codec/test/HTTP1xCodecTest.cpp b/proxygen/lib/http/codec/test/HTTP1xCodecTest.cpp
index 1e3197ee01..0b576253d0 100644
--- a/proxygen/lib/http/codec/test/HTTP1xCodecTest.cpp
+++ b/proxygen/lib/http/codec/test/HTTP1xCodecTest.cpp
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace std;
@@ -61,7 +62,7 @@ class HTTP1xCodecCallback : public HTTPCodec::Callback {
                const HTTPException& error,
                bool /*newTxn*/) override {
     ++errors;
-    LOG(ERROR) << "parse error " << error;
+    PRX_LOG(ERROR) << "parse error " << error;
   }
 
   uint32_t headersComplete{0};
@@ -493,7 +494,7 @@ TEST(HTTP1xCodecTest, TestChunkedUpstream) {
   ASSERT_EQ("5\r\nHello\r\n", bodyFromBuf->moveToFbString());
 
   codec.generateBody(buf, txnID, std::move(body2), HTTPCodec::NoPadding, true);
-  LOG(WARNING) << "len chain" << buf.chainLength();
+  PRX_LOG(WARNING) << "len chain" << buf.chainLength();
 
   auto eomFromBuf = buf.split(buf.chainLength());
   ASSERT_EQ("5\r\nWorld\r\n0\r\n\r\n", eomFromBuf->moveToFbString());
@@ -988,7 +989,7 @@ TEST(HTTP1xCodecTest, TestChunkResponseSerialization) {
 
   std::string tmp;
   blob.appendToString(tmp);
-  VLOG(2) << "serializeMessage blob: " << tmp;
+  PRX_VLOG(2) << "serializeMessage blob: " << tmp;
 
   // deserialize
   HTTP1xCodec upCodec(TransportDirection::UPSTREAM);
diff --git a/proxygen/lib/http/codec/test/HTTP2CodecTest.cpp b/proxygen/lib/http/codec/test/HTTP2CodecTest.cpp
index e15314ad59..0e155852ce 100644
--- a/proxygen/lib/http/codec/test/HTTP2CodecTest.cpp
+++ b/proxygen/lib/http/codec/test/HTTP2CodecTest.cpp
@@ -17,6 +17,7 @@
 
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::compress;
@@ -2586,7 +2587,8 @@ TEST_F(HTTP2CodecTest, GenerateHeadersWithEmptyRequest) {
 }
 
 TEST_F(HTTP2CodecTest, SetIfNotPresent) {
-  auto* egressSettings = CHECK_NOTNULL(downstreamCodec_.getEgressSettings());
+  auto* egressSettings =
+      PRX_CHECK_NOTNULL(downstreamCodec_.getEgressSettings());
   // WT_MAX_SESSIONS not currently present
   EXPECT_TRUE(egressSettings->setIfNotPresent(SettingsId::WT_MAX_SESSIONS, 1));
   // no-op since added above
diff --git a/proxygen/lib/http/codec/test/TestUtils.cpp b/proxygen/lib/http/codec/test/TestUtils.cpp
index 711187f4f2..6617c3c63c 100644
--- a/proxygen/lib/http/codec/test/TestUtils.cpp
+++ b/proxygen/lib/http/codec/test/TestUtils.cpp
@@ -14,6 +14,7 @@
 #include <folly/Random.h>
 #include <folly/io/Cursor.h>
 #include <folly/io/async/EventBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly::io;
 using namespace std;
@@ -301,9 +302,10 @@ void WtCapsuleCodecCallback::onStopSending(
 }
 
 void WtCapsuleCodecCallback::onStream(WTStreamCapsule capsule) noexcept {
-  VLOG(4) << __func__ << "; id=" << capsule.streamId << "; len="
-          << (capsule.streamData ? capsule.streamData->computeChainDataLength()
-                                 : 0);
+  PRX_VLOG(4)
+      << __func__ << "; id=" << capsule.streamId << "; len="
+      << (capsule.streamData ? capsule.streamData->computeChainDataLength()
+                             : 0);
   stream.emplace(std::move(capsule));
   signal();
 }
@@ -362,13 +364,13 @@ void WtCapsuleCodecCallback::onDrainSession(
 
 void WtCapsuleCodecCallback::onConnectionError(
     WebTransportCapsuleCodec::ErrorCode) noexcept {
-  LOG(FATAL) << "conn error";
+  PRX_LOG(FATAL) << "conn error";
 }
 
 void WtCapsuleCodecCallback::onCapsule(uint64_t capsuleType,
                                        uint64_t capsuleLength) noexcept {
-  VLOG(4) << __func__ << "; capsuleType=" << capsuleType
-          << "; capsuleLength=" << capsuleLength;
+  PRX_VLOG(4) << __func__ << "; capsuleType=" << capsuleType
+              << "; capsuleLength=" << capsuleLength;
 }
 
 void WtCapsuleCodecCallback::signal() {
diff --git a/proxygen/lib/http/codec/test/TestUtils.h b/proxygen/lib/http/codec/test/TestUtils.h
index d4c4bddc4b..495bdf4c0c 100644
--- a/proxygen/lib/http/codec/test/TestUtils.h
+++ b/proxygen/lib/http/codec/test/TestUtils.h
@@ -13,6 +13,7 @@
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
 #include <proxygen/lib/http/codec/webtransport/WebTransportCapsuleCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/TestUtils.h>
 
 namespace proxygen {
@@ -333,33 +334,33 @@ class FakeHTTPCodecCallback : public HTTPCodec::Callback {
   }
 
   void dumpCounters(int verbosity) const {
-    VLOG(verbosity) << "Dumping HTTP codec callback counters";
-    VLOG(verbosity) << "headersCompleteId: " << headersCompleteId;
-    VLOG(verbosity) << "assocStreamId: " << assocStreamId;
-    VLOG(verbosity) << "pushId: " << pushId;
-    VLOG(verbosity) << "controlStreamId: " << controlStreamId;
-    VLOG(verbosity) << "unidirectional: " << isUnidirectional;
-    VLOG(verbosity) << "messageBegin: " << messageBegin;
-    VLOG(verbosity) << "headersComplete: " << headersComplete;
-    VLOG(verbosity) << "bodyCalls: " << bodyCalls;
-    VLOG(verbosity) << "bodyLength: " << bodyLength;
-    VLOG(verbosity) << "paddingBytes: " << paddingBytes;
-    VLOG(verbosity) << "chunkHeaders: " << chunkHeaders;
-    VLOG(verbosity) << "chunkComplete: " << chunkComplete;
-    VLOG(verbosity) << "trailers: " << trailers;
-    VLOG(verbosity) << "aborts: " << aborts;
-    VLOG(verbosity) << "goaways: " << goaways;
-    VLOG(verbosity) << "sessionErrors: " << sessionErrors;
-    VLOG(verbosity) << "streamErrors: " << streamErrors;
-    VLOG(verbosity) << "recvPingRequest: " << recvPingRequest;
-    VLOG(verbosity) << "recvPingReply: " << recvPingReply;
-    VLOG(verbosity) << "windowUpdateCalls: " << windowUpdateCalls;
-    VLOG(verbosity) << "settings: " << settings;
-    VLOG(verbosity) << "settingsAcks: " << settingsAcks;
-    VLOG(verbosity) << "windowSize: " << windowSize;
-    VLOG(verbosity) << "maxStreams: " << maxStreams;
-    VLOG(verbosity) << "datagramEnabled: " << datagramEnabled;
-    VLOG(verbosity) << "headerFrames: " << headerFrames;
+    PRX_VLOG_LEVEL(verbosity) << "Dumping HTTP codec callback counters";
+    PRX_VLOG_LEVEL(verbosity) << "headersCompleteId: " << headersCompleteId;
+    PRX_VLOG_LEVEL(verbosity) << "assocStreamId: " << assocStreamId;
+    PRX_VLOG_LEVEL(verbosity) << "pushId: " << pushId;
+    PRX_VLOG_LEVEL(verbosity) << "controlStreamId: " << controlStreamId;
+    PRX_VLOG_LEVEL(verbosity) << "unidirectional: " << isUnidirectional;
+    PRX_VLOG_LEVEL(verbosity) << "messageBegin: " << messageBegin;
+    PRX_VLOG_LEVEL(verbosity) << "headersComplete: " << headersComplete;
+    PRX_VLOG_LEVEL(verbosity) << "bodyCalls: " << bodyCalls;
+    PRX_VLOG_LEVEL(verbosity) << "bodyLength: " << bodyLength;
+    PRX_VLOG_LEVEL(verbosity) << "paddingBytes: " << paddingBytes;
+    PRX_VLOG_LEVEL(verbosity) << "chunkHeaders: " << chunkHeaders;
+    PRX_VLOG_LEVEL(verbosity) << "chunkComplete: " << chunkComplete;
+    PRX_VLOG_LEVEL(verbosity) << "trailers: " << trailers;
+    PRX_VLOG_LEVEL(verbosity) << "aborts: " << aborts;
+    PRX_VLOG_LEVEL(verbosity) << "goaways: " << goaways;
+    PRX_VLOG_LEVEL(verbosity) << "sessionErrors: " << sessionErrors;
+    PRX_VLOG_LEVEL(verbosity) << "streamErrors: " << streamErrors;
+    PRX_VLOG_LEVEL(verbosity) << "recvPingRequest: " << recvPingRequest;
+    PRX_VLOG_LEVEL(verbosity) << "recvPingReply: " << recvPingReply;
+    PRX_VLOG_LEVEL(verbosity) << "windowUpdateCalls: " << windowUpdateCalls;
+    PRX_VLOG_LEVEL(verbosity) << "settings: " << settings;
+    PRX_VLOG_LEVEL(verbosity) << "settingsAcks: " << settingsAcks;
+    PRX_VLOG_LEVEL(verbosity) << "windowSize: " << windowSize;
+    PRX_VLOG_LEVEL(verbosity) << "maxStreams: " << maxStreams;
+    PRX_VLOG_LEVEL(verbosity) << "datagramEnabled: " << datagramEnabled;
+    PRX_VLOG_LEVEL(verbosity) << "headerFrames: " << headerFrames;
   }
 
   HTTPCodec::StreamID headersCompleteId{0};
diff --git a/proxygen/lib/http/connpool/CMakeLists.txt b/proxygen/lib/http/connpool/CMakeLists.txt
index ebf9dfb599..5a8a4e53c7 100644
--- a/proxygen/lib/http/connpool/CMakeLists.txt
+++ b/proxygen/lib/http/connpool/CMakeLists.txt
@@ -10,6 +10,7 @@ proxygen_add_library(proxygen_http_connpool_session_holder
   SRCS
     SessionHolder.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_socket
     Folly::folly_random
   EXPORTED_DEPS
@@ -25,6 +26,7 @@ proxygen_add_library(proxygen_http_connpool
     SessionPool.cpp
     ThreadIdleSessionController.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_event_base_manager
   EXPORTED_DEPS
     proxygen_http_connpool_session_holder
diff --git a/proxygen/lib/http/connpool/ServerIdleSessionController.cpp b/proxygen/lib/http/connpool/ServerIdleSessionController.cpp
index 022d4c9ae7..c9f5c0c566 100644
--- a/proxygen/lib/http/connpool/ServerIdleSessionController.cpp
+++ b/proxygen/lib/http/connpool/ServerIdleSessionController.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/connpool/ServerIdleSessionController.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -24,7 +25,7 @@ folly::Future<HTTPSessionBase*> ServerIdleSessionController::getIdleSession() {
   }
 
   if (maxPool->getEventBase()->isInEventBaseThread()) {
-    LOG(ERROR) << "Idle session already belongs to current thread!";
+    PRX_LOG(ERROR) << "Idle session already belongs to current thread!";
     return folly::makeFuture<HTTPSessionBase*>(nullptr);
   }
 
@@ -47,7 +48,7 @@ void ServerIdleSessionController::addIdleSession(const HTTPSessionBase* session,
   std::lock_guard<std::mutex> lock(lock_);
   if (sessionMap_.find(session) != sessionMap_.end()) {
     // removeIdleSession should've been called before re-adding
-    LOG(ERROR) << "Session " << session << " already exists!";
+    PRX_LOG(ERROR) << "Session " << session << " already exists!";
     return;
   }
   if (sessionsByIdleAge_.size() < maxIdleCount_) {
diff --git a/proxygen/lib/http/connpool/SessionHolder.cpp b/proxygen/lib/http/connpool/SessionHolder.cpp
index 20fa8b3337..772167e7f8 100644
--- a/proxygen/lib/http/connpool/SessionHolder.cpp
+++ b/proxygen/lib/http/connpool/SessionHolder.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/Random.h>
 #include <folly/io/async/AsyncSocket.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::AsyncSocket;
 using folly::SocketAddress;
@@ -24,8 +25,8 @@ SessionHolder::SessionHolder(HTTPSessionBase* sess,
                              Callback* parent,
                              Stats* stats,
                              Endpoint endpoint)
-    : session_(CHECK_NOTNULL(sess)),
-      parent_(CHECK_NOTNULL(parent)),
+    : session_(PRX_CHECK_NOTNULL(sess)),
+      parent_(PRX_CHECK_NOTNULL(parent)),
       stats_(stats),
       jitter_(folly::Random::randDouble(-kJitterPct, kJitterPct)),
       endpoint_(std::move(endpoint)),
@@ -34,9 +35,9 @@ SessionHolder::SessionHolder(HTTPSessionBase* sess,
 }
 
 SessionHolder::~SessionHolder() {
-  CHECK(state_ == ListState::DETACHED);
-  CHECK(!listHook.is_linked());
-  CHECK(!secondaryListHook.is_linked());
+  PRX_CHECK(state_ == ListState::DETACHED);
+  PRX_CHECK(!listHook.is_linked());
+  PRX_CHECK(!secondaryListHook.is_linked());
 }
 
 bool SessionHolder::isPoolable(const HTTPSessionBase* sess) {
@@ -67,7 +68,7 @@ std::chrono::steady_clock::time_point SessionHolder::getLastUseTime() const {
 }
 
 void SessionHolder::drain() {
-  VLOG(4) << "draining holder=" << *this;
+  PRX_VLOG(4) << "draining holder=" << *this;
   if (state_ != ListState::DETACHED) {
     unlink();
   }
@@ -107,8 +108,8 @@ void SessionHolder::closeWithReset() {
 }
 
 void SessionHolder::unlink() {
-  CHECK(parent_);
-  CHECK(listHook.is_linked());
+  PRX_CHECK(parent_);
+  PRX_CHECK(listHook.is_linked());
 
   switch (state_) {
     case ListState::IDLE:
@@ -121,19 +122,20 @@ void SessionHolder::unlink() {
       parent_->detachFilled(this);
       break;
     case ListState::DETACHED:
-      LOG(FATAL) << "Inconsistentency between listHook.is_linked() and state_";
+      PRX_LOG(FATAL)
+          << "Inconsistentency between listHook.is_linked() and state_";
   }
   state_ = ListState::DETACHED;
 }
 
 void SessionHolder::link() {
-  CHECK(state_ == ListState::DETACHED);
+  PRX_CHECK(state_ == ListState::DETACHED);
   if (!parent_) {
     return;
   }
 
   if (!isPoolable(session_)) {
-    VLOG(4) << *this << " Not pooling session since it is not poolable";
+    PRX_VLOG(4) << *this << " Not pooling session since it is not poolable";
     drain();
     return;
   }
@@ -153,7 +155,7 @@ void SessionHolder::link() {
 }
 
 void SessionHolder::onCreate(const HTTPSessionBase&) {
-  LOG(FATAL) << "onCreate() should not be reachable.";
+  PRX_LOG(FATAL) << "onCreate() should not be reachable.";
 }
 
 void SessionHolder::onIngressError(const HTTPSessionBase& session,
@@ -229,7 +231,7 @@ void SessionHolder::onDestroy(const HTTPSessionBase& session) {
   if (originalSessionInfoCb_) {
     originalSessionInfoCb_->onDestroy(session);
   }
-  VLOG(4) << *this << " connection to server was destroyed";
+  PRX_VLOG(4) << *this << " connection to server was destroyed";
   delete this;
 }
 
@@ -366,7 +368,7 @@ void SessionHolder::describe(std::ostream& os) const {
 }
 
 void SessionHolder::handleTransactionDetached() {
-  CHECK(state_ != ListState::DETACHED);
+  PRX_CHECK(state_ != ListState::DETACHED);
   unlink();
   link();
 }
diff --git a/proxygen/lib/http/connpool/SessionPool.cpp b/proxygen/lib/http/connpool/SessionPool.cpp
index a66feb66b8..6af650d351 100644
--- a/proxygen/lib/http/connpool/SessionPool.cpp
+++ b/proxygen/lib/http/connpool/SessionPool.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/connpool/ThreadIdleSessionController.h>
 
 #include <folly/io/async/EventBaseManager.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -36,7 +37,7 @@ SessionPool::~SessionPool() {
   drainSessionList(idleSessionList_);
   drainSessionList(unfilledSessionList_);
   drainSessionList(fullSessionList_);
-  DCHECK(empty());
+  PRX_DCHECK(empty());
 }
 
 void SessionPool::setMaxIdleSessions(uint32_t num) {
@@ -111,7 +112,7 @@ HTTPTransaction* SessionPool::getTransaction(
 void SessionPool::purgeExcessIdleSessions() {
   auto thresh = std::chrono::steady_clock::now() - getTimeout();
 
-  CHECK_LE(idleSessionList_.size(), std::numeric_limits<uint32_t>::max());
+  PRX_CHECK_LE(idleSessionList_.size(), std::numeric_limits<uint32_t>::max());
   int64_t excess =
       static_cast<int64_t>(idleSessionList_.size()) - getMaxIdleSessions();
   while (!idleSessionList_.empty()) {
@@ -127,7 +128,7 @@ void SessionPool::purgeExcessIdleSessions() {
 HTTPSessionBase* FOLLY_NULLABLE SessionPool::removeOldestIdleSession() {
   if (!idleSessionList_.empty()) {
     SessionHolder* holder = &idleSessionList_.front();
-    CHECK_NOTNULL(holder);
+    PRX_CHECK_NOTNULL(holder);
     return holder->release();
   }
   return nullptr;
diff --git a/proxygen/lib/http/connpool/test/SessionPoolTest.cpp b/proxygen/lib/http/connpool/test/SessionPoolTest.cpp
index f23fb61d71..a5a0cc3c51 100644
--- a/proxygen/lib/http/connpool/test/SessionPoolTest.cpp
+++ b/proxygen/lib/http/connpool/test/SessionPoolTest.cpp
@@ -19,6 +19,7 @@
 #include <wangle/acceptor/ConnectionManager.h>
 
 #include <proxygen/lib/http/session/test/HQSessionMocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace std;
@@ -147,7 +148,7 @@ TEST_F(SessionPoolFixture, ParallelPoolLists) {
   auto sess2 = makeParallelSession();
   p.putSession(sess1);
   p.putSession(sess2);
-  txnsSess1.push_back(CHECK_NOTNULL(p.getTransaction(this)));
+  txnsSess1.push_back(PRX_CHECK_NOTNULL(p.getTransaction(this)));
   // Since these two sessions are equally old, it's ok for either one to
   // be selected to become "active"
   if (sess2->getNumOutgoingStreams() > sess1->getNumOutgoingStreams()) {
@@ -161,7 +162,7 @@ TEST_F(SessionPoolFixture, ParallelPoolLists) {
 
   // sess1 should be filled completely before we add any transactions to sess2
   while (sess1->supportsMoreTransactions()) {
-    txnsSess1.push_back(CHECK_NOTNULL(p.getTransaction(this)));
+    txnsSess1.push_back(PRX_CHECK_NOTNULL(p.getTransaction(this)));
   }
   ASSERT_EQ(sess1->getNumOutgoingStreams(),
             sess1->getMaxConcurrentOutgoingStreams());
@@ -172,7 +173,7 @@ TEST_F(SessionPoolFixture, ParallelPoolLists) {
 
   // Now fill sess2
   while (sess2->supportsMoreTransactions()) {
-    txnsSess2.push_back(CHECK_NOTNULL(p.getTransaction(this)));
+    txnsSess2.push_back(PRX_CHECK_NOTNULL(p.getTransaction(this)));
   }
   // The two sessions should be completely full
   ASSERT_EQ(sess1->getNumOutgoingStreams(),
@@ -184,7 +185,7 @@ TEST_F(SessionPoolFixture, ParallelPoolLists) {
   ASSERT_EQ(closed_, 0);
 
   // Adding 1 more txn should fail since both sessions are full
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
 
   evb_.loop();
   ASSERT_EQ(sess1->getNumOutgoingStreams(),
@@ -219,7 +220,7 @@ TEST_F(SessionPoolFixture, ParallelPoolLists) {
   txnsSess2.back()->sendAbort();
   txnsSess2.pop_back();
   ASSERT_EQ(deactivated_, 1);
-  txnsSess2.push_back(CHECK_NOTNULL(p.getTransaction(this)));
+  txnsSess2.push_back(PRX_CHECK_NOTNULL(p.getTransaction(this)));
 
   // Set the max pooled sessions to zero and drop all txns from
   // sess2. The session should be automatically closed when it hits
@@ -254,7 +255,7 @@ TEST_F(SessionPoolFixture, OutstandingWrites) {
   p.putSession(sess);
   ASSERT_FALSE(attached_);
   ASSERT_FALSE(sess->isClosing());
-  auto txn = CHECK_NOTNULL(p.getTransaction(this));
+  auto txn = PRX_CHECK_NOTNULL(p.getTransaction(this));
   ASSERT_TRUE(attached_);
   txn->sendHeaders(HTTPMessage());
   txn->sendAbort();
@@ -280,7 +281,7 @@ TEST_F(SessionPoolFixture, OutstandingTransaction) {
     p.putSession(sess);
     ASSERT_FALSE(attached_);
     txn = p.getTransaction(this);
-    CHECK_NOTNULL(txn);
+    PRX_CHECK_NOTNULL(txn);
     ASSERT_TRUE(attached_);
     ASSERT_EQ(deactivated_, 0);
     ASSERT_EQ(closed_, 0);
@@ -327,7 +328,7 @@ TEST_F(SessionPoolFixture, DroppedRequestNotPooled) {
   evb_.loop();
   // Writes have now succeeded. We should still be attached since we
   // terminated the loop before the timeouts fired
-  CHECK(!timeout_);
+  PRX_CHECK(!timeout_);
   ASSERT_TRUE(attached_);
 
   // Now drop the txn before the response comes back
@@ -350,7 +351,7 @@ TEST_F(SessionPoolFixture, InsertIntoZeroSizePool) {
   // Let the session pool have 0 max sessions
   SessionPool p(this, 0, std::chrono::seconds(4));
   p.putSession(makeSerialSession());
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
   evb_.loop();
 }
 
@@ -360,11 +361,11 @@ TEST_F(SessionPoolFixture, DrainSessionLater) {
   auto session = makeParallelSession();
   p.putSession(session);
 
-  auto txn1 = CHECK_NOTNULL(p.getTransaction(this));
-  auto txn2 = CHECK_NOTNULL(p.getTransaction(this));
+  auto txn1 = PRX_CHECK_NOTNULL(p.getTransaction(this));
+  auto txn2 = PRX_CHECK_NOTNULL(p.getTransaction(this));
   session->drain();
   ASSERT_EQ(p.getNumSessions(), 1); // don't detect until getTransaction()
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
   ASSERT_EQ(p.getNumSessions(), 0);
   // now let the session be destroyed
   txn1->sendAbort();
@@ -374,7 +375,7 @@ TEST_F(SessionPoolFixture, DrainSessionLater) {
 TEST_F(SessionPoolFixture, InsertDrainedSession) {
   // Put a draining session into the pool. Make sure the pool ignores it.
   auto session = makeParallelSession();
-  CHECK_NOTNULL(session->newTransaction(this));
+  PRX_CHECK_NOTNULL(session->newTransaction(this));
   session->drain();
 
   auto cm = wangle::ConnectionManager::makeUnique(
@@ -383,7 +384,7 @@ TEST_F(SessionPoolFixture, InsertDrainedSession) {
   cm->addConnection(session);
   p.putSession(session);
   ASSERT_EQ(p.getNumSessions(), 0);
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
 
   // this session needs to be owned by the cm
   cm->dropAllConnections();
@@ -408,7 +409,7 @@ TEST_F(SessionPoolFixture, CloseNotReusable) {
 
   p.putSession(makeSession(std::move(codec)));
   ASSERT_EQ(p.getNumSessions(), 1);
-  auto txn = CHECK_NOTNULL(p.getTransaction(this));
+  auto txn = PRX_CHECK_NOTNULL(p.getTransaction(this));
   reusable = false; // Mark the session as not reusable, e.g. if it got
                     // Connection: close
   txn->sendAbort();
@@ -425,7 +426,7 @@ TEST_F(SessionPoolFixture, InsertOldSession) {
   usleep(70000); // exceeds max jitter (currently 65ms)
   p.putSession(session);
   ASSERT_EQ(p.getNumSessions(), 0);
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
 }
 
 TEST_F(SessionPoolFixture, IdleTmeout) {
@@ -437,10 +438,10 @@ TEST_F(SessionPoolFixture, IdleTmeout) {
       this, 10, std::chrono::milliseconds(250), std::chrono::seconds(4));
   p.putSession(session);
   ASSERT_TRUE(p.getNumSessions() == 1);
-  auto txn = CHECK_NOTNULL(p.getTransaction(this));
+  auto txn = PRX_CHECK_NOTNULL(p.getTransaction(this));
   txn->sendAbort();
   /* sleep override */ usleep(260000); // > 250ms
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
   ASSERT_EQ(p.getNumSessions(), 0);
 }
 
@@ -454,10 +455,10 @@ TEST_F(SessionPoolFixture, AgeOut) {
   p.putSession(session);
   // possible flake if this process takes a dirtnap for >= 175ms
   ASSERT_TRUE(p.getNumSessions() == 1);
-  auto txn = CHECK_NOTNULL(p.getTransaction(this));
+  auto txn = PRX_CHECK_NOTNULL(p.getTransaction(this));
   txn->sendAbort();
   usleep(350000); // over max jitter (325 ms)
-  CHECK(nullptr == p.getTransaction(this));
+  PRX_CHECK(nullptr == p.getTransaction(this));
   ASSERT_EQ(p.getNumSessions(), 0);
 }
 
@@ -729,7 +730,7 @@ TEST_F(SessionPoolFixture, DescribeWithNullTransport) {
   SessionHolder sessionHolder(&session, &cb);
 
   // This should not crash.
-  LOG(INFO) << sessionHolder;
+  PRX_LOG(INFO) << sessionHolder;
   // This is to appease mock session destructor.
   session.setInfoCallback(nullptr);
 }
diff --git a/proxygen/lib/http/coro/CMakeLists.txt b/proxygen/lib/http/coro/CMakeLists.txt
index c911c0a7f0..4e09671370 100644
--- a/proxygen/lib/http/coro/CMakeLists.txt
+++ b/proxygen/lib/http/coro/CMakeLists.txt
@@ -19,6 +19,7 @@ proxygen_add_library(proxygen_http_coro_filter_factory_handler
   DEPS
     proxygen_coro_source
     proxygen_http_coro_filters_FilterFactory
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_coro_handler_chain
 )
@@ -39,6 +40,7 @@ proxygen_add_library(proxygen_coro_source
     proxygen_http_h3_errors
     proxygen_http_http_header_size
     proxygen_http_message
+    proxygen_utils_log_shim
     proxygen_utils_parse_url
     proxygen_utils_weak_ref_counted_ptr
     mvfst::mvfst_common_buf_util
@@ -46,7 +48,6 @@ proxygen_add_library(proxygen_coro_source
     Folly::folly_coro_task
     Folly::folly_function
     Folly::folly_io_iobuf
-    Folly::folly_logging_logging
     Folly::folly_optional
     Folly::folly_scope_guard
 )
@@ -57,20 +58,19 @@ proxygen_add_library(proxygen_http_coro_coro_reader
   EXPORTED_DEPS
     proxygen_coro_source
     proxygen_http_coro_util_timed_baton
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_coro_stream_source
   SRCS
     HTTPStreamSource.cpp
-  DEPS
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_coro_source
     proxygen_http_codec_codec_common
     proxygen_http_coro_util_timed_baton
     proxygen_http_coro_util_window_contiainer
     proxygen_http_session_http_state_machine_lib
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_coro
@@ -99,6 +99,7 @@ proxygen_add_library(proxygen_coro
     proxygen_http_coro_util_window_contiainer
     proxygen_http_session_quic_protocol_info
     proxygen_http_session_stream_dispatcher
+    proxygen_utils_log_shim
     proxygen_utils_util_inl
     mvfst::mvfst_api_transport
     mvfst::mvfst_common_events_folly_eventbase
@@ -113,7 +114,6 @@ proxygen_add_library(proxygen_coro
     Folly::folly_io_async_async_base
     Folly::folly_io_async_async_socket
     Folly::folly_io_coro_socket
-    Folly::folly_logging_logging
     Folly::folly_utility
 )
 
@@ -128,6 +128,7 @@ proxygen_add_library(proxygen_coro_stream_source_sink
     proxygen_http_session_http_transaction
     proxygen_http_sink_client_sink_interface
     proxygen_utils_conditional_gate
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_http_transaction_adaptor_source
@@ -135,6 +136,7 @@ proxygen_add_library(proxygen_http_coro_http_transaction_adaptor_source
     HTTPTransactionAdaptorSource.cpp
   DEPS
     proxygen_http_coro_coro_reader
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_coro_source
     proxygen_http_coro_coro_stream_source
diff --git a/proxygen/lib/http/coro/HTTPBodyEventQueue.cpp b/proxygen/lib/http/coro/HTTPBodyEventQueue.cpp
index 84342ca2c1..fe15c75759 100644
--- a/proxygen/lib/http/coro/HTTPBodyEventQueue.cpp
+++ b/proxygen/lib/http/coro/HTTPBodyEventQueue.cpp
@@ -9,6 +9,7 @@
 #include "proxygen/lib/http/coro/HTTPBodyEventQueue.h"
 
 #include <folly/Conv.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::coro::co_error;
 using folly::coro::co_nothrow;
@@ -31,14 +32,14 @@ folly::coro::Task<HTTPHeaderEvent> HTTPBodyEventQueue::readHeaderEvent() {
 
 folly::coro::Task<HTTPBodyEventQueue::ReadBodyResult>
 HTTPBodyEventQueue::readBodyEvent(uint32_t max) {
-  XCHECK(source_);
-  XLOG(DBG4) << "Waiting for buffer space";
+  PRX_CHECK(source_);
+  PRX_VLOG(4) << "Waiting for buffer space";
   auto bufferSpace = availableBuffer();
   if (!bufferSpace) {
     bufferSpace = co_await co_nothrow(waitAvailableBuffer());
   }
-  XLOG(DBG4) << "Got buffer space len=" << bufferSpace
-             << " waiting for body event";
+  PRX_VLOG(4) << "Got buffer space len=" << bufferSpace
+              << " waiting for body event";
   max = std::min(max, uint32_t(bufferSpace));
   auto bodyEvent = co_await co_nothrow(source_.readBodyEvent(max));
   const auto& ct = co_await folly::coro::co_current_cancellation_token;
@@ -67,7 +68,7 @@ void HTTPBodyEventQueue::setExpectedEgressContentLength(
 
   auto convResult = folly::tryTo<uint64_t>(contentLen);
   if (convResult.hasError()) {
-    XLOG(ERR)
+    PRX_LOG(ERROR)
         << "Invalid content-length: " << contentLen << ", ex="
         << folly::makeConversionError(convResult.error(), contentLen).what();
     shouldValidateContentLength_ = false;
@@ -93,13 +94,13 @@ void HTTPBodyEventQueue::clear(const HTTPError& err) {
 }
 
 HTTPBodyEvent HTTPBodyEventQueue::dequeueBodyEvent(uint32_t max) {
-  XCHECK(!bodyQueue_.empty());
+  PRX_CHECK(!bodyQueue_.empty());
   auto bodyEvent = std::move(bodyQueue_.front());
   bodyQueue_.pop_front();
   if (auto* body = asBodyEv(bodyEvent)) {
     auto length = body->chainLength();
     auto toReturn = std::min(max, uint32_t(length));
-    XCHECK_GE(bufferedBodyBytes_, toReturn);
+    PRX_CHECK_GE(bufferedBodyBytes_, toReturn);
     bool wasOverLimit = bufferedBodyBytes_ >= limit_;
     bufferedBodyBytes_ -= toReturn;
     if (wasOverLimit && bufferedBodyBytes_ < limit_) {
@@ -131,7 +132,7 @@ folly::coro::Task<size_t> HTTPBodyEventQueue::waitAvailableBuffer() {
 }
 
 bool HTTPBodyEventQueue::processBodyEvent(HTTPBodyEvent&& bodyEvent) {
-  XLOG(DBG4) << "Queuing body event";
+  PRX_VLOG(4) << "Queuing body event";
   for (auto& reg : bodyEvent.byteEventRegistrations) {
     if (!reg.streamID) {
       reg.streamID = id_;
diff --git a/proxygen/lib/http/coro/HTTPBodyEventQueue.h b/proxygen/lib/http/coro/HTTPBodyEventQueue.h
index 3147f19beb..8b09ec5df2 100644
--- a/proxygen/lib/http/coro/HTTPBodyEventQueue.h
+++ b/proxygen/lib/http/coro/HTTPBodyEventQueue.h
@@ -12,8 +12,8 @@
 #include "proxygen/lib/http/coro/HTTPSourceHolder.h"
 #include "proxygen/lib/http/coro/util/CancellableBaton.h"
 #include <folly/coro/Task.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/HTTPCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -69,7 +69,7 @@ class HTTPBodyEventQueue {
   }
 
   virtual void contentLengthMismatch() {
-    XLOG(ERR) << folly::to<std::string>(
+    PRX_LOG(ERROR) << folly::to<std::string>(
         "Content-Length/body mismatch on egress: expected= ",
         expectedContentLength_,
         ", actual= ",
diff --git a/proxygen/lib/http/coro/HTTPByteEventHelpers.cpp b/proxygen/lib/http/coro/HTTPByteEventHelpers.cpp
index 1f762b39c5..bef3f5650d 100644
--- a/proxygen/lib/http/coro/HTTPByteEventHelpers.cpp
+++ b/proxygen/lib/http/coro/HTTPByteEventHelpers.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPByteEventHelpers.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 constexpr uint32_t kMaxTxAckEvents = 96;
@@ -15,7 +16,7 @@ constexpr uint32_t kMaxTxAckEvents = 96;
 namespace proxygen::coro {
 
 PendingByteEvent::~PendingByteEvent() noexcept {
-  XLOG_IF(DFATAL, callback) << "~PendingByteEvent with active callback";
+  PRX_LOG_IF(DFATAL, callback) << "~PendingByteEvent with active callback";
   onError(HTTPError{HTTPErrorCode::CANCEL, "ByteEvent Cancelled"});
 }
 
@@ -100,8 +101,8 @@ void AsyncSocketByteEventObserver::byteEvent(
     const folly::AsyncSocketObserverInterface::ByteEvent& event) noexcept {
   // Note: if there are other observers on this socket that register for TX or
   // ACK events, this observer will also fire, even if it did _not_ register.
-  XLOG(DBG5) << "byteEvent type=" << uint32_t(event.type)
-             << " off=" << event.offset;
+  PRX_VLOG(5) << "byteEvent type=" << uint32_t(event.type)
+              << " off=" << event.offset;
   if (event.type ==
       folly::AsyncSocketObserverInterface::ByteEvent::Type::WRITE) {
     maxTransportWriteOffset_ = event.offset;
@@ -124,7 +125,7 @@ void AsyncSocketByteEventObserver::byteEvent(
 void AsyncSocketByteEventObserver::scheduleOrFireTxAckEvent(
     RegAndEvent regAndEvent) {
   if (regAndEvent.registration.events & uint8_t(HTTPByteEvent::Type::NIC_TX)) {
-    XLOG(DBG5) << "Scheduling TX event off=" << maxTransportWriteOffset_;
+    PRX_VLOG(5) << "Scheduling TX event off=" << maxTransportWriteOffset_;
     // copy the ByteEvent, we are setting the type and moving it to txEvents_
     auto event = regAndEvent.byteEvent;
     event.type = HTTPByteEvent::Type::NIC_TX;
@@ -134,9 +135,9 @@ void AsyncSocketByteEventObserver::scheduleOrFireTxAckEvent(
     if (maxTransportTxOffset_ >= maxTransportWriteOffset_) {
       auto nEvents =
           PendingByteEvent::fireEvents(txEvents_, maxTransportTxOffset_);
-      XCHECK_EQ(nEvents, 1u);
+      PRX_CHECK_EQ(nEvents, 1u);
     } else {
-      XCHECK(timer_);
+      PRX_CHECK(timer_);
       refCount_.incRef();
       txEvents_.back().refcount = &refCount_;
       timer_->scheduleTimeout(&txEvents_.back(), byteEventTimeout_);
@@ -144,7 +145,7 @@ void AsyncSocketByteEventObserver::scheduleOrFireTxAckEvent(
   }
   if (regAndEvent.registration.events &
       uint8_t(HTTPByteEvent::Type::CUMULATIVE_ACK)) {
-    XLOG(DBG5) << "Scheduling ACK event off=" << maxTransportWriteOffset_;
+    PRX_VLOG(5) << "Scheduling ACK event off=" << maxTransportWriteOffset_;
     regAndEvent.byteEvent.type = HTTPByteEvent::Type::CUMULATIVE_ACK;
     ackEvents_.emplace_back(maxTransportWriteOffset_,
                             std::move(regAndEvent.byteEvent),
@@ -152,10 +153,10 @@ void AsyncSocketByteEventObserver::scheduleOrFireTxAckEvent(
     if (maxTransportAckOffset_ >= maxTransportWriteOffset_) {
       auto nEvents =
           PendingByteEvent::fireEvents(ackEvents_, maxTransportAckOffset_);
-      XCHECK_EQ(nEvents, 1u);
+      PRX_CHECK_EQ(nEvents, 1u);
     } else {
       refCount_.incRef();
-      XCHECK(timer_);
+      PRX_CHECK(timer_);
       ackEvents_.back().refcount = &refCount_;
       timer_->scheduleTimeout(&ackEvents_.back(), byteEventTimeout_);
     }
diff --git a/proxygen/lib/http/coro/HTTPByteEventHelpers.h b/proxygen/lib/http/coro/HTTPByteEventHelpers.h
index 981767a55c..2a7deb11eb 100644
--- a/proxygen/lib/http/coro/HTTPByteEventHelpers.h
+++ b/proxygen/lib/http/coro/HTTPByteEventHelpers.h
@@ -16,6 +16,7 @@
 #include <quic/api/QuicSocket.h>
 
 #include <folly/Utility.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -50,7 +51,7 @@ class PendingByteEvent : public folly::HHWheelTimer::Callback {
   }
   void timeoutExpired() noexcept override {
     // incRef called when timeout scheduled in scheduleOrFireTxAckEvent
-    XLOG(DBG4) << "ByteEvent Timeout";
+    PRX_VLOG(4) << "ByteEvent Timeout";
     onError(HTTPError{HTTPErrorCode::READ_TIMEOUT, "ByteEvent Timeout"});
   }
   HTTPByteEvent byteEvent;
@@ -96,8 +97,8 @@ class QuicByteEventCallback : public quic::ByteEventCallback {
         return quic::ByteEvent::Type::ACK;
       case HTTPByteEvent::Type::TRANSPORT_WRITE:
       default:
-        XLOG(FATAL) << "Invalid event type "
-                    << folly::to_underlying(httpByteEvent_.type);
+        PRX_LOG(FATAL) << "Invalid event type "
+                       << folly::to_underlying(httpByteEvent_.type);
     }
   }
 
@@ -109,19 +110,19 @@ class QuicByteEventCallback : public quic::ByteEventCallback {
 
  private:
   void onByteEventRegistered(quic::ByteEvent byteEvent) override {
-    XLOG(DBG4) << "onByteEventRegistered for id=" << byteEvent.id;
+    PRX_VLOG(4) << "onByteEventRegistered for id=" << byteEvent.id;
     refcount_.incRef();
   }
 
   void onByteEvent(quic::ByteEvent byteEvent) override {
-    XLOG(DBG4) << "onByteEvent for id=" << byteEvent.id;
+    PRX_VLOG(4) << "onByteEvent for id=" << byteEvent.id;
     callback_->onByteEvent(httpByteEvent_);
     refcount_.decRef();
     delete this;
   }
 
   void onByteEventCanceled(quic::ByteEvent byteEvent) override {
-    XLOG(DBG4) << "onByteEventCanceled for id=" << byteEvent.id;
+    PRX_VLOG(4) << "onByteEventCanceled for id=" << byteEvent.id;
     auto& refcount = refcount_;
     cancel();
     refcount.decRef();
diff --git a/proxygen/lib/http/coro/HTTPCoroSession.cpp b/proxygen/lib/http/coro/HTTPCoroSession.cpp
index 408e665002..d133e8d7c0 100644
--- a/proxygen/lib/http/coro/HTTPCoroSession.cpp
+++ b/proxygen/lib/http/coro/HTTPCoroSession.cpp
@@ -16,7 +16,7 @@
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
 #include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 #include <quic/state/QuicStreamUtilities.h>
 #include <wangle/acceptor/ConnectionManager.h>
@@ -55,7 +55,7 @@ HTTPErrorCode sourceCompleteErr2ErrorCode(HTTPErrorCode ec) {
     case HTTPErrorCode::CONTENT_LENGTH_MISMATCH:
       return HTTPErrorCode::CONTENT_LENGTH_MISMATCH;
     default:
-      XLOG(FATAL) << "Invalid error from sourceComplete ec=" << uint16_t(ec);
+      PRX_LOG(FATAL) << "Invalid error from sourceComplete ec=" << uint16_t(ec);
   }
 }
 
@@ -276,14 +276,14 @@ struct HTTPCoroSession::StreamState {
                               (!isIngress && msg.isEgressWebsocketUpgrade());
     if (msg.isRequest() &&
         (msg.getMethod() == HTTPMethod::CONNECT || isWebSocketUpgrade)) {
-      XCHECK(upgrade_ == Upgrade::NONE);
+      PRX_CHECK(upgrade_ == Upgrade::NONE);
       upgrade_ = Upgrade::PENDING;
     } else if (upgrade_ == Upgrade::PENDING && msg.isResponse() &&
                (msg.getStatusCode() == 200 || isWebSocketUpgrade)) {
       upgrade_ = Upgrade::UPGRADED;
     }
-    XLOG(DBG8) << __func__ << "; upgrade=" << int(upgrade_)
-               << "; isWtConnectStream=" << isWtConnectStream_;
+    PRX_VLOG(8) << __func__ << "; upgrade=" << int(upgrade_)
+                << "; isWtConnectStream=" << isWtConnectStream_;
     return upgrade_ != Upgrade::NONE;
   }
 
@@ -296,7 +296,7 @@ struct HTTPCoroSession::StreamState {
   }
 
   void markStreamSourceComplete() {
-    XCHECK(!streamSourceComplete_);
+    PRX_CHECK(!streamSourceComplete_);
     streamSourceComplete_ = true;
   }
 
@@ -305,7 +305,7 @@ struct HTTPCoroSession::StreamState {
   }
 
   void markEgressCoroComplete() {
-    XCHECK(!egressCoroComplete_);
+    PRX_CHECK(!egressCoroComplete_);
     egressCoroComplete_ = true;
   }
 
@@ -346,8 +346,8 @@ struct HTTPCoroSession::StreamState {
   }
 
   void setErrorStatusCode(uint16_t statusCode) {
-    XCHECK(canSendHeaders());
-    XCHECK(!egressCoroComplete_);
+    PRX_CHECK(canSendHeaders());
+    PRX_CHECK(!egressCoroComplete_);
     errorStatusCode = statusCode;
     cs.ingress.requestCancellation();
     std::exchange(cs.egress, {}).requestCancellation();
@@ -374,15 +374,15 @@ struct HTTPCoroSession::StreamState {
     HTTPBodyEvent bodyEvent(bodyEventQueue_.dequeueBodyEvent(maxToSend));
     if (auto* body = asBodyEv(bodyEvent)) {
       auto length = body->chainLength();
-      XLOG(DBG4) << "Sending body length=" << length << " id=" << getID()
-                 << " eom=" << uint32_t(bodyEvent.eom);
+      PRX_VLOG(4) << "Sending body length=" << length << " id=" << getID()
+                  << " eom=" << uint32_t(bodyEvent.eom);
       if (length == 0 && !bodyEvent.eom) {
         flowControlBlocked = true;
       } else {
-        XCHECK(sendWindow_.reserve(length));
+        PRX_CHECK(sendWindow_.reserve(length));
       }
     }
-    XCHECK(!bodyEvent.eom || bodyEventQueue_.empty())
+    PRX_CHECK(!bodyEvent.eom || bodyEventQueue_.empty())
         << "stream returned EOM with pending events";
     if (bodyEvent.eom) {
       markEgressComplete();
@@ -410,7 +410,8 @@ struct HTTPCoroSession::StreamState {
   void resetStream(const HTTPError& err) {
     markEgressComplete();
     if (!bodyEventQueue_.empty()) {
-      XLOG(DBG4) << "Discarding pending egress on reset for stream=" << getID();
+      PRX_VLOG(4) << "Discarding pending egress on reset for stream="
+                  << getID();
       bodyEventQueue_.clear(err);
     }
     cs.egress.requestCancellation();
@@ -472,9 +473,9 @@ HTTPCoroSession::HTTPCoroSession(folly::EventBase* eventBase,
 }
 
 HTTPCoroSession::~HTTPCoroSession() {
-  XLOG(DBG4) << "Destroying " << *this;
-  XCHECK(streams_.empty());
-  XCHECK_EQ(numPushStreams_, 0UL);
+  PRX_VLOG(4) << "Destroying " << *this;
+  PRX_CHECK(streams_.empty());
+  PRX_CHECK_EQ(numPushStreams_, 0UL);
   SESS_STATS(recordTransactionsServed, nextStreamSequenceNumber_);
   deliverLifecycleEvent(&LifecycleObserver::onDestroy, *this);
 }
@@ -504,7 +505,7 @@ HTTPQuicCoroSession::~HTTPQuicCoroSession() = default;
 
 void HTTPQuicCoroSession::setEarlyDataHandler(
     std::unique_ptr<H3EarlyDataHandler> handler) {
-  XCHECK(isUpstream());
+  PRX_CHECK(isUpstream());
   earlyDataHandler_ = std::move(handler);
 }
 
@@ -512,7 +513,7 @@ HTTPCoroSession* HTTPCoroSession::makeUpstreamCoroSession(
     std::unique_ptr<folly::coro::TransportIf> coroTransport,
     std::unique_ptr<HTTPCodec> codec,
     wangle::TransportInfo tinfo) {
-  XCHECK(proxygen::isUpstream(codec->getTransportDirection()));
+  PRX_CHECK(proxygen::isUpstream(codec->getTransportDirection()));
   return new HTTPUniplexTransportSession(
       std::move(coroTransport), std::move(codec), std::move(tinfo));
 }
@@ -522,7 +523,7 @@ HTTPCoroSession* HTTPCoroSession::makeDownstreamCoroSession(
     std::shared_ptr<HTTPHandler> handler,
     std::unique_ptr<HTTPCodec> codec,
     wangle::TransportInfo tinfo) {
-  XCHECK(proxygen::isDownstream(codec->getTransportDirection()));
+  PRX_CHECK(proxygen::isDownstream(codec->getTransportDirection()));
   return new HTTPUniplexTransportSession(std::move(coroTransport),
                                          std::move(codec),
                                          std::move(tinfo),
@@ -533,7 +534,7 @@ HTTPCoroSession* HTTPCoroSession::makeUpstreamCoroSession(
     std::shared_ptr<quic::QuicSocket> sock,
     std::unique_ptr<hq::HQMultiCodec> codec,
     wangle::TransportInfo tinfo) {
-  XCHECK(proxygen::isUpstream(codec->getTransportDirection()));
+  PRX_CHECK(proxygen::isUpstream(codec->getTransportDirection()));
   return new HTTPQuicCoroSession(
       std::move(sock), std::move(codec), std::move(tinfo));
 }
@@ -543,7 +544,7 @@ HTTPCoroSession* HTTPCoroSession::makeDownstreamCoroSession(
     std::shared_ptr<HTTPHandler> handler,
     std::unique_ptr<hq::HQMultiCodec> codec,
     wangle::TransportInfo tinfo) {
-  XCHECK(proxygen::isDownstream(codec->getTransportDirection()));
+  PRX_CHECK(proxygen::isDownstream(codec->getTransportDirection()));
   return new HTTPQuicCoroSession(
       std::move(sock), std::move(codec), std::move(tinfo), std::move(handler));
 }
@@ -607,7 +608,7 @@ void HTTPQuicCoroSession::start() {
                            multiCodec_->getQPACKDecoderWriteBuf(),
                            qpackDecoderStreamID_)) {
     // connection is unusable
-    XLOG(DBG4) << "Failed to create control stream; sess=" << *this;
+    PRX_VLOG(4) << "Failed to create control stream; sess=" << *this;
     return;
   }
   multiCodec_->setQPACKEncoderMaxDataFn([this] {
@@ -638,7 +639,7 @@ void HTTPUniplexTransportSession::setRateLimitParams(
 
 void HTTPQuicCoroSession::onPriority(quic::StreamId streamId,
                                      const HTTPPriority& pri) {
-  XCHECK(isDownstream());
+  PRX_CHECK(isDownstream());
   if (isDraining() || !quicSocket_->good()) {
     return;
   }
@@ -658,11 +659,11 @@ void HTTPQuicCoroSession::onPriority(quic::StreamId streamId,
  *  - Sets the local egress priority to the same level
  */
 size_t HTTPQuicCoroSession::sendPriority(quic::StreamId id, HTTPPriority pri) {
-  XCHECK(isUpstream());
+  PRX_CHECK(isUpstream());
 
   if (!quic::isClientBidirectionalStream(id) || !findStream(id)) {
-    XLOG(WARNING) << "sendPriority streamID = " << id
-                  << " not found; sess=" << *this;
+    PRX_LOG(WARNING) << "sendPriority streamID = " << id
+                     << " not found; sess=" << *this;
     return 0;
   }
 
@@ -677,7 +678,7 @@ size_t HTTPQuicCoroSession::sendPriority(quic::StreamId id, HTTPPriority pri) {
 
 size_t HTTPQuicCoroSession::sendPushPriority(uint64_t pushId,
                                              HTTPPriority pri) {
-  XCHECK(isUpstream());
+  PRX_CHECK(isUpstream());
 
   // Find push stream
   auto found = pushStreamsAwaitingStreamID_.contains(pushId);
@@ -692,8 +693,8 @@ size_t HTTPQuicCoroSession::sendPushPriority(uint64_t pushId,
   }
 
   if (!found) {
-    XLOG(WARNING) << "sendPushPriority pushId = " << pushId
-                  << " was not found; sess=" << *this;
+    PRX_LOG(WARNING) << "sendPushPriority pushId = " << pushId
+                     << " was not found; sess=" << *this;
     return 0;
   }
 
@@ -716,8 +717,8 @@ bool HTTPQuicCoroSession::createControlStream(
       return true;
     }
   }
-  XLOG(ERR) << __func__ << " failed for type=" << uint64_t(streamType)
-            << " sess=" << *this;
+  PRX_LOG(ERROR) << __func__ << " failed for type=" << uint64_t(streamType)
+                 << " sess=" << *this;
   connectionError(
       HTTPErrorCode::STREAM_CREATION_ERROR,
       folly::to<std::string>("Failed to create HTTP control stream, type=",
@@ -730,7 +731,7 @@ folly::coro::TaskWithExecutor<void> HTTPUniplexTransportSession::run() {
 }
 
 folly::coro::Task<void> HTTPUniplexTransportSession::runImpl() {
-  XLOG(DBG6) << "starting run sess=" << *this;
+  PRX_VLOG(6) << "starting run sess=" << *this;
   // Start the write loop asynchronously.  The writeLoop coroutine is not
   // chained for cancellation.  If readLoop detects cancellation, it will
   // trigger writeLoop to exit.
@@ -740,10 +741,10 @@ folly::coro::Task<void> HTTPUniplexTransportSession::runImpl() {
 
   // Wait for writes to complete
   co_await writesFinished_;
-  XLOG(DBG6) << "waiting for outstanding refs sess=" << *this;
+  PRX_VLOG(6) << "waiting for outstanding refs sess=" << *this;
   // expects a post outside of evb (i.e. our readExec_ will trip a check here)
   co_await co_withExecutor(eventBase_, zeroRefs()).startInlineUnsafe();
-  XLOG(DBG6) << "terminating run sess=" << *this;
+  PRX_VLOG(6) << "terminating run sess=" << *this;
   destroy();
 }
 
@@ -798,8 +799,8 @@ HTTPCoroSession::StreamState& HTTPCoroSession::createNewStream(
           getStreamRecvFlowControlWindow(),
           fromSendRequest ? std::chrono::milliseconds(0) : streamReadTimeout_,
           writeTimeout_));
-  XCHECK(res.second) << "Duplicate stream";
-  XLOG(DBG4) << "Creating id=" << streamID << " sess=" << *this;
+  PRX_CHECK(res.second) << "Duplicate stream";
+  PRX_VLOG(4) << "Creating id=" << streamID << " sess=" << *this;
   if (sessionStats_) {
     sessionStats_->recordTransactionOpened();
     if (nextStreamSequenceNumber_ > 0) {
@@ -829,7 +830,7 @@ HTTPCoroSession::StreamState* HTTPCoroSession::findStream(
     HTTPCodec::StreamID id) {
   auto it = streams_.find(id);
   if (it == streams_.end()) {
-    XLOG(DBG4) << "Stream not found sess=" << *this << " id=" << id;
+    PRX_VLOG(4) << "Stream not found sess=" << *this << " id=" << id;
     return nullptr;
   }
   return it->second.get();
@@ -845,7 +846,7 @@ void HTTPCoroSession::insertWithPriority(const StreamState& stream) {
 
 void HTTPCoroSession::onMessageBegin(HTTPCodec::StreamID streamID,
                                      HTTPMessage* /*msg*/) {
-  XLOG(DBG6) << __func__ << " streamId=" << streamID << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " streamId=" << streamID << " sess=" << *this;
   auto it = streams_.find(streamID);
   if (it == streams_.end()) {
     if (isUpstream()) {
@@ -859,7 +860,7 @@ void HTTPCoroSession::onMessageBegin(HTTPCodec::StreamID streamID,
   } else {
     if (isDownstream()) {
       // The codecs shouldn't do this, but HQ manually invokes onMessageBegin
-      XLOG_IF(DFATAL, codec_->getProtocol() != CodecProtocol::HQ)
+      PRX_LOG_IF(DFATAL, codec_->getProtocol() != CodecProtocol::HQ)
           << "Duplicate stream sess=" << *this << " id=" << streamID;
     } // upstream, it can happen
     return;
@@ -893,10 +894,10 @@ void HTTPUniplexTransportSession::onPushMessageBegin(
     HTTPCodec::StreamID streamID,
     HTTPCodec::StreamID assocStreamID,
     HTTPMessage* /*promise*/) {
-  XLOG(DBG6) << __func__ << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " sess=" << *this;
   deliverLifecycleEvent(&LifecycleObserver::onRequestBegin, *this);
   if (findStream(streamID)) {
-    XLOG(DBG4) << "Duplicate push sess=" << *this << " id=" << streamID;
+    PRX_VLOG(4) << "Duplicate push sess=" << *this << " id=" << streamID;
     return;
   }
 
@@ -916,19 +917,19 @@ void HTTPUniplexTransportSession::onPushMessageBegin(
 void HTTPQuicCoroSession::onPushMessageBegin(HTTPCodec::StreamID pushID,
                                              HTTPCodec::StreamID streamID,
                                              HTTPMessage* /*promise*/) {
-  XLOG(DBG6) << __func__ << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " sess=" << *this;
   deliverLifecycleEvent(&LifecycleObserver::onRequestBegin, *this);
   auto parent = findStream(streamID);
   // In HQ this comes from parsing on the actual parent stream
-  XCHECK(parent);
-  XCHECK(!parent->currentPushID);
+  PRX_CHECK(parent);
+  PRX_CHECK(!parent->currentPushID);
   parent->currentPushID = pushID;
 }
 
 void HTTPCoroSession::onHeadersComplete(HTTPCodec::StreamID streamID,
                                         std::unique_ptr<HTTPMessage> msg
                                         /* bool eom!*/) {
-  XLOG(DBG4) << "onHeadersComplete streamId=" << streamID << " sess=" << *this;
+  PRX_VLOG(4) << "onHeadersComplete streamId=" << streamID << " sess=" << *this;
   msg->dumpMessage(4);
   deliverLifecycleEvent(
       &LifecycleObserver::onIngressMessage, *this, *msg.get());
@@ -1000,12 +1001,13 @@ bool HTTPUniplexTransportSession::checkAndHandlePushPromiseComplete(
     // Upstream push awaiting promise headers
     stream.currentPushID.reset();
 
-    XCHECK(stream.parent);
+    PRX_CHECK(stream.parent);
     auto parent = findStream(*stream.parent);
     if (!parent) {
-      XLOG(ERR) << "Received PUSH_PROMISE but parent stream is gone. Parent "
-                << "stream=" << *stream.parent << " push stream=" << streamID
-                << " sess=" << *this;
+      PRX_LOG(ERROR)
+          << "Received PUSH_PROMISE but parent stream is gone. Parent "
+          << "stream=" << *stream.parent << " push stream=" << streamID
+          << " sess=" << *this;
       egressResetStream(streamID, &stream, HTTPErrorCode::REFUSED_STREAM);
     } else {
       stream.streamSourceActive();
@@ -1030,8 +1032,8 @@ bool HTTPQuicCoroSession::checkAndHandlePushPromiseComplete(
   auto it = pushStreamsAwaitingPromises_.find(pushID);
   if (it == pushStreamsAwaitingPromises_.end()) {
     // stream has not yet arrived
-    XLOG(DBG4) << "Push promise complete before stream, pushID=" << pushID
-               << " parent=" << stream.getID() << " sess=" << *this;
+    PRX_VLOG(4) << "Push promise complete before stream, pushID=" << pushID
+                << " parent=" << stream.getID() << " sess=" << *this;
     auto pushStream =
         std::make_unique<StreamState>(eventBase_.get(),
                                       HTTPCodec::MaxStreamID,
@@ -1044,14 +1046,14 @@ bool HTTPQuicCoroSession::checkAndHandlePushPromiseComplete(
     pushStreamsAwaitingStreamID_.emplace(pushID, std::move(pushStream));
   } else {
     auto pushStreamID = it->second;
-    XLOG(DBG4) << "Push promise matched stream=" << pushStreamID
-               << " pushID=" << pushID << " parent=" << stream.getID()
-               << " sess=" << *this;
+    PRX_VLOG(4) << "Push promise matched stream=" << pushStreamID
+                << " pushID=" << pushID << " parent=" << stream.getID()
+                << " sess=" << *this;
     pushStreamsAwaitingPromises_.erase(it);
     auto res = quicSocket_->resumeRead(pushStreamID);
     if (res.hasError()) {
-      XLOG(ERR) << "Failed to resume push stream=" << pushStreamID
-                << " sess=" << *this;
+      PRX_LOG(ERROR) << "Failed to resume push stream=" << pushStreamID
+                     << " sess=" << *this;
       // This push promise just gets silently abandoned
       return true;
     } else {
@@ -1078,17 +1080,17 @@ void HTTPQuicCoroSession::dispatchPushStream(quic::StreamId id,
   auto it = pushStreamsAwaitingStreamID_.find(pushID);
   if (it == pushStreamsAwaitingStreamID_.end()) {
     // promise has not arrived yet, pause the push stream
-    XLOG(DBG4) << "Push stream before push promise, pushID=" << pushID
-               << " stream=" << id << " sess=" << *this;
+    PRX_VLOG(4) << "Push stream before push promise, pushID=" << pushID
+                << " stream=" << id << " sess=" << *this;
     quicSocket_->pauseRead(id);
     // TODO: duplicate possibility?
     pushStreamsAwaitingPromises_.emplace(pushID, id);
   } else {
     auto pushStream = std::move(it->second);
-    XCHECK(pushStream->parent);
-    XLOG(DBG4) << "Push stream matched promise, stream id=" << id
-               << " pushID=" << pushID << " parent=" << *pushStream->parent
-               << " sess=" << *this;
+    PRX_CHECK(pushStream->parent);
+    PRX_VLOG(4) << "Push stream matched promise, stream id=" << id
+                << " pushID=" << pushID << " parent=" << *pushStream->parent
+                << " sess=" << *this;
     pushStream->streamSource.setStreamID(id);
     multiCodec_->addCodec(id);
     numPushStreams_++;
@@ -1105,7 +1107,7 @@ void HTTPCoroSession::onBody(HTTPCodec::StreamID streamID,
                              std::unique_ptr<folly::IOBuf> chain,
                              uint16_t padding
                              /* bool eom!*/) {
-  XLOG(DBG6) << __func__ << " streamId=" << streamID << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " streamId=" << streamID << " sess=" << *this;
   BufQueue body(std::move(chain));
   auto length = body.chainLength();
   if (!recvWindow_.reserve(length, padding)) {
@@ -1148,7 +1150,7 @@ void HTTPQuicCoroSession::handleIngressLimitExceeded(HTTPCodec::StreamID id) {
 
 void HTTPCoroSession::onTrailersComplete(
     HTTPCodec::StreamID streamID, std::unique_ptr<HTTPHeaders> trailers) {
-  XLOG(DBG6) << __func__ << " streamId=" << streamID << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " streamId=" << streamID << " sess=" << *this;
   auto stream = findStream(streamID);
   if (!stream) {
     return;
@@ -1158,8 +1160,8 @@ void HTTPCoroSession::onTrailersComplete(
 
 void HTTPCoroSession::onMessageComplete(HTTPCodec::StreamID streamID,
                                         bool upgrade) {
-  XLOG(DBG6) << __func__ << " streamId=" << streamID
-             << " upgrade=" << int(upgrade) << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " streamId=" << streamID
+              << " upgrade=" << int(upgrade) << " sess=" << *this;
   auto stream = findStream(streamID);
   if (!stream) {
     return;
@@ -1191,8 +1193,8 @@ void HTTPCoroSession::onMessageComplete(HTTPCodec::StreamID streamID,
 void HTTPCoroSession::onError(HTTPCodec::StreamID streamID,
                               const HTTPException& error,
                               bool /*newTxn*/) {
-  XLOG(DBG4) << "Parse error, ex=" << error.what() << " id=" << streamID
-             << " sess=" << *this;
+  PRX_VLOG(4) << "Parse error, ex=" << error.what() << " id=" << streamID
+              << " sess=" << *this;
   if (streamID == getSessionStreamID()) {
     // TODO: HTTPSession reports kErrorMessage here, but that doesn't
     // seem right for H2.
@@ -1207,7 +1209,8 @@ void HTTPCoroSession::onError(HTTPCodec::StreamID streamID,
                       error.what());
     } else {
       // Session errors, only comes from H2/QCodecs, with an error code
-      XLOG(FATAL) << "Session error with no protocol error code sess=" << *this;
+      PRX_LOG(FATAL) << "Session error with no protocol error code sess="
+                     << *this;
     }
     return;
   }
@@ -1241,8 +1244,8 @@ void HTTPCoroSession::onResetStream(HTTPCodec::StreamID streamID,
   if (!stream) {
     return;
   }
-  XLOG(DBG4) << "Received RST_STREAM code=" << static_cast<uint32_t>(code)
-             << " sess=" << *this << " id=" << streamID;
+  PRX_VLOG(4) << "Received RST_STREAM code=" << static_cast<uint32_t>(code)
+              << " sess=" << *this << " id=" << streamID;
   decrementPushStreamCount(*stream);
   deliverAbort(*stream, code, "received RST_STREAM from peer");
 }
@@ -1284,12 +1287,13 @@ void HTTPQuicCoroSession::deliverAbort(StreamState& stream,
 void HTTPCoroSession::onGoaway(uint64_t lastGoodStreamID,
                                ErrorCode code,
                                std::unique_ptr<folly::IOBuf> /*debugData*/) {
-  XLOG(DBG4) << __func__ << " lastGoodStreamID=" << lastGoodStreamID
-             << " code=" << int(code) << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " lastGoodStreamID=" << lastGoodStreamID
+              << " code=" << int(code) << " sess=" << *this;
   // TODO: Queue an onGoaway event for all active transactions
   //       Do something with debugData?
 
-  XCHECK(codec_->supportsParallelRequests()) << "GOAWAY is for parallel codecs";
+  PRX_CHECK(codec_->supportsParallelRequests())
+      << "GOAWAY is for parallel codecs";
 
   // Notify the interested parties
   deliverLifecycleEvent(
@@ -1338,7 +1342,7 @@ bool HTTPQuicCoroSession::streamRefusedByGoaway(
 }
 
 void HTTPCoroSession::drainStarted() {
-  XLOG(DBG4)
+  PRX_VLOG(4)
       << "Drain started, setting maxConcurrentOutgoingStreamsConfig_ to 0 "
       << "sess=" << *this;
   const bool wasDraining = isDraining();
@@ -1352,13 +1356,13 @@ void HTTPCoroSession::connectionError(
     HTTPErrorCode httpError,
     std::string msg,
     folly::Optional<HTTPErrorCode> streamError) {
-  XLOG(DBG4) << "connectionError msg=" << msg << " sess=" << *this;
+  PRX_VLOG(4) << "connectionError msg=" << msg << " sess=" << *this;
   drainStarted();
   handleConnectionError(httpError, msg);
   resetOpenStreams(streamError.value_or(httpError), msg);
   writeEvent_.signal();
   interruptReadLoop();
-  XCHECK(!codec_->isWaitingToDrain());
+  PRX_CHECK(!codec_->isWaitingToDrain());
   writableStreams_.clear();
 }
 
@@ -1385,7 +1389,7 @@ void HTTPQuicCoroSession::handleConnectionError(HTTPErrorCode error,
 }
 
 void HTTPCoroSession::initiateDrain() {
-  XLOG(DBG4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   if (isDraining()) {
     return;
   }
@@ -1401,7 +1405,7 @@ void HTTPCoroSession::initiateDrain() {
 }
 
 void HTTPCoroSession::closeWhenIdle() {
-  XLOG(DBG4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   goawayTimeoutExpired();
   goawayTimeout_.cancelTimeout();
 }
@@ -1415,7 +1419,7 @@ void HTTPCoroSession::goawayTimeoutExpired() {
 }
 
 void HTTPCoroSession::dropConnection(const std::string& errorMsg) {
-  XLOG(DBG4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
 
   // TODO: dropping a connection with open streams will almost certainly not
   // complete within the current event loop, which can be problematic.
@@ -1547,8 +1551,8 @@ void HTTPUniplexTransportSession::onWindowUpdate(HTTPCodec::StreamID streamID,
                           "Peer overflowed stream window, stream=", streamID));
       return;
     } else if (res.value()) {
-      XLOG(DBG4) << "Adding previously blocked stream to writable id="
-                 << streamID << " sess=" << *this;
+      PRX_VLOG(4) << "Adding previously blocked stream to writable id="
+                  << streamID << " sess=" << *this;
       notifyBodyWrite(*stream);
     }
   }
@@ -1564,8 +1568,9 @@ void HTTPUniplexTransportSession::onSettings(const SettingsList& settings) {
       }
     } else if (setting.id == SettingsId::MAX_CONCURRENT_STREAMS) {
       auto maxStreams = setting.value;
-      XLOG(DBG4) << "Got new max number of concurrent streams we can initiate: "
-                 << maxStreams << " sess=" << *this;
+      PRX_VLOG(4)
+          << "Got new max number of concurrent streams we can initiate: "
+          << maxStreams << " sess=" << *this;
       bool didSupport = supportsMoreTransactions();
       maxConcurrentOutgoingStreamsRemote_ = maxStreams;
       onSetMaxInitiatedStreams(didSupport);
@@ -1621,8 +1626,8 @@ void HTTPQuicCoroSession::onSettings(const SettingsList& settings) {
   multiCodec_->getQPACKCodec().setEncoderHeaderTableSize(tableSize);
   multiCodec_->getQPACKCodec().setMaxVulnerable(blocked);
   writeEvent_.signal();
-  XLOG(DBG3) << "Applied SETTINGS sess=" << *this << " size=" << tableSize
-             << " blocked=" << blocked;
+  PRX_VLOG(3) << "Applied SETTINGS sess=" << *this << " size=" << tableSize
+              << " blocked=" << blocked;
 }
 
 void HTTPCoroSession::onSetMaxInitiatedStreams(bool didSupport) {
@@ -1666,8 +1671,8 @@ void HTTPUniplexTransportSession::bytesProcessed(HTTPCodec::StreamID id,
   if (!codec_->supportsSessionFlowControl()) {
     auto stream = findStream(id);
     if (stream && shouldResumeIngress(*stream, delta)) {
-      XLOG(DBG4) << "resuming stream previously ingress limited; sess="
-                 << *this;
+      PRX_VLOG(4) << "resuming stream previously ingress limited; sess="
+                  << *this;
       flowControlBaton_.signal();
     }
   }
@@ -1680,7 +1685,7 @@ void HTTPQuicCoroSession::bytesProcessed(HTTPCodec::StreamID id,
 
   auto stream = findStream(id);
   if (stream && shouldResumeIngress(*stream, delta)) {
-    XLOG(DBG4) << "resuming stream previously ingress limited; sess=" << *this;
+    PRX_VLOG(4) << "resuming stream previously ingress limited; sess=" << *this;
     // We were previously read limited and now we're not, so we can resume the
     // read loop only if we're not qpack blocked.
     if (multiCodec_->setCurrentStream(id) && !multiCodec_->isParserPaused()) {
@@ -1696,16 +1701,16 @@ bool HTTPUniplexTransportSession::sendFlowControlUpdate(HTTPCodec::StreamID id,
 
 void HTTPCoroSession::sourceComplete(HTTPCodec::StreamID id,
                                      folly::Optional<HTTPError> error) {
-  XLOG(DBG6) << __func__ << " sess=" << *this << " id=" << id
-             << " error=" << (error.has_value() ? error->describe() : "");
-  auto stream = CHECK_NOTNULL(findStream(id));
+  PRX_VLOG(6) << __func__ << " sess=" << *this << " id=" << id
+              << " error=" << (error.has_value() ? error->describe() : "");
+  auto stream = PRX_CHECK_NOTNULL(findStream(id));
   stream->markStreamSourceComplete();
   if (stream->streamSource.isEOMSeen() && !error) {
     checkForDetach(*stream);
     return;
   }
-  XCHECK(error) << "StreamSource must supply an error when source complete "
-                << "but not EOM seen";
+  PRX_CHECK(error) << "StreamSource must supply an error when source complete "
+                   << "but not EOM seen";
   if (isDownstream() && stream->canSendHeaders() &&
       (stream->errorStatusCode || error->code == HTTPErrorCode::READ_TIMEOUT)) {
     // If there's an error source, don't reset, otherwise it's a timeout
@@ -1735,8 +1740,8 @@ void HTTPCoroSession::sourceComplete(HTTPCodec::StreamID id,
     }
   } else {
     // The stream is complete, but there's nothing to egress on the wire.
-    XLOG(DBG4) << "Clearing stream state for stream=" << id
-               << " sess=" << *this;
+    PRX_VLOG(4) << "Clearing stream state for stream=" << id
+                << " sess=" << *this;
     resetStreamState(*stream, *error);
   }
   writeEvent_.signal();
@@ -1753,8 +1758,8 @@ void HTTPQuicCoroSession::handleDeferredStopSending(HTTPCodec::StreamID id) {
 }
 
 void HTTPCoroSession::egressFinished(StreamState& stream) {
-  XLOG(DBG4) << "egress finished for stream id=" << stream.getID()
-             << " sess=" << *this;
+  PRX_VLOG(4) << "egress finished for stream id=" << stream.getID()
+              << " sess=" << *this;
   decrementPushStreamCount(stream,
                            /*eomMarkedEgressComplete=*/true);
   deliverLifecycleEvent(&LifecycleObserver::onRequestEnd, *this, 0);
@@ -1766,8 +1771,8 @@ void HTTPCoroSession::egressFinished(StreamState& stream) {
 
 folly::coro::Task<HTTPSourceHolder> HTTPCoroSession::handleRequest(
     StreamState& stream) {
-  XLOG(DBG6) << "starting handleRequest id=" << stream.getID()
-             << " sess=" << *this;
+  PRX_VLOG(6) << "starting handleRequest id=" << stream.getID()
+              << " sess=" << *this;
   HTTPSourceHolder responseSource{nullptr};
   // Don't invoke handleRequest if egress is already complete
   if (!stream.isEgressComplete()) {
@@ -1775,7 +1780,7 @@ folly::coro::Task<HTTPSourceHolder> HTTPCoroSession::handleRequest(
     auto res = co_await co_awaitTry(handler_->handleRequest(
         eventBase_.get(), acquireKeepAlive(), &stream.streamSource));
     if (auto* ex = res.tryGetExceptionObject()) {
-      XLOG(DBG4) << "Handler generated exception: " << ex->what();
+      PRX_VLOG(4) << "Handler generated exception: " << ex->what();
       responseSource = getErrorResponse(500, ex->what());
     } else {
       responseSource = std::move(res.value());
@@ -1795,14 +1800,14 @@ folly::coro::Task<void> HTTPCoroSession::readResponse(
 
   auto responseSource = co_await std::move(getRespSourceTask);
   if (stream.isEgressComplete()) {
-    XLOG(DBG4)
+    PRX_VLOG(4)
         << "readResponse egressComplete responseSource=" << int(responseSource)
         << " id=" << stream.getID() << " sess=" << *this;
     co_return;
   }
   if (!responseSource) {
-    XLOG(DBG3) << "Handler did not provide a response source, returning 500"
-               << " id=" << stream.getID() << " sess=" << *this;
+    PRX_VLOG(3) << "Handler did not provide a response source, returning 500"
+                << " id=" << stream.getID() << " sess=" << *this;
     responseSource.setSource(getErrorResponse(500));
   }
   stream.setEgressSource(responseSource.release());
@@ -1818,7 +1823,7 @@ folly::coro::Task<void> HTTPCoroSession::readResponse(
       co_return;
     }
   } while (responseState == ResponseState::HEADERS);
-  XLOG(DBG6) << "Done generating headers sess=" << *this;
+  PRX_VLOG(6) << "Done generating headers sess=" << *this;
   g.dismiss();
   co_withExecutor(eventBase_,
                   co_withCancellation(wcs.getToken(),
@@ -1833,7 +1838,7 @@ HTTPCoroSession::ResponseState HTTPCoroSession::processResponseHeaderEvent(
   }
 
   auto switchToErrSource = [&](HTTPErrorCode ec) {
-    XLOG(DBG4) << "switchToErrSource sc=" << stream.errorStatusCode;
+    PRX_VLOG(4) << "switchToErrSource sc=" << stream.errorStatusCode;
     stream.stopReading(ec);
     stream.setEgressSource(
         getErrorResponse(std::exchange(stream.errorStatusCode, 0)));
@@ -1842,8 +1847,8 @@ HTTPCoroSession::ResponseState HTTPCoroSession::processResponseHeaderEvent(
 
   if (headerEvent.hasException()) {
     auto ex = getHTTPError(headerEvent);
-    XLOG(DBG4) << "Error getting response headers sess=" << *this
-               << " ex=" << ex.msg;
+    PRX_VLOG(4) << "Error getting response headers sess=" << *this
+                << " ex=" << ex.msg;
     if (stream.errorStatusCode) {
       return switchToErrSource(ex.code);
     }
@@ -1858,8 +1863,8 @@ HTTPCoroSession::ResponseState HTTPCoroSession::processResponseHeaderEvent(
     return switchToErrSource(HTTPErrorCode::INTERNAL_ERROR);
   }
 
-  XLOG(DBG4) << "Got response headers eom=" << uint32_t(headerEvent->eom)
-             << " sess=" << *this;
+  PRX_VLOG(4) << "Got response headers eom=" << uint32_t(headerEvent->eom)
+              << " sess=" << *this;
   headers.dumpMessage(4);
   auto upgrade = stream.checkForUpgrade(headers, /*isIngress=*/false);
   if (upgrade & !codec_->supportsParallelRequests()) {
@@ -1894,7 +1899,7 @@ HTTPCoroSession::ResponseState HTTPCoroSession::processResponseHeaderEvent(
 
   const bool wtConnectStream =
       upgrade && stream.isWtConnectStream() && headerEvent->wtHandler;
-  XLOG(DBG8) << "wtConnectStream=" << wtConnectStream;
+  PRX_VLOG(8) << "wtConnectStream=" << wtConnectStream;
   if (wtConnectStream) { // must be a 200 since upgrade is true
     WtHelper wtHelper{*this};
     auto egress = wtHelper.createEgressSource();
@@ -1934,13 +1939,14 @@ bool HTTPQuicCoroSession::handleWrite(HTTPCodec::StreamID id,
   }
   deliverLifecycleEvent(
       &LifecycleObserver::onWrite, *this, writeBuf.chainLength());
-  XLOG(DBG4) << "Writing id=" << id << " len=" << writeBuf.chainLength()
-             << " eom=" << (eom ? "true" : "false") << " sess=" << *this;
+  PRX_VLOG(4) << "Writing id=" << id << " len=" << writeBuf.chainLength()
+              << " eom=" << (eom ? "true" : "false") << " sess=" << *this;
   auto res = quicSocket_->writeChain(
       id, writeBuf.move(), eom, eom ? &deliveryCallback_ : nullptr);
   if (res.hasError()) {
-    XLOG(DBG3) << "Error writing to stream, err=" << quic::toString(res.error())
-               << " id=" << id << " sess=" << *this;
+    PRX_VLOG(3)
+        << "Error writing to stream, err=" << quic::toString(res.error())
+        << " id=" << id << " sess=" << *this;
     connectionError(HTTPErrorCode::INTERNAL_ERROR, "Write failed");
     return false;
   }
@@ -1949,7 +1955,7 @@ bool HTTPQuicCoroSession::handleWrite(HTTPCodec::StreamID id,
 
 folly::coro::Task<void> HTTPCoroSession::transferBody(
     StreamState& stream, std::function<void()> guard) {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
   auto errorCode = HTTPErrorCode::NO_ERROR;
   SCOPE_EXIT {
     stream.stopReading(errorCode);
@@ -1957,13 +1963,13 @@ folly::coro::Task<void> HTTPCoroSession::transferBody(
   };
   bool eom = false;
   do {
-    XLOG(DBG4) << "Waiting for a body event id=" << stream.getID()
-               << " sess=" << *this;
+    PRX_VLOG(4) << "Waiting for a body event id=" << stream.getID()
+                << " sess=" << *this;
     auto eomEvent = co_await co_awaitTry(stream.nextBodyEvent());
     if (eomEvent.hasException()) {
       auto err = getHTTPError(eomEvent);
-      XLOG(DBG4) << "Error getting body sess=" << *this
-                 << " id=" << stream.getID() << " err=" << err.msg;
+      PRX_VLOG(4) << "Error getting body sess=" << *this
+                  << " id=" << stream.getID() << " err=" << err.msg;
       if (!stream.isEgressComplete()) {
         egressResetStream(stream.getID(), &stream, err.code, true);
       }
@@ -1990,7 +1996,7 @@ void HTTPUniplexTransportSession::registerByteEvents(
     uint64_t bodyOffset,
     std::vector<HTTPByteEventRegistration>&& regs,
     bool eom) {
-  XCHECK(streamByteOffset) << "streamByteOffset required for uniplex";
+  PRX_CHECK(streamByteOffset) << "streamByteOffset required for uniplex";
   auto sessionByteOffset = sessionBytesScheduled_ + writeBuf_.chainLength();
   byteEventObserver_.registerByteEvents(id,
                                         sessionByteOffset,
@@ -2015,7 +2021,7 @@ void HTTPQuicCoroSession::registerByteEvents(
     if (maybeStreamByteOffset.has_value()) {
       // TODO: could save this lookup by passing stream*
       auto stream = findStream(id);
-      XCHECK(stream);
+      PRX_CHECK(stream);
       streamByteOffset =
           *maybeStreamByteOffset + stream->getWriteBuf().chainLength();
     } else {
@@ -2066,14 +2072,14 @@ void HTTPCoroSession::notifyBodyWrite(StreamState& stream) {
 void HTTPQuicCoroSession::onDatagramsAvailable() noexcept {
   auto result = quicSocket_->readDatagrams();
   if (result.hasError()) {
-    XLOG(ERR) << "Got error while reading datagrams: error="
-              << toString(result.error());
+    PRX_LOG(ERROR) << "Got error while reading datagrams: error="
+                   << toString(result.error());
     connectionError(HTTPErrorCode::INTERNAL_ERROR,
                     "H3_DATAGRAM: internal error");
     return;
   }
-  XLOG(DBG4) << "Received " << result.value().size()
-             << " datagrams. sess=" << *this;
+  PRX_VLOG(4) << "Received " << result.value().size()
+              << " datagrams. sess=" << *this;
   for (auto& datagram : result.value()) {
     folly::io::Cursor cursor(datagram.bufQueue().front());
     auto quarterStreamId = quic::follyutils::decodeQuicInteger(cursor);
@@ -2091,8 +2097,8 @@ void HTTPQuicCoroSession::onDatagramsAvailable() noexcept {
     auto stream = findStream(streamId);
 
     if (!stream || stream->streamSource.isUnprocessed()) {
-      XLOG(DBG5) << "Stream cannot receive datagrams. streamId=" << streamId
-                 << " len=" << datagramQ.chainLength() << " sess=" << *this;
+      PRX_VLOG(5) << "Stream cannot receive datagrams. streamId=" << streamId
+                  << " len=" << datagramQ.chainLength() << " sess=" << *this;
       // TODO: a possible optimization would be to discard datagrams destined
       // to streams that were already closed
       auto itr = datagramsBuffer_.find(streamId);
@@ -2109,8 +2115,8 @@ void HTTPQuicCoroSession::onDatagramsAvailable() noexcept {
       continue;
     }
 
-    XLOG(DBG5) << "Received datagram for streamId=" << streamId
-               << " len=" << datagramQ.chainLength() << " sess=" << *this;
+    PRX_VLOG(5) << "Received datagram for streamId=" << streamId
+                << " len=" << datagramQ.chainLength() << " sess=" << *this;
     stream->streamSource.datagram(datagramQ.move());
   }
 }
@@ -2145,14 +2151,14 @@ bool HTTPQuicCoroSession::sendDatagram(HTTPCodec::StreamID id,
   if (streamIdRes.hasError()) {
     return false;
   }
-  XLOG(DBG5) << "Sending datagram for streamId=" << id
-             << " len=" << datagram->computeChainDataLength()
-             << " sess=" << *this;
+  PRX_VLOG(5) << "Sending datagram for streamId=" << id
+              << " len=" << datagram->computeChainDataLength()
+              << " sess=" << *this;
   quic::BufQueue queue(std::move(headerBuf));
   queue.append(std::move(datagram));
   auto writeRes = quicSocket_->writeDatagram(queue.move());
   if (writeRes.hasError()) {
-    XLOG(DBG5) << "Failed to send datagram for streamId=" << id;
+    PRX_VLOG(5) << "Failed to send datagram for streamId=" << id;
     return false;
   }
   return true;
@@ -2190,10 +2196,10 @@ folly::coro::Task<HTTPSourceHolder> HTTPCoroSession::sendRequest(
 
 folly::Try<HTTPCoroSession::RequestReservation>
 HTTPCoroSession::reserveRequest() {
-  XLOG(DBG6) << "reserveRequest sess=" << *this;
+  PRX_VLOG(6) << "reserveRequest sess=" << *this;
   if (!supportsMoreTransactions()) {
-    XLOG(ERR) << "Refusing to send request, streams=" << numOutgoingStreams()
-              << " sess=" << *this;
+    PRX_LOG(ERROR) << "Refusing to send request, streams="
+                   << numOutgoingStreams() << " sess=" << *this;
     return folly::Try<RequestReservation>(
         HTTPError(HTTPErrorCode::REFUSED_STREAM, "Exceeded stream limit"));
   }
@@ -2206,7 +2212,7 @@ HTTPCoroSession::reserveRequest() {
 folly::coro::Task<HTTPSourceHolder> HTTPCoroSession::sendRequest(
     HTTPSourceHolder requestSource, RequestReservation reservation) {
   if (!reservation.fromSession(this)) {
-    XLOG(DFATAL) << "Invalid reservation sess=" << *this;
+    PRX_LOG(DFATAL) << "Invalid reservation sess=" << *this;
     co_yield co_error(
         HTTPError(HTTPErrorCode::INTERNAL_ERROR, "Invalid reservation"));
   }
@@ -2214,15 +2220,15 @@ folly::coro::Task<HTTPSourceHolder> HTTPCoroSession::sendRequest(
   auto headerEvent = co_await co_awaitTry(requestSource.readHeaderEvent());
   const auto& cancelToken = co_await folly::coro::co_current_cancellation_token;
   if (cancelToken.isCancellationRequested()) {
-    XLOG(DBG4) << "Egress coro cancelled for new stream, sess=" << *this;
+    PRX_VLOG(4) << "Egress coro cancelled for new stream, sess=" << *this;
     co_yield co_error(HTTPError(HTTPErrorCode::CORO_CANCELLED, "Cancelled"));
   }
   if (headerEvent.hasException()) {
-    XLOG(DBG4) << "Error getting headers for sess=" << *this;
+    PRX_VLOG(4) << "Error getting headers for sess=" << *this;
     co_yield co_error(getHTTPError(headerEvent));
   }
   if (isDraining()) {
-    XLOG(DBG3) << "Refusing to send new stream on draining sess=" << *this;
+    PRX_VLOG(3) << "Refusing to send new stream on draining sess=" << *this;
     co_yield co_error(
         HTTPError(HTTPErrorCode::REFUSED_STREAM, "Session draining"));
   }
@@ -2243,12 +2249,12 @@ folly::Expected<HTTPSourceHolder, HTTPError> HTTPCoroSession::sendRequest(
     const HTTPMessage& headers,
     HTTPSourceHolder bodySource) noexcept {
   if (!reservation.fromSession(this)) {
-    XLOG(DFATAL) << "Invalid reservation sess=" << *this;
+    PRX_LOG(DFATAL) << "Invalid reservation sess=" << *this;
     return folly::makeUnexpected(
         HTTPError{HTTPErrorCode::INTERNAL_ERROR, "Invalid reservation"});
   }
   if (isDraining()) {
-    XLOG(DBG3) << "Refusing to send new stream on draining sess=" << *this;
+    PRX_VLOG(3) << "Refusing to send new stream on draining sess=" << *this;
     return folly::makeUnexpected(
         HTTPError(HTTPErrorCode::REFUSED_STREAM, "Session draining"));
   }
@@ -2266,7 +2272,7 @@ folly::Expected<HTTPSourceHolder, HTTPError> HTTPCoroSession::sendRequestImpl(
     HTTPSourceHolder bodySource) noexcept {
   auto* stream = createReqStream();
   if (!stream) {
-    XLOG(ERR) << "Failed to create new stream" << *this;
+    PRX_LOG(ERROR) << "Failed to create new stream" << *this;
     return folly::makeUnexpected(
         HTTPError{HTTPErrorCode::REFUSED_STREAM, "Create stream failed"});
   }
@@ -2274,7 +2280,7 @@ folly::Expected<HTTPSourceHolder, HTTPError> HTTPCoroSession::sendRequestImpl(
     stream->markIngressAsHeadResponse();
   }
   auto streamID = stream->getID();
-  XLOG(DBG4) << "Got request headers sess=" << *this << " id=" << streamID;
+  PRX_VLOG(4) << "Got request headers sess=" << *this << " id=" << streamID;
   headers.dumpMessage(4);
   stream->checkForUpgrade(headers, /*isIngress=*/false);
   // TODO: do we want to throttle reading request headers on buffer space
@@ -2282,7 +2288,7 @@ folly::Expected<HTTPSourceHolder, HTTPError> HTTPCoroSession::sendRequestImpl(
   HTTPHeaderSize size;
   codec_->generateHeader(stream->getWriteBuf(), streamID, headers, eom, &size);
   stream->addToStreamOffset(size.compressed);
-  XLOG(DBG6) << "Done generating headers sess=" << *this << " id=" << streamID;
+  PRX_VLOG(6) << "Done generating headers sess=" << *this << " id=" << streamID;
   HTTPByteEvent::FieldSectionInfo fsInfo = {
       HTTPByteEvent::FieldSectionInfo::Type::HEADERS, true, size};
   registerByteEvents(stream->getID(),
@@ -2313,7 +2319,7 @@ folly::Expected<HTTPSourceHolder, HTTPError> HTTPCoroSession::sendRequestImpl(
                         transferRequestBody(*stream, std::move(bodySource))))
         .startInlineUnsafe();
   }
-  XLOG(DBG6) << "terminating sendRequest sess=" << *this << " id=" << streamID;
+  PRX_VLOG(6) << "terminating sendRequest sess=" << *this << " id=" << streamID;
 
   return &stream->streamSource;
 }
@@ -2380,7 +2386,7 @@ void HTTPUniplexTransportSession::generateResetStream(
   // h1 & h2 resets are bidirectional (terminates ingress & egress)
   if (!codec_->generateRstStream(
           writeBuf_, id, HTTPErrorCode2ErrorCode(error, fromSource))) {
-    XLOG(DBG4) << "resetAfterDrainingWrites sess=" << *this;
+    PRX_VLOG(4) << "resetAfterDrainingWrites sess=" << *this;
     resetAfterDrainingWrites_ = true;
     drainStarted();
   }
@@ -2395,8 +2401,8 @@ void HTTPQuicCoroSession::generateResetStream(HTTPCodec::StreamID id,
   // not valid for uni-ingress
   if (quicSocket_->isBidirectionalStream(id) ||
       (quicSocket_->isServerStream(id) == isDownstream())) {
-    XLOG(DBG4) << "resetStream err=" << uint32_t(error) << " id=" << id
-               << " sess=" << *this;
+    PRX_VLOG(4) << "resetStream err=" << uint32_t(error) << " id=" << id
+                << " sess=" << *this;
     quicSocket_->resetStream(id, quic::ApplicationErrorCode(h3Error));
   }
 
@@ -2415,8 +2421,8 @@ void HTTPQuicCoroSession::generateStopSending(HTTPCodec::StreamID id,
       quicSocket_->isServerStream(id) == isUpstream()) {
 
     HTTP3::ErrorCode h3Error = HTTPErrorCode2HTTP3ErrorCode(error, fromSource);
-    XLOG(DBG4) << "stopSending err=" << uint32_t(error) << " id=" << id
-               << " sess=" << *this;
+    PRX_VLOG(4) << "stopSending err=" << uint32_t(error) << " id=" << id
+                << " sess=" << *this;
 
     multiCodec_->encodeCancelStream(id);
     quicSocket_->stopSending(id, quic::ApplicationErrorCode(h3Error));
@@ -2437,7 +2443,7 @@ void HTTPCoroSession::resetStreamState(StreamState& stream,
 
 bool HTTPCoroSession::checkForDetach(StreamState& stream) {
   if (stream.isDetachable()) {
-    XLOG(DBG4) << "detaching stream=" << stream.getID() << " sess=" << *this;
+    PRX_VLOG(4) << "detaching stream=" << stream.getID() << " sess=" << *this;
     eraseStream(stream.getID());
     transactionDetached();
     if (!codec_->supportsParallelRequests() && streams_.size() <= 1) {
@@ -2518,7 +2524,7 @@ bool HTTPUniplexTransportSession::shouldContinueReadLooping() const {
   bool continueLoop = !writesFinished_.ready() && !resetAfterDrainingWrites_ &&
                       (codec_->isReusable() || !streams_.empty());
   // clang-format off
-  XLOG(DBG4)
+  PRX_VLOG(4)
     << __func__
     << " continue=" << uint32_t(continueLoop)
     << " writesFinished_=" << uint32_t(writesFinished_.ready())
@@ -2531,20 +2537,20 @@ bool HTTPUniplexTransportSession::shouldContinueReadLooping() const {
 }
 
 folly::coro::Task<void> HTTPUniplexTransportSession::readLoop() noexcept {
-  XLOG(DBG6) << "starting readLoop sess=" << *this;
+  PRX_VLOG(6) << "starting readLoop sess=" << *this;
   folly::IOBufQueue readBuf(folly::IOBufQueue::cacheChainLength());
   const auto& cancelToken = co_await folly::coro::co_current_cancellation_token;
   folly::CancellationCallback cancellationCallback{
       cancelToken, [this] { dropConnection("Connection dropped (cancel)"); }};
   while (shouldContinueReadLooping()) {
-    XLOG(DBG6) << "before read sess=" << *this;
+    PRX_VLOG(6) << "before read sess=" << *this;
     auto cancellationToken = readCancellationSource_.getToken();
     if (!flowControlBaton_.ready()) {
       flowControlBaton_.reset();
       auto status = co_await flowControlBaton_.timedWait(eventBase_.get(),
                                                          connReadTimeout_);
       if (status == TimedBaton::Status::timedout) {
-        XLOG(DBG4) << "Timed out waiting for flow control sess=" << *this;
+        PRX_VLOG(4) << "Timed out waiting for flow control sess=" << *this;
         connectionError(HTTPErrorCode::READ_TIMEOUT,
                         "ingress backpressure timeout");
         break;
@@ -2559,30 +2565,30 @@ folly::coro::Task<void> HTTPUniplexTransportSession::readLoop() noexcept {
               readBuf, kMinReadSize, readBufNewAllocSize_, connReadTimeout_)));
     }
     if (cancellationToken.isCancellationRequested()) {
-      XLOG(DBG4) << "Read cancelled sess=" << *this;
-      XCHECK(!shouldContinueReadLooping());
+      PRX_VLOG(4) << "Read cancelled sess=" << *this;
+      PRX_CHECK(!shouldContinueReadLooping());
       if (rc.hasException()) {
         continue;
       }
     }
     if (rc.hasException()) {
       auto ex = rc.exception().get_exception<folly::AsyncSocketException>();
-      XCHECK(ex) << "Unexpected exception type "
-                 << folly::exceptionStr(rc.exception());
+      PRX_CHECK(ex) << "Unexpected exception type "
+                    << folly::exceptionStr(rc.exception());
       if (ex->getType() == folly::coro::TransportIf::ErrorCode::TIMED_OUT) {
-        XLOG(DBG4) << "Initiating drain due to read timeout sess=" << *this;
+        PRX_VLOG(4) << "Initiating drain due to read timeout sess=" << *this;
         initiateDrain();
         continue;
       }
       deliverLifecycleEvent(
           &LifecycleObserver::onIngressError, *this, kErrorConnectionReset);
 
-      XLOG(DBG4) << "Read Error ex=" << ex->what() << " sess=" << *this;
+      PRX_VLOG(4) << "Read Error ex=" << ex->what() << " sess=" << *this;
       connectionError(HTTPErrorCode::TRANSPORT_READ_ERROR, ex->what());
       break;
     }
     if (*rc == 0) { // peer closed the connection
-      XLOG(DBG4) << "Read EOF sess=" << *this;
+      PRX_VLOG(4) << "Read EOF sess=" << *this;
       deliverLifecycleEvent(&LifecycleObserver::onIngressEOF, *this);
       codec_->onIngressEOF();
       for (auto& [_, stream] : streams_) {
@@ -2590,7 +2596,7 @@ folly::coro::Task<void> HTTPUniplexTransportSession::readLoop() noexcept {
       }
       break;
     }
-    XLOG(DBG6) << "Read " << *rc << " bytes sess=" << *this;
+    PRX_VLOG(6) << "Read " << *rc << " bytes sess=" << *this;
     deliverLifecycleEvent(
         &LifecycleObserver::onRead, *this, *rc, HTTPCodec::NoStream);
     // We basically have two timeouts here
@@ -2601,11 +2607,11 @@ folly::coro::Task<void> HTTPUniplexTransportSession::readLoop() noexcept {
       readBuf.trimStart(bytesParsed);
       if (bytesParsed == 0 && !readBuf.empty() &&
           !codec_->supportsParallelRequests() && streams_.size() > 1) {
-        XLOG(DBG4) << "Waiting for previous transaction(s) to finish before "
-                   << "parsing more sess=" << *this;
+        PRX_VLOG(4) << "Waiting for previous transaction(s) to finish before "
+                    << "parsing more sess=" << *this;
         antiPipelineBaton_.reset();
         auto status = co_await antiPipelineBaton_.wait();
-        XCHECK(status != TimedBaton::Status::timedout);
+        PRX_CHECK(status != TimedBaton::Status::timedout);
         if (status != TimedBaton::Status::cancelled) {
           // pretend we parsed something so we go around the loop again
           bytesParsed = 1;
@@ -2624,26 +2630,27 @@ folly::coro::Task<void> HTTPUniplexTransportSession::readLoop() noexcept {
   }
   readsClosed_ = true;
   writeEvent_.signal();
-  XLOG(DBG6) << "readLoop terminating sess=" << *this;
+  PRX_VLOG(6) << "readLoop terminating sess=" << *this;
 }
 
 void HTTPQuicCoroSession::onNewBidirectionalStream(quic::StreamId id) noexcept {
-  XLOG(DBG4) << "New bidi stream=" << id << " sess=" << *this;
+  PRX_VLOG(4) << "New bidi stream=" << id << " sess=" << *this;
   resetIdleTimeout();
   // TODO: downstream only, for now
   if (isUpstream()) {
-    XLOG(DBG4) << "Refusing server-init bidi id=" << id << " sess=" << *this;
+    PRX_VLOG(4) << "Refusing server-init bidi id=" << id << " sess=" << *this;
     egressResetStream(id, nullptr, HTTPErrorCode::STREAM_CREATION_ERROR);
     return;
   }
   if (!multiCodec_->isStreamIngressEgressAllowed(id)) {
-    XLOG(DBG4) << "Refusing stream after GOAWAY id=" << id << " sess=" << *this;
+    PRX_VLOG(4) << "Refusing stream after GOAWAY id=" << id
+                << " sess=" << *this;
     egressResetStream(id, nullptr, HTTPErrorCode::REQUEST_REJECTED);
     return;
   }
 
   onMessageBegin(id, nullptr);
-  auto& stream = *CHECK_NOTNULL(findStream(id));
+  auto& stream = *PRX_CHECK_NOTNULL(findStream(id));
   multiCodec_->addCodec(id);
   backgroundScope_.add(co_withExecutor(
       &readExec_,
@@ -2652,7 +2659,7 @@ void HTTPQuicCoroSession::onNewBidirectionalStream(quic::StreamId id) noexcept {
 
 void HTTPQuicCoroSession::onNewUnidirectionalStream(
     quic::StreamId id) noexcept {
-  XLOG(DBG4) << "New uni stream=" << id << " sess=" << *this;
+  PRX_VLOG(4) << "New uni stream=" << id << " sess=" << *this;
   resetIdleTimeout();
   uniStreamDispatcher_.takeTemporaryOwnership(id);
   quicSocket_->setPeekCallback(id, &uniStreamDispatcher_);
@@ -2660,7 +2667,7 @@ void HTTPQuicCoroSession::onNewUnidirectionalStream(
 
 void HTTPQuicCoroSession::onStopSending(
     quic::StreamId id, quic::ApplicationErrorCode /*error*/) noexcept {
-  XLOG(DBG4) << "onStopSending stream=" << id << " sess=" << *this;
+  PRX_VLOG(4) << "onStopSending stream=" << id << " sess=" << *this;
   // Always reset the stream at the transport.  There are 4 cases:
   // 1. Stream is not yet egress complete from session
   // 2. Stream is egress complete from session, but not transport
@@ -2676,15 +2683,15 @@ void HTTPQuicCoroSession::onStopSending(
 void HTTPQuicCoroSession::onBidirectionalStreamsAvailable(
     uint64_t numStreamsAvailable) noexcept {
   if (isUpstream()) {
-    XLOG(DBG4) << "Got new max number of concurrent streams we can initiate: "
-               << numStreamsAvailable << " sess=" << *this;
+    PRX_VLOG(4) << "Got new max number of concurrent streams we can initiate: "
+                << numStreamsAvailable << " sess=" << *this;
     // Conservatively assume we were at 0
     onSetMaxInitiatedStreams(/*didSupport=*/false);
   }
 }
 
 void HTTPQuicCoroSession::onConnectionEnd() noexcept {
-  XLOG(DBG4) << "onConnectionEnd sess=" << *this;
+  PRX_VLOG(4) << "onConnectionEnd sess=" << *this;
   onConnectionError(kHTTPNoError);
 }
 
@@ -2703,9 +2710,9 @@ void HTTPQuicCoroSession::onConnectionError(quic::QuicError error) noexcept {
     multiCodec_->getQPACKCodec().decoderStreamEnd();
   }
   if (!noError || !streams_.empty()) {
-    XLOG(ERR) << "Connection error type=" << int(error.code.type())
-              << " err=" << error.message << " httpError=" << (int)httpError
-              << " sess=" << *this;
+    PRX_LOG(ERROR) << "Connection error type=" << int(error.code.type())
+                   << " err=" << error.message
+                   << " httpError=" << (int)httpError << " sess=" << *this;
   }
   connectionError(httpError, "QUIC connection error");
   /**
@@ -2734,7 +2741,7 @@ folly::coro::Task<void> HTTPQuicCoroSession::readLoop() noexcept {
       dropConnection("Connection dropped (cancel)");
     }
   }
-  XLOG(DBG6) << "Idle loop complete sess=" << *this;
+  PRX_VLOG(6) << "Idle loop complete sess=" << *this;
   multiCodec_->getQPACKCodec().encoderStreamEnd();
   multiCodec_->getQPACKCodec().decoderStreamEnd();
   writeEvent_.signal();
@@ -2744,14 +2751,14 @@ folly::coro::Task<void> HTTPQuicCoroSession::runImpl() {
   backgroundScope_.add(co_withExecutor(&writeExec_, writeLoop()));
   co_await readLoop();
   co_await backgroundScope_.joinAsync();
-  XLOG(DBG6) << "Background scope joined sess=" << *this;
+  PRX_VLOG(6) << "Background scope joined sess=" << *this;
   co_await co_withCancellation(/*cancelToken=*/{},
                                waitForAllStreams()); // uncancellable
-  XLOG(DBG6) << "All streams done sess=" << *this;
+  PRX_VLOG(6) << "All streams done sess=" << *this;
   // already uncancellable
   // expects a post outside of evb (i.e. our readExec_ will trip a check here)
   co_await co_withExecutor(eventBase_, zeroRefs()).startInlineUnsafe();
-  XLOG(DBG6) << "terminating run sess=" << *this;
+  PRX_VLOG(6) << "terminating run sess=" << *this;
   destroy();
 }
 
@@ -2799,9 +2806,9 @@ void HTTPQuicCoroSession::dispatchControlStream(
       controlCodec = &qpackDecoderCodec_;
       break;
     default:
-      XLOG(FATAL) << "Invalid type=" << streamType;
+      PRX_LOG(FATAL) << "Invalid type=" << streamType;
   }
-  XLOG(DBG4) << "Dispatching uni stream=" << id << " sess=" << *this;
+  PRX_VLOG(4) << "Dispatching uni stream=" << id << " sess=" << *this;
   quicSocket_->consume(id, toConsume);
   quicSocket_->setPeekCallback(id, nullptr);
   co_withExecutor(&readExec_,
@@ -2813,7 +2820,7 @@ void HTTPQuicCoroSession::dispatchPushStream(quic::StreamId id,
                                              hq::PushId pushId,
                                              size_t toConsume) {
   // ingress push streams are not allowed on the server
-  XLOG_IF(WARNING, isDownstream())
+  PRX_LOG_IF(WARNING, isDownstream())
       << "PUSH stream received on server, id=" << id << " sess=" << *this;
   quicSocket_->consume(id, toConsume);
   quicSocket_->setPeekCallback(id, nullptr);
@@ -2832,12 +2839,12 @@ folly::coro::Task<void> HTTPQuicCoroSession::readControlStream(
           isQPACKEncoder_(isQPACKEncoder) {
     }
     void readAvailable(quic::StreamId id) noexcept override {
-      XLOG(DBG4) << "Read available on control stream id=" << id
-                 << " sess=" << session_;
+      PRX_VLOG(4) << "Read available on control stream id=" << id
+                  << " sess=" << session_;
       session_.resetIdleTimeout();
       auto buf = session_.quicSocket_->read(id, 0);
       if (buf.hasError()) {
-        XLOG(ERR)
+        PRX_LOG(ERROR)
             << "Error reading control stream err=" << uint64_t(buf.error())
             << "  id=" << id << " sess=" << session_;
         // TODO: Is the stream state reset in this case?
@@ -2852,8 +2859,8 @@ folly::coro::Task<void> HTTPQuicCoroSession::readControlStream(
                                        id);
         input_.append(std::move(buf->first));
         if (!input_.empty()) {
-          XLOG(DBG4) << "Parsing len=" << input_.chainLength() << " id=" << id
-                     << " sess=" << session_;
+          PRX_VLOG(4) << "Parsing len=" << input_.chainLength() << " id=" << id
+                      << " sess=" << session_;
           input_.append(controlCodec_.onUnidirectionalIngress(input_.move()));
           if (isQPACKEncoder_) {
             // Trigger an iteration of the controlStreamWriteLoop.  This will
@@ -2863,7 +2870,8 @@ folly::coro::Task<void> HTTPQuicCoroSession::readControlStream(
         }
       }
       if (buf->second) {
-        XLOG(DBG4) << "Parsing end of stream id=" << id << " sess=" << session_;
+        PRX_VLOG(4) << "Parsing end of stream id=" << id
+                    << " sess=" << session_;
         controlCodec_.onUnidirectionalIngressEOF();
         baton_.signal();
       }
@@ -2884,9 +2892,10 @@ folly::coro::Task<void> HTTPQuicCoroSession::readControlStream(
     }
     void readError(quic::StreamId id, quic::QuicError error) noexcept override {
       if (!noError(error.code)) {
-        XLOG(ERR) << "Error reading control stream type="
-                  << uint64_t(error.code.type()) << " msg=" << error.message
-                  << ", id=" << id << " sess=" << session_;
+        PRX_LOG(ERROR) << "Error reading control stream type="
+                       << uint64_t(error.code.type())
+                       << " msg=" << error.message << ", id=" << id
+                       << " sess=" << session_;
         session_.connectionError(HTTPErrorCode::CLOSED_CRITICAL_STREAM,
                                  "control stream read error");
       }
@@ -2897,16 +2906,16 @@ folly::coro::Task<void> HTTPQuicCoroSession::readControlStream(
     bool isQPACKEncoder_{false};
   };
 
-  XLOG(DBG4) << __func__ << " started id=" << id << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " started id=" << id << " sess=" << *this;
   if (quicSocket_->good()) {
     quicSocket_->setControlStream(id);
     ControlRCB controlRcb(*this, codec, isQPACKEncoder);
     quicSocket_->setReadCallback(id, &controlRcb, std::nullopt);
     auto res = co_await controlRcb.getBaton().wait();
-    XCHECK(res != TimedBaton::Status::timedout);
+    PRX_CHECK(res != TimedBaton::Status::timedout);
     // Do I need to clear the read callback for this stream?
   }
-  XLOG(DBG4) << __func__ << " complete, id=" << id << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " complete, id=" << id << " sess=" << *this;
 }
 
 void HTTPQuicCoroSession::dispatchUniWTStream(quic::StreamId streamId,
@@ -2929,12 +2938,12 @@ void HTTPQuicCoroSession::StreamRCB::readAvailable(quic::StreamId id) noexcept {
   if (inProcessRead_) {
     return;
   }
-  XLOG(DBG4) << "Read available id=" << id << " sess=" << session_;
+  PRX_VLOG(4) << "Read available id=" << id << " sess=" << session_;
   session_.resetIdleTimeout();
   auto buf = session_.quicSocket_->read(id, 0);
   if (buf.hasError()) {
-    XLOG(ERR) << "Error reading stream id=" << id
-              << quic::toString(buf.error());
+    PRX_LOG(ERROR) << "Error reading stream id=" << id
+                   << quic::toString(buf.error());
     // TODO: Stream state reset?
     baton_.signal();
     return;
@@ -2958,10 +2967,10 @@ void HTTPQuicCoroSession::StreamRCB::processRead(quic::StreamId id) {
   inProcessRead_ = true;
   auto g = folly::makeGuard([this] { inProcessRead_ = false; });
   if (!input_.empty()) {
-    XLOG(DBG4) << "Parsing len=" << input_.chainLength() << " id=" << id
-               << " sess=" << session_;
+    PRX_VLOG(4) << "Parsing len=" << input_.chainLength() << " id=" << id
+                << " sess=" << session_;
     if (!session_.multiCodec_->setCurrentStream(id)) {
-      XLOG(DBG3) << "No codec for stream=" << id << " sess=" << session_;
+      PRX_VLOG(3) << "No codec for stream=" << id << " sess=" << session_;
       // Stream has already detached, so a stop-sending must be in flight?
       baton_.signal();
       return;
@@ -2971,10 +2980,10 @@ void HTTPQuicCoroSession::StreamRCB::processRead(quic::StreamId id) {
   }
   if (input_.empty() && readEOF_) {
     session_.quicSocket_->setReadCallback(id, nullptr, std::nullopt);
-    XLOG(DBG4) << "Parsing end of stream id=" << id << " sess=" << session_;
+    PRX_VLOG(4) << "Parsing end of stream id=" << id << " sess=" << session_;
     readEOF_ = false;
     if (!session_.multiCodec_->setCurrentStream(id)) {
-      XLOG(DBG3) << "No codec for stream=" << id << " sess=" << session_;
+      PRX_VLOG(3) << "No codec for stream=" << id << " sess=" << session_;
       // Stream has already detached, so a stop-sending must be in flight?
       baton_.signal();
       return;
@@ -3000,15 +3009,15 @@ void HTTPQuicCoroSession::StreamRCB::processRead(quic::StreamId id) {
 }
 
 void HTTPQuicCoroSession::StreamRCB::resumeRead(quic::StreamId id) {
-  XLOG(DBG4) << "Process read from resume id=" << id << " sess=" << session_;
+  PRX_VLOG(4) << "Process read from resume id=" << id << " sess=" << session_;
   processRead(id);
 }
 
 void HTTPQuicCoroSession::StreamRCB::readError(quic::StreamId id,
                                                quic::QuicError error) noexcept {
-  XLOG(DBG3) << "Error reading stream id=" << id << " sess=" << session_
-             << " type=" << uint32_t(error.code.type())
-             << " err=" << quic::toString(error.code);
+  PRX_VLOG(3) << "Error reading stream id=" << id << " sess=" << session_
+              << " type=" << uint32_t(error.code.type())
+              << " err=" << quic::toString(error.code);
   HTTPErrorCode httpError = HTTPErrorCode::TRANSPORT_READ_ERROR;
   if (error.code.type() == quic::QuicErrorCode::Type::ApplicationErrorCode) {
     auto code = (HTTP3::ErrorCode)*error.code.asApplicationErrorCode();
@@ -3034,8 +3043,8 @@ folly::coro::Task<void> HTTPQuicCoroSession::readLoop(
     quic::StreamId id) noexcept {
   if (quicSocket_->good()) {
     if (!multiCodec_->setCurrentStream(id)) {
-      XLOG(DBG2) << "readLoop no-op, stream already cancelled id=" << id
-                 << " sess=" << *this;
+      PRX_VLOG(2) << "readLoop no-op, stream already cancelled id=" << id
+                  << " sess=" << *this;
       return folly::coro::makeTask(folly::Unit());
     }
     auto streamRCB = std::make_shared<StreamRCB>(*this);
@@ -3049,7 +3058,7 @@ folly::coro::Task<void> HTTPQuicCoroSession::readLoop(
     if (rc.has_value()) {
       return readLoopImpl(std::move(streamRCB), id);
     } else {
-      XLOG(ERR) << rc.error();
+      PRX_LOG(ERROR) << rc.error();
     }
   }
   return folly::coro::makeTask(folly::Unit());
@@ -3057,11 +3066,11 @@ folly::coro::Task<void> HTTPQuicCoroSession::readLoop(
 
 folly::coro::Task<void> HTTPQuicCoroSession::readLoopImpl(
     std::shared_ptr<StreamRCB> streamRCB, quic::StreamId id) noexcept {
-  XLOG(DBG4) << __func__ << " started id=" << id << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " started id=" << id << " sess=" << *this;
   auto res = co_await streamRCB->getBaton().wait();
-  XCHECK(res != TimedBaton::Status::timedout);
+  PRX_CHECK(res != TimedBaton::Status::timedout);
   quicSocket_->setReadCallback(id, nullptr, std::nullopt);
-  XLOG(DBG4) << __func__ << " complete id=" << id << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " complete id=" << id << " sess=" << *this;
 }
 
 void HTTPCoroSession::handleWriteEventTimeout() {
@@ -3071,7 +3080,8 @@ void HTTPCoroSession::handleWriteEventTimeout() {
   if (isConnectionFlowControlBlocked()) {
     for (auto& [id, stream] : streams_) {
       if (!stream->isBodyQueueEmpty()) {
-        XLOG(ERR) << "Timed out waiting for conn flow control, sess=" << *this;
+        PRX_LOG(ERROR) << "Timed out waiting for conn flow control, sess="
+                       << *this;
         connectionError(HTTPErrorCode::FLOW_CONTROL_ERROR,
                         "Timed out waiting for flow control");
         break;
@@ -3088,8 +3098,8 @@ void HTTPCoroSession::handleWriteEventTimeout() {
       }
     }
     for (auto id : ids) {
-      XLOG(DBG4) << "Stream id=" << id
-                 << " flow control timeout, resetting, sess=" << *this;
+      PRX_VLOG(4) << "Stream id=" << id
+                  << " flow control timeout, resetting, sess=" << *this;
       egressResetStream(id, nullptr, HTTPErrorCode::FLOW_CONTROL_ERROR);
     }
   }
@@ -3127,8 +3137,8 @@ folly::coro::Task<void> HTTPCoroSession::waitForAllStreams() {
     auto status =
         co_await writeEvent_.timedWait(eventBase_.get(), writeTimeout_);
     if (status == TimedBaton::Status::timedout) {
-      XLOG(DBG4) << "Timeout waiting for stream to drain on error, nStreams="
-                 << streams_.size() << " sess=" << *this;
+      PRX_VLOG(4) << "Timeout waiting for stream to drain on error, nStreams="
+                  << streams_.size() << " sess=" << *this;
     }
   }
 }
@@ -3150,7 +3160,7 @@ bool HTTPUniplexTransportSession::shouldContinueWriteLooping() const {
        (!readsClosed_ && codec_->isReusable()) ||
        pendingSendStreams_ > 0);
   // clang-format on
-  XLOG(DBG6)
+  PRX_VLOG(6)
       << __func__ << " continueLoop=" << (continueLoop ? 1 : 0)
       << " pendingSendStreams_=" << pendingSendStreams_
       << " closeOnEgressComplete=" << (codec_->closeOnEgressComplete() ? 1 : 0)
@@ -3167,21 +3177,21 @@ bool HTTPUniplexTransportSession::shouldContinueWriteLooping() const {
 bool HTTPQuicCoroSession::shouldContinueWriteLooping() const {
   auto continueLoop =
       hasControlWrite() || codec_->isReusable() || !streams_.empty();
-  XLOG(DBG6) << __func__ << " continueLoop=" << (continueLoop ? 1 : 0)
-             << " hasControlWrite=" << hasControlWrite()
-             << " codec_->isReusable()=" << (codec_->isReusable() ? 1 : 0)
-             << " nStreams=" << streams_.size() << " sess=" << *this;
+  PRX_VLOG(6) << __func__ << " continueLoop=" << (continueLoop ? 1 : 0)
+              << " hasControlWrite=" << hasControlWrite()
+              << " codec_->isReusable()=" << (codec_->isReusable() ? 1 : 0)
+              << " nStreams=" << streams_.size() << " sess=" << *this;
   return continueLoop;
 }
 
 folly::coro::Task<void> HTTPUniplexTransportSession::writeLoop() noexcept {
-  XLOG(DBG6) << "starting writeLoop sess=" << *this;
+  PRX_VLOG(6) << "starting writeLoop sess=" << *this;
   folly::Optional<std::string> writeError;
   while (!writeError && shouldContinueWriteLooping()) {
     if (writeBuf_.empty() &&
         (writableStreams_.empty() || sendWindow_.getSize() == 0)) {
       writeEvent_.reset();
-      XLOG(DBG6) << "Waiting for writeEvent sess=" << *this;
+      PRX_VLOG(6) << "Waiting for writeEvent sess=" << *this;
       TimedBaton::Status status = TimedBaton::Status::signalled;
       {
         auto guard = writeExec_.acquireGuard();
@@ -3189,13 +3199,13 @@ folly::coro::Task<void> HTTPUniplexTransportSession::writeLoop() noexcept {
             co_await writeEvent_.timedWait(eventBase_.get(), writeTimeout_);
       }
 
-      XCHECK(status != TimedBaton::Status::cancelled)
+      PRX_CHECK(status != TimedBaton::Status::cancelled)
           << "writeLoop not cancellable";
       if (status == TimedBaton::Status::timedout) {
         handleWriteEventTimeout();
         // fall through to check for writes below before terminating loop
       }
-      XLOG(DBG4) << "Got writeEvent sess=" << *this;
+      PRX_VLOG(4) << "Got writeEvent sess=" << *this;
     }
 
     // Add stream body data, if there's buffer space and flow control
@@ -3205,11 +3215,11 @@ folly::coro::Task<void> HTTPUniplexTransportSession::writeLoop() noexcept {
       // bodies
       int32_t bufSpace = kWriteBufLimit - writeBuf_.chainLength();
       auto maxStreamToWrite = std::min(bufSpace, sendWindow_.getSize());
-      XCHECK_GT(maxStreamToWrite, 0);
-      XLOG(DBG4) << "Egressing stream bodies up to max=" << maxStreamToWrite
-                 << " sess=" << *this;
+      PRX_CHECK_GT(maxStreamToWrite, 0);
+      PRX_VLOG(4) << "Egressing stream bodies up to max=" << maxStreamToWrite
+                  << " sess=" << *this;
       auto written = addStreamBodyDataToWriteBuf(maxStreamToWrite);
-      XLOG(DBG4) << "Egressed len=" << written << " sess=" << *this;
+      PRX_VLOG(4) << "Egressed len=" << written << " sess=" << *this;
     }
 
     if (!writeBuf_.empty()) {
@@ -3219,28 +3229,28 @@ folly::coro::Task<void> HTTPUniplexTransportSession::writeLoop() noexcept {
       if (txAckEvent) {
         // If there's a TX or ACK event, we have to split the write on the
         // event offset, and update the writeFlags.
-        XLOG(DBG5) << "Split writeBuf_ at " << txAckEvent->sessionByteOffset;
-        XCHECK_GT(txAckEvent->sessionByteOffset, sessionBytesScheduled_);
+        PRX_VLOG(5) << "Split writeBuf_ at " << txAckEvent->sessionByteOffset;
+        PRX_CHECK_GT(txAckEvent->sessionByteOffset, sessionBytesScheduled_);
         writeLength = txAckEvent->sessionByteOffset - sessionBytesScheduled_;
         writeFlags = txAckEvent->writeFlags();
       }
       folly::IOBufQueue writeBuf{folly::IOBufQueue::cacheChainLength()};
       writeBuf.append(writeBuf_.split(writeLength));
       sessionBytesScheduled_ += writeLength;
-      XLOG(DBG4) << "Writing length=" << writeLength << " sess=" << *this;
+      PRX_VLOG(4) << "Writing length=" << writeLength << " sess=" << *this;
       byteEventObserver_.transportWrite(sessionBytesScheduled_);
       auto result = co_await co_awaitTry(
           coroTransport_->write(writeBuf, writeTimeout_, writeFlags));
       if (result.hasException()) {
-        XLOG(DBG4) << "Write error, err=" << result.exception()
-                   << " sess=" << *this;
+        PRX_VLOG(4) << "Write error, err=" << result.exception()
+                    << " sess=" << *this;
         if (txAckEvent) {
           txAckEvent->cancel(HTTPError(HTTPErrorCode::TRANSPORT_WRITE_ERROR,
                                        result.exception().what().c_str()));
         }
         writeError.emplace(result.exception().what());
       } else {
-        XLOG(DBG4) << "Wrote length=" << writeLength << " sess=" << *this;
+        PRX_VLOG(4) << "Wrote length=" << writeLength << " sess=" << *this;
         deliverLifecycleEvent(&LifecycleObserver::onWrite, *this, writeLength);
         byteEventObserver_.transportWriteComplete(sessionBytesScheduled_,
                                                   std::move(txAckEvent));
@@ -3252,7 +3262,7 @@ folly::coro::Task<void> HTTPUniplexTransportSession::writeLoop() noexcept {
     cleanupAfterWriteError(*writeError);
   }
 
-  XLOG(DBG6)
+  PRX_VLOG(6)
       << "writeLoop terminating, closing with "
       << ((resetAfterDrainingWrites_ || writeError) ? "error" : "no error")
       << " sess=" << *this;
@@ -3292,7 +3302,7 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
   while (shouldContinueWriteLooping()) {
     if (!hasControlWrite() && writableStreams_.empty()) {
       writeEvent_.reset();
-      XLOG(DBG6) << "Waiting for writeEvent sess=" << *this;
+      PRX_VLOG(6) << "Waiting for writeEvent sess=" << *this;
       auto guard = writeExec_.acquireGuard();
       auto res =
           co_await writeEvent_.timedWait(eventBase_.get(), writeTimeout_);
@@ -3300,10 +3310,10 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
         break;
       }
       if (res == TimedBaton::Status::timedout) {
-        XLOG(DBG4) << "writeEvent timeout sess=" << *this;
+        PRX_VLOG(4) << "writeEvent timeout sess=" << *this;
         handleWriteEventTimeout();
       }
-      XLOG_IF(DBG4, res == TimedBaton::Status::signalled)
+      PRX_VLOG_IF(4, res == TimedBaton::Status::signalled)
           << "Got writeEvent sess=" << *this;
     }
     if (!quicSocket_->good()) {
@@ -3319,14 +3329,14 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
     writeControlStream(qpackDecoderStreamID_,
                        multiCodec_->getQPACKDecoderWriteBuf());
 
-    XLOG(DBG4) << "Egressing stream bodies sess=" << *this;
+    PRX_VLOG(4) << "Egressing stream bodies sess=" << *this;
     while (!writableStreams_.empty()) {
       auto id = writableStreams_.getNextScheduledID(std::nullopt);
       auto streamId = id.asStreamID();
       auto stream = findStream(streamId);
       if (!stream) {
-        XLOG(ERR) << "Writable stream missing from streams_ id=" << streamId
-                  << " sess=" << *this;
+        PRX_LOG(ERROR) << "Writable stream missing from streams_ id="
+                       << streamId << " sess=" << *this;
         writableStreams_.erase(id);
         continue;
       }
@@ -3372,10 +3382,10 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
             // TODO
             break;
           case HTTPBodyEvent::SUSPEND:
-            XCHECK(false) << "Bad event";
+            PRX_CHECK(false) << "Bad event";
             break;
           case HTTPBodyEvent::DATAGRAM: {
-            XCHECK(!bodyEvent.eom) << "DATAGRAM can't be EOM";
+            PRX_CHECK(!bodyEvent.eom) << "DATAGRAM can't be EOM";
             if (bodyEvent.event.datagram) {
               sendDatagram(stream->getID(),
                            std::move(bodyEvent.event.datagram));
@@ -3383,8 +3393,8 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
             break;
           }
           case HTTPBodyEvent::TRAILERS: {
-            XLOG(DBG4) << "Sending trailers sess=" << *this
-                       << " id=" << stream->getID();
+            PRX_VLOG(4) << "Sending trailers sess=" << *this
+                        << " id=" << stream->getID();
             auto sz = codec_->generateTrailers(stream->getWriteBuf(),
                                                stream->getID(),
                                                *bodyEvent.event.trailers);
@@ -3393,7 +3403,7 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
                 {HTTPByteEvent::FieldSectionInfo::Type::TRAILERS,
                  true,
                  {uint32_t(sz), uint32_t(sz), 0}});
-            XCHECK(bodyEvent.eom) << "Trailers always EOM";
+            PRX_CHECK(bodyEvent.eom) << "Trailers always EOM";
             break;
           }
           case HTTPBodyEvent::PUSH_PROMISE: {
@@ -3422,8 +3432,8 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
         }
         stream->onWindowUpdate(bytesWritten); // simulate window update
       }
-      XLOG(DBG4) << "Egressed len=" << bytesWritten << " id=" << stream->getID()
-                 << " sess=" << *this;
+      PRX_VLOG(4) << "Egressed len=" << bytesWritten
+                  << " id=" << stream->getID() << " sess=" << *this;
 
       if (bodyQueueEmpty) {
         writableStreams_.erase(id);
@@ -3448,9 +3458,9 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
     }
   }
   if (quicSocket_->good()) {
-    XLOG(DBG4) << "Closing QuicSocket from writeLoop with "
-               << ((connectionError_) ? "error" : "no error")
-               << " sess=" << *this;
+    PRX_VLOG(4) << "Closing QuicSocket from writeLoop with "
+                << ((connectionError_) ? "error" : "no error")
+                << " sess=" << *this;
     if (connectionError_) {
       quicSocket_->close(connectionError_);
     } else {
@@ -3458,17 +3468,17 @@ folly::coro::Task<void> HTTPQuicCoroSession::writeLoop() noexcept {
       registerControlDeliveryCallback(controlStreamID_);
       registerControlDeliveryCallback(qpackEncoderStreamID_);
       registerControlDeliveryCallback(qpackDecoderStreamID_);
-      XLOG(DBG4) << "Waiting for all control data to be delivered count="
-                 << DeliveryCallback::kDeliveryCallbackTimeout.count()
-                 << " sess=" << *this;
+      PRX_VLOG(4) << "Waiting for all control data to be delivered count="
+                  << DeliveryCallback::kDeliveryCallbackTimeout.count()
+                  << " sess=" << *this;
       co_await deliveryCallback_.zeroRefs(eventBase_.get());
-      XLOG(DBG4) << "Waiting for outstanding byte events";
+      PRX_VLOG(4) << "Waiting for outstanding byte events";
       co_await byteEventRefcount_.zeroRefs();
       quicSocket_->close(kHTTPNoError);
     }
-    XCHECK_EQ(byteEventRefcount_.count(), 0u); // either we waited or error'd
+    PRX_CHECK_EQ(byteEventRefcount_.count(), 0u); // either we waited or error'd
     idle_.signal();
-    XLOG(DBG6) << __func__ << " completed";
+    PRX_VLOG(6) << __func__ << " completed";
   }
 }
 
@@ -3478,8 +3488,8 @@ void HTTPQuicCoroSession::writeControlStream(quic::StreamId id,
     // This stream failed to create, clear the write buffer
     writeBuf_.move();
   } else if (!writeBuf.empty()) {
-    XLOG(DBG4) << "Writing len=" << writeBuf.chainLength()
-               << " on control stream=" << id << " sess=" << *this;
+    PRX_VLOG(4) << "Writing len=" << writeBuf.chainLength()
+                << " on control stream=" << id << " sess=" << *this;
     if (!handleWrite(id, writeBuf, false)) {
       connectionError(HTTPErrorCode::CLOSED_CRITICAL_STREAM,
                       "Write failed on control stream");
@@ -3516,8 +3526,8 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
     auto streamId = id.asStreamID();
     auto stream = findStream(streamId);
     if (!stream) {
-      XLOG(ERR) << "Writable stream missing from streams_ id=" << streamId
-                << " sess=" << *this;
+      PRX_LOG(ERROR) << "Writable stream missing from streams_ id=" << streamId
+                     << " sess=" << *this;
       writableStreams_.erase(id);
       continue;
     }
@@ -3525,7 +3535,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
     bool bodyQueueEmpty = false;
     bool eom = false;
     do {
-      XCHECK_GT(max, fcBytesWritten);
+      PRX_CHECK_GT(max, fcBytesWritten);
       HTTPBodyEvent bodyEvent;
       std::tie(bodyEvent, flowControlBlocked) =
           stream->nextEgressEvent(max - fcBytesWritten);
@@ -3540,7 +3550,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
           }
           auto length = bodyEvent.event.body.chainLength();
           if (!sendWindow_.reserve(length)) {
-            XLOG(DFATAL) << "Underflow connection send flow control";
+            PRX_LOG(DFATAL) << "Underflow connection send flow control";
             // In opt builds, continue and send anyways, the peer will close
           }
           // Simulate window updates for H1 if needed
@@ -3556,7 +3566,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
                                   *this);
           }
           if (length == 0) {
-            XCHECK(bodyEvent.eom);
+            PRX_CHECK(bodyEvent.eom);
             auto eomBytes = codec_->generateEOM(writeBuf_, streamId);
             bytesWritten += eomBytes;
             stream->addToStreamOffset(eomBytes);
@@ -3566,7 +3576,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
                                                  bodyEvent.event.body.move(),
                                                  HTTPCodec::NoPadding,
                                                  bodyEvent.eom);
-            XCHECK_GT(genBytes, 0ul);
+            PRX_CHECK_GT(genBytes, 0ul);
             fcBytesWritten += length;
             bytesWritten += genBytes;
             stream->addToStreamOffset(genBytes);
@@ -3583,10 +3593,11 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
           // TODO
           break;
         case HTTPBodyEvent::SUSPEND:
-          XCHECK(false) << "Bad event";
+          PRX_CHECK(false) << "Bad event";
           break;
         case HTTPBodyEvent::TRAILERS: {
-          XLOG(DBG4) << "Sending trailers sess=" << *this << " id=" << streamId;
+          PRX_VLOG(4) << "Sending trailers sess=" << *this
+                      << " id=" << streamId;
           auto sz = codec_->generateTrailers(
               writeBuf_, streamId, *bodyEvent.event.trailers);
           bytesWritten += sz;
@@ -3596,7 +3607,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
               {HTTPByteEvent::FieldSectionInfo::Type::TRAILERS,
                true,
                {uint32_t(sz), uint32_t(sz), 0}});
-          XCHECK(bodyEvent.eom) << "Trailers always EOM";
+          PRX_CHECK(bodyEvent.eom) << "Trailers always EOM";
           break;
         }
         case HTTPBodyEvent::PADDING: {
@@ -3624,7 +3635,7 @@ size_t HTTPUniplexTransportSession::addStreamBodyDataToWriteBuf(uint32_t max) {
     } while (!bodyQueueEmpty && bytesWritten < max && !flowControlBlocked);
     if (bodyQueueEmpty || flowControlBlocked) {
       // The stream ran out of events/flow control, erase from writableStreams_
-      XLOG(DBG4)
+      PRX_VLOG(4)
           << "Ran out of queued events or flow control for stream: blocked="
           << uint32_t(flowControlBlocked) << " eom=" << uint32_t(eom)
           << " id=" << streamId << " sess=" << *this;
@@ -3649,7 +3660,7 @@ folly::Expected<std::pair<HTTPCodec::StreamID, HTTPCodec::StreamID>, ErrorCode>
 HTTPQuicCoroSession::createEgressPushStream() {
   auto pushStreamID = quicSocket_->createUnidirectionalStream();
   if (pushStreamID.hasError()) {
-    XLOG(ERR) << "Failed to create a uni stream for push sess=" << *this;
+    PRX_LOG(ERROR) << "Failed to create a uni stream for push sess=" << *this;
     return folly::makeUnexpected(ErrorCode::PROTOCOL_ERROR);
   }
   auto pushID = multiCodec_->nextPushID();
@@ -3668,18 +3679,18 @@ HTTPQuicCoroSession::createEgressPushStream() {
 
 HTTPHeaderSize HTTPCoroSession::addPushPromiseToWriteBuf(
     StreamState& stream, HTTPBodyEvent& bodyEvent) {
-  XCHECK(isDownstream());
-  XLOG(DBG4) << "Sending push promise sess=" << *this
-             << " id=" << stream.getID();
+  PRX_CHECK(isDownstream());
+  PRX_VLOG(4) << "Sending push promise sess=" << *this
+              << " id=" << stream.getID();
   if (!codec_->supportsPushTransactions()) {
-    XLOG(WARNING) << "Ignoring push because peer does not support push";
+    PRX_LOG(WARNING) << "Ignoring push because peer does not support push";
     return {0, 0, 0};
   }
   if (!supportsMoreTransactions()) {
     // TODO: technically you can send unlimited PUSH_PROMISES, but
     // you need to throttle the streams themselves, but we just
     // throttle the promises.
-    XLOG(ERR) << "Exceeded outgoing stream limit sess=" << *this;
+    PRX_LOG(ERROR) << "Exceeded outgoing stream limit sess=" << *this;
     return {0, 0, 0};
   }
   auto res = createEgressPushStream();
@@ -3705,8 +3716,8 @@ HTTPHeaderSize HTTPCoroSession::addPushPromiseToWriteBuf(
                               &size);
 
   // A little strange to start a co-routine from the egress path
-  XLOG(DBG4) << "Starting egress push readResponse for id="
-             << pushStream.getID();
+  PRX_VLOG(4) << "Starting egress push readResponse for id="
+              << pushStream.getID();
   co_withExecutor(eventBase_,
                   co_withCancellation(
                       pushStream.cs.egress.getToken(),
@@ -3728,7 +3739,7 @@ void HTTPCoroSession::decrementPushStreamCount(const StreamState& stream,
   if ((isUpstream() && !stream.streamSource.isEOMSeen()) ||
       (isDownstream() &&
        (!stream.isEgressComplete() || eomMarkedEgressComplete))) {
-    XCHECK_GT(numPushStreams_, 0UL);
+    PRX_CHECK_GT(numPushStreams_, 0UL);
     numPushStreams_--;
   }
 }
@@ -3761,9 +3772,9 @@ bool HTTPCoroSession::isDetachable() const {
 }
 
 void HTTPCoroSession::detachEvb() {
-  XLOG(DBG4) << __func__;
-  XCHECK(isDetachable());
-  XCHECK(eventBase_ && eventBase_->isInEventBaseThread());
+  PRX_VLOG(4) << __func__;
+  PRX_CHECK(isDetachable());
+  PRX_CHECK(eventBase_ && eventBase_->isInEventBaseThread());
   eventBase_.reset();
   readExec_.detachEvb();
   writeExec_.detachEvb();
@@ -3771,8 +3782,8 @@ void HTTPCoroSession::detachEvb() {
 }
 
 void HTTPCoroSession::attachEvb(folly::EventBase* evb) {
-  XLOG(DBG4) << __func__;
-  XCHECK(evb->inRunningEventBaseThread());
+  PRX_VLOG(4) << __func__;
+  PRX_CHECK(evb->inRunningEventBaseThread());
   eventBase_ = evb;
   readExec_.attachEvb(evb);
   writeExec_.attachEvb(evb);
@@ -3837,7 +3848,8 @@ folly::coro::Task<WtReqResult> HTTPCoroSession::sendWtReq(
     RequestReservation reservation,
     const HTTPMessage& msg,
     std::unique_ptr<WebTransportHandler>) noexcept {
-  // XLOG_IF(FATAL, !folly::kIsDebug) << "wt wip"; // crash in non-debug modes
+  // PRX_LOG_IF(FATAL, !folly::kIsDebug) << "wt wip"; // crash in non-debug
+  // modes
   if (!reservation.fromSession(this)) {
     return makeInternalEx("Invalid reservation");
   }
@@ -3852,7 +3864,7 @@ folly::coro::Task<WtReqResult> HTTPCoroSession::sendWtReq(
   const bool validWtReq = HTTPWebTransport::isConnectMessage(msg);
   if (!(wtEnabled && validWtReq)) {
     auto err = !validWtReq ? kInvalidWtReq : kWtNotSupported;
-    XLOG(DBG6) << __func__ << " err=" << err << "; sess=" << *this;
+    PRX_VLOG(6) << __func__ << " err=" << err << "; sess=" << *this;
     return makeInternalEx(err);
   }
 
@@ -3879,7 +3891,7 @@ folly::coro::Task<WtReqResult> HTTPUniplexTransportSession::sendWtReq(
                              /*egressHeadersFn=*/nullptr,
                              /*byteEventRegistrations=*/{},
                              /*bodySource=*/egressSource.get());
-  XCHECK(res.hasValue()); // http/2 should always succeed here
+  PRX_CHECK(res.hasValue()); // http/2 should always succeed here
 
   WtReqResult ret;
   do {
diff --git a/proxygen/lib/http/coro/HTTPCoroSession.h b/proxygen/lib/http/coro/HTTPCoroSession.h
index 0ac40812aa..40f4f429cf 100644
--- a/proxygen/lib/http/coro/HTTPCoroSession.h
+++ b/proxygen/lib/http/coro/HTTPCoroSession.h
@@ -23,7 +23,6 @@
 #include <folly/coro/AsyncScope.h>
 #include <folly/coro/Task.h>
 #include <folly/io/coro/Transport.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/HQMultiCodec.h>
 #include <proxygen/lib/http/codec/HTTP2Constants.h>
 #include <proxygen/lib/http/codec/HTTPCodecFilter.h>
@@ -32,6 +31,7 @@
 #include <proxygen/lib/http/codec/RateLimitFilter.h>
 #include <proxygen/lib/http/session/HQStreamDispatcher.h>
 #include <proxygen/lib/http/session/QuicProtocolInfo.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/UtilInl.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/common/Optional.h>
@@ -348,7 +348,7 @@ class HTTPCoroSession
   void addLifecycleObserver(LifecycleObserver* cb) override {
     // add to the beginning of the list, so that a currently iterating
     // ::deliverLifecycleEvent does not call into this observer
-    lifecycleObservers_.push_front(CHECK_NOTNULL(cb));
+    lifecycleObservers_.push_front(PRX_CHECK_NOTNULL(cb));
     cb->onAttached(*this);
   }
 
@@ -373,7 +373,7 @@ class HTTPCoroSession
 
   void setMaxConcurrentOutgoingStreams(uint32_t maxConcurrentOutgoingStreams) {
     if (maxConcurrentOutgoingStreams == 0) {
-      XLOG(ERR) << "Cannot set maxConcurrentOutgoingStreams_ to 0";
+      PRX_LOG(ERROR) << "Cannot set maxConcurrentOutgoingStreams_ to 0";
       return;
     }
     if (codec_->supportsParallelRequests()) {
@@ -383,16 +383,16 @@ class HTTPCoroSession
 
   uint32_t numOutgoingStreams() const override {
     auto nStreams = streams_.size();
-    XCHECK_GE(nStreams, numPushStreams_);
-    XCHECK_LT(nStreams, std::numeric_limits<uint32_t>::max());
+    PRX_CHECK_GE(nStreams, numPushStreams_);
+    PRX_CHECK_LT(nStreams, std::numeric_limits<uint32_t>::max());
     return isUpstream()
                ? uint32_t(nStreams) - numPushStreams_ + pendingSendStreams_
                : numPushStreams_;
   }
   uint32_t numIncomingStreams() const override {
     auto nStreams = streams_.size();
-    XCHECK_GE(nStreams, numPushStreams_);
-    XCHECK_LT(nStreams, std::numeric_limits<uint32_t>::max());
+    PRX_CHECK_GE(nStreams, numPushStreams_);
+    PRX_CHECK_LT(nStreams, std::numeric_limits<uint32_t>::max());
     return isDownstream() ? uint32_t(nStreams) - numPushStreams_
                           : numPushStreams_;
   }
@@ -616,7 +616,7 @@ class HTTPCoroSession
   }
   uint32_t getStreamFlowControlWindow(const HTTPSettings* settings) const {
     if (codec_->supportsStreamFlowControl()) {
-      XCHECK(settings) << "H2 has settings and stream flow control";
+      PRX_CHECK(settings) << "H2 has settings and stream flow control";
       auto setting = settings->getSetting(SettingsId::INITIAL_WINDOW_SIZE);
       return setting ? uint32_t(setting->value) : http2::kInitialWindow;
     }
@@ -1110,7 +1110,7 @@ class HTTPQuicCoroSession final
     uint64_t transportAvailable =
         isUpstream() ? quicSocket_->getNumOpenableBidirectionalStreams()
                      : quicSocket_->getNumOpenableUnidirectionalStreams();
-    XCHECK(pendingSendStreams_ == 0 || isUpstream());
+    PRX_CHECK(pendingSendStreams_ == 0 || isUpstream());
     if (transportAvailable <= pendingSendStreams_) {
       return 0; // at transport limit
     }
@@ -1282,12 +1282,12 @@ class HTTPQuicCoroSession final
     }
 
     void onByteEvent(quic::ByteEvent byteEvent) override {
-      XLOG(DBG4) << "onDeliveryAck for id=" << byteEvent.id;
+      PRX_VLOG(4) << "onDeliveryAck for id=" << byteEvent.id;
       decRef();
     }
 
     void onByteEventCanceled(quic::ByteEvent byteEvent) override {
-      XLOG(DBG4) << "onCanceled for id=" << byteEvent.id;
+      PRX_VLOG(4) << "onCanceled for id=" << byteEvent.id;
       decRef();
     }
 
diff --git a/proxygen/lib/http/coro/HTTPError.cpp b/proxygen/lib/http/coro/HTTPError.cpp
index a34a921338..fff9fd1f40 100644
--- a/proxygen/lib/http/coro/HTTPError.cpp
+++ b/proxygen/lib/http/coro/HTTPError.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPError.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/container/F14Map.h>
 #include <proxygen/lib/http/HTTPException.h>
@@ -37,8 +37,8 @@ bool checkInvalidAppErrorCode(HTTPErrorCode ec) {
     case HTTPErrorCode::BODY_PARSE_ERROR:
     case HTTPErrorCode::DROPPED:
     case HTTPErrorCode::CORO_CANCELLED:
-      XLOG(WARNING) << "Application supplied internal error code ec="
-                    << uint16_t(ec);
+      PRX_LOG(WARNING) << "Application supplied internal error code ec="
+                       << uint16_t(ec);
       return true;
 
     // Internal H3 errors
@@ -54,8 +54,8 @@ bool checkInvalidAppErrorCode(HTTPErrorCode ec) {
     case HTTPErrorCode::QPACK_DECOMPRESSION_FAILED:
     case HTTPErrorCode::QPACK_ENCODER_STREAM_ERROR:
     case HTTPErrorCode::QPACK_DECODER_STREAM_ERROR:
-      XLOG(WARNING) << "Application supplied internal H3 error code ec="
-                    << uint16_t(ec);
+      PRX_LOG(WARNING) << "Application supplied internal H3 error code ec="
+                       << uint16_t(ec);
       return true;
     default:
       return false;
@@ -131,11 +131,11 @@ ErrorCode HTTPErrorCode2ErrorCode(HTTPErrorCode ec, bool fromSource) {
     case HTTPErrorCode::MESSAGE_ERROR:
     case HTTPErrorCode::PROTOCOL_ERROR:
     case HTTPErrorCode::GENERAL_PROTOCOL_ERROR:
-      XCHECK(!fromSource);
+      PRX_CHECK(!fromSource);
       return ErrorCode::PROTOCOL_ERROR;
 
     case HTTPErrorCode::FLOW_CONTROL_ERROR:
-      XCHECK(!fromSource);
+      PRX_CHECK(!fromSource);
       return ErrorCode::FLOW_CONTROL_ERROR;
 
     default:
@@ -183,14 +183,14 @@ HTTP3::ErrorCode HTTPErrorCode2HTTP3ErrorCode(HTTPErrorCode ec,
 
     // There is no H3 version of this
     case HTTPErrorCode::INADEQUATE_SECURITY:
-      XLOG(WARNING) << "Got INADEQUATE_SECURITY for H3 conn";
+      PRX_LOG(WARNING) << "Got INADEQUATE_SECURITY for H3 conn";
       return HTTP3::ErrorCode::HTTP_INTERNAL_ERROR;
 
     // This is really an internal code we need to map sometimes
     case HTTPErrorCode::MESSAGE_ERROR:
     case HTTPErrorCode::PROTOCOL_ERROR:
     case HTTPErrorCode::GENERAL_PROTOCOL_ERROR:
-      XCHECK(!fromSource);
+      PRX_CHECK(!fromSource);
       return HTTP3::ErrorCode::HTTP_GENERAL_PROTOCOL_ERROR;
 
     default:
@@ -239,7 +239,7 @@ HTTPErrorCode HTTPException2HTTPErrorCode(const proxygen::HTTPException& ex) {
   } else if (ex.hasProxygenError()) {
     // These come from HTTP1xCodec
     auto err = ex.getProxygenError();
-    XCHECK_NE(err, proxygen::kErrorNone);
+    PRX_CHECK_NE(err, proxygen::kErrorNone);
     switch (err) {
       case proxygen::kErrorParseHeader:
         return HTTPErrorCode::HEADER_PARSE_ERROR;
diff --git a/proxygen/lib/http/coro/HTTPEvents.cpp b/proxygen/lib/http/coro/HTTPEvents.cpp
index ba0155e902..d18682a242 100644
--- a/proxygen/lib/http/coro/HTTPEvents.cpp
+++ b/proxygen/lib/http/coro/HTTPEvents.cpp
@@ -9,13 +9,14 @@
 #include "proxygen/lib/http/coro/HTTPEvents.h"
 #include "proxygen/lib/http/coro/HTTPSource.h"
 #include "proxygen/lib/http/webtransport/WebTransport.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
 HTTPHeaderEvent::HTTPHeaderEvent(std::unique_ptr<HTTPMessage> inHeaders,
                                  bool inEOM) noexcept
     : headers(std::move(inHeaders)), eom(inEOM) {
-  XCHECK(headers->isFinal() || !eom);
+  PRX_CHECK(headers->isFinal() || !eom);
 }
 
 HTTPHeaderEvent::~HTTPHeaderEvent() noexcept = default;
diff --git a/proxygen/lib/http/coro/HTTPEvents.h b/proxygen/lib/http/coro/HTTPEvents.h
index 044db3a8c0..ebed7d849f 100644
--- a/proxygen/lib/http/coro/HTTPEvents.h
+++ b/proxygen/lib/http/coro/HTTPEvents.h
@@ -12,9 +12,9 @@
 #include "proxygen/lib/http/coro/util/TimedBaton.h"
 #include <folly/coro/Task.h>
 #include <folly/io/IOBuf.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/HTTPHeaderSize.h>
 #include <proxygen/lib/http/HTTPMessage.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/common/BufUtil.h>
 
 namespace proxygen {
diff --git a/proxygen/lib/http/coro/HTTPFilterFactoryHandler.cpp b/proxygen/lib/http/coro/HTTPFilterFactoryHandler.cpp
index 597ceece94..5891c5c87c 100644
--- a/proxygen/lib/http/coro/HTTPFilterFactoryHandler.cpp
+++ b/proxygen/lib/http/coro/HTTPFilterFactoryHandler.cpp
@@ -10,6 +10,7 @@
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
 #include "proxygen/lib/http/coro/HTTPSourceFilterChain.h"
 #include "proxygen/lib/http/coro/filters/FilterFactory.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -33,7 +34,7 @@ folly::coro::Task<HTTPSourceHolder> HTTPFilterFactoryHandler::handleRequest(
   }
 
   // hand off request to the next handler
-  CHECK(getNextHandler());
+  PRX_CHECK(getNextHandler());
   auto nextHandlerResult = co_await co_awaitTry(
       getNextHandler()->handleRequest(evb, std::move(ctx), reqChain.release()));
 
diff --git a/proxygen/lib/http/coro/HTTPFixedSource.h b/proxygen/lib/http/coro/HTTPFixedSource.h
index aa8a7f3567..ee1270ce2b 100644
--- a/proxygen/lib/http/coro/HTTPFixedSource.h
+++ b/proxygen/lib/http/coro/HTTPFixedSource.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/coro/HTTPSource.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/URL.h>
 
 namespace proxygen::coro {
@@ -164,7 +164,7 @@ class HTTPErrorSource : public HTTPSource {
 
   folly::coro::Task<HTTPBodyEvent> readBodyEvent(
       uint32_t /*max = std::numeric_limits<uint32_t>::max()*/) override {
-    XLOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   void stopReading(
diff --git a/proxygen/lib/http/coro/HTTPSource.h b/proxygen/lib/http/coro/HTTPSource.h
index 98611c5c73..0bf1af1d45 100644
--- a/proxygen/lib/http/coro/HTTPSource.h
+++ b/proxygen/lib/http/coro/HTTPSource.h
@@ -11,9 +11,9 @@
 #include <folly/Function.h>
 #include <folly/ScopeGuard.h>
 #include <folly/coro/Task.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/coro/HTTPError.h>
 #include <proxygen/lib/http/coro/HTTPEvents.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -125,13 +125,13 @@ class HTTPSource {
 
 template <typename T>
 HTTPError getHTTPError(const folly::Try<T>& tryEvent) {
-  XCHECK(tryEvent.hasException());
+  PRX_CHECK(tryEvent.hasException());
   auto httpErr = tryEvent.template tryGetExceptionObject<HTTPError>();
   if (httpErr) {
     return std::move(*httpErr);
   }
   auto ex = tryEvent.tryGetExceptionObject();
-  XCHECK(ex);
+  PRX_CHECK(ex);
   return HTTPError(HTTPErrorCode::INTERNAL_ERROR, ex->what());
 }
 
diff --git a/proxygen/lib/http/coro/HTTPSourceFilter.cpp b/proxygen/lib/http/coro/HTTPSourceFilter.cpp
index 3277222411..098be00012 100644
--- a/proxygen/lib/http/coro/HTTPSourceFilter.cpp
+++ b/proxygen/lib/http/coro/HTTPSourceFilter.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPSourceFilter.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -18,7 +19,7 @@ HTTPSourceFilter::~HTTPSourceFilter() {
 
 folly::coro::Task<HTTPHeaderEvent> HTTPSourceFilter::readHeaderEventImpl(
     bool deleteOnDone) {
-  XCHECK(source_);
+  PRX_CHECK(source_);
   auto event = co_await co_awaitTry(source_->readHeaderEvent());
   if (event.hasException() || event->eom) {
     source_ = nullptr;
@@ -31,7 +32,7 @@ folly::coro::Task<HTTPHeaderEvent> HTTPSourceFilter::readHeaderEventImpl(
 
 folly::coro::Task<HTTPBodyEvent> HTTPSourceFilter::readBodyEventImpl(
     uint32_t max, bool deleteOnDone) {
-  XCHECK(source_);
+  PRX_CHECK(source_);
   auto event = co_await co_awaitTry(source_->readBodyEvent(max));
   if (event.hasException() || event->eom) {
     source_ = nullptr;
@@ -44,7 +45,7 @@ folly::coro::Task<HTTPBodyEvent> HTTPSourceFilter::readBodyEventImpl(
 
 void HTTPSourceFilter::stopReading(
     folly::Optional<const HTTPErrorCode> error) noexcept {
-  XCHECK(source_);
+  PRX_CHECK(source_);
   source_->stopReading(error);
   source_ = nullptr;
   if (heapAllocated_) {
diff --git a/proxygen/lib/http/coro/HTTPSourceFilter.h b/proxygen/lib/http/coro/HTTPSourceFilter.h
index c128a6ef22..43611e935b 100644
--- a/proxygen/lib/http/coro/HTTPSourceFilter.h
+++ b/proxygen/lib/http/coro/HTTPSourceFilter.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "proxygen/lib/http/coro/HTTPSource.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -64,12 +64,12 @@ class HTTPSourceFilter : public HTTPSource {
 
   [[nodiscard]] folly::Optional<uint64_t> getStreamID()
       const noexcept override {
-    XCHECK(source_);
+    PRX_CHECK(source_);
     return source_->getStreamID();
   }
 
   void setReadTimeout(std::chrono::milliseconds timeout) noexcept override {
-    XCHECK(source_);
+    PRX_CHECK(source_);
     source_->setReadTimeout(timeout);
   }
 
diff --git a/proxygen/lib/http/coro/HTTPSourceReader.cpp b/proxygen/lib/http/coro/HTTPSourceReader.cpp
index 8065455001..1541e5a29c 100644
--- a/proxygen/lib/http/coro/HTTPSourceReader.cpp
+++ b/proxygen/lib/http/coro/HTTPSourceReader.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPSourceReader.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -134,7 +135,7 @@ HTTPSourceReader& HTTPSourceReader::onErrorAsync(AsyncErrorFn errorFn) {
 
 folly::coro::Task<void> HTTPSourceReader::read(uint32_t maxBodySize) {
   auto head = filterChain_.release();
-  XCHECK(head);
+  PRX_CHECK(head);
   bool readCompleted = false;
   SCOPE_EXIT {
     if (!readCompleted) {
@@ -211,7 +212,7 @@ folly::coro::Task<void> HTTPSourceReader::read(uint32_t maxBodySize) {
     readCompleted = bodyEvent->eom;
     switch (bodyEvent->eventType) {
       case HTTPBodyEvent::BODY:
-        XCHECK(!bodyEvent->event.body.empty() || bodyEvent->eom);
+        PRX_CHECK(!bodyEvent->event.body.empty() || bodyEvent->eom);
         if (bodyFn_) {
           stop |= bodyFn_(std::move(bodyEvent->event.body), bodyEvent->eom);
         } else if (asyncBodyFn_) {
@@ -220,8 +221,8 @@ folly::coro::Task<void> HTTPSourceReader::read(uint32_t maxBodySize) {
         }
         break;
       case HTTPBodyEvent::DATAGRAM:
-        CHECK(bodyEvent->event.datagram);
-        CHECK(!bodyEvent->eom);
+        PRX_CHECK(bodyEvent->event.datagram);
+        PRX_CHECK(!bodyEvent->eom);
         if (datagramFn_) {
           stop |= datagramFn_(std::move(bodyEvent->event.datagram));
         } else if (asyncDatagramFn_) {
@@ -242,7 +243,7 @@ folly::coro::Task<void> HTTPSourceReader::read(uint32_t maxBodySize) {
         }
         break;
       case HTTPBodyEvent::TRAILERS:
-        XCHECK(bodyEvent->eom) << "Trailers implies EOM";
+        PRX_CHECK(bodyEvent->eom) << "Trailers implies EOM";
         if (trailerFn_) {
           trailerFn_(std::move(bodyEvent->event.trailers));
         } else if (asyncTrailerFn_) {
diff --git a/proxygen/lib/http/coro/HTTPSourceReader.h b/proxygen/lib/http/coro/HTTPSourceReader.h
index 0e0bf9f35f..cd217e0314 100644
--- a/proxygen/lib/http/coro/HTTPSourceReader.h
+++ b/proxygen/lib/http/coro/HTTPSourceReader.h
@@ -13,7 +13,7 @@
 #include "proxygen/lib/http/coro/HTTPSourceFilterChain.h"
 #include "proxygen/lib/http/coro/HTTPSourceHolder.h"
 #include "proxygen/lib/http/coro/util/TimedBaton.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
diff --git a/proxygen/lib/http/coro/HTTPStreamSource.cpp b/proxygen/lib/http/coro/HTTPStreamSource.cpp
index 4b719474ed..577d873df4 100644
--- a/proxygen/lib/http/coro/HTTPStreamSource.cpp
+++ b/proxygen/lib/http/coro/HTTPStreamSource.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPStreamSource.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 constexpr uint32_t kMaxBufferedDatagramSize = 65536;
 
@@ -22,7 +22,7 @@ HTTPStreamSource::HTTPStreamSource(folly::EventBase* evb,
     : id_(id),
       callback_(callback),
       recvWindow_(recvStreamFlowControlWindow),
-      event_(CHECK_NOTNULL(evb), readTimeout),
+      event_(PRX_CHECK_NOTNULL(evb), readTimeout),
       sinkMode_(false),
       sourceComplete_(false),
       strictFlowControl_(strictFlowControl),
@@ -103,8 +103,8 @@ void HTTPStreamSource::datagram(std::unique_ptr<folly::IOBuf> datagram) {
   }
   auto length = datagram->computeChainDataLength();
   if (bufferedDatagramSize_ + length > kMaxBufferedDatagramSize) {
-    XLOG(DBG2) << "Dropping datagram length=" << length
-               << " bufferedDatagramSize_=" << bufferedDatagramSize_;
+    PRX_VLOG(2) << "Dropping datagram length=" << length
+                << " bufferedDatagramSize_=" << bufferedDatagramSize_;
     return;
   }
   if (!sinkMode_) {
@@ -119,7 +119,7 @@ void HTTPStreamSource::pushPromise(std::unique_ptr<HTTPMessage> promise,
                                    bool eom) {
   // Treat this like a body event for state machine purposes.  Legal
   // anytime after headers and before eom
-  XCHECK(pushSource);
+  PRX_CHECK(pushSource);
   if (!validateStateTransition(HTTPTransactionIngressSM::Event::onBody, eom)) {
     pushSource->stopReading();
     return;
@@ -169,12 +169,12 @@ void HTTPStreamSource::eom() {
         // both queues are empty, put eom in body queue
         bodyQueue_.emplace_back(nullptr, true);
         event_.signal();
-        XLOG(DBG6) << "placing eom in bodyQueue_ id=" << id_;
+        PRX_VLOG(6) << "placing eom in bodyQueue_ id=" << id_;
       } else {
         // body queue is empty but header queue is not empty, put eom in
         // header queue
         headerQueue_.back().eom = true;
-        XLOG(DBG6) << "placing eom in headerQueue_ id=" << id_;
+        PRX_VLOG(6) << "placing eom in headerQueue_ id=" << id_;
       }
     } else {
       // body queue is non-empty, put eom in body queue, except datagram
@@ -183,10 +183,10 @@ void HTTPStreamSource::eom() {
       } else {
         bodyQueue_.back().eom = true;
       }
-      XLOG(DBG6) << "placing eom in bodyQueue_ id=" << id_;
+      PRX_VLOG(6) << "placing eom in bodyQueue_ id=" << id_;
     }
   } else {
-    XLOG(DBG4) << "discarding eom for sinkMode_ id=" << id_;
+    PRX_VLOG(4) << "discarding eom for sinkMode_ id=" << id_;
   }
 }
 
@@ -203,7 +203,7 @@ void HTTPStreamSource::abort(HTTPErrorCode error, std::string_view details) {
 }
 
 folly::coro::Task<HTTPHeaderEvent> HTTPStreamSource::readHeaderEvent() {
-  XCHECK(event_.getEventBase()->isInEventBaseThread());
+  PRX_CHECK(event_.getEventBase()->isInEventBaseThread());
 
   bool eomReturn = false;
   auto guard =
@@ -220,7 +220,7 @@ folly::coro::Task<HTTPHeaderEvent> HTTPStreamSource::readHeaderEvent() {
     co_yield folly::coro::co_error(std::move(error_->first));
   }
   // Calling body() before headers() will error out of waitForEvent
-  XCHECK(!headerQueue_.empty());
+  PRX_CHECK(!headerQueue_.empty());
   auto res = std::move(headerQueue_.front());
   headerQueue_.pop_front();
   eomReturn = res.eom;
@@ -232,8 +232,8 @@ folly::coro::Task<HTTPHeaderEvent> HTTPStreamSource::readHeaderEvent() {
 }
 
 folly::coro::Task<HTTPBodyEvent> HTTPStreamSource::readBodyEvent(uint32_t max) {
-  XCHECK_GT(max, 0UL);
-  XCHECK(event_.getEventBase()->isInEventBaseThread());
+  PRX_CHECK_GT(max, 0UL);
+  PRX_CHECK(event_.getEventBase()->isInEventBaseThread());
   bool eomReturn = false;
   auto guard =
       folly::makeGuard([this, &eomReturn] { checkForCompletion(eomReturn); });
@@ -259,7 +259,7 @@ folly::coro::Task<HTTPBodyEvent> HTTPStreamSource::readBodyEvent(uint32_t max) {
     co_yield folly::coro::co_error(std::move(error_->first));
   }
   // If there's no error, there must be queued body event
-  XCHECK(!bodyQueue_.empty());
+  PRX_CHECK(!bodyQueue_.empty());
   auto res = std::move(bodyQueue_.front());
   bodyQueue_.pop_front();
   if (res.eventType == HTTPBodyEvent::BODY && !res.event.body.empty()) {
@@ -278,10 +278,10 @@ folly::coro::Task<HTTPBodyEvent> HTTPStreamSource::readBodyEvent(uint32_t max) {
   } else if (res.eventType == HTTPBodyEvent::DATAGRAM) {
     auto length = res.event.datagram->computeChainDataLength();
     if (length > max) {
-      VLOG(2) << "Returning DATAGRAM with length=" << length
-              << " exceeding max=" << max;
+      PRX_VLOG(2) << "Returning DATAGRAM with length=" << length
+                  << " exceeding max=" << max;
     }
-    DCHECK_GE(bufferedDatagramSize_, length);
+    PRX_DCHECK_GE(bufferedDatagramSize_, length);
     bufferedDatagramSize_ -= length;
   }
   eomReturn = res.eom;
@@ -290,8 +290,8 @@ folly::coro::Task<HTTPBodyEvent> HTTPStreamSource::readBodyEvent(uint32_t max) {
 
 void HTTPStreamSource::stopReading(
     folly::Optional<const HTTPErrorCode> error) noexcept {
-  XCHECK(!sourceComplete_) << "Cannot call stopReading twice, or after you "
-                              "have finished reading";
+  PRX_CHECK(!sourceComplete_) << "Cannot call stopReading twice, or after you "
+                                 "have finished reading";
 
   setErrorImpl(error.value_or(HTTPErrorCode::NO_ERROR),
                "Abandoned reading",
@@ -317,7 +317,7 @@ bool HTTPStreamSource::validateHeaders(const HTTPMessage& msg, bool eom) {
     auto parsedContentLen = folly::tryTo<uint64_t>(contentLen);
     if (parsedContentLen.hasError()) {
       shouldValidateContentLength_ = false;
-      XLOG_IF(ERR, !contentLen.empty())
+      PRX_LOG_IF(ERROR, !contentLen.empty())
           << "Invalid content-length: " << contentLen;
     } else {
       expectedIngressContentLength_ = expectedIngressContentLengthRemaining_ =
@@ -340,8 +340,8 @@ void HTTPStreamSource::setError(HTTPErrorCode error,
     // there's already an error queued, no-op
     return;
   }
-  XLOG(DBG4) << "Encountered error on stream=" << id_
-             << " error=" << uint64_t(error) << " msg=" << msg;
+  PRX_VLOG(4) << "Encountered error on stream=" << id_
+              << " error=" << uint64_t(error) << " msg=" << msg;
   setErrorImpl(error, std::move(msg), ingress);
 }
 
@@ -358,7 +358,7 @@ void HTTPStreamSource::setErrorImpl(HTTPErrorCode error,
 }
 
 void HTTPStreamSource::enableSinkMode() {
-  XLOG(DBG4) << "clearing source events for id_=" << id_;
+  PRX_VLOG(4) << "clearing source events for id_=" << id_;
   headerQueue_.clear();
   while (!bodyQueue_.empty()) {
     auto res = std::move(bodyQueue_.front());
@@ -374,7 +374,7 @@ void HTTPStreamSource::enableSinkMode() {
 folly::coro::Task<void> HTTPStreamSource::waitForEvent() noexcept {
   event_.reset();
   // Really not sure why it can be > 1
-  XCHECK_LT(waiters_, std::numeric_limits<uint8_t>::max());
+  PRX_CHECK_LT(waiters_, std::numeric_limits<uint8_t>::max());
   waiters_++;
   auto status = co_await event_.wait();
   waiters_--;
diff --git a/proxygen/lib/http/coro/HTTPStreamSource.h b/proxygen/lib/http/coro/HTTPStreamSource.h
index 6fd7006cc0..3050d229a8 100644
--- a/proxygen/lib/http/coro/HTTPStreamSource.h
+++ b/proxygen/lib/http/coro/HTTPStreamSource.h
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/session/HTTPTransactionIngressSM.h>
 
 #include <list>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 /**
@@ -92,7 +93,7 @@ class HTTPStreamSource : public HTTPSource {
   ~HTTPStreamSource() override {
     // must be destructed in evb thread
     auto* evb = event_.getEventBase();
-    XCHECK(evb->isInEventBaseThread());
+    PRX_CHECK(evb->isInEventBaseThread());
   }
   HTTPStreamSource(const HTTPStreamSource&) = delete;
   HTTPStreamSource& operator=(const HTTPStreamSource&) = delete;
@@ -127,7 +128,7 @@ class HTTPStreamSource : public HTTPSource {
   // This is only for H3 ingress push streams which can be created before a
   // transport stream ID is assigned
   void setStreamID(HTTPCodec::StreamID id) {
-    XCHECK_EQ(id_, HTTPCodec::MaxStreamID);
+    PRX_CHECK_EQ(id_, HTTPCodec::MaxStreamID);
     id_ = id;
   }
 
@@ -213,7 +214,7 @@ class HTTPStreamSource : public HTTPSource {
         expectedIngressContentLength_,
         ", actual= ",
         observedBodySize);
-    XLOG(ERR) << errorMsg << " " << this;
+    PRX_LOG(ERROR) << errorMsg << " " << this;
     expectedIngressContentLengthRemaining_ = 0;
     shouldValidateContentLength_ = false;
     setError(HTTPErrorCode::CONTENT_LENGTH_MISMATCH, errorMsg);
@@ -303,8 +304,8 @@ class HTTPStreamSource : public HTTPSource {
  protected:
   // consumer will be expected to only invoke ::readBodyEvent
   void validateHeadersAndSkip(const HTTPMessage& msg, bool eom = false) {
-    XCHECK_EQ(readState_, ReadState::HeaderEvents);
-    XCHECK(headerQueue_.empty());
+    PRX_CHECK_EQ(readState_, ReadState::HeaderEvents);
+    PRX_CHECK(headerQueue_.empty());
     validateHeaders(msg, eom);
     readState_ = ReadState::BodyEvents;
   }
@@ -329,10 +330,14 @@ class HTTPStreamSource : public HTTPSource {
     HeaderEvents,
     BodyEvents
   } readState_{ReadState::HeaderEvents};
+  friend std::ostream& operator<<(std::ostream& os, ReadState s) {
+    return os << static_cast<uint32_t>(s);
+  }
   bool sinkMode_ : 1;
   bool sourceComplete_ : 1;
   bool strictFlowControl_ : 1;
   bool shouldValidateContentLength_ : 1;
   bool canSuspend_ : 1;
 };
+
 } // namespace proxygen::coro
diff --git a/proxygen/lib/http/coro/HTTPStreamSourceSink.cpp b/proxygen/lib/http/coro/HTTPStreamSourceSink.cpp
index 28faf874bf..0d9c726686 100644
--- a/proxygen/lib/http/coro/HTTPStreamSourceSink.cpp
+++ b/proxygen/lib/http/coro/HTTPStreamSourceSink.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/HTTPStreamSourceSink.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -80,7 +81,7 @@ class EomHttpSource : public HTTPSource {
 inline void handleIngressException(
     HTTPTransactionHandler* handler,
     const folly::exception_wrapper& ex) noexcept {
-  auto* httpError = CHECK_NOTNULL(ex.get_exception<HTTPError>());
+  auto* httpError = PRX_CHECK_NOTNULL(ex.get_exception<HTTPError>());
   handler->onError(HTTPErrorToHTTPException(*httpError));
 }
 
@@ -152,14 +153,14 @@ HTTPStreamSourceUpstreamSink::~HTTPStreamSourceUpstreamSink() {
 
 void HTTPStreamSourceUpstreamSink::detachAndAbortIfIncomplete(
     std::unique_ptr<HTTPSink> self) {
-  CHECK_EQ(self.get(), this);
+  PRX_CHECK_EQ(self.get(), this);
   self_ = std::move(self);
   handler_ = &kNoopTxnHandler;
   sendAbort();
 }
 
 void HTTPStreamSourceUpstreamSink::sendAbort() {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
   egressSource_.abort(HTTPErrorCode::CANCEL);
   cancellationSource_.requestCancellation();
 }
@@ -203,7 +204,7 @@ folly::coro::Task<void> HTTPStreamSourceUpstreamSink::transact(
 
   if (responseSource.hasError()) {
     std::string err{responseSource.error().describe()};
-    XLOG(DBG6) << "failed ::sendRequest; err=" << err;
+    PRX_VLOG(6) << "failed ::sendRequest; err=" << err;
     handler_->onError(
         HTTPException(HTTPException::Direction::INGRESS_AND_EGRESS, err));
     gate_.set(Event::IngressComplete);
@@ -212,7 +213,7 @@ folly::coro::Task<void> HTTPStreamSourceUpstreamSink::transact(
 
   // respSource must have streamID
   id_ = responseSource->getStreamID();
-  XCHECK(id_);
+  PRX_CHECK(id_);
   egressSource_.setStreamID(id_.value());
 
   co_await folly::coro::co_withCancellation(cancellationSource_.getToken(),
@@ -234,7 +235,7 @@ folly::coro::Task<void> HTTPStreamSourceUpstreamSink::read(
     co_await ingressResumed_.wait();
     auto headerEvent = co_await co_awaitTry(ingressSource.readHeaderEvent());
     if (headerEvent.hasException()) {
-      XLOG(DBG6) << "headerEvent err=" << headerEvent.exception().what();
+      PRX_VLOG(6) << "headerEvent err=" << headerEvent.exception().what();
       handleIngressException(handler_, headerEvent.exception());
       break;
     }
@@ -261,7 +262,7 @@ folly::coro::Task<void> HTTPStreamSourceUpstreamSink::read(
     auto bodyEvent =
         co_await co_awaitTry(ingressSource.readBodyEvent(kMaxBodyChunkSize));
     if (bodyEvent.hasException()) {
-      XLOG(DBG6) << "bodyEvent err=" << bodyEvent.exception().what();
+      PRX_VLOG(6) << "bodyEvent err=" << bodyEvent.exception().what();
       handleIngressException(handler_, bodyEvent.exception());
       break;
     }
@@ -298,7 +299,7 @@ folly::coro::Task<void> HTTPStreamSourceUpstreamSink::read(
       handler_->onEOM();
     }
   }
-  XLOG(DBG6) << __func__ << "; done";
+  PRX_VLOG(6) << __func__ << "; done";
 }
 
 } // namespace proxygen::coro
diff --git a/proxygen/lib/http/coro/HTTPStreamSourceSink.h b/proxygen/lib/http/coro/HTTPStreamSourceSink.h
index 0485b40655..c60b1951a2 100644
--- a/proxygen/lib/http/coro/HTTPStreamSourceSink.h
+++ b/proxygen/lib/http/coro/HTTPStreamSourceSink.h
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/sink/HTTPSink.h>
 #include <proxygen/lib/utils/ConditionalGate.h>
 
+#include <proxygen/lib/utils/LogShim.h>
 #include <utility>
 
 namespace proxygen::coro {
@@ -128,11 +129,11 @@ class HTTPStreamSourceUpstreamSink
   }
   // Flow control
   void pauseIngress() override {
-    XLOG(DBG8) << __func__;
+    PRX_VLOG(8) << __func__;
     ingressResumed_.reset();
   }
   void resumeIngress() override {
-    XLOG(DBG8) << __func__;
+    PRX_VLOG(8) << __func__;
     ingressResumed_.signal();
     /**
      * due to InlineExecutor being used, this will resume read loop inline and
diff --git a/proxygen/lib/http/coro/HTTPTransactionAdaptorSource.cpp b/proxygen/lib/http/coro/HTTPTransactionAdaptorSource.cpp
index 91b170826f..9883a8911f 100644
--- a/proxygen/lib/http/coro/HTTPTransactionAdaptorSource.cpp
+++ b/proxygen/lib/http/coro/HTTPTransactionAdaptorSource.cpp
@@ -9,6 +9,7 @@
 #include "proxygen/lib/http/coro/HTTPTransactionAdaptorSource.h"
 #include "proxygen/lib/http/coro/HTTPError.h"
 #include "proxygen/lib/http/coro/HTTPSourceReader.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 constexpr std::chrono::milliseconds kDefaultEgressTimeout =
@@ -34,8 +35,8 @@ HTTPTransactionAdaptorSource* HTTPTransactionAdaptorSource::create(
 }
 
 HTTPTransactionAdaptorSource::~HTTPTransactionAdaptorSource() {
-  XCHECK(!txn_);
-  XCHECK(ingressSource_.inputFinished());
+  PRX_CHECK(!txn_);
+  PRX_CHECK(ingressSource_.inputFinished());
 }
 
 folly::CancellationToken HTTPTransactionAdaptorSource::getCancelToken() {
@@ -191,7 +192,7 @@ folly::coro::Task<void> HTTPTransactionAdaptorSource::egressLoop() {
           return;
         }
 
-        XLOG_EVERY_MS(ERR, 10000)
+        PRX_LOG_EVERY_MS(ERROR, 10000)
             << "Error while handling transaction" << error.describe();
         txn_->sendAbort();
       });
diff --git a/proxygen/lib/http/coro/benchmark/HTTPCoroBenchmark.cpp b/proxygen/lib/http/coro/benchmark/HTTPCoroBenchmark.cpp
index 4ac8dca9fc..a9b1c803d3 100644
--- a/proxygen/lib/http/coro/benchmark/HTTPCoroBenchmark.cpp
+++ b/proxygen/lib/http/coro/benchmark/HTTPCoroBenchmark.cpp
@@ -11,6 +11,7 @@
 #include "proxygen/lib/http/coro/client/HTTPCoroSessionPool.h"
 #include "proxygen/lib/http/coro/server/ScopedHTTPServer.h"
 #include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "folly/init/Init.h"
 #include <folly/Benchmark.h>
@@ -84,7 +85,7 @@ HTTPClient::SecureTransportImpl transportImpl(TransportType transportType) {
     case TransportType::TLS_FIZZ:
       return HTTPClient::SecureTransportImpl::FIZZ;
     default:
-      XLOG(FATAL) << "Don't call this for QUIC";
+      PRX_LOG(FATAL) << "Don't call this for QUIC";
   }
 }
 
@@ -119,7 +120,7 @@ class SizeHandler
       HTTPSessionContextPtr /*ctx*/,
       HTTPSourceHolder requestSource) override {
     auto headerEvent = co_await requestSource.readHeaderEvent();
-    XCHECK(headerEvent.eom);
+    PRX_CHECK(headerEvent.eom);
     co_return HTTPFixedSource::makeFixedResponse(200, respBody_->clone());
   }
 
@@ -246,7 +247,7 @@ class BenchmarkFixture {
     try {
       tlsConfig.setCertificate(getServerCertPath(), getServerKeyPath(), "");
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+      PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
     }
     serverConfig.socketConfig.bindAddress.setFromLocalPort(uint16_t(0));
     if (transportType_ != TransportType::TCP) {
@@ -353,18 +354,18 @@ class BenchmarkFixture {
   folly::coro::Task<void> get(HTTPCoroSessionPool& pool) {
     auto res = co_await co_awaitTry(pool.getSessionWithReservation());
     if (res.hasException()) {
-      XLOG(ERR) << res.exception().what();
+      PRX_LOG(ERROR) << res.exception().what();
       res.throwUnlessValue();
     }
     HTTPSourceReader reader;
     reader
         .onHeaders([](std::unique_ptr<HTTPMessage> resp, bool, bool) {
-          XLOG_IF(ERR, resp->getStatusCode() != 200)
+          PRX_LOG_IF(ERROR, resp->getStatusCode() != 200)
               << "Error response, status=" << resp->getStatusCode();
           return HTTPSourceReader::Continue;
         })
         .onError([](HTTPSourceReader::ErrorContext, const HTTPError& err) {
-          XLOG(ERR) << err.msg;
+          PRX_LOG(ERROR) << err.msg;
         });
     auto maybe = co_await co_awaitTry(HTTPClient::request(
         res->session,
@@ -372,7 +373,7 @@ class BenchmarkFixture {
         HTTPFixedSource::makeFixedSource(std::make_unique<HTTPMessage>(req_)),
         std::move(reader)));
     if (maybe.hasException()) {
-      XLOG(ERR) << maybe.exception().what();
+      PRX_LOG(ERROR) << maybe.exception().what();
       res.throwUnlessValue();
     }
   }
diff --git a/proxygen/lib/http/coro/client/CMakeLists.txt b/proxygen/lib/http/coro/client/CMakeLists.txt
index a444350880..19952a00f0 100644
--- a/proxygen/lib/http/coro/client/CMakeLists.txt
+++ b/proxygen/lib/http/coro/client/CMakeLists.txt
@@ -12,8 +12,8 @@ proxygen_add_library(proxygen_http_coro_client_dns_resolver
   DEPS
     proxygen_dns_dns_module
     proxygen_dns_rfc6724
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_base
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_dns_dns_base
     Folly::folly_coro_baton
@@ -30,6 +30,7 @@ proxygen_add_library(proxygen_http_coro_client_http_connector
     proxygen_http_coro_transport_coro_ssl_transport
     proxygen_http_coro_transport_http_connect_transport
     proxygen_http_coro_util_Transport
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     mvfst::mvfst_client
     mvfst::mvfst_common_events_folly_eventbase
@@ -45,7 +46,6 @@ proxygen_add_library(proxygen_http_coro_client_http_connector
     Folly::folly_file_util
     Folly::folly_io_async_async_ssl_socket
     Folly::folly_io_async_ssl_options
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_coro
     proxygen_http_codec_codec_common
@@ -81,15 +81,15 @@ proxygen_add_library(proxygen_http_coro_client_http_connpool
     proxygen_coro
     proxygen_http_coro_client_http_connector
     proxygen_http_coro_client_http_session_factory
+    proxygen_utils_log_shim
     Folly::folly_intrusive_list
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_client_cert_reload_session_pool
   SRCS
     CertReloadSessionPool.cpp
   DEPS
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_coro_client_http_connector
     proxygen_http_coro_client_http_connpool
@@ -104,9 +104,9 @@ proxygen_add_library(proxygen_http_coro_client_http_client_connection_cache
     proxygen_http_coro_client_http_client_lib
   EXPORTED_DEPS
     proxygen_http_coro_client_http_connpool
+    proxygen_utils_log_shim
     fizz::fizz
     Folly::folly_container_evicting_cache_map
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_client_http_client_lib
@@ -115,7 +115,7 @@ proxygen_add_library(proxygen_http_coro_client_http_client_lib
   DEPS
     proxygen_coro_source
     proxygen_http_coro_client_dns_resolver
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
     Folly::folly_network_address
   EXPORTED_DEPS
     proxygen_coro
diff --git a/proxygen/lib/http/coro/client/CertReloadSessionPool.cpp b/proxygen/lib/http/coro/client/CertReloadSessionPool.cpp
index f6160a6092..1f17e90d9c 100644
--- a/proxygen/lib/http/coro/client/CertReloadSessionPool.cpp
+++ b/proxygen/lib/http/coro/client/CertReloadSessionPool.cpp
@@ -8,18 +8,18 @@
 
 #include <proxygen/lib/http/coro/client/CertReloadSessionPool.h>
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
 CertReloadSessionPool::~CertReloadSessionPool() {
-  XCHECK(getEventBase()->isInEventBaseThread());
+  PRX_CHECK(getEventBase()->isInEventBaseThread());
 }
 
 void CertReloadSessionPool::setTimerCallback(
     std::function<void(HTTPCoroSessionPool&)> cb,
     std::chrono::milliseconds interval) {
-  XCHECK(getEventBase()->isInEventBaseThread());
+  PRX_CHECK(getEventBase()->isInEventBaseThread());
   if (interval.count() > 0) {
     reloadTimer_.emplace(*this, std::move(cb), interval);
   }
diff --git a/proxygen/lib/http/coro/client/CoroDNSResolver.cpp b/proxygen/lib/http/coro/client/CoroDNSResolver.cpp
index 229187569e..7893e1bcb5 100644
--- a/proxygen/lib/http/coro/client/CoroDNSResolver.cpp
+++ b/proxygen/lib/http/coro/client/CoroDNSResolver.cpp
@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/dns/DNSModule.h"
 #include "proxygen/lib/dns/DNSResolver.h"
@@ -34,7 +34,7 @@ bool hasStatsCollector(folly::EventBase* evb) {
 }
 
 StatsCollector* getStatsCollector(folly::EventBase* evb) {
-  XCHECK(hasStatsCollector(evb));
+  PRX_CHECK(hasStatsCollector(evb));
   return stats_.get(*evb)->get();
 }
 
diff --git a/proxygen/lib/http/coro/client/HTTPClient.cpp b/proxygen/lib/http/coro/client/HTTPClient.cpp
index 3b43c59073..34a4fd8dd5 100644
--- a/proxygen/lib/http/coro/client/HTTPClient.cpp
+++ b/proxygen/lib/http/coro/client/HTTPClient.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/HTTPCoroSession.h"
 #include "proxygen/lib/http/coro/HTTPSourceReader.h"
 #include "proxygen/lib/http/coro/client/CoroDNSResolver.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
 #include <folly/SocketAddress.h>
@@ -44,7 +44,7 @@ void getConnParamsImpl(HTTPCoroConnector::ConnectionParams* connParams,
                        SecureTransportImpl secureTransportImpl,
                        folly::StringPiece sni,
                        const HTTPCoroConnector::TLSParams& tlsParams) {
-  XCHECK(!qconnParams || (secureTransportImpl == SecureTransportImpl::FIZZ));
+  PRX_CHECK(!qconnParams || (secureTransportImpl == SecureTransportImpl::FIZZ));
   HTTPCoroConnector::BaseConnectionParams* baseParams{nullptr};
   if (secureTransportImpl != SecureTransportImpl::NONE) {
     if (qconnParams) {
diff --git a/proxygen/lib/http/coro/client/HTTPClientConnectionCache.cpp b/proxygen/lib/http/coro/client/HTTPClientConnectionCache.cpp
index 09f6c93b52..7fc7311c84 100644
--- a/proxygen/lib/http/coro/client/HTTPClientConnectionCache.cpp
+++ b/proxygen/lib/http/coro/client/HTTPClientConnectionCache.cpp
@@ -9,7 +9,7 @@
 #include "proxygen/lib/http/coro/client/HTTPClientConnectionCache.h"
 #include "proxygen/lib/http/coro/client/CoroDNSResolver.h"
 #include "proxygen/lib/http/coro/client/HTTPClient.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using ConnectionParams = proxygen::coro::HTTPCoroConnector::ConnectionParams;
 using SessionParams = proxygen::coro::HTTPCoroConnector::SessionParams;
@@ -160,7 +160,7 @@ proxygen::coro::HTTPCoroSessionPool &HTTPClientConnectionCache::getPool(
     bool isSecure,
     const HTTPCoroConnector::ConnectionParams *maybeConnParams) {
   if (usingProxy() && !useConnectForProxy_) {
-    XLOG(DBG4) << "Not using CONNECT";
+    PRX_VLOG(4) << "Not using CONNECT";
     // The caller will make a GET request via the proxy.
     return *proxyPool_;
   }
@@ -168,7 +168,7 @@ proxygen::coro::HTTPCoroSessionPool &HTTPClientConnectionCache::getPool(
   auto it = pools_.find(key);
   auto sni = folly::IPAddress::validate(host) ? "" : host;
   if (it == pools_.end()) {
-    XLOG(DBG4) << "Making a new pool for key: " << key;
+    PRX_VLOG(4) << "Making a new pool for key: " << key;
     HTTPCoroConnector::ConnectionParams connParams;
     if (maybeConnParams || connParams_) {
       connParams = maybeConnParams ? *maybeConnParams : *connParams_;
diff --git a/proxygen/lib/http/coro/client/HTTPClientConnectionCache.h b/proxygen/lib/http/coro/client/HTTPClientConnectionCache.h
index 728735b6a4..4cdbab1e4d 100644
--- a/proxygen/lib/http/coro/client/HTTPClientConnectionCache.h
+++ b/proxygen/lib/http/coro/client/HTTPClientConnectionCache.h
@@ -11,7 +11,7 @@
 #include "proxygen/lib/http/coro/client/HTTPCoroSessionPool.h"
 #include <fizz/client/SynchronizedLruPskCache.h>
 #include <folly/container/EvictingCacheMap.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -67,10 +67,10 @@ class HTTPClientConnectionCache : public HTTPSessionFactory {
   }
 
   void setConnParams(HTTPCoroConnector::ConnectionParams connParams) {
-    XCHECK(connParams.sslContext ||
-           connParams.fizzContextAndVerifier.fizzContext)
+    PRX_CHECK(connParams.sslContext ||
+              connParams.fizzContextAndVerifier.fizzContext)
         << "Must set secure ConnectionParams";
-    XCHECK(!usingProxy() || useConnectForProxy_)
+    PRX_CHECK(!usingProxy() || useConnectForProxy_)
         << "Cannot set connParams with non CONNECT proxy";
     connParams_ = std::move(connParams);
   }
diff --git a/proxygen/lib/http/coro/client/HTTPCoroConnector.cpp b/proxygen/lib/http/coro/client/HTTPCoroConnector.cpp
index 3d3704f63b..caacc7185b 100644
--- a/proxygen/lib/http/coro/client/HTTPCoroConnector.cpp
+++ b/proxygen/lib/http/coro/client/HTTPCoroConnector.cpp
@@ -7,8 +7,8 @@
  */
 
 #include "proxygen/lib/http/coro/client/HTTPCoroConnector.h"
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/coro/transport/CoroSSLTransport.h"
 #include "proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h"
@@ -532,8 +532,8 @@ folly::coro::Task<HTTPCoroSession*> connectImpl(
   }
   co_await folly::coro::co_safe_point;
   if (socket.hasException()) {
-    XLOG(DBG4) << "Failed to connect to: " << serverAddr.describe()
-               << " err=" << socket.exception().what();
+    PRX_VLOG(4) << "Failed to connect to: " << serverAddr.describe()
+                << " err=" << socket.exception().what();
     if (isSecure && connParams.tlsStats) {
       bool verifyError = false; // TODO?
       // TOOD: exclude OperationCancelled?
@@ -603,8 +603,8 @@ folly::coro::Task<HTTPCoroSession*> HTTPCoroConnector::happyEyeballsConnect(
         co_await folly::coro::co_awaitTry(HTTPCoroConnector::connect(
             evb, std::move(primaryAddr), timeout, connParams, sessionParams));
     if (sessionTry.hasException()) {
-      XLOG(DBG4) << "Happy eyeballs primary connect failed: "
-                 << sessionTry.exception().what();
+      PRX_VLOG(4) << "Happy eyeballs primary connect failed: "
+                  << sessionTry.exception().what();
       failedConnection.setValue();
     }
     co_return sessionTry;
@@ -625,7 +625,7 @@ folly::coro::Task<HTTPCoroSession*> HTTPCoroConnector::happyEyeballsConnect(
         folly::coro::sleepReturnEarlyOnCancel(happyEyeballsDelay),
         failedConnection.getFuture());
     co_await folly::coro::co_safe_point;
-    XLOG(DBG4) << "Happy eyeballs fallback attempt to " << fallbackAddr;
+    PRX_VLOG(4) << "Happy eyeballs fallback attempt to " << fallbackAddr;
     co_return co_await co_nothrow(HTTPCoroConnector::connect(
         evb, fallbackAddr, timeout, connParams, sessionParams));
   };
@@ -657,7 +657,7 @@ folly::coro::Task<HTTPCoroSession*> HTTPCoroConnector::proxyConnect(
     const SessionParams& sessionParams) {
 
   // egress bufer option?
-  XLOG(DBG2) << "Sending CONNECT to " << authority;
+  PRX_VLOG(2) << "Sending CONNECT to " << authority;
   std::unique_ptr<HTTPConnectStream> connectStream;
   if (connectUnique) {
     connectStream = co_await co_nothrow(HTTPConnectStream::connectUnique(
diff --git a/proxygen/lib/http/coro/client/HTTPCoroSessionPool.cpp b/proxygen/lib/http/coro/client/HTTPCoroSessionPool.cpp
index 21e755e185..7d56957ef3 100644
--- a/proxygen/lib/http/coro/client/HTTPCoroSessionPool.cpp
+++ b/proxygen/lib/http/coro/client/HTTPCoroSessionPool.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/client/HTTPCoroConnector.h"
 #include <chrono>
 #include <folly/Random.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Time.h>
 
 using folly::coro::co_error;
@@ -52,9 +52,9 @@ HTTPCoroSessionPool::Holder::~Holder() {
 
 void HTTPCoroSessionPool::Holder::onTransactionAttached(
     const HTTPCoroSession& sess) {
-  XCHECK_EQ(&sess, &session);
+  PRX_CHECK_EQ(&sess, &session);
   // Shouldn't happen, but maybe there's a race and we should keep going
-  XLOG_IF(DFATAL, state_ == Full)
+  PRX_LOG_IF(DFATAL, state_ == Full)
       << "onTransactionAttached to unavailable session";
   if (!session.supportsMoreTransactions()) {
     pool_.moveToFull(*this);
@@ -65,7 +65,7 @@ void HTTPCoroSessionPool::Holder::onTransactionAttached(
 
 void HTTPCoroSessionPool::Holder::onTransactionDetached(
     const HTTPCoroSession& sess) {
-  XCHECK_EQ(&sess, &session);
+  PRX_CHECK_EQ(&sess, &session);
   if (!pool_.poolingEnabled_) {
     session.initiateDrain();
   } else if (state_ == Full && session.supportsMoreTransactions()) {
@@ -74,7 +74,7 @@ void HTTPCoroSessionPool::Holder::onTransactionDetached(
 }
 void HTTPCoroSessionPool::Holder::onSettingsOutgoingStreamsFull(
     const HTTPCoroSession& sess) {
-  XCHECK_EQ(&sess, &session);
+  PRX_CHECK_EQ(&sess, &session);
   pool_.moveToFull(*this);
 }
 
@@ -84,21 +84,21 @@ void HTTPCoroSessionPool::Holder::onSettingsOutgoingStreamsNotFull(
 }
 
 void HTTPCoroSessionPool::Holder::onDrainStarted(const HTTPCoroSession& sess) {
-  XLOG(DBG4) << "onDrainStarted pool=" << pool_ << " session=" << session;
+  PRX_VLOG(4) << "onDrainStarted pool=" << pool_ << " session=" << session;
   onDestroy(sess);
 }
 
 void HTTPCoroSessionPool::Holder::onDestroy(const HTTPCoroSession& sess) {
-  XLOG(DBG4) << "Destroying session holder in pool=" << pool_
-             << " session=" << session;
-  XCHECK_EQ(&sess, &session);
+  PRX_VLOG(4) << "Destroying session holder in pool=" << pool_
+              << " session=" << session;
+  PRX_CHECK_EQ(&sess, &session);
   delete this;
 }
 
 void HTTPCoroSessionPool::Holder::onDeactivateConnection(
     const HTTPCoroSession& sess) {
-  XLOG(DBG4) << "onDeactivateConnection pool=" << pool_
-             << " session=" << session;
+  PRX_VLOG(4) << "onDeactivateConnection pool=" << pool_
+              << " session=" << session;
   if (sess.supportsMoreTransactions()) {
     pool_.moveToIdle(*this);
   }
@@ -137,9 +137,9 @@ HTTPCoroSessionPool::HTTPCoroSessionPool(
       sessionParams_(std::move(sessionParams)) {
   setMaxConnections(poolParams.maxConnections);
   setMaxConnectionAttempts(poolParams.maxConnectionAttempts);
-  XLOG(DBG4) << "Creating pool for " << *this
-             << " maxConnections_=" << poolParams_.maxConnections
-             << " observer=" << observer_;
+  PRX_VLOG(4) << "Creating pool for " << *this
+              << " maxConnections_=" << poolParams_.maxConnections
+              << " observer=" << observer_;
   setSslManager();
 }
 
@@ -161,9 +161,9 @@ HTTPCoroSessionPool::HTTPCoroSessionPool(
       sessionParams_(std::move(sessionParams)) {
   setMaxConnections(poolParams.maxConnections);
   setMaxConnectionAttempts(poolParams.maxConnectionAttempts);
-  XLOG(DBG4) << "Creating pool for " << *this
-             << " maxConnections_=" << poolParams_.maxConnections
-             << " observer=" << observer_;
+  PRX_VLOG(4) << "Creating pool for " << *this
+              << " maxConnections_=" << poolParams_.maxConnections
+              << " observer=" << observer_;
   setSslManager();
 }
 
@@ -185,9 +185,9 @@ HTTPCoroSessionPool::HTTPCoroSessionPool(
       sessionParams_(std::move(sessionParams)) {
   setMaxConnections(poolParams.maxConnections);
   setMaxConnectionAttempts(poolParams.maxConnectionAttempts);
-  XLOG(DBG4) << "Creating pool for " << *this
-             << " maxConnections_=" << poolParams_.maxConnections
-             << " observer=" << observer_;
+  PRX_VLOG(4) << "Creating pool for " << *this
+              << " maxConnections_=" << poolParams_.maxConnections
+              << " observer=" << observer_;
 }
 
 void HTTPCoroSessionPool::setSslManager() {
@@ -211,8 +211,8 @@ HTTPCoroSessionPool::SessionList& HTTPCoroSessionPool::getSessionList(
 }
 
 void HTTPCoroSessionPool::moveToFull(HTTPCoroSessionPool::Holder& holder) {
-  XLOG(DBG4) << "Session now full, pool=" << *this
-             << " session=" << holder.session;
+  PRX_VLOG(4) << "Session now full, pool=" << *this
+              << " session=" << holder.session;
   removeSession(holder, /*checkForWaiters=*/false);
   addSession(holder, Holder::State::Full);
 }
@@ -222,16 +222,16 @@ void HTTPCoroSessionPool::moveToFull(HTTPCoroSessionPool::Holder& holder) {
  * slow servers from being excessively re-used and drawing load to themselves.
  */
 void HTTPCoroSessionPool::moveToAvailable(HTTPCoroSessionPool::Holder& holder) {
-  XLOG(DBG4) << "Session now available, pool=" << *this
-             << " session=" << holder.session;
+  PRX_VLOG(4) << "Session now available, pool=" << *this
+              << " session=" << holder.session;
   // TODO: consider leaving in fullSessions if the pool is over-full somehow?
   removeSession(holder, /*checkForWaiters=*/false);
   addSession(holder, Holder::State::Available);
 }
 
 void HTTPCoroSessionPool::moveToIdle(HTTPCoroSessionPool::Holder& holder) {
-  XLOG(DBG4) << "Session now idle, pool=" << *this
-             << " session=" << holder.session;
+  PRX_VLOG(4) << "Session now idle, pool=" << *this
+              << " session=" << holder.session;
   // TODO: consider leaving in fullSessions if the pool is over-full somehow?
   removeSession(holder, /*checkForWaiters=*/false);
   addSession(holder, Holder::State::Idle);
@@ -258,10 +258,10 @@ void HTTPCoroSessionPool::removeSession(HTTPCoroSessionPool::Holder& holder,
   sessionList.erase(sessionList.iterator_to(holder));
 
   if (checkForWaiters && !isDraining() && !waiters_.empty() && !full()) {
-    XLOG(DBG5) << "Initiating new connection attempt, pool=" << *this;
+    PRX_VLOG(5) << "Initiating new connection attempt, pool=" << *this;
     connectsInProgress_++;
-    XLOG(DBG4) << *this << ":" << serverAddress_
-               << " ++connectsInProgress_ = " << connectsInProgress_;
+    PRX_VLOG(4) << *this << ":" << serverAddress_
+                << " ++connectsInProgress_ = " << connectsInProgress_;
     co_withExecutor(
         eventBase_,
         co_withCancellation(cancellationSource_.getToken(), addNewConnection()))
@@ -298,8 +298,8 @@ HTTPCoroSessionPool::getSessionWithReservation() {
                                                 : availableSessions_.front();
       bool supportsMoreTransactions = holder.session.supportsMoreTransactions();
       if (supportsMoreTransactions && !shouldAgeOut(holder)) {
-        XLOG(DBG4) << "Session available, pool=" << *this
-                   << " returning session=" << holder.session;
+        PRX_VLOG(4) << "Session available, pool=" << *this
+                    << " returning session=" << holder.session;
         auto& session = holder.session;
         auto maybeReservation = session.reserveRequest();
         if (maybeReservation.hasException()) {
@@ -307,17 +307,17 @@ HTTPCoroSessionPool::getSessionWithReservation() {
         }
         co_return GetSessionResult(std::move(*maybeReservation), &session);
       } else if (!supportsMoreTransactions) {
-        XLOG(ERR) << "Full session in available!, pool=" << *this
-                  << " sess=" << holder.session;
+        PRX_LOG(ERROR) << "Full session in available!, pool=" << *this
+                       << " sess=" << holder.session;
         moveToFull(holder);
       } else {
-        XLOG(DBG4) << "Draining too-old session, pool=" << *this
-                   << " session=" << holder.session;
+        PRX_VLOG(4) << "Draining too-old session, pool=" << *this
+                    << " session=" << holder.session;
         holder.session.initiateDrain();
       }
     }
     if (millisecondsSince(start) > poolParams_.connectTimeout) {
-      XLOG(ERR) << "Timed out waiting for session, pool=" << *this;
+      PRX_LOG(ERROR) << "Timed out waiting for session, pool=" << *this;
       co_yield co_error(
           Exception(Exception::Type::Timeout, "Timed out waiting for session"));
     }
@@ -328,10 +328,10 @@ HTTPCoroSessionPool::getSessionWithReservation() {
       // of them.
       // TODO: keep an average of the last N max_streams per conn, and delay
       // creating a new connection if a pending one is likely to satisfy this
-      XLOG(DBG5) << "Initiating new connection attempt, pool=" << *this;
+      PRX_VLOG(5) << "Initiating new connection attempt, pool=" << *this;
       connectsInProgress_++;
-      XLOG(DBG4) << *this << ":" << serverAddress_
-                 << " ++connectsInProgress_ = " << connectsInProgress_;
+      PRX_VLOG(4) << *this << ":" << serverAddress_
+                  << " ++connectsInProgress_ = " << connectsInProgress_;
       co_withExecutor(eventBase_,
                       co_withCancellation(cancellationSource_.getToken(),
                                           addNewConnection()))
@@ -341,12 +341,12 @@ HTTPCoroSessionPool::getSessionWithReservation() {
     waiters_.push_back(waiter);
     // we may be exceeding the max waiters
     signalWaiters(0);
-    XLOG(DBG4) << "No sessions available, waiting, pool=" << *this;
+    PRX_VLOG(4) << "No sessions available, waiting, pool=" << *this;
     auto res = co_await co_withCancellation(
         waiter.cancellationSource.getToken(),
         waiter.baton.timedWait(eventBase_, poolParams_.connectTimeout));
     if (res == TimedBaton::Status::cancelled) {
-      XLOG_IF(DBG4, !poolToken.isCancellationRequested())
+      PRX_VLOG_IF(4, !poolToken.isCancellationRequested())
           << "getSession cancelled, pool=" << *this;
       if (waiter.exception) {
         co_yield co_error(std::move(*waiter.exception));
@@ -373,23 +373,23 @@ folly::coro::Task<void> HTTPCoroSessionPool::addNewConnection() {
   co_await folly::coro::co_safe_point;
   auto g = folly::makeGuard([&, observer = observer_] {
     if (observer) {
-      XLOG(DBG4) << "--pendingUpstreamConnections";
+      PRX_VLOG(4) << "--pendingUpstreamConnections";
       observer->incrementPendingUpstreamConnections(-1);
     }
     if (!cancelToken.isCancellationRequested()) {
       connectsInProgress_--;
-      XLOG(DBG4) << *this << ":" << serverAddress_
-                 << " --connectsInProgress_ = " << connectsInProgress_;
+      PRX_VLOG(4) << *this << ":" << serverAddress_
+                  << " --connectsInProgress_ = " << connectsInProgress_;
     }
   });
   if (observer_) {
-    XLOG(DBG4) << "++pendingUpstreamConnections, pool=" << *this;
+    PRX_VLOG(4) << "++pendingUpstreamConnections, pool=" << *this;
     observer_->incrementPendingUpstreamConnections(1);
   } else {
-    XLOG(DBG4) << "observer not set, pool=" << *this;
+    PRX_VLOG(4) << "observer not set, pool=" << *this;
   }
   folly::exception_wrapper exceptionWrapper;
-  XLOG(DBG4) << "Getting session, pool=" << *this;
+  PRX_VLOG(4) << "Getting session, pool=" << *this;
   for (uint16_t attempt = 0; attempt < poolParams_.maxConnectionAttempts;
        attempt++) {
     folly::Try<HTTPCoroSession*> sessionTry;
@@ -431,26 +431,27 @@ folly::coro::Task<void> HTTPCoroSessionPool::addNewConnection() {
       co_yield folly::coro::co_stopped_may_throw;
     }
     if (sessionTry.hasException()) {
-      XLOG(DBG3) << "Failed to get connection for pool=" << *this
-                 << " err=" << sessionTry.exception().what()
-                 << ", server=" << serverAddress_;
+      PRX_VLOG(3) << "Failed to get connection for pool=" << *this
+                  << " err=" << sessionTry.exception().what()
+                  << ", server=" << serverAddress_;
       exceptionWrapper = sessionTry.exception();
       if (overflowed()) {
-        XLOG(ERR) << "Too many connections in progress=" << " pending="
-                  << connectsInProgress_ << ", idle=" << idleSessions_.size()
-                  << ", available=" << availableSessions_.size()
-                  << ", full=" << fullSessions_.size();
+        PRX_LOG(ERROR) << "Too many connections in progress=" << " pending="
+                       << connectsInProgress_
+                       << ", idle=" << idleSessions_.size()
+                       << ", available=" << availableSessions_.size()
+                       << ", full=" << fullSessions_.size();
       }
       if (waiters_.empty()) {
         // No one is waiting
-        XLOG(INFO) << "Giving up on a connection attempt, no waiters";
+        PRX_LOG(INFO) << "Giving up on a connection attempt, no waiters";
         break;
       }
-      XLOG(DBG4) << *this << ":" << serverAddress_
-                 << " ++connectsInProgress_ = " << connectsInProgress_;
+      PRX_VLOG(4) << *this << ":" << serverAddress_
+                  << " ++connectsInProgress_ = " << connectsInProgress_;
     } else {
       auto session = *sessionTry;
-      XLOG(DBG4) << "Got upstream, pool=" << *this << " session=" << *session;
+      PRX_VLOG(4) << "Got upstream, pool=" << *this << " session=" << *session;
       auto* holder = new Holder(*session, *this);
       // defaulted available since immediate local use is expected
       addSession(*holder, holder->state_);
@@ -458,7 +459,7 @@ folly::coro::Task<void> HTTPCoroSessionPool::addNewConnection() {
     }
   }
   if (!waiters_.empty() && !hasSession() && connectsInProgress_ == 1) {
-    XLOG(DBG4) << "Cancelling waiters in pool=" << *this;
+    PRX_VLOG(4) << "Cancelling waiters in pool=" << *this;
     // The last running connect exited in failure, but there are getSession
     // calls waiting.  Cancel them so they return.
     cancelWaiters(Exception(Exception::Type::ConnectFailed,
@@ -468,8 +469,8 @@ folly::coro::Task<void> HTTPCoroSessionPool::addNewConnection() {
 }
 
 void HTTPCoroSessionPool::signalWaiters(uint32_t n) {
-  XLOG(DBG4) << "signalWaiters n=" << n
-             << ", waiters_.size()=" << waiters_.size();
+  PRX_VLOG(4) << "signalWaiters n=" << n
+              << ", waiters_.size()=" << waiters_.size();
   while (!waiters_.empty() && n-- > 0) {
     // Remove waiters as they are signalled
     waiters_.front().baton.signal();
@@ -497,10 +498,11 @@ void HTTPCoroSessionPool::cancelWaiters(Exception ex) {
 }
 
 void HTTPCoroSessionPool::drain() {
-  XCHECK(!eventBase_->isRunning() || eventBase_->isInEventBaseThread());
+  PRX_CHECK(!eventBase_->isRunning() || eventBase_->isInEventBaseThread());
   cancellationSource_.requestCancellation();
-  XLOG(DBG4) << *this << ":" << serverAddress_
-             << " connectsInProgress_ = " << connectsInProgress_ << " at drain";
+  PRX_VLOG(4) << *this << ":" << serverAddress_
+              << " connectsInProgress_ = " << connectsInProgress_
+              << " at drain";
   connectsInProgress_ = 0;
   cancelWaiters(Exception(Exception::Type::Draining, "Draining"));
   flush();
@@ -528,7 +530,7 @@ void HTTPCoroSessionPool::flush() {
 }
 
 HTTPSessionContextPtr HTTPCoroSessionPool::detachIdleSession() noexcept {
-  XLOG(DBG6) << "pool=" << *this;
+  PRX_VLOG(6) << "pool=" << *this;
   if (!hasIdleSessions() || !waiters_.empty()) {
     return {};
   }
@@ -536,12 +538,12 @@ HTTPSessionContextPtr HTTPCoroSessionPool::detachIdleSession() noexcept {
   for (auto& holder : idleSessions_) {
     auto& session = holder.session;
     if (session.isDetachable()) {
-      XLOG(DBG6) << __func__ << "; found detachable sess=" << session;
+      PRX_VLOG(6) << __func__ << "; found detachable sess=" << session;
       session.detachEvb();
       delete &holder;
       return session.acquireKeepAlive();
     } else {
-      XLOG(ERR) << __func__ << "idle session not detachable";
+      PRX_LOG(ERROR) << __func__ << "idle session not detachable";
     }
   }
 
@@ -550,9 +552,9 @@ HTTPSessionContextPtr HTTPCoroSessionPool::detachIdleSession() noexcept {
 
 void HTTPCoroSessionPool::insertIdleSession(
     HTTPSessionContextPtr&& sess) noexcept {
-  XLOG(DBG6) << __func__ << "; sess=" << sess.get();
+  PRX_VLOG(6) << __func__ << "; sess=" << sess.get();
   auto* session = static_cast<HTTPCoroSession*>(sess.get());
-  XCHECK_EQ(sess->getEventBase(), eventBase_);
+  PRX_CHECK_EQ(sess->getEventBase(), eventBase_);
   auto* holder = std::make_unique<Holder>(*session, *this).release();
   // set as available since immediate local use is expected
   addSession(*holder, Holder::State::Available);
diff --git a/proxygen/lib/http/coro/client/HTTPCoroSessionPool.h b/proxygen/lib/http/coro/client/HTTPCoroSessionPool.h
index 1a64de3c4b..b33e2cc574 100644
--- a/proxygen/lib/http/coro/client/HTTPCoroSessionPool.h
+++ b/proxygen/lib/http/coro/client/HTTPCoroSessionPool.h
@@ -11,7 +11,7 @@
 #include "proxygen/lib/http/coro/HTTPCoroSession.h"
 #include "proxygen/lib/http/coro/client/HTTPCoroConnector.h"
 #include "proxygen/lib/http/coro/client/HTTPSessionFactory.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/IntrusiveList.h>
 
@@ -125,11 +125,11 @@ class HTTPCoroSessionPool {
     if (!isDraining()) {
       drain();
     }
-    XCHECK_EQ(waiters_.size(), 0UL);
-    XCHECK_EQ(connectsInProgress_, 0UL);
-    XCHECK(idleSessions_.empty());
-    XCHECK(availableSessions_.empty());
-    XCHECK(fullSessions_.empty());
+    PRX_CHECK_EQ(waiters_.size(), 0UL);
+    PRX_CHECK_EQ(connectsInProgress_, 0UL);
+    PRX_CHECK(idleSessions_.empty());
+    PRX_CHECK(availableSessions_.empty());
+    PRX_CHECK(fullSessions_.empty());
   }
 
   [[nodiscard]] bool isSecure() const {
diff --git a/proxygen/lib/http/coro/client/samples/cocurl/CoCurl.cpp b/proxygen/lib/http/coro/client/samples/cocurl/CoCurl.cpp
index 25cf6853b4..0a2078d33c 100644
--- a/proxygen/lib/http/coro/client/samples/cocurl/CoCurl.cpp
+++ b/proxygen/lib/http/coro/client/samples/cocurl/CoCurl.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/client/HTTPClient.h"
 #include "proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h"
 #include <fizz/protocol/DefaultCertificateVerifier.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/URL.h>
 
 #include <folly/String.h>
@@ -100,7 +100,7 @@ int main(int argc, char** argv) {
   ::gflags::ParseCommandLineFlags(&argc, &argv, false);
 
   if (argc < 2) {
-    XLOG(ERR) << "Usage: cocurl <url>";
+    PRX_LOG(ERROR) << "Usage: cocurl <url>";
     return 1;
   }
 
@@ -197,7 +197,7 @@ folly::coro::Task<void> getWithCoro(folly::EventBase* evb,
                                           FLAGS_client_cert_path,
                                           FLAGS_client_key_path);
 
-  XLOG(INFO) << "Sending GET for " << urlStr;
+  PRX_LOG(INFO) << "Sending GET for " << urlStr;
   co_await HTTPClient::get(session,
                            std::move(url),
                            std::move(reader),
@@ -236,7 +236,7 @@ folly::coro::Task<void> postWithCoro(folly::EventBase* evb,
                                           FLAGS_client_cert_path,
                                           FLAGS_client_key_path);
 
-  XLOG(INFO) << "Sending POST for " << urlStr;
+  PRX_LOG(INFO) << "Sending POST for " << urlStr;
   co_await HTTPClient::post(session,
                             std::move(url),
                             ss.str(),
@@ -252,8 +252,8 @@ folly::coro::Task<void> getViaProxy(folly::EventBase* evb,
                                     HTTPSourceReader reader) {
   folly::SocketAddress proxyAddr;
   proxyAddr.setFromHostPort(FLAGS_proxy);
-  XLOG(INFO) << "Establishing HTTP connection to proxy: "
-             << proxyAddr.describe();
+  PRX_LOG(INFO) << "Establishing HTTP connection to proxy: "
+                << proxyAddr.describe();
   std::chrono::milliseconds timeout(FLAGS_timeout_ms);
   auto proxySession =
       co_await HTTPClient::getHTTPSession(evb,
@@ -265,7 +265,7 @@ folly::coro::Task<void> getViaProxy(folly::EventBase* evb,
                                           timeout,
                                           FLAGS_client_cert_path,
                                           FLAGS_client_key_path);
-  XLOG(INFO) << "Got HTTP connection to proxy: " << proxyAddr.describe();
+  PRX_LOG(INFO) << "Got HTTP connection to proxy: " << proxyAddr.describe();
 
   URL url(urlStr);
   if (!url.isValid() || !url.hasHost()) {
@@ -284,7 +284,7 @@ folly::coro::Task<void> getViaProxy(folly::EventBase* evb,
       /*clientCertPath=*/"",
       /*clientKeyPath=*/"");
 
-  XLOG(INFO) << "Sending GET for " << urlStr;
+  PRX_LOG(INFO) << "Sending GET for " << urlStr;
   co_await HTTPClient::get(endpointSession,
                            std::move(url),
                            std::move(reader),
diff --git a/proxygen/lib/http/coro/client/test/HTTPClientTests.cpp b/proxygen/lib/http/coro/client/test/HTTPClientTests.cpp
index 0bb2ea9969..5dcbcb72e1 100644
--- a/proxygen/lib/http/coro/client/test/HTTPClientTests.cpp
+++ b/proxygen/lib/http/coro/client/test/HTTPClientTests.cpp
@@ -14,7 +14,7 @@
 #include "proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h"
 #include "proxygen/lib/http/coro/test/HTTPTestSources.h"
 #include "proxygen/lib/http/coro/util/test/TestHelpers.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/client/QuicClientTransport.h>
 
 #include <folly/SocketAddress.h>
@@ -45,7 +45,7 @@ HTTPClient::SecureTransportImpl transportImpl(TransportType transportType) {
     case TransportType::TLS_FIZZ:
       return HTTPClient::SecureTransportImpl::FIZZ;
     default:
-      XLOG(FATAL) << "Don't call this for QUIC";
+      PRX_LOG(FATAL) << "Don't call this for QUIC";
   }
 }
 
@@ -251,7 +251,7 @@ CO_TEST_P_X(HTTPClientTests, MigrateSessionEvb) {
   std::array<folly::ScopedEventBaseThread, 10> scopedEvbs{};
 
   // validate we've connected successfully
-  CHECK(!maybeSess.hasException());
+  PRX_CHECK(!maybeSess.hasException());
   auto* sess = maybeSess.value();
 
   // we require a few evb loops until we reach the detachable suspension points
@@ -273,7 +273,7 @@ CO_TEST_P_X(HTTPClientTests, MigrateSessionEvb) {
 
           auto res = co_await co_awaitTry(
               sess->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-          CHECK(!res.hasException());
+          PRX_CHECK(!res.hasException());
 
           HTTPSourceReader reader(std::move(res).value());
           reader.onHeaders(
@@ -286,7 +286,7 @@ CO_TEST_P_X(HTTPClientTests, MigrateSessionEvb) {
           auto readRes = co_await folly::coro::co_awaitTry(reader.read());
           EXPECT_FALSE(readRes.hasException());
 
-          XCHECK(sess->isDetachable());
+          PRX_CHECK(sess->isDetachable());
           sess->detachEvb();
         }));
   }
@@ -343,7 +343,7 @@ CO_TEST_P_X(HTTPClientTests, ConnectorConnectError) {
                                 folly::SocketAddress("169.254.1.1", 443),
                                 milliseconds(1),
                                 getConnParams(GetParam())));
-  CHECK(sess.hasException());
+  PRX_CHECK(sess.hasException());
   if (useQuic()) {
     auto ex = sess.tryGetExceptionObject<quic::QuicInternalException>();
     EXPECT_TRUE(ex->errorCode() == quic::LocalErrorCode::CONNECT_FAILED ||
@@ -404,7 +404,7 @@ CO_TEST_P_X(HTTPClientTests, ConnectorConnectTimeout) {
           .start()
           .getTry();
 
-  CHECK(sess.hasException());
+  PRX_CHECK(sess.hasException());
   expectException(GetParam(), sess, ExceptionType::TIMED_OUT);
 
   co_return;
@@ -1182,9 +1182,9 @@ CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolLateBindConnectOnClose) {
   EXPECT_FALSE(respSource.hasException());
   res->session->initiateDrain();
   auto fut = co_withExecutor(&evb_, pool_->getSessionWithReservation()).start();
-  XLOG(DBG4) << "waiting for headers";
+  PRX_VLOG(4) << "waiting for headers";
   auto resp = co_await co_awaitTry(respSource->readHeaderEvent());
-  XLOG(DBG4) << "got headers";
+  PRX_VLOG(4) << "got headers";
   EXPECT_FALSE(resp.hasException());
   EXPECT_EQ(resp->headers->getStatusCode(), 200);
   EXPECT_TRUE(resp->eom);
@@ -1280,7 +1280,7 @@ CO_TEST_P_X(HTTPCoroSessionPoolTests, TwoWaitersOneConns) {
                                      std::move(res2->reservation)))
                      .start();
   auto res3 = co_await folly::coro::co_awaitTry(std::move(res3Fut));
-  XCHECK(res3.hasValue());
+  PRX_CHECK(res3.hasValue());
   EXPECT_EQ(res1->session, res3->session);
 
   // maxWaiters=2 => res4Fut is cancelled
@@ -1571,7 +1571,7 @@ CO_TEST_P_X(HTTPCoroSessionPoolTests, IdleSessionsTest) {
     co_await folly::coro::co_reschedule_on_current_executor;
     // there should be two idle sessions; expect detach to return session
     auto idleSession = pool_->detachIdleSession();
-    XCHECK(idleSession);
+    PRX_CHECK(idleSession);
     EXPECT_EQ(idleSession->getEventBase(), nullptr);
 
     // reservation will synchronously return reservation since we still have one
@@ -1584,7 +1584,7 @@ CO_TEST_P_X(HTTPCoroSessionPoolTests, IdleSessionsTest) {
     // no available sessions => will open new connection
     EXPECT_FALSE(pool_->hasAvailableSessions());
     auto res2 = co_await co_awaitTry(pool_->getSessionWithReservation());
-    XCHECK(!res2.hasException());
+    PRX_CHECK(!res2.hasException());
 
     // acquiring another res will indefinitely suspend since pool is full
     EXPECT_TRUE(pool_->full());
@@ -1957,7 +1957,7 @@ CO_TEST_P_X(HTTPClientConnectionCacheTests, GetSessionDuringDrain) {
   auto res = co_await co_awaitTry(connCache_.getSessionWithReservation(
       getURL(""), std::chrono::seconds(1)));
   auto ex = res.tryGetExceptionObject<HTTPCoroSessionPool::Exception>();
-  CHECK(ex);
+  PRX_CHECK(ex);
   EXPECT_EQ(ex->type, HTTPCoroSessionPool::Exception::Type::Draining);
   EXPECT_EQ(std::string(ex->what()), "Pool is draining");
 }
@@ -1973,7 +1973,7 @@ CO_TEST_P_X(HTTPClientConnectionCacheTests, GetSessionReqCancel) {
                                            std::chrono::seconds(1))));
 
   auto ex = res.tryGetExceptionObject<HTTPError>();
-  CHECK(ex);
+  PRX_CHECK(ex);
   EXPECT_EQ(ex->code, HTTPErrorCode::CORO_CANCELLED);
   EXPECT_EQ(ex->msg, "Cancelled");
 }
@@ -2006,9 +2006,9 @@ CO_TEST_P_X(HTTPClientConnectionCacheTests, PendingGetSessionDrain) {
   auto ex = co_await co_awaitTry(
       connCache.getSessionWithReservation(getURL(""), kTimeout));
 
-  CHECK(ex.hasException());
+  PRX_CHECK(ex.hasException());
   auto poolEx = ex.tryGetExceptionObject<HTTPCoroSessionPool::Exception>();
-  CHECK(poolEx);
+  PRX_CHECK(poolEx);
   EXPECT_EQ(poolEx->type, HTTPCoroSessionPool::Exception::Type::Draining);
   EXPECT_EQ(std::string(poolEx->what()), "Pool is draining");
 }
@@ -2045,9 +2045,9 @@ CO_TEST_P_X(HTTPClientConnectionCacheTests, PendingGetSessionReqCancel) {
   auto ex = co_await co_awaitTry(co_withCancellation(
       cancelSource.getToken(),
       connCache.getSessionWithReservation(getURL(""), kTimeout)));
-  CHECK(ex.hasException());
+  PRX_CHECK(ex.hasException());
   auto poolEx = ex.tryGetExceptionObject<HTTPCoroSessionPool::Exception>();
-  CHECK(poolEx);
+  PRX_CHECK(poolEx);
   EXPECT_EQ(poolEx->type, HTTPCoroSessionPool::Exception::Type::Cancelled);
   EXPECT_EQ(std::string(poolEx->what()), "Cancelled");
 }
diff --git a/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.cpp b/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.cpp
index e3e9e3c3bf..3aee6da6a9 100644
--- a/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.cpp
+++ b/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.cpp
@@ -7,6 +7,8 @@
  */
 
 #include "proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h"
+#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::coro::co_nothrow;
 
@@ -39,7 +41,7 @@ namespace proxygen::coro::test {
                              kTestDir + "certs/test_key1.pem",
                              "");
   } catch (const std::exception& ex) {
-    XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+    PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
   }
   HTTPServer::Config serverConfig;
   serverConfig.socketConfig.bindAddress.setFromIpPort(ip, port);
@@ -112,7 +114,7 @@ folly::coro::Task<HTTPSourceHolder> TestHandler::handleRequest(
     co_yield folly::coro::co_error(HTTPError(HTTPErrorCode::CANCEL, "cancel"));
   }
   if (request->getPathAsStringPiece() == "/trailers") {
-    XCHECK(headerEvent.eom);
+    PRX_CHECK(headerEvent.eom);
     auto resp = HTTPFixedSource::makeFixedResponse(200, "Trailers");
     resp->trailers_ = std::make_unique<HTTPHeaders>();
     resp->trailers_->add("Test", "Success");
diff --git a/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h b/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h
index f3b69197e8..2b1ac36910 100644
--- a/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h
+++ b/proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h
@@ -16,7 +16,7 @@
 #include "proxygen/lib/http/coro/server/ScopedHTTPServer.h"
 #include "proxygen/lib/http/coro/test/HTTPTestSources.h"
 #include "proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <algorithm>
 #include <folly/coro/Baton.h>
diff --git a/proxygen/lib/http/coro/client/test/HTTPConnectIntegrationTest.cpp b/proxygen/lib/http/coro/client/test/HTTPConnectIntegrationTest.cpp
index 0a45fdb1ca..6d84fc1086 100644
--- a/proxygen/lib/http/coro/client/test/HTTPConnectIntegrationTest.cpp
+++ b/proxygen/lib/http/coro/client/test/HTTPConnectIntegrationTest.cpp
@@ -14,6 +14,7 @@
 #include "proxygen/lib/http/coro/util/test/TestHelpers.h"
 #include "proxygen/lib/http/session/HTTPSessionStats.h"
 #include <proxygen/lib/http/session/test/MockHTTPSessionStats.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::coro::co_awaitTry;
 using folly::coro::co_error;
@@ -44,12 +45,12 @@ class ConnectHandler : public HTTPHandler {
       folly::EventBase* evb,
       HTTPSessionContextPtr ctx,
       HTTPSourceHolder requestSource) override {
-    XLOG(DBG6) << "ConnectHandler connecting to upstream";
+    PRX_VLOG(6) << "ConnectHandler connecting to upstream";
     auto transport =
         co_await co_awaitTry(folly::coro::Transport::newConnectedSocket(
             evb, serverAddress_, std::chrono::milliseconds(50)));
     // loopback connect should never fail?
-    XCHECK(!transport.hasException()) << "loopback connect failed!";
+    PRX_CHECK(!transport.hasException()) << "loopback connect failed!";
     auto connectSource = std::make_unique<ConnectSource>(
         std::make_unique<folly::coro::Transport>(std::move(transport).value()),
         std::move(requestSource));
@@ -68,18 +69,18 @@ class Handler : public TestHandler {
       HTTPSessionContextPtr ctx,
       HTTPSourceHolder requestSource) override {
     auto headerEvent = co_await co_awaitTry(requestSource.readHeaderEvent());
-    XLOG(DBG6) << " Handler::handleRequest; got headerEvent; ex="
-               << int(headerEvent.hasException());
+    PRX_VLOG(6) << " Handler::handleRequest; got headerEvent; ex="
+                << int(headerEvent.hasException());
     if (headerEvent.hasException()) {
       co_yield co_error(headerEvent.exception());
     }
 
     auto method = headerEvent->headers->getMethod();
-    XCHECK(method);
+    PRX_CHECK(method);
     if (method == HTTPMethod::CONNECT) {
-      XLOG(DBG6) << "Handler::handleRequest HTTPMethod::CONNECT";
+      PRX_VLOG(6) << "Handler::handleRequest HTTPMethod::CONNECT";
       if (headerEvent->eom) {
-        XLOG(DBG4) << "eom in header event for CONNECT request";
+        PRX_VLOG(4) << "eom in header event for CONNECT request";
         co_yield co_error(
             HTTPError{HTTPErrorCode::REFUSED_STREAM, "eom in connect request"});
       }
@@ -89,13 +90,13 @@ class Handler : public TestHandler {
       co_yield co_result(std::move(connectRes));
     }
 
-    XLOG(DBG6) << "header event query string ="
-               << headerEvent->headers->getQueryString();
+    PRX_VLOG(6) << "header event query string ="
+                << headerEvent->headers->getQueryString();
     uint64_t suspendEgressMs =
         parseQueryParamAsInt(*headerEvent->headers, kSuspendEgressMs)
             .value_or(0);
     if (suspendEgressMs > 0) {
-      XLOG(DBG6) << folly::to<std::string>(
+      PRX_VLOG(6) << folly::to<std::string>(
           "suspending ingress for ", suspendEgressMs, "ms");
       co_await folly::coro::sleep(std::chrono::milliseconds(suspendEgressMs));
     }
@@ -147,7 +148,7 @@ class HTTPConnectIntegrationTest : public ::testing::Test {
   folly::coro::Task<HTTPCoroSession*> getProxySess() {
     auto proxySess = co_await co_awaitTry(HTTPCoroConnector::connect(
         &evb_, getServAddr(), kConnectTimeout, getConnParams()));
-    XCHECK(!proxySess.hasException())
+    PRX_CHECK(!proxySess.hasException())
         << "proxySess ex=" << proxySess.exception().what();
     co_return proxySess.value();
   }
@@ -181,7 +182,7 @@ CO_TEST_F_X(HTTPConnectIntegrationTest, Simple) {
   auto authority = folly::to<std::string>(
       "https://localhost:", getServAddr().getPort(), "/");
   auto serverSess = co_await co_awaitTry(proxyConnect(proxySess, authority));
-  XCHECK(!serverSess.hasException())
+  PRX_CHECK(!serverSess.hasException())
       << "serverSess ex=" << serverSess.exception().what();
 
   // simple GET request on the tunneled session should yield 200
@@ -189,8 +190,8 @@ CO_TEST_F_X(HTTPConnectIntegrationTest, Simple) {
       HTTPClient::get(/*session=*/serverSess.value(),
                       /*reservation=*/*serverSess.value()->reserveRequest(),
                       /*url=*/URL{authority}));
-  XCHECK(!resp.hasException()) << "resp ex=" << resp.exception();
-  XCHECK_EQ(resp->headers->getStatusCode(), 200);
+  PRX_CHECK(!resp.hasException()) << "resp ex=" << resp.exception();
+  PRX_CHECK_EQ(resp->headers->getStatusCode(), 200);
 
   serverSess.value()->initiateDrain();
   proxySess->initiateDrain();
@@ -214,7 +215,7 @@ CO_TEST_F_X(HTTPConnectIntegrationTest, TimeoutConnectTransportRead) {
   sessParams.connReadTimeout = std::chrono::milliseconds(200);
   auto serverSess =
       co_await co_awaitTry(proxyConnect(proxySess, authority, sessParams));
-  XCHECK(!serverSess.hasException())
+  PRX_CHECK(!serverSess.hasException())
       << "serverSess ex=" << serverSess.exception().what();
 
   // send a request with a suspend_egress_ms query param which is read by the
@@ -224,11 +225,11 @@ CO_TEST_F_X(HTTPConnectIntegrationTest, TimeoutConnectTransportRead) {
 
   auto respSource =
       co_await co_awaitTry(serverSess.value()->sendRequest(reqSource));
-  XCHECK(!respSource.hasException()) << respSource.exception().what();
+  PRX_CHECK(!respSource.hasException()) << respSource.exception().what();
   HTTPSourceReader reader{std::move(respSource).value()};
 
   auto readResult = co_await co_awaitTry(reader.read());
-  XCHECK(!readResult.hasException()) << readResult.exception();
+  PRX_CHECK(!readResult.hasException()) << readResult.exception();
 
   serverSess.value()->initiateDrain();
   proxySess->initiateDrain();
diff --git a/proxygen/lib/http/coro/filters/CMakeLists.txt b/proxygen/lib/http/coro/filters/CMakeLists.txt
index 9d52e0dba8..c70ac00fae 100644
--- a/proxygen/lib/http/coro/filters/CMakeLists.txt
+++ b/proxygen/lib/http/coro/filters/CMakeLists.txt
@@ -22,6 +22,7 @@ proxygen_add_library(proxygen_http_coro_filters_compression_filter
   EXPORTED_DEPS
     proxygen_coro_source
     proxygen_utils_compression_filter_utils
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_filters_decompression_filter
@@ -47,6 +48,7 @@ proxygen_add_library(proxygen_http_coro_filters_decompression_filter_factory
     DecompressionFilterFactory.cpp
   DEPS
     proxygen_http_coro_filters_decompression_filter
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_coro_filters_FilterFactory
     proxygen_http_coro_filters_ServerFilterFactory
@@ -56,7 +58,7 @@ proxygen_add_library(proxygen_http_coro_filters_status_1xx_filter
   SRCS
     Status1xxFilter.cpp
   DEPS
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_coro_source
 )
@@ -80,16 +82,16 @@ proxygen_add_library(proxygen_http_coro_filters_logger
     proxygen_coro
     proxygen_coro_source
     proxygen_sampling_sampled
+    proxygen_utils_log_shim
     Folly::folly_coro_collect
     Folly::folly_coro_promise
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_filters_redirect_handler
   SRCS
     HTTPRedirectHandler.cpp
   DEPS
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_coro
     proxygen_coro_source
diff --git a/proxygen/lib/http/coro/filters/CompressionFilter.cpp b/proxygen/lib/http/coro/filters/CompressionFilter.cpp
index eba323a8c4..4029e3124c 100644
--- a/proxygen/lib/http/coro/filters/CompressionFilter.cpp
+++ b/proxygen/lib/http/coro/filters/CompressionFilter.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/filters/CompressionFilter.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 using folly::coro::co_error;
@@ -72,7 +73,7 @@ folly::coro::Task<HTTPBodyEvent> CompressionFilter::readBodyEvent(
 
   // try to compress body, validate success
   if (auto* body = asBodyEv(*bodyEvent)) {
-    CHECK(compressor_);
+    PRX_CHECK(compressor_);
     folly::IOBuf emptyBuf{};
     auto* pBuf = bodyEvent->event.body.empty() ? &emptyBuf : body->front();
     auto compressed = compressor_->compress(pBuf, bodyEvent->eom);
@@ -100,7 +101,7 @@ folly::coro::Task<HTTPBodyEvent> CompressionFilter::readBodyEvent(
     }
 
     // need to buffer trailers, dismiss guard as mentioned above
-    CHECK(!pendingBodyEvent_);
+    PRX_CHECK(!pendingBodyEvent_);
     pendingBodyEvent_.emplace(std::move(*bodyEvent));
     guard.dismiss();
     // eom=false; there's a pending event to be delivered via next
diff --git a/proxygen/lib/http/coro/filters/CompressionFilter.h b/proxygen/lib/http/coro/filters/CompressionFilter.h
index bd8a1c5c6a..4c7b0bcb07 100644
--- a/proxygen/lib/http/coro/filters/CompressionFilter.h
+++ b/proxygen/lib/http/coro/filters/CompressionFilter.h
@@ -10,6 +10,7 @@
 
 #include "proxygen/lib/http/coro/HTTPSourceFilter.h"
 #include <proxygen/lib/utils/CompressionFilterUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 using FilterParams = proxygen::CompressionFilterUtils::FilterParams;
@@ -21,7 +22,7 @@ class CompressionFilter : public HTTPSourceFilter {
   CompressionFilter(HTTPSource* source,
                     std::shared_ptr<folly::Optional<FilterParams>> params)
       : HTTPSourceFilter(source), params_(std::move(params)) {
-    CHECK(params_);
+    PRX_CHECK(params_);
   }
 
   folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override;
diff --git a/proxygen/lib/http/coro/filters/DecompressionFilterFactory.cpp b/proxygen/lib/http/coro/filters/DecompressionFilterFactory.cpp
index 0110bd5334..b3550642e0 100644
--- a/proxygen/lib/http/coro/filters/DecompressionFilterFactory.cpp
+++ b/proxygen/lib/http/coro/filters/DecompressionFilterFactory.cpp
@@ -8,6 +8,7 @@
 
 #include "proxygen/lib/http/coro/filters/DecompressionFilterFactory.h"
 #include "proxygen/lib/http/coro/filters/DecompressionFilter.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -15,7 +16,7 @@ namespace {
 template <typename Filter>
 Filter* makeDecompressionFilter() {
   auto filter = std::make_unique<Filter>(/*source=*/nullptr);
-  XCHECK(filter);
+  PRX_CHECK(filter);
   filter->setHeapAllocated();
   return filter.release();
 }
diff --git a/proxygen/lib/http/coro/filters/HTTPRedirectHandler.cpp b/proxygen/lib/http/coro/filters/HTTPRedirectHandler.cpp
index 1afefbc92e..03ea31531a 100644
--- a/proxygen/lib/http/coro/filters/HTTPRedirectHandler.cpp
+++ b/proxygen/lib/http/coro/filters/HTTPRedirectHandler.cpp
@@ -8,7 +8,7 @@
 
 #include "proxygen/lib/http/coro/filters/HTTPRedirectHandler.h"
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 bool isRedirectable(uint16_t code,
diff --git a/proxygen/lib/http/coro/filters/Logger.cpp b/proxygen/lib/http/coro/filters/Logger.cpp
index a4289d50c5..1c35cf4457 100644
--- a/proxygen/lib/http/coro/filters/Logger.cpp
+++ b/proxygen/lib/http/coro/filters/Logger.cpp
@@ -8,6 +8,7 @@
 
 #include "proxygen/lib/http/coro/filters/Logger.h"
 #include <proxygen/lib/http/HTTPPriorityFunctions.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -49,7 +50,7 @@ void Logger::Filter::describe(std::ostream& os) const {
 }
 
 void Logger::logWithVlog(int level) const {
-  VLOG(level)
+  PRX_VLOG_LEVEL(level)
     << "HTTP request logger: \n\t"
     << "Local Addr:\t" << localAddr << "\n\t"
     << "Peer Addr:\t" << peerAddr << "\n\t"
diff --git a/proxygen/lib/http/coro/filters/Logger.h b/proxygen/lib/http/coro/filters/Logger.h
index 6a0fc22b43..d18068ada4 100644
--- a/proxygen/lib/http/coro/filters/Logger.h
+++ b/proxygen/lib/http/coro/filters/Logger.h
@@ -12,8 +12,8 @@
 #include "proxygen/lib/http/coro/HTTPSourceFilter.h"
 #include <folly/coro/Collect.h>
 #include <folly/coro/Promise.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/sampling/Sampled.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -46,7 +46,7 @@ class Logger {
   explicit Logger(HTTPSessionContextPtr sessionCtx,
                   std::shared_ptr<SampledLogger> logImpl = nullptr,
                   bool logOnDestroy = true) {
-    XCHECK(sessionCtx);
+    PRX_CHECK(sessionCtx);
     sessionCtx_ = std::move(sessionCtx);
     localAddr = sessionCtx_->getLocalAddress();
     peerAddr = sessionCtx_->getPeerAddress();
diff --git a/proxygen/lib/http/coro/filters/Status1xxFilter.cpp b/proxygen/lib/http/coro/filters/Status1xxFilter.cpp
index 97ce3f5412..077bd8cd63 100644
--- a/proxygen/lib/http/coro/filters/Status1xxFilter.cpp
+++ b/proxygen/lib/http/coro/filters/Status1xxFilter.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/filters/Status1xxFilter.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -15,7 +15,7 @@ folly::coro::Task<HTTPHeaderEvent> Status1xxFilter::readHeaderEvent() {
   auto headerEvent = co_await HTTPSourceFilter::readHeaderEvent();
   while (!headerEvent.isFinal()) {
     // Ignore this event and wait for the next one.
-    XLOG(DBG4)
+    PRX_VLOG(4)
         << fmt::format("A response with status code {} has been filtered out",
                        headerEvent.headers->getStatusCode());
     headerEvent = co_await HTTPSourceFilter::readHeaderEvent();
diff --git a/proxygen/lib/http/coro/filters/test/CompressionFilterTests.cpp b/proxygen/lib/http/coro/filters/test/CompressionFilterTests.cpp
index 2e259b5ed5..d60deeebe5 100644
--- a/proxygen/lib/http/coro/filters/test/CompressionFilterTests.cpp
+++ b/proxygen/lib/http/coro/filters/test/CompressionFilterTests.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/coro/HTTPHybridSource.h>
 #include <proxygen/lib/http/coro/HTTPSourceReader.h>
 #include <proxygen/lib/http/coro/test/Mocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/ZlibStreamCompressor.h>
 #include <proxygen/lib/utils/ZstdStreamDecompressor.h>
 
@@ -137,7 +138,7 @@ class CompressionFilterTest : public Test {
       }
       auto processedBody =
           expectCompression ? zd_->decompress(body.move().get()) : body.move();
-      CHECK(!zd_->hasError()) << "Failed to decompress body!";
+      PRX_CHECK(!zd_->hasError()) << "Failed to decompress body!";
       if (decompressedResponseBody) {
         decompressedResponseBody->prependChain(std::move(processedBody));
       } else {
@@ -150,7 +151,7 @@ class CompressionFilterTest : public Test {
     co_withExecutor(&evb_, reader.read()).start();
     evb_.loop();
 
-    CHECK(decompressedResponseBody);
+    PRX_CHECK(decompressedResponseBody);
     EXPECT_THAT(decompressedResponseBody.get(),
                 IOBufEquals(maybeChainedRespBody.get()));
   }
diff --git a/proxygen/lib/http/coro/filters/test/DecompressionFilterTest.cpp b/proxygen/lib/http/coro/filters/test/DecompressionFilterTest.cpp
index 2cef8f3bdf..afac8a91b5 100644
--- a/proxygen/lib/http/coro/filters/test/DecompressionFilterTest.cpp
+++ b/proxygen/lib/http/coro/filters/test/DecompressionFilterTest.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/coro/filters/DecompressionFilterFactory.h>
 #include <proxygen/lib/http/coro/test/HTTPTestSources.h>
 #include <proxygen/lib/http/coro/util/test/TestHelpers.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 
@@ -63,7 +64,7 @@ CO_TEST_F_X(DecompressionEgressFilterTest, TestExceptionPassthru) {
         getEgressDecompressionFilter(&headerEventExceptionSource);
 
     auto headerEvent = co_await co_awaitTry(egressFilter->readHeaderEvent());
-    XCHECK(headerEvent.hasException());
+    PRX_CHECK(headerEvent.hasException());
   }
 
   // test yielding exception on body event
@@ -75,9 +76,9 @@ CO_TEST_F_X(DecompressionEgressFilterTest, TestExceptionPassthru) {
         getEgressDecompressionFilter(&bodyEventExceptionSource);
 
     auto headerEvent = co_await co_awaitTry(egressFilter->readHeaderEvent());
-    XCHECK(!headerEvent.hasException());
+    PRX_CHECK(!headerEvent.hasException());
     auto bodyEvent = co_await co_awaitTry(egressFilter->readBodyEvent());
-    XCHECK(bodyEvent.hasException());
+    PRX_CHECK(bodyEvent.hasException());
   }
 }
 
@@ -93,7 +94,7 @@ CO_TEST_F_X(DecompressionEgressFilterTest, SkipExistingAcceptEncoding) {
 
   // check filter doesn't modify header
   auto headerEvent = co_await co_awaitTry(egressFilter->readHeaderEvent());
-  XCHECK(!headerEvent.hasException() && headerEvent->eom);
+  PRX_CHECK(!headerEvent.hasException() && headerEvent->eom);
   auto acceptEncoding = headerEvent->headers->getHeaders().getSingleOrEmpty(
       HTTP_HEADER_ACCEPT_ENCODING);
   EXPECT_EQ(acceptEncoding, "foo");
@@ -108,7 +109,7 @@ CO_TEST_F_X(DecompressionEgressFilterTest, AddAcceptEncodingIfMissing) {
 
   // check filter adds headers
   auto headerEvent = co_await co_awaitTry(egressFilter->readHeaderEvent());
-  XCHECK(!headerEvent.hasException() && headerEvent->eom);
+  PRX_CHECK(!headerEvent.hasException() && headerEvent->eom);
   auto acceptEncoding = headerEvent->headers->getHeaders().getSingleOrEmpty(
       HTTP_HEADER_ACCEPT_ENCODING);
   EXPECT_EQ(acceptEncoding, "gzip, deflate, zstd");
@@ -136,7 +137,7 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestExceptionPassthru) {
         getIngressDecompressionFilter(&headerEventExceptionSource);
 
     auto headerEvent = co_await co_awaitTry(ingressFilter->readHeaderEvent());
-    XCHECK(headerEvent.hasException());
+    PRX_CHECK(headerEvent.hasException());
   }
 
   // test yielding exception on body event
@@ -149,9 +150,9 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestExceptionPassthru) {
         getIngressDecompressionFilter(&bodyEventExceptionSource);
 
     auto headerEvent = co_await co_awaitTry(ingressFilter->readHeaderEvent());
-    XCHECK(!headerEvent.hasException());
+    PRX_CHECK(!headerEvent.hasException());
     auto bodyEvent = co_await co_awaitTry(ingressFilter->readBodyEvent());
-    XCHECK(bodyEvent.hasException());
+    PRX_CHECK(bodyEvent.hasException());
   }
 }
 
@@ -181,7 +182,7 @@ CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
   // should we modify the headers if just eom (i.e. no body)?
   auto* ingressFilter = getIngressDecompressionFilter(&respSource);
   auto headerEvent = co_await co_awaitTry(ingressFilter->readHeaderEvent());
-  XCHECK(!headerEvent.hasException());
+  PRX_CHECK(!headerEvent.hasException());
   const auto& respHeaders = headerEvent->headers->getHeaders();
   // should have been stripped by the filter
   EXPECT_FALSE(respHeaders.exists(HTTP_HEADER_CONTENT_ENCODING));
@@ -191,9 +192,9 @@ CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
   EXPECT_EQ(transferEncoding, "chunked");
 
   auto bodyEvent = co_await co_awaitTry(ingressFilter->readBodyEvent());
-  XCHECK(!bodyEvent.hasException());
-  XCHECK(bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
-         bodyEvent->eom);
+  PRX_CHECK(!bodyEvent.hasException());
+  PRX_CHECK(bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
+            bodyEvent->eom);
   EXPECT_EQ(bodyEvent->event.body.move()->toString(),
             "abcdefghijklmnopqrstuvwxyz");
 }
@@ -208,13 +209,13 @@ CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
 
   auto&& [requestFilter, responseFilter] =
       ServerDecompressionFilterFactory{}.makeFilters();
-  XCHECK(responseFilter == nullptr);
-  XCHECK(requestFilter != nullptr);
+  PRX_CHECK(responseFilter == nullptr);
+  PRX_CHECK(requestFilter != nullptr);
   requestFilter->setSource(&reqSource);
 
   const auto headerEvent =
       co_await co_awaitTry(requestFilter->readHeaderEvent());
-  XCHECK(headerEvent.hasValue());
+  PRX_CHECK(headerEvent.hasValue());
   const auto& respHeaders = headerEvent->headers->getHeaders();
   // should have been stripped by the filter
   EXPECT_FALSE(respHeaders.exists(HTTP_HEADER_CONTENT_ENCODING));
@@ -224,9 +225,9 @@ CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
   EXPECT_EQ(transferEncoding, "chunked");
 
   auto bodyEvent = co_await co_awaitTry(requestFilter->readBodyEvent());
-  XCHECK(bodyEvent.hasValue() &&
-         bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
-         bodyEvent->eom);
+  PRX_CHECK(bodyEvent.hasValue() &&
+            bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
+            bodyEvent->eom);
   EXPECT_EQ(bodyEvent->event.body.move()->toString(),
             "abcdefghijklmnopqrstuvwxyz");
 }
@@ -261,7 +262,7 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestUnsupportedCompression) {
 
   auto* ingressFilter = getIngressDecompressionFilter(&respSource);
   auto headerEvent = co_await co_awaitTry(ingressFilter->readHeaderEvent());
-  XCHECK(!headerEvent.hasException());
+  PRX_CHECK(!headerEvent.hasException());
   const auto& respHeaders = headerEvent->headers->getHeaders();
   // should NOT have been stripped by the filter
   const auto& contentEncoding =
@@ -270,9 +271,9 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestUnsupportedCompression) {
   EXPECT_TRUE(respHeaders.exists(HTTP_HEADER_CONTENT_LENGTH));
 
   auto bodyEvent = co_await co_awaitTry(ingressFilter->readBodyEvent());
-  XCHECK(!bodyEvent.hasException());
-  XCHECK(bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
-         bodyEvent->eom);
+  PRX_CHECK(!bodyEvent.hasException());
+  PRX_CHECK(bodyEvent->eventType == HTTPBodyEvent::EventType::BODY &&
+            bodyEvent->eom);
   // should be identical to original body
   EXPECT_EQ(bodyEvent->event.body.move()->to<std::string>(),
             "abcdefghijklmnopqrstuvwxyz");
@@ -291,7 +292,7 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestMalformedCompression) {
 
   auto* ingressFilter = getIngressDecompressionFilter(&respSource);
   auto headerEvent = co_await co_awaitTry(ingressFilter->readHeaderEvent());
-  XCHECK(!headerEvent.hasException());
+  PRX_CHECK(!headerEvent.hasException());
   const auto& respHeaders = headerEvent->headers->getHeaders();
   // should have been stripped by the filter
   EXPECT_FALSE(respHeaders.exists(HTTP_HEADER_CONTENT_ENCODING));
@@ -301,7 +302,7 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestMalformedCompression) {
   EXPECT_EQ(transferEncoding, "chunked");
 
   auto bodyEvent = co_await co_awaitTry(ingressFilter->readBodyEvent());
-  XCHECK(bodyEvent.hasException());
+  PRX_CHECK(bodyEvent.hasException());
 }
 
 class MockStatsCallback : public DecompressionIngressFilter::StatsCallback {
@@ -366,7 +367,7 @@ CO_TEST_F_X(DecompressionIngressFilterTest, TestStatsCallback_Failure) {
 
   co_await co_awaitTry(ingressFilter->readHeaderEvent());
   auto bodyEvent = co_await co_awaitTry(ingressFilter->readBodyEvent());
-  XCHECK(bodyEvent.hasException());
+  PRX_CHECK(bodyEvent.hasException());
 }
 
 } // namespace proxygen::coro::test
diff --git a/proxygen/lib/http/coro/filters/test/HTTPRedirectHandlerTest.cpp b/proxygen/lib/http/coro/filters/test/HTTPRedirectHandlerTest.cpp
index 491840ded0..88a8402460 100644
--- a/proxygen/lib/http/coro/filters/test/HTTPRedirectHandlerTest.cpp
+++ b/proxygen/lib/http/coro/filters/test/HTTPRedirectHandlerTest.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
 #include "proxygen/lib/http/coro/HTTPSourceReader.h"
 #include "proxygen/lib/http/coro/test/HTTPTestSources.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/coro/test/Mocks.h"
 #include <folly/coro/GmockHelpers.h>
@@ -403,7 +403,7 @@ CO_TEST_F(HTTPRedirectHandlerTest, StopReading) {
             co_await folly::coro::co_withCancellation(
                 cancellationSource.getToken(),
                 folly::coro::sleep(std::chrono::minutes(1)));
-            XLOG(FATAL) << "Unreachable";
+            PRX_LOG(FATAL) << "Unreachable";
           }));
   EXPECT_CALL(mockSource, stopReading(_))
       .WillOnce(Invoke(
@@ -428,7 +428,7 @@ CO_TEST_F(HTTPRedirectHandlerTest, StopReadingWhileConnecting) {
           [](std::string, uint16_t, bool, std::chrono::milliseconds, auto)
               -> folly::coro::Task<HTTPSessionFactory::GetSessionResult> {
             co_await folly::coro::sleep(std::chrono::minutes(1));
-            XLOG(FATAL) << "Unreachable";
+            PRX_LOG(FATAL) << "Unreachable";
           }));
   HTTPRedirectHandler redirectHandler(mockSessionFactory_);
   HTTPSourceReader reqReader;
@@ -455,7 +455,7 @@ CO_TEST_F(HTTPRedirectHandlerTest, StopReadingWhileSending) {
                  [](HTTPSourceHolder, HTTPCoroSession::RequestReservation)
                      -> folly::coro::Task<HTTPSourceHolder> {
                    co_await folly::coro::sleep(std::chrono::minutes(1));
-                   XLOG(FATAL) << "Unreachable";
+                   PRX_LOG(FATAL) << "Unreachable";
                  });
   HTTPRedirectHandler redirectHandler(mockSessionFactory_);
   HTTPSourceReader reqReader;
diff --git a/proxygen/lib/http/coro/filters/test/MutateFilterTest.cpp b/proxygen/lib/http/coro/filters/test/MutateFilterTest.cpp
index bc8fa545f3..2084451681 100644
--- a/proxygen/lib/http/coro/filters/test/MutateFilterTest.cpp
+++ b/proxygen/lib/http/coro/filters/test/MutateFilterTest.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/coro/HTTPStreamSource.h>
 #include <proxygen/lib/http/coro/filters/MutateFilter.h>
 #include <proxygen/lib/http/coro/util/test/TestHelpers.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 
@@ -45,7 +46,7 @@ CO_TEST_F_X(MutateFilterTest, SimpleTest) {
   MutateFilter::BodyMutateFn bodyHook = [](HTTPBodyEvent& bodyEvent) {
     // replace "hello" in body with "world"
     EXPECT_EQ(bodyEvent.eventType, HTTPBodyEvent::BODY);
-    CHECK(!bodyEvent.event.body.empty());
+    PRX_CHECK(!bodyEvent.event.body.empty());
     auto bodyStr = bodyEvent.event.body.move()->to<std::string>();
     EXPECT_EQ(bodyStr, "hello");
     bodyEvent.event.body.append(folly::IOBuf::copyBuffer("world"));
@@ -68,7 +69,7 @@ CO_TEST_F_X(MutateFilterTest, SimpleTest) {
       });
 
   reader.onBody([](BufQueue body, bool /*eom*/) {
-    CHECK(!body.empty());
+    PRX_CHECK(!body.empty());
     auto bodyStr = body.move()->to<std::string>();
     EXPECT_EQ(bodyStr, "world");
     return true;
@@ -86,10 +87,10 @@ CO_TEST_F_X(MutateFilterTest, PassThruOnError) {
   // create visitor
   MutateFilter::HeaderMutateFn headerHook =
       [](HTTPHeaderEvent& /*headerEvent*/) {
-        XLOG(FATAL) << "header hook called";
+        PRX_LOG(FATAL) << "header hook called";
       };
   MutateFilter::BodyMutateFn bodyHook = [](HTTPBodyEvent& /*bodyEvent*/) {
-    XLOG(FATAL) << "body hook called";
+    PRX_LOG(FATAL) << "body hook called";
   };
 
   auto* mutateSource =
diff --git a/proxygen/lib/http/coro/filters/test/TransformFilterTest.cpp b/proxygen/lib/http/coro/filters/test/TransformFilterTest.cpp
index 078ec1d379..86df574d2e 100644
--- a/proxygen/lib/http/coro/filters/test/TransformFilterTest.cpp
+++ b/proxygen/lib/http/coro/filters/test/TransformFilterTest.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/coro/HTTPStreamSource.h>
 #include <proxygen/lib/http/coro/filters/TransformFilter.h>
 #include <proxygen/lib/http/coro/util/test/TestHelpers.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 
@@ -38,7 +39,7 @@ CO_TEST_F_X(TransformFilterTest, BasicTest) {
   // header transform filter adds two header fields into HTTPHeaders
   TransformFilter::HeaderTransformFn headerHook =
       [](folly::Try<HTTPHeaderEvent>&& headerEvent) {
-        CHECK(!headerEvent.hasException());
+        PRX_CHECK(!headerEvent.hasException());
         // add two random header fields
         auto& headers = headerEvent->headers->getHeaders();
         headers.add("x-header-a", "x-value-a");
@@ -49,10 +50,10 @@ CO_TEST_F_X(TransformFilterTest, BasicTest) {
   // body transform filter ("hello", eom=false) -> ("world", eom=true)
   TransformFilter::BodyTransformFn bodyHook =
       [](folly::Try<HTTPBodyEvent>&& bodyEvent) {
-        CHECK(!bodyEvent.hasException());
+        PRX_CHECK(!bodyEvent.hasException());
         // replace "hello" in body with "world"
         EXPECT_EQ(bodyEvent->eventType, HTTPBodyEvent::BODY);
-        CHECK(!bodyEvent->event.body.empty());
+        PRX_CHECK(!bodyEvent->event.body.empty());
         auto bodyStr = bodyEvent->event.body.move()->to<std::string>();
         EXPECT_EQ(bodyStr, "hello");
         bodyEvent->event.body.append(folly::IOBuf::copyBuffer("world"));
@@ -78,7 +79,7 @@ CO_TEST_F_X(TransformFilterTest, BasicTest) {
       });
 
   reader.onBody([](BufQueue body, bool /*eom*/) {
-    CHECK(!body.empty());
+    PRX_CHECK(!body.empty());
     auto bodyStr = body.move()->to<std::string>();
     EXPECT_EQ(bodyStr, "world");
     return HTTPSourceReader::Continue;
@@ -113,7 +114,7 @@ CO_TEST_F_X(TransformFilterTest, PassthruFilter) {
         return HTTPSourceReader::Continue;
       });
   reader.onBody([&kBodyStr](BufQueue body, bool /*eom*/) {
-    EXPECT_EQ((void*)CHECK_NOTNULL(body.front())->data(), kBodyStr.begin());
+    EXPECT_EQ((void*)PRX_CHECK_NOTNULL(body.front())->data(), kBodyStr.begin());
     return HTTPSourceReader::Continue;
   });
 
@@ -133,7 +134,7 @@ CO_TEST_F_X(TransformFilterTest, InvokeOnError) {
       };
   TransformFilter::BodyTransformFn bodyHook =
       [](folly::Try<HTTPBodyEvent>&& bodyEvent) -> folly::Try<HTTPBodyEvent> {
-    LOG(FATAL) << "unreachable";
+    PRX_LOG(FATAL) << "unreachable";
   };
 
   auto* transformSource = new TransformFilter(
@@ -170,7 +171,7 @@ CO_TEST_F_X(TransformFilterTest, TransformBodyToError) {
   HTTPSourceReader reader(transformSource);
 
   reader.onBody([](BufQueue body, bool /*eom*/) -> bool {
-    LOG(FATAL) << "shouldn't happen";
+    PRX_LOG(FATAL) << "shouldn't happen";
   });
 
   // read response
diff --git a/proxygen/lib/http/coro/filters/test/VisitorFilterTest.cpp b/proxygen/lib/http/coro/filters/test/VisitorFilterTest.cpp
index a91fed06a1..ae7e58ba54 100644
--- a/proxygen/lib/http/coro/filters/test/VisitorFilterTest.cpp
+++ b/proxygen/lib/http/coro/filters/test/VisitorFilterTest.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/coro/HTTPStreamSource.h>
 #include <proxygen/lib/http/coro/filters/VisitorFilter.h>
 #include <proxygen/lib/http/coro/util/test/TestHelpers.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 
@@ -43,7 +44,7 @@ CO_TEST_F_X(VisitorFilterTest, SimpleTest) {
   size_t numHeaderCallbacks{0}, numBodyCallbacks{0};
   VisitorFilter::HeaderHookFn headerHook =
       [&numHeaderCallbacks](const folly::Try<HTTPHeaderEvent>& headerEvent) {
-        CHECK(!headerEvent.hasException());
+        PRX_CHECK(!headerEvent.hasException());
         // validate message is the same
         numHeaderCallbacks++;
         const auto& headers = headerEvent->headers->getHeaders();
@@ -52,7 +53,7 @@ CO_TEST_F_X(VisitorFilterTest, SimpleTest) {
       };
   VisitorFilter::BodyHookFn bodyHook =
       [&numBodyCallbacks](const folly::Try<HTTPBodyEvent>& bodyEvent) {
-        CHECK(!bodyEvent.hasException());
+        PRX_CHECK(!bodyEvent.hasException());
         if (bodyEvent->eventType == HTTPBodyEvent::SUSPEND) {
           return;
         }
@@ -94,11 +95,11 @@ CO_TEST_F_X(VisitorFilterTest, VisitorInvokedOnError) {
   VisitorFilter::HeaderHookFn headerHook =
       [&expectHeaderHook](const folly::Try<HTTPHeaderEvent>& headerEvent) {
         expectHeaderHook = true;
-        CHECK(headerEvent.hasException());
+        PRX_CHECK(headerEvent.hasException());
       };
   VisitorFilter::BodyHookFn bodyHook =
       [](const folly::Try<HTTPBodyEvent>& /*bodyEvent*/) {
-        XLOG(FATAL) << "body hook called";
+        PRX_LOG(FATAL) << "body hook called";
       };
 
   // create visitor source
@@ -129,12 +130,12 @@ CO_TEST_F_X(VisitorFilterTest, PassThruObserver) {
   // sanity check headers and body
   HTTPSourceReader reader(visitorSource);
   reader.onHeaders([](std::unique_ptr<HTTPMessage> msg, bool final, bool eom) {
-    CHECK(final && !eom);
+    PRX_CHECK(final && !eom);
     EXPECT_EQ(msg->getStatusCode(), 200);
     return true;
   });
   reader.onBody([](BufQueue body, bool eom) {
-    CHECK(!body.empty() && eom);
+    PRX_CHECK(!body.empty() && eom);
     EXPECT_EQ(body.move()->to<std::string>(), "hello");
     return true;
   });
diff --git a/proxygen/lib/http/coro/server/CMakeLists.txt b/proxygen/lib/http/coro/server/CMakeLists.txt
index 1498eaba32..9578ba7ef7 100644
--- a/proxygen/lib/http/coro/server/CMakeLists.txt
+++ b/proxygen/lib/http/coro/server/CMakeLists.txt
@@ -12,9 +12,9 @@ proxygen_add_library(proxygen_http_coro_server_coro_acceptor
   DEPS
     proxygen_coro
     proxygen_http_session_http_session_codec_factory
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     mvfst::mvfst_common_events_folly_eventbase
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_error
     proxygen_http_codec_compress_header_codec
@@ -39,13 +39,13 @@ proxygen_add_library(proxygen_http_coro_server_coro_httpserver
     proxygen_http_coro_filters_ServerFilterFactory
     proxygen_http_coro_server_coro_acceptor
     proxygen_sampling
+    proxygen_utils_log_shim
     mvfst::mvfst_server
     mvfst::mvfst_server_quic_handshake_socket_holder
     wangle::wangle_acceptor
     Folly::folly_container_f14_hash
     Folly::folly_executors_io_thread_pool_executor
     Folly::folly_io_async_async_signal_handler
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_server_scope_coro_httpserver
diff --git a/proxygen/lib/http/coro/server/HTTPCoroAcceptor.cpp b/proxygen/lib/http/coro/server/HTTPCoroAcceptor.cpp
index 728fc0838b..bbfdc09d9e 100644
--- a/proxygen/lib/http/coro/server/HTTPCoroAcceptor.cpp
+++ b/proxygen/lib/http/coro/server/HTTPCoroAcceptor.cpp
@@ -8,7 +8,7 @@
 
 #include "proxygen/lib/http/coro/server/HTTPCoroAcceptor.h"
 #include "proxygen/lib/http/coro/HTTPCoroSession.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/http/session/HTTPDefaultSessionCodecFactory.h>
 #include <quic/api/QuicSocket.h>
@@ -100,14 +100,14 @@ HTTPCoroSession* HTTPCoroDownstreamSessionFactory::makeUniplexSession(
   auto codec = codecFactory_->getCodec(
       attemptNextProtocol, TransportDirection::DOWNSTREAM, isTLS);
   if (!codec) {
-    XLOG(DBG2) << "codecFactory_ failed to provide codec for proto="
-               << attemptNextProtocol;
+    PRX_VLOG(2) << "codecFactory_ failed to provide codec for proto="
+                << attemptNextProtocol;
     return nullptr;
   }
 
   applySettingsToCodec(*codec);
-  XLOG(DBG4) << "Created new " << attemptNextProtocol << " session for peer "
-             << *peerAddress;
+  PRX_VLOG(4) << "Created new " << attemptNextProtocol << " session for peer "
+              << *peerAddress;
   auto eventBase = transport->getEventBase();
   auto coroTransport =
       std::make_unique<folly::coro::Transport>(eventBase, std::move(transport));
@@ -129,8 +129,8 @@ HTTPCoroSession* HTTPCoroDownstreamSessionFactory::makeQuicSession(
                                           codecFactory_->useStrictValidation(),
                                           accConfig_->headerIndexingStrategy);
   applySettingsToCodec(*codec);
-  XLOG(DBG4) << "Created new " << *tinfo.appProtocol << " session for peer "
-             << quicSocket->getPeerAddress();
+  PRX_VLOG(4) << "Created new " << *tinfo.appProtocol << " session for peer "
+              << quicSocket->getPeerAddress();
   HTTPCoroSession* session =
       HTTPCoroSession::makeDownstreamCoroSession(std::move(quicSocket),
                                                  std::move(handler),
@@ -216,7 +216,7 @@ void HTTPCoroAcceptor::onNewConnection(
                                           std::move(tinfo),
                                           handler_,
                                           /*strictValidation=*/true);
-  XCHECK(session);
+  PRX_CHECK(session);
   onSessionReady(eventBase, session);
 }
 
diff --git a/proxygen/lib/http/coro/server/HTTPServer.cpp b/proxygen/lib/http/coro/server/HTTPServer.cpp
index ebc9dcee7e..08c4e5ff83 100644
--- a/proxygen/lib/http/coro/server/HTTPServer.cpp
+++ b/proxygen/lib/http/coro/server/HTTPServer.cpp
@@ -16,8 +16,8 @@
 
 #include <folly/fibers/BatchSemaphore.h>
 #include <folly/io/async/EventBaseManager.h>
-#include <folly/logging/xlog.h>
 #include <folly/system/HardwareConcurrency.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -76,7 +76,7 @@ class HTTPServerHandler : public proxygen::coro::HTTPFilterFactoryHandler {
   HTTPServerHandler(std::shared_ptr<HTTPHandler> userHandler,
                     HTTPServer::ServerFilterFactoryList filterFactories) {
     // user supplied handler must exist
-    CHECK(userHandler);
+    PRX_CHECK(userHandler);
     setNextHandler(std::move(userHandler));
     for (auto& factory : filterFactories) {
       addFilterFactory(std::move(factory));
@@ -89,7 +89,7 @@ class HTTPServerHandler : public proxygen::coro::HTTPFilterFactoryHandler {
 } // namespace
 
 HTTPServer::~HTTPServer() {
-  XCHECK(!eventBase_.isRunning());
+  PRX_CHECK(!eventBase_.isRunning());
 }
 
 void HTTPServer::start(
@@ -130,7 +130,7 @@ void HTTPServer::start(
       startTcp(evbs);
     }
   } catch (const std::exception& ex) {
-    XLOG(ERR) << "Initialization encountered an error=" << ex.what();
+    PRX_LOG(ERROR) << "Initialization encountered an error=" << ex.what();
     if (onError) {
       onError(std::current_exception());
     } else {
@@ -194,14 +194,14 @@ HTTPServer::getQuicAcceptor(folly::EventBase* evb) {
     return nullptr;
   }
   // For now, the quic implementation can still only support one acceptor.
-  XCHECK_EQ(it->second.size(), 1UL);
+  PRX_CHECK_EQ(it->second.size(), 1UL);
   return &it->second.front();
 }
 
 void HTTPServer::startTcp(const KeepAliveEventBaseVec& keepAliveEvbs) {
   std::vector<SocketAcceptorConfig> socketAcceptorConfigs;
   if (socketAcceptorConfigFactoryFn_) {
-    XLOG(DBG4) << "Using custom socket acceptor config factory";
+    PRX_VLOG(4) << "Using custom socket acceptor config factory";
     socketAcceptorConfigs = socketAcceptorConfigFactoryFn_(eventBase_, config_);
     for (auto& socketAcceptorConfig : socketAcceptorConfigs) {
       socketAcceptorConfig.socket->startAccepting();
@@ -223,7 +223,7 @@ void HTTPServer::startTcp(const KeepAliveEventBaseVec& keepAliveEvbs) {
       serverSocket->listen(config_.socketConfig.acceptBacklog);
       serverSocket->startAccepting();
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Failed to setup server socket ex=" << ex.what();
+      PRX_LOG(ERROR) << "Failed to setup server socket ex=" << ex.what();
       throw;
     }
     socketAcceptorConfigs.push_back({
@@ -241,8 +241,8 @@ void HTTPServer::startTcp(const KeepAliveEventBaseVec& keepAliveEvbs) {
 }
 
 void HTTPServer::run(std::function<void()> onSuccess) {
-  XLOG(DBG4) << __func__;
-  XCHECK_EQ(state_, State::UNINIT);
+  PRX_VLOG(4) << __func__;
+  PRX_CHECK_EQ(state_, State::UNINIT);
   state_ = State::RUNNING;
   for (auto sig : config_.shutdownOnSignals) {
     signalHandler_.registerSignalHandler(sig);
@@ -251,7 +251,7 @@ void HTTPServer::run(std::function<void()> onSuccess) {
     eventBase_.runInLoop([onSuccess = std::move(onSuccess)] { onSuccess(); });
   }
   eventBase_.loop();
-  XLOG(DBG4) << __func__ << " exit";
+  PRX_VLOG(4) << __func__ << " exit";
 }
 
 void HTTPServer::createQuicServer(const std::vector<folly::EventBase*>& evbs) {
@@ -272,7 +272,7 @@ void HTTPServer::createQuicServer(const std::vector<folly::EventBase*>& evbs) {
       fizzCtx = acceptor->recreateFizzContext();
     }
   }
-  CHECK(config_.quicConfig) << "QuicConfig must be set";
+  PRX_CHECK(config_.quicConfig) << "QuicConfig must be set";
   quicServer_ =
       quic::QuicServer::createQuicServer(config_.quicConfig->transportSettings);
   quicServer_->setBindV6Only(false);
@@ -338,12 +338,12 @@ void HTTPServer::onQuicTransportReady(
       getQuicAcceptor(quicSocket->getEventBase()
                           ->getTypedEventBase<quic::FollyQuicEventBase>()
                           ->getBackingEventBase());
-  XCHECK(acceptor) << "QuicSocket in foreign EventBase";
+  PRX_CHECK(acceptor) << "QuicSocket in foreign EventBase";
   acceptor->onNewConnection(std::move(quicSocket), std::move(tinfo));
 }
 
 void HTTPServer::drain() {
-  XLOG(DBG4) << __func__;
+  PRX_VLOG(4) << __func__;
   if (state_ == State::RUNNING) {
     state_ = State::DRAINING;
     eventBase_.runImmediatelyOrRunInEventBaseThread(
@@ -363,9 +363,9 @@ void HTTPServer::drain() {
 }
 
 void HTTPServer::globalDrainImpl() {
-  XLOG(DBG4) << __func__;
+  PRX_VLOG(4) << __func__;
   for (const auto& serverSocket : serverSockets_) {
-    XCHECK(serverSocket);
+    PRX_CHECK(serverSocket);
     serverSocket->stopAccepting();
   }
   if (quicServer_) {
@@ -374,28 +374,28 @@ void HTTPServer::globalDrainImpl() {
 }
 
 void HTTPServer::unregisterSignalHandlers() {
-  XLOG(DBG4) << __func__;
+  PRX_VLOG(4) << __func__;
   for (auto sig : config_.shutdownOnSignals) {
     signalHandler_.unregisterSignalHandler(sig);
   }
 }
 
 void HTTPServer::drainImpl(HTTPCoroAcceptor& acceptor) {
-  XLOG(DBG4) << __func__;
+  PRX_VLOG(4) << __func__;
   if (quicServer_) {
     acceptor.stopAcceptingQuic();
   }
 }
 
 void HTTPServer::forceStop() {
-  XLOG(DBG4) << __func__;
+  PRX_VLOG(4) << __func__;
   auto state = state_.load();
   if (state == State::RUNNING) {
     state_ = state = State::DRAINING;
     folly::ExecutorKeepAlive keepAlive(&eventBase_);
     eventBase_.runImmediatelyOrRunInEventBaseThread([this] {
       for (const auto& serverSocket : serverSockets_) {
-        XCHECK(serverSocket);
+        PRX_CHECK(serverSocket);
         serverSocket->stopAccepting();
       }
     });
diff --git a/proxygen/lib/http/coro/server/HTTPServer.h b/proxygen/lib/http/coro/server/HTTPServer.h
index ef8802c79b..b9ddb73251 100644
--- a/proxygen/lib/http/coro/server/HTTPServer.h
+++ b/proxygen/lib/http/coro/server/HTTPServer.h
@@ -13,9 +13,9 @@
 #include <folly/container/F14Map.h>
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include <folly/io/async/AsyncSignalHandler.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
 #include <proxygen/lib/sampling/Sampling.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/server/QuicHandshakeSocketHolder.h>
 #include <quic/server/QuicServer.h>
 #include <signal.h>
@@ -155,7 +155,7 @@ class HTTPServer : public quic::QuicHandshakeSocketHolder::Callback {
    */
   std::optional<folly::SocketAddress> address() const {
     if (!serverSockets_.empty()) {
-      XCHECK_EQ(serverSockets_.size(), 1UL)
+      PRX_CHECK_EQ(serverSockets_.size(), 1UL)
           << "Attempt to use address() on an implementation that supports "
              "multiple addresses";
       folly::SocketAddress address;
@@ -226,7 +226,7 @@ class HTTPServer : public quic::QuicHandshakeSocketHolder::Callback {
   };
 
   void addObserver(Observer* observer) {
-    CHECK_NOTNULL(observer);
+    PRX_CHECK_NOTNULL(observer);
     observers_.insert(observer);
   }
 
@@ -257,7 +257,7 @@ class HTTPServer : public quic::QuicHandshakeSocketHolder::Callback {
       std::shared_ptr<quic::QuicSocket> quicSocket) override;
   void onConnectionSetupError(std::shared_ptr<quic::QuicSocket>,
                               quic::QuicError error) override {
-    XLOG(ERR) << "Failed to accept QUIC connection: " << error.message;
+    PRX_LOG(ERROR) << "Failed to accept QUIC connection: " << error.message;
   }
   void run(std::function<void()> onSuccess);
   void globalDrainImpl();
@@ -335,7 +335,7 @@ class HTTPServer : public quic::QuicHandshakeSocketHolder::Callback {
     }
 
     void signalReceived(int signum) noexcept override {
-      XLOG(DBG2) << "Received signal " << signum << ", initiating drain";
+      PRX_VLOG(2) << "Received signal " << signum << ", initiating drain";
       server_.drain();
     }
 
diff --git a/proxygen/lib/http/coro/server/handlers/CMakeLists.txt b/proxygen/lib/http/coro/server/handlers/CMakeLists.txt
index fac676d568..595af936ff 100644
--- a/proxygen/lib/http/coro/server/handlers/CMakeLists.txt
+++ b/proxygen/lib/http/coro/server/handlers/CMakeLists.txt
@@ -11,7 +11,7 @@ proxygen_add_library(proxygen_http_coro_server_handlers_expect_continue_wrapper_
     ExpectContinueWrapperHandler.cpp
   DEPS
     proxygen_http_http_headers
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_coro
     proxygen_coro_source
diff --git a/proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.cpp b/proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.cpp
index 16ba7146d2..549098a50a 100644
--- a/proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.cpp
+++ b/proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
 #include <proxygen/lib/http/HTTPCommonHeaders.h>
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <string_view>
 
 namespace proxygen::coro {
@@ -24,7 +24,7 @@ constexpr uint16_t kExpectationFailedStatusCode = 417;
 folly::coro::Task<HTTPHeaderEvent>
 ExpectContinueWrapperResponse::readHeaderEvent() {
   if (!response100Written_) {
-    XLOG(DBG8)
+    PRX_VLOG(8)
         << "ExpectContinueWrapper sending 100-continue to fulfill expectation";
     response100Written_ = true;
     auto msg = std::make_unique<HTTPMessage>();
@@ -59,7 +59,7 @@ void ExpectContinueWrapperResponse::stopReading(
 folly::coro::Task<void>
 ExpectContinueWrapperResponse::ensureNextHandlerInvoked() {
   if (!bool(wrappedResponseHolder_)) {
-    XLOG(DBG8) << "ExpectContinueWrapper invoking wrapped handler";
+    PRX_VLOG(8) << "ExpectContinueWrapper invoking wrapped handler";
     wrappedResponseHolder_ = co_await nextHandler_->handleRequest(
         evb_, ctx_, std::move(requestForNextHandler_));
   }
@@ -70,7 +70,7 @@ folly::coro::Task<HTTPSourceHolder> ExpectContinueWrapperHandler::handleRequest(
     HTTPSessionContextPtr ctx,
     HTTPSourceHolder requestSource) {
   auto headerEvent = co_await requestSource.readHeaderEvent();
-  XCHECK(headerEvent.headers);
+  PRX_CHECK(headerEvent.headers);
   auto headers = headerEvent.headers->getHeaders();
   if (headers.exists(HTTP_HEADER_EXPECT)) {
     auto& expectVal = headers.getSingleOrEmpty(HTTP_HEADER_EXPECT);
@@ -79,7 +79,7 @@ folly::coro::Task<HTTPSourceHolder> ExpectContinueWrapperHandler::handleRequest(
       // Request has an expectation with the value 100-continue
       // We need to wrap the next handler in an ExpectContinueWrapperResponse
       // to inject the 100 Continue response
-      XLOG(DBG8) << "ExpectContinueWrapper found 100-continue expectation";
+      PRX_VLOG(8) << "ExpectContinueWrapper found 100-continue expectation";
       headerEvent.headers->getHeaders().remove(HTTP_HEADER_EXPECT);
       auto expectWrapperResponse =
           new ExpectContinueWrapperResponse(evb,
@@ -91,7 +91,7 @@ folly::coro::Task<HTTPSourceHolder> ExpectContinueWrapperHandler::handleRequest(
       co_return expectWrapperResponse;
     } else {
       // Invalid expectation. Send a response failing this request.
-      XLOG(DBG8)
+      PRX_VLOG(8)
           << "ExpectContinueWrapper returning 417 for invalid expectation: "
           << expectVal;
       co_return HTTPFixedSource::makeFixedResponse(
diff --git a/proxygen/lib/http/coro/server/samples/echo/EchoServer.cpp b/proxygen/lib/http/coro/server/samples/echo/EchoServer.cpp
index 55043225dc..1f8c80ea39 100644
--- a/proxygen/lib/http/coro/server/samples/echo/EchoServer.cpp
+++ b/proxygen/lib/http/coro/server/samples/echo/EchoServer.cpp
@@ -8,7 +8,7 @@
 
 #include "proxygen/lib/http/coro/HTTPFixedSource.h"
 #include "proxygen/lib/http/coro/server/HTTPServer.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 // TODO: move handler to it's own file?
 #include "proxygen/lib/http/coro/HTTPCoroSession.h"
 #include <quic/QuicConstants.h>
@@ -51,7 +51,7 @@ class EchoResponse : public HTTPSource {
     auto path = headerEvent->headers->getPathAsStringPiece();
     if (path == "/push") {
       if (headerEvent->eom) {
-        XLOG(ERR) << "Can only push in reply to POST";
+        PRX_LOG(ERROR) << "Can only push in reply to POST";
       }
       pendingPush_ = true;
     }
@@ -107,10 +107,10 @@ class EchoHandler
     co_return new EchoResponse(std::move(requestSource));
   }
   void onThreadStart(folly::EventBase* /*evb*/) override {
-    XLOG(DBG2) << "Thread started";
+    PRX_VLOG(2) << "Thread started";
   }
   void onThreadStop(folly::EventBase* /*evb*/) override {
-    XLOG(DBG2) << "Thread stopped";
+    PRX_VLOG(2) << "Thread stopped";
   }
 };
 
@@ -130,7 +130,7 @@ int main(int argc, char** argv) {
     try {
       tlsConfig.setCertificate(FLAGS_cert, FLAGS_key, "");
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+      PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
     }
     httpServerConfig.socketConfig.sslContextConfigs.emplace_back(
         std::move(tlsConfig));
@@ -142,7 +142,7 @@ int main(int argc, char** argv) {
           FLAGS_quic_batch_size;
     }
   } else if (FLAGS_quic) {
-    XLOG(ERR) << "QUIC requires a cert and key";
+    PRX_LOG(ERROR) << "QUIC requires a cert and key";
     return 1;
   }
   auto handler = std::make_shared<EchoHandler>();
diff --git a/proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h b/proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h
index eac829af46..c80133e81e 100644
--- a/proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h
+++ b/proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h
@@ -10,6 +10,7 @@
 
 #include "proxygen/lib/http/coro/HTTPCoroSession.h"
 #include <proxygen/lib/utils/ConditionalGate.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -33,7 +34,7 @@ class ConnectSource : public HTTPSource {
     do {
       auto bodyEvent = co_await co_awaitTry(reqSource_.readBodyEvent(65535));
       if (bodyEvent.hasException()) {
-        XLOG(ERR) << "read exception:" << bodyEvent.exception().what();
+        PRX_LOG(ERROR) << "read exception:" << bodyEvent.exception().what();
         // This will break the server read loop
         transport_->closeWithReset();
         co_return;
@@ -42,19 +43,19 @@ class ConnectSource : public HTTPSource {
           !bodyEvent->event.body.empty()) {
         folly::IOBufQueue writeBuf{folly::IOBufQueue::cacheChainLength()};
         writeBuf.append(bodyEvent->event.body.move());
-        XLOG(DBG2) << "Got " << writeBuf.chainLength() << " client bytes";
+        PRX_VLOG(2) << "Got " << writeBuf.chainLength() << " client bytes";
         try {
           co_await transport_->write(writeBuf,
                                      std::chrono::milliseconds(writeTimeout_));
         } catch (const std::exception& ex) {
-          XLOG(ERR) << "Upstream write error: " << ex.what();
+          PRX_LOG(ERROR) << "Upstream write error: " << ex.what();
           transport_->closeWithReset();
           co_return;
         }
       } // else ignore any other events
       eom = bodyEvent->eom;
     } while (!eom);
-    XLOG(DBG2) << "Client read finished";
+    PRX_VLOG(2) << "Client read finished";
     transport_->shutdownWrite();
   }
 
@@ -78,11 +79,11 @@ class ConnectSource : public HTTPSource {
         transport_->read(readBuf, 1500, 4096, readTimeout_)));
     inRead_ = false;
     if (nread.hasException()) {
-      XLOG(ERR) << "read error: " << nread.exception().what();
+      PRX_LOG(ERROR) << "read error: " << nread.exception().what();
       gate_.set(Event::WriteResponseComplete);
       co_yield folly::coro::co_error(std::move(nread.exception()));
     }
-    XLOG(DBG2) << "Got " << *nread << " server bytes";
+    PRX_VLOG(2) << "Got " << *nread << " server bytes";
     if (*nread == 0) {
       gate_.set(Event::WriteResponseComplete);
     }
diff --git a/proxygen/lib/http/coro/server/samples/fwdproxy/FwdProxyServer.cpp b/proxygen/lib/http/coro/server/samples/fwdproxy/FwdProxyServer.cpp
index 31f52e37a1..4f92306ae5 100644
--- a/proxygen/lib/http/coro/server/samples/fwdproxy/FwdProxyServer.cpp
+++ b/proxygen/lib/http/coro/server/samples/fwdproxy/FwdProxyServer.cpp
@@ -15,9 +15,9 @@
 #include "proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h"
 #include <folly/init/Init.h>
 #include <folly/io/async/EventBaseLocal.h>
-#include <folly/logging/xlog.h>
 #include <folly/portability/GFlags.h>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 DEFINE_int32(port, 8082, "What port to listen on");
 DEFINE_string(cert, "", "Certificate file");
@@ -44,14 +44,14 @@ class FwdProxyHandler : public proxygen::coro::HTTPHandler {
     auto& request = headerEvent->headers;
     auto parseURL = ParseURL::parseURL(request->getURL());
     if (!parseURL.has_value() || !parseURL->hasHost()) {
-      XLOG(ERR) << "Invalid url=" << request->getURL();
+      PRX_LOG(ERROR) << "Invalid url=" << request->getURL();
       co_return HTTPFixedSource::makeFixedResponse(400);
     }
 
     // Handle connect separately
     if (request->getMethod() == HTTPMethod::CONNECT) {
       if (parseURL->port() == 0) {
-        XLOG(ERR) << "Invalid url=" << request->getURL();
+        PRX_LOG(ERROR) << "Invalid url=" << request->getURL();
         co_return HTTPFixedSource::makeFixedResponse(400);
       }
       co_return co_await handleConnect(evb,
@@ -62,17 +62,17 @@ class FwdProxyHandler : public proxygen::coro::HTTPHandler {
     }
 
     if (parseURL->scheme().empty()) {
-      XLOG(ERR) << "Invalid url=" << request->getURL();
+      PRX_LOG(ERROR) << "Invalid url=" << request->getURL();
       co_return HTTPFixedSource::makeFixedResponse(400);
     }
 
-    XLOG(DBG4) << "Sending request upstream";
+    PRX_VLOG(4) << "Sending request upstream";
     // any exceptions are propagated
     auto& connCache = connCache_.try_emplace(*evb, *evb);
     auto res = co_await co_awaitTry(connCache.getSessionWithReservation(
         request->getURL(), std::chrono::milliseconds(FLAGS_timeout)));
     if (res.hasException()) {
-      XLOG(ERR) << "Failed to connect err=" << res.exception().what();
+      PRX_LOG(ERROR) << "Failed to connect err=" << res.exception().what();
       co_return HTTPFixedSource::makeFixedResponse(503);
     }
     URL reqURL(std::move(*parseURL));
@@ -95,7 +95,7 @@ class FwdProxyHandler : public proxygen::coro::HTTPHandler {
     auto serverAddresses = co_await co_awaitTry(CoroDNSResolver::resolveHost(
         evb, host, std::chrono::milliseconds(FLAGS_timeout)));
     if (serverAddresses.hasException()) {
-      XLOG(ERR) << "DNS error: " << serverAddresses.exception().what();
+      PRX_LOG(ERROR) << "DNS error: " << serverAddresses.exception().what();
       co_return HTTPFixedSource::makeFixedResponse(503);
     }
     serverAddresses->primary.setPort(port);
@@ -105,7 +105,7 @@ class FwdProxyHandler : public proxygen::coro::HTTPHandler {
             serverAddresses->primary,
             std::chrono::milliseconds(FLAGS_timeout)));
     if (transport.hasException()) {
-      XLOG(ERR) << "Connect error: " << transport.exception().what();
+      PRX_LOG(ERROR) << "Connect error: " << transport.exception().what();
       co_return HTTPFixedSource::makeFixedResponse(503);
     }
     auto connectSource = new ConnectSource(
@@ -137,7 +137,7 @@ int main(int argc, char** argv) {
     try {
       tlsConfig.setCertificate(FLAGS_cert, FLAGS_key, "");
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+      PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
     }
     httpServerConfig.socketConfig.sslContextConfigs.emplace_back(
         std::move(tlsConfig));
@@ -145,7 +145,7 @@ int main(int argc, char** argv) {
       httpServerConfig.quicConfig = HTTPServer::QuicConfig();
     }
   } else if (FLAGS_quic) {
-    XLOG(ERR) << "QUIC requires a cert and key";
+    PRX_LOG(ERROR) << "QUIC requires a cert and key";
     return 1;
   }
   HTTPServer server(std::move(httpServerConfig),
diff --git a/proxygen/lib/http/coro/server/samples/proxy/ProxyServer.cpp b/proxygen/lib/http/coro/server/samples/proxy/ProxyServer.cpp
index fe41307662..8f6e7f6ae3 100644
--- a/proxygen/lib/http/coro/server/samples/proxy/ProxyServer.cpp
+++ b/proxygen/lib/http/coro/server/samples/proxy/ProxyServer.cpp
@@ -12,9 +12,9 @@
 #include "proxygen/lib/http/coro/client/HTTPCoroSessionPool.h"
 #include "proxygen/lib/http/coro/server/HTTPServer.h"
 #include <folly/init/Init.h>
-#include <folly/logging/xlog.h>
 #include <folly/portability/GFlags.h>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 DEFINE_int32(port, 8082, "What port to listen on");
 DEFINE_string(cert, "", "Certificate file");
@@ -63,14 +63,14 @@ class ProxyHandler : public proxygen::coro::HTTPHandler {
     }
 
     auto& pool = getPool(evb);
-    XLOG(DBG4) << "Sending request upstream";
+    PRX_VLOG(4) << "Sending request upstream";
     if (FLAGS_fbssl && !FLAGS_backend_tls) {
       headerEvent->headers->getHeaders().add("FBSSL", "ON");
     }
     // any exceptions are propagated
     auto res = co_await co_awaitTry(pool.getSessionWithReservation());
     if (res.hasException()) {
-      XLOG(ERR)
+      PRX_LOG(ERROR)
           << "Failed to connect err="
           << uint64_t(
                  res.tryGetExceptionObject<HTTPCoroSessionPool::Exception>()
@@ -99,7 +99,7 @@ int main(int argc, char** argv) {
     try {
       tlsConfig.setCertificate(FLAGS_cert, FLAGS_key, "");
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+      PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
     }
     httpServerConfig.socketConfig.sslContextConfigs.emplace_back(
         std::move(tlsConfig));
@@ -107,7 +107,7 @@ int main(int argc, char** argv) {
       httpServerConfig.quicConfig = HTTPServer::QuicConfig();
     }
   } else if (FLAGS_quic) {
-    XLOG(ERR) << "QUIC requires a cert and key";
+    PRX_LOG(ERROR) << "QUIC requires a cert and key";
     return 1;
   }
   HTTPServer server(std::move(httpServerConfig),
diff --git a/proxygen/lib/http/coro/server/test/HTTPServerTest.cpp b/proxygen/lib/http/coro/server/test/HTTPServerTest.cpp
index 717a922b0e..1ba499b48d 100644
--- a/proxygen/lib/http/coro/server/test/HTTPServerTest.cpp
+++ b/proxygen/lib/http/coro/server/test/HTTPServerTest.cpp
@@ -19,6 +19,7 @@
 #include <proxygen/lib/http/coro/server/HTTPServer.h>
 #include <proxygen/lib/http/coro/server/ScopedHTTPServer.h>
 #include <proxygen/lib/http/coro/test/HTTPTestSources.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <chrono>
 #include <folly/coro/GtestHelpers.h>
@@ -174,7 +175,7 @@ class HTTPServerTests : public TestWithParam<TransportType> {
       }
     }
 
-    CHECK(handler_);
+    PRX_CHECK(handler_);
     server_ = ScopedHTTPServer::start(
         std::move(serverConfig_), handler_, mockObserver);
   }
@@ -195,7 +196,7 @@ class HTTPServerTests : public TestWithParam<TransportType> {
                                kTestDir + "certs/test_key1.pem",
                                "");
     } catch (const std::exception& ex) {
-      XLOG(ERR) << "Invalid certificate file or key file: %s" << ex.what();
+      PRX_LOG(ERROR) << "Invalid certificate file or key file: %s" << ex.what();
     }
     return tlsConfig;
   }
@@ -254,7 +255,7 @@ TEST_P(HTTPServerTests, TestExistingSocket) {
   initClient();
 
   auto address = server_->address();
-  CHECK(address.has_value());
+  PRX_CHECK(address.has_value());
   auto url = fmt::format("https://{}/test", address->describe());
   EventBase evb;
   auto response = blockingWait(
@@ -473,7 +474,7 @@ TEST_P(HTTPServerTests, TestUpdateTLSCredentials) {
       TlsConnectCb cb{*sock};
       sock->connect(&cb, server_->address().value(), 100);
       co_await cb.baton;
-      CHECK(!cb.ex && cb.peerCert);
+      PRX_CHECK(!cb.ex && cb.peerCert);
       co_return getCertDigest(cb.peerCert.get());
     });
   };
@@ -559,12 +560,12 @@ TEST_P(HTTPStatsFilterTests, TestSimplePostStatsFilter) {
       HTTPClient::post(
           &evb, url, std::move(body), std::chrono::milliseconds(500), useQuic),
       &evb);
-  CHECK(response.headers.get());
+  PRX_CHECK(response.headers.get());
   auto statusCode = response.headers->getStatusCode();
   EXPECT_EQ(statusCode, 200);
 
   // stats is thread local and needs to run in server evb
-  CHECK_NOTNULL(serverEvb_)
+  PRX_CHECK_NOTNULL(serverEvb_)
       ->runImmediatelyOrRunInEventBaseThreadAndWait(
           [this, bodyLen, statusCode]() {
             auto& fakeStats = statsFilterFactory_->stats_;
@@ -606,7 +607,7 @@ TEST_P(HTTPStatsFilterTests, TestServerErrorHandler) {
   EXPECT_TRUE(response.hasException());
 
   // stats is thread local and needs to run in server evb
-  CHECK_NOTNULL(serverEvb_)
+  PRX_CHECK_NOTNULL(serverEvb_)
       ->runImmediatelyOrRunInEventBaseThreadAndWait([this, bodyLen]() {
         auto& fakeStats = statsFilterFactory_->stats_;
         EXPECT_EQ(fakeStats.reqs, 1);
@@ -635,7 +636,7 @@ class MultiAcceptorHttpServerTest : public HTTPServerTests {
  protected:
   void startServer(std::vector<folly::SocketAddress>&& addresses,
                    MockServerObserver* mockObserver = nullptr) {
-    CHECK(handler_);
+    PRX_CHECK(handler_);
     HTTPServer::SocketAcceptorConfigFactoryFn socketAcceptorConfigFactoryFn =
         [this, addresses](folly::EventBase& evb,
                           [[maybe_unused]] const HTTPServer::Config& config) {
@@ -680,7 +681,7 @@ TEST_F(MultiAcceptorHttpServerTest, TestMultiplePorts) {
     auto response = blockingWait(
         HTTPClient::get(&evb, url, std::chrono::milliseconds(500), false),
         &evb);
-    CHECK(response.headers.get());
+    PRX_CHECK(response.headers.get());
     EXPECT_EQ(response.headers->getStatusCode(), 200);
   }
 
@@ -786,27 +787,27 @@ namespace {
 // Creates a pair of connected TCP sockets (server-side, client-side).
 std::pair<folly::NetworkSocket, folly::NetworkSocket> createTcpSocketPair() {
   int listenFd = ::socket(AF_INET, SOCK_STREAM, 0);
-  CHECK_GE(listenFd, 0);
+  PRX_CHECK_GE(listenFd, 0);
 
   struct sockaddr_in addr{};
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   addr.sin_port = 0;
-  CHECK_EQ(::bind(listenFd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)),
-           0);
-  CHECK_EQ(::listen(listenFd, 1), 0);
+  PRX_CHECK_EQ(
+      ::bind(listenFd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)), 0);
+  PRX_CHECK_EQ(::listen(listenFd, 1), 0);
 
   socklen_t addrLen = sizeof(addr);
-  CHECK_EQ(
+  PRX_CHECK_EQ(
       ::getsockname(listenFd, reinterpret_cast<sockaddr*>(&addr), &addrLen), 0);
 
   int clientFd = ::socket(AF_INET, SOCK_STREAM, 0);
-  CHECK_GE(clientFd, 0);
-  CHECK_EQ(
+  PRX_CHECK_GE(clientFd, 0);
+  PRX_CHECK_EQ(
       ::connect(clientFd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)), 0);
 
   int serverFd = ::accept(listenFd, nullptr, nullptr);
-  CHECK_GE(serverFd, 0);
+  PRX_CHECK_GE(serverFd, 0);
   ::close(listenFd);
 
   return {folly::NetworkSocket::fromFd(serverFd),
diff --git a/proxygen/lib/http/coro/test/HTTPCoroSessionTests.cpp b/proxygen/lib/http/coro/test/HTTPCoroSessionTests.cpp
index fc454aa3b4..a46a6e3089 100644
--- a/proxygen/lib/http/coro/test/HTTPCoroSessionTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPCoroSessionTests.cpp
@@ -9,6 +9,7 @@
 #include "proxygen/lib/http/coro/test/HTTPCoroSessionTests.h"
 
 #include <proxygen/lib/http/codec/HTTPCodecFactory.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 using namespace proxygen;
@@ -29,8 +30,7 @@ std::string paramsToTestName(const testing::TestParamInfo<TestParams> &info) {
     case CodecProtocol::HQ:
       return "h3";
     default:
-      XLOG(FATAL);
-      return "";
+      PRX_LOG(FATAL);
   }
 }
 
diff --git a/proxygen/lib/http/coro/test/HTTPCoroSessionTests.h b/proxygen/lib/http/coro/test/HTTPCoroSessionTests.h
index dc42512b7f..8758af1227 100644
--- a/proxygen/lib/http/coro/test/HTTPCoroSessionTests.h
+++ b/proxygen/lib/http/coro/test/HTTPCoroSessionTests.h
@@ -14,11 +14,11 @@
 #include "proxygen/lib/http/coro/util/TimedBaton.h"
 
 #include "proxygen/lib/http/session/test/MockHTTPSessionStats.h"
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/CodecProtocol.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
 #include <proxygen/lib/http/session/test/MockQuicSocketDriver.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -81,23 +81,23 @@ class TestCoroMultiplexTransport : public TestHTTPTransport {
       , public quic::QuicSocket::ConnectionCallback {
    public:
     void onNewBidirectionalStream(quic::StreamId /*id*/) noexcept override {
-      XLOG(FATAL) << __func__ << " on dummy conn cb";
+      PRX_LOG(FATAL) << __func__ << " on dummy conn cb";
     }
     void onNewUnidirectionalStream(quic::StreamId /*id*/) noexcept override {
-      XLOG(FATAL) << __func__ << " on dummy conn cb";
+      PRX_LOG(FATAL) << __func__ << " on dummy conn cb";
     }
     void onStopSending(quic::StreamId /*id*/,
                        quic::ApplicationErrorCode /*error*/) noexcept override {
-      XLOG(FATAL) << __func__ << " on dummy conn cb";
+      PRX_LOG(FATAL) << __func__ << " on dummy conn cb";
     }
     void onConnectionEnd() noexcept override {
-      XLOG(FATAL) << __func__ << " on dummy conn cb";
+      PRX_LOG(FATAL) << __func__ << " on dummy conn cb";
     }
     void onConnectionSetupError(quic::QuicError code) noexcept override {
       onConnectionError(std::move(code));
     }
     void onConnectionError(quic::QuicError /*code*/) noexcept override {
-      XLOG(FATAL) << __func__ << " on dummy conn cb";
+      PRX_LOG(FATAL) << __func__ << " on dummy conn cb";
     }
   };
 
@@ -254,7 +254,7 @@ class HTTPCoroSessionTest : public testing::TestWithParam<TestParams> {
                 bool(expectedError_) || bool(notExpectedError_));
       if (!expectedError_ && !notExpectedError_) {
         for (auto &stream : muxTransport_->socketDriver_.streams_) {
-          XLOG(DBG2) << "Verifying stream=" << stream.first;
+          PRX_VLOG(2) << "Verifying stream=" << stream.first;
           EXPECT_TRUE(stream.second.unsentBuf.empty());
           EXPECT_TRUE(stream.second.pendingWriteBuf.empty());
         }
@@ -303,7 +303,7 @@ class HTTPCoroSessionTest : public testing::TestWithParam<TestParams> {
   }
 
   void parseOutputUniplex() {
-    XCHECK(!isHQ());
+    PRX_CHECK(!isHQ());
     folly::IOBufQueue parseOutputStream{folly::IOBufQueue::cacheChainLength()};
     for (auto &event : transportState_.writeEvents) {
       parseOutputStream.append(event.move());
diff --git a/proxygen/lib/http/coro/test/HTTPDownstreamCoroSessionTests.cpp b/proxygen/lib/http/coro/test/HTTPDownstreamCoroSessionTests.cpp
index 32ee4f4ec1..f1e68d01db 100644
--- a/proxygen/lib/http/coro/test/HTTPDownstreamCoroSessionTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPDownstreamCoroSessionTests.cpp
@@ -18,7 +18,7 @@
 
 #include "folly/coro/GmockHelpers.h"
 #include <folly/coro/Sleep.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 
 using namespace proxygen;
@@ -64,7 +64,7 @@ class HTTPDownstreamSessionTest : public HTTPCoroSessionTest {
                               HTTPSessionContextPtr ctx,
                               HTTPSourceHolder source)
                 -> folly::coro::Task<HTTPSourceHolder> {
-              CHECK_EQ(ctx->getEventBase(), evb);
+              PRX_CHECK_EQ(ctx->getEventBase(), evb);
               return (*sharedHandlerFn)(evb, ctx, std::move(source));
             }))
         .RetiresOnSaturation();
@@ -95,7 +95,7 @@ class HTTPDownstreamSessionTest : public HTTPCoroSessionTest {
         !stream.second.writeBuf.empty()) {
       folly::io::Cursor cursor(stream.second.writeBuf.front());
       auto preface = quic::follyutils::decodeQuicInteger(cursor);
-      XCHECK(preface);
+      PRX_CHECK(preface);
       size_t toTrim = preface->second;
       auto g = folly::makeGuard(
           [&toTrim, &stream] { stream.second.writeBuf.trimStart(toTrim); });
@@ -112,18 +112,18 @@ class HTTPDownstreamSessionTest : public HTTPCoroSessionTest {
         case hq::UnidirectionalStreamType::PUSH: {
           auto pushID = quic::follyutils::decodeQuicInteger(cursor);
           multiCodec_->addCodec(stream.first);
-          XCHECK(pushID);
+          PRX_CHECK(pushID);
           pushMap_.emplace(pushID->first, stream.first);
           toTrim += pushID->second;
           // Parse the rest of the push later
           return;
         }
         default:
-          XLOG(FATAL) << "Bad uni stream type";
+          PRX_LOG(FATAL) << "Bad uni stream type";
       }
     }
     if (!stream.second.writeBuf.empty()) {
-      XLOG(DBG4) << "Decoding stream id=" << stream.first;
+      PRX_VLOG(4) << "Decoding stream id=" << stream.first;
       if (controlCodec) {
         if (!stream.second.writeBuf.empty()) {
           controlCodec->onUnidirectionalIngress(stream.second.writeBuf.move());
@@ -680,8 +680,8 @@ TEST_P(HTTPDownstreamSessionTest, ByteEventsCancelOnWriteError) {
       .Times(2)
       .WillRepeatedly(
           Invoke([](const HTTPByteEvent &event, const HTTPError &err) {
-            XLOG(DBG4) << "onByteEventCanceled t=" << uint8_t(event.type)
-                       << " off=" << event.transportOffset;
+            PRX_VLOG(4) << "onByteEventCanceled t=" << uint8_t(event.type)
+                        << " off=" << event.transportOffset;
             EXPECT_EQ(event.type, HTTPByteEvent::Type::KERNEL_WRITE);
             EXPECT_EQ(err.code, HTTPErrorCode::TRANSPORT_WRITE_ERROR);
           }));
@@ -880,7 +880,7 @@ TEST_P(H1DownstreamSessionTest, ReadDataAfterCancel) {
   expectResponse(id, 200);
   parseOutput();
   // expect graceful shutdown (i.e. eof & not rst)
-  XCHECK(!transportState_.closedWithReset && transportState_.writesClosed);
+  PRX_CHECK(!transportState_.closedWithReset && transportState_.writesClosed);
 }
 
 TEST_P(H2DownstreamSessionTest, ByteEventsCancelOnProtocolError) {
@@ -1618,7 +1618,7 @@ CO_TEST_P(H2DownstreamSessionTest, ResetRateLimit) {
       &evb_,
       [](HTTPSourceHolder reqSource) -> folly::coro::Task<void> {
         auto bodyEvent = co_await co_awaitTry(reqSource.readBodyEvent());
-        CHECK(bodyEvent.hasException());
+        PRX_CHECK(bodyEvent.hasException());
         auto *ex = bodyEvent.tryGetExceptionObject<HTTPError>();
         EXPECT_TRUE(ex && ex->code == HTTPErrorCode::CANCEL);
       }(std::move(keepaliveReqSource)))
@@ -1692,7 +1692,7 @@ TEST_P(HTTPDownstreamSessionTest, InvalidPeerCertificate) {
                                     HTTPSourceHolder requestSource)
                                  -> folly::coro::Task<HTTPSourceHolder> {
         co_await expectRequest(requestSource, HTTPMethod::GET, "/");
-        CHECK(ctx);
+        PRX_CHECK(ctx);
         auto peerIdentity = ctx->getPeerCertificate()->getIdentity();
         co_return peerIdentity == "good_actor"
             ? HTTPFixedSource::makeFixedResponse(200, "ok!")
@@ -2100,13 +2100,13 @@ TEST_P(H2QDownstreamSessionTest, ResetStreamAwaitingHeaders) {
     }
 
     folly::coro::Task<HTTPBodyEvent> readBodyEvent(uint32_t) override {
-      XCHECK(false);
+      PRX_CHECK(false);
     }
 
     void stopReading(
         folly::Optional<const proxygen::coro::HTTPErrorCode>) noexcept
         override {
-      XCHECK(false);
+      PRX_CHECK(false);
     }
   };
 
@@ -2316,7 +2316,7 @@ TEST_P(H2QDownstreamSessionTest, StateMachineError) {
                                  -> folly::coro::Task<HTTPSourceHolder> {
         auto err = co_await expectHeaderError(
             requestSource, HTTPErrorCode::INVALID_STATE_TRANSITION);
-        XCHECK(err.httpMessage);
+        PRX_CHECK(err.httpMessage);
         EXPECT_EQ(
             err.httpMessage->getHeaders().getSingleOrEmpty("cache-control"),
             "max-age=0");
@@ -2523,7 +2523,8 @@ TEST_P(H2QDownstreamSessionTest, EgressPushStreamLimitExceeded) {
                                  -> folly::coro::Task<HTTPSourceHolder> {
         co_await expectRequest(requestSource, HTTPMethod::GET, "/");
         co_return makeResponseWithPush([]() -> OnEOMSource::CallbackReturn {
-          XLOG(FATAL) << "EOM is never read, because session calls stopSending";
+          PRX_LOG(FATAL)
+              << "EOM is never read, because session calls stopSending";
           co_return folly::none;
         });
       });
@@ -2552,7 +2553,8 @@ TEST_P(H2DownstreamSessionTest, EgressPushNotSupported) {
                                  -> folly::coro::Task<HTTPSourceHolder> {
         co_await expectRequest(requestSource, HTTPMethod::GET, "/");
         co_return makeResponseWithPush([]() -> OnEOMSource::CallbackReturn {
-          XLOG(FATAL) << "EOM is never read, because session calls stopSending";
+          PRX_LOG(FATAL)
+              << "EOM is never read, because session calls stopSending";
           co_return folly::none;
         });
       });
@@ -3467,7 +3469,7 @@ CO_TEST_P_X(HTTPDownstreamSessionTest, IngressErrorCustomResponse) {
                                  -> folly::coro::Task<HTTPSourceHolder> {
         auto headers = co_await co_awaitTry(
             expectRequest(requestSource, HTTPMethod::POST, "/", false));
-        CHECK(headers.hasValue());
+        PRX_CHECK(headers.hasValue());
 
         auto res = co_await co_awaitTry(readBodyEventNoSuspend(requestSource));
         auto err = res.tryGetExceptionObject<HTTPError>();
@@ -3509,7 +3511,7 @@ CO_TEST_P_X(HTTPDownstreamSessionTest, IngressErrorCustomResponseMismatch) {
                                  -> folly::coro::Task<HTTPSourceHolder> {
         auto headers = co_await co_awaitTry(
             expectRequest(requestSource, HTTPMethod::POST, "/", false));
-        CHECK(headers.hasValue());
+        PRX_CHECK(headers.hasValue());
 
         auto res = co_await co_awaitTry(readBodyEventNoSuspend(requestSource));
         auto err = res.tryGetExceptionObject<HTTPError>();
@@ -4317,7 +4319,7 @@ CO_TEST_P_X(H2DownstreamWtTest, BypassWebTransportTermination) {
   co_await waitForHandler;
   // expected ingress eventType=BODY, equal to kBody, and eom=true
   auto ingressBody = co_await co_nothrow(reqSource->readBodyEvent());
-  CHECK_EQ(ingressBody.eventType, HTTPBodyEvent::BODY);
+  PRX_CHECK_EQ(ingressBody.eventType, HTTPBodyEvent::BODY);
   EXPECT_EQ(ingressBody.event.body.move()->toString(), kBody);
   EXPECT_TRUE(ingressBody.eom);
 
diff --git a/proxygen/lib/http/coro/test/HTTPFilterFactoryHandlerTests.cpp b/proxygen/lib/http/coro/test/HTTPFilterFactoryHandlerTests.cpp
index 6700868e39..e802bd5c67 100644
--- a/proxygen/lib/http/coro/test/HTTPFilterFactoryHandlerTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPFilterFactoryHandlerTests.cpp
@@ -19,6 +19,7 @@
 #include "proxygen/lib/http/coro/filters/FilterFactory.h"
 #include "proxygen/lib/http/coro/filters/MutateFilter.h"
 #include "proxygen/lib/http/coro/test/Mocks.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::test {
 
@@ -111,7 +112,7 @@ class HTTPFilterFactoryHandlerTests : public ::testing::Test {
           .onHeaders([this](std::unique_ptr<HTTPMessage> msg,
                             bool /*final*/,
                             bool /*eom*/) {
-            CHECK(msg);
+            PRX_CHECK(msg);
             const auto& headers = msg->getHeaders();
             EXPECT_EQ(headers.getSingleOrEmpty("req-filter"),
                       expectedReqFilterValue_);
diff --git a/proxygen/lib/http/coro/test/HTTPSourceTests.cpp b/proxygen/lib/http/coro/test/HTTPSourceTests.cpp
index 9705180828..7c01122523 100644
--- a/proxygen/lib/http/coro/test/HTTPSourceTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPSourceTests.cpp
@@ -20,12 +20,12 @@
 #include <folly/coro/BlockingWait.h>
 #include <folly/coro/Sleep.h>
 #include <folly/io/async/ScopedEventBaseThread.h>
-#include <folly/logging/xlog.h>
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
 #include <memory>
 #include <proxygen/lib/http/HTTP3ErrorCode.h>
 #include <proxygen/lib/http/codec/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen::coro;
 using namespace testing;
@@ -60,8 +60,8 @@ class HTTPStreamSourceTest : public testing::Test {
             evb_.terminateLoopSoon();
           }
         }));
-    XCHECK(!stream_.sourceComplete());
-    XCHECK_EQ(stream_.window().getSize(), 65'535);
+    PRX_CHECK(!stream_.sourceComplete());
+    PRX_CHECK_EQ(stream_.window().getSize(), 65'535);
   }
 
  protected:
@@ -1035,7 +1035,7 @@ TEST(HTTPSourceReader, stop) {
             return HTTPSourceReader::Cancel; // Stop reading
           })
       .onBody([](BufQueue, bool) {
-        XLOG(FATAL) << "onBody called after stop";
+        ADD_FAILURE() << "onBody called after stop";
         return HTTPSourceReader::Continue;
       });
   co_withExecutor(&evb,
@@ -1061,11 +1061,13 @@ TEST(HTTPSourceReader, cancelHeaders) {
         co_return HTTPSourceReader::Continue;
       })
       .onBody([](BufQueue, bool) {
-        XLOG(FATAL) << "onBody called after cancel";
+        ADD_FAILURE() << "onBody called after cancel";
+
         return HTTPSourceReader::Continue;
       })
       .onError([](const HTTPSourceReader::ErrorContext&, const HTTPError&) {
-        XLOG(FATAL) << "onError called after cancel";
+        ADD_FAILURE() << "onError called after cancel";
+
         return HTTPSourceReader::Continue;
       });
   co_withExecutor(&evb,
@@ -1095,11 +1097,13 @@ TEST(HTTPSourceReader, cancelPreRead) {
       })
       .onHeaders(
           [](std::unique_ptr<HTTPMessage> headers, bool final, bool eom) {
-            XLOG(FATAL) << "onHeaders called after cancel";
+            ADD_FAILURE() << "onHeaders called after cancel";
+
             return HTTPSourceReader::Continue;
           })
       .onError([](const HTTPSourceReader::ErrorContext&, const HTTPError&) {
-        XLOG(FATAL) << "onError called after cancel";
+        ADD_FAILURE() << "onError called after cancel";
+
         return HTTPSourceReader::Continue;
       });
   co_withExecutor(&evb,
@@ -1236,7 +1240,7 @@ TEST(HTTPSourceReader, filter) {
   class ByteCountFilter : public HTTPSourceFilter {
    public:
     folly::coro::Task<HTTPBodyEvent> readBodyEvent(uint32_t max) override {
-      XLOG(INFO) << __func__;
+      PRX_LOG(INFO) << __func__;
       auto bodyEvent = co_await readBodyEventImpl(max);
       bytes += (bodyEvent.eventType == HTTPBodyEvent::BODY)
                    ? bodyEvent.event.body.chainLength()
@@ -1391,7 +1395,7 @@ CO_TEST(FilterChainTest, SetBeforeInsert) {
 CO_TEST(FilterChainTest, ReleaseFilterChain) {
   auto readChainTask = [](HTTPSourceHolder holder) -> folly::coro::Task<void> {
     auto headerEvent = co_await co_awaitTry(holder.readHeaderEvent());
-    CHECK(!headerEvent.hasException());
+    PRX_CHECK(!headerEvent.hasException());
     EXPECT_EQ(headerEvent->headers->getPathAsStringPiece(), "/filterchain");
     co_return;
   };
@@ -1589,34 +1593,34 @@ CO_TEST(ConsumerProducer, TestHTTPStreamSourceHolderDestructor) {
 
   auto streamSourceHolder =
       HTTPStreamSourceHolder::make(consumerAndProducerEvb.getEventBase());
-  CHECK(streamSourceHolder->get());
+  PRX_CHECK(streamSourceHolder->get());
 
   // space out producer work to introduce randomness in execution
   consumerAndProducerEvb.add([streamSourceHolder]() {
     // source should still exist
     auto source = streamSourceHolder->get();
-    CHECK(streamSourceHolder->get());
+    PRX_CHECK(streamSourceHolder->get());
     source->headers(makeResponse(200), /*eom=*/false);
   });
 
   consumerAndProducerEvb.add([streamSourceHolder]() {
     // source should still exist
     auto source = streamSourceHolder->get();
-    CHECK(streamSourceHolder->get());
+    PRX_CHECK(streamSourceHolder->get());
     source->body(makeBuf(100), /*padding=*/0, /*eom=*/false);
   });
 
   consumerAndProducerEvb.add([streamSourceHolder]() {
     // source should still exist
     auto source = streamSourceHolder->get();
-    CHECK(streamSourceHolder->get());
+    PRX_CHECK(streamSourceHolder->get());
     source->datagram(makeBuf(100));
   });
 
   consumerAndProducerEvb.add([streamSourceHolder]() {
     // source should still exist
     auto source = streamSourceHolder->get();
-    CHECK(streamSourceHolder->get());
+    PRX_CHECK(streamSourceHolder->get());
     source->eom();
   });
 
@@ -1625,36 +1629,37 @@ CO_TEST(ConsumerProducer, TestHTTPStreamSourceHolderDestructor) {
       folly::coro::co_invoke([streamSourceHolder]() -> folly::coro::Task<void> {
         auto maybeHeaders =
             co_await co_awaitTry(streamSourceHolder->get()->readHeaderEvent());
-        CHECK(!maybeHeaders.hasException());
+        PRX_CHECK(!maybeHeaders.hasException());
 
         // source should still exist
-        CHECK(streamSourceHolder->get());
+        PRX_CHECK(streamSourceHolder->get());
         auto maybeBody =
             co_await co_awaitTry(streamSourceHolder->get()->readBodyEvent());
-        CHECK(!maybeBody.hasException());
-        CHECK(maybeBody->eventType == HTTPBodyEvent::EventType::BODY);
-        CHECK(maybeBody->event.body.chainLength() == 100 &&
-              maybeBody->eom == false);
+        PRX_CHECK(!maybeBody.hasException());
+        PRX_CHECK(maybeBody->eventType == HTTPBodyEvent::EventType::BODY);
+        PRX_CHECK(maybeBody->event.body.chainLength() == 100 &&
+                  maybeBody->eom == false);
 
         // source should still exist
-        CHECK(streamSourceHolder->get());
+        PRX_CHECK(streamSourceHolder->get());
         auto maybeDatagram =
             co_await co_awaitTry(streamSourceHolder->get()->readBodyEvent());
         // this last event should be an abort so expect exception
-        CHECK(!maybeDatagram.hasException() &&
-              maybeDatagram->eventType == HTTPBodyEvent::EventType::DATAGRAM);
+        PRX_CHECK(!maybeDatagram.hasException() &&
+                  maybeDatagram->eventType ==
+                      HTTPBodyEvent::EventType::DATAGRAM);
 
         // source should still exist
-        CHECK(streamSourceHolder->get());
+        PRX_CHECK(streamSourceHolder->get());
         auto maybeEom =
             co_await co_awaitTry(streamSourceHolder->get()->readBodyEvent());
         // this last event should be an abort so expect exception
-        CHECK(!maybeEom.hasException() && maybeEom->eom);
+        PRX_CHECK(!maybeEom.hasException() && maybeEom->eom);
 
         // source should no longer exist due to ::sourceComplete callback –
         // which should run destructor of the internal HTTPStreamSource within
         // the producer evb
-        CHECK(streamSourceHolder->get() == nullptr);
+        PRX_CHECK(streamSourceHolder->get() == nullptr);
       }));
 
   folly::coro::blockingWait(std::move(consumerTask));
@@ -1667,7 +1672,7 @@ CO_TEST(ConsumerProducer, TestHTTPStreamSourceHolderDestructor) {
 TEST(HTTPStreamSourceHolder, Simple) {
   folly::EventBase evb;
   auto source = HTTPStreamSourceHolder::make(&evb);
-  XCHECK(source->get());
+  PRX_CHECK(source->get());
 
   HTTPSourceReader reader{source->get()};
   co_withExecutor(&evb, reader.read()).start();
@@ -1688,7 +1693,7 @@ TEST(HTTPStreamSourceHolder, Simple) {
 TEST(HTTPStreamSourceHolder, DestructorTest) {
   folly::EventBase evb;
   auto source = HTTPStreamSourceHolder::make(&evb);
-  XCHECK(source->get());
+  PRX_CHECK(source->get());
   source->get()->headers(makePostRequest(1'000));
 }
 
diff --git a/proxygen/lib/http/coro/test/HTTPStreamSourceSinkTests.cpp b/proxygen/lib/http/coro/test/HTTPStreamSourceSinkTests.cpp
index d36b016df8..13ea02560d 100644
--- a/proxygen/lib/http/coro/test/HTTPStreamSourceSinkTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPStreamSourceSinkTests.cpp
@@ -14,6 +14,7 @@
 #include <folly/MoveWrapper.h>
 #include <folly/coro/BlockingWait.h>
 #include <folly/coro/Sleep.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen::coro;
 using namespace testing;
@@ -73,7 +74,7 @@ CO_TEST_P_X(HTTPClientTests, FailSendUpstreamReq) {
 
   // get request before drain
   auto reservation = sess->reserveRequest();
-  XCHECK(reservation.hasValue());
+  PRX_CHECK(reservation.hasValue());
   // initiateDrain will cause next HTTPCoroSession::sendRequest to yield an
   // exception
   sess->initiateDrain();
diff --git a/proxygen/lib/http/coro/test/HTTPTestSources.h b/proxygen/lib/http/coro/test/HTTPTestSources.h
index d8aee36f28..bc95b64df9 100644
--- a/proxygen/lib/http/coro/test/HTTPTestSources.h
+++ b/proxygen/lib/http/coro/test/HTTPTestSources.h
@@ -15,6 +15,7 @@
 #include "proxygen/lib/http/coro/HTTPSourceHolder.h"
 #include <folly/coro/Sleep.h>
 #include <folly/io/IOBufQueue.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::test {
 
@@ -242,8 +243,8 @@ class ByteEventFilter : public HTTPSourceFilter {
     auto ev = co_await HTTPSourceFilter::readBodyEventImpl(std::min(max_, max));
     for (auto eventType : HTTPByteEvent::kByteEventTypes) {
       if (bodyEvents_ & folly::to_underlying(eventType)) {
-        XLOG(DBG4) << "registering for event t="
-                   << folly::to_underlying(eventType);
+        PRX_VLOG(4) << "registering for event t="
+                    << folly::to_underlying(eventType);
         HTTPByteEventRegistration reg;
         reg.events = folly::to_underlying(eventType);
 
@@ -290,7 +291,7 @@ class YieldExceptionSource : public HTTPSource {
 
   folly::coro::Task<HTTPBodyEvent> readBodyEvent(
       uint32_t max = std::numeric_limits<uint32_t>::max()) override {
-    XCHECK(stage_ == BodyEvent);
+    PRX_CHECK(stage_ == BodyEvent);
     [[maybe_unused]] auto guard = folly::makeGuard([this] {
       if (heapAllocated_) {
         delete this;
diff --git a/proxygen/lib/http/coro/test/HTTPUpstreamCoroSessionTests.cpp b/proxygen/lib/http/coro/test/HTTPUpstreamCoroSessionTests.cpp
index e1ab9a59ef..07f59608dc 100644
--- a/proxygen/lib/http/coro/test/HTTPUpstreamCoroSessionTests.cpp
+++ b/proxygen/lib/http/coro/test/HTTPUpstreamCoroSessionTests.cpp
@@ -10,7 +10,7 @@
 #include "proxygen/lib/http/coro/test/HTTPCoroSessionTests.h"
 #include "proxygen/lib/http/coro/test/HTTPTestSources.h"
 #include "proxygen/lib/http/coro/test/Mocks.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/ExceptionWrapper.h>
 #include <folly/coro/Timeout.h>
@@ -84,7 +84,7 @@ class HTTPUpstreamSessionTest : public HTTPCoroSessionTest {
           if (!bodyEvent->event.body.empty()) {
             EXPECT_GT(contentLength, 0);
             auto length = bodyEvent->event.body.chainLength();
-            XCHECK_GE(contentLength, length);
+            PRX_CHECK_GE(contentLength, length);
             contentLength -= length;
             response->body_.append(bodyEvent->event.body.move());
           }
@@ -219,7 +219,7 @@ class HTTPUpstreamSessionTest : public HTTPCoroSessionTest {
     // send a request for GET /
     auto responseSource = co_await co_awaitTry(
         session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-    XCHECK(!responseSource.hasException());
+    PRX_CHECK(!responseSource.hasException());
     auto streamID = *responseSource->getStreamID();
 
     // serialize a response with no EOM
@@ -279,7 +279,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, Simple) {
   if (!IS_H1()) {
     EXPECT_EQ(session_->numTransactionsAvailable(), 9);
   }
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   serializeResponse(*responseSource->getStreamID(), 200, makeBuf(100), true);
   co_await expectResponse(std::move(*responseSource), 200, 100, true);
   transport_->addReadEvent(nullptr, true);
@@ -288,7 +288,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, Simple) {
 CO_TEST_P_X(HTTPUpstreamSessionTest, SimplePost) {
   auto responseSource = co_await co_awaitTry(session_->sendRequest(
       HTTPFixedSource::makeFixedRequest("/", HTTPMethod::POST, makeBuf(100))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   serializeResponse(*responseSource->getStreamID(), 200, makeBuf(100), true);
   co_await expectResponse(std::move(*responseSource), 200, 100, true);
   transport_->addReadEvent(nullptr, true);
@@ -307,7 +307,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, LargePost) {
                         serializeResponse(id, 200, makeBuf(40000), true);
                         co_return folly::none;
                       })));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   id = *responseSource->getStreamID();
   evb_.runInLoop([this, id] {
     // The POST will run out of flow control, give it some in the loop
@@ -328,7 +328,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, LargePost) {
 CO_TEST_P_X(HTTPUpstreamSessionTest, Padding) {
   auto responseSource = co_await co_awaitTry(session_->sendRequest(
       HTTPFixedSource::makeFixedRequest("/", HTTPMethod::POST, makeBuf(100))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   // @lint-ignore CLANGTIDY bugprone-unchecked-optional-access
   const auto id = *responseSource->getStreamID();
   HTTPMessage msg = makeResponse(200, /*eom=*/false);
@@ -369,7 +369,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, ReceiveFullResponsePriorToRequestEOM) {
   // send request & get id
   auto responseSource =
       co_await co_awaitTry(session_->sendRequest(reqStreamSource));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   serializeResponse(id, 200, makeBuf(1500));
 
@@ -419,7 +419,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, StopReadingOnAbort) {
               stopReading(A<folly::Optional<const HTTPErrorCode>>()));
 
   auto responseSource = co_await co_awaitTry(session_->sendRequest(&reqSource));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   id = *responseSource->getStreamID();
   auto resSourceHeaderEvent =
       co_await co_awaitTry(responseSource->readHeaderEvent());
@@ -436,7 +436,7 @@ CO_TEST_P_X(H2UpstreamSessionTest, RstStreamAfterEOM) {
   // send request & get id
   auto responseSource =
       co_await co_awaitTry(session_->sendRequest(reqStreamSource));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   id = *responseSource->getStreamID();
 
   // send response with eom and follow with RST_STREAM
@@ -469,7 +469,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, ReceiveStopSendingStreamPriorToResponseEOM) {
   // send request & get id
   auto responseSource =
       co_await co_awaitTry(session_->sendRequest(reqStreamSource));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   id = *responseSource->getStreamID();
 
   // serialize partial response
@@ -554,7 +554,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, ReserveRequest) {
   // Valid request
   auto responseSource = co_await co_awaitTry(session_->sendRequest(
       HTTPFixedSource::makeFixedRequest("/"), std::move(*res)));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   serializeResponse(*responseSource->getStreamID(), 200, makeBuf(100), true);
   co_await expectResponse(std::move(*responseSource), 200, 100, true);
   EXPECT_EQ(session_->getNextStreamSeqNum(), 1);
@@ -565,7 +565,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, IngressResetStream) {
   // Send request, response with a reset stream
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   resetStream(id, ErrorCode::CANCEL);
   auto headerEvent = co_await co_awaitTry(responseSource->readHeaderEvent());
@@ -639,7 +639,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, Push) {
   onTearDown([this] {
     EXPECT_EQ(pushes_.size(), 1);
     auto &push = pushes_.front();
-    XCHECK(push.second);
+    PRX_CHECK(push.second);
     EXPECT_EQ(push.first.promise->getURL(), "/push");
     EXPECT_EQ(push.second->msg_->getStatusCode(), 200);
     EXPECT_EQ(push.second->body_.chainLength(), 100);
@@ -654,7 +654,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, PushEgressRstStream) {
     // triggering STOP_SENDING/RST_STREAM (w/ ErrorCode::CANCEL) since we
     // haven't seen EOM yet.
     co_await rescheduleN(2);
-    XLOG(DBG4) << "Abandoning push";
+    PRX_VLOG(4) << "Abandoning push";
     co_return;
   };
 
@@ -710,7 +710,7 @@ CO_TEST_P_X(H2UpstreamSessionTest, PushParentReset) {
   // send a request for GET /
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto streamID = *responseSource->getStreamID();
 
   // serialize a response with no body/EOM
@@ -741,7 +741,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, PromiseBeforePush) {
   // send a request for GET /
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto streamID = *responseSource->getStreamID();
 
   // serialize a response with no EOM
@@ -779,7 +779,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, SendPushPriority) {
   // send a request for GET /
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto streamID = *responseSource->getStreamID();
 
   // serialize a response with no EOM
@@ -827,7 +827,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterCodecNotReusable) {
   // send first request, verify no exception
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
 
   // rx response with Connection: Close header (i.e. no keep-alive)
   auto id = *responseSource->getStreamID();
@@ -852,7 +852,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterCodecNotReusable) {
   // yield exception
   auto drainedException = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  CHECK(drainedException.hasException());
+  PRX_CHECK(drainedException.hasException());
   auto ex = drainedException.exception().get_exception<HTTPError>();
 
   // reservation fails with "Exceeded stream limit" since
@@ -864,7 +864,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterCodecNotReusable) {
 CO_TEST_P_X(H1UpstreamSessionTest, ReceiveGoaway) {
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   generateGoaway(id, ErrorCode::NO_ERROR);
   serializeResponseHeader(id, 200, false);
@@ -890,7 +890,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, SendGoaway) {
   auto req = HTTPFixedSource::makeFixedRequest("/");
   req->msg_->getHeaders().set(HTTP_HEADER_CONNECTION, "close");
   auto responseSource = co_await co_awaitTry(session_->sendRequest(req));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   serializeResponseHeader(id, 200, false);
   transport_->addReadEvent(id, writeBuf_.move(), false);
@@ -912,7 +912,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterFailedUpgrade) {
   auto req = HTTPFixedSource::makeFixedRequest("/websocket");
   req->msg_->setEgressWebsocketUpgrade();
   auto responseSource = co_await co_awaitTry(session_->sendRequest(req));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   serializeResponseHeader(id, 500, /*eom*/ true);
   transport_->addReadEvent(id, writeBuf_.move(), false);
@@ -1048,7 +1048,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, BodyError) {
 CO_TEST_P_X(H2QUpstreamSessionTest, ReceiveGoawayWithOpenStream) {
   auto responseSource1 = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource1.hasException());
+  PRX_CHECK(!responseSource1.hasException());
   auto responseSource2 = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
   auto id = *responseSource1->getStreamID();
@@ -1166,7 +1166,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, PostBodyReadTimeout) {
   auto req = std::make_unique<HTTPMessage>(getPostRequest(100));
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(new TimeoutSource(std::move(req))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto resp = co_await co_awaitTry(folly::coro::timeoutNoDiscard(
       responseSource->readHeaderEvent(), std::chrono::milliseconds(500)));
   // Wait for a header event for 2x the read timeout -- the read timer isn't
@@ -1182,7 +1182,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, PostReadTimeout) {
   session_->setStreamReadTimeout(std::chrono::milliseconds(250));
   auto responseSource = co_await co_awaitTry(session_->sendRequest(
       HTTPFixedSource::makeFixedRequest("/", HTTPMethod::POST, makeBuf(100))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto resp = co_await co_awaitTry(folly::coro::timeoutNoDiscard(
       responseSource->readHeaderEvent(), std::chrono::milliseconds(1500)));
   // Timer is running, read timeout before timeoutNoDiscard
@@ -1197,7 +1197,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, PostReadCustomTimeout) {
   session_->setStreamReadTimeout(std::chrono::seconds(20));
   auto responseSource = co_await co_awaitTry(session_->sendRequest(
       HTTPFixedSource::makeFixedRequest("/", HTTPMethod::POST, makeBuf(100))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   responseSource->setReadTimeout(std::chrono::milliseconds(250));
   auto resp = co_await co_awaitTry(folly::coro::timeoutNoDiscard(
       responseSource->readHeaderEvent(), std::chrono::milliseconds(1500)));
@@ -1213,7 +1213,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, GetReadTimeout) {
   session_->setStreamReadTimeout(std::chrono::milliseconds(250));
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto resp = co_await co_awaitTry(folly::coro::timeoutNoDiscard(
       responseSource->readHeaderEvent(), std::chrono::milliseconds(1500)));
   // Timer is running, read timeout before timeoutNoDiscard
@@ -1319,7 +1319,7 @@ CO_TEST_P_X(H2QUpstreamSessionTest, OnDeactivateConnectionLifecycle) {
   EXPECT_CALL(lifecycleObs_, onTransactionAttached(_)).Times(1);
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   serializeResponse(*responseSource->getStreamID(), 200, makeBuf(100), true);
 
   // detaching a stream with a pending reservation should not
@@ -1344,7 +1344,7 @@ CO_TEST_P_X(H2UpstreamSessionTest, PushPromiseParseError) {
   // send a request for GET /
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto streamID = *responseSource->getStreamID();
 
   // serialize a response with no body/EOM
@@ -1435,7 +1435,7 @@ CO_TEST_P_X(H2UpstreamSessionTest, EgressWhileWritesBlocked) {
   EXPECT_EQ(transportState_.writeEvents.size(), 1);
   auto responseSource1 = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource1.hasException());
+  PRX_CHECK(!responseSource1.hasException());
   // Pause writes and let the egress go to the writeBuf
   transport_->pauseWrites(0);
   co_await folly::coro::co_reschedule_on_current_executor;
@@ -1582,7 +1582,7 @@ CO_TEST_P_X(HTTPUpstreamSessionTest, SendRequestHeadersAvailable) {
   auto reservation = session_->reserveRequest().value();
   auto res = session_->sendRequest(
       std::move(reservation), *headerEv.headers, &reqSource);
-  XCHECK(!res.hasError());
+  PRX_CHECK(!res.hasError());
 
   EXPECT_CALL(lifecycleObs_, onTransactionDetached(_));
   serializeResponse(res->getStreamID().value(), 200, makeBuf(100), true);
@@ -1635,7 +1635,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, TrailingGarbage) {
       });
   auto responseSource =
       co_await co_awaitTry(session_->sendRequest(onEomRequestSource));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto resp = makeResponse(200, true); // eom=true prevents te: chunked
   resp.getHeaders().add(HTTP_HEADER_CONTENT_LENGTH, "10");
   serializeResponseHeader(
@@ -1666,7 +1666,7 @@ CO_TEST_P_X(H1UpstreamSessionTest, TrailingGarbage) {
 CO_TEST_P_X(HQUpstreamSessionTest, CreateBidiStreamFailure) {
   // reserve request successfully
   auto reservation = session_->reserveRequest();
-  XCHECK(reservation.hasValue());
+  PRX_CHECK(reservation.hasValue());
 
   // make next call to QuicSocket::createBidirectionalStream fail
   EXPECT_CALL(*muxTransport_->socketDriver_.sock_, createBidirectionalStream(_))
@@ -1679,7 +1679,8 @@ CO_TEST_P_X(HQUpstreamSessionTest, CreateBidiStreamFailure) {
 
   // verify exception yielded
   EXPECT_TRUE(responseSource.hasException());
-  auto ex = CHECK_NOTNULL(responseSource.tryGetExceptionObject<HTTPError>());
+  auto ex =
+      PRX_CHECK_NOTNULL(responseSource.tryGetExceptionObject<HTTPError>());
   EXPECT_EQ(ex->code, HTTPErrorCode::REFUSED_STREAM);
 }
 
@@ -1715,7 +1716,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, StopSending) {
   auto req = std::make_unique<HTTPMessage>(getPostRequest(100));
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(new TimeoutSource(std::move(req))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   // Server asks client to stop sending.  Cancels the egress coro
   auto id = *responseSource->getStreamID();
   muxTransport_->socketDriver_.addStopSending(
@@ -1732,7 +1733,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, StopSendingEgressComplete) {
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest(
           "/", HTTPMethod::POST, makeBuf(70000))));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   // Server asks client to stop sending.  Egress coro is already complete
   auto id = *responseSource->getStreamID();
   muxTransport_->socketDriver_.addStopSending(
@@ -1750,7 +1751,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, StopSendingEgressComplete) {
 CO_TEST_P_X(HQUpstreamSessionTest, CancelWithStopSending) {
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   co_await folly::coro::co_reschedule_on_current_executor;
   responseSource->stopReading();
@@ -1764,7 +1765,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, QPACKQueuedOnClose) {
   co_await rescheduleN(2);
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   auto resp = makeResponse(200);
   resp.getHeaders().add("Dynamic", "Header");
@@ -1785,7 +1786,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, QPACKQueuedOnClose) {
 CO_TEST_P_X(HQUpstreamSessionTest, DrainSessionOnConnectionError) {
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   // ::onConnectionError callback should invoke ::onDrainStarted
   EXPECT_CALL(lifecycleObs_, onDrainStarted(_));
   muxTransport_->socketDriver_.closeImpl(std::nullopt);
@@ -1795,7 +1796,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, QPACKQueuedOnCloseNoEncoderStream) {
   // Don't wait for the encoder stream to be established
   auto responseSource = co_await co_awaitTry(
       session_->sendRequest(HTTPFixedSource::makeFixedRequest("/")));
-  XCHECK(!responseSource.hasException());
+  PRX_CHECK(!responseSource.hasException());
   auto id = *responseSource->getStreamID();
   auto resp = makeResponse(200);
   resp.getHeaders().add("Dynamic", "Header");
@@ -1818,7 +1819,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, LargeRequest) {
   }
   // reserve request successfully
   auto reservation = session_->reserveRequest();
-  XCHECK(reservation.hasValue());
+  PRX_CHECK(reservation.hasValue());
 
   struct SourceCallback : public HTTPStreamSource::Callback {
     void bytesProcessed(HTTPCodec::StreamID, size_t, size_t) override {
@@ -1839,7 +1840,7 @@ CO_TEST_P_X(HQUpstreamSessionTest, LargeRequest) {
   reqSource.headers(makePostRequest(kReqSize));
 
   auto responseSource = co_await co_awaitTry(session_->sendRequest(&reqSource));
-  XCHECK(responseSource.hasValue());
+  PRX_CHECK(responseSource.hasValue());
 
   uint32_t egressed = 0;
   constexpr auto kChunkSize = std::numeric_limits<uint16_t>::max();
diff --git a/proxygen/lib/http/coro/test/HttpWtUpstreamTests.cpp b/proxygen/lib/http/coro/test/HttpWtUpstreamTests.cpp
index f949822f13..59bcec744c 100644
--- a/proxygen/lib/http/coro/test/HttpWtUpstreamTests.cpp
+++ b/proxygen/lib/http/coro/test/HttpWtUpstreamTests.cpp
@@ -16,6 +16,7 @@
 #include <proxygen/lib/http/coro/util/CoroWtSession.h>
 #include <proxygen/lib/http/webtransport/WtStreamManager.h>
 #include <proxygen/lib/http/webtransport/test/Mocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::test;
@@ -39,7 +40,7 @@ struct WtCapsuleCodecCallback : public WebTransportCapsuleCodec::Callback {
     baton.post();
   }
   void onStream(WTStreamCapsule capsule) noexcept override {
-    XLOG(DBG4)
+    PRX_VLOG(4)
         << __func__ << "; id=" << capsule.streamId << "; len="
         << (capsule.streamData ? capsule.streamData->computeChainDataLength()
                                : 0);
@@ -83,12 +84,12 @@ struct WtCapsuleCodecCallback : public WebTransportCapsuleCodec::Callback {
   }
   void onConnectionError(
       WebTransportCapsuleCodec::ErrorCode) noexcept override {
-    XLOG(FATAL) << "conn error";
+    PRX_LOG(FATAL) << "conn error";
   }
   void onCapsule(uint64_t capsuleType,
                  uint64_t capsuleLength) noexcept override {
-    XLOG(DBG4) << __func__ << "; capsuleType=" << capsuleType
-               << "; capsuleLength=" << capsuleLength;
+    PRX_VLOG(4) << __func__ << "; capsuleType=" << capsuleType
+                << "; capsuleLength=" << capsuleLength;
   }
 
   folly::coro::Task<void> waitForEvent() {
@@ -290,14 +291,14 @@ class WtTest : public H2WtUpstreamSessionTest {
     });
     EXPECT_CALL(callbacks_, onBody(1, _, _))
         .WillRepeatedly([this](auto id, auto buf, auto padding) {
-          XLOG(DBG5) << "::onBody len=" << buf->computeChainDataLength();
+          PRX_VLOG(5) << "::onBody len=" << buf->computeChainDataLength();
           wtCodec.onIngress(buf->clone(), false);
         });
     EXPECT_CALL(callbacks_, onMessageComplete(1, _)).WillRepeatedly([this]() {
-      XLOG(DBG5) << "::onMessageComplete";
+      PRX_VLOG(5) << "::onMessageComplete";
       wtCodec.onIngress(nullptr, true);
     });
-    coroTp = CHECK_NOTNULL(dynamic_cast<TestCoroTransport*>(transport_));
+    coroTp = PRX_CHECK_NOTNULL(dynamic_cast<TestCoroTransport*>(transport_));
   }
 
   void TearDown() override {
@@ -387,7 +388,7 @@ class WtTest : public H2WtUpstreamSessionTest {
  *    the http/2 loop has dequeued from WtStreamManager
  */
 CO_TEST_P_X(WtTest, SimpleUniEgress) {
-  XCHECK(wt);
+  PRX_CHECK(wt);
 
   // no available uni/bidi streams
   auto createStream = wt->createUniStream();
@@ -406,7 +407,7 @@ CO_TEST_P_X(WtTest, SimpleUniEgress) {
 
   // peer advertised uni credit => ::createUniStream now yields handle
   createStream = wt->createUniStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto* wh = createStream.value();
   auto id = wh->getID();
 
@@ -434,7 +435,7 @@ CO_TEST_P_X(WtTest, SimpleUniEgress) {
 
   // validate we've rx'd a wt_stream capsule with expected values
   auto streamEvent = std::exchange(wtCodecCb.stream, {});
-  XCHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), kBufLen);
 
@@ -462,7 +463,7 @@ CO_TEST_P_X(WtTest, SimpleUniEgress) {
   co_await wtCodecCb.waitForEvent(); // ouch, this needs 5 loops otherwise
                                      // (i.e. co_await rescheduleN(5))
   streamEvent = std::exchange(wtCodecCb.stream, {});
-  XCHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), 1);
 
@@ -472,7 +473,7 @@ CO_TEST_P_X(WtTest, SimpleUniEgress) {
 
   co_await wtCodecCb.waitForEvent();
   streamEvent = std::exchange(wtCodecCb.stream, {});
-  XCHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), 0);
   EXPECT_EQ(streamEvent->fin, true);
@@ -489,7 +490,7 @@ CO_TEST_P_X(WtTest, SimpleUniEgress) {
  *    frame respectively
  */
 CO_TEST_P_X(WtTest, SimpleUniIngress) {
-  XCHECK(wt);
+  PRX_CHECK(wt);
   constexpr uint16_t kBufLen = 65'535;
   constexpr uint16_t kIngressId = 3;
 
@@ -539,7 +540,7 @@ CO_TEST_P_X(WtTest, SimpleUniIngress) {
 }
 
 CO_TEST_P_X(WtTest, SimpleBidiEcho) {
-  XCHECK(wt);
+  PRX_CHECK(wt);
   constexpr uint16_t kBufLen = 65'535;
 
   // no available bidi streams
@@ -559,7 +560,7 @@ CO_TEST_P_X(WtTest, SimpleBidiEcho) {
 
   // peer advertised bidi credit => ::createBidiStream now yields handle
   createStream = wt->createBidiStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto handle = createStream.value();
   auto id = handle.readHandle->getID();
 
@@ -596,7 +597,7 @@ CO_TEST_P_X(WtTest, SimpleBidiEcho) {
 
     // validate we've rx'd a wt_stream capsule with val idx
     auto streamEvent = std::exchange(wtCodecCb.stream, {});
-    XCHECK(streamEvent.has_value());
+    PRX_CHECK(streamEvent.has_value());
     EXPECT_EQ(streamEvent->streamId, id);
     EXPECT_EQ(streamEvent->streamData->length(), 1);
     EXPECT_EQ(*streamEvent->streamData->data(), idx);
@@ -643,7 +644,7 @@ CO_TEST_P_X(WtTest, TestReadTimeout) {
 }
 
 TEST_P(WtTest, TestErrConditions) {
-  XCHECK(wt);
+  PRX_CHECK(wt);
 
   // default no uni credit
   auto uniRes = wt->createUniStream();
@@ -685,7 +686,7 @@ TEST_P(WtTest, TestErrConditions) {
 CO_TEST_P_X(WtTest, PeerBidiAndTransportEom) {
   // Deliver a peer-initiated bidi stream, followed by a transport eom (http/2
   // stream eom). This should trigger shutdown of WebTransport
-  XCHECK(wt);
+  PRX_CHECK(wt);
 
   constexpr uint16_t kBufLen = 65'535;
   constexpr uint16_t kIngressId = 1;
@@ -730,7 +731,7 @@ CO_TEST_P_X(WtTest, MaxStreamsBidiUni) {
   // open 5 of each peer-initiated uni streams and peer-initiated bidi streams;
   // close them to verify that advertising MaxStreamsBidi/MaxStreamsUni is
   // working as expected (when 50% of the limit is reached)
-  XCHECK(wt);
+  PRX_CHECK(wt);
   uint64_t nextServerBidi = 0x01, nextServerUni = 0x03;
 
   // send 1 byte of data on the first five server bidi and server uni streams
@@ -777,12 +778,12 @@ CO_TEST_P_X(WtTest, MaxStreamsBidiUni) {
 }
 
 CO_TEST_P_X(WtTest, Datagrams) {
-  XCHECK(wt);
+  PRX_CHECK(wt);
   // tx datagram to peer
   wt->sendDatagram(folly::IOBuf::copyBuffer("datagram1"));
   // wait for peer codec to receive event
   co_await wtCodecCb.waitForEvent();
-  CHECK_EQ(wtCodecCb.dgrams.size(), 1);
+  PRX_CHECK_EQ(wtCodecCb.dgrams.size(), 1u);
   EXPECT_EQ(wtCodecCb.dgrams.front()->toString(), "datagram1");
 
   // rx datagram from peer
diff --git a/proxygen/lib/http/coro/transport/CMakeLists.txt b/proxygen/lib/http/coro/transport/CMakeLists.txt
index 6472cbe4ca..fab31af80a 100644
--- a/proxygen/lib/http/coro/transport/CMakeLists.txt
+++ b/proxygen/lib/http/coro/transport/CMakeLists.txt
@@ -10,9 +10,9 @@ proxygen_add_library(proxygen_http_coro_transport_coro_ssl_transport
   SRCS
     CoroSSLTransport.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_ssl_basic_transport_certificate
     Folly::folly_io_async_ssl_ssl_errors
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_coro_util_timed_baton
     Folly::folly_io_async_certificate_identity_verifier
@@ -31,8 +31,8 @@ proxygen_add_library(proxygen_http_coro_transport_http_connect_transport
   EXPORTED_DEPS
     proxygen_coro
     proxygen_http_coro_coro_stream_source
+    proxygen_utils_log_shim
     Folly::folly_coro_bounded_queue
     Folly::folly_io_async_async_transport
     Folly::folly_io_coro_socket
-    Folly::folly_logging_logging
 )
diff --git a/proxygen/lib/http/coro/transport/CoroSSLTransport.cpp b/proxygen/lib/http/coro/transport/CoroSSLTransport.cpp
index 9ae8eacf93..6d40f12765 100644
--- a/proxygen/lib/http/coro/transport/CoroSSLTransport.cpp
+++ b/proxygen/lib/http/coro/transport/CoroSSLTransport.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/transport/CoroSSLTransport.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/io/Cursor.h>
 #include <folly/io/async/ssl/BasicTransportCertificate.h>
@@ -27,9 +27,9 @@ constexpr int CORO_SSL_TRANSPORT_RETRY = -1;
 
 CoroSSLTransport* transportFromBio(BIO* bio) {
   auto appData = OpenSSLUtils::getBioAppData(bio);
-  XCHECK(appData);
+  PRX_CHECK(appData);
   auto* transport = reinterpret_cast<CoroSSLTransport*>(appData);
-  XCHECK(transport);
+  PRX_CHECK(transport);
   return transport;
 }
 
@@ -183,7 +183,7 @@ folly::coro::Task<CoroSSLTransport::IOResult> waitForIO(
   currentDeadline.reset();
   if (res == TimedBaton::Status::cancelled) {
     // This can happen with outstanding writes in closeWithReset
-    XLOG(DBG6) << "IO wait cancelled";
+    PRX_VLOG(6) << "IO wait cancelled";
     co_yield folly::coro::co_error(folly::AsyncSocketException(
         folly::AsyncSocketException::CANCELED, "IO wait cancelled"));
   } else if (res == TimedBaton::Status::timedout) {
@@ -247,16 +247,16 @@ folly::coro::Task<void> CoroSSLTransport::connect(
     static const folly::Indestructible<AsyncSocketException> ex(
         AsyncSocketException::INTERNAL_ERROR,
         "error calling SSLContext::createSSL()");
-    XLOG(ERR) << "CoroSSLTransport::connect(this=" << this
-              << "): " << ex->what();
+    PRX_LOG(ERROR) << "CoroSSLTransport::connect(this=" << this
+                   << "): " << ex->what();
     throw(*ex);
   }
 
   if (!setupSSLBio()) {
     static const folly::Indestructible<AsyncSocketException> ex(
         AsyncSocketException::INTERNAL_ERROR, "error creating SSL bio");
-    XLOG(ERR) << "CoroSSLTransport::connect(this=" << this
-              << "): " << ex->what();
+    PRX_LOG(ERROR) << "CoroSSLTransport::connect(this=" << this
+                   << "): " << ex->what();
     co_yield folly::coro::co_error(*ex);
   }
 
@@ -264,8 +264,8 @@ folly::coro::Task<void> CoroSSLTransport::connect(
     static const folly::Indestructible<AsyncSocketException> ex(
         AsyncSocketException::INTERNAL_ERROR,
         "error applying the SSL verification options");
-    XLOG(ERR) << "CoroSSLTransport::connect(this=" << this
-              << "): " << ex->what();
+    PRX_LOG(ERROR) << "CoroSSLTransport::connect(this=" << this
+                   << "): " << ex->what();
     co_yield folly::coro::co_error(*ex);
   }
 
@@ -299,7 +299,7 @@ folly::coro::Task<void> CoroSSLTransport::doConnect(
       folly::annotate_ignore_thread_sanitizer_guard g(__FILE__, __LINE__);
       ret = SSL_connect(ssl_.get());
     }
-    XLOG(DBG6) << "SSL_connect returned=" << ret;
+    PRX_VLOG(6) << "SSL_connect returned=" << ret;
     if (ret <= 0) {
       auto res = co_await folly::coro::co_withCancellation(
           cancellationSource_.getToken(),
@@ -309,7 +309,7 @@ folly::coro::Task<void> CoroSSLTransport::doConnect(
             AsyncSocketException::END_OF_FILE, "EOF during handshake"));
       }
     } else {
-      XLOG(DBG3) << "CoroSSLTransport " << this << ": successfully connected";
+      PRX_VLOG(3) << "CoroSSLTransport " << this << ": successfully connected";
       co_return;
     }
   }
@@ -319,7 +319,8 @@ bool CoroSSLTransport::applyVerificationOptions(
     const folly::ssl::SSLUniquePtr& ssl) {
   // apply the settings specified in verifyPeer_
   if (verifyPeer_ == folly::SSLContext::SSLVerifyPeerEnum::USE_CTX) {
-    XLOG_IF(WARNING, transportOptions_.verifier) << "Verifier set but ignored";
+    PRX_LOG_IF(WARNING, transportOptions_.verifier)
+        << "Verifier set but ignored";
     if (ctx_->needsPeerVerification()) {
       if (ctx_->checkPeerName()) {
         std::string peerNameToVerify =
@@ -377,8 +378,8 @@ int CoroSSLTransport::sslVerifyCallback(int preverifyOk,
       x509Ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
   auto* self = getCoroSSLTransportFromSSL(ssl);
 
-  XLOG(DBG3) << "CoroSSLTransport::sslVerifyCallback() this=" << self << ", "
-             << ", preverifyOk=" << preverifyOk;
+  PRX_VLOG(3) << "CoroSSLTransport::sslVerifyCallback() this=" << self << ", "
+              << ", preverifyOk=" << preverifyOk;
 
   if (!preverifyOk) {
     // OpenSSL verification failure, no need to call CertificateIdentityVerifier
@@ -406,8 +407,9 @@ int CoroSSLTransport::sslVerifyCallback(int preverifyOk,
     self->peerCertData_ = std::move(verifiedCert);
   } catch (folly::CertificateIdentityVerifierException& e) {
 
-    XLOG(ERR) << "CoroSSLTransport::sslVerifyCallback(this=" << self
-              << ") Failed to verify leaf certificate identity(ies): " << e;
+    PRX_LOG(ERROR)
+        << "CoroSSLTransport::sslVerifyCallback(this=" << self
+        << ") Failed to verify leaf certificate identity(ies): " << e;
     return 0;
   }
 
@@ -417,7 +419,7 @@ int CoroSSLTransport::sslVerifyCallback(int preverifyOk,
 folly::coro::Task<size_t> CoroSSLTransport::read(
     folly::MutableByteRange buf, std::chrono::milliseconds timeout) {
   SCOPE_EXIT {
-    XLOG(DBG6) << "read complete";
+    PRX_VLOG(6) << "read complete";
   };
   if (buf.size() == 0) {
     co_return 0;
@@ -429,7 +431,7 @@ folly::coro::Task<size_t> CoroSSLTransport::read(
   auto readDeadline = deadlineFromTimeout(timeout);
   while (true) {
     auto ret = SSL_read(ssl_.get(), buf.data(), buf.size());
-    XLOG(DBG6) << "SSL_read returned=" << ret;
+    PRX_VLOG(6) << "SSL_read returned=" << ret;
     if (ret <= 0) {
       auto res = co_await folly::coro::co_withCancellation(
           cancellationSource_.getToken(),
@@ -459,7 +461,7 @@ folly::coro::Task<size_t> CoroSSLTransport::read(
 folly::coro::Task<CoroSSLTransport::IOResult>
 CoroSSLTransport::handleReturnMaybeIO(
     int ret, std::optional<std::chrono::steady_clock::time_point> deadline) {
-  XLOG(DBG6) << "handleReturnMaybeIO";
+  PRX_VLOG(6) << "handleReturnMaybeIO";
   int sslError;
   unsigned long errError;
   int errnoCopy = errno;
@@ -483,26 +485,27 @@ CoroSSLTransport::handleReturnMaybeIO(
 bool CoroSSLTransport::willBlock(int ret,
                                  int* sslErrorOut,
                                  unsigned long* errErrorOut) noexcept {
-  XLOG(DBG6) << "willBlock";
+  PRX_VLOG(6) << "willBlock";
   *errErrorOut = 0;
   int error = *sslErrorOut = SSL_get_error(ssl_.get(), ret);
   if (error == SSL_ERROR_WANT_READ) {
-    XLOG(DBG6) << "CoroSSLTransport(" << this << "): SSL_ERROR_WANT_READ";
+    PRX_VLOG(6) << "CoroSSLTransport(" << this << "): SSL_ERROR_WANT_READ";
     return true;
   }
   if (error == SSL_ERROR_WANT_WRITE) {
-    XLOG(DBG6) << "CoroSSLTransport(" << this << "): SSL_ERROR_WANT_WRITE";
+    PRX_VLOG(6) << "CoroSSLTransport(" << this << "): SSL_ERROR_WANT_WRITE";
     return true;
   }
 
   // No support yet for SSL_ERROR_WANT_ASYNC
   unsigned long lastError = *errErrorOut = ERR_get_error();
-  XLOG(DBG6) << "CoroSSLTransport(" << this << "): SSL error: " << error << ", "
-             << "errno: " << errno << ", " << "ret: " << ret << ", "
-             << "read: " << BIO_number_read(SSL_get_rbio(ssl_.get())) << ", "
-             << "written: " << BIO_number_written(SSL_get_wbio(ssl_.get()))
-             << ", " << "func: " << ERR_func_error_string(lastError) << ", "
-             << "reason: " << ERR_reason_error_string(lastError);
+  PRX_VLOG(6) << "CoroSSLTransport(" << this << "): SSL error: " << error
+              << ", "
+              << "errno: " << errno << ", " << "ret: " << ret << ", "
+              << "read: " << BIO_number_read(SSL_get_rbio(ssl_.get())) << ", "
+              << "written: " << BIO_number_written(SSL_get_wbio(ssl_.get()))
+              << ", " << "func: " << ERR_func_error_string(lastError) << ", "
+              << "reason: " << ERR_reason_error_string(lastError);
   return false;
 }
 
@@ -537,8 +540,8 @@ int CoroSSLTransport::bioRead(char* buf, size_t sz) {
   }
   folly::io::Cursor cursor(transportReadBuf_.front());
   auto nRead = cursor.pullAtMost(buf, sz);
-  XLOG(DBG6) << "transportReadBuf_ size=" << transportReadBuf_.chainLength()
-             << " returning nRead=" << nRead;
+  PRX_VLOG(6) << "transportReadBuf_ size=" << transportReadBuf_.chainLength()
+              << " returning nRead=" << nRead;
   transportReadBuf_.trimStart(nRead);
   return nRead;
 }
@@ -562,7 +565,7 @@ folly::coro::Task<folly::Unit> CoroSSLTransport::writeImpl(
     WriteInfo* writeInfo,
     bool writev) {
   if (!writev) {
-    XCHECK_EQ(writers_, 0UL) << "One write at a time please";
+    PRX_CHECK_EQ(writers_, 0UL) << "One write at a time please";
   }
   co_await folly::coro::co_safe_point;
   auto deadline = deadlineFromTimeout(timeout);
@@ -575,7 +578,7 @@ folly::coro::Task<folly::Unit> CoroSSLTransport::writeImpl(
       // bioWrite gets the timeout from here
       writesBlocked_.setTimeout(timeoutFromDeadline(deadline));
       auto rc = SSL_write(ssl_.get(), buf.data(), buf.size());
-      XLOG(DBG6) << "SSL_write returned=" << rc;
+      PRX_VLOG(6) << "SSL_write returned=" << rc;
       if (rc <= 0) {
         auto res = co_await handleReturnMaybeIO(rc, deadline);
         if (res == IOResult::EndOfFile) {
@@ -583,7 +586,7 @@ folly::coro::Task<folly::Unit> CoroSSLTransport::writeImpl(
               AsyncSocketException::END_OF_FILE, "EOF during write"));
         }
       } else {
-        XCHECK_EQ(static_cast<size_t>(rc), buf.size());
+        PRX_CHECK_EQ(static_cast<size_t>(rc), buf.size());
         break;
       }
     }
@@ -606,7 +609,7 @@ folly::coro::Task<folly::Unit> CoroSSLTransport::write(
     co_yield folly::coro::co_error(folly::AsyncSocketException(
         AsyncSocketException::END_OF_FILE, "write after shutdownWrite"));
   }
-  XCHECK_EQ(writers_, 0UL) << "One write at a time please";
+  PRX_CHECK_EQ(writers_, 0UL) << "One write at a time please";
   auto deadline = deadlineFromTimeout(timeout);
   do {
     // TODO: If data is smaller than kMinSSLWriteSize, we could skip the extra
@@ -645,11 +648,11 @@ int CoroSSLTransport::bioWrite(const char* buf, size_t sz) {
   // Maybe change Transport::write to do the setup inline
   int ret = sz;
   try {
-    XLOG(DBG6) << "transport_->write sz=" << sz;
+    PRX_VLOG(6) << "transport_->write sz=" << sz;
     if (transportBytesOutstanding_ > kMaxBufferSize) {
       if (writesBlocked_.getStatus() != TimedBaton::Status::notReady) {
-        XLOG(DBG6) << "Blocking writes, transportBytesOutstanding_="
-                   << transportBytesOutstanding_;
+        PRX_VLOG(6) << "Blocking writes, transportBytesOutstanding_="
+                    << transportBytesOutstanding_;
         writesBlocked_.reset();
       }
       return CORO_SSL_TRANSPORT_RETRY;
@@ -665,20 +668,20 @@ int CoroSSLTransport::bioWrite(const char* buf, size_t sz) {
         .via(getEventBase())
         .thenTry([this, sz, deleted = deleted_](
                      folly::Try<folly::Unit> result) {
-          XLOG(DBG6) << "Write completed sz=" << sz;
+          PRX_VLOG(6) << "Write completed sz=" << sz;
           if (!*deleted) {
-            XCHECK_GE(transportBytesOutstanding_, sz);
+            PRX_CHECK_GE(transportBytesOutstanding_, sz);
             transportBytesOutstanding_ -= sz;
-            XLOG(DBG6) << "transportBytesOutstanding_="
-                       << transportBytesOutstanding_;
+            PRX_VLOG(6) << "transportBytesOutstanding_="
+                        << transportBytesOutstanding_;
             if (result.hasException()) {
-              XLOG(ERR) << "Write error ex=" << result.exception().what();
+              PRX_LOG(ERROR) << "Write error ex=" << result.exception().what();
               transport_->closeWithReset();
               return;
             }
             if (transportBytesOutstanding_ <= kMaxBufferSize &&
                 writesBlocked_.getStatus() == TimedBaton::Status::notReady) {
-              XLOG(DBG6) << "Resuming writes";
+              PRX_VLOG(6) << "Resuming writes";
               writesBlocked_.signal();
             }
             if (pendingShutdown_) {
@@ -688,7 +691,7 @@ int CoroSSLTransport::bioWrite(const char* buf, size_t sz) {
         });
   } catch (const std::exception& ex) {
     // This is a catch-all so we don't jump past OpenSSL code
-    XLOG(ERR) << ex.what();
+    PRX_LOG(ERROR) << ex.what();
     return -1;
   }
   return ret;
@@ -731,17 +734,17 @@ void CoroSSLTransport::shutdownWrite() {
     if (writers_ > 0 || transportBytesOutstanding_ > 0) {
       // Can't call SSL_shutdown until SSL_write calls finish and flush
       if (!pendingShutdown_) {
-        XLOG(DBG6) << "Delayed shutdown with pending writes";
+        PRX_VLOG(6) << "Delayed shutdown with pending writes";
         pendingShutdown_ = true;
       }
       return;
     }
     pendingShutdown_ = false;
-    XLOG(DBG6) << "SSL_shutdown";
+    PRX_VLOG(6) << "SSL_shutdown";
     int rc = SSL_shutdown(ssl_.get());
     if (rc == 0) {
       // peer's notify has not yet been received
-      XLOG(DBG4) << "SSL writes shutdown";
+      PRX_VLOG(4) << "SSL writes shutdown";
       if (pendingClose_) {
         transport_->close();
       } else {
@@ -750,7 +753,7 @@ void CoroSSLTransport::shutdownWrite() {
     } else if (rc == 1) {
       // fully shutdown.  There shouldn't be a read in progress (would have
       // returned 0 already), but call shutdownRead in case.
-      XLOG(DBG4) << "SSL completely shutdown";
+      PRX_VLOG(4) << "SSL completely shutdown";
       shutdownRead();
       transport_->close();
     } else {
@@ -775,7 +778,7 @@ bool CoroSSLTransport::shutdownRead() {
   // interrupt any read coros
   cancellationSource_.requestCancellation();
   if (ssl_ && (SSL_get_shutdown(ssl_.get()) & SSL_RECEIVED_SHUTDOWN) == 0) {
-    XLOG(DBG6) << "Shutting down reads but CLOSE_NOTIFY not received";
+    PRX_VLOG(6) << "Shutting down reads but CLOSE_NOTIFY not received";
     return false;
   }
   return true;
diff --git a/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.cpp b/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.cpp
index 883eec6cab..401c5e7578 100644
--- a/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.cpp
+++ b/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -18,7 +18,7 @@ HTTPConnectAsyncTransport::HTTPConnectAsyncTransport(
 }
 
 HTTPConnectAsyncTransport::~HTTPConnectAsyncTransport() {
-  XLOG(DBG4) << "~HTTPConnectAsyncTransport";
+  PRX_VLOG(4) << "~HTTPConnectAsyncTransport";
   if (auto* readCb = resetReadCb()) {
     folly::AsyncSocketException ex(
         folly::AsyncSocketException::AsyncSocketExceptionType::END_OF_FILE,
@@ -50,7 +50,7 @@ void HTTPConnectAsyncTransport::setReadCB(ReadCallback* callback) {
                         cancellationSource_.getToken(), read()))
         .start();
   } else {
-    XCHECK(!inRead_) << "Cannot clear the read callback while reading";
+    PRX_CHECK(!inRead_) << "Cannot clear the read callback while reading";
     readCallback_ = callback;
   }
 }
@@ -58,7 +58,7 @@ void HTTPConnectAsyncTransport::setReadCB(ReadCallback* callback) {
 folly::coro::Task<void> HTTPConnectAsyncTransport::read() {
   co_await folly::coro::co_safe_point;
   if (deferredEof_) {
-    CHECK_NOTNULL(resetReadCb())->readEOF();
+    PRX_CHECK_NOTNULL(resetReadCb())->readEOF();
     co_return;
   }
   const auto& cancelToken = co_await folly::coro::co_current_cancellation_token;
@@ -73,15 +73,15 @@ folly::coro::Task<void> HTTPConnectAsyncTransport::read() {
     }
     // This is not interruptible without an unrecoverable abort
     inRead_ = true;
-    XLOG(DBG5) << "ingressSource->readBodyEvent";
+    PRX_VLOG(5) << "ingressSource->readBodyEvent";
     auto bodyEvent = co_await co_awaitTry(ingressSource->readBodyEvent(size));
-    XLOG(DBG5) << "ingressSource->readBodyEvent done";
+    PRX_VLOG(5) << "ingressSource->readBodyEvent done";
     if (cancelToken.isCancellationRequested()) {
       co_return;
     }
     inRead_ = false;
     if (bodyEvent.hasException()) {
-      XLOG(DBG3) << "readBodyEvent exception";
+      PRX_VLOG(3) << "readBodyEvent exception";
       ingressError_ = getHTTPError(bodyEvent);
       if (auto* readCb = resetReadCb()) {
         folly::AsyncSocketException ex(
@@ -91,14 +91,14 @@ folly::coro::Task<void> HTTPConnectAsyncTransport::read() {
       }
       co_return;
     }
-    XCHECK(readCallback_);
+    PRX_CHECK(readCallback_);
     if (auto* body = asBodyEv(*bodyEvent); body && !body->empty()) {
       size = body->chainLength();
       if (readCallback_->isBufferMovable()) {
         readCallback_->readBufferAvailable(body->move());
       } else {
         folly::io::Cursor cursor(body->front());
-        XCHECK(buf);
+        PRX_CHECK(buf);
         cursor.pullAtMost(buf, size);
         readCallback_->readDataAvailable(size);
       }
@@ -153,14 +153,14 @@ void HTTPConnectAsyncTransport::shutdownRead() {
     readCallback->readEOF();
   }
   if (connectStream_->canRead()) {
-    XLOG(DBG4) << "ingressSource_->stopReading from shutdownRead";
+    PRX_VLOG(4) << "ingressSource_->stopReading from shutdownRead";
     connectStream_->ingressSource_->stopReading();
   }
 }
 
 void HTTPConnectAsyncTransport::shutdownWrite() {
   if (writable()) {
-    XLOG(DBG4) << "egressSource_->eom from shutdownWrite";
+    PRX_VLOG(4) << "egressSource_->eom from shutdownWrite";
     connectStream_->egressSource_->eom();
   }
 }
diff --git a/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h b/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h
index 20feaec8f1..d5d33fbf57 100644
--- a/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h
+++ b/proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include <folly/io/async/AsyncTransport.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/coro/transport/HTTPConnectStream.h"
 
@@ -108,10 +108,10 @@ class HTTPConnectAsyncTransport
     return ingressError_ || connectStream_->egressError_;
   }
   void attachEventBase(folly::EventBase* /*eventBase*/) override {
-    XLOG(FATAL) << "Cannot change eventBase";
+    PRX_LOG(FATAL) << "Cannot change eventBase";
   }
   void detachEventBase() override {
-    XLOG(FATAL) << "Cannot change eventBase";
+    PRX_LOG(FATAL) << "Cannot change eventBase";
   }
   [[nodiscard]] bool isDetachable() const override {
     return false;
@@ -138,7 +138,7 @@ class HTTPConnectAsyncTransport
 
   void setEorTracking(bool track) override {
     if (track) {
-      XLOG(WARNING)
+      PRX_LOG(WARNING)
           << "Cannot enable EOR tracking with HTTPConnectAsyncTransport";
     }
   }
diff --git a/proxygen/lib/http/coro/transport/HTTPConnectStream.cpp b/proxygen/lib/http/coro/transport/HTTPConnectStream.cpp
index c9209c20c2..9f3fc48120 100644
--- a/proxygen/lib/http/coro/transport/HTTPConnectStream.cpp
+++ b/proxygen/lib/http/coro/transport/HTTPConnectStream.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/transport/HTTPConnectStream.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -110,8 +110,8 @@ folly::coro::Task<void> HTTPConnectStream::connectImpl(
         peerAddr.setFromIpPort(upstreamAddress, upstreamPort);
         peerAddr_ = std::move(peerAddr);
       } catch (const std::exception& ex) {
-        XLOG(ERR) << "Upstream returned invalid X-Connected-To: "
-                  << upstreamAddress << " err=" << ex.what();
+        PRX_LOG(ERROR) << "Upstream returned invalid X-Connected-To: "
+                       << upstreamAddress << " err=" << ex.what();
       }
     }
     break; // meh
diff --git a/proxygen/lib/http/coro/transport/HTTPConnectTransport.cpp b/proxygen/lib/http/coro/transport/HTTPConnectTransport.cpp
index b363ed0f46..c85e348e55 100644
--- a/proxygen/lib/http/coro/transport/HTTPConnectTransport.cpp
+++ b/proxygen/lib/http/coro/transport/HTTPConnectTransport.cpp
@@ -7,7 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/transport/HTTPConnectTransport.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::AsyncSocketException;
 using AsyncSocketExceptionType =
@@ -45,7 +45,7 @@ void HTTPConnectTransport::scheduleAsyncRead(
       .startInlineUnsafe(
           [this, ingressSource, deleted = deleted_](
               folly::Try<HTTPBodyEvent> maybeBodyEvent) {
-            XLOG(DBG6) << "async readBodyEvent done";
+            PRX_VLOG(6) << "async readBodyEvent done";
             if (*deleted) {
               return;
             }
@@ -55,7 +55,7 @@ void HTTPConnectTransport::scheduleAsyncRead(
               maybeBodyEvent.emplaceException(AsyncSocketException(
                   AsyncSocketException::INTERNAL_ERROR, httpErr.describe()));
             }
-            XCHECK(bodyEvents_.try_enqueue(std::move(maybeBodyEvent)));
+            PRX_CHECK(bodyEvents_.try_enqueue(std::move(maybeBodyEvent)));
             pendingRead_ = false;
           },
           ct);
@@ -95,7 +95,7 @@ folly::coro::Task<size_t> HTTPConnectTransport::read(
         auto timeoutEx = folly::Try<HTTPBodyEvent>(
             AsyncSocketException(AsyncSocketException::TIMED_OUT,
                                  "Timed out waiting for body event"));
-        XCHECK(transportRef_.bodyEvents_.try_enqueue(std::move(timeoutEx)));
+        PRX_CHECK(transportRef_.bodyEvents_.try_enqueue(std::move(timeoutEx)));
       }
     }
 
@@ -204,7 +204,7 @@ folly::coro::Task<folly::Unit> HTTPConnectTransport::write(
   auto flowState =
       connectStream_->egressSource_->body(std::move(buf), 0, pendingEOM_);
   if (flowState != HTTPStreamSource::FlowControlState::OPEN) {
-    XLOG(DBG4) << "Blocking writes";
+    PRX_VLOG(4) << "Blocking writes";
     flowControlWindowOpen_.reset();
   }
   if (writeInfo) {
@@ -214,7 +214,7 @@ folly::coro::Task<folly::Unit> HTTPConnectTransport::write(
 }
 
 void HTTPConnectTransport::windowOpen(HTTPCodec::StreamID /*id*/) {
-  XLOG(DBG4) << "Resuming writes";
+  PRX_VLOG(4) << "Resuming writes";
   flowControlWindowOpen_.signal();
 }
 
diff --git a/proxygen/lib/http/coro/transport/test/Client.cpp b/proxygen/lib/http/coro/transport/test/Client.cpp
index 22ecc6ffe4..b5288806ec 100644
--- a/proxygen/lib/http/coro/transport/test/Client.cpp
+++ b/proxygen/lib/http/coro/transport/test/Client.cpp
@@ -11,6 +11,7 @@
 #include <folly/io/async/EventBase.h>
 #include <folly/portability/GFlags.h>
 #include <iostream>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen::coro;
 
@@ -19,12 +20,12 @@ class Callback : public folly::AsyncSocket::ConnectCallback {
   bool connected{false};
 
   void connectSuccess() noexcept override {
-    XLOG(INFO) << "Connected";
+    PRX_LOG(INFO) << "Connected";
     connected = true;
   }
 
   void connectErr(const folly::AsyncSocketException& ex) noexcept override {
-    XLOG(ERR) << "Connect failed: " << ex.what();
+    PRX_LOG(ERROR) << "Connect failed: " << ex.what();
   }
 };
 
@@ -33,7 +34,7 @@ int main(int argc, char** argv) {
   ::gflags::ParseCommandLineFlags(&argc, &argv, false);
 
   if (argc < 2) {
-    XLOG(ERR) << "Usage: async_ssl_transport_client server[:port]";
+    PRX_LOG(ERROR) << "Usage: async_ssl_transport_client server[:port]";
     return 1;
   }
 
diff --git a/proxygen/lib/http/coro/transport/test/CoroSSLTransportTest.cpp b/proxygen/lib/http/coro/transport/test/CoroSSLTransportTest.cpp
index 5ea9ad3fc8..6875dc48d3 100644
--- a/proxygen/lib/http/coro/transport/test/CoroSSLTransportTest.cpp
+++ b/proxygen/lib/http/coro/transport/test/CoroSSLTransportTest.cpp
@@ -20,6 +20,7 @@
 #include <folly/testing/TestUtil.h>
 
 #include "proxygen/lib/http/coro/transport/test/TestCoroTransport.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace std::chrono_literals;
 using namespace folly;
@@ -462,7 +463,7 @@ TEST_F(CoroSSLTransportTest, WriteCancelled) {
     auto cs = co_await connect();
     // reduce the send buffer size so the write wouldn't complete immediately
     auto asyncSocket = dynamic_cast<folly::AsyncSocket*>(cs->getTransport());
-    XCHECK(asyncSocket);
+    PRX_CHECK(asyncSocket);
     EXPECT_EQ(asyncSocket->setSendBufSize(4096), 0);
 
     constexpr auto kBufSize = 65536;
@@ -624,9 +625,9 @@ namespace {
 
 TestCoroTransport* transportFromBio(BIO* bio) {
   auto appData = OpenSSLUtils::getBioAppData(bio);
-  XCHECK(appData);
+  PRX_CHECK(appData);
   auto* transport = reinterpret_cast<TestCoroTransport*>(appData);
-  XCHECK(transport);
+  PRX_CHECK(transport);
   return transport;
 }
 
@@ -729,13 +730,13 @@ class CoroSSLTransportFakeTest : public TransportTest {
     try {
       ssl_.reset(ctx_->createSSL());
     } catch (std::exception& ex) {
-      XLOG(ERR) << "TestSSLTransport::accept(this=" << this
-                << "): " << ex.what();
+      PRX_LOG(ERROR) << "TestSSLTransport::accept(this=" << this
+                     << "): " << ex.what();
       throw;
     }
 
     if (!setupSSLBio()) {
-      XLOG(ERR) << "TestSSLTransport::accept(this=" << this << "): ";
+      PRX_LOG(ERROR) << "TestSSLTransport::accept(this=" << this << "): ";
       co_return;
     }
 
@@ -747,12 +748,12 @@ class CoroSSLTransportFakeTest : public TransportTest {
           // A bit lame, but meh
           co_await folly::coro::sleep(100ms);
         } else {
-          XLOG(ERR) << "SSL_accept error=" << sslError;
+          PRX_LOG(ERROR) << "SSL_accept error=" << sslError;
           sslAccept_.post();
           break;
         }
       } else {
-        XLOG(INFO) << "accepted";
+        PRX_LOG(INFO) << "accepted";
         sslAccept_.post();
         break;
       }
@@ -904,16 +905,16 @@ TEST_F(CoroSSLTransportFakeTest, WriteFromSSLRead) {
           // A bit lame, but meh
           co_await folly::coro::sleep(100ms);
         } else if (sslError == SSL_ERROR_ZERO_RETURN) {
-          XLOG(ERR) << "SSL_read zer return";
+          PRX_LOG(ERROR) << "SSL_read zer return";
           break;
         } else {
-          XLOG(ERR) << "SSL_read error=" << sslError;
+          PRX_LOG(ERROR) << "SSL_read error=" << sslError;
           break;
         }
       } else {
         serverReadBytes += rc;
-        XLOG(DBG6) << "Server read returned rc=" << rc
-                   << " serverReadBytes=" << serverReadBytes;
+        PRX_VLOG(6) << "Server read returned rc=" << rc
+                    << " serverReadBytes=" << serverReadBytes;
       }
     }
     EXPECT_EQ(serverReadBytes, kBufSize + 1);
diff --git a/proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.cpp b/proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.cpp
index d110583b47..1a9b159017 100644
--- a/proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.cpp
+++ b/proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.cpp
@@ -11,6 +11,7 @@
 
 #include <folly/coro/BlockingWait.h>
 #include <folly/coro/Collect.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace std::chrono_literals;
 using namespace folly;
@@ -42,7 +43,7 @@ class ReadCallback : public AsyncTransport::ReadCallback {
   }
 
   void readDataAvailable(size_t len) noexcept override {
-    XLOG(DBG2) << "readDataAvailable, len " << len;
+    PRX_VLOG(2) << "readDataAvailable, len " << len;
     readBuf_.postallocate(len);
     if (readBuf_.chainLength() >= expectedLen) {
       promise.setValue(folly::Unit());
@@ -62,13 +63,13 @@ class ReadCallback : public AsyncTransport::ReadCallback {
   }
 
   void readErr(const AsyncSocketException& ex) noexcept override {
-    XLOG(DBG2) << "readError " << ex.what();
+    PRX_VLOG(2) << "readError " << ex.what();
     promise.setException(ex);
     eofPromise.setException(std::runtime_error("EOF waiting for data"));
   }
 
   void readEOF() noexcept override {
-    XLOG(DBG2) << "readEOF";
+    PRX_VLOG(2) << "readEOF";
 
     if (!promise.isFulfilled()) {
       promise.setException(std::runtime_error("EOF waiting for data"));
@@ -87,14 +88,14 @@ class ReadCallback : public AsyncTransport::ReadCallback {
 class WriteCallback : public AsyncTransport::WriteCallback {
  public:
   void writeSuccess() noexcept override {
-    XLOG(DBG2) << "writeSuccess";
+    PRX_VLOG(2) << "writeSuccess";
     promise.setValue(folly::Unit());
   }
 
   void writeErr(size_t nBytesWritten,
                 const AsyncSocketException& ex) noexcept override {
-    XLOG(DBG2) << "writeError: bytesWritten " << nBytesWritten << ", exception "
-               << ex.what();
+    PRX_VLOG(2) << "writeError: bytesWritten " << nBytesWritten
+                << ", exception " << ex.what();
     promise.setException(ex);
   }
 
@@ -412,8 +413,8 @@ TEST_F(HTTPConnectTransportTest, ReadAfterReadTimeout) {
      */
     auto read_res = co_await folly::coro::co_awaitTry(cs->read(
         MutableByteRange(buf.data(), (buf.data() + buf.size())), 50ms));
-    auto asyncSocketEx =
-        CHECK_NOTNULL(read_res.tryGetExceptionObject<AsyncSocketException>());
+    auto asyncSocketEx = PRX_CHECK_NOTNULL(
+        read_res.tryGetExceptionObject<AsyncSocketException>());
     EXPECT_EQ(asyncSocketEx->getType(), AsyncSocketException::TIMED_OUT);
 
     // instruct server to send response & h2 eom together
@@ -437,7 +438,7 @@ TEST_F(HTTPConnectTransportTest, ReadAfterReadTimeout) {
     read_res = co_await folly::coro::co_awaitTry(cs->read(
         MutableByteRange(buf.data(), (buf.data() + buf.size())), 50ms));
 
-    XCHECK(!read_res.hasException());
+    PRX_CHECK(!read_res.hasException());
     EXPECT_GT(read_res.value(), 0);
     sess->setSessionStats(nullptr);
 
diff --git a/proxygen/lib/http/coro/transport/test/TestCoroTransport.cpp b/proxygen/lib/http/coro/transport/test/TestCoroTransport.cpp
index d2e0556716..87f2c9e017 100644
--- a/proxygen/lib/http/coro/transport/test/TestCoroTransport.cpp
+++ b/proxygen/lib/http/coro/transport/test/TestCoroTransport.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/coro/transport/test/TestCoroTransport.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 using TransportErrorCode = folly::coro::TransportIf::ErrorCode;
 
@@ -20,7 +21,7 @@ folly::coro::Task<size_t> TestCoroTransport::read(
     folly::MutableByteRange buf, std::chrono::milliseconds timeout) noexcept {
   const auto &cancelToken = co_await folly::coro::co_current_cancellation_token;
   folly::CancellationCallback cancellationCallback{
-      cancelToken, [&]() { XLOG(DBG8) << "::read() cancelled"; }};
+      cancelToken, [&]() { PRX_VLOG(8) << "::read() cancelled"; }};
 
   while (true) {
     const bool hasError = state_->readError.has_value();
@@ -29,7 +30,7 @@ folly::coro::Task<size_t> TestCoroTransport::read(
     // cancel without data read handled later
     if (hasError && !isCancelErr) {
       auto readError = *state_->readError;
-      XLOG(DBG8) << "::read(); readError=" << readError;
+      PRX_VLOG(8) << "::read(); readError=" << readError;
       if (readError == TransportErrorCode::TIMED_OUT) {
         // Timeouts reset after being read out
         state_->readError = folly::none;
@@ -49,13 +50,13 @@ folly::coro::Task<size_t> TestCoroTransport::read(
       if (readEvent.empty()) {
         state_->readEvents.pop_front();
       }
-      XLOG(DBG8) << "::read(); rc=" << rc;
+      PRX_VLOG(8) << "::read(); rc=" << rc;
       co_return rc;
     } else if (state_->readEOF) {
-      XLOG(DBG8) << "::read(); state_->readEOF";
+      PRX_VLOG(8) << "::read(); state_->readEOF";
       co_return 0;
     } else if (isCancelErr) {
-      XLOG(DBG8) << "::read(); readError=" << *state_->readError;
+      PRX_VLOG(8) << "::read(); readError=" << *state_->readError;
       co_yield folly::coro::co_stopped_may_throw;
     } else {
       readEvent_.reset();
@@ -66,7 +67,7 @@ folly::coro::Task<size_t> TestCoroTransport::read(
                  !state_->readError) {
         state_->readError = TransportErrorCode::CANCELED;
       }
-      XLOG(DBG8) << "::read(); readEvent_.wait() status=" << int(status);
+      PRX_VLOG(8) << "::read(); readEvent_.wait() status=" << int(status);
     }
   }
   // unreachable
@@ -79,7 +80,7 @@ folly::coro::Task<size_t> TestCoroTransport::read(
     size_t minReadSize,
     size_t newAllocationSize,
     std::chrono::milliseconds timeout) noexcept {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   static const size_t kMaxReadsPerEvent = 16;
   size_t numReads = 0;
   size_t totalRead = 0;
@@ -179,12 +180,12 @@ folly::coro::Task<folly::Unit> TestCoroTransport::write(
 }
 
 void TestCoroTransport::shutdownWrite() {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   state_->writesClosed = true;
 }
 
 void TestCoroTransport::close() {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   state_->writesClosed = true;
   if (!state_->closedWithReset) {
     state_->readEOF = true;
@@ -193,7 +194,7 @@ void TestCoroTransport::close() {
 }
 
 void TestCoroTransport::closeWithReset() {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   state_->writesClosed = true;
   state_->readError = TransportErrorCode::NETWORK_ERROR;
   state_->closedWithReset = true;
@@ -202,7 +203,7 @@ void TestCoroTransport::closeWithReset() {
 
 void TestCoroTransport::addReadEvent(std::unique_ptr<folly::IOBuf> ev,
                                      bool eof) {
-  XLOG(DBG8) << __func__ << "; ev=" << ev.get() << "; eof=" << int(eof);
+  PRX_VLOG(8) << __func__ << "; ev=" << ev.get() << "; eof=" << int(eof);
   folly::IOBufQueue bufQueue{folly::IOBufQueue::cacheChainLength()};
   if (ev) {
     bufQueue.append(std::move(ev));
@@ -215,18 +216,18 @@ void TestCoroTransport::addReadEvent(std::unique_ptr<folly::IOBuf> ev,
 }
 
 void TestCoroTransport::pauseWrites() {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   writesPaused_ = true;
 }
 
 void TestCoroTransport::resumeWrites() {
-  XLOG(DBG8) << __func__;
+  PRX_VLOG(8) << __func__;
   writesPaused_ = false;
   writeEvent_.signal();
 }
 
 void TestCoroTransport::addReadError(TransportErrorCode err) {
-  XLOG(DBG8) << __func__ << "; err=" << err;
+  PRX_VLOG(8) << __func__ << "; err=" << err;
   state_->readError = err;
   readEvent_.signal();
 }
diff --git a/proxygen/lib/http/coro/util/AwaitableKeepAlive.h b/proxygen/lib/http/coro/util/AwaitableKeepAlive.h
index 524d682adf..43eff1b826 100644
--- a/proxygen/lib/http/coro/util/AwaitableKeepAlive.h
+++ b/proxygen/lib/http/coro/util/AwaitableKeepAlive.h
@@ -10,7 +10,7 @@
 
 #include <folly/coro/Baton.h>
 #include <folly/coro/Task.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::detail {
 
@@ -40,12 +40,12 @@ struct KeepAliveState {
   void keepAliveAcquired() {
     uint64_t prevCount = refCount_.fetch_add(1, std::memory_order_relaxed);
     // 0->1 refcount is a logical uaf; abort
-    XCHECK_GE(prevCount, 1ull) << "use after free";
+    PRX_CHECK_GE(prevCount, 1ull) << "use after free";
   }
 
   void keepAliveReleased() {
     uint64_t prevCount = refCount_.fetch_sub(1, std::memory_order_relaxed);
-    XCHECK_GE(prevCount, 1ull) << "underflow";
+    PRX_CHECK_GE(prevCount, 1ull) << "underflow";
     if (prevCount == 1) {
       refsBaton_.post();
     }
@@ -148,7 +148,7 @@ class KeepAlivePtr {
  private:
   friend class EnableAwaitableKeepAlive<T>;
   explicit KeepAlivePtr(KeepAliveState<T>* keepAliveState)
-      : keepAliveState_(CHECK_NOTNULL(keepAliveState)) {
+      : keepAliveState_(PRX_CHECK_NOTNULL(keepAliveState)) {
     // increment refcount
     keepAliveState_->keepAliveAcquired();
   }
diff --git a/proxygen/lib/http/coro/util/CMakeLists.txt b/proxygen/lib/http/coro/util/CMakeLists.txt
index a09b6e6010..fa92ee92e8 100644
--- a/proxygen/lib/http/coro/util/CMakeLists.txt
+++ b/proxygen/lib/http/coro/util/CMakeLists.txt
@@ -8,12 +8,12 @@
 
 proxygen_add_library(proxygen_http_coro_util_timed_baton
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_cancellation_token
     Folly::folly_coro_baton
     Folly::folly_coro_task
     Folly::folly_io_async_async_base
     Folly::folly_io_async_destructor_check
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_util_cancellable_baton
@@ -21,28 +21,28 @@ proxygen_add_library(proxygen_http_coro_util_cancellable_baton
     CancellableBaton.cpp
   EXPORTED_DEPS
     proxygen_http_coro_util_timed_baton
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_util_awaitable_keepalive
   EXPORTED_DEPS
     proxygen_http_coro_util_cancellable_baton
+    proxygen_utils_log_shim
     Folly::folly_coro_baton
     Folly::folly_coro_task
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_coro_util_window_contiainer
   EXPORTED_DEPS
     proxygen_http_window
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_util_DetachableExecutor
   SRCS
     DetachableExecutor.cpp
-  DEPS
-    Folly::folly_logging_logging
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_intrusive_list
     Folly::folly_io_async_async_base
 )
@@ -51,9 +51,9 @@ proxygen_add_library(proxygen_http_coro_util_Transport
   SRCS
     Transport.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_base
     Folly::folly_io_coro_transport_callbacks
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     Folly::folly_io_coro_socket
 )
@@ -63,14 +63,15 @@ proxygen_add_library(proxygen_http_coro_util_executor_source_filter
     ExecutorSourceFilter.cpp
   EXPORTED_DEPS
     proxygen_coro_source
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_coro_util_CoroWtSession
   SRCS
     CoroWtSession.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_coro_socket
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_coro_source
     proxygen_http_codec_webtransport_webtransport_capsule_codec
diff --git a/proxygen/lib/http/coro/util/CancellableBaton.cpp b/proxygen/lib/http/coro/util/CancellableBaton.cpp
index c9aed699b2..c884af645d 100644
--- a/proxygen/lib/http/coro/util/CancellableBaton.cpp
+++ b/proxygen/lib/http/coro/util/CancellableBaton.cpp
@@ -7,11 +7,12 @@
  */
 
 #include "proxygen/lib/http/coro/util/CancellableBaton.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::detail {
 
 void CancellableBaton::signal(TimedBaton::Status status) noexcept {
-  XLOG(DBG8) << __func__ << " signalled; status=" << int(status);
+  PRX_VLOG(8) << __func__ << " signalled; status=" << int(status);
   // only resolve status for the first signaller
   auto* pStatus = std::exchange(status_, nullptr);
   if (pStatus && *pStatus == TimedBaton::Status::notReady) {
@@ -21,7 +22,7 @@ void CancellableBaton::signal(TimedBaton::Status status) noexcept {
 }
 
 folly::coro::Task<TimedBaton::Status> CancellableBaton::wait() noexcept {
-  XCHECK_EQ(status_, nullptr) << "supports only one awaiting coro";
+  PRX_CHECK_EQ(status_, nullptr) << "supports only one awaiting coro";
 
   TimedBaton::Status status = TimedBaton::Status::notReady;
   status_ = &status;
@@ -47,8 +48,8 @@ folly::coro::Task<TimedBaton::Status> CancellableBaton::wait() noexcept {
     status = TimedBaton::Status::signalled;
   }
 
-  XCHECK(status == TimedBaton::Status::cancelled ||
-         status == TimedBaton::Status::signalled);
+  PRX_CHECK(status == TimedBaton::Status::cancelled ||
+            status == TimedBaton::Status::signalled);
 
   co_return ct.isCancellationRequested() ? TimedBaton::Status::cancelled
                                          : status;
@@ -57,8 +58,8 @@ folly::coro::Task<TimedBaton::Status> CancellableBaton::wait() noexcept {
 folly::coro::Task<TimedBaton::Status> CancellableBaton::timedWaitImpl(
     folly::EventBase* evb, std::chrono::milliseconds timeout) {
   // > 0ms timeout must have evb
-  XCHECK(evb && timeout.count() > 0);
-  XCHECK_EQ(status_, nullptr) << "supports only one awaiting coro";
+  PRX_CHECK(evb && timeout.count() > 0);
+  PRX_CHECK_EQ(status_, nullptr) << "supports only one awaiting coro";
 
   TimedBaton::Status status{TimedBaton::Status::notReady};
   status_ = &status;
diff --git a/proxygen/lib/http/coro/util/CancellableBaton.h b/proxygen/lib/http/coro/util/CancellableBaton.h
index 11ea5cafeb..f0f91d83f8 100644
--- a/proxygen/lib/http/coro/util/CancellableBaton.h
+++ b/proxygen/lib/http/coro/util/CancellableBaton.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "proxygen/lib/http/coro/util/TimedBaton.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::detail {
 
@@ -24,7 +25,7 @@ class CancellableBaton {
   CancellableBaton(CancellableBaton&&) = delete;
   CancellableBaton& operator=(CancellableBaton&&) = delete;
   ~CancellableBaton() {
-    XCHECK_EQ(status_, nullptr);
+    PRX_CHECK_EQ(status_, nullptr);
   }
 
   // wait indefinitely until ::signal is called or cancellation requested
@@ -38,7 +39,7 @@ class CancellableBaton {
   }
 
   void reset() {
-    XLOG(DBG8) << __func__;
+    PRX_VLOG(8) << __func__;
     status_ = nullptr;
     baton_.reset();
   }
diff --git a/proxygen/lib/http/coro/util/CoroWtSession.cpp b/proxygen/lib/http/coro/util/CoroWtSession.cpp
index 39c0abd907..e900d75de3 100644
--- a/proxygen/lib/http/coro/util/CoroWtSession.cpp
+++ b/proxygen/lib/http/coro/util/CoroWtSession.cpp
@@ -7,8 +7,8 @@
  */
 
 #include <folly/io/coro/Transport.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/coro/util/CoroWtSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -70,7 +70,7 @@ folly::coro::Task<void> CoroWtSession::readLoop(Ptr self) {
                                               /*newAllocationSize=*/4000,
                                               /*timeout=*/config_.readTimeout));
     if (readRes.hasException()) {
-      XLOG(DBG4) << __func__ << "; ex=" << readRes.exception();
+      PRX_VLOG(4) << __func__ << "; ex=" << readRes.exception();
       break;
     }
 
@@ -90,7 +90,7 @@ folly::coro::Task<void> CoroWtSession::readLoop(Ptr self) {
       break;
     }
   }
-  XLOG(DBG4) << "CoroWtSession::readLoop exiting";
+  PRX_VLOG(4) << "CoroWtSession::readLoop exiting";
   sm.shutdown(WtStreamManager::CloseSession{.err = 0x00,
                                             .msg = "stream ingress closed"});
   readLoopFinished();
@@ -103,11 +103,11 @@ folly::coro::Task<void> CoroWtSession::writeLoop(Ptr self) {
 
   while (!eventVisitor.sessionClosed) {
     // wait for WtStreamManager control events or writable streams
-    XLOG(DBG6) << "waiting for WtStreamManager event";
+    PRX_VLOG(6) << "waiting for WtStreamManager event";
     co_await waitForEventBaton.wait();
     waitForEventBaton.reset();
 
-    XLOG(DBG6) << "received WtStreamManager event";
+    PRX_VLOG(6) << "received WtStreamManager event";
     // always write control frames first
     auto ctrl = sm.moveEvents();
     for (auto& ev : ctrl) {
@@ -138,13 +138,13 @@ folly::coro::Task<void> CoroWtSession::writeLoop(Ptr self) {
       auto writeRes = co_await co_awaitTry(
           transport_->write(egressBuf, config_.writeTimeout));
       if (writeRes.hasException()) {
-        XLOG(DBG4) << __func__ << "; ex=" << writeRes.exception();
+        PRX_VLOG(4) << __func__ << "; ex=" << writeRes.exception();
         break;
       }
     }
   }
 
-  XLOG(DBG4) << "CoroWtSession::writeLoop exiting";
+  PRX_VLOG(4) << "CoroWtSession::writeLoop exiting";
   transport_->shutdownWrite();
   writeLoopFinished();
   co_return;
@@ -283,23 +283,23 @@ class HttpSourceTransport : public folly::coro::TransportIf {
                                        folly::WriteFlags,
                                        WriteInfo* info) noexcept override {
     if (callback_.ex) {
-      XLOG(DBG4) << "id=" << getId() << "; ex=" << callback_.ex.what();
+      PRX_VLOG(4) << "id=" << getId() << "; ex=" << callback_.ex.what();
       co_yield co_error(makeSocketEx(AsyncSocketExceptionType::NOT_OPEN,
                                      callback_.ex.what()));
     }
     auto bytesAvailable = egressSource_->window().getNonNegativeSize();
-    XLOG(DBG4) << "id=" << getId() << "; bytesAvailable=" << bytesAvailable;
+    PRX_VLOG(4) << "id=" << getId() << "; bytesAvailable=" << bytesAvailable;
     if (bytesAvailable == 0) {
-      XLOG(DBG5) << __func__ << " egress blocked";
+      PRX_VLOG(5) << __func__ << " egress blocked";
       callback_.waitForEgress.reset(); // suspend until egress drained
     }
     auto res = co_await callback_.waitForEgress.timedWait(evb_, timeout);
     if (res == TimedBaton::Status::timedout) {
-      XLOG(DBG6) << "id=" << getId() << "; ingress timeout";
+      PRX_VLOG(6) << "id=" << getId() << "; ingress timeout";
       co_yield co_error(makeSocketEx(AsyncSocketExceptionType::TIMED_OUT));
     }
     if (res == TimedBaton::Status::cancelled) {
-      XLOG(DBG6) << "id=" << getId() << "; cancelled";
+      PRX_VLOG(6) << "id=" << getId() << "; cancelled";
       co_yield co_error(makeSocketEx(AsyncSocketExceptionType::CANCELED));
     }
     auto len = ioBufQueue.chainLength();
@@ -329,17 +329,17 @@ class HttpSourceTransport : public folly::coro::TransportIf {
                                        std::chrono::milliseconds,
                                        folly::WriteFlags,
                                        WriteInfo*) noexcept override {
-    XLOG(FATAL) << "not implemented";
+    PRX_LOG(FATAL) << "not implemented";
   }
   folly::coro::Task<size_t> read(folly::MutableByteRange,
                                  std::chrono::milliseconds) noexcept override {
-    XLOG(FATAL) << "not implemented";
+    PRX_LOG(FATAL) << "not implemented";
   }
   folly::SocketAddress getLocalAddress() const noexcept override {
-    XLOG(FATAL) << "not implemented";
+    PRX_LOG(FATAL) << "not implemented";
   }
   folly::SocketAddress getPeerAddress() const noexcept override {
-    XLOG(FATAL) << "not implemented";
+    PRX_LOG(FATAL) << "not implemented";
   }
 
  private:
diff --git a/proxygen/lib/http/coro/util/DetachableExecutor.cpp b/proxygen/lib/http/coro/util/DetachableExecutor.cpp
index 7fde93e77b..fc383dc934 100644
--- a/proxygen/lib/http/coro/util/DetachableExecutor.cpp
+++ b/proxygen/lib/http/coro/util/DetachableExecutor.cpp
@@ -8,23 +8,23 @@
 
 #include "proxygen/lib/http/coro/util/DetachableExecutor.h"
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::detail {
 
 void DetachableExecutor::add(folly::Func fn) {
-  XLOG(DBG8) << __func__ << "; pEvb_=" << pEvb_;
+  PRX_VLOG(8) << __func__ << "; pEvb_=" << pEvb_;
   // must be "attached" and running in evb thread
-  XCHECK(pEvb_ && pEvb_->isInEventBaseThread());
+  PRX_CHECK(pEvb_ && pEvb_->isInEventBaseThread());
   auto loopCallback = std::make_unique<LoopCallback>(std::move(fn));
   fnList_.push_back(*loopCallback);
   pEvb_->runInLoop(loopCallback.release()); // deleted after invocation
 }
 
 void DetachableExecutor::detachEvb() {
-  XLOG(DBG8) << __func__ << "; pEvb_=" << pEvb_;
-  XCHECK(pEvb_->isInEventBaseThread());
-  XCHECK_EQ(state_, State::Detachable);
+  PRX_VLOG(8) << __func__ << "; pEvb_=" << pEvb_;
+  PRX_CHECK(pEvb_->isInEventBaseThread());
+  PRX_CHECK_EQ(state_, State::Detachable);
   pEvb_ = nullptr;
   for (auto& loopCallback : fnList_) {
     loopCallback.cancelLoopCallback();
@@ -32,8 +32,8 @@ void DetachableExecutor::detachEvb() {
 }
 
 void DetachableExecutor::attachEvb(folly::EventBase* evb) {
-  XLOG(DBG8) << __func__ << "; evb=" << evb;
-  XCHECK(evb->isInEventBaseThread());
+  PRX_VLOG(8) << __func__ << "; evb=" << evb;
+  PRX_CHECK(evb->isInEventBaseThread());
   pEvb_ = evb;
   for (auto& loopCallback : fnList_) {
     pEvb_->runInLoop(&loopCallback);
diff --git a/proxygen/lib/http/coro/util/DetachableExecutor.h b/proxygen/lib/http/coro/util/DetachableExecutor.h
index 659b8b8aa4..bf0dcb63e2 100644
--- a/proxygen/lib/http/coro/util/DetachableExecutor.h
+++ b/proxygen/lib/http/coro/util/DetachableExecutor.h
@@ -10,6 +10,7 @@
 
 #include <folly/IntrusiveList.h>
 #include <folly/io/async/EventBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::detail {
 
@@ -24,7 +25,7 @@ namespace proxygen::coro::detail {
 class DetachableExecutor : public folly::Executor {
  public:
   explicit DetachableExecutor(folly::EventBase* pEvb)
-      : pEvb_(CHECK_NOTNULL(pEvb)) {
+      : pEvb_(PRX_CHECK_NOTNULL(pEvb)) {
   }
   /**
    * DetachableGuard should only be acquired in strategic suspension points
diff --git a/proxygen/lib/http/coro/util/ExecutorSourceFilter.h b/proxygen/lib/http/coro/util/ExecutorSourceFilter.h
index 41116e5cbd..fb2b8d45e3 100644
--- a/proxygen/lib/http/coro/util/ExecutorSourceFilter.h
+++ b/proxygen/lib/http/coro/util/ExecutorSourceFilter.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "proxygen/lib/http/coro/HTTPSourceFilter.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -21,7 +22,7 @@ namespace proxygen::coro {
 class ExecutorSourceFilter : public HTTPSourceFilter {
  public:
   static std::unique_ptr<HTTPSourceFilter> make(folly::EventBase* evb) {
-    auto* executorSource = new ExecutorSourceFilter(*CHECK_NOTNULL(evb));
+    auto* executorSource = new ExecutorSourceFilter(*PRX_CHECK_NOTNULL(evb));
     executorSource->setHeapAllocated();
     return std::unique_ptr<HTTPSourceFilter>(executorSource);
   }
diff --git a/proxygen/lib/http/coro/util/Refcount.h b/proxygen/lib/http/coro/util/Refcount.h
index d559a5fa04..af67d220de 100644
--- a/proxygen/lib/http/coro/util/Refcount.h
+++ b/proxygen/lib/http/coro/util/Refcount.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "proxygen/lib/http/coro/util/CancellableBaton.h"
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -32,7 +32,7 @@ class Refcount {
   }
 
   void decRef() {
-    XCHECK_GT(count_, 0UL);
+    PRX_CHECK_GT(count_, 0UL);
     if (--count_ == 0) {
       baton_.signal();
     }
diff --git a/proxygen/lib/http/coro/util/TimedBaton.h b/proxygen/lib/http/coro/util/TimedBaton.h
index 818f615b8a..c79f8b381d 100644
--- a/proxygen/lib/http/coro/util/TimedBaton.h
+++ b/proxygen/lib/http/coro/util/TimedBaton.h
@@ -13,7 +13,7 @@
 #include <folly/coro/Task.h>
 #include <folly/io/async/DestructorCheck.h>
 #include <folly/io/async/EventBase.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -41,14 +41,14 @@ class TimedBaton
   enum class Status : uint8_t { notReady, signalled, timedout, cancelled };
 
   void signal(Status status = Status::signalled) {
-    XCHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+    PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
     if (status == status_) {
       return;
     }
     cancelTimeout();
     if (status_ != Status::notReady && status_ != Status::signalled) {
-      XLOG(DBG4) << "Ignoring TimedBaton signal while in error state="
-                 << uint32_t(status_);
+      PRX_VLOG(4) << "Ignoring TimedBaton signal while in error state="
+                  << uint32_t(status_);
     } else {
       status_ = status;
     }
@@ -64,7 +64,7 @@ class TimedBaton
   }
 
   void reset() {
-    XCHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+    PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
     status_ = Status::notReady;
     baton_.reset();
   }
@@ -74,11 +74,12 @@ class TimedBaton
   }
 
   void setTimeout(std::chrono::milliseconds timeout) {
-    XCHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+    PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
     timeout_ = timeout;
     if (waiting_ > 0) {
       if (timeout_.count() > 0) {
-        XCHECK(eventBase_) << "Must provide an event base when timeout is set";
+        PRX_CHECK(eventBase_)
+            << "Must provide an event base when timeout is set";
         eventBase_->timer().scheduleTimeout(this, timeout_);
       } else {
         cancelTimeout();
@@ -87,7 +88,7 @@ class TimedBaton
   }
 
   folly::coro::Task<Status> wait() noexcept {
-    XCHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+    PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
     const auto& cancelToken =
         co_await folly::coro::co_current_cancellation_token;
     if (cancelToken.isCancellationRequested()) {
@@ -108,7 +109,7 @@ class TimedBaton
           });
         }};
     if (timeout_.count() > 0 && !baton_.ready()) {
-      XCHECK(eventBase_) << "Must provide an event base when timeout is set";
+      PRX_CHECK(eventBase_) << "Must provide an event base when timeout is set";
       eventBase_->timer().scheduleTimeout(this, timeout_);
     }
     waiting_++;
@@ -123,7 +124,7 @@ class TimedBaton
 
   ~TimedBaton() override {
     // must be destructed in evb thread
-    XCHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+    PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
     *destroyed_ = true;
     if (status_ == Status::notReady) {
       signal(Status::cancelled);
@@ -132,7 +133,7 @@ class TimedBaton
 
  protected:
   void timeoutExpired() noexcept override {
-    XLOG(DBG6) << "in TimedBaton timeout expired";
+    PRX_VLOG(6) << "in TimedBaton timeout expired";
     status_ = Status::timedout;
     baton_.post();
   }
diff --git a/proxygen/lib/http/coro/util/Transport.cpp b/proxygen/lib/http/coro/util/Transport.cpp
index 4dc67d3e3b..7a0cbdfcd8 100644
--- a/proxygen/lib/http/coro/util/Transport.cpp
+++ b/proxygen/lib/http/coro/util/Transport.cpp
@@ -8,15 +8,15 @@
 
 #include <folly/io/async/EventBase.h>
 #include <folly/io/coro/TransportCallbacks.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/coro/util/Transport.h"
 
 namespace proxygen::coro::detail {
 
 void Transport::detachEventBase() {
-  XCHECK(eventBase_->isInEventBaseThread());
-  XCHECK_EQ(readCB_, nullptr);
+  PRX_CHECK(eventBase_->isInEventBaseThread());
+  PRX_CHECK_EQ(readCB_, nullptr);
   /**
    * static_cast<folly::coro::ReadCallback> necessary to ::cancelTimeout below
    * and ::rescheduleTimeout in attachEventBase. This is ok because the contract
@@ -25,7 +25,7 @@ void Transport::detachEventBase() {
    */
   readCB_ =
       static_cast<folly::coro::ReadCallback*>(transport_->getReadCallback());
-  XLOG(DBG6) << __func__ << "; readCB_=" << readCB_;
+  PRX_VLOG(6) << __func__ << "; readCB_=" << readCB_;
   transport_->setReadCB(nullptr); // ok if already uninstalled
   if (readCB_) {
     readCB_->cancelTimeout();
@@ -34,7 +34,7 @@ void Transport::detachEventBase() {
 }
 
 void Transport::attachEventBase(folly::EventBase* evb) {
-  XLOG(DBG6) << __func__ << "; readCB_=" << readCB_;
+  PRX_VLOG(6) << __func__ << "; readCB_=" << readCB_;
   eventBase_ = evb;
   transport_->attachEventBase(evb);
   if (auto* readCB = std::exchange(readCB_, nullptr)) {
diff --git a/proxygen/lib/http/coro/util/WindowContainer.h b/proxygen/lib/http/coro/util/WindowContainer.h
index 0fa98b96a9..c86b8db668 100644
--- a/proxygen/lib/http/coro/util/WindowContainer.h
+++ b/proxygen/lib/http/coro/util/WindowContainer.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/Window.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro {
 
@@ -29,8 +29,8 @@ class WindowContainer {
   }
 
   size_t processed(size_t amount) {
-    XCHECK_LE(amount, std::numeric_limits<uint32_t>::max());
-    XCHECK(recvWindow_.free(uint32_t(amount)));
+    PRX_CHECK_LE(amount, std::numeric_limits<uint32_t>::max());
+    PRX_CHECK(recvWindow_.free(uint32_t(amount)));
     recvToAck_ += amount;
     size_t ret = 0;
     if (recvToAck_ >= kMinThreshold ||
@@ -43,12 +43,12 @@ class WindowContainer {
 
   uint32_t setCapacity(uint32_t capacity) {
     if (capacity < recvWindow_.getCapacity()) {
-      XLOG(ERR) << "Can't shrink window capacity " << capacity << " < "
-                << recvWindow_.getCapacity();
+      PRX_LOG(ERROR) << "Can't shrink window capacity " << capacity << " < "
+                     << recvWindow_.getCapacity();
       return 0;
     } else {
       uint32_t delta = capacity - recvWindow_.getCapacity();
-      XCHECK(recvWindow_.setCapacity(capacity)) << "setCapacity overflow";
+      PRX_CHECK(recvWindow_.setCapacity(capacity)) << "setCapacity overflow";
       return delta;
     }
   }
diff --git a/proxygen/lib/http/coro/util/test/AwaitableKeepAliveTest.cpp b/proxygen/lib/http/coro/util/test/AwaitableKeepAliveTest.cpp
index 54db0b6f76..1b89eef8d5 100644
--- a/proxygen/lib/http/coro/util/test/AwaitableKeepAliveTest.cpp
+++ b/proxygen/lib/http/coro/util/test/AwaitableKeepAliveTest.cpp
@@ -11,6 +11,7 @@
 #include <folly/coro/GmockHelpers.h>
 #include <folly/coro/GtestHelpers.h>
 #include <folly/io/async/ScopedEventBaseThread.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::coro::test {
 
@@ -187,7 +188,7 @@ TEST_F(TestKeepAlive, SimpleMemberAccess) {
   AwaitableNoop obj;
   // default constructed should be empty
   detail::KeepAlivePtr<AwaitableNoop> ka;
-  XCHECK(!ka);
+  PRX_CHECK(!ka);
 
   ka = obj.acquireKeepAlive();
   EXPECT_EQ(ka->val, 0);
diff --git a/proxygen/lib/http/experimental/RFC1867.cpp b/proxygen/lib/http/experimental/RFC1867.cpp
index 871728720b..f5ae5331f5 100644
--- a/proxygen/lib/http/experimental/RFC1867.cpp
+++ b/proxygen/lib/http/experimental/RFC1867.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/experimental/RFC1867.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Logging.h>
 
 using folly::IOBuf;
@@ -69,7 +70,7 @@ std::unique_ptr<IOBuf> RFC1867Codec::onIngress(std::unique_ptr<IOBuf> data) {
             *input_.front(), 0, boundary_.data() + 1, boundary_.length() - 1);
         if (br == BoundaryResult::NO) {
           if (callback_) {
-            LOG(ERROR) << "Invalid starting sequence";
+            PRX_LOG(ERROR) << "Invalid starting sequence";
             callback_->onError();
           }
           state_ = ParserState::ERROR;
@@ -115,7 +116,7 @@ std::unique_ptr<IOBuf> RFC1867Codec::onIngress(std::unique_ptr<IOBuf> data) {
       }
         headerParser_.setParserPaused(false);
         headerParser_.onIngress(*dummyBuf);
-        CHECK(!parseError_);
+        PRX_CHECK(!parseError_);
         state_ = ParserState::HEADERS;
         [[fallthrough]];
 
@@ -128,8 +129,8 @@ std::unique_ptr<IOBuf> RFC1867Codec::onIngress(std::unique_ptr<IOBuf> data) {
         }
         if (parseError_) {
           if (callback_) {
-            LOG(ERROR) << "Error parsing header data: ";
-            VLOG(3) << IOBufPrinter::printHexFolly(input_.front());
+            PRX_LOG(ERROR) << "Error parsing header data: ";
+            PRX_VLOG(3) << IOBufPrinter::printHexFolly(input_.front());
             callback_->onError();
           }
           state_ = ParserState::ERROR;
@@ -142,7 +143,7 @@ std::unique_ptr<IOBuf> RFC1867Codec::onIngress(std::unique_ptr<IOBuf> data) {
         value_.append(result.move());
         if (!value_.empty() && callback_) {
           if (callback_->onFieldData(value_.move(), bytesProcessed_) < 0) {
-            LOG(ERROR) << "Callback returned error";
+            PRX_LOG(ERROR) << "Callback returned error";
             state_ = ParserState::ERROR;
             return nullptr;
           }
@@ -154,8 +155,8 @@ std::unique_ptr<IOBuf> RFC1867Codec::onIngress(std::unique_ptr<IOBuf> data) {
           state_ = ParserState::HEADERS_START;
         } else {
           if (input_.chainLength() > 0) {
-            VLOG(5) << "Trailing input="
-                    << IOBufPrinter::printHexFolly(input_.front());
+            PRX_VLOG(5) << "Trailing input="
+                        << IOBufPrinter::printHexFolly(input_.front());
           }
           return input_.move();
         }
@@ -195,13 +196,13 @@ void RFC1867Codec::onHeadersComplete(HTTPCodec::StreamID /*stream*/,
         } else if (parameter == kFilename) {
           filename = value.str();
         } else if (parameter != kFormData) {
-          LOG(WARNING) << "Ignoring parameter " << parameter << " value \""
-                       << value << '"';
+          PRX_LOG(WARNING) << "Ignoring parameter " << parameter << " value \""
+                           << value << '"';
         }
       });
   if (name.empty()) {
     if (callback_) {
-      LOG(ERROR) << "name empty";
+      PRX_LOG(ERROR) << "name empty";
       callback_->onError();
     }
     state_ = ParserState::ERROR;
@@ -211,7 +212,7 @@ void RFC1867Codec::onHeadersComplete(HTTPCodec::StreamID /*stream*/,
     if (callback_ && callback_->onFieldStart(
                          name, filename, std::move(msg), bytesProcessed_) < 0) {
       field_ = name;
-      LOG(WARNING) << "Callback returned error";
+      PRX_LOG(WARNING) << "Callback returned error";
       state_ = ParserState::ERROR;
     }
   }
@@ -234,7 +235,7 @@ IOBufQueue RFC1867Codec::readToBoundary(bool& foundBoundary) {
       boundaryResult =
           isBoundary(*head, readlen, boundary_.data(), boundary_.length());
       if (boundaryResult == BoundaryResult::YES) {
-        CHECK(readlen < head->length());
+        PRX_CHECK(readlen < head->length());
         bool hasCr = false;
         if (readlen == 0 && pendingCR_) {
           pendingCR_.reset();
@@ -277,7 +278,7 @@ IOBufQueue RFC1867Codec::readToBoundary(bool& foundBoundary) {
     // to result, except maybe the last char if it's a CR.
     if (resultLen > 0 && head->data()[resultLen - 1] == '\r') {
       result.append(input_.split(resultLen - 1));
-      CHECK(!pendingCR_);
+      PRX_CHECK(!pendingCR_);
       pendingCR_ = input_.split(1);
     } else {
       result.append(input_.split(resultLen));
@@ -293,7 +294,7 @@ IOBufQueue RFC1867Codec::readToBoundary(bool& foundBoundary) {
 
 void RFC1867Codec::onIngressEOM() {
   if (state_ == ParserState::FIELD_DATA) {
-    LOG(WARNING) << "Field not terminated by boundary";
+    PRX_LOG(WARNING) << "Field not terminated by boundary";
     if (callback_) {
       callback_->onFieldEnd(false, bytesProcessed_);
     }
@@ -301,7 +302,7 @@ void RFC1867Codec::onIngressEOM() {
   if (state_ != ParserState::HEADERS_START && state_ != ParserState::ERROR &&
       state_ != ParserState::DONE) {
     if (callback_) {
-      LOG(ERROR) << "onIngressEOM with state_=" << (uint8_t)state_;
+      PRX_LOG(ERROR) << "onIngressEOM with state_=" << (uint8_t)state_;
       callback_->onError();
     }
   }
diff --git a/proxygen/lib/http/experimental/RFC1867.h b/proxygen/lib/http/experimental/RFC1867.h
index 61bcb44a0b..bd0f760a87 100644
--- a/proxygen/lib/http/experimental/RFC1867.h
+++ b/proxygen/lib/http/experimental/RFC1867.h
@@ -10,6 +10,7 @@
 
 #include <folly/Conv.h>
 #include <proxygen/lib/http/codec/HTTP1xCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -44,7 +45,7 @@ class RFC1867Codec : HTTPCodec::Callback {
   //
   //   Content-type: multipart/form-data, boundary=AaB03x
   explicit RFC1867Codec(const std::string& boundary) {
-    CHECK(!boundary.empty());
+    PRX_CHECK(!boundary.empty());
     boundary_ = folly::to<std::string>("\n--", boundary);
     headerParser_.setCallback(this);
   }
diff --git a/proxygen/lib/http/experimental/test/RFC1867Test.cpp b/proxygen/lib/http/experimental/test/RFC1867Test.cpp
index bfb330a4ca..eacab6b585 100644
--- a/proxygen/lib/http/experimental/test/RFC1867Test.cpp
+++ b/proxygen/lib/http/experimental/test/RFC1867Test.cpp
@@ -12,6 +12,7 @@
 
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 using folly::IOBuf;
@@ -194,7 +195,7 @@ void RFC1867Base::testSimple(unique_ptr<IOBuf> data,
     // been added
     parsedDataBuf->coalesce();
   }
-  CHECK_EQ(fileLength, fileSize);
+  PRX_CHECK_EQ(fileLength, fileSize);
 }
 
 TEST_F(RFC1867Test, TestSimplePost) {
diff --git a/proxygen/lib/http/observer/CMakeLists.txt b/proxygen/lib/http/observer/CMakeLists.txt
index fabd567057..c24ebaacbf 100644
--- a/proxygen/lib/http/observer/CMakeLists.txt
+++ b/proxygen/lib/http/observer/CMakeLists.txt
@@ -17,7 +17,7 @@ proxygen_add_library(proxygen_http_observer_session_observer_interface
     HTTPSessionObserverInterface.cpp
   EXPORTED_DEPS
     proxygen_http_message
-    glog::glog
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_observer_http_transaction_observer_container
@@ -29,6 +29,8 @@ proxygen_add_library(proxygen_http_observer_http_transaction_observer_container
 proxygen_add_library(proxygen_http_observer_http_transaction_observer_interface
   SRCS
     HTTPTransactionObserverInterface.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_message
     proxygen_utils_time_util
diff --git a/proxygen/lib/http/observer/HTTPSessionObserverInterface.cpp b/proxygen/lib/http/observer/HTTPSessionObserverInterface.cpp
index 7e97925488..1b197c5f88 100644
--- a/proxygen/lib/http/observer/HTTPSessionObserverInterface.cpp
+++ b/proxygen/lib/http/observer/HTTPSessionObserverInterface.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/observer/HTTPSessionObserverInterface.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -39,8 +40,9 @@ HTTPSessionObserverInterface::RequestStartedEvent::Builder::build() && {
 
 HTTPSessionObserverInterface::RequestStartedEvent::RequestStartedEvent(
     const RequestStartedEvent::BuilderFields& builderFields)
-    : timestamp(*CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())),
-      request(*CHECK_NOTNULL(builderFields.maybeRequestRef.get_pointer())),
+    : timestamp(
+          *PRX_CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())),
+      request(*PRX_CHECK_NOTNULL(builderFields.maybeRequestRef.get_pointer())),
       txnObserverAccessor(builderFields.maybeTxnObserverAccessorPtr) {
 }
 
@@ -65,9 +67,10 @@ HTTPSessionObserverInterface::PreWriteEvent::Builder::build() && {
 
 HTTPSessionObserverInterface::PreWriteEvent::PreWriteEvent(
     PreWriteEvent::BuilderFields& builderFields)
-    : pendingEgressBytes(*CHECK_NOTNULL(
+    : pendingEgressBytes(*PRX_CHECK_NOTNULL(
           builderFields.maybePendingEgressBytesRef.get_pointer())),
-      timestamp(*CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())) {
+      timestamp(
+          *PRX_CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())) {
 }
 
 HTTPSessionObserverInterface::PingReplyEvent::Builder&&
@@ -90,8 +93,9 @@ HTTPSessionObserverInterface::PingReplyEvent::Builder::build() && {
 
 HTTPSessionObserverInterface::PingReplyEvent::PingReplyEvent(
     PingReplyEvent::BuilderFields& builderFields)
-    : id(*CHECK_NOTNULL(builderFields.maybeId.get_pointer())),
-      timestamp(*CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())) {
+    : id(*PRX_CHECK_NOTNULL(builderFields.maybeId.get_pointer())),
+      timestamp(
+          *PRX_CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())) {
 }
 
 } // namespace proxygen
diff --git a/proxygen/lib/http/observer/HTTPSessionObserverInterface.h b/proxygen/lib/http/observer/HTTPSessionObserverInterface.h
index 4d8db6c0eb..bdcc0d6197 100644
--- a/proxygen/lib/http/observer/HTTPSessionObserverInterface.h
+++ b/proxygen/lib/http/observer/HTTPSessionObserverInterface.h
@@ -9,8 +9,8 @@
 #pragma once
 #include <chrono>
 #include <cstdint>
-#include <glog/logging.h>
 #include <proxygen/lib/http/HTTPMessage.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <utility>
 
 namespace proxygen {
diff --git a/proxygen/lib/http/observer/HTTPTransactionObserverInterface.cpp b/proxygen/lib/http/observer/HTTPTransactionObserverInterface.cpp
index 168e1c2e50..f7cdebe1ac 100644
--- a/proxygen/lib/http/observer/HTTPTransactionObserverInterface.cpp
+++ b/proxygen/lib/http/observer/HTTPTransactionObserverInterface.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/observer/HTTPTransactionObserverInterface.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -44,7 +45,8 @@ HTTPTransactionObserverInterface::TxnBytesEvent::Builder::build() && {
 
 HTTPTransactionObserverInterface::TxnBytesEvent::TxnBytesEvent(
     const TxnBytesEvent::BuilderFields& builderFields)
-    : timestamp(*CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())),
+    : timestamp(
+          *PRX_CHECK_NOTNULL(builderFields.maybeTimestampRef.get_pointer())),
       type(builderFields.type),
       maybeNumBytes(builderFields.numBytes),
       maybeHeadersRef(builderFields.maybeHeadersRef) {
diff --git a/proxygen/lib/http/session/ByteEventTracker.cpp b/proxygen/lib/http/session/ByteEventTracker.cpp
index 7884866633..9531b59423 100644
--- a/proxygen/lib/http/session/ByteEventTracker.cpp
+++ b/proxygen/lib/http/session/ByteEventTracker.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/session/ByteEventTracker.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -24,7 +25,7 @@ void ByteEventTracker::absorb(ByteEventTracker&& other) {
 bool ByteEventTracker::processByteEvents(std::shared_ptr<ByteEventTracker> self,
                                          uint64_t bytesWritten) {
   // update our local cache of the number of bytes written so far
-  DCHECK(bytesWritten >= bytesWritten_);
+  PRX_DCHECK(bytesWritten >= bytesWritten_);
   bytesWritten_ = bytesWritten;
 
   while (!byteEvents_.empty() &&
@@ -68,7 +69,7 @@ bool ByteEventTracker::processByteEvents(std::shared_ptr<ByteEventTracker> self,
     if (event.callback_) {
       event.callback_(event);
     }
-    VLOG(5) << " removing ByteEvent " << event;
+    PRX_VLOG(5) << " removing ByteEvent " << event;
     // explicitly remove from the list, in case delete event triggers a
     // callback that would absorb this ByteEventTracker.
     byteEvents_.pop_front_and_dispose([](ByteEvent* event) { delete event; });
@@ -90,7 +91,7 @@ size_t ByteEventTracker::drainByteEvents() {
 void ByteEventTracker::addLastByteEvent(HTTPTransaction* txn,
                                         uint64_t byteNo,
                                         ByteEvent::Callback callback) noexcept {
-  VLOG(5) << " adding last byte event for " << byteNo;
+  PRX_VLOG(5) << " adding last byte event for " << byteNo;
   auto* event =
       new TransactionByteEvent(byteNo, ByteEvent::LAST_BYTE, txn, callback);
   byteEvents_.push_back(*event);
@@ -100,7 +101,7 @@ void ByteEventTracker::addTrackedByteEvent(
     HTTPTransaction* txn,
     uint64_t byteNo,
     ByteEvent::Callback callback) noexcept {
-  VLOG(5) << " adding tracked byte event for " << byteNo;
+  PRX_VLOG(5) << " adding tracked byte event for " << byteNo;
   auto* event =
       new TransactionByteEvent(byteNo, ByteEvent::TRACKED_BYTE, txn, callback);
   byteEvents_.push_back(*event);
@@ -116,8 +117,8 @@ void ByteEventTracker::addPingByteEvent(size_t pingSize,
   auto i = byteEvents_.rbegin();
   for (; i != byteEvents_.rend(); ++i) {
     if (i->byteOffset_ > bytesScheduled) {
-      VLOG(5) << "pushing back ByteEvent from " << *i << " to "
-              << ByteEvent(i->byteOffset_ + pingSize, i->eventType_);
+      PRX_VLOG(5) << "pushing back ByteEvent from " << *i << " to "
+                  << ByteEvent(i->byteOffset_ + pingSize, i->eventType_);
       i->byteOffset_ += pingSize;
     } else {
       break; // the rest of the events are already scheduled
@@ -131,7 +132,7 @@ void ByteEventTracker::addPingByteEvent(size_t pingSize,
     byteEvents_.push_back(*be);
   } else {
     --i;
-    CHECK_GT(i->byteOffset_, bytesScheduled);
+    PRX_CHECK_GT(i->byteOffset_, bytesScheduled);
     byteEvents_.insert(i.base(), *be);
   }
 }
diff --git a/proxygen/lib/http/session/CMakeLists.txt b/proxygen/lib/http/session/CMakeLists.txt
index c07e5d6456..4126c798a6 100644
--- a/proxygen/lib/http/session/CMakeLists.txt
+++ b/proxygen/lib/http/session/CMakeLists.txt
@@ -34,6 +34,7 @@ proxygen_add_library(proxygen_http_session_session
     proxygen_http_session_http_session_activity_tracker
     proxygen_http_session_http_transaction
     proxygen_http_session_transaction_byte_events
+    proxygen_utils_log_shim
     proxygen_utils_shared_wheel_timer
     proxygen_utils_time_util
     wangle::wangle_acceptor_acceptor_core
@@ -48,7 +49,6 @@ proxygen_add_library(proxygen_http_session_session
     Folly::folly_io_async_ssl_context
     Folly::folly_io_iobuf
     Folly::folly_optional
-    glog::glog
 )
 
 proxygen_add_library(proxygen_http_session_server
@@ -63,7 +63,6 @@ proxygen_add_library(proxygen_http_session_server
     proxygen_http_session_http_session_codec_factory
     Folly::folly_conv
     Folly::folly_io_iobuf
-    glog::glog
   EXPORTED_DEPS
     proxygen_error
     proxygen_http_codec_codec_factory
@@ -71,6 +70,7 @@ proxygen_add_library(proxygen_http_session_server
     proxygen_http_session_http_transaction
     proxygen_http_session_session
     proxygen_services_http_acceptor
+    proxygen_utils_log_shim
     proxygen_utils_shared_wheel_timer
     Folly::folly_io_async_async_ssl_socket
 )
@@ -98,6 +98,8 @@ proxygen_add_library(proxygen_http_session_byte_events
 proxygen_add_library(proxygen_http_session_transaction_byte_events
   SRCS
     ByteEventTracker.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_session_byte_events
     proxygen_http_session_http_transaction
@@ -118,6 +120,7 @@ proxygen_add_library(proxygen_http_session_http2_priority_queue
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     proxygen_http_codec_http2_codec
+    proxygen_utils_log_shim
     proxygen_utils_shared_wheel_timer
     Folly::folly_intrusive_list
     Folly::folly_io_async_async_base
@@ -129,7 +132,7 @@ proxygen_add_library(proxygen_http_session_http_event
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     proxygen_http_http_utils
-    glog::glog
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_session_http_state_machine_lib
@@ -137,6 +140,7 @@ proxygen_add_library(proxygen_http_session_http_state_machine_lib
     HTTPTransactionEgressSM.cpp
     HTTPTransactionIngressSM.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_indestructible
   EXPORTED_DEPS
     proxygen_utils_state_machine
@@ -153,7 +157,6 @@ proxygen_add_library(proxygen_http_session_http_transaction
     Folly::folly_conv
     Folly::folly_io_async_event_base_manager
     Folly::folly_tracing_scoped_trace_section
-    glog::glog
   EXPORTED_DEPS
     proxygen_error
     proxygen_http_codec_codec_common
@@ -170,6 +173,7 @@ proxygen_add_library(proxygen_http_session_http_transaction
     proxygen_http_webtransport
     proxygen_http_webtransport_webtransportimpl
     proxygen_http_window
+    proxygen_utils_log_shim
     proxygen_utils_shared_wheel_timer
     proxygen_utils_time_util
     proxygen_utils_trace
@@ -186,6 +190,7 @@ proxygen_add_library(proxygen_http_session_http_upstream_session
   SRCS
     HTTPUpstreamSession.cpp
   DEPS
+    proxygen_utils_log_shim
     wangle::wangle_acceptor_managed
     Folly::folly_io_async_async_ssl_socket
   EXPORTED_DEPS
@@ -210,6 +215,7 @@ proxygen_add_library(proxygen_http_session_stream_dispatcher
     HQStreamDispatcher.cpp
   EXPORTED_DEPS
     proxygen_http_codec_hq_codec
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     Folly::folly_io_async_async_base
 )
@@ -245,6 +251,7 @@ proxygen_add_library(proxygen_http_session_hq_session
     proxygen_http_session_stream_dispatcher
     proxygen_http_session_webtransport_filter
     proxygen_utils_conditional_gate
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     mvfst::mvfst_codec_types
     mvfst::mvfst_common_buf_util
@@ -268,6 +275,7 @@ proxygen_add_library(proxygen_http_session_hq_upstream_session
     wangle::wangle_acceptor_managed
   EXPORTED_DEPS
     proxygen_http_session_hq_session
+    proxygen_utils_log_shim
     mvfst::mvfst_common_events_folly_eventbase
     Folly::folly_io_async_async_base
 )
@@ -277,6 +285,7 @@ proxygen_add_library(proxygen_http_session_hq_downstream_session
     HQDownstreamSession.cpp
   EXPORTED_DEPS
     proxygen_http_session_hq_session
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_session_quic_protocol_info
@@ -293,7 +302,7 @@ proxygen_add_library(proxygen_http_session_webtransport_filter
     proxygen_http_http_message_filters
     proxygen_http_session_http_transaction
     proxygen_http_webtransport
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
 )
 
 if(BUILD_TESTS)
diff --git a/proxygen/lib/http/session/CodecErrorResponseHandler.cpp b/proxygen/lib/http/session/CodecErrorResponseHandler.cpp
index 580b9438d2..ec6ca1c22d 100644
--- a/proxygen/lib/http/session/CodecErrorResponseHandler.cpp
+++ b/proxygen/lib/http/session/CodecErrorResponseHandler.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/session/CodecErrorResponseHandler.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using std::unique_ptr;
@@ -29,16 +30,16 @@ void CodecErrorResponseHandler::detachTransaction() noexcept {
 
 void CodecErrorResponseHandler::onHeadersComplete(
     std::unique_ptr<HTTPMessage> /*msg*/) noexcept {
-  VLOG(4) << "discarding headers";
+  PRX_VLOG(4) << "discarding headers";
 }
 
 void CodecErrorResponseHandler::onBody(unique_ptr<IOBuf> /*chain*/) noexcept {
-  VLOG(4) << "discarding request body";
+  PRX_VLOG(4) << "discarding request body";
 }
 
 void CodecErrorResponseHandler::onTrailers(
     unique_ptr<HTTPHeaders> /*trailers*/) noexcept {
-  VLOG(4) << "discarding request trailers";
+  PRX_VLOG(4) << "discarding request trailers";
 }
 
 void CodecErrorResponseHandler::onEOM() noexcept {
@@ -49,7 +50,7 @@ void CodecErrorResponseHandler::onUpgrade(
 }
 
 void CodecErrorResponseHandler::onError(const HTTPException& error) noexcept {
-  VLOG(4) << "processing error " << error;
+  PRX_VLOG(4) << "processing error " << error;
   txn_->sendAbort();
 }
 
diff --git a/proxygen/lib/http/session/HQDownstreamSession.cpp b/proxygen/lib/http/session/HQDownstreamSession.cpp
index bdcfb9de16..e5649bfe7e 100644
--- a/proxygen/lib/http/session/HQDownstreamSession.cpp
+++ b/proxygen/lib/http/session/HQDownstreamSession.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/session/HQDownstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -49,7 +50,7 @@ void HQDownstreamSession::setupOnHeadersComplete(HTTPTransaction* txn,
                                                  HTTPMessage* msg) {
   HTTPTransaction::Handler* handler =
       getController()->getRequestHandler(*txn, msg);
-  CHECK(handler);
+  PRX_CHECK(handler);
   txn->setHandler(handler);
   if (infoCallback_) {
     infoCallback_->onIngressMessage(*this, *msg);
@@ -57,7 +58,7 @@ void HQDownstreamSession::setupOnHeadersComplete(HTTPTransaction* txn,
 }
 
 bool HQDownstreamSession::isDetachable(bool) const {
-  LOG(FATAL) << __func__ << " is an upstream interface";
+  PRX_LOG(FATAL) << __func__ << " is an upstream interface";
 }
 
 void HQDownstreamSession::attachThreadLocals(
@@ -68,11 +69,11 @@ void HQDownstreamSession::attachThreadLocals(
     FilterIteratorFn,
     HeaderCodec::Stats*,
     HTTPSessionController*) {
-  LOG(FATAL) << __func__ << " is an upstream interface";
+  PRX_LOG(FATAL) << __func__ << " is an upstream interface";
 }
 
 void HQDownstreamSession::detachThreadLocals(bool) {
-  LOG(FATAL) << __func__ << " is an upstream interface";
+  PRX_LOG(FATAL) << __func__ << " is an upstream interface";
 }
 
 bool HQDownstreamSession::pushAllowedByGoaway(hq::PushId pushId) {
@@ -85,16 +86,16 @@ HQDownstreamSession::createEgressPushStream(hq::PushId pushId,
                                             quic::StreamId streamId,
                                             quic::StreamId parentStreamId) {
 
-  VLOG(4) << __func__ << "sess=" << *this << " pushId=" << pushId
-          << " isClosing()=" << isClosing() << " streamId=" << streamId
-          << " parentStreamId=" << parentStreamId;
+  PRX_VLOG(4) << __func__ << "sess=" << *this << " pushId=" << pushId
+              << " isClosing()=" << isClosing() << " streamId=" << streamId
+              << " parentStreamId=" << parentStreamId;
 
   // Use version utils to ensure that the session is not in draining state
   if (!pushAllowedByGoaway(pushId)) {
-    VLOG(3) << __func__ << " Not creating - session is draining"
-            << " sess=" << *this << " pushId=" << pushId
-            << " isClosing()=" << isClosing() << " streamId=" << streamId
-            << " parentStreamId=" << parentStreamId;
+    PRX_VLOG(3) << __func__ << " Not creating - session is draining"
+                << " sess=" << *this << " pushId=" << pushId
+                << " isClosing()=" << isClosing() << " streamId=" << streamId
+                << " parentStreamId=" << parentStreamId;
     return nullptr;
   }
 
@@ -116,8 +117,8 @@ HQDownstreamSession::createEgressPushStream(hq::PushId pushId,
   pushIdToStreamId_[pushId] = streamId;
   streamIdToPushId_[streamId] = pushId;
 
-  CHECK(matchPair.second) << "Emplacement failed, despite earlier "
-                             "existence check.";
+  PRX_CHECK(matchPair.second) << "Emplacement failed, despite earlier "
+                                 "existence check.";
 
   // Generate the stream preface
   matchPair.first->second.generateStreamPreface();
@@ -141,16 +142,16 @@ HTTPTransaction* FOLLY_NULLABLE HQDownstreamSession::newPushedTransaction(
     ProxygenError* error) {
 
   if (isClosing()) {
-    VLOG(3) << __func__ << " Not creating transaction - draining ";
+    PRX_VLOG(3) << __func__ << " Not creating transaction - draining ";
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorTransportIsDraining);
     return nullptr;
   }
 
   auto parentRequestStream = findNonDetachedStream(parentRequestStreamId);
   if (!parentRequestStream) {
-    VLOG(3) << __func__
-            << " Not creating transaction - request stream StreamID="
-            << parentRequestStreamId << " not found";
+    PRX_VLOG(3) << __func__
+                << " Not creating transaction - request stream StreamID="
+                << parentRequestStreamId << " not found";
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorParentStreamNotExist);
     return nullptr;
   }
@@ -163,7 +164,7 @@ HTTPTransaction* FOLLY_NULLABLE HQDownstreamSession::newPushedTransaction(
   // NOTE: should be stored in the transaction
   // NOTE: should be cleaned up when the transaction is closed
   if (!pushStreamId) {
-    VLOG(2) << __func__ << " failed to create new unidirectional stream";
+    PRX_VLOG(2) << __func__ << " failed to create new unidirectional stream";
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorCreatingStream);
     return nullptr;
   }
@@ -175,14 +176,14 @@ HTTPTransaction* FOLLY_NULLABLE HQDownstreamSession::newPushedTransaction(
       pushId, pushStreamId.value(), parentRequestStreamId);
 
   if (!pushStream) {
-    LOG(ERROR) << "Creation of the push stream failed, pushID=" << pushId;
+    PRX_LOG(ERROR) << "Creation of the push stream failed, pushID=" << pushId;
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorCreatingStream);
     return nullptr;
   }
 
-  VLOG(4) << "New pushed transaction: pushId=" << pushId
-          << "; pushStreamId=" << pushStreamId.value()
-          << "; assocStreamId=" << parentRequestStreamId;
+  PRX_VLOG(4) << "New pushed transaction: pushId=" << pushId
+              << "; pushStreamId=" << pushStreamId.value()
+              << "; assocStreamId=" << parentRequestStreamId;
 
   pushStream->txn_.setHandler(handler);
   return &pushStream->txn_;
@@ -200,7 +201,7 @@ HQDownstreamSession::findEgressPushStream(quic::StreamId streamId) {
     return nullptr;
   } else {
     auto pstream = &it->second;
-    DCHECK(pstream->isUsing(streamId));
+    PRX_DCHECK(pstream->isUsing(streamId));
     return pstream;
   }
 }
@@ -230,12 +231,13 @@ void HQDownstreamSession::HQEgressPushStream::sendPushPromise(
     HTTPHeaderSize* size,
     bool includeEOM) {
 
-  CHECK(txn) << "Must be invoked on a live transaction";
-  CHECK(txn->getAssocTxnId())
+  PRX_CHECK(txn) << "Must be invoked on a live transaction";
+  PRX_CHECK(txn->getAssocTxnId())
       << "Must be invoked on a transaction with a parent";
-  CHECK_EQ(txn_.getID(), txn->getID()) << " Transaction stream mismatch";
-  CHECK(pushId == folly::none) << " The push id is stored in the egress stream,"
-                               << " and should not be passed by the session";
+  PRX_CHECK_EQ(txn_.getID(), txn->getID()) << " Transaction stream mismatch";
+  PRX_CHECK(pushId == folly::none)
+      << " The push id is stored in the egress stream,"
+      << " and should not be passed by the session";
 
   auto parentStreamId = txn->getAssocTxnId();
 #if DEBUG
@@ -258,7 +260,7 @@ void HQDownstreamSession::HQEgressPushStream::sendPushPromise(
 size_t HQDownstreamSession::HQEgressPushStream::generateStreamPushId() {
   // reserve space for max quic interger len
   auto result = hq::writeStreamPreface(writeBuf_, pushId_);
-  CHECK(result.has_value())
+  PRX_CHECK(result.has_value())
       << __func__ << " QUIC integer encoding error value=" << pushId_;
 
   return *result;
diff --git a/proxygen/lib/http/session/HQDownstreamSession.h b/proxygen/lib/http/session/HQDownstreamSession.h
index 33dc188a66..68de8fe209 100644
--- a/proxygen/lib/http/session/HQDownstreamSession.h
+++ b/proxygen/lib/http/session/HQDownstreamSession.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <proxygen/lib/http/session/HQSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -54,7 +55,7 @@ class HQDownstreamSession : public HQSession {
   void detachThreadLocals(bool) override;
 
   bool isReplaySafe() const override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
   // Create a new pushed transaction.
   HTTPTransaction* newPushedTransaction(
@@ -85,7 +86,7 @@ class HQDownstreamSession : public HQSession {
 
  protected:
   ~HQDownstreamSession() override {
-    CHECK_EQ(getNumStreams(), 0);
+    PRX_CHECK_EQ(getNumStreams(), 0u);
   }
 
 #ifdef _MSC_VER
@@ -134,8 +135,8 @@ class HQDownstreamSession : public HQSession {
     // the egress push stream does not have to flush
     // ingress queues
     void transactionTimeout(HTTPTransaction* txn) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
-      DCHECK(txn == &txn_);
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_DCHECK(txn == &txn_);
     }
 
     void sendPushPromise(HTTPTransaction* /* txn */,
@@ -151,14 +152,14 @@ class HQDownstreamSession : public HQSession {
 
     // Egress only stream should not pause ingress
     void pauseIngress(HTTPTransaction* /* txn */) noexcept override {
-      VLOG(4) << __func__
-              << " Ingress function called on egress-only stream, ignoring";
+      PRX_VLOG(4) << __func__
+                  << " Ingress function called on egress-only stream, ignoring";
     }
 
     // Egress only stream should not pause ingress
     void resumeIngress(HTTPTransaction* /* txn */) noexcept override {
-      VLOG(4) << __func__
-              << " Ingress function called on egress-only stream, ignoring";
+      PRX_VLOG(4) << __func__
+                  << " Ingress function called on egress-only stream, ignoring";
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode> sendWTMaxData(
@@ -200,7 +201,7 @@ class HQDownstreamSession : public HQSession {
   void dispatchPushStream(quic::StreamId /* pushStreamId */,
                           hq::PushId /* pushId */,
                           size_t /* toConsume */) override {
-    LOG(DFATAL) << "nope";
+    PRX_LOG(DFATAL) << "nope";
   }
 
   // This is the current method of creating new push IDs.
diff --git a/proxygen/lib/http/session/HQSession.cpp b/proxygen/lib/http/session/HQSession.cpp
index 918ae950af..bc4d7f4ef2 100644
--- a/proxygen/lib/http/session/HQSession.cpp
+++ b/proxygen/lib/http/session/HQSession.cpp
@@ -32,6 +32,7 @@
 #include <folly/io/async/AsyncTransport.h>
 #include <folly/io/async/DelayedDestructionBase.h>
 #include <folly/io/async/HHWheelTimer.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/QuicConstants.h>
 #include <quic/common/BufUtil.h>
 #include <quic/folly_utils/Utils.h>
@@ -135,12 +136,12 @@ uint32_t writeWTStreamPrefaceToSock(
   auto res =
       proxygen::hq::writeWTStreamPreface(writeBuf, streamType, wtSessionId);
   if (!res) {
-    LOG(ERROR) << "Failed to write WT stream preface";
+    PRX_LOG(ERROR) << "Failed to write WT stream preface";
     return 0;
   }
   auto writeRes = sock.writeChain(wtStreamId, writeBuf.move(), false);
   if (writeRes.hasError()) {
-    LOG(ERROR) << "Failed to write stream preface to socket";
+    PRX_LOG(ERROR) << "Failed to write stream preface to socket";
     return 0;
   }
   return *res;
@@ -165,13 +166,13 @@ const http2::PriorityUpdate hqDefaultPriority{
     .streamDependency = kSessionStreamId, .exclusive = false, .weight = 15};
 
 HQSession::~HQSession() {
-  VLOG(3) << *this << " closing";
+  PRX_VLOG(3) << *this << " closing";
   runDestroyCallbacks();
 }
 
 void HQSession::setEarlyDataHandler(
     std::unique_ptr<H3EarlyDataHandler> handler) {
-  CHECK(isUpstream(direction_));
+  PRX_CHECK(isUpstream(direction_));
   earlyDataHandler_ = std::move(handler);
 }
 
@@ -183,7 +184,7 @@ void HQSession::setSessionStats(HTTPSessionStats* stats) {
 }
 
 void HQSession::onNewBidirectionalStream(quic::StreamId id) noexcept {
-  VLOG(4) << __func__ << " sess=" << *this << ": new streamID=" << id;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": new streamID=" << id;
   // The transport should never call onNewBidirectionalStream before
   // onTransportReady
 
@@ -196,7 +197,7 @@ void HQSession::onNewBidirectionalStream(quic::StreamId id) noexcept {
     return;
   }
   auto hqStream = findNonDetachedStream(id);
-  DCHECK(!hqStream);
+  PRX_DCHECK(!hqStream);
   if (supportsWebTransport()) {
     bidirectionalReadDispatcher_.takeTemporaryOwnership(id);
     sock_->setPeekCallback(id, &bidirectionalReadDispatcher_);
@@ -207,7 +208,7 @@ void HQSession::onNewBidirectionalStream(quic::StreamId id) noexcept {
 
 void HQSession::dispatchRequestStream(quic::StreamId id) {
   if (!sock_->good()) {
-    LOG(ERROR) << "Bad socket sess=" << *this;
+    PRX_LOG(ERROR) << "Bad socket sess=" << *this;
     return;
   }
   sock_->setPeekCallback(id, nullptr);
@@ -221,7 +222,7 @@ void HQSession::dispatchRequestStreamImpl(quic::StreamId id) {
   // id < kMaxClientBidiStreamId, so id + 4 will not wrap
   minUnseenIncomingStreamId_ = std::max(minUnseenIncomingStreamId_, id + 4);
   auto hqStream = createStreamTransport(id);
-  DCHECK(hqStream);
+  PRX_DCHECK(hqStream);
   sock_->setReadCallback(id, this);
   if (ingressLimitExceeded()) {
     sock_->pauseRead(id);
@@ -229,15 +230,15 @@ void HQSession::dispatchRequestStreamImpl(quic::StreamId id) {
   if (id == 0 && version_ == HQVersion::HQ) {
     // generate grease frame
     auto res = hq::writeGreaseFrame(hqStream->writeBuf_);
-    VLOG_IF(2, !res) << __func__ << " ::writeGreaseFrame err " << *this;
+    PRX_VLOG_IF(2, !res) << __func__ << " ::writeGreaseFrame err " << *this;
   }
 }
 
 void HQSession::onBidirectionalStreamsAvailable(
     uint64_t numStreamsAvailable) noexcept {
   if (isUpstream(direction_)) {
-    VLOG(4) << "Got new max number of concurrent streams we can initiate: "
-            << numStreamsAvailable << " sess=" << *this;
+    PRX_VLOG(4) << "Got new max number of concurrent streams we can initiate: "
+                << numStreamsAvailable << " sess=" << *this;
     if (infoCallback_ && supportsMoreTransactions()) {
       infoCallback_->onSettingsOutgoingStreamsNotFull(*this);
     }
@@ -248,12 +249,13 @@ void HQSession::onNewUnidirectionalStream(quic::StreamId id) noexcept {
   // This is where a new unidirectional ingress stream is available
   // Try to check whether this is a push
   // if yes, register this as a push
-  VLOG(4) << __func__ << " sess=" << *this << ": new streamID=" << id;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": new streamID=" << id;
   // The transport should never call onNewUnidirectionalStream
   // before onTransportReady
   // The new stream should not exist yet.
   auto existingStream = findStream(id);
-  DCHECK(!existingStream) << "duplicate " << __func__ << " for streamID=" << id;
+  PRX_DCHECK(!existingStream)
+      << "duplicate " << __func__ << " for streamID=" << id;
   // This has to be a new control or push stream, but we haven't read the
   // preface yet
   // Assign the stream to the dispatcher
@@ -264,8 +266,8 @@ void HQSession::onNewUnidirectionalStream(quic::StreamId id) noexcept {
 void HQSession::onStopSending(quic::StreamId id,
                               quic::ApplicationErrorCode error) noexcept {
   auto errorCode = static_cast<HTTP3::ErrorCode>(error);
-  VLOG(3) << __func__ << " sess=" << *this << ": new streamID=" << id
-          << " error=" << toString(errorCode);
+  PRX_VLOG(3) << __func__ << " sess=" << *this << ": new streamID=" << id
+              << " error=" << toString(errorCode);
   auto stream = findStream(id);
   if (stream) {
     handleWriteError(stream, error);
@@ -294,10 +296,10 @@ void HQSession::onStopSending(quic::StreamId id,
 void HQSession::onKnob(uint64_t knobSpace,
                        uint64_t knobId,
                        quic::BufPtr knobBlob) {
-  VLOG(3) << __func__ << " sess=" << *this
-          << " knob frame received: " << " KnobSpace: " << std::hex << knobSpace
-          << " KnobId: " << knobId
-          << " KnobBlob: " << knobBlob->to<std::string>();
+  PRX_VLOG(3) << __func__ << " sess=" << *this
+              << " knob frame received: " << " KnobSpace: " << std::hex
+              << knobSpace << " KnobId: " << knobId
+              << " KnobBlob: " << knobBlob->to<std::string>();
 }
 
 bool HQSession::maybeRejectRequestAfterGoaway(quic::StreamId id) {
@@ -375,8 +377,8 @@ bool HQSession::createEgressControlStreams() {
 bool HQSession::createEgressControlStream(UnidirectionalStreamType streamType) {
   auto id = sock_->createUnidirectionalStream();
   if (id.hasError()) {
-    LOG(ERROR) << "Failed to create " << streamType
-               << " unidirectional stream. error='" << id.error() << "'";
+    PRX_LOG(ERROR) << "Failed to create " << streamType
+                   << " unidirectional stream. error='" << id.error() << "'";
     onConnectionError(
         quic::QuicError(quic::LocalErrorCode::CONNECT_FAILED,
                         "Failed to create unidirectional stream"));
@@ -387,7 +389,7 @@ bool HQSession::createEgressControlStream(UnidirectionalStreamType streamType) {
       std::piecewise_construct,
       std::forward_as_tuple(streamType),
       std::forward_as_tuple(*this, id.value(), streamType));
-  CHECK(matchPair.second) << "Emplacement failed";
+  PRX_CHECK(matchPair.second) << "Emplacement failed";
   sock_->setControlStream(id.value());
   matchPair.first->second.generateStreamPreface();
   return true;
@@ -401,13 +403,14 @@ HQSession::createIngressControlStream(quic::StreamId id,
   // this is an error in the use of the API, egress control streams must get
   // created at the very beginning
   if (!ctrlStream) {
-    LOG(FATAL) << "Cannot create ingress control stream without an egress "
-                  "stream streamID="
-               << id << " sess=" << *this;
+    PRX_LOG(FATAL) << "Cannot create ingress control stream without an egress "
+                      "stream streamID="
+                   << id << " sess=" << *this;
   }
 
   if (ctrlStream->ingressCodec_) {
-    LOG(ERROR) << "Too many " << streamType << " streams for sess=" << *this;
+    PRX_LOG(ERROR) << "Too many " << streamType
+                   << " streams for sess=" << *this;
     dropConnectionAsync(
         quic::QuicError(HTTP3::ErrorCode::HTTP_STREAM_CREATION_ERROR,
                         "HTTP wrong stream count"),
@@ -443,12 +446,12 @@ std::unique_ptr<hq::HQUnidirectionalCodec> HQSession::createControlCodec(
       return std::make_unique<hq::QPACKDecoderCodec>(qpackCodec_,
                                                      controlStream);
     default:
-      LOG(FATAL) << "Failed to create ingress codec";
+      PRX_LOG(FATAL) << "Failed to create ingress codec";
   }
 }
 
 bool HQSession::getAndCheckApplicationProtocol() {
-  CHECK(sock_);
+  PRX_CHECK(sock_);
   auto alpn = sock_->getAppProtocol();
   if (alpn) {
     if (alpn == kH3FBCurrentDraft || alpn == kH3AliasV1 || alpn == kH3AliasV2 ||
@@ -459,8 +462,8 @@ bool HQSession::getAndCheckApplicationProtocol() {
   if (!alpn || !version_) {
     // next protocol not specified or version not supported, close connection
     // with error
-    LOG(ERROR) << "next protocol not supported: "
-               << (alpn ? *alpn : "no protocol") << " sess=" << *this;
+    PRX_LOG(ERROR) << "next protocol not supported: "
+                   << (alpn ? *alpn : "no protocol") << " sess=" << *this;
 
     onConnectionError(quic::QuicError(quic::LocalErrorCode::CONNECT_FAILED,
                                       "ALPN not supported"));
@@ -494,7 +497,7 @@ void HQSession::onConnectionEnd(quic::QuicError error) noexcept {
 }
 
 void HQSession::onConnectionEnd() noexcept {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   // The transport will not call onConnectionEnd after we call close(),
   // so there is no need for us here to handle re-entrancy
   // checkForShutdown->close->onConnectionEnd.
@@ -511,8 +514,8 @@ void HQSession::onConnectionSetupError(quic::QuicError code) noexcept {
 void HQSession::onConnectionError(quic::QuicError code) noexcept {
   // the connector will drop the connection in case of connect error
   HQSession::DestructorGuard dg(this);
-  VLOG(4) << __func__ << " sess=" << *this
-          << ": connection error=" << code.message;
+  PRX_VLOG(4) << __func__ << " sess=" << *this
+              << ": connection error=" << code.message;
 
   // Map application errors here to kErrorConnectionReset: eg, the peer tore
   // down the connection
@@ -528,17 +531,17 @@ void HQSession::onConnectionError(quic::QuicError code) noexcept {
   if (code.code.type() == quic::QuicErrorCode::Type::ApplicationErrorCode &&
       isQPACKError(
           static_cast<HTTP3::ErrorCode>(*code.code.asApplicationErrorCode()))) {
-    LOG(ERROR) << "Connection QPACK error err="
-               << static_cast<uint32_t>(*code.code.asApplicationErrorCode())
-               << " msg=" << code.message << " " << *this;
+    PRX_LOG(ERROR) << "Connection QPACK error err="
+                   << static_cast<uint32_t>(*code.code.asApplicationErrorCode())
+                   << " msg=" << code.message << " " << *this;
   } else if (!noError(code.code)) {
     std::stringstream msgStream;
     msgStream << "Connection closed with error err=" << code.code
               << " msg=" << code.message << " " << *this;
     if (isVlogLevel(code.code)) {
-      VLOG(3) << msgStream.str();
+      PRX_VLOG(3) << msgStream.str();
     } else {
-      LOG(ERROR) << msgStream.str();
+      PRX_LOG(ERROR) << msgStream.str();
     }
   }
 
@@ -651,8 +654,8 @@ size_t HQSession::sendPushPriority(hq::PushId pushId, HTTPPriority priority) {
   auto streamId = iter->second;
   auto stream = findPushStream(streamId);
   if (!stream) {
-    LOG(ERROR) << "Cannot find push streamId=" << streamId
-               << " with pushId=" << pushId << " presented in id map";
+    PRX_LOG(ERROR) << "Cannot find push streamId=" << streamId
+                   << " with pushId=" << pushId << " presented in id map";
     return 0;
   }
 
@@ -672,7 +675,7 @@ size_t HQSession::sendPushPriority(hq::PushId pushId, HTTPPriority priority) {
 
 size_t HQSession::HQStreamTransportBase::changePriority(
     HTTPTransaction* txn, HTTPPriority httpPriority) noexcept {
-  CHECK_EQ(txn, &txn_);
+  PRX_CHECK_EQ(txn, &txn_);
   if (queueHandle_.isStreamTransportEnqueued()) {
     // If the stream is already enqueued, we need to update the priority
     auto id = queueHandle_.getStreamId();
@@ -727,7 +730,7 @@ bool HQSession::HQStreamTransportBase::wantsOnWriteReady(size_t canSend) const {
 void HQSession::drainImpl() {
   if (drainState_ != DrainState::NONE) {
     // no op
-    VLOG(5) << "Already draining sess=" << *this;
+    PRX_VLOG(5) << "Already draining sess=" << *this;
     return;
   }
   drainState_ = DrainState::PENDING;
@@ -741,12 +744,12 @@ void HQSession::sendGoaway() {
     return;
   }
   // send GOAWAY frame on the control stream
-  DCHECK(drainState_ == DrainState::PENDING ||
-         drainState_ == DrainState::FIRST_GOAWAY);
+  PRX_DCHECK(drainState_ == DrainState::PENDING ||
+             drainState_ == DrainState::FIRST_GOAWAY);
 
   auto connCtrlStream = findControlStream(UnidirectionalStreamType::CONTROL);
   auto g = folly::makeGuard(connCtrlStream->setActiveCodec(__func__));
-  DCHECK(connCtrlStream);
+  PRX_DCHECK(connCtrlStream);
   auto goawayStreamId = getGoawayStreamId();
   auto generated = connCtrlStream->codecFilterChain->generateGoaway(
       connCtrlStream->writeBuf_, goawayStreamId, ErrorCode::NO_ERROR);
@@ -757,23 +760,23 @@ void HQSession::sendGoaway() {
   if (generated == 0 || writeOffset.hasError() ||
       writeBufferedBytes.hasError()) {
     // shortcut to shutdown
-    LOG(ERROR) << " error generating GOAWAY sess=" << *this;
+    PRX_LOG(ERROR) << " error generating GOAWAY sess=" << *this;
     drainState_ = DrainState::DONE;
     return;
   }
-  VLOG(3) << "generated GOAWAY maxStreamID=" << goawayStreamId
-          << " sess=" << *this;
+  PRX_VLOG(3) << "generated GOAWAY maxStreamID=" << goawayStreamId
+              << " sess=" << *this;
 
   auto totalStreamLength = *writeOffset + *writeBufferedBytes +
                            connCtrlStream->writeBuf_.chainLength();
-  CHECK_GT(totalStreamLength, 0);
+  PRX_CHECK_GT(totalStreamLength, 0u);
   auto res =
       sock_->registerDeliveryCallback(connCtrlStream->getEgressStreamId(),
                                       totalStreamLength - 1,
                                       connCtrlStream);
   if (res.hasError()) {
     // shortcut to shutdown
-    LOG(ERROR) << " error generating GOAWAY sess=" << *this;
+    PRX_LOG(ERROR) << " error generating GOAWAY sess=" << *this;
     drainState_ = DrainState::DONE;
     return;
   }
@@ -781,13 +784,13 @@ void HQSession::sendGoaway() {
   if (drainState_ == DrainState::PENDING) {
     drainState_ = DrainState::FIRST_GOAWAY;
   } else {
-    DCHECK_EQ(drainState_, DrainState::FIRST_GOAWAY);
+    PRX_DCHECK_EQ(drainState_, DrainState::FIRST_GOAWAY);
     drainState_ = DrainState::SECOND_GOAWAY;
   }
 }
 
 quic::StreamId HQSession::getGoawayStreamId() {
-  DCHECK(isDownstream(direction_));
+  PRX_DCHECK(isDownstream(direction_));
   if (drainState_ == DrainState::NONE || drainState_ == DrainState::PENDING) {
     return HTTPCodec::MaxStreamID;
   }
@@ -819,7 +822,7 @@ size_t HQSession::sendSettings() {
         case hq::SettingId::WT_ENABLED:
         case hq::SettingId::ENABLE_WEBTRANSPORT:
           if (setting.value) {
-            VLOG(4) << "wt enabled sess=" << *this;
+            PRX_VLOG(4) << "wt enabled sess=" << *this;
             supportsWebTransport_.set(
                 folly::to_underlying(SettingEnabled::SELF));
           }
@@ -830,7 +833,7 @@ size_t HQSession::sendSettings() {
 
   auto connCtrlStream = findControlStream(UnidirectionalStreamType::CONTROL);
   auto g = folly::makeGuard(connCtrlStream->setActiveCodec(__func__));
-  DCHECK(connCtrlStream);
+  PRX_DCHECK(connCtrlStream);
   auto generated = connCtrlStream->codecFilterChain->generateSettings(
       connCtrlStream->writeBuf_);
   scheduleWrite();
@@ -838,12 +841,12 @@ size_t HQSession::sendSettings() {
 }
 
 void HQSession::notifyPendingShutdown() {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   drainImpl();
 }
 
 void HQSession::closeWhenIdle() {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   drainImpl();
   cleanupPendingStreams();
   checkForShutdown();
@@ -863,13 +866,13 @@ void HQSession::dropConnectionAsync(quic::QuicError errorCode,
                                            .proxygenError = proxygenError};
     scheduleLoopCallback(true);
   } else {
-    VLOG(4) << "Session already scheduled to be dropped: sess=" << *this;
+    PRX_VLOG(4) << "Session already scheduled to be dropped: sess=" << *this;
   }
 }
 
 void HQSession::dropConnectionSync(quic::QuicError errorCode,
                                    ProxygenError proxygenError) {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   HQSession::DestructorGuard dg(this);
   // dropping_ is used to guard against dropConnection->onError->dropConnection
   // re-entrancy. instead drainState_ = DONE means the connection can only be
@@ -877,7 +880,7 @@ void HQSession::dropConnectionSync(quic::QuicError errorCode,
   // We can get here with drainState_ == DONE, if somthing is holding a
   // DestructorGuardon the session when it gets dropped.
   if (dropping_) {
-    VLOG(5) << "Already dropping sess=" << *this;
+    PRX_VLOG(5) << "Already dropping sess=" << *this;
     return;
   }
   dropping_ = true;
@@ -910,13 +913,14 @@ void HQSession::dropConnectionSync(quic::QuicError errorCode,
   drainState_ = DrainState::DONE;
   cancelLoopCallback();
   checkForShutdown();
-  if (VLOG_IS_ON(5)) {
+  if (PRX_VLOG_IS_ON(5)) {
     unidirectionalReadDispatcher_.invokeOnPendingStreamIDs(
         [&](quic::StreamId pendingStreamId) {
-          VLOG(5) << __func__ << " pendingStreamStillOpen: " << pendingStreamId;
+          PRX_VLOG(5) << __func__
+                      << " pendingStreamStillOpen: " << pendingStreamId;
         });
   }
-  CHECK_EQ(getNumStreams(), 0);
+  PRX_CHECK_EQ(getNumStreams(), 0u);
 }
 
 void HQSession::checkForShutdown() {
@@ -926,11 +930,11 @@ void HQSession::checkForShutdown() {
   // request streams are done. In the process it will still be able to receive
   // and process GOAWAYs from the server
   if (isUpstream(direction_) && drainState_ == DrainState::PENDING) {
-    if (VLOG_IS_ON(5)) {
+    if (PRX_VLOG_IS_ON(5)) {
       unidirectionalReadDispatcher_.invokeOnPendingStreamIDs(
           [&](quic::StreamId pendingStreamId) {
-            VLOG(5) << __func__
-                    << " pendingStreamStillOpen: " << pendingStreamId;
+            PRX_VLOG(5) << __func__
+                        << " pendingStreamStillOpen: " << pendingStreamId;
           });
     }
     drainState_ = DrainState::DONE;
@@ -1041,8 +1045,8 @@ HQSession::findStreamImpl(quic::StreamId streamId,
   if (!pstream) {
     return nullptr;
   }
-  CHECK(pstream);
-  DCHECK(pstream->isUsing(streamId));
+  PRX_CHECK(pstream);
+  PRX_DCHECK(pstream->isUsing(streamId));
   if (!includeDetached) {
     if (pstream->detached_) {
       return nullptr;
@@ -1142,9 +1146,9 @@ void HQSession::runSessionLoopCallback() noexcept {
   }
 
   // Maybe schedule the next loop callback
-  VLOG(4) << "sess=" << *this << " maybe schedule the next loop callback. "
-          << " pending writes: " << !httpPriorityQueue_.empty()
-          << " pending processing reads: " << pendingProcessReadSet_.size();
+  PRX_VLOG(4) << "sess=" << *this << " maybe schedule the next loop callback. "
+              << " pending writes: " << !httpPriorityQueue_.empty()
+              << " pending processing reads: " << pendingProcessReadSet_.size();
   if (!pendingProcessReadSet_.empty()) {
     scheduleLoopCallback(false);
   }
@@ -1156,7 +1160,7 @@ void HQSession::readDataProcessed() {
   if (ici) {
     auto QPACKDecoderStream =
         findControlStream(UnidirectionalStreamType::QPACK_DECODER);
-    DCHECK(QPACKDecoderStream);
+    PRX_DCHECK(QPACKDecoderStream);
     QPACKDecoderStream->writeBuf_.append(std::move(ici));
     // don't need to explicitly schedule write because this is called in the
     // loop before control streams are written
@@ -1193,8 +1197,8 @@ void HQSession::scheduleLoopCallback(bool thisIteration) {
 }
 
 void HQSession::resumeReads(quic::StreamId streamId) {
-  VLOG(4) << __func__ << " sess=" << *this
-          << ": resuming reads id=" << streamId;
+  PRX_VLOG(4) << __func__ << " sess=" << *this
+              << ": resuming reads id=" << streamId;
   sock_->resumeRead(streamId);
   scheduleLoopCallback(true);
   // TODO: ideally we should cancel the managed timeout when all the streams are
@@ -1202,7 +1206,7 @@ void HQSession::resumeReads(quic::StreamId streamId) {
 }
 
 void HQSession::resumeReads() {
-  VLOG(4) << __func__ << " sess=" << *this << ": resuming reads";
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": resuming reads";
   invokeOnIngressStreams([this](HQStreamTransportBase* hqStream) {
     if (sock_) {
       sock_->resumeRead(hqStream->getIngressStreamId());
@@ -1211,12 +1215,13 @@ void HQSession::resumeReads() {
 }
 
 void HQSession::pauseReads(quic::StreamId streamId) {
-  VLOG(4) << __func__ << " sess=" << *this << ": pausing reads id=" << streamId;
+  PRX_VLOG(4) << __func__ << " sess=" << *this
+              << ": pausing reads id=" << streamId;
   sock_->pauseRead(streamId);
 }
 
 void HQSession::pauseReads() {
-  VLOG(4) << __func__ << " sess=" << *this << ": pausing reads";
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": pausing reads";
   invokeOnIngressStreams([this](HQStreamTransportBase* hqStream) {
     sock_->pauseRead(hqStream->getIngressStreamId());
   });
@@ -1224,14 +1229,14 @@ void HQSession::pauseReads() {
 
 void HQSession::readAvailable(quic::StreamId id) noexcept {
   // this is the bidirectional callback
-  VLOG(4) << __func__ << " sess=" << *this
-          << ": readAvailable on streamID=" << id;
+  PRX_VLOG(4) << __func__ << " sess=" << *this
+              << ": readAvailable on streamID=" << id;
   if (readsPerLoop_ >= kMaxReadsPerLoop) {
     if (sessionStats_) {
       sessionStats_->recordReadPerLoopLimitExceeded();
     }
-    VLOG(3) << __func__ << ": skipping read for streamID=" << id
-            << " maximum reads per loop reached" << " sess=" << *this;
+    PRX_VLOG(3) << __func__ << ": skipping read for streamID=" << id
+                << " maximum reads per loop reached" << " sess=" << *this;
 
     return;
   }
@@ -1242,8 +1247,8 @@ void HQSession::readAvailable(quic::StreamId id) noexcept {
 }
 
 void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
-  VLOG(4) << __func__ << " sess=" << *this << ": readError streamID=" << id
-          << " error: " << error;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": readError streamID=" << id
+              << " error: " << error;
 
   HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                    folly::to<std::string>("Got error=", quic::toString(error)));
@@ -1252,8 +1257,9 @@ void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
     case quic::QuicErrorCode::Type::ApplicationErrorCode: {
       auto errorCode =
           static_cast<HTTP3::ErrorCode>(*error.code.asApplicationErrorCode());
-      VLOG(3) << "readError: QUIC Application Error: " << toString(errorCode)
-              << " streamID=" << id << " sess=" << *this;
+      PRX_VLOG(3)
+          << "readError: QUIC Application Error: " << toString(errorCode)
+          << " streamID=" << id << " sess=" << *this;
       ex.setHttp3ErrorCode(errorCode);
       auto stream = findNonDetachedStream(id);
       if (stream) {
@@ -1261,7 +1267,7 @@ void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
       } else {
         // When a stream is erased, it's callback is cancelled, so it really
         // should be here
-        VLOG(3)
+        PRX_VLOG(3)
             << "readError: received application error=" << toString(errorCode)
             << " for detached streamID=" << id << " sess=" << *this;
       }
@@ -1269,8 +1275,8 @@ void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
     }
     case quic::QuicErrorCode::Type::LocalErrorCode: {
       quic::LocalErrorCode& errorCode = *error.code.asLocalErrorCode();
-      VLOG(3) << "readError: QUIC Local Error: " << errorCode
-              << " streamID=" << id << " sess=" << *this;
+      PRX_VLOG(3) << "readError: QUIC Local Error: " << errorCode
+                  << " streamID=" << id << " sess=" << *this;
       if (errorCode == quic::LocalErrorCode::CONNECT_FAILED) {
         ex.setProxygenError(kErrorConnect);
       } else if (errorCode == quic::LocalErrorCode::IDLE_TIMEOUT) {
@@ -1283,8 +1289,8 @@ void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
     }
     case quic::QuicErrorCode::Type::TransportErrorCode: {
       quic::TransportErrorCode& errorCode = *error.code.asTransportErrorCode();
-      VLOG(3) << "readError: QUIC Transport Error: " << errorCode
-              << " streamID=" << id << " sess=" << *this;
+      PRX_VLOG(3) << "readError: QUIC Transport Error: " << errorCode
+                  << " streamID=" << id << " sess=" << *this;
       ex.setProxygenError(kErrorConnectionReset);
       // TODO: set Quic error when fbcode/quic/QuicConstants.h is OSS
       ex.setErrno(uint32_t(errorCode));
@@ -1295,13 +1301,13 @@ void HQSession::readError(quic::StreamId id, quic::QuicError error) noexcept {
 }
 
 void HQSession::timeoutExpired() noexcept {
-  VLOG(3) << "ManagedConnection timeoutExpired " << *this;
+  PRX_VLOG(3) << "ManagedConnection timeoutExpired " << *this;
   if (getNumStreams() > 0) {
-    VLOG(3) << "ignoring session timeout " << *this;
+    PRX_VLOG(3) << "ignoring session timeout " << *this;
     resetTimeout();
     return;
   }
-  VLOG(3) << "Timeout with nothing pending " << *this;
+  PRX_VLOG(3) << "Timeout with nothing pending " << *this;
   setCloseReason(ConnectionCloseReason::TIMEOUT);
   closeWhenIdle();
 }
@@ -1313,17 +1319,17 @@ folly::Optional<UnidirectionalStreamType> HQSession::parseUniStreamPreface(
   auto res = hq::withType(preface, parse);
   if (res && *res == hq::UnidirectionalStreamType::WEBTRANSPORT &&
       !supportsWebTransport()) {
-    LOG(ERROR) << "WT stream when it is unsupported sess=" << *this;
+    PRX_LOG(ERROR) << "WT stream when it is unsupported sess=" << *this;
     return folly::none;
   }
   return res;
 }
 
 void HQSession::readControlStream(HQControlStream* ctrlStream) {
-  DCHECK(ctrlStream);
+  PRX_DCHECK(ctrlStream);
   auto readRes = sock_->read(ctrlStream->getIngressStreamId(), 0);
   if (readRes.hasError()) {
-    LOG(ERROR) << "Got synchronous read error=" << readRes.error();
+    PRX_LOG(ERROR) << "Got synchronous read error=" << readRes.error();
     readError(ctrlStream->getIngressStreamId(),
               quic::QuicError(readRes.error(), "sync read error"));
     return;
@@ -1331,7 +1337,7 @@ void HQSession::readControlStream(HQControlStream* ctrlStream) {
   resetTimeout();
   quic::BufPtr data = std::move(readRes.value().first);
   auto readSize = data ? data->computeChainDataLength() : 0;
-  VLOG(4) << "Read " << readSize << " bytes from control stream";
+  PRX_VLOG(4) << "Read " << readSize << " bytes from control stream";
   ctrlStream->readBuf_.append(std::move(data));
   ctrlStream->readEOF_ = readRes.value().second;
 
@@ -1350,11 +1356,11 @@ void HQSession::readControlStream(HQControlStream* ctrlStream) {
 void HQSession::dispatchControlStream(quic::StreamId id,
                                       hq::UnidirectionalStreamType type,
                                       size_t toConsume) {
-  VLOG(4) << __func__ << " streamID=" << id << " type=" << type
-          << " toConsume=" << toConsume;
+  PRX_VLOG(4) << __func__ << " streamID=" << id << " type=" << type
+              << " toConsume=" << toConsume;
 
   auto consumeRes = sock_->consume(id, toConsume);
-  CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
+  PRX_CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
 
   // Notify the read callback
   if (infoCallback_) {
@@ -1388,7 +1394,7 @@ void HQSession::rejectStream(quic::StreamId id) {
   // Do not read data for unknown unidirectional stream types.  Send
   // STOP_SENDING and rely on the peer sending a RESET to clear the stream in
   // the transport, or the transport to detect if the peer has sent everything.
-  VLOG(4) << "rejectStream id=" << id;
+  PRX_VLOG(4) << "rejectStream id=" << id;
   sock_->stopSending(id, HTTP3::ErrorCode::HTTP_STREAM_CREATION_ERROR);
   sock_->resetStream(id, HTTP3::ErrorCode::HTTP_STREAM_CREATION_ERROR);
   sock_->setReadCallback(id, nullptr, std::nullopt);
@@ -1419,16 +1425,16 @@ void HQSession::clearStreamCallbacks(quic::StreamId id) {
     sock_->setReadCallback(id, nullptr, std::nullopt);
     sock_->setPeekCallback(id, nullptr);
   } else {
-    VLOG(4) << "Attempt to clear callbacks on closed socket";
+    PRX_VLOG(4) << "Attempt to clear callbacks on closed socket";
   }
 }
 
 void HQSession::controlStreamReadAvailable(quic::StreamId id) {
-  VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id;
   auto ctrlStream = findControlStream(id);
   if (!ctrlStream) {
-    LOG(ERROR) << "Got readAvailable on unknown stream id=" << id
-               << " sess=" << *this;
+    PRX_LOG(ERROR) << "Got readAvailable on unknown stream id=" << id
+                   << " sess=" << *this;
     return;
   }
   readControlStream(ctrlStream);
@@ -1436,15 +1442,15 @@ void HQSession::controlStreamReadAvailable(quic::StreamId id) {
 
 void HQSession::controlStreamReadError(quic::StreamId id,
                                        const quic::QuicError& error) {
-  VLOG(4) << __func__ << " sess=" << *this << ": readError streamID=" << id
-          << " error: " << error;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": readError streamID=" << id
+              << " error: " << error;
 
   auto ctrlStream = findControlStream(id);
 
   if (!ctrlStream) {
     const quic::LocalErrorCode* err = error.code.asLocalErrorCode();
     bool shouldLog = !err || (*err != quic::LocalErrorCode::NO_ERROR);
-    LOG_IF(ERROR, shouldLog)
+    PRX_LOG_IF(ERROR, shouldLog)
         << __func__ << " received read error=" << error
         << " for unknown control streamID=" << id << " sess=" << *this;
     return;
@@ -1460,14 +1466,14 @@ void HQSession::readRequestStream(quic::StreamId id) noexcept {
   auto hqStream = findIngressStream(id, false /* includeDetached */);
   if (!hqStream) {
     // can we even get readAvailable after a stream is marked for detach ?
-    DCHECK(findStream(id));
+    PRX_DCHECK(findStream(id));
     return;
   }
   // Read as much as you possibly can!
   auto readRes = sock_->read(id, 0);
 
   if (readRes.hasError()) {
-    LOG(ERROR) << "Got synchronous read error=" << readRes.error();
+    PRX_LOG(ERROR) << "Got synchronous read error=" << readRes.error();
     readError(id, quic::QuicError(readRes.error(), "sync read error"));
     return;
   }
@@ -1476,8 +1482,9 @@ void HQSession::readRequestStream(quic::StreamId id) noexcept {
   quic::BufPtr data = std::move(readRes.value().first);
   auto readSize = data ? data->computeChainDataLength() : 0;
   hqStream->readEOF_ = readRes.value().second;
-  VLOG(3) << "Got streamID=" << hqStream->getStreamId() << " len=" << readSize
-          << " eof=" << uint32_t(hqStream->readEOF_) << " sess=" << *this;
+  PRX_VLOG(3) << "Got streamID=" << hqStream->getStreamId()
+              << " len=" << readSize << " eof=" << uint32_t(hqStream->readEOF_)
+              << " sess=" << *this;
   if (hqStream->readEOF_) {
     auto timeDiff = std::chrono::duration_cast<std::chrono::milliseconds>(
         std::chrono::steady_clock::now() - hqStream->createdTime);
@@ -1486,7 +1493,7 @@ void HQSession::readRequestStream(quic::StreamId id) noexcept {
           id, quic::kOnEOM, timeDiff);
     }
   } else if (readSize == 0) {
-    VLOG(3) << "Got a blank read, ignoring sess=" << *this;
+    PRX_VLOG(3) << "Got a blank read, ignoring sess=" << *this;
     return;
   }
   // Just buffer the data and postpone processing in the loop callback
@@ -1519,8 +1526,8 @@ void HQSession::processReadData() {
 
     // Check whether the stream has been detached
     if (ingressStream->detached_) {
-      VLOG(4) << __func__ << " killing pending read data for detached txn="
-              << ingressStream->txn_;
+      PRX_VLOG(4) << __func__ << " killing pending read data for detached txn="
+                  << ingressStream->txn_;
       ingressStream->readBuf_.move();
       ingressStream->readEOF_ = false;
       continue;
@@ -1559,7 +1566,7 @@ void HQSession::onSettings(const SettingsList& settings) {
 
 void HQSession::applySettings(const SettingsList& settings) {
   DestructorGuard g(this);
-  VLOG(3) << "Got SETTINGS sess=" << *this;
+  PRX_VLOG(3) << "Got SETTINGS sess=" << *this;
 
   uint32_t tableSize = kDefaultIngressHeaderTableSize;
   uint32_t blocked = kDefaultIngressQpackBlockedStream;
@@ -1579,7 +1586,7 @@ void HQSession::applySettings(const SettingsList& settings) {
           // StreamCodec
           break;
         case hq::SettingId::ENABLE_CONNECT_PROTOCOL:
-          VLOG(3) << "Peer sent ENABLE_CONNECT_PROTOCOL=" << setting.value;
+          PRX_VLOG(3) << "Peer sent ENABLE_CONNECT_PROTOCOL=" << setting.value;
           break;
         case hq::SettingId::H3_DATAGRAM:
         case hq::SettingId::H3_DATAGRAM_RFC:
@@ -1587,22 +1594,23 @@ void HQSession::applySettings(const SettingsList& settings) {
           break;
         case hq::SettingId::WT_ENABLED:
         case hq::SettingId::ENABLE_WEBTRANSPORT:
-          VLOG(3) << "Peer sent WT_ENABLED=" << setting.value;
+          PRX_VLOG(3) << "Peer sent WT_ENABLED=" << setting.value;
           supportsWebTransport_.set(folly::to_underlying(SettingEnabled::PEER));
           break;
         case hq::SettingId::H3_WT_MAX_SESSIONS:
-          VLOG(3) << "Peer sent WEBTRANSPORT_MAX_SESSIONS=" << setting.value;
+          PRX_VLOG(3) << "Peer sent WEBTRANSPORT_MAX_SESSIONS="
+                      << setting.value;
           supportsWebTransport_.set(folly::to_underlying(SettingEnabled::PEER));
           break;
         case hq::SettingId::WT_INITIAL_MAX_DATA:
-          VLOG(3) << "Peer sent WT_INITIAL_MAX_DATA=" << setting.value;
+          PRX_VLOG(3) << "Peer sent WT_INITIAL_MAX_DATA=" << setting.value;
           wtInitialSendWindow_ = setting.value;
           break;
       }
     }
   }
-  VLOG(3) << "Applied SETTINGS sess=" << *this << " tableSize=" << tableSize
-          << " blocked=" << blocked;
+  PRX_VLOG(3) << "Applied SETTINGS sess=" << *this << " tableSize=" << tableSize
+              << " blocked=" << blocked;
   qpackCodec_.setEncoderHeaderTableSize(tableSize);
   qpackCodec_.setMaxVulnerable(blocked);
 
@@ -1625,13 +1633,14 @@ void HQSession::onGoaway(uint64_t minUnseenId,
   // NOTE: This function needs to be idempotent. i.e. be a no-op if invoked
   // twice with the same lastGoodStreamID
   if (isDownstream(direction_)) {
-    VLOG(3) << "Ignoring downstream GOAWAY minUnseenId=" << minUnseenId
-            << " sess=" << *this;
+    PRX_VLOG(3) << "Ignoring downstream GOAWAY minUnseenId=" << minUnseenId
+                << " sess=" << *this;
     return;
   }
-  VLOG(3) << "Got GOAWAY minUnseenId=" << minUnseenId << " sess=" << *this;
+  PRX_VLOG(3) << "Got GOAWAY minUnseenId=" << minUnseenId << " sess=" << *this;
   if (minUnseenId > peerMinUnseenId_) {
-    LOG(ERROR) << "Goaway id increased=" << minUnseenId << " sess=" << *this;
+    PRX_LOG(ERROR) << "Goaway id increased=" << minUnseenId
+                   << " sess=" << *this;
     dropConnectionAsync(
         quic::QuicError(HTTP3::ErrorCode::HTTP_ID_ERROR, "GOAWAY id increased"),
         kErrorMalformedInput);
@@ -1661,11 +1670,11 @@ void HQSession::onGoaway(uint64_t minUnseenId,
 }
 
 void HQSession::onPriority(quic::StreamId streamId, const HTTPPriority& pri) {
-  CHECK(isDownstream(direction_));
+  PRX_CHECK(isDownstream(direction_));
   if (drainState_ != DrainState::NONE) {
     return;
   }
-  CHECK(sock_);
+  PRX_CHECK(sock_);
   // This also covers push streams:
   auto stream = findStream(streamId);
   if (!stream || (!stream->txn_.isPushed() && !stream->hasHeaders_)) {
@@ -1680,15 +1689,15 @@ void HQSession::onPriority(quic::StreamId streamId, const HTTPPriority& pri) {
 }
 
 void HQSession::onPushPriority(hq::PushId pushId, const HTTPPriority& pri) {
-  CHECK(isDownstream(direction_));
+  PRX_CHECK(isDownstream(direction_));
   if (drainState_ != DrainState::NONE) {
     return;
   }
-  CHECK(sock_);
+  PRX_CHECK(sock_);
 
   if (maxAllowedPushId_.hasValue() && *maxAllowedPushId_ < pushId) {
-    VLOG(4) << "Priority update stream id=" << pushId
-            << " greater than max allowed push id=" << *maxAllowedPushId_;
+    PRX_VLOG(4) << "Priority update stream id=" << pushId
+                << " greater than max allowed push id=" << *maxAllowedPushId_;
     dropConnectionAsync(quic::QuicError(HTTP3::ErrorCode::HTTP_ID_ERROR,
                                         "PushId is beyond max allowed push id"),
                         kErrorMalformedInput);
@@ -1696,7 +1705,7 @@ void HQSession::onPushPriority(hq::PushId pushId, const HTTPPriority& pri) {
   }
   auto iter = pushIdToStreamId_.find(pushId);
   if (iter == pushIdToStreamId_.end()) {
-    VLOG(4) << "Priority update of unknown push id=" << pushId;
+    PRX_VLOG(4) << "Priority update of unknown push id=" << pushId;
     return;
   }
   auto streamId = iter->second;
@@ -1717,11 +1726,11 @@ void HQSession::notifyEgressBodyBuffered(int64_t bytes) {
 }
 
 void HQSession::onFlowControlUpdate(quic::StreamId id) noexcept {
-  VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id;
 
   auto flowControl = sock_->getStreamFlowControl(id);
   if (flowControl.hasError()) {
-    LOG(ERROR) << "Got error=" << flowControl.error() << " streamID=" << id;
+    PRX_LOG(ERROR) << "Got error=" << flowControl.error() << " streamID=" << id;
     return;
   }
 
@@ -1741,8 +1750,8 @@ void HQSession::onFlowControlUpdate(quic::StreamId id) noexcept {
   auto stream = findEgressStream(id);
 
   if (!stream) {
-    LOG(ERROR) << "Got flow control update for unknown streamID=" << id
-               << " sess=" << this;
+    PRX_LOG(ERROR) << "Got flow control update for unknown streamID=" << id
+                   << " sess=" << this;
     return;
   }
 
@@ -1771,7 +1780,7 @@ void HQSession::onFlowControlUpdate(quic::StreamId id) noexcept {
 }
 
 void HQSession::onConnectionWriteReady(uint64_t maxToSend) noexcept {
-  VLOG(4) << __func__ << " sess=" << *this << ": maxToSend=" << maxToSend;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": maxToSend=" << maxToSend;
   scheduledWrite_ = false;
   maxToSend_ = maxToSend;
 
@@ -1780,7 +1789,8 @@ void HQSession::onConnectionWriteReady(uint64_t maxToSend) noexcept {
 
 void HQSession::onConnectionWriteError(quic::QuicError error) noexcept {
   scheduledWrite_ = false;
-  VLOG(4) << __func__ << " sess=" << *this << ": writeError error=" << error;
+  PRX_VLOG(4) << __func__ << " sess=" << *this
+              << ": writeError error=" << error;
   // Leave this as a no-op.  We will most likely get onConnectionError soon
 }
 
@@ -1793,7 +1803,7 @@ uint64_t HQSession::writeControlStreams(uint64_t maxEgress) {
       continue;
     }
     auto sent = controlStreamWriteImpl(&it.second, maxEgress);
-    DCHECK_LE(sent, maxEgress);
+    PRX_DCHECK_LE(sent, maxEgress);
     maxEgress -= sent;
     if (maxEgress == 0) {
       break;
@@ -1807,7 +1817,7 @@ uint64_t HQSession::controlStreamWriteImpl(HQControlStream* ctrlStream,
   auto egressStreamId = ctrlStream->getEgressStreamId();
   auto flowControl = sock_->getStreamFlowControl(egressStreamId);
   if (flowControl.hasError()) {
-    LOG(ERROR)
+    PRX_LOG(ERROR)
         << "Got error=" << flowControl.error() << " streamID=" << egressStreamId
         << " bufLen=" << static_cast<int>(ctrlStream->writeBuf_.chainLength())
         << " readEOF=" << ctrlStream->readEOF_;
@@ -1823,16 +1833,16 @@ uint64_t HQSession::controlStreamWriteImpl(HQControlStream* ctrlStream,
   auto sendLen = std::min(canSend, ctrlStream->writeBuf_.chainLength());
   auto tryWriteBuf = ctrlStream->writeBuf_.splitAtMost(canSend);
 
-  VLOG(4) << __func__ << " before write sess=" << *this
-          << ": streamID=" << egressStreamId << " maxEgress=" << maxEgress
-          << " sendWindow=" << streamSendWindow << " sendLen=" << sendLen;
+  PRX_VLOG(4) << __func__ << " before write sess=" << *this
+              << ": streamID=" << egressStreamId << " maxEgress=" << maxEgress
+              << " sendWindow=" << streamSendWindow << " sendLen=" << sendLen;
 
   auto writeRes = sock_->writeChain(
       egressStreamId, std::move(tryWriteBuf), false /*eof*/, nullptr);
 
   if (writeRes.hasError()) {
-    LOG(ERROR) << " Got error=" << writeRes.error()
-               << " streamID=" << egressStreamId;
+    PRX_LOG(ERROR) << " Got error=" << writeRes.error()
+                   << " streamID=" << egressStreamId;
     // Going to call this a write error no matter what the underlying reason was
     handleSessionError(ctrlStream,
                        StreamDirection::EGRESS,
@@ -1841,7 +1851,7 @@ uint64_t HQSession::controlStreamWriteImpl(HQControlStream* ctrlStream,
     return 0;
   }
 
-  VLOG(4)
+  PRX_VLOG(4)
       << __func__ << " after write sess=" << *this
       << ": streamID=" << ctrlStream->getEgressStreamId() << " sent=" << sendLen
       << " buflen=" << static_cast<int>(ctrlStream->writeBuf_.chainLength());
@@ -1861,18 +1871,19 @@ void HQSession::handleSessionError(HQStreamBase* stream,
                    ? ctrlStream->getEgressStreamId()
                    : ctrlStream->getIngressStreamId());
     // We will miss spurious control stream RST or write errors in the logs
-    VLOG(3) << "Got error on control stream error=" << err << " streamID=" << id
-            << " Dropping connection. sess=" << *this;
+    PRX_VLOG(3) << "Got error on control stream error=" << err
+                << " streamID=" << id << " Dropping connection. sess=" << *this;
     appErrorMsg = "HTTP error on control stream";
   } else {
     auto requestStream = dynamic_cast<HQStreamTransport*>(stream);
-    CHECK(requestStream);
+    PRX_CHECK(requestStream);
     auto id = requestStream->getEgressStreamId();
-    LOG(ERROR) << "Got error on request stream error=" << err
-               << " streamID=" << id << " Dropping connection. sess=" << *this;
+    PRX_LOG(ERROR) << "Got error on request stream error=" << err
+                   << " streamID=" << id
+                   << " Dropping connection. sess=" << *this;
     appErrorMsg = "HTTP error on request stream";
     // for request streams this function must be called with an ApplicationError
-    DCHECK(err.asApplicationErrorCode());
+    PRX_DCHECK(err.asApplicationErrorCode());
   }
   // errors on a control stream means we must drop the entire connection,
   // but there are some errors that we expect during shutdown
@@ -1919,7 +1930,7 @@ uint64_t HQSession::writeRequestStreams(uint64_t maxEgress) noexcept {
   while (!httpPriorityQueue_.empty() && maxEgress != 0) {
     auto id = httpPriorityQueue_.peekNextScheduledID().asStreamID();
     auto stream = findStream(id);
-    CHECK(stream);
+    PRX_CHECK(stream);
     auto pri = stream->queueHandle_.getPriority();
     auto maxStreamEgress = maxEgress;
     if (pri->incremental && httpPriorityQueue_.getRoundRobinElements() > 1) {
@@ -1928,7 +1939,7 @@ uint64_t HQSession::writeRequestStreams(uint64_t maxEgress) noexcept {
       httpPriorityQueue_.consume(maxStreamEgress);
     }
     auto sent = requestStreamWriteImpl(stream, maxStreamEgress, 1);
-    DCHECK_LE(sent, maxEgress);
+    PRX_DCHECK_LE(sent, maxEgress);
     maxEgress -= sent;
   }
 
@@ -1961,7 +1972,8 @@ void HQSession::handleWriteError(HQStreamTransportBase* hqStream,
       break;
     }
     case quic::QuicErrorCode::Type::TransportErrorCode: {
-      CHECK(false) << "Unexpected errorCode=" << *err.asTransportErrorCode();
+      PRX_CHECK(false) << "Unexpected errorCode="
+                       << *err.asTransportErrorCode();
     }
   }
   // Do I need a dguard here?
@@ -1984,8 +1996,8 @@ size_t HQSession::handleWrite(WriteFunc writeFunc,
                             sendEof,
                             deliveryCallback);
   if (writeRes.hasError()) {
-    LOG(ERROR) << " Got error=" << writeRes.error()
-               << " streamID=" << hqStream->getEgressStreamId();
+    PRX_LOG(ERROR) << " Got error=" << writeRes.error()
+                   << " streamID=" << hqStream->getEgressStreamId();
     handleWriteError(hqStream, writeRes.error());
     return 0;
   }
@@ -1993,7 +2005,7 @@ size_t HQSession::handleWrite(WriteFunc writeFunc,
   auto sent = dataChainLen;
   if (sendEof) {
     // This will hold the transaction open until onDeliveryAck or onCanceled
-    DCHECK(deliveryCallback);
+    PRX_DCHECK(deliveryCallback);
     hqStream->txn_.incrementPendingByteEvents();
     // NOTE: This may not be necessary long term, once we properly implement
     // detach or when we enforce flow control for headers and EOM
@@ -2010,13 +2022,13 @@ size_t HQSession::handleWrite(WriteFunc writeFunc,
 uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
                                            uint64_t maxEgress,
                                            double ratio) {
-  CHECK(hqStream->queueHandle_.isStreamTransportEnqueued());
+  PRX_CHECK(hqStream->queueHandle_.isStreamTransportEnqueued());
   HTTPTransaction::DestructorGuard dg(&hqStream->txn_);
 
   auto streamId = hqStream->getStreamId();
   auto flowControl = sock_->getStreamFlowControl(streamId);
   if (flowControl.hasError()) {
-    LOG(ERROR)
+    PRX_LOG(ERROR)
         << "Got error=" << flowControl.error() << " streamID=" << streamId
         << " detached=" << hqStream->detached_
         << " readBufLen=" << static_cast<int>(hqStream->readBuf_.chainLength())
@@ -2039,11 +2051,11 @@ uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
     // Populate the write buffer by telling the transaction how much
     // room is available for body data
     size_t maxBodySend = canSend - hqStream->writeBufferSize();
-    VLOG(4) << __func__ << " asking txn for more bytes sess=" << *this
-            << ": streamID=" << streamId << " canSend=" << canSend
-            << " remain=" << hqStream->writeBufferSize()
-            << " pendingEOM=" << hqStream->pendingEOM_
-            << " maxBodySend=" << maxBodySend << " ratio=" << ratio;
+    PRX_VLOG(4) << __func__ << " asking txn for more bytes sess=" << *this
+                << ": streamID=" << streamId << " canSend=" << canSend
+                << " remain=" << hqStream->writeBufferSize()
+                << " pendingEOM=" << hqStream->pendingEOM_
+                << " maxBodySend=" << maxBodySend << " ratio=" << ratio;
     hqStream->txn_.onWriteReady(maxBodySend, ratio);
     // onWriteReady may not be able to detach any byte from the deferred egress
     // body bytes, in case it's getting rate limited.
@@ -2067,11 +2079,11 @@ uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
   auto tryWriteBuf = hqStream->writeBuf_.splitAtMost(canSend);
   bool sendEof = (hqStream->pendingEOM_ && !hqStream->hasPendingBody());
   if (bufSendLen > 0 || sendEof) {
-    VLOG(4) << __func__ << " before write sess=" << *this
-            << ": streamID=" << streamId << " maxEgress=" << maxEgress
-            << " sendWindow=" << streamSendWindow
-            << " tryToSend=" << tryWriteBuf->computeChainDataLength()
-            << " sendEof=" << sendEof;
+    PRX_VLOG(4) << __func__ << " before write sess=" << *this
+                << ": streamID=" << streamId << " maxEgress=" << maxEgress
+                << " sendWindow=" << streamSendWindow
+                << " tryToSend=" << tryWriteBuf->computeChainDataLength()
+                << " sendEof=" << sendEof;
     sent = handleWrite(std::move(bufWritter),
                        hqStream,
                        std::move(tryWriteBuf),
@@ -2079,12 +2091,12 @@ uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
                        sendEof);
   }
 
-  VLOG(4) << __func__ << " after write sess=" << *this
-          << ": streamID=" << streamId << " sent=" << sent
-          << " buflen=" << hqStream->writeBufferSize()
-          << " hasPendingBody=" << hqStream->txn_.hasPendingBody()
-          << " EOM=" << hqStream->pendingEOM_;
-  CHECK_GE(maxEgress, sent);
+  PRX_VLOG(4) << __func__ << " after write sess=" << *this
+              << ": streamID=" << streamId << " sent=" << sent
+              << " buflen=" << hqStream->writeBufferSize()
+              << " hasPendingBody=" << hqStream->txn_.hasPendingBody()
+              << " EOM=" << hqStream->pendingEOM_;
+  PRX_CHECK_GE(maxEgress, sent);
 
   bool flowControlBlocked = (sent == streamSendWindow && !sendEof);
   if (flowControlBlocked) {
@@ -2102,11 +2114,12 @@ uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
   // enqueued
   if (hqStream->queueHandle_.isStreamTransportEnqueued() &&
       (!hqStream->hasPendingEgress() || flowControlBlocked)) {
-    VLOG(4) << "clearPendingEgress for " << hqStream->txn_;
+    PRX_VLOG(4) << "clearPendingEgress for " << hqStream->txn_;
     hqStream->clearPendingEgressStreamTransport();
   }
   if (flowControlBlocked && !hqStream->txn_.isEgressComplete()) {
-    VLOG(4) << __func__ << " txn flow control blocked, txn=" << hqStream->txn_;
+    PRX_VLOG(4) << __func__
+                << " txn flow control blocked, txn=" << hqStream->txn_;
     hqStream->txn_.pauseEgress();
   }
   return sent;
@@ -2115,27 +2128,28 @@ uint64_t HQSession::requestStreamWriteImpl(HQStreamTransportBase* hqStream,
 void HQSession::onDeliveryAck(quic::StreamId id,
                               uint64_t offset,
                               std::chrono::microseconds rtt) {
-  VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id
-          << " offset=" << offset;
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": streamID=" << id
+              << " offset=" << offset;
   auto pEgressStream = findEgressStream(id, true /* includeDetached */);
-  DCHECK(pEgressStream);
+  PRX_DCHECK(pEgressStream);
   if (pEgressStream) {
     pEgressStream->txn_.onEgressLastByteAck(
         std::chrono::duration_cast<std::chrono::milliseconds>(rtt));
     pEgressStream->txn_.decrementPendingByteEvents();
   } else {
-    LOG(ERROR) << " not expecting to receive delivery ack for erased stream";
+    PRX_LOG(ERROR)
+        << " not expecting to receive delivery ack for erased stream";
   }
 }
 
 void HQSession::onCanceled(quic::StreamId id, uint64_t /*offset*/) {
-  VLOG(3) << __func__ << " sess=" << *this << ": streamID=" << id;
+  PRX_VLOG(3) << __func__ << " sess=" << *this << ": streamID=" << id;
   auto pEgressStream = findEgressStream(id);
   if (pEgressStream) {
     pEgressStream->txn_.decrementPendingByteEvents();
   } else {
-    LOG(DFATAL) << __func__ << " sess=" << *this << ": streamID=" << id
-                << " onCanceled but txn missing, aborted without reset?";
+    PRX_LOG(DFATAL) << __func__ << " sess=" << *this << ": streamID=" << id
+                    << " onCanceled but txn missing, aborted without reset?";
   }
 }
 
@@ -2144,16 +2158,16 @@ void HQSession::HQControlStream::onDeliveryAck(
   // We set the delivery callback for the control stream to keep track of the
   // GOAWAY being delivered to the remote endpoint. When that happens we can
   // send a second GOAWAY. sendGoaway is a no-op after the second time
-  VLOG(3) << "GOAWAY received by remote endpoint on streamID=" << id
-          << " sess=" << session_;
+  PRX_VLOG(3) << "GOAWAY received by remote endpoint on streamID=" << id
+              << " sess=" << session_;
   session_.onGoawayAck();
 }
 
 void HQSession::HQControlStream::onCanceled(quic::StreamId id,
                                             uint64_t /*offset*/) {
   // This shouldn't really happen, but in case it does let's accelerate draining
-  VLOG(3) << "GOAWAY delivery callback canceled on streamID=" << id
-          << " sess=" << session_;
+  PRX_VLOG(3) << "GOAWAY delivery callback canceled on streamID=" << id
+              << " sess=" << session_;
   session_.drainState_ = DrainState::DONE;
   // if we are shutting down, do so in the loop callback
   session_.scheduleLoopCallback(false);
@@ -2171,16 +2185,16 @@ void HQSession::onGoawayAck() {
 
 HQSession::HQStreamTransport* FOLLY_NULLABLE
 HQSession::createStreamTransport(quic::StreamId streamId) {
-  VLOG(3) << __func__ << " sess=" << *this;
+  PRX_VLOG(3) << __func__ << " sess=" << *this;
 
   // Checking for egress and ingress streams as well
   auto streamAlreadyExists = findStream(streamId);
   if (!sock_->good() || streamAlreadyExists) {
-    VLOG(3) << __func__ << " Refusing to add a transaction on a closing "
-            << " session / existing transaction"
-            << " sock good: " << sock_->good()
-            << "; streams count: " << streams_.count(streamId) << "; streamId "
-            << streamId;
+    PRX_VLOG(3) << __func__ << " Refusing to add a transaction on a closing "
+                << " session / existing transaction"
+                << " sock good: " << sock_->good()
+                << "; streams count: " << streams_.count(streamId)
+                << "; streamId " << streamId;
     return nullptr;
   }
 
@@ -2215,8 +2229,8 @@ HQSession::createStreamTransport(quic::StreamId streamId) {
           folly::none /* assocStreamId */));
   incrementSeqNo();
 
-  CHECK(matchPair.second) << "Emplacement failed, despite earlier "
-                             "existence check.";
+  PRX_CHECK(matchPair.second) << "Emplacement failed, despite earlier "
+                                 "existence check.";
 
   // tracks max historical streams
   HTTPSessionBase::onNewOutgoingStream(getNumOutgoingStreams());
@@ -2230,10 +2244,10 @@ HQSession::createStreamTransport(quic::StreamId streamId) {
 std::unique_ptr<HTTPCodec> HQSession::createCodec(quic::StreamId streamId) {
   auto QPACKEncoderStream =
       findControlStream(UnidirectionalStreamType::QPACK_ENCODER);
-  DCHECK(QPACKEncoderStream);
+  PRX_DCHECK(QPACKEncoderStream);
   auto QPACKDecoderStream =
       findControlStream(UnidirectionalStreamType::QPACK_DECODER);
-  DCHECK(QPACKDecoderStream);
+  PRX_DCHECK(QPACKDecoderStream);
   auto codec = std::make_unique<hq::HQStreamCodec>(
       streamId,
       direction_,
@@ -2282,21 +2296,21 @@ HQSession::HQStreamTransportBase::HQStreamTransportBase(
            parentTxnId,
            session_.setIngressTimeoutAfterEom_),
       byteEventTracker_(nullptr, session.getQuicSocket(), streamId) {
-  VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
   byteEventTracker_.setTTLBAStats(session_.sessionStats_);
   quicStreamProtocolInfo_ = std::make_shared<QuicStreamProtocolInfo>();
 }
 
 void HQSession::HQStreamTransportBase::initCodec(
     std::unique_ptr<HTTPCodec> codec, const std::string& where) {
-  VLOG(3) << where << " " << __func__ << " txn=" << txn_;
-  CHECK(session_.sock_)
+  PRX_VLOG(3) << where << " " << __func__ << " txn=" << txn_;
+  PRX_CHECK(session_.sock_)
       << "Socket is null drainState=" << (int)session_.drainState_
       << " streams=" << session_.getNumStreams();
   realCodec_ = std::move(codec);
   if (session_.version_ == HQVersion::HQ) {
     auto c = dynamic_cast<hq::HQStreamCodec*>(realCodec_.get());
-    CHECK(c) << "HQ should use HQStream codec";
+    PRX_CHECK(c) << "HQ should use HQStream codec";
     c->setActivationHook([this] { return setActiveCodec("self"); });
   }
   auto g = folly::makeGuard(setActiveCodec(__func__));
@@ -2307,8 +2321,8 @@ void HQSession::HQStreamTransportBase::initCodec(
 }
 
 void HQSession::HQStreamTransportBase::initIngress(const std::string& where) {
-  VLOG(3) << where << " " << __func__ << " txn=" << txn_;
-  CHECK(session_.sock_)
+  PRX_VLOG(3) << where << " " << __func__ << " txn=" << txn_;
+  PRX_CHECK(session_.sock_)
       << "Socket is null drainState=" << (int)session_.drainState_
       << " streams=" << session_.getNumStreams();
 
@@ -2326,24 +2340,24 @@ void HQSession::HQStreamTransportBase::initIngress(const std::string& where) {
 
 HTTPTransaction* FOLLY_NULLABLE
 HQSession::newTransaction(HTTPTransaction::Handler* handler) {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   setStreamLimitExceeded(false);
 
   if (drainState_ == DrainState::CLOSE_SENT ||
       drainState_ == DrainState::FIRST_GOAWAY ||
       drainState_ == DrainState::DONE) {
-    VLOG(4) << __func__ << " newTransaction after drain: " << *this;
+    PRX_VLOG(4) << __func__ << " newTransaction after drain: " << *this;
     return nullptr;
   }
   if (!sock_->good()) {
-    VLOG(4) << __func__ << " newTransaction after sock went bad: " << this;
+    PRX_VLOG(4) << __func__ << " newTransaction after sock went bad: " << this;
     return nullptr;
   }
 
   // TODO stream limit handling
   auto quicStreamId = sock_->createBidirectionalStream();
   if (!quicStreamId) {
-    VLOG(2) << __func__ << " failed to create new stream: " << this;
+    PRX_VLOG(2) << __func__ << " failed to create new stream: " << this;
     setStreamLimitExceeded(true);
     return nullptr;
   }
@@ -2354,22 +2368,22 @@ HQSession::newTransaction(HTTPTransaction::Handler* handler) {
     // generate grease frame
     auto writeGreaseFrameResult = hq::writeGreaseFrame(hqStream->writeBuf_);
     if (!writeGreaseFrameResult) {
-      VLOG(2) << __func__ << " failed to create grease frame: " << *this;
+      PRX_VLOG(2) << __func__ << " failed to create grease frame: " << *this;
       return nullptr;
     }
   }
 
   if (hqStream) {
     // DestructorGuard dg(this);
-    hqStream->txn_.setHandler(CHECK_NOTNULL(handler));
+    hqStream->txn_.setHandler(PRX_CHECK_NOTNULL(handler));
     sock_->setReadCallback(quicStreamId.value(), this);
     if (ingressLimitExceeded()) {
       sock_->pauseRead(quicStreamId.value());
     }
     return &hqStream->txn_;
   } else {
-    VLOG(3) << __func__ << "Failed to create new transaction on "
-            << quicStreamId.value();
+    PRX_VLOG(3) << __func__ << "Failed to create new transaction on "
+                << quicStreamId.value();
     abortStream(HTTPException::Direction::INGRESS_AND_EGRESS,
                 quicStreamId.value(),
                 HTTP3::ErrorCode::HTTP_INTERNAL_ERROR);
@@ -2378,9 +2392,9 @@ HQSession::newTransaction(HTTPTransaction::Handler* handler) {
 }
 
 void HQSession::startNow() {
-  VLOG(4) << __func__ << " sess=" << *this;
-  CHECK(!started_);
-  CHECK(sock_);
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
+  PRX_CHECK(!started_);
+  PRX_CHECK(sock_);
   started_ = true;
   transportInfo_.secure = true;
   transportInfo_.validTcpinfo = true;
@@ -2404,8 +2418,8 @@ void HQSession::HQStreamTransportBase::checkForDetach() {
 
 bool HQSession::HQStreamTransportBase::getCurrentTransportInfo(
     wangle::TransportInfo* tinfo) {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(quicStreamProtocolInfo_.get());
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(quicStreamProtocolInfo_.get());
   bool success = session_.getCurrentTransportInfo(tinfo);
 
   // Save connection-level protocol fields in the HQStreamTransport-level
@@ -2446,14 +2460,14 @@ void HQSession::detachStreamTransport(HQStreamTransportBase* hqStream) {
   // prior to being erased
   if (hqStream->hasIngressStreamId() || hqStream->hasEgressStreamId()) {
     auto streamId = hqStream->getStreamId();
-    VLOG(4) << __func__ << " streamID=" << streamId;
-    CHECK(findStream(streamId));
+    PRX_VLOG(4) << __func__ << " streamID=" << streamId;
+    PRX_CHECK(findStream(streamId));
     if (sock_ && hqStream->hasIngressStreamId()) {
       clearStreamCallbacks(streamId);
     }
     eraseStream(streamId);
   } else {
-    VLOG(4) << __func__ << " streamID=NA";
+    PRX_VLOG(4) << __func__ << " streamID=NA";
     eraseUnboundStream(hqStream);
   }
 
@@ -2481,13 +2495,13 @@ void HQSession::HQControlStream::processReadData() {
     // chain callbacks
     savedCodec = std::move(realCodec_);
     realCodec_.reset(static_cast<HQControlCodec*>(ingressCodec_.release()));
-    CHECK(!ingressCodec_);
+    PRX_CHECK(!ingressCodec_);
   }
   auto g1 = folly::makeGuard([&] {
     if (!isControl) {
       return;
     }
-    CHECK(!ingressCodec_);
+    PRX_CHECK(!ingressCodec_);
     ingressCodec_.reset(static_cast<HQControlCodec*>(realCodec_.release()));
     realCodec_ = std::move(savedCodec);
   });
@@ -2495,7 +2509,7 @@ void HQSession::HQControlStream::processReadData() {
   if (isControl) {
     // Now ingressCodec_ has been pushed onto the codec stack.  Restore the
     // egress codec, in case an ingress callback triggers egress
-    CHECK(!realCodec_);
+    PRX_CHECK(!realCodec_);
     realCodec_ = std::move(savedCodec);
   }
   auto g2 = folly::makeGuard([&] {
@@ -2505,14 +2519,14 @@ void HQSession::HQControlStream::processReadData() {
     savedCodec = std::move(realCodec_);
   });
 
-  CHECK(ingressCodecPtr->isIngress());
+  PRX_CHECK(ingressCodecPtr->isIngress());
   auto initialLength = readBuf_.chainLength();
   if (initialLength > 0) {
     auto ret = ingressCodecPtr->onUnidirectionalIngress(readBuf_.move());
-    VLOG(4) << "streamID=" << getIngressStreamId() << " parsed bytes="
-            << static_cast<int>(initialLength - readBuf_.chainLength())
-            << " from readBuf remain=" << readBuf_.chainLength()
-            << " eof=" << readEOF_;
+    PRX_VLOG(4) << "streamID=" << getIngressStreamId() << " parsed bytes="
+                << static_cast<int>(initialLength - readBuf_.chainLength())
+                << " from readBuf remain=" << readBuf_.chainLength()
+                << " eof=" << readEOF_;
     readBuf_.append(std::move(ret));
   }
   if (readEOF_ && readBuf_.chainLength() == 0) {
@@ -2524,8 +2538,8 @@ bool HQSession::HQStreamTransportBase::processReadData() {
   auto g = folly::makeGuard(setActiveCodec(__func__));
   if (eomGate_.get(EOMType::CODEC) && readBuf_.chainLength() > 0) {
     // why are we calling processReadData with no data?
-    VLOG(3) << " Received data after HTTP EOM for txn=" << txn_
-            << ", len=" << static_cast<int>(readBuf_.chainLength());
+    PRX_VLOG(3) << " Received data after HTTP EOM for txn=" << txn_
+                << ", len=" << static_cast<int>(readBuf_.chainLength());
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
                      "Unexpected data after request");
     errorOnTransaction(ex);
@@ -2538,10 +2552,10 @@ bool HQSession::HQStreamTransportBase::processReadData() {
       readBuf_.pop_front();
     }
     size_t bytesParsed = codecFilterChain->onIngress(*readBuf_.front());
-    VLOG(4) << "streamID=" << getStreamId()
-            << " parsed bytes=" << static_cast<int>(bytesParsed)
-            << " from readBuf remain=" << readBuf_.chainLength()
-            << " eof=" << readEOF_;
+    PRX_VLOG(4) << "streamID=" << getStreamId()
+                << " parsed bytes=" << static_cast<int>(bytesParsed)
+                << " from readBuf remain=" << readBuf_.chainLength()
+                << " eof=" << readEOF_;
     if (bytesParsed == 0) {
       break;
     }
@@ -2572,13 +2586,13 @@ void HQSession::HQStreamTransportBase::setPriority(quic::QuicSocket& sock,
 // see specific comments in the method body
 void HQSession::HQStreamTransportBase::onHeadersComplete(
     HTTPCodec::StreamID streamID, std::unique_ptr<HTTPMessage> msg) {
-  VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
   msg->dumpMessage(3);
   // TODO: the codec will set this
   msg->setAdvancedProtocolString(session_.alpn_);
   msg->setSecure(true);
-  CHECK(codecStreamId_);
-  CHECK_EQ(streamID, *codecStreamId_);
+  PRX_CHECK(codecStreamId_);
+  PRX_CHECK_EQ(streamID, *codecStreamId_);
 
   if (msg->isRequest() && session_.userAgent_.empty()) {
     session_.userAgent_ = session_.codec_->getUserAgent();
@@ -2608,14 +2622,14 @@ void HQSession::HQStreamTransportBase::onHeadersComplete(
           });
     }
     if (HTTPWebTransport::isConnectMessage(*msg)) {
-      VLOG(3) << "Peer sent WT Connect";
+      PRX_VLOG(3) << "Peer sent WT Connect";
       session_.supportsWebTransport_.set(
           folly::to_underlying(SettingEnabled::PEER));
     }
   } else if (msg->isResponse() && msg->getStatusCode() == 200 &&
              txn_.isWebTransportConnectStream() && !wtSess_) {
     if (!session_.wtFilter_) {
-      VLOG(4) << "Received a 200 resp for a WT connect req";
+      PRX_VLOG(4) << "Received a 200 resp for a WT connect req";
       session_.wtFilter_ = WebTransportFilter::make(&txn_, CodecVersion::H3);
       session_.wtFilter_->setWebTransportImpl(txn_.getWebTransport());
     }
@@ -2699,28 +2713,28 @@ void HQSession::HQStreamTransportBase::onHeadersComplete(
 void HQSession::HQStreamTransportBase::transactionTimeout(
     HTTPTransaction* txn) noexcept {
   auto g = folly::makeGuard(setActiveCodec(__func__));
-  VLOG(4) << __func__ << " txn=" << txn_;
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_DCHECK(txn == &txn_);
 
   if (txn->isPushed()) {
     if (!hasIngressStreamId()) {
       // This transaction has not been assigned a stream id yet.
       // Do not attempt to close the stream but do invoke
       // the timeout on the txn
-      VLOG(3) << "Transaction timeout on pushedTxn pushId=" << txn->getID();
+      PRX_VLOG(3) << "Transaction timeout on pushedTxn pushId=" << txn->getID();
       txn_.onIngressTimeout();
       return;
     }
   }
   // Verify that the transaction has egress or ingress stream
-  DCHECK(hasIngressStreamId() || hasEgressStreamId())
+  PRX_DCHECK(hasIngressStreamId() || hasEgressStreamId())
       << "Timeout on transaction without stream id txnID=" << txn->getID()
       << " isPushed=" << txn->isPushed();
   // A transaction has timed out.  If the transaction does not have
   // a Handler yet, because we haven't yet received the full request
   // headers, we give it a DirectResponseHandler that generates an
   // error page.
-  VLOG(3) << "Transaction timeout for streamID=" << getStreamId();
+  PRX_VLOG(3) << "Transaction timeout for streamID=" << getStreamId();
 
   if (!codecStreamId_) {
     // transactionTimeout before onMessageBegin
@@ -2729,12 +2743,12 @@ void HQSession::HQStreamTransportBase::transactionTimeout(
 
   if (!txn_.getHandler() &&
       txn_.getEgressState() == HTTPTransactionEgressSM::State::Start) {
-    VLOG(4) << " Timed out receiving headers. " << this;
+    PRX_VLOG(4) << " Timed out receiving headers. " << this;
     if (session_.infoCallback_) {
       session_.infoCallback_->onIngressError(session_, kErrorTimeout);
     }
 
-    VLOG(4) << " creating direct error handler. " << this;
+    PRX_VLOG(4) << " creating direct error handler. " << this;
     auto handler = session_.getTransactionTimeoutHandler(&txn_);
     txn_.setHandler(handler);
   }
@@ -2757,8 +2771,8 @@ void HQSession::HQStreamTransportBase::transactionTimeout(
 void HQSession::abortStream(HTTPException::Direction dir,
                             quic::StreamId id,
                             HTTP3::ErrorCode err) {
-  VLOG(4) << __func__ << "sess=" << *this << " id=" << id << " err=" << err;
-  CHECK(sock_);
+  PRX_VLOG(4) << __func__ << "sess=" << *this << " id=" << id << " err=" << err;
+  PRX_CHECK(sock_);
   if (isUpstream(direction_) &&
       err == HTTP3::ErrorCode::HTTP_REQUEST_REJECTED) {
     // Clients MUST NOT use the H3_REQUEST_REJECTED error code, except when a
@@ -2788,7 +2802,7 @@ void HQSession::abortStream(quic::StreamId id) {
   auto cancel = qpackCodec_.encodeCancelStream(id);
   auto QPACKDecoderStream =
       findControlStream(hq::UnidirectionalStreamType::QPACK_DECODER);
-  DCHECK(QPACKDecoderStream);
+  PRX_DCHECK(QPACKDecoderStream);
   QPACKDecoderStream->writeBuf_.append(std::move(cancel));
   scheduleWrite();
 }
@@ -2810,7 +2824,7 @@ HQSession::HQStreamTransportBase::generateHeadersCommon(
     bool includeEOM,
     HTTPHeaderSize* size) noexcept {
   const uint64_t oldOffset = streamWriteByteOffset();
-  CHECK(codecStreamId_)
+  PRX_CHECK(codecStreamId_)
       << "Trying to send headers on an half open stream isRequest="
       << headers.isRequest()
       << "; assocTxnId=" << txn_.getAssocTxnId().value_or(-1)
@@ -2824,9 +2838,10 @@ HQSession::HQStreamTransportBase::generateHeadersCommon(
 
   const uint64_t newOffset = streamWriteByteOffset();
   if (size) {
-    VLOG(4) << "sending headers, size=" << size->compressed
-            << ", compressedBlock=" << size->compressedBlock
-            << ", uncompressedSize=" << size->uncompressed << " txn=" << txn_;
+    PRX_VLOG(4) << "sending headers, size=" << size->compressed
+                << ", compressedBlock=" << size->compressedBlock
+                << ", uncompressedSize=" << size->uncompressed
+                << " txn=" << txn_;
   }
 
   // only do it for downstream now to bypass handling upstream reuse cases
@@ -2862,9 +2877,10 @@ void HQSession::HQStreamTransportBase::sendHeaders(HTTPTransaction* txn,
                                                    const HTTPMessage& headers,
                                                    HTTPHeaderSize* size,
                                                    bool includeEOM) noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
 
   updatePriority(headers);
   // If this is a push promise, send it on the parent stream.
@@ -2881,7 +2897,7 @@ void HQSession::HQStreamTransportBase::sendHeaders(HTTPTransaction* txn,
   auto newOffset = headerGenOffsets.second;
 
   if (includeEOM) {
-    CHECK_GE(newOffset, oldOffset);
+    PRX_CHECK_GE(newOffset, oldOffset);
     session_.handleLastByteEvents(&byteEventTracker_,
                                   &txn_,
                                   newOffset - oldOffset,
@@ -2927,14 +2943,15 @@ void HQSession::HQStreamTransportBase::sendHeaders(HTTPTransaction* txn,
 
 size_t HQSession::HQStreamTransportBase::sendEOM(
     HTTPTransaction* txn, const HTTPHeaders* trailers) noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
   auto g = folly::makeGuard(setActiveCodec(__func__));
 
   size_t encodedSize = 0;
 
-  CHECK(codecStreamId_);
+  PRX_CHECK(codecStreamId_);
   if (trailers) {
     encodedSize = codecFilterChain->generateTrailers(
         writeBuf_, *codecStreamId_, *trailers);
@@ -2985,7 +3002,7 @@ size_t HQSession::HQStreamTransportBase::sendAbort(
 
 size_t HQSession::HQStreamTransportBase::sendAbortImpl(HTTP3::ErrorCode code,
                                                        std::string errorMsg) {
-  VLOG(4) << __func__ << " txn=" << txn_ << " msg=" << errorMsg;
+  PRX_VLOG(4) << __func__ << " txn=" << txn_ << " msg=" << errorMsg;
 
   // If the HQ stream is bound to a transport stream, abort it.
   if (hasStreamId()) {
@@ -3017,19 +3034,19 @@ size_t HQSession::HQStreamTransportBase::sendAbortImpl(HTTP3::ErrorCode code,
 }
 
 void HQSession::HQStreamTransportBase::abortIngress() {
-  VLOG(4) << "Aborting ingress for " << txn_;
+  PRX_VLOG(4) << "Aborting ingress for " << txn_;
   ingressError_ = true;
   readBuf_.move();
   codecFilterChain->setParserPaused(true);
 }
 
 void HQSession::HQStreamTransportBase::abortEgress(bool checkForDetach) {
-  VLOG(4) << "Aborting egress for " << txn_;
+  PRX_VLOG(4) << "Aborting egress for " << txn_;
   byteEventTracker_.drainByteEvents();
   writeBuf_.move();
   pendingEOM_ = false;
   if (queueHandle_.isStreamTransportEnqueued()) {
-    VLOG(4) << "clearPendingEgress for " << txn_;
+    PRX_VLOG(4) << "clearPendingEgress for " << txn_;
     clearPendingEgressStreamTransport();
   }
   if (checkForDetach) {
@@ -3051,11 +3068,11 @@ void HQSession::HQControlStream::onError(HTTPCodec::StreamID streamID,
         isQPACKError(error.getHttp3ErrorCode()) ? kErrorBadDecompress
                                                 : kErrorMessage);
   }
-  LOG(ERROR) << "Got error on control stream error="
-             << toString(error.getHttp3ErrorCode()) << " streamID=" << streamID
-             << " sess=" << session_;
+  PRX_LOG(ERROR) << "Got error on control stream error="
+                 << toString(error.getHttp3ErrorCode())
+                 << " streamID=" << streamID << " sess=" << session_;
   session_.handleSessionError(
-      CHECK_NOTNULL(session_.findControlStream(streamID)),
+      PRX_CHECK_NOTNULL(session_.findControlStream(streamID)),
       StreamDirection::INGRESS,
       error.getHttp3ErrorCode(),
       kErrorConnection);
@@ -3064,11 +3081,11 @@ void HQSession::HQControlStream::onError(HTTPCodec::StreamID streamID,
 void HQSession::HQStreamTransportBase::onError(HTTPCodec::StreamID streamID,
                                                const HTTPException& error,
                                                bool /* newTxn */) {
-  VLOG(4) << __func__ << " (from Codec) txn=" << txn_ << " err=" << error;
+  PRX_VLOG(4) << __func__ << " (from Codec) txn=" << txn_ << " err=" << error;
   // Codec must either call onMessageComplete or onError, but not both
   // I think.  The exception might be if stream has more than one HTTP
   // message on it.
-  CHECK(!eomGate_.get(EOMType::CODEC));
+  PRX_CHECK(!eomGate_.get(EOMType::CODEC));
   ingressError_ = true;
 
   if (streamID == kSessionStreamId) {
@@ -3078,9 +3095,10 @@ void HQSession::HQStreamTransportBase::onError(HTTPCodec::StreamID streamID,
           isQPACKError(error.getHttp3ErrorCode()) ? kErrorBadDecompress
                                                   : kErrorMessage);
     }
-    LOG(ERROR) << "Got session error error="
-               << toString(error.getHttp3ErrorCode()) << " msg=" << error
-               << " streamID=" << getIngressStreamId() << " sess=" << session_;
+    PRX_LOG(ERROR)
+        << "Got session error error=" << toString(error.getHttp3ErrorCode())
+        << " msg=" << error << " streamID=" << getIngressStreamId()
+        << " sess=" << session_;
     session_.handleSessionError(this,
                                 StreamDirection::INGRESS,
                                 error.getHttp3ErrorCode(),
@@ -3097,8 +3115,8 @@ void HQSession::HQStreamTransportBase::onError(HTTPCodec::StreamID streamID,
       txn_.getEgressState() == HTTPTransactionEgressSM::State::Start) {
     if (error.getDirection() != HTTPException::Direction::INGRESS) {
       // Direct error handler only process INGRESS
-      LOG(DFATAL) << "Codec gave egress error with no handler sess="
-                  << session_;
+      PRX_LOG(DFATAL) << "Codec gave egress error with no handler sess="
+                      << session_;
     }
     session_.abortStream(HTTPException::Direction::INGRESS,
                          getIngressStreamId(),
@@ -3131,7 +3149,7 @@ void HQSession::HQStreamTransportBase::onResetStream(HTTP3::ErrorCode errorCode,
   }
 
   if (errorCode == HTTP3::ErrorCode::HTTP_REQUEST_REJECTED) {
-    VLOG_IF(2, isDownstream(session_.direction_))
+    PRX_VLOG_IF(2, isDownstream(session_.direction_))
         << "RST_STREAM/REJECTED should not be sent by clients txn=" << txn_;
     // kErrorStreamUnacknowledged signals that this is safe to retry
     ex.setProxygenError(kErrorStreamUnacknowledged);
@@ -3151,8 +3169,9 @@ void HQSession::HQStreamTransportBase::onResetStream(HTTP3::ErrorCode errorCode,
 }
 
 void HQSession::HQStreamTransportBase::notifyPendingEgress() noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
   signalPendingEgressStreamTransport();
   session_.scheduleWrite();
 }
@@ -3163,8 +3182,8 @@ void HQSession::HQStreamTransportBase::coalesceEOM(size_t encodedBodyBytes) {
                                 encodedBodyBytes,
                                 streamWriteByteOffset(),
                                 true);
-  VLOG(3) << "sending EOM in body for streamID=" << getStreamId()
-          << " txn=" << txn_;
+  PRX_VLOG(3) << "sending EOM in body for streamID=" << getStreamId()
+              << " txn=" << txn_;
   pendingEOM_ = true;
   auto timeDiff = std::chrono::duration_cast<std::chrono::milliseconds>(
       std::chrono::steady_clock::now() - createdTime);
@@ -3182,14 +3201,15 @@ size_t HQSession::HQStreamTransportBase::sendBody(
     bool includeEOM,
     bool /* trackLastByteFlushed */) noexcept {
   auto bodyLength = body->computeChainDataLength();
-  VLOG(4) << __func__ << " len=" << bodyLength << " eof=" << includeEOM
-          << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " len=" << bodyLength << " eof=" << includeEOM
+              << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
   uint64_t offset = streamWriteByteOffset();
 
   auto g = folly::makeGuard(setActiveCodec(__func__));
-  CHECK(codecStreamId_);
+  PRX_CHECK(codecStreamId_);
   size_t encodedSize = codecFilterChain->generateBody(writeBuf_,
                                                       *codecStreamId_,
                                                       std::move(body),
@@ -3221,11 +3241,12 @@ size_t HQSession::HQStreamTransportBase::sendBody(
 
 size_t HQSession::HQStreamTransportBase::sendChunkHeader(
     HTTPTransaction* txn, size_t length) noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
   auto g = folly::makeGuard(setActiveCodec(__func__));
-  CHECK(codecStreamId_);
+  PRX_CHECK(codecStreamId_);
   size_t encodedSize =
       codecFilterChain->generateChunkHeader(writeBuf_, *codecStreamId_, length);
   notifyPendingEgress();
@@ -3234,11 +3255,12 @@ size_t HQSession::HQStreamTransportBase::sendChunkHeader(
 
 size_t HQSession::HQStreamTransportBase::sendChunkTerminator(
     HTTPTransaction* txn) noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
   auto g = folly::makeGuard(setActiveCodec(__func__));
-  CHECK(codecStreamId_);
+  PRX_CHECK(codecStreamId_);
   size_t encodedSize =
       codecFilterChain->generateChunkTerminator(writeBuf_, *codecStreamId_);
   notifyPendingEgress();
@@ -3247,11 +3269,12 @@ size_t HQSession::HQStreamTransportBase::sendChunkTerminator(
 
 size_t HQSession::HQStreamTransportBase::sendPadding(
     HTTPTransaction* txn, uint16_t padding) noexcept {
-  VLOG(4) << __func__ << " txn=" << txn_ << " padding=" << padding;
-  CHECK(hasEgressStreamId()) << __func__ << " invoked on stream without egress";
-  DCHECK(txn == &txn_);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_ << " padding=" << padding;
+  PRX_CHECK(hasEgressStreamId())
+      << __func__ << " invoked on stream without egress";
+  PRX_DCHECK(txn == &txn_);
   auto g = folly::makeGuard(setActiveCodec(__func__));
-  CHECK(codecStreamId_);
+  PRX_CHECK(codecStreamId_);
   size_t encodedSize =
       codecFilterChain->generatePadding(writeBuf_, *codecStreamId_, padding);
   if (encodedSize > 0) {
@@ -3262,13 +3285,14 @@ size_t HQSession::HQStreamTransportBase::sendPadding(
 
 void HQSession::HQStreamTransportBase::onMessageBegin(
     HTTPCodec::StreamID streamID, HTTPMessage* /* msg */) {
-  VLOG(4) << __func__ << " txn=" << txn_ << " streamID=" << streamID
-          << " ingressPushId=" << ingressPushId_.value_or(-1);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_ << " streamID=" << streamID
+              << " ingressPushId=" << ingressPushId_.value_or(-1);
 
   if (ingressPushId_) {
     constexpr auto error =
         "Received onMessageBegin in the middle of push promise";
-    LOG(ERROR) << error << " streamID=" << streamID << " session=" << session_;
+    PRX_LOG(ERROR) << error << " streamID=" << streamID
+                   << " session=" << session_;
     // TODO: Audit this error code
     session_.dropConnectionAsync(
         quic::QuicError(HTTP3::ErrorCode::HTTP_FRAME_ERROR, error),
@@ -3301,9 +3325,9 @@ void HQSession::HQStreamTransportBase::trackEgressBodyOffset(
   // We need to track last byte sent offset, so substract one here.
   auto offset = streamOffset - 1;
   armEgressBodyCallbacks(bodyOffset, offset, eventFlags);
-  VLOG(4) << __func__ << ": armed body byte event cb for offset=" << offset
-          << "; body offset=" << bodyOffset
-          << "; flags=" << uint32_t(eventFlags) << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__ << ": armed body byte event cb for offset=" << offset
+              << "; body offset=" << bodyOffset
+              << "; flags=" << uint32_t(eventFlags) << "; txn=" << txn_;
 }
 
 void HQSession::HQStreamTransportBase::armStreamByteEventCb(
@@ -3313,7 +3337,7 @@ void HQSession::HQStreamTransportBase::armStreamByteEventCb(
   if (res.hasError()) {
     auto errStr = folly::to<std::string>(
         "failed to register byte event callback: ", toString(res.error()));
-    LOG(ERROR) << errStr;
+    PRX_LOG(ERROR) << errStr;
     HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, errStr);
     ex.setProxygenError(kErrorNetwork);
     errorOnTransaction(ex);
@@ -3325,15 +3349,16 @@ void HQSession::HQStreamTransportBase::armStreamByteEventCb(
   // and ack/cancel from transport here.
   txn_.incrementPendingByteEvents();
 
-  VLOG(4) << __func__ << ": registered type=" << uint32_t(type)
-          << " callback for offset=" << streamOffset << "; sess=" << session_
-          << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__ << ": registered type=" << uint32_t(type)
+              << " callback for offset=" << streamOffset
+              << "; sess=" << session_ << "; txn=" << txn_;
 }
 
 void HQSession::HQStreamTransportBase::armEgressHeadersAckCb(
     uint64_t streamOffset) {
-  VLOG(4) << __func__ << ": registering headers delivery callback for offset="
-          << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__
+              << ": registering headers delivery callback for offset="
+              << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
   armStreamByteEventCb(streamOffset, quic::ByteEvent::Type::ACK);
   egressHeadersAckOffset_ = streamOffset;
 }
@@ -3342,9 +3367,10 @@ void HQSession::HQStreamTransportBase::armEgressBodyCallbacks(
     uint64_t bodyOffset,
     uint64_t streamOffset,
     proxygen::ByteEvent::EventFlags eventFlags) {
-  VLOG(4) << __func__ << ": registering body byte event callback for offset="
-          << streamOffset << "; flags=" << uint32_t(eventFlags)
-          << "; sess=" << session_ << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__
+              << ": registering body byte event callback for offset="
+              << streamOffset << "; flags=" << uint32_t(eventFlags)
+              << "; sess=" << session_ << "; txn=" << txn_;
   if (eventFlags & proxygen::ByteEvent::EventFlags::TX) {
     armStreamByteEventCb(streamOffset, quic::ByteEvent::Type::TX);
     auto res = egressBodyByteEventOffsets_.try_emplace(
@@ -3365,16 +3391,17 @@ void HQSession::HQStreamTransportBase::armEgressBodyCallbacks(
 
 void HQSession::HQStreamTransportBase::handleHeadersAcked(
     uint64_t streamOffset) {
-  CHECK(egressHeadersAckOffset_);
+  PRX_CHECK(egressHeadersAckOffset_);
   if (*egressHeadersAckOffset_ != streamOffset) {
-    LOG(ERROR)
+    PRX_LOG(ERROR)
         << ": bad offset for egress headers ack: e=" << *egressHeadersAckOffset_
         << ", r=" << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
     return;
   }
 
-  VLOG(4) << __func__ << ": got delivery ack for egress headers, stream offset="
-          << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__
+              << ": got delivery ack for egress headers, stream offset="
+              << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
 
   resetEgressHeadersAckOffset();
   txn_.onLastEgressHeaderByteAcked();
@@ -3386,13 +3413,14 @@ void HQSession::HQStreamTransportBase::handleBodyEvent(
 
   auto bodyOffset = resetEgressBodyEventOffset(streamOffset);
   if (!bodyOffset) {
-    LOG(DFATAL) << __func__ << ": received an unexpected byte event at offset "
-                << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
+    PRX_LOG(DFATAL)
+        << __func__ << ": received an unexpected byte event at offset "
+        << streamOffset << "; sess=" << session_ << "; txn=" << txn_;
     return;
   }
-  VLOG(4) << __func__ << ": got byte event type=" << uint32_t(type)
-          << " for egress body, bodyOffset=" << *bodyOffset
-          << "; sess=" << session_ << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__ << ": got byte event type=" << uint32_t(type)
+              << " for egress body, bodyOffset=" << *bodyOffset
+              << "; sess=" << session_ << "; txn=" << txn_;
 
   if (type == quic::ByteEvent::Type::ACK) {
     txn_.onEgressBodyBytesAcked(*bodyOffset);
@@ -3407,9 +3435,9 @@ void HQSession::HQStreamTransportBase::handleBodyEventCancelled(
 
   auto bodyOffset = resetEgressBodyEventOffset(streamOffset);
   if (!bodyOffset) {
-    LOG(DFATAL) << __func__
-                << ": received an unexpected onCanceled event at offset "
-                << streamOffset;
+    PRX_LOG(DFATAL) << __func__
+                    << ": received an unexpected onCanceled event at offset "
+                    << streamOffset;
     return;
   }
   // Use the same callback whether the body did not TX or did not ACK.  Caller
@@ -3418,11 +3446,12 @@ void HQSession::HQStreamTransportBase::handleBodyEventCancelled(
 }
 
 void HQSession::HQStreamTransportBase::onByteEvent(quic::ByteEvent byteEvent) {
-  VLOG(4) << __func__ << ": got byte event type=" << uint32_t(byteEvent.type)
-          << " for offset=" << byteEvent.offset << "; sess=" << session_
-          << "; txn=" << txn_;
+  PRX_VLOG(4) << __func__
+              << ": got byte event type=" << uint32_t(byteEvent.type)
+              << " for offset=" << byteEvent.offset << "; sess=" << session_
+              << "; txn=" << txn_;
 
-  DCHECK_GT(numActiveDeliveryCallbacks_, 0);
+  PRX_DCHECK_GT(numActiveDeliveryCallbacks_, 0u);
   numActiveDeliveryCallbacks_--;
   txn_.decrementPendingByteEvents();
 
@@ -3441,11 +3470,11 @@ void HQSession::HQStreamTransportBase::onByteEvent(quic::ByteEvent byteEvent) {
 
 void HQSession::HQStreamTransportBase::onByteEventCanceled(
     quic::ByteEventCancellation cancellation) {
-  VLOG(3) << __func__ << ": data cancelled on stream=" << cancellation.id
-          << ", type=" << uint32_t(cancellation.type)
-          << ", offset=" << cancellation.offset << "; sess=" << session_
-          << "; txn=" << txn_;
-  DCHECK_GT(numActiveDeliveryCallbacks_, 0);
+  PRX_VLOG(3) << __func__ << ": data cancelled on stream=" << cancellation.id
+              << ", type=" << uint32_t(cancellation.type)
+              << ", offset=" << cancellation.offset << "; sess=" << session_
+              << "; txn=" << txn_;
+  PRX_DCHECK_GT(numActiveDeliveryCallbacks_, 0u);
   numActiveDeliveryCallbacks_--;
   txn_.decrementPendingByteEvents();
 
@@ -3467,14 +3496,15 @@ void HQSession::HQStreamTransportBase::onPushMessageBegin(
     HTTPCodec::StreamID pushID,
     HTTPCodec::StreamID assocStreamID,
     HTTPMessage* /* msg */) {
-  VLOG(4) << __func__ << " txn=" << txn_ << " streamID=" << getIngressStreamId()
-          << " assocStreamID=" << assocStreamID
-          << " ingressPushId=" << ingressPushId_.value_or(-1);
+  PRX_VLOG(4) << __func__ << " txn=" << txn_
+              << " streamID=" << getIngressStreamId()
+              << " assocStreamID=" << assocStreamID
+              << " ingressPushId=" << ingressPushId_.value_or(-1);
 
   if (ingressPushId_) {
     constexpr auto error =
         "Received onPushMessageBegin in the middle of push promise";
-    LOG(ERROR) << error;
+    PRX_LOG(ERROR) << error;
     // TODO: Audit this error code
     session_.dropConnectionAsync(
         quic::QuicError(HTTP3::ErrorCode::HTTP_FRAME_ERROR, error),
@@ -3497,13 +3527,13 @@ void HQSession::HQStreamTransportBase::onPushMessageBegin(
 
 HQSession::HQStreamTransportBase* HQSession::findWTSessionOrAbort(
     quic::StreamId sessionID, quic::StreamId streamID) {
-  CHECK(supportsWebTransport());
+  PRX_CHECK(supportsWebTransport());
   auto* connectStream = findNonDetachedStream(sessionID);
   const bool ok =
       connectStream && connectStream->txn_.isWebTransportConnectStream();
   if (!ok) {
-    LOG(ERROR) << "invalid wt connect id=" << sessionID
-               << " stream id=" << streamID;
+    PRX_LOG(ERROR) << "invalid wt connect id=" << sessionID
+                   << " stream id=" << streamID;
     // need to error stopSending/reset this stream
     abortStream(HTTPException::Direction::INGRESS_AND_EGRESS,
                 streamID,
@@ -3519,9 +3549,9 @@ void HQSession::dispatchUniWTStream(quic::StreamId streamID,
                                     size_t toConsume) {
   sock_->setPeekCallback(streamID, nullptr);
   auto consumeRes = sock_->consume(streamID, toConsume);
-  CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
-  VLOG(6) << __func__ << " sess=" << *this << " id=" << streamID
-          << " wt-sess-id=" << sessionID;
+  PRX_CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
+  PRX_VLOG(6) << __func__ << " sess=" << *this << " id=" << streamID
+              << " wt-sess-id=" << sessionID;
   auto* connectStream = findWTSessionOrAbort(sessionID, streamID);
   if (!connectStream) {
     return;
@@ -3542,9 +3572,9 @@ void HQSession::dispatchBidiWTStream(HTTPCodec::StreamID streamID,
                                      size_t toConsume) {
   sock_->setPeekCallback(streamID, nullptr);
   auto consumeRes = sock_->consume(streamID, toConsume);
-  CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
-  VLOG(6) << __func__ << " sess=" << *this << " id=" << streamID
-          << " wt-sess-id=" << sessionID;
+  PRX_CHECK(!consumeRes.hasError()) << "Unexpected error consuming bytes";
+  PRX_VLOG(6) << __func__ << " sess=" << *this << " id=" << streamID
+              << " wt-sess-id=" << sessionID;
   auto* connectStream = findWTSessionOrAbort(sessionID, streamID);
   if (!connectStream) {
     return;
@@ -3571,9 +3601,10 @@ void HQSession::HQStreamTransport::sendPushPromise(
     const HTTPMessage& headers,
     HTTPHeaderSize* size,
     bool includeEOM) {
-  CHECK(txn);
+  PRX_CHECK(txn);
 
-  CHECK(pushId.has_value()) << " Request stream impl expects pushID to be set";
+  PRX_CHECK(pushId.has_value())
+      << " Request stream impl expects pushID to be set";
   const uint64_t oldOffset = streamWriteByteOffset();
   auto g = folly::makeGuard(setActiveCodec(__func__));
 
@@ -3582,12 +3613,13 @@ void HQSession::HQStreamTransport::sendPushPromise(
 
   const uint64_t newOffset = streamWriteByteOffset();
   if (size) {
-    VLOG(4) << "sending push promise, size=" << size->compressed
-            << ", uncompressedSize=" << size->uncompressed << " txn=" << txn_;
+    PRX_VLOG(4) << "sending push promise, size=" << size->compressed
+                << ", uncompressedSize=" << size->uncompressed
+                << " txn=" << txn_;
   }
 
   if (includeEOM) {
-    CHECK_GE(newOffset, oldOffset);
+    PRX_CHECK_GE(newOffset, oldOffset);
     session_.handleLastByteEvents(&byteEventTracker_,
                                   &txn_,
                                   newOffset - oldOffset,
@@ -3620,7 +3652,7 @@ HQSession::HQStreamTransport::newPushedTransaction(
     HTTPTransaction::PushHandler* handler,
     ProxygenError* error) noexcept {
 
-  CHECK_EQ(parentRequestStreamId, txn_.getID());
+  PRX_CHECK_EQ(parentRequestStreamId, txn_.getID());
 
   return session_.newPushedTransaction(
       parentRequestStreamId, // stream id of the egress push stream
@@ -3632,9 +3664,9 @@ void HQSession::HQStreamTransport::onPushPromiseHeadersComplete(
     hq::PushId pushID,
     HTTPCodec::StreamID assocStreamID,
     std::unique_ptr<HTTPMessage> msg) {
-  VLOG(4) << "processing new Push Promise msg=" << msg.get()
-          << " streamID=" << assocStreamID << " maybePushID=" << pushID
-          << ", txn= " << txn_;
+  PRX_VLOG(4) << "processing new Push Promise msg=" << msg.get()
+              << " streamID=" << assocStreamID << " maybePushID=" << pushID
+              << ", txn= " << txn_;
 
   // Notify the testing callbacks
   if (session_.serverPushLifecycleCb_) {
@@ -3648,7 +3680,7 @@ void HQSession::HQStreamTransport::onPushPromiseHeadersComplete(
   // virtual function call into UpstreamSession.  This will crash if it happens
   // downstream.
   auto pushStream = session_.createIngressPushStream(assocStreamID, pushID);
-  CHECK(pushStream);
+  PRX_CHECK(pushStream);
 
   // Notify the *parent* transaction that the *pushed* transaction has been
   // successfully created.
@@ -3662,15 +3694,15 @@ void HQSession::HQStreamTransport::onPushPromiseHeadersComplete(
 void HQSession::onDatagramsAvailable() noexcept {
   auto result = sock_->readDatagramBufs();
   if (result.hasError()) {
-    LOG(ERROR) << "Got error while reading datagrams: error="
-               << toString(result.error());
+    PRX_LOG(ERROR) << "Got error while reading datagrams: error="
+                   << toString(result.error());
     dropConnectionAsync(quic::QuicError(HTTP3::ErrorCode::HTTP_INTERNAL_ERROR,
                                         "H3_DATAGRAM: internal error "),
                         kErrorConnection);
     return;
   }
-  VLOG(4) << "Received " << result.value().size()
-          << " datagrams. sess=" << *this;
+  PRX_VLOG(4) << "Received " << result.value().size()
+              << " datagrams. sess=" << *this;
   for (auto& datagram : result.value()) {
     folly::io::Cursor cursor(datagram.get());
     auto quarterStreamId = quic::follyutils::decodeQuicInteger(cursor);
@@ -3700,8 +3732,9 @@ void HQSession::onDatagramsAvailable() noexcept {
     datagramQ.trimStart(quarterStreamId->second + (ctxId ? ctxId->second : 0));
 
     if (!stream || !stream->hasHeaders_) {
-      VLOG(4) << "Stream cannot receive datagrams yet. streamId=" << streamId
-              << " len=" << datagramQ.chainLength() << " sess=" << *this;
+      PRX_VLOG(4)
+          << "Stream cannot receive datagrams yet. streamId=" << streamId
+          << " len=" << datagramQ.chainLength() << " sess=" << *this;
       // TODO: a possible optimization would be to discard datagrams destined
       // to streams that were already closed
       auto itr = datagramsBuffer_.find(streamId);
@@ -3718,9 +3751,10 @@ void HQSession::onDatagramsAvailable() noexcept {
       continue;
     }
 
-    VLOG(4) << "Received datagram for streamId=" << streamId << " ctx="
-            << (ctxId ? folly::to<std::string>(ctxId->first) : std::string())
-            << " len=" << datagramQ.chainLength() << " sess=" << *this;
+    PRX_VLOG(4)
+        << "Received datagram for streamId=" << streamId << " ctx="
+        << (ctxId ? folly::to<std::string>(ctxId->first) : std::string())
+        << " len=" << datagramQ.chainLength() << " sess=" << *this;
     if (stream->wtSess_) {
       stream->wtSess_->onDatagram(datagramQ.move());
     } else {
@@ -3768,14 +3802,15 @@ HQSession::HQStreamTransport::sendDatagram(
       return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
     }
   }
-  VLOG(4) << "Sending datagram for streamId=" << streamId_.value()
-          << " len=" << datagram->computeChainDataLength()
-          << " sess=" << session_;
+  PRX_VLOG(4) << "Sending datagram for streamId=" << streamId_.value()
+              << " len=" << datagram->computeChainDataLength()
+              << " sess=" << session_;
   quic::BufQueue queue(std::move(headerBuf));
   queue.append(std::move(datagram));
   auto writeRes = session_.sock_->writeDatagram(queue.move());
   if (writeRes.hasError()) {
-    LOG(ERROR) << "Failed to send datagram for streamId=" << streamId_.value();
+    PRX_LOG(ERROR) << "Failed to send datagram for streamId="
+                   << streamId_.value();
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
   }
   return folly::unit;
@@ -3785,7 +3820,7 @@ folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
 HQSession::HQStreamTransport::newWebTransportBidiStream() {
   auto id = session_.sock_->createBidirectionalStream();
   if (!id) {
-    LOG(ERROR) << "Failed to create new bidirectional stream";
+    PRX_LOG(ERROR) << "Failed to create new bidirectional stream";
     return folly::makeUnexpected(
         WebTransport::ErrorCode::STREAM_CREATION_ERROR);
   }
@@ -3795,7 +3830,7 @@ HQSession::HQStreamTransport::newWebTransportBidiStream() {
                                  getEgressStreamId(),
                                  hq::WebTransportStreamType::BIDI);
   if (numPrefaceBytesWritten == 0) {
-    LOG(ERROR) << "Failed to write bidirectional stream preface";
+    PRX_LOG(ERROR) << "Failed to write bidirectional stream preface";
     // TODO: resetStream/stopSending?
     return folly::makeUnexpected(
         WebTransport::ErrorCode::STREAM_CREATION_ERROR);
@@ -3807,8 +3842,8 @@ folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
 HQSession::HQStreamTransport::newWebTransportUniStream() {
   auto id = session_.sock_->createUnidirectionalStream();
   if (!id) {
-    LOG(ERROR) << "Failed to create unidirectional stream. error='"
-               << id.error() << "'";
+    PRX_LOG(ERROR) << "Failed to create unidirectional stream. error='"
+                   << id.error() << "'";
     return folly::makeUnexpected(
         WebTransport::ErrorCode::STREAM_CREATION_ERROR);
   }
@@ -3818,7 +3853,7 @@ HQSession::HQStreamTransport::newWebTransportUniStream() {
                                  getEgressStreamId(),
                                  hq::WebTransportStreamType::UNI);
   if (numPrefaceBytesWritten == 0) {
-    LOG(ERROR) << "Failed to write unidirectional stream preface";
+    PRX_LOG(ERROR) << "Failed to write unidirectional stream preface";
     return folly::makeUnexpected(
         WebTransport::ErrorCode::STREAM_CREATION_ERROR);
   }
@@ -3848,16 +3883,16 @@ HQSession::HQStreamTransport::sendWebTransportStreamData(
   auto res =
       session_.sock_->writeChain(id, std::move(data), eof, deliveryCallback);
   if (res.hasError()) {
-    LOG(ERROR) << "Failed to write WT stream data";
+    PRX_LOG(ERROR) << "Failed to write WT stream data";
     return folly::makeUnexpected(WebTransport::ErrorCode::SEND_ERROR);
   }
   auto flowControl = session_.sock_->getStreamFlowControl(id);
   if (!flowControl) {
-    LOG(ERROR) << "Failed to get flow control";
+    PRX_LOG(ERROR) << "Failed to get flow control";
     return folly::makeUnexpected(WebTransport::ErrorCode::SEND_ERROR);
   }
   if (!eof && flowControl->sendWindowAvailable == 0) {
-    VLOG(4) << "FC window closed";
+    PRX_VLOG(4) << "FC window closed";
     return WebTransport::FCState::BLOCKED;
   } else {
     return WebTransport::FCState::UNBLOCKED;
@@ -3878,7 +3913,7 @@ HQSession::HQStreamTransport::sendWTMaxData(uint64_t maxData) {
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 HQSession::HQStreamTransport::notifyPendingWriteOnStream(
     HTTPCodec::StreamID id, quic::StreamWriteCallback* wcb) {
-  CHECK(session_.sock_);
+  PRX_CHECK(session_.sock_);
   session_.sock_->notifyPendingWriteOnStream(id, wcb);
   return folly::unit;
 }
@@ -3955,11 +3990,11 @@ bool HQSession::HQStreamTransportBase::tryWtSession(HTTPTransaction& txn,
   const bool upgraded = txn.isWebTransportConnectStream() &&
                         (msg.isRequest() || msg.is2xxResponse());
   const bool makeWtSession = sock && !eom && upgraded && wtCtx.hasWtHandler();
-  VLOG(6) << "sock=" << bool(sock) << "; eom=" << eom
-          << "; upgraded=" << upgraded
-          << "; wtConnect=" << txn.isWebTransportConnectStream()
-          << "; supportsWebTransport=" << supportsWebTransport()
-          << "; wtHandler=" << wtCtx.hasWtHandler();
+  PRX_VLOG(6) << "sock=" << bool(sock) << "; eom=" << eom
+              << "; upgraded=" << upgraded
+              << "; wtConnect=" << txn.isWebTransportConnectStream()
+              << "; supportsWebTransport=" << supportsWebTransport()
+              << "; wtHandler=" << wtCtx.hasWtHandler();
   if (!makeWtSession) {
     return false;
   }
diff --git a/proxygen/lib/http/session/HQSession.h b/proxygen/lib/http/session/HQSession.h
index 58172543ba..b5a93ce521 100644
--- a/proxygen/lib/http/session/HQSession.h
+++ b/proxygen/lib/http/session/HQSession.h
@@ -42,6 +42,7 @@
 #include <quic/priority/PriorityQueue.h>
 
 #include <proxygen/lib/http/codec/H3EarlyDataHandler.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -457,12 +458,12 @@ class HQSession
 
   // Upstream interface
   bool isReusable() const override {
-    VLOG(4) << __func__ << " sess=" << *this;
+    PRX_VLOG(4) << __func__ << " sess=" << *this;
     return !isClosing();
   }
 
   bool isClosing() const override {
-    VLOG(4) << __func__ << " sess=" << *this;
+    PRX_VLOG(4) << __func__ << " sess=" << *this;
     return (drainState_ != DrainState::NONE || dropping_);
   }
 
@@ -589,7 +590,7 @@ class HQSession
     }
 
     for (HQStreamTransportBase* pstream : streams) {
-      CHECK(pstream);
+      PRX_CHECK(pstream);
       fn(pstream);
     }
   }
@@ -650,7 +651,7 @@ class HQSession
       if (supportsWebTransport()) {
         return hq::BidirectionalStreamType::WEBTRANSPORT;
       } else {
-        LOG(ERROR) << "WT stream when it is unsupported sess=" << *this;
+        PRX_LOG(ERROR) << "WT stream when it is unsupported sess=" << *this;
         return folly::none;
       }
     }
@@ -986,7 +987,7 @@ class HQSession
     }
 
     void createEgressCodec() {
-      CHECK(type_.has_value());
+      PRX_CHECK(type_.has_value());
       switch (*type_) {
         case hq::UnidirectionalStreamType::CONTROL:
           realCodec_ =
@@ -1001,7 +1002,7 @@ class HQSession
           // These are statically allocated in the session
           break;
         default:
-          LOG(FATAL)
+          PRX_LOG(FATAL)
               << "Failed to create egress codec."
               << " unrecognized stream type=" << static_cast<uint64_t>(*type_);
       }
@@ -1022,29 +1023,29 @@ class HQSession
     // HTTPCodec::Callback
     void onMessageBegin(HTTPCodec::StreamID /*stream*/,
                         HTTPMessage* /*msg*/) override {
-      LOG(FATAL) << __func__ << " called on a Control Stream.";
+      PRX_LOG(FATAL) << __func__ << " called on a Control Stream.";
     }
 
     void onHeadersComplete(HTTPCodec::StreamID /*stream*/,
                            std::unique_ptr<HTTPMessage> /*msg*/) override {
-      LOG(FATAL) << __func__ << " called on a Control Stream.";
+      PRX_LOG(FATAL) << __func__ << " called on a Control Stream.";
     }
 
     void onBody(HTTPCodec::StreamID /*stream*/,
                 std::unique_ptr<folly::IOBuf> /*chain*/,
                 uint16_t /*padding*/) override {
-      LOG(FATAL) << __func__ << " called on a Control Stream.";
+      PRX_LOG(FATAL) << __func__ << " called on a Control Stream.";
     }
 
     void onTrailersComplete(
         HTTPCodec::StreamID /*stream*/,
         std::unique_ptr<HTTPHeaders> /*trailers*/) override {
-      LOG(FATAL) << __func__ << " called on a Control Stream.";
+      PRX_LOG(FATAL) << __func__ << " called on a Control Stream.";
     }
 
     void onMessageComplete(HTTPCodec::StreamID /*stream*/,
                            bool /*upgrade*/) override {
-      LOG(FATAL) << __func__ << " called on a Control Stream.";
+      PRX_LOG(FATAL) << __func__ << " called on a Control Stream.";
     }
 
     void onError(HTTPCodec::StreamID /*stream*/,
@@ -1151,7 +1152,7 @@ class HQSession
         hq::PushId /* pushID */,
         HTTPCodec::StreamID /* assoc streamID */,
         std::unique_ptr<HTTPMessage> /* msg */) {
-      LOG(ERROR) << "push promise: txn=" << txn_ << " TODO";
+      PRX_LOG(ERROR) << "push promise: txn=" << txn_ << " TODO";
     }
 
     void onHeadersComplete(HTTPCodec::StreamID streamID,
@@ -1160,8 +1161,8 @@ class HQSession
     void onBody(HTTPCodec::StreamID /* streamID */,
                 std::unique_ptr<folly::IOBuf> chain,
                 uint16_t padding) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
-      CHECK(chain);
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_CHECK(chain);
       auto len = chain->computeChainDataLength();
       if (session_.onBodyImpl(std::move(chain), len, padding, &txn_)) {
         session_.pauseReads();
@@ -1170,24 +1171,24 @@ class HQSession
 
     void onChunkHeader(HTTPCodec::StreamID /* stream */,
                        size_t length) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       txn_.onIngressChunkHeader(length);
     }
 
     void onChunkComplete(HTTPCodec::StreamID /* stream */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       txn_.onIngressChunkComplete();
     }
 
     void onTrailersComplete(HTTPCodec::StreamID /* streamID */,
                             std::unique_ptr<HTTPHeaders> trailers) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       txn_.onIngressTrailers(std::move(trailers));
     }
 
     void onMessageComplete(HTTPCodec::StreamID /* streamID */,
                            bool /* upgrade */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       // for 1xx responses (excluding 101) onMessageComplete may be called
       // more than once
       if (txn_.isUpstream() && txn_.extraResponseExpected()) {
@@ -1206,7 +1207,7 @@ class HQSession
 
     void onIngressEOF() {
       // Can only call this once
-      CHECK(!eomGate_.get(EOMType::TRANSPORT));
+      PRX_CHECK(!eomGate_.get(EOMType::TRANSPORT));
       if (ingressError_) {
         // This codec has already errored, no need to give it more input
         return;
@@ -1225,10 +1226,10 @@ class HQSession
 
     void onAbort(HTTPCodec::StreamID /* streamID */,
                  ErrorCode /* code */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       // Can't really get here since no HQ codecs can produce aborts.
       // The entry point is onResetStream via readError()
-      LOG(DFATAL) << "Unexpected abort";
+      PRX_LOG(DFATAL) << "Unexpected abort";
     }
 
     void onFrameHeader(HTTPCodec::StreamID /* stream_id */,
@@ -1236,45 +1237,45 @@ class HQSession
                        uint64_t /* length */,
                        uint64_t /* type */,
                        uint16_t /* version */ = 0) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void onGoaway(
         uint64_t /* lastGoodStreamID */,
         ErrorCode /* code */,
         std::unique_ptr<folly::IOBuf> /* debugData */ = nullptr) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void onPingRequest(uint64_t /* data */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void onPingReply(uint64_t /* data */) override {
       // This method should not get called
-      LOG(FATAL) << __func__ << " txn=" << txn_;
+      PRX_LOG(FATAL) << __func__ << " txn=" << txn_;
     }
 
     void onWindowUpdate(HTTPCodec::StreamID /* stream */,
                         uint32_t /* amount */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void onSettings(const SettingsList& /*settings*/) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void onSettingsAck() override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     uint32_t numOutgoingStreams() const override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return 0;
     }
 
     uint32_t numIncomingStreams() const override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return 0;
     }
 
@@ -1284,11 +1285,11 @@ class HQSession
     // will pause when total buffered egress exceeds the configured limit, which
     // should be equal to the recv flow control window
     void pauseIngress(HTTPTransaction* /* txn */) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void resumeIngress(HTTPTransaction* /* txn */) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     void transactionTimeout(HTTPTransaction* /* txn */) noexcept override;
@@ -1323,8 +1324,8 @@ class HQSession
 
     size_t sendWindowUpdate(HTTPTransaction* /* txn */,
                             uint32_t /* bytes */) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
-      CHECK(hasEgressStreamId())
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_CHECK(hasEgressStreamId())
           << __func__ << " invoked on stream without egress";
       return 0;
     }
@@ -1336,15 +1337,15 @@ class HQSession
                                  const HTTPMessage& /* headers */,
                                  HTTPHeaderSize* /* outSize */,
                                  bool /* includeEOM */) {
-      VLOG(4) << __func__ << " txn=" << txn_;
-      CHECK(hasEgressStreamId())
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_CHECK(hasEgressStreamId())
           << __func__ << " invoked on stream without egress";
     }
 
     void notifyPendingEgress() noexcept override;
 
     void detach(HTTPTransaction* /* txn */) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       detached_ = true;
       session_.httpPriorityQueue_.erase(queueHandle_.getStreamId());
       session_.scheduleLoopCallback();
@@ -1352,7 +1353,7 @@ class HQSession
     void checkForDetach();
 
     void notifyIngressBodyProcessed(uint32_t bytes) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       if (session_.notifyBodyProcessed(bytes)) {
         session_.resumeReads();
       }
@@ -1376,7 +1377,7 @@ class HQSession
 
     const wangle::TransportInfo& getSetupTransportInfo()
         const noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return session_.transportInfo_;
     }
 
@@ -1398,11 +1399,11 @@ class HQSession
     }
 
     void drain() override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
     }
 
     bool isDraining() const override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return false;
     }
 
@@ -1410,18 +1411,18 @@ class HQSession
         HTTPCodec::StreamID /* parentTxnId */,
         HTTPTransaction::PushHandler* /* handler */,
         ProxygenError* /* error */ = nullptr) noexcept override {
-      LOG(FATAL) << __func__ << " Only available via request stream";
+      PRX_LOG(FATAL) << __func__ << " Only available via request stream";
       folly::assume_unreachable();
     }
 
     std::string getSecurityProtocol() const override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return "quic/tls1.3";
     }
 
     void addWaitingForReplaySafety(folly::AsyncTransport::ReplaySafetyCallback*
                                        callback) noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       if (session_.sock_->replaySafe()) {
         callback->onReplaySafe();
       } else {
@@ -1432,18 +1433,18 @@ class HQSession
     void removeWaitingForReplaySafety(
         folly::AsyncTransport::ReplaySafetyCallback* callback) noexcept
         override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       session_.waitingForReplaySafety_.remove(callback);
     }
 
     bool needToBlockForReplaySafety() const override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return false;
     }
 
     const folly::AsyncTransport* getUnderlyingTransport()
         const noexcept override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return nullptr;
     }
 
@@ -1466,7 +1467,7 @@ class HQSession
 
     folly::Optional<const HTTPMessage::HTTP2Priority> getHTTPPriority(
         uint8_t /* pri */) override {
-      VLOG(4) << __func__ << " txn=" << txn_;
+      PRX_VLOG(4) << __func__ << " txn=" << txn_;
       return HTTPMessage::HTTP2Priority(hqDefaultPriority.streamDependency,
                                         hqDefaultPriority.exclusive,
                                         hqDefaultPriority.weight);
@@ -1627,13 +1628,13 @@ class HQSession
                                                    queueHandle_.getPriority());
         queueHandle_.setStreamTransportEnqueued(true);
       } else {
-        VLOG(4) << "Delay pending egress signal on blocked txn=" << txn_;
+        PRX_VLOG(4) << "Delay pending egress signal on blocked txn=" << txn_;
       }
     }
 
     // Notify the queue when a transaction no longer has egress
     void clearPendingEgress(HTTP2PriorityQueueBase::Handle /*h*/) override {
-      CHECK(queueHandle_.isTransactionEnqueued());
+      PRX_CHECK(queueHandle_.isTransactionEnqueued());
       queueHandle_.setTransactionEnqueued(false);
       if (pendingEOM_ || hasWriteBuffer()) {
         // no-op
@@ -1722,7 +1723,7 @@ class HQSession
         uint64_t streamOffset) {
       auto it = egressBodyByteEventOffsets_.find(streamOffset);
       if (it != egressBodyByteEventOffsets_.end()) {
-        CHECK_GT(it->second.callbacks, 0);
+        PRX_CHECK_GT(it->second.callbacks, 0u);
         it->second.callbacks--;
         auto bodyOffset = it->second.bodyOffset;
         if (it->second.callbacks == 0) {
diff --git a/proxygen/lib/http/session/HQStreamBase.cpp b/proxygen/lib/http/session/HQStreamBase.cpp
index 5fc2d72ef9..735b178175 100644
--- a/proxygen/lib/http/session/HQStreamBase.cpp
+++ b/proxygen/lib/http/session/HQStreamBase.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HQStreamBase.h>
 
 #include <proxygen/lib/http/session/HQSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -32,7 +33,7 @@ const HTTPCodec& HQStreamBase::getCodec() const noexcept {
     return *realCodecPtr_->get();
   }
   // must be the current codec
-  return *CHECK_NOTNULL(&codecFilterChain.getChainEnd());
+  return *PRX_CHECK_NOTNULL(&codecFilterChain.getChainEnd());
 }
 
 HQSession& HQStreamBase::getSession() const noexcept {
@@ -61,12 +62,12 @@ HQSession& HQStreamBase::getSession() const noexcept {
 folly::Function<void()> HQStreamBase::setActiveCodec(const std::string& where) {
   if (!realCodecPtr_->get()) {
     // already the active codec, no-op
-    CHECK(!realCodec_);
+    PRX_CHECK(!realCodec_);
     return [] {};
   }
-  VLOG(5) << "Pushing active codec from " << where;
-  CHECK_LT(session_.codecStack_.size(), HQSession::kMaxCodecStackDepth);
-  CHECK(!session_.codecStack_.back().codec);
+  PRX_VLOG(5) << "Pushing active codec from " << where;
+  PRX_CHECK_LT(session_.codecStack_.size(), HQSession::kMaxCodecStackDepth);
+  PRX_CHECK(!session_.codecStack_.back().codec);
   // Set the requested codec as the chain destination, and store the previous
   // codec to its spot in the codecStack
   session_.codecStack_.back().codec =
@@ -78,9 +79,9 @@ folly::Function<void()> HQStreamBase::setActiveCodec(const std::string& where) {
   codecFilterChain.setCallback(this);
   return [this, where] {
     // put this codec back where it belongs
-    VLOG(5) << "Popping active codec from " << where;
+    PRX_VLOG(5) << "Popping active codec from " << where;
     auto codecPtr = session_.codecStack_.back().codecPtr;
-    CHECK(!session_.codecStack_.back().codec);
+    PRX_CHECK(!session_.codecStack_.back().codec);
     // pop the stack
     session_.codecStack_.pop_back();
     // move previous codec from the stack to active
@@ -94,13 +95,14 @@ folly::Function<void()> HQStreamBase::setActiveCodec(const std::string& where) {
 size_t HQStreamBase::generateStreamPreface() {
   // Request (aka HQStreamTransport) streams do not type set.
   // If "generateStreamPreface" is invoked on those, its a bug
-  CHECK(type_.has_value())
+  PRX_CHECK(type_.has_value())
       << "Can not generate preface on streams without a type";
-  VLOG(4) << "generating stream preface for " << type_.value()
-          << " stream streamID=" << getEgressStreamId() << " sess=" << session_;
+  PRX_VLOG(4) << "generating stream preface for " << type_.value()
+              << " stream streamID=" << getEgressStreamId()
+              << " sess=" << session_;
   auto res = hq::writeStreamPreface(
       writeBuf_, static_cast<hq::StreamTypeType>(type_.value()));
-  CHECK(res.has_value());
+  PRX_CHECK(res.has_value());
   return res.value();
 }
 } // namespace proxygen
diff --git a/proxygen/lib/http/session/HQStreamBase.h b/proxygen/lib/http/session/HQStreamBase.h
index 8222f40e42..b595457393 100644
--- a/proxygen/lib/http/session/HQStreamBase.h
+++ b/proxygen/lib/http/session/HQStreamBase.h
@@ -17,6 +17,7 @@
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 #include <proxygen/lib/http/codec/HTTPCodecFilter.h>
 #include <proxygen/lib/http/codec/HTTPSettings.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/Types.h>
 
 /**
@@ -285,7 +286,7 @@ class SSBidir : public virtual HQStreamMapping {
   }
 
   quic::StreamId getStreamId() const override {
-    CHECK(streamId_) << "Stream MUST be assigned before being accessed";
+    PRX_CHECK(streamId_) << "Stream MUST be assigned before being accessed";
     return streamId_.value();
   }
 
@@ -317,12 +318,12 @@ class SSEgress : public SSBidir {
   }
 
   quic::StreamId getIngressStreamId() const override {
-    LOG(FATAL) << "Egress only stream can not be used for ingress";
+    PRX_LOG(FATAL) << "Egress only stream can not be used for ingress";
     folly::assume_unreachable();
   }
 
   void setIngressStreamId(quic::StreamId /* streamId */) override {
-    LOG(FATAL) << "Egress only stream can not be used for ingress";
+    PRX_LOG(FATAL) << "Egress only stream can not be used for ingress";
   }
 
   bool hasIngressStreamId() const override {
@@ -344,12 +345,12 @@ class SSIngress : public SSBidir {
   }
 
   quic::StreamId getEgressStreamId() const override {
-    LOG(FATAL) << "Ingress only stream can not be used for egress";
+    PRX_LOG(FATAL) << "Ingress only stream can not be used for egress";
     folly::assume_unreachable();
   }
 
   void setEgressStreamId(quic::StreamId /* streamId */) override {
-    LOG(FATAL) << "Ingress only stream can not be used for egress";
+    PRX_LOG(FATAL) << "Ingress only stream can not be used for egress";
   }
 
   bool hasEgressStreamId() const override {
@@ -380,13 +381,13 @@ class CSBidir : public virtual HQStreamMapping {
   }
 
   quic::StreamId getEgressStreamId() const override {
-    CHECK(egressStreamId_)
+    PRX_CHECK(egressStreamId_)
         << "Egress stream MUST be assigned before being accessed";
     return egressStreamId_.value();
   }
 
   quic::StreamId getIngressStreamId() const override {
-    CHECK(ingressStreamId_)
+    PRX_CHECK(ingressStreamId_)
         << "Ingress stream MUST be assigned before being accessed";
     return ingressStreamId_.value();
   }
@@ -414,7 +415,7 @@ class CSBidir : public virtual HQStreamMapping {
   }
 
   quic::StreamId getStreamId() const override {
-    LOG(FATAL) << "Ambiguous call 'getStreamId' on a composite stream";
+    PRX_LOG(FATAL) << "Ambiguous call 'getStreamId' on a composite stream";
     folly::assume_unreachable();
   }
 
diff --git a/proxygen/lib/http/session/HQStreamDispatcher.cpp b/proxygen/lib/http/session/HQStreamDispatcher.cpp
index 8d754c13f1..d4e128168c 100644
--- a/proxygen/lib/http/session/HQStreamDispatcher.cpp
+++ b/proxygen/lib/http/session/HQStreamDispatcher.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/session/HQStreamDispatcher.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 
@@ -17,26 +18,27 @@ HQStreamDispatcherBase::HQStreamDispatcherBase(
 
 void HQStreamDispatcherBase::peekError(quic::StreamId id,
                                        quic::QuicError error) noexcept {
-  VLOG(4) << __func__ << ": peekError streamID=" << id << " error: " << error;
+  PRX_VLOG(4) << __func__ << ": peekError streamID=" << id
+              << " error: " << error;
 
   switch (error.code.type()) {
     case quic::QuicErrorCode::Type::ApplicationErrorCode: {
       auto errorCode =
           static_cast<HTTP3::ErrorCode>(*error.code.asApplicationErrorCode());
-      VLOG(4) << "peekError: QUIC Application Error: " << toString(errorCode)
-              << " streamID=" << id;
+      PRX_VLOG(4) << "peekError: QUIC Application Error: "
+                  << toString(errorCode) << " streamID=" << id;
       break;
     }
     case quic::QuicErrorCode::Type::LocalErrorCode: {
       quic::LocalErrorCode& errorCode = *error.code.asLocalErrorCode();
-      VLOG(4) << "peekError: QUIC Local Error: " << errorCode
-              << " streamID=" << id;
+      PRX_VLOG(4) << "peekError: QUIC Local Error: " << errorCode
+                  << " streamID=" << id;
       break;
     }
     case quic::QuicErrorCode::Type::TransportErrorCode: {
       quic::TransportErrorCode& errorCode = *error.code.asTransportErrorCode();
-      VLOG(4) << "peekError: QUIC Transport Error: " << errorCode
-              << " streamID=" << id;
+      PRX_VLOG(4) << "peekError: QUIC Transport Error: " << errorCode
+                  << " streamID=" << id;
       break;
     }
   }
@@ -57,7 +59,7 @@ void HQStreamDispatcherBase::onDataAvailable(
   auto maybeClearPeekCallback = folly::makeGuard([&] {
     if (peekFirst.eof) {
       // Chunk offset 0 with EOF means we must dispatch, or clear the cb
-      VLOG(4) << "Undispatchable stream (EOF before preface complete)";
+      PRX_VLOG(4) << "Undispatchable stream (EOF before preface complete)";
       callback_.rejectStream(releaseOwnership(id));
     }
   });
@@ -68,8 +70,8 @@ void HQStreamDispatcherBase::onDataAvailable(
   }
 
   // Look for a stream preface in the first read buffer
-  VLOG(4) << "Attempting peek dispatch stream=" << id
-          << " len=" << dataBuf->computeChainDataLength();
+  PRX_VLOG(4) << "Attempting peek dispatch stream=" << id
+              << " len=" << dataBuf->computeChainDataLength();
   folly::io::Cursor cursor(dataBuf);
   auto preface = quic::follyutils::decodeQuicInteger(cursor);
   if (!preface) {
@@ -142,10 +144,10 @@ HQStreamDispatcherBase::HandleStreamResult HQUniStreamDispatcher::handleStream(
       }
     }
     case hq::UnidirectionalStreamType::GREASE:
-      VLOG(4) << "Hey, a grease stream id=" << id;
+      PRX_VLOG(4) << "Hey, a grease stream id=" << id;
       break;
     default:
-      LOG(ERROR) << "Unrecognized type=" << folly::to_underlying(*type);
+      PRX_LOG(ERROR) << "Unrecognized type=" << folly::to_underlying(*type);
   }
   return HandleStreamResult::REJECT;
 }
@@ -182,7 +184,8 @@ HQStreamDispatcherBase::HandleStreamResult HQBidiStreamDispatcher::handleStream(
       }
     }
     default: {
-      LOG(ERROR) << "Unrecognized type=" << static_cast<uint64_t>(type.value());
+      PRX_LOG(ERROR) << "Unrecognized type="
+                     << static_cast<uint64_t>(type.value());
     }
   }
   return HandleStreamResult::REJECT;
diff --git a/proxygen/lib/http/session/HQStreamDispatcher.h b/proxygen/lib/http/session/HQStreamDispatcher.h
index 80333914d2..3fb661245d 100644
--- a/proxygen/lib/http/session/HQStreamDispatcher.h
+++ b/proxygen/lib/http/session/HQStreamDispatcher.h
@@ -14,6 +14,7 @@
 #include <proxygen/lib/http/codec/HQUnidirectionalCodec.h>
 
 #include <folly/io/async/EventBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -67,10 +68,10 @@ class HQStreamDispatcherBase : public quic::QuicSocket::PeekCallback {
   }
 
   quic::StreamId releaseOwnership(quic::StreamId id) {
-    LOG_IF(DFATAL, !hasOwnership(id))
+    PRX_LOG_IF(DFATAL, !hasOwnership(id))
         << "Can not release ownership on unowned streamID=" << id;
     bool found = pendingStreams_.erase(id);
-    LOG_IF(DFATAL, !found) << "Inconstency detected streamID=" << id;
+    PRX_LOG_IF(DFATAL, !found) << "Inconstency detected streamID=" << id;
     return id;
   }
 
diff --git a/proxygen/lib/http/session/HQUpstreamSession.cpp b/proxygen/lib/http/session/HQUpstreamSession.cpp
index c17a283d38..d4dd035744 100644
--- a/proxygen/lib/http/session/HQUpstreamSession.cpp
+++ b/proxygen/lib/http/session/HQUpstreamSession.cpp
@@ -7,13 +7,14 @@
  */
 
 #include <proxygen/lib/http/session/HQUpstreamSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/common/events/FollyQuicEventBase.h>
 #include <wangle/acceptor/ConnectionManager.h>
 
 namespace proxygen {
 
 HQUpstreamSession::~HQUpstreamSession() {
-  CHECK_EQ(getNumStreams(), 0);
+  PRX_CHECK_EQ(getNumStreams(), 0u);
 }
 
 void HQUpstreamSession::startNow() {
@@ -26,7 +27,7 @@ void HQUpstreamSession::startNow() {
 }
 
 void HQUpstreamSession::connectTimeoutExpired() noexcept {
-  VLOG(4) << __func__ << " sess=" << *this << ": connection failed";
+  PRX_VLOG(4) << __func__ << " sess=" << *this << ": connection failed";
   if (connectCb_) {
     onConnectionError(quic::QuicError(quic::LocalErrorCode::CONNECT_FAILED,
                                       "connect timeout"));
@@ -86,7 +87,7 @@ void HQUpstreamSession::handleReplaySafe() noexcept {
 }
 
 void HQUpstreamSession::onConnectionEnd() noexcept {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
 
   HQSession::DestructorGuard dg(this);
   if (connectCb_) {
@@ -110,7 +111,7 @@ void HQUpstreamSession::onConnectionSetupErrorHandler(
 }
 
 bool HQUpstreamSession::isDetachable(bool checkSocket) const {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   // TODO: deal with control streams in h2q
   if (checkSocket && sock_ && !sock_->isDetachable()) {
     return false;
@@ -127,7 +128,7 @@ void HQUpstreamSession::attachThreadLocals(
     HeaderCodec::Stats* headerCodecStats,
     HTTPSessionController* controller) {
   // TODO: deal with control streams in h2q
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   setController(controller);
   setSessionStats(stats);
   auto qEvbWrapper = std::make_shared<quic::FollyQuicEventBase>(eventBase);
@@ -141,9 +142,9 @@ void HQUpstreamSession::attachThreadLocals(
 }
 
 void HQUpstreamSession::detachThreadLocals(bool) {
-  VLOG(4) << __func__ << " sess=" << *this;
+  PRX_VLOG(4) << __func__ << " sess=" << *this;
   // TODO: deal with control streams in h2q
-  CHECK_EQ(getNumOutgoingStreams(), 0);
+  PRX_CHECK_EQ(getNumOutgoingStreams(), 0u);
   cancelLoopCallback();
 
   // TODO: Pause reads and invoke infocallback
@@ -168,10 +169,10 @@ bool HQUpstreamSession::tryBindIngressStreamToTxn(
     hq::PushId pushId,
     HQIngressPushStream* pushStream) {
   // lookup pending nascent stream id
-  CHECK(pushStream);
+  PRX_CHECK(pushStream);
 
-  VLOG(4) << __func__ << " attempting to bind streamID=" << streamId
-          << " to pushID=" << pushId;
+  PRX_VLOG(4) << __func__ << " attempting to bind streamID=" << streamId
+              << " to pushID=" << pushId;
   pushStream->bindTo(streamId);
 
 #if defined(DEBUG) && DEBUG
@@ -181,16 +182,16 @@ bool HQUpstreamSession::tryBindIngressStreamToTxn(
   auto streamById = findIngressPushStream(streamId);
   auto streamByPushId = findIngressPushStreamByPushId(pushId);
 
-  DCHECK_EQ(streamId, pushStream->getIngressStreamId());
-  DCHECK(streamById) << "Ingress stream must be bound to the streamID="
-                     << streamId;
-  DCHECK(streamByPushId) << "Ingress stream must be found by the pushID="
-                         << pushId;
-  DCHECK_EQ(streamById, streamByPushId) << "Must be same stream";
+  PRX_DCHECK_EQ(streamId, pushStream->getIngressStreamId());
+  PRX_DCHECK(streamById) << "Ingress stream must be bound to the streamID="
+                         << streamId;
+  PRX_DCHECK(streamByPushId)
+      << "Ingress stream must be found by the pushID=" << pushId;
+  PRX_DCHECK_EQ(streamById, streamByPushId) << "Must be same stream";
 #endif
 
-  VLOG(4) << __func__ << " successfully bound streamID=" << streamId
-          << " to pushID=" << pushId;
+  PRX_VLOG(4) << __func__ << " successfully bound streamID=" << streamId
+              << " to pushID=" << pushId;
   return true;
 }
 
@@ -200,7 +201,7 @@ HQUpstreamSession::createIngressPushStream(HTTPCodec::StreamID parentId,
                                            hq::PushId pushId) {
 
   // Check that a stream with this ID has not been created yet
-  DCHECK(!findIngressPushStreamByPushId(pushId))
+  PRX_DCHECK(!findIngressPushStreamByPushId(pushId))
       << "Ingress stream with this push ID already exists pushID=" << pushId;
 
   auto matchPair = ingressPushStreams_.emplace(
@@ -213,8 +214,8 @@ HQUpstreamSession::createIngressPushStream(HTTPCodec::StreamID parentId,
           getNumTxnServed(),
           WheelTimerInstance(transactionsTimeout_, getEventBase())));
 
-  CHECK(matchPair.second) << "Emplacement failed, despite earlier "
-                             "existence check.";
+  PRX_CHECK(matchPair.second) << "Emplacement failed, despite earlier "
+                                 "existence check.";
 
   auto newIngressPushStream = &matchPair.first->second;
 
@@ -223,7 +224,7 @@ HQUpstreamSession::createIngressPushStream(HTTPCodec::StreamID parentId,
   bool bound = false;
   auto res = pushIdToStreamId_.find(pushId);
   if (res == pushIdToStreamId_.end()) {
-    VLOG(4)
+    PRX_VLOG(4)
         << __func__ << " pushID=" << pushId
         << " not found in the lookup table, size=" << pushIdToStreamId_.size();
   } else {
@@ -231,11 +232,11 @@ HQUpstreamSession::createIngressPushStream(HTTPCodec::StreamID parentId,
         tryBindIngressStreamToTxn(res->second, pushId, newIngressPushStream);
   }
 
-  VLOG(4) << "Successfully created new ingress push stream"
-          << " pushID=" << pushId << " parentStreamID=" << parentId
-          << " bound=" << bound << " streamID="
-          << (bound ? newIngressPushStream->getIngressStreamId()
-                    : static_cast<unsigned long>(-1));
+  PRX_VLOG(4) << "Successfully created new ingress push stream"
+              << " pushID=" << pushId << " parentStreamID=" << parentId
+              << " bound=" << bound << " streamID="
+              << (bound ? newIngressPushStream->getIngressStreamId()
+                        : static_cast<unsigned long>(-1));
 
   return newIngressPushStream;
 }
@@ -257,7 +258,8 @@ HQUpstreamSession::findIngressPushStream(quic::StreamId streamId) {
 
 HQUpstreamSession::HQIngressPushStream* FOLLY_NULLABLE
 HQUpstreamSession::findIngressPushStreamByPushId(hq::PushId pushId) {
-  VLOG(4) << __func__ << " looking up ingress push stream by pushID=" << pushId;
+  PRX_VLOG(4) << __func__
+              << " looking up ingress push stream by pushID=" << pushId;
   auto it = ingressPushStreams_.find(pushId);
   if (it == ingressPushStreams_.end()) {
     return nullptr;
@@ -289,12 +291,13 @@ uint32_t HQUpstreamSession::numberOfIngressPushStreams() const {
 void HQUpstreamSession::dispatchPushStream(quic::StreamId pushStreamId,
                                            hq::PushId pushId,
                                            size_t toConsume) {
-  VLOG(4) << __func__ << " streamID=" << pushStreamId << " pushId=" << pushId;
+  PRX_VLOG(4) << __func__ << " streamID=" << pushStreamId
+              << " pushId=" << pushId;
 
   // TODO: if/when we support client goaway, reject stream if
   // pushId >= minUnseenIncomingPushId_ after the GOAWAY is sent
   minUnseenIncomingPushId_ = std::max(minUnseenIncomingPushId_, pushId);
-  DCHECK_GT(toConsume, 0);
+  PRX_DCHECK_GT(toConsume, 0u);
 
   bool eom = false;
   if (serverPushLifecycleCb_) {
@@ -302,7 +305,7 @@ void HQUpstreamSession::dispatchPushStream(quic::StreamId pushStreamId,
   }
 
   auto consumeRes = sock_->consume(pushStreamId, toConsume);
-  CHECK(!consumeRes.hasError())
+  PRX_CHECK(!consumeRes.hasError())
       << "Unexpected error " << consumeRes.error() << " while consuming "
       << toConsume << " bytes from stream=" << pushStreamId
       << " pushId=" << pushId;
@@ -318,8 +321,8 @@ void HQUpstreamSession::dispatchPushStream(quic::StreamId pushStreamId,
   pushIdToStreamId_.emplace(pushId, pushStreamId);
   streamIdToPushId_.emplace(pushStreamId, pushId);
 
-  VLOG(4) << __func__ << " assigned lookup from pushID=" << pushId
-          << " to streamID=" << pushStreamId;
+  PRX_VLOG(4) << __func__ << " assigned lookup from pushID=" << pushId
+              << " to streamID=" << pushStreamId;
 
   // We have successfully read the push id. Notify the testing callbacks
   if (serverPushLifecycleCb_) {
@@ -333,17 +336,17 @@ void HQUpstreamSession::dispatchPushStream(quic::StreamId pushStreamId,
   if (ingressPushStream) {
     auto bound =
         tryBindIngressStreamToTxn(pushStreamId, pushId, ingressPushStream);
-    VLOG(4) << __func__ << " bound=" << bound << " pushID=" << pushId
-            << " pushStreamID=" << pushStreamId << " to txn ";
+    PRX_VLOG(4) << __func__ << " bound=" << bound << " pushID=" << pushId
+                << " pushStreamID=" << pushStreamId << " to txn ";
   }
 }
 
 void HQUpstreamSession::HQIngressPushStream::bindTo(quic::StreamId streamId) {
   // Ensure the nascent push stream is in correct state
   // and that its push id matches this stream's push id
-  DCHECK(txn_.getAssocTxnId().has_value());
-  VLOG(4) << __func__ << " Binding streamID=" << streamId
-          << " to txn=" << txn_.getID();
+  PRX_DCHECK(txn_.getAssocTxnId().has_value());
+  PRX_VLOG(4) << __func__ << " Binding streamID=" << streamId
+              << " to txn=" << txn_.getID();
 #if defined(DEBUG) && DEBUG
   // will throw bad-cast
   HQUpstreamSession& session = dynamic_cast<HQUpstreamSession&>(session_);
@@ -353,12 +356,12 @@ void HQUpstreamSession::HQIngressPushStream::bindTo(quic::StreamId streamId) {
   // Initialize this stream's codec with the id of the transport stream
   auto codec = session.createCodec(streamId);
   initCodec(std::move(codec), __func__);
-  DCHECK_EQ(*codecStreamId_, streamId);
+  PRX_DCHECK_EQ(*codecStreamId_, streamId);
 
   // Now that the codec is initialized, set the stream ID
   // of the push stream
   setIngressStreamId(streamId);
-  DCHECK_EQ(getIngressStreamId(), streamId);
+  PRX_DCHECK_EQ(getIngressStreamId(), streamId);
 
   // Enable ingress on this stream. Read callback for the stream's
   // id will be transferred to the HQSession
@@ -381,12 +384,12 @@ void HQUpstreamSession::HQIngressPushStream::bindTo(quic::StreamId streamId) {
 // This can only be unbound in that it has not received a stream ID yet
 void HQUpstreamSession::eraseUnboundStream(HQStreamTransportBase* hqStream) {
   auto hqPushIngressStream = dynamic_cast<HQIngressPushStream*>(hqStream);
-  CHECK(hqPushIngressStream)
+  PRX_CHECK(hqPushIngressStream)
       << "Only HQIngressPushStream streams are allowed to be non-bound";
   // This is what makes it unbound, it also cannot be in the map
-  DCHECK(!hqStream->hasIngressStreamId());
+  PRX_DCHECK(!hqStream->hasIngressStreamId());
   auto pushId = hqPushIngressStream->getPushId();
-  DCHECK(pushIdToStreamId_.find(pushId) == pushIdToStreamId_.end());
+  PRX_DCHECK(pushIdToStreamId_.find(pushId) == pushIdToStreamId_.end());
   ingressPushStreams_.erase(pushId);
 }
 
diff --git a/proxygen/lib/http/session/HQUpstreamSession.h b/proxygen/lib/http/session/HQUpstreamSession.h
index 4e069914b1..7ac923edbb 100644
--- a/proxygen/lib/http/session/HQUpstreamSession.h
+++ b/proxygen/lib/http/session/HQUpstreamSession.h
@@ -10,6 +10,7 @@
 #include <proxygen/lib/http/session/HQSession.h>
 
 #include <folly/io/async/HHWheelTimer.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/common/events/FollyQuicEventBase.h>
 
 namespace proxygen {
@@ -146,7 +147,7 @@ class HQUpstreamSession : public HQSession {
 
       // NOTE: change the API to avoid accepting parent txn ids
       // as optional
-      CHECK(parentTxnId.has_value());
+      PRX_CHECK(parentTxnId.has_value());
       auto cb = ((HQUpstreamSession&)session_).serverPushLifecycleCb_;
       if (cb) {
         cb->onHalfOpenPushedTxn(&txn_, pushId, *parentTxnId, false);
@@ -159,8 +160,8 @@ class HQUpstreamSession : public HQSession {
     void onPushMessageBegin(HTTPCodec::StreamID pushId,
                             HTTPCodec::StreamID parentTxnId,
                             HTTPMessage* /* msg */) override {
-      LOG(ERROR) << "Push promise on push stream" << " txn=" << txn_
-                 << " pushID=" << pushId << " parentTxnId=" << parentTxnId;
+      PRX_LOG(ERROR) << "Push promise on push stream" << " txn=" << txn_
+                     << " pushID=" << pushId << " parentTxnId=" << parentTxnId;
       session_.dropConnectionAsync(
           quic::QuicError(HTTP3::ErrorCode::HTTP_FRAME_UNEXPECTED,
                           "Push promise on push stream"),
diff --git a/proxygen/lib/http/session/HTTP2PriorityQueue.cpp b/proxygen/lib/http/session/HTTP2PriorityQueue.cpp
index 5ee76d4914..f4267b1325 100644
--- a/proxygen/lib/http/session/HTTP2PriorityQueue.cpp
+++ b/proxygen/lib/http/session/HTTP2PriorityQueue.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/session/HTTP2PriorityQueue.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::list;
 using std::unique_ptr;
@@ -17,7 +18,7 @@ HTTP2PriorityQueue::Node* HTTP2PriorityQueue::nodeFromBaseNode(
     HTTP2PriorityQueue::BaseNode* bnode) {
   return
 #if DEBUG
-      CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(bnode));
+      PRX_CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(bnode));
 #else
       static_cast<HTTP2PriorityQueue::Node*>(bnode);
 #endif
@@ -38,7 +39,7 @@ HTTP2PriorityQueue::Node::Node(HTTP2PriorityQueue& queue,
       weight_(weight + 1),
       txn_(txn) {
   auto result = queue_.nodes_.emplace(id_, this);
-  DCHECK(result.second);
+  PRX_DCHECK(result.second);
 }
 
 HTTP2PriorityQueue::Node::~Node() {
@@ -51,9 +52,9 @@ HTTP2PriorityQueue::Node::~Node() {
 // Add a new node as a child of this node
 HTTP2PriorityQueue::Node* HTTP2PriorityQueue::Node::emplaceNode(
     unique_ptr<HTTP2PriorityQueue::Node> node, bool exclusive) {
-  CHECK(!node->isEnqueued());
+  PRX_CHECK(!node->isEnqueued());
   list<unique_ptr<Node>> children;
-  CHECK_NE(id_, node->id_) << "Tried to create a loop in the tree";
+  PRX_CHECK_NE(id_, node->id_) << "Tried to create a loop in the tree";
   if (exclusive) {
     // this->children become new node's children
     std::swap(children, children_);
@@ -79,10 +80,10 @@ void HTTP2PriorityQueue::Node::addChildren(list<unique_ptr<Node>>&& children) {
     if (child->inEgressTree()) {
       totalEnqueuedWeight += child->weight_;
       child->parent_->removeEnqueuedChild(child.get());
-      CHECK(!child->enqueuedHook_.is_linked());
+      PRX_CHECK(!child->enqueuedHook_.is_linked());
       addEnqueuedChild(child.get());
     } else {
-      CHECK(!child->enqueuedHook_.is_linked());
+      PRX_CHECK(!child->enqueuedHook_.is_linked());
     }
     addChild(std::move(child));
   }
@@ -97,7 +98,7 @@ void HTTP2PriorityQueue::Node::addChildren(list<unique_ptr<Node>>&& children) {
 
 HTTP2PriorityQueue::Node* HTTP2PriorityQueue::Node::addChild(
     unique_ptr<HTTP2PriorityQueue::Node> child) {
-  CHECK_NE(id_, child->id_) << "Tried to create a loop in the tree";
+  PRX_CHECK_NE(id_, child->id_) << "Tried to create a loop in the tree";
   child->parent_ = this;
   totalChildWeight_ += child->weight_;
   Node* raw = child.get();
@@ -108,7 +109,7 @@ HTTP2PriorityQueue::Node* HTTP2PriorityQueue::Node::addChild(
 
 unique_ptr<HTTP2PriorityQueue::Node> HTTP2PriorityQueue::Node::detachChild(
     Node* node) {
-  CHECK(!node->isEnqueued());
+  PRX_CHECK(!node->isEnqueued());
   totalChildWeight_ -= node->weight_;
   auto it = node->self_;
   auto res = std::move(*node->self_);
@@ -164,13 +165,13 @@ bool HTTP2PriorityQueue::Node::isDescendantOf(
 
 void HTTP2PriorityQueue::Node::addEnqueuedChild(
     HTTP2PriorityQueue::Node* node) {
-  CHECK(!node->enqueuedHook_.is_linked());
+  PRX_CHECK(!node->enqueuedHook_.is_linked());
   enqueuedChildren_.push_back(*node);
 }
 
 void HTTP2PriorityQueue::Node::removeEnqueuedChild(
     HTTP2PriorityQueue::Node* node) {
-  CHECK(node->enqueuedHook_.is_linked());
+  PRX_CHECK(node->enqueuedHook_.is_linked());
   enqueuedChildren_.erase(enqueuedChildren_.iterator_to(*node));
 }
 
@@ -196,7 +197,7 @@ void HTTP2PriorityQueue::Node::propagatePendingEgressSignal(
 }
 
 void HTTP2PriorityQueue::Node::clearPendingEgress() {
-  CHECK(enqueued_);
+  PRX_CHECK(enqueued_);
   enqueued_ = false;
   propagatePendingEgressClear(this);
 }
@@ -209,7 +210,7 @@ void HTTP2PriorityQueue::Node::propagatePendingEgressClear(
   // as long as node state changes from egress-in-subtree to
   // no-egress-in-subtree
   while (parent && !stop) {
-    CHECK_GE(parent->totalEnqueuedWeight_, node->weight_);
+    PRX_CHECK_GE(parent->totalEnqueuedWeight_, node->weight_);
     parent->totalEnqueuedWeight_ -= node->weight_;
     parent->removeEnqueuedChild(node);
     stop = parent->inEgressTree();
@@ -236,12 +237,12 @@ void HTTP2PriorityQueue::Node::removeFromTree() {
     double r = double(weight_) / totalChildWeight_;
     for (auto& child : children_) {
       uint64_t newWeight = std::max(uint64_t(child->weight_ * r), uint64_t(1));
-      CHECK_LE(newWeight, 256);
+      PRX_CHECK_LE(newWeight, 256u);
       child->updateWeight(uint8_t(newWeight) - 1);
     }
   }
 
-  CHECK(!isEnqueued());
+  PRX_CHECK(!isEnqueued());
   if (inEgressTree()) {
     // Gah this is tricky.
     // The children of this node are moving to this node's parent.  We need the
@@ -267,7 +268,7 @@ bool HTTP2PriorityQueue::Node::iterate(
     return true;
   }
 #ifndef NDEBUG
-  CHECK_EQ(totalEnqueuedWeight_, totalEnqueuedWeightCheck_);
+  PRX_CHECK_EQ(totalEnqueuedWeight_, totalEnqueuedWeightCheck_);
 #endif
   if (parent_ /* exclude root */ && (all || isEnqueued())) {
     stop = fn(id_, txn_, getRelativeWeight());
@@ -294,7 +295,7 @@ bool HTTP2PriorityQueue::Node::visitBFS(
   auto relativeEnqueuedWeight = getRelativeEnqueuedWeight();
 
 #ifndef NDEBUG
-  CHECK_EQ(totalEnqueuedWeight_, totalEnqueuedWeightCheck_);
+  PRX_CHECK_EQ(totalEnqueuedWeight_, totalEnqueuedWeightCheck_);
 #endif
   // Add children when all==true, or for any not invoked node with
   // pending children
@@ -331,9 +332,9 @@ void HTTP2PriorityQueue::Node::updateEnqueuedWeight(bool activeNodes) {
   if (activeNodes) {
     if (totalEnqueuedWeightCheck_ == 0 && !isEnqueued()) {
       // Must only be called with activeCount_ > 0, root cannot be dequeued
-      CHECK_NOTNULL(parent_)->totalEnqueuedWeightCheck_ -= weight_;
+      PRX_CHECK_NOTNULL(parent_)->totalEnqueuedWeightCheck_ -= weight_;
     } else {
-      CHECK(parent_ == nullptr || enqueuedHook_.is_linked());
+      PRX_CHECK(parent_ == nullptr || enqueuedHook_.is_linked());
     }
   } else {
     totalEnqueuedWeightCheck_ = 0;
@@ -352,9 +353,9 @@ void HTTP2PriorityQueue::Node::dropPriorityNodes() {
 }
 
 void HTTP2PriorityQueue::Node::convertVirtualNode(HTTPTransaction* txn) {
-  CHECK(!txn_);
-  CHECK(!isPermanent_);
-  CHECK_GT(queue_.numVirtualNodes_, 0);
+  PRX_CHECK(!txn_);
+  PRX_CHECK(!isPermanent_);
+  PRX_CHECK_GT(queue_.numVirtualNodes_, 0u);
   queue_.numVirtualNodes_--;
   txn_ = txn;
   cancelTimeout();
@@ -438,7 +439,7 @@ void HTTP2PriorityQueue::addOrUpdatePriorityNode(HTTPCodec::StreamID id,
   auto handle = find(id);
   if (handle) {
     // already added
-    CHECK(handle->getTransaction() == nullptr);
+    PRX_CHECK(handle->getTransaction() == nullptr);
     updatePriority(handle, pri);
   } else {
     // brand new
@@ -452,14 +453,15 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::addTransaction(
     HTTPTransaction* txn,
     bool permanent,
     uint64_t* depth) {
-  CHECK_NE(id, rootNodeId_);
-  CHECK_NE(id, pri.streamDependency) << "Tried to create a loop in the tree";
-  CHECK(!txn || !permanent);
+  PRX_CHECK_NE(id, rootNodeId_);
+  PRX_CHECK_NE(id, pri.streamDependency)
+      << "Tried to create a loop in the tree";
+  PRX_CHECK(!txn || !permanent);
   if (largestId_ && id <= *largestId_) {
     Node* existingNode = find(id, depth);
     if (existingNode) {
-      CHECK(!permanent);
-      existingNode->convertVirtualNode(CHECK_NOTNULL(txn));
+      PRX_CHECK(!permanent);
+      existingNode->convertVirtualNode(PRX_CHECK_NOTNULL(txn));
       updatePriority(existingNode, pri);
       return existingNode;
     }
@@ -481,7 +483,7 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::addTransaction(
     Node* dep = find(pri.streamDependency, depth);
     if (dep == nullptr) {
       // specified a missing parent (timed out an idle node)?
-      VLOG(4) << "assigning default priority to txn=" << id;
+      PRX_VLOG(4) << "assigning default priority to txn=" << id;
       // No point to try to instantiate one more virtual node
       // if we already reached the virtual node limit
       if (numVirtualNodes_ < maxVirtualNodes_) {
@@ -499,8 +501,8 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::addTransaction(
           *depth += 1;
         }
       } else {
-        VLOG(4) << "Virtual node limit reached, ignoring stream dependency "
-                << pri.streamDependency << " for new node ID " << id;
+        PRX_VLOG(4) << "Virtual node limit reached, ignoring stream dependency "
+                    << pri.streamDependency << " for new node ID " << id;
       }
     } else {
       parent = dep;
@@ -509,8 +511,8 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::addTransaction(
       }
     }
   }
-  VLOG(4) << "Adding id=" << id << " with parent=" << parent->getID()
-          << " and weight=" << ((uint16_t)pri.weight + 1);
+  PRX_VLOG(4) << "Adding id=" << id << " with parent=" << parent->getID()
+              << " and weight=" << ((uint16_t)pri.weight + 1);
   auto node = std::make_unique<Node>(*this, parent, id, pri.weight, txn);
   if (permanent) {
     node->setPermanent();
@@ -528,11 +530,11 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::updatePriority(
     uint64_t* depth) {
   Node* node = nodeFromBaseNode(handle);
   pendingWeightChange_ = true;
-  VLOG(4) << "Updating id=" << node->getID()
-          << " with parent=" << pri.streamDependency
-          << " and weight=" << ((uint16_t)pri.weight + 1);
+  PRX_VLOG(4) << "Updating id=" << node->getID()
+              << " with parent=" << pri.streamDependency
+              << " and weight=" << ((uint16_t)pri.weight + 1);
   node->updateWeight(pri.weight);
-  CHECK_NE(pri.streamDependency, node->getID())
+  PRX_CHECK_NE(pri.streamDependency, node->getID())
       << "Tried to create a loop in the tree";
   if (pri.streamDependency == node->parentID() && !pri.exclusive) {
     // no move
@@ -558,8 +560,8 @@ HTTP2PriorityQueue::Handle HTTP2PriorityQueue::updatePriority(
                          nullptr,
                          false));
 
-      VLOG(4) << "updatePriority missing parent, creating virtual parent="
-              << newParent->getID() << " for txn=" << node->getID();
+      PRX_VLOG(4) << "updatePriority missing parent, creating virtual parent="
+                  << newParent->getID() << " for txn=" << node->getID();
     }
   }
 
@@ -585,7 +587,7 @@ void HTTP2PriorityQueue::removeTransaction(HTTP2PriorityQueue::Handle handle) {
     numVirtualNodes_++;
     scheduleNodeExpiration(node);
   } else {
-    VLOG(5) << "Deleting dangling node over max id=" << node->getID();
+    PRX_VLOG(5) << "Deleting dangling node over max id=" << node->getID();
     node->removeFromTree();
   }
 }
@@ -599,7 +601,7 @@ void HTTP2PriorityQueue::signalPendingEgress(Handle handle) {
 }
 
 void HTTP2PriorityQueue::clearPendingEgress(Handle handle) {
-  CHECK_GT(activeCount_, 0);
+  PRX_CHECK_GT(activeCount_, 0u);
   // clear does a CHECK on handle->isEnqueued()
   nodeFromBaseNode(handle)->clearPendingEgress();
   activeCount_--;
@@ -618,7 +620,7 @@ void HTTP2PriorityQueue::iterateBFS(
 
   updateEnqueuedWeight();
   while (!stop && !stopFn() && !pendingNodes.empty()) {
-    CHECK(newPendingNodes.empty());
+    PRX_CHECK(newPendingNodes.empty());
     while (!stop && !pendingNodes.empty()) {
       Node* node = findInternal(pendingNodes.front().id);
       if (node) {
@@ -704,7 +706,7 @@ void HTTP2PriorityQueue::updateEnqueuedWeight() {
 // Internal error handling
 
 void HTTP2PriorityQueue::rebuildTree() {
-  CHECK_LE(rebuildCount_ + 1, kMaxRebuilds_);
+  PRX_CHECK_LE(rebuildCount_ + 1, kMaxRebuilds_);
   root_.flattenSubtree();
   rebuildCount_++;
 }
diff --git a/proxygen/lib/http/session/HTTP2PriorityQueue.h b/proxygen/lib/http/session/HTTP2PriorityQueue.h
index dcdbc92dd8..37bc0d621a 100644
--- a/proxygen/lib/http/session/HTTP2PriorityQueue.h
+++ b/proxygen/lib/http/session/HTTP2PriorityQueue.h
@@ -16,6 +16,7 @@
 
 #include <deque>
 #include <list>
+#include <proxygen/lib/utils/LogShim.h>
 #include <unordered_map>
 
 namespace proxygen {
@@ -201,8 +202,8 @@ class HTTP2PriorityQueue : public HTTP2PriorityQueueBase {
 
   void scheduleNodeExpiration(Node* node) {
     if (timeout_) {
-      VLOG(5) << "scheduling expiration for node=" << node->getID();
-      DCHECK_GT(kNodeLifetime_.count(), 0);
+      PRX_VLOG(5) << "scheduling expiration for node=" << node->getID();
+      PRX_DCHECK_GT(kNodeLifetime_.count(), 0);
       timeout_.scheduleTimeout(node, kNodeLifetime_);
     }
   }
@@ -377,8 +378,8 @@ class HTTP2PriorityQueue : public HTTP2PriorityQueueBase {
     static void propagatePendingEgressClear(Node* node);
 
     void timeoutExpired() noexcept override {
-      VLOG(5) << "Node=" << id_ << " expired";
-      CHECK(txn_ == nullptr);
+      PRX_VLOG(5) << "Node=" << id_ << " expired";
+      PRX_CHECK(txn_ == nullptr);
       queue_.pendingWeightChange_ = true;
       removeFromTree();
     }
diff --git a/proxygen/lib/http/session/HTTPDirectResponseHandler.cpp b/proxygen/lib/http/session/HTTPDirectResponseHandler.cpp
index da818e0356..11314f5374 100644
--- a/proxygen/lib/http/session/HTTPDirectResponseHandler.cpp
+++ b/proxygen/lib/http/session/HTTPDirectResponseHandler.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/Conv.h>
 #include <proxygen/lib/http/session/HTTPErrorPage.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 using std::string;
@@ -40,7 +41,7 @@ void HTTPDirectResponseHandler::detachTransaction() noexcept {
 
 void HTTPDirectResponseHandler::onHeadersComplete(
     std::unique_ptr<HTTPMessage> /*msg*/) noexcept {
-  VLOG(4) << "processing request";
+  PRX_VLOG(4) << "processing request";
   headersSent_ = true;
   HTTPMessage response;
   std::unique_ptr<folly::IOBuf> responseBody;
@@ -57,7 +58,7 @@ void HTTPDirectResponseHandler::onHeadersComplete(
   if (errorPage_) {
     HTTPErrorPage::Page page = errorPage_->generate(
         0, statusCode_, statusMessage_, nullptr, empty_string, err_);
-    VLOG(4) << "sending error page with type " << page.contentType;
+    PRX_VLOG(4) << "sending error page with type " << page.contentType;
     response.getHeaders().add(HTTP_HEADER_CONTENT_TYPE, page.contentType);
     responseBody = std::move(page.content);
     page.headers.copyTo(response.getHeaders());
@@ -73,12 +74,12 @@ void HTTPDirectResponseHandler::onHeadersComplete(
 }
 
 void HTTPDirectResponseHandler::onBody(unique_ptr<IOBuf> /*chain*/) noexcept {
-  VLOG(4) << "discarding request body";
+  PRX_VLOG(4) << "discarding request body";
 }
 
 void HTTPDirectResponseHandler::onTrailers(
     unique_ptr<HTTPHeaders> /*trailers*/) noexcept {
-  VLOG(4) << "discarding request trailers";
+  PRX_VLOG(4) << "discarding request trailers";
 }
 
 void HTTPDirectResponseHandler::onEOM() noexcept {
@@ -97,7 +98,7 @@ void HTTPDirectResponseHandler::onError(const HTTPException& error) noexcept {
 
   if (error.getDirection() == HTTPException::Direction::INGRESS) {
     if (error.getProxygenError() == kErrorTimeout) {
-      VLOG(4) << "processing ingress timeout";
+      PRX_VLOG(4) << "processing ingress timeout";
       if (!headersSent_) {
         onHeadersComplete(nullptr);
       }
@@ -105,7 +106,7 @@ void HTTPDirectResponseHandler::onError(const HTTPException& error) noexcept {
         onEOM();
       }
     } else {
-      VLOG(4) << "processing ingress error";
+      PRX_VLOG(4) << "processing ingress error";
       if (!headersSent_) {
         onHeadersComplete(nullptr);
       }
diff --git a/proxygen/lib/http/session/HTTPDownstreamSession.cpp b/proxygen/lib/http/session/HTTPDownstreamSession.cpp
index 5e21330d8e..8093e63dd8 100644
--- a/proxygen/lib/http/session/HTTPDownstreamSession.cpp
+++ b/proxygen/lib/http/session/HTTPDownstreamSession.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HTTPDownstreamSession.h>
 
 #include <proxygen/lib/http/session/HTTPSessionController.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -20,8 +21,8 @@ void HTTPDownstreamSession::startNow() {
 
 void HTTPDownstreamSession::setupOnHeadersComplete(HTTPTransaction* txn,
                                                    HTTPMessage* msg) {
-  VLOG(5) << "setupOnHeadersComplete txn=" << txn << ", id=" << txn->getID()
-          << ", handler=" << txn->getHandler() << ", msg=" << msg;
+  PRX_VLOG(5) << "setupOnHeadersComplete txn=" << txn << ", id=" << txn->getID()
+              << ", handler=" << txn->getHandler() << ", msg=" << msg;
   // We need to find a Handler to process the transaction.
   // Note: The handler is responsible for freeing itself
   // when it has finished processing the transaction.  The
@@ -30,7 +31,8 @@ void HTTPDownstreamSession::setupOnHeadersComplete(HTTPTransaction* txn,
 
   // In the general case, delegate to the handler factory to generate
   // a handler for the transaction.
-  auto* handler = CHECK_NOTNULL(getController()->getRequestHandler(*txn, msg));
+  auto* handler =
+      PRX_CHECK_NOTNULL(getController()->getRequestHandler(*txn, msg));
 
   DestructorGuard dg(this);
   txn->setHandler(handler);
diff --git a/proxygen/lib/http/session/HTTPDownstreamSession.h b/proxygen/lib/http/session/HTTPDownstreamSession.h
index 5587f4baf4..38fe027be4 100644
--- a/proxygen/lib/http/session/HTTPDownstreamSession.h
+++ b/proxygen/lib/http/session/HTTPDownstreamSession.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <proxygen/lib/http/session/HTTPSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/WheelTimerInstance.h>
 
 namespace proxygen {
@@ -36,11 +37,12 @@ class HTTPDownstreamSession final : public HTTPSession {
                     std::move(sock),
                     localAddr,
                     peerAddr,
-                    CHECK_NOTNULL(controller),
+                    PRX_CHECK_NOTNULL(controller),
                     std::move(codec),
                     tinfo,
                     infoCallback) {
-    CHECK_EQ(codec_->getTransportDirection(), TransportDirection::DOWNSTREAM);
+    PRX_CHECK_EQ(codec_->getTransportDirection(),
+                 TransportDirection::DOWNSTREAM);
   }
 
   // allows using HTTPDownstreamSession with HHWheelTimer when it is not shared
@@ -56,7 +58,7 @@ class HTTPDownstreamSession final : public HTTPSession {
                               std::move(sock),
                               localAddr,
                               peerAddr,
-                              CHECK_NOTNULL(controller),
+                              PRX_CHECK_NOTNULL(controller),
                               std::move(codec),
                               tinfo,
                               infoCallback) {
@@ -89,7 +91,7 @@ class HTTPDownstreamSession final : public HTTPSession {
 
   // Upstream methods.  Can implement when servers support making request
   bool isDetachable(bool) const override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   void attachThreadLocals(folly::EventBase*,
@@ -99,27 +101,27 @@ class HTTPDownstreamSession final : public HTTPSession {
                           FilterIteratorFn,
                           HeaderCodec::Stats*,
                           HTTPSessionController*) override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   void detachThreadLocals(bool) override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   HTTPTransaction* newTransaction(HTTPTransaction::Handler*) override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   bool isReplaySafe() const override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   bool isReusable() const override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 
   bool isClosing() const override {
-    LOG(FATAL) << __func__ << " is an upstream interface";
+    PRX_LOG(FATAL) << __func__ << " is an upstream interface";
   }
 };
 
diff --git a/proxygen/lib/http/session/HTTPErrorPage.cpp b/proxygen/lib/http/session/HTTPErrorPage.cpp
index 8b666a806e..6e8647d779 100644
--- a/proxygen/lib/http/session/HTTPErrorPage.cpp
+++ b/proxygen/lib/http/session/HTTPErrorPage.cpp
@@ -9,7 +9,7 @@
 #include <proxygen/lib/http/session/HTTPErrorPage.h>
 
 #include <folly/io/IOBuf.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using std::string;
 
@@ -29,7 +29,7 @@ HTTPErrorPage::Page HTTPStaticErrorPage::generate(
     ProxygenError err) const {
 
   HTTPHeaders headers;
-  VLOG(4) << "adding server-status header for proxygen error";
+  PRX_VLOG(4) << "adding server-status header for proxygen error";
   headers.set("Server-Status", folly::to<std::string>(static_cast<int>(err)));
   return {contentType_, content_->clone(), std::move(headers)};
 }
diff --git a/proxygen/lib/http/session/HTTPEvent.h b/proxygen/lib/http/session/HTTPEvent.h
index ac2e31e112..035e717ed5 100644
--- a/proxygen/lib/http/session/HTTPEvent.h
+++ b/proxygen/lib/http/session/HTTPEvent.h
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include <glog/logging.h>
 #include <proxygen/lib/http/HTTPConstants.h>
 #include <proxygen/lib/http/codec/HTTPCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -49,7 +49,7 @@ class HTTPEvent {
     // so we could enforce this check at compile time.  Unfortunately,
     // that would prevent us from using this constructor with
     // deferredCallbacks_.emplace().)
-    CHECK(event == Type::CHUNK_HEADER);
+    PRX_CHECK(event == Type::CHUNK_HEADER);
   }
 
   HTTPEvent(HTTPCodec::StreamID streamID,
@@ -85,7 +85,7 @@ class HTTPEvent {
         length_(0),
         event_(Type::ERROR),
         upgrade_(false) {
-    CHECK(error_);
+    PRX_CHECK(error_);
   }
 
   HTTPEvent(HTTPCodec::StreamID streamID, Type event, UpgradeProtocol protocol)
@@ -125,12 +125,12 @@ class HTTPEvent {
   }
 
   bool isUpgrade() const {
-    CHECK(event_ == Type::MESSAGE_COMPLETE);
+    PRX_CHECK(event_ == Type::MESSAGE_COMPLETE);
     return upgrade_;
   }
 
   size_t getChunkLength() const {
-    CHECK(event_ == Type::CHUNK_HEADER);
+    PRX_CHECK(event_ == Type::CHUNK_HEADER);
     return length_;
   }
 
diff --git a/proxygen/lib/http/session/HTTPSession.cpp b/proxygen/lib/http/session/HTTPSession.cpp
index c540904b80..3fc3a1881f 100644
--- a/proxygen/lib/http/session/HTTPSession.cpp
+++ b/proxygen/lib/http/session/HTTPSession.cpp
@@ -23,6 +23,7 @@
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
 #include <proxygen/lib/http/webtransport/WebTransportSession.h>
 #include <proxygen/lib/http/webtransport/WtUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/ConnectionManager.h>
 
 using fizz::AsyncFizzBase;
@@ -166,12 +167,12 @@ void HTTPSession::setupCodec() {
 }
 
 HTTPSession::~HTTPSession() {
-  VLOG(4) << *this << " closing";
+  PRX_VLOG(4) << *this << " closing";
 
-  CHECK(transactions_.empty());
+  PRX_CHECK(transactions_.empty());
   txnEgressQueue_.dropPriorityNodes();
-  CHECK(txnEgressQueue_.empty());
-  DCHECK(!sock_->getReadCallback());
+  PRX_CHECK(txnEgressQueue_.empty());
+  PRX_DCHECK(!sock_->getReadCallback());
 
   if (writeTimeout_.isScheduled()) {
     writeTimeout_.cancelTimeout();
@@ -202,7 +203,7 @@ std::chrono::milliseconds HTTPSession::getDrainTimeout() const {
 }
 
 void HTTPSession::startNow() {
-  CHECK(!started_);
+  PRX_CHECK(!started_);
   started_ = true;
   detail::setEgressWtHttpSettings(codec_->getEgressSettings());
 
@@ -220,7 +221,7 @@ void HTTPSession::startNow() {
       wheelTimer_.scheduleTimeout(&drainTimeout_, getDrainTimeout());
     } else if (isDownstream()) {
       // transactions must be empty and reads cannot be shutdown
-      VLOG(4) << "Starting drain timer";
+      PRX_VLOG(4) << "Starting drain timer";
       resetTimeoutTo(getDrainTimeout());
     } // it's upstream, let the client close it when they want
   }
@@ -254,7 +255,7 @@ void HTTPSession::setSessionStats(HTTPSessionStats* stats) {
 void HTTPSession::setFlowControl(size_t initialReceiveWindow,
                                  size_t receiveStreamWindowSize,
                                  size_t receiveSessionWindowSize) {
-  CHECK(!started_);
+  PRX_CHECK(!started_);
   initialReceiveWindow_ = initialReceiveWindow;
   receiveStreamWindowSize_ = receiveStreamWindowSize;
   receiveSessionWindowSize_ = receiveSessionWindowSize;
@@ -267,7 +268,7 @@ void HTTPSession::setFlowControl(size_t initialReceiveWindow,
 }
 
 void HTTPSession::setEgressSettings(const SettingsList& inSettings) {
-  VLOG_IF(4, started_) << "Must flush egress settings to peer";
+  PRX_VLOG_IF(4, started_) << "Must flush egress settings to peer";
   HTTPSettings* settings = codec_->getEgressSettings();
   if (settings) {
     for (const auto& setting : inSettings) {
@@ -280,7 +281,7 @@ void HTTPSession::setEgressSettings(const SettingsList& inSettings) {
 }
 
 void HTTPSession::setMaxConcurrentIncomingStreams(uint32_t num) {
-  CHECK(!started_);
+  PRX_CHECK(!started_);
   if (codec_->supportsParallelRequests()) {
     maxConcurrentIncomingStreams_ = num;
     HTTPSettings* settings = codec_->getEgressSettings();
@@ -292,19 +293,20 @@ void HTTPSession::setMaxConcurrentIncomingStreams(uint32_t num) {
 }
 
 void HTTPSession::setEgressBytesLimit(uint64_t bytesLimit) {
-  CHECK(!started_);
+  PRX_CHECK(!started_);
   egressBytesLimit_ = bytesLimit;
 }
 
 void HTTPSession::readTimeoutExpired() noexcept {
-  VLOG(3) << "session-level timeout on " << *this;
+  PRX_VLOG(3) << "session-level timeout on " << *this;
 
   DestructorGuard g(this);
   setCloseReason(ConnectionCloseReason::TIMEOUT);
   if (!codec_->isReusable() && transactions_.empty()) {
-    LOG_IF(DFATAL, readsShutdown()) << "Why did we have a read timer running?";
+    PRX_LOG_IF(DFATAL, readsShutdown())
+        << "Why did we have a read timer running?";
     // Shutdown reads (uninstall read callback, etc).  Session will close
-    VLOG(4) << "Shutdown from readTimeoutExpired sess=" << *this;
+    PRX_VLOG(4) << "Shutdown from readTimeoutExpired sess=" << *this;
     shutdownTransport(true, false);
   } // otherwise
   //    1. The codec is re-usable - we will notifyPendingShutdown to start drain
@@ -315,9 +317,9 @@ void HTTPSession::readTimeoutExpired() noexcept {
 }
 
 void HTTPSession::writeTimeoutExpired() noexcept {
-  VLOG(4) << "Write timeout for " << *this;
+  PRX_VLOG(4) << "Write timeout for " << *this;
 
-  CHECK(pendingWrite_.hasValue());
+  PRX_CHECK(pendingWrite_.hasValue());
   DestructorGuard g(this);
 
   setCloseReason(ConnectionCloseReason::TIMEOUT);
@@ -325,7 +327,7 @@ void HTTPSession::writeTimeoutExpired() noexcept {
 }
 
 void HTTPSession::flowControlTimeoutExpired() noexcept {
-  VLOG(4) << "Flow control timeout for " << *this;
+  PRX_VLOG(4) << "Flow control timeout for " << *this;
 
   DestructorGuard g(this);
 
@@ -354,7 +356,7 @@ void HTTPSession::notifyPendingEgress() noexcept {
 }
 
 void HTTPSession::notifyPendingShutdown() {
-  VLOG(4) << *this << " notified pending shutdown";
+  PRX_VLOG(4) << *this << " notified pending shutdown";
   drain();
 }
 
@@ -370,7 +372,7 @@ void HTTPSession::closeWhenIdle() {
     dropConnection();
   } else if (isDownstream() && !readsShutdown()) {
     auto to = getDrainTimeout();
-    VLOG(4) << "Starting drain timer t=" << to.count();
+    PRX_VLOG(4) << "Starting drain timer t=" << to.count();
     resetTimeoutTo(to);
   }
 }
@@ -383,16 +385,16 @@ void HTTPSession::immediateShutdown() {
     shutdownTransportCb_.reset();
   }
   // checkForShutdown only closes the connection if these conditions are true
-  DCHECK(writesShutdown());
-  DCHECK(transactions_.empty());
+  PRX_DCHECK(writesShutdown());
+  PRX_DCHECK(transactions_.empty());
   checkForShutdown();
 }
 
 void HTTPSession::dropConnection(const std::string& errorMsg) {
-  VLOG(4) << "dropping " << *this;
+  PRX_VLOG(4) << "dropping " << *this;
   if (!sock_ || (readsShutdown() && writesShutdown())) {
-    VLOG(4) << *this << " already shutdown";
-    DCHECK(!shutdownTransportCb_) << "Why is there a shutdownTransportCb_?";
+    PRX_VLOG(4) << *this << " already shutdown";
+    PRX_DCHECK(!shutdownTransportCb_) << "Why is there a shutdownTransportCb_?";
     if (isLoopCallbackScheduled()) {
       immediateShutdown();
     }
@@ -436,7 +438,7 @@ void HTTPSession::getReadBuffer(void** buf, size_t* bufSize) {
 void HTTPSession::readDataAvailable(size_t readSize) noexcept {
   FOLLY_SCOPED_TRACE_SECTION(
       "HTTPSession - readDataAvailable", "readSize", readSize);
-  VLOG(10) << "read completed on " << *this << ", bytes=" << readSize;
+  PRX_VLOG(10) << "read completed on " << *this << ", bytes=" << readSize;
 
   DestructorGuard dg(this);
   if (pingProber_) {
@@ -445,8 +447,8 @@ void HTTPSession::readDataAvailable(size_t readSize) noexcept {
   resetTimeout();
 
   if (ingressError_) {
-    VLOG(3) << "discarding readBuf due to ingressError_ sess=" << *this
-            << " bytes=" << readSize;
+    PRX_VLOG(3) << "discarding readBuf due to ingressError_ sess=" << *this
+                << " bytes=" << readSize;
     return;
   }
   readBuf_.postallocate(readSize);
@@ -466,7 +468,7 @@ void HTTPSession::readBufferAvailable(std::unique_ptr<IOBuf> readBuf) noexcept {
   size_t readSize = readBuf->computeChainDataLength();
   FOLLY_SCOPED_TRACE_SECTION(
       "HTTPSession - readBufferAvailable", "readSize", readSize);
-  VLOG(5) << "read completed on " << *this << ", bytes=" << readSize;
+  PRX_VLOG(5) << "read completed on " << *this << ", bytes=" << readSize;
 
   if (pingProber_) {
     pingProber_->refreshTimeout(/*onIngress=*/true);
@@ -476,8 +478,8 @@ void HTTPSession::readBufferAvailable(std::unique_ptr<IOBuf> readBuf) noexcept {
   resetTimeout();
 
   if (ingressError_) {
-    VLOG(3) << "discarding readBuf due to ingressError_ sess=" << *this
-            << " bytes=" << readSize;
+    PRX_VLOG(3) << "discarding readBuf due to ingressError_ sess=" << *this
+                << " bytes=" << readSize;
     return;
   }
   readBuf_.append(std::move(readBuf));
@@ -515,7 +517,7 @@ void HTTPSession::processReadData() {
 
 void HTTPSession::readEOF() noexcept {
   DestructorGuard guard(this);
-  VLOG(4) << "EOF on " << *this;
+  PRX_VLOG(4) << "EOF on " << *this;
   // for SSL only: error without any bytes from the client might happen
   // due to client-side issues with the SSL cert. Note that it can also
   // happen if the client sends a H2 frame header but no body.
@@ -534,7 +536,7 @@ void HTTPSession::readEOF() noexcept {
 
 void HTTPSession::readErr(const AsyncSocketException& ex) noexcept {
   DestructorGuard guard(this);
-  VLOG(4) << "read error on " << *this << ": " << ex.what();
+  PRX_VLOG(4) << "read error on " << *this << ": " << ex.what();
 
   auto sslEx = dynamic_cast<const folly::SSLException*>(&ex);
   if (infoCallback_ && sslEx) {
@@ -562,8 +564,8 @@ HTTPTransaction* HTTPSession::newPushedTransaction(
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorPushNotSupported);
     return nullptr;
   }
-  CHECK(isDownstream());
-  CHECK_NOTNULL(handler);
+  PRX_CHECK(isDownstream());
+  PRX_CHECK_NOTNULL(handler);
   if (draining_) {
     // This session doesn't support any more push transactions
     SET_PROXYGEN_ERROR_IF(error, ProxygenError::kErrorTransportIsDraining);
@@ -598,7 +600,7 @@ size_t HTTPSession::getCodecSendWindowSize() const {
 
 void HTTPSession::onMessageBegin(HTTPCodec::StreamID streamID,
                                  HTTPMessage* msg) {
-  VLOG(4) << "processing new msg streamID=" << streamID << " " << *this;
+  PRX_VLOG(4) << "processing new msg streamID=" << streamID << " " << *this;
 
   HTTPTransaction* txn = findTransaction(streamID);
   if (txn) {
@@ -628,57 +630,57 @@ void HTTPSession::onMessageBegin(HTTPCodec::StreamID streamID,
 
     // HTTP/1.1 pipeline is detected, and which is incompactible with
     // ByteEventTracker. Drain all the ByteEvents
-    CHECK(byteEventTracker_);
+    PRX_CHECK(byteEventTracker_);
     byteEventTracker_->drainByteEvents();
 
     // drainByteEvents() may detach txn(s). Don't pause read if one txn left
     if (getPipelineStreamCount() < 2) {
-      DCHECK(readsUnpaused());
+      PRX_DCHECK(readsUnpaused());
       return;
     }
 
     // There must be at least two transactions (we just checked). The previous
     // txns haven't completed yet. Pause reads until they complete
-    DCHECK_GE(transactions_.size(), 2);
+    PRX_DCHECK_GE(transactions_.size(), 2u);
     std::map<HTTPCodec::StreamID, HTTPTransaction*> sortedTxns;
     for (auto& x_2 : transactions_) {
       sortedTxns.emplace(x_2.first, &x_2.second);
     }
     for (auto it = ++sortedTxns.rbegin(); it != sortedTxns.rend(); ++it) {
-      DCHECK(it->second->isIngressEOMSeen());
+      PRX_DCHECK(it->second->isIngressEOMSeen());
       it->second->pauseIngress();
     }
     sortedTxns.rbegin()->second->pauseIngress();
-    DCHECK_EQ(liveTransactions_, 0);
-    DCHECK(readsPaused());
+    PRX_DCHECK_EQ(liveTransactions_, 0u);
+    PRX_DCHECK(readsPaused());
   }
 }
 
 void HTTPSession::onPushMessageBegin(HTTPCodec::StreamID streamID,
                                      HTTPCodec::StreamID assocStreamID,
                                      HTTPMessage* msg) {
-  VLOG(4) << "processing new push promise streamID=" << streamID
-          << " on assocStreamID=" << assocStreamID << " " << *this;
+  PRX_VLOG(4) << "processing new push promise streamID=" << streamID
+              << " on assocStreamID=" << assocStreamID << " " << *this;
   if (infoCallback_) {
     infoCallback_->onRequestBegin(*this);
   }
   if (assocStreamID == 0) {
-    VLOG(2) << "push promise " << streamID << " should be associated with "
-            << "an active stream=" << assocStreamID << " " << *this;
+    PRX_VLOG(2) << "push promise " << streamID << " should be associated with "
+                << "an active stream=" << assocStreamID << " " << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   if (isDownstream()) {
-    VLOG(2) << "push promise cannot be sent to upstream " << *this;
+    PRX_VLOG(2) << "push promise cannot be sent to upstream " << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
 
   HTTPTransaction* assocTxn = findTransaction(assocStreamID);
   if (!assocTxn || assocTxn->isIngressEOMSeen()) {
-    VLOG(2) << "cannot find the assocTxn=" << assocTxn
-            << ", or assoc stream is already closed by upstream" << *this;
+    PRX_VLOG(2) << "cannot find the assocTxn=" << assocTxn
+                << ", or assoc stream is already closed by upstream" << *this;
     invalidStream(streamID, ErrorCode::PROTOCOL_ERROR);
     return;
   }
@@ -689,8 +691,8 @@ void HTTPSession::onPushMessageBegin(HTTPCodec::StreamID streamID,
   }
 
   if (!assocTxn->onPushedTransaction(txn)) {
-    VLOG(1) << "Failed to add pushed txn " << streamID << " to assoc txn "
-            << assocStreamID << " on " << *this;
+    PRX_VLOG(1) << "Failed to add pushed txn " << streamID << " to assoc txn "
+                << assocStreamID << " on " << *this;
     HTTPException ex(
         HTTPException::Direction::INGRESS_AND_EGRESS,
         folly::to<std::string>("Failed to add pushed transaction ", streamID));
@@ -703,8 +705,8 @@ void HTTPSession::onHeadersComplete(HTTPCodec::StreamID streamID,
                                     unique_ptr<HTTPMessage> msg) {
   // The codec's parser detected the end of an ingress message's
   // headers.
-  VLOG(4) << "processing ingress headers complete for " << *this
-          << ", streamID=" << streamID;
+  PRX_VLOG(4) << "processing ingress headers complete for " << *this
+              << ", streamID=" << streamID;
 
   if (!codec_->isReusable()) {
     setCloseReason(ConnectionCloseReason::REQ_NOTREUSABLE);
@@ -790,7 +792,7 @@ void HTTPSession::onBody(HTTPCodec::StreamID streamID,
   }
 
   if (HTTPSessionBase::onBodyImpl(std::move(chain), length, padding, txn)) {
-    VLOG(4) << *this << " pausing due to read limit exceeded.";
+    PRX_VLOG(4) << *this << " pausing due to read limit exceeded.";
     pauseReads();
   }
 }
@@ -845,8 +847,8 @@ void HTTPSession::onMessageComplete(HTTPCodec::StreamID streamID,
   DestructorGuard dg(this);
   // The codec's parser detected the end of the ingress message for
   // this transaction.
-  VLOG(4) << "processing ingress message complete for " << *this
-          << ", streamID=" << streamID;
+  PRX_VLOG(4) << "processing ingress message complete for " << *this
+              << ", streamID=" << streamID;
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     invalidStream(streamID);
@@ -884,7 +886,7 @@ void HTTPSession::onMessageComplete(HTTPCodec::StreamID streamID,
   // There may be additional checks that need to be performed that are
   // specific to requests or responses, so we call the subclass too.
   if (!codec_->isReusable() && !codec_->supportsParallelRequests()) {
-    VLOG(4) << *this << " cannot reuse ingress";
+    PRX_VLOG(4) << *this << " cannot reuse ingress";
     shutdownTransport(true, false);
   }
 }
@@ -896,7 +898,8 @@ void HTTPSession::onError(HTTPCodec::StreamID streamID,
   // The codec detected an error in the ingress stream, possibly bad
   // syntax, a truncated message, or bad semantics in the frame.  If reads
   // are paused, queue up the event; otherwise, process it now.
-  VLOG(4) << "Error on " << *this << ", streamID=" << streamID << ", " << error;
+  PRX_VLOG(4) << "Error on " << *this << ", streamID=" << streamID << ", "
+              << error;
 
   if (ingressError_) {
     return;
@@ -932,7 +935,7 @@ void HTTPSession::onError(HTTPCodec::StreamID streamID,
     } else if (newTxn) {
       onNewTransactionParseError(streamID, error);
     } else {
-      VLOG(4) << *this << " parse error with invalid transaction";
+      PRX_VLOG(4) << *this << " parse error with invalid transaction";
       invalidStream(streamID);
     }
     return;
@@ -946,20 +949,20 @@ void HTTPSession::onError(HTTPCodec::StreamID streamID,
 
   txn->onError(error);
   if (!codec_->isReusable() && transactions_.empty()) {
-    VLOG(4) << *this << "shutdown from onError";
+    PRX_VLOG(4) << *this << "shutdown from onError";
     setCloseReason(ConnectionCloseReason::SESSION_PARSE_ERROR);
     shutdownTransport(true, true);
   }
 }
 
 void HTTPSession::onAbort(HTTPCodec::StreamID streamID, ErrorCode code) {
-  VLOG(4) << "stream abort on " << *this << ", streamID=" << streamID
-          << ", code=" << getErrorCodeString(code);
+  PRX_VLOG(4) << "stream abort on " << *this << ", streamID=" << streamID
+              << ", code=" << getErrorCodeString(code);
 
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
-    VLOG(4) << *this
-            << " abort for unrecognized transaction, streamID= " << streamID;
+    PRX_VLOG(4) << *this << " abort for unrecognized transaction, streamID= "
+                << streamID;
     return;
   }
   HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS,
@@ -973,10 +976,10 @@ void HTTPSession::onAbort(HTTPCodec::StreamID streamID, ErrorCode code) {
 
   if (abortPushesOnRST_ && isDownstream() && !txn->getAssocTxnId() &&
       code == ErrorCode::CANCEL) {
-    VLOG(4) << "Cancel all push txns because assoc txn has been cancelled.";
+    PRX_VLOG(4) << "Cancel all push txns because assoc txn has been cancelled.";
     for (auto assocPushId : txn->getPushedTransactions()) {
       auto* pushTxn = findTransaction(assocPushId);
-      DCHECK(pushTxn != nullptr);
+      PRX_DCHECK(pushTxn != nullptr);
       pushTxn->onError(ex);
     }
   }
@@ -988,7 +991,7 @@ void HTTPSession::onGoaway(uint64_t lastGoodStreamID,
                            ErrorCode code,
                            std::unique_ptr<folly::IOBuf> debugData) {
   DestructorGuard g(this);
-  VLOG(4) << "GOAWAY on " << *this << ", code=" << getErrorCodeString(code);
+  PRX_VLOG(4) << "GOAWAY on " << *this << ", code=" << getErrorCodeString(code);
 
   setCloseReason(ConnectionCloseReason::GOAWAY);
 
@@ -1039,7 +1042,7 @@ void HTTPSession::onGoaway(uint64_t lastGoodStreamID,
 }
 
 void HTTPSession::onPingRequest(uint64_t data) {
-  VLOG(4) << *this << " got ping request with data=" << data;
+  PRX_VLOG(4) << *this << " got ping request with data=" << data;
 
   TimePoint timestamp = getCurrentTime();
 
@@ -1071,7 +1074,7 @@ void HTTPSession::onPingRequest(uint64_t data) {
 }
 
 void HTTPSession::onPingReply(uint64_t data) {
-  VLOG(4) << *this << " got ping reply with id=" << data;
+  PRX_VLOG(4) << *this << " got ping reply with id=" << data;
   if (pingProber_) {
     pingProber_->onPingReply(data);
   }
@@ -1093,8 +1096,8 @@ void HTTPSession::onPingReply(uint64_t data) {
 
 void HTTPSession::onWindowUpdate(HTTPCodec::StreamID streamID,
                                  uint32_t amount) {
-  VLOG(4) << *this << " got window update on streamID=" << streamID << " for "
-          << amount << " bytes.";
+  PRX_VLOG(4) << *this << " got window update on streamID=" << streamID
+              << " for " << amount << " bytes.";
   HTTPTransaction* txn = findTransaction(streamID);
   if (!txn) {
     return;
@@ -1120,7 +1123,7 @@ void HTTPSession::onSettings(const SettingsList& settings) {
 }
 
 void HTTPSession::onSettingsAck() {
-  VLOG(4) << *this << " received settings ack";
+  PRX_VLOG(4) << *this << " received settings ack";
   if (infoCallback_) {
     infoCallback_->onSettingsAck(*this);
   }
@@ -1136,15 +1139,16 @@ void HTTPSession::onPriority(HTTPCodec::StreamID streamID,
 }
 
 void HTTPSession::onSetSendWindow(uint32_t windowSize) {
-  VLOG(4) << *this << " got send window size adjustment. new=" << windowSize;
+  PRX_VLOG(4) << *this
+              << " got send window size adjustment. new=" << windowSize;
   invokeOnAllTransactions([windowSize](HTTPTransaction* txn) {
     txn->onIngressSetSendWindow(windowSize);
   });
 }
 
 void HTTPSession::onSetMaxInitiatedStreams(uint32_t maxTxns) {
-  VLOG(4) << *this << " got new maximum number of concurrent txns "
-          << "we can initiate: " << maxTxns;
+  PRX_VLOG(4) << *this << " got new maximum number of concurrent txns "
+              << "we can initiate: " << maxTxns;
   const bool didSupport = supportsMoreTransactions();
   maxConcurrentOutgoingStreamsRemote_ = maxTxns;
   if (infoCallback_ && didSupport != supportsMoreTransactions()) {
@@ -1163,9 +1167,9 @@ size_t HTTPSession::sendSettings() {
 }
 
 void HTTPSession::pauseIngress(HTTPTransaction* txn) noexcept {
-  VLOG(4) << *this << " pausing streamID=" << txn->getID()
-          << ", liveTransactions_ was " << liveTransactions_;
-  CHECK_GT(liveTransactions_, 0);
+  PRX_VLOG(4) << *this << " pausing streamID=" << txn->getID()
+              << ", liveTransactions_ was " << liveTransactions_;
+  PRX_CHECK_GT(liveTransactions_, 0u);
   --liveTransactions_;
 
   if (liveTransactions_ == 0) {
@@ -1174,8 +1178,8 @@ void HTTPSession::pauseIngress(HTTPTransaction* txn) noexcept {
 }
 
 void HTTPSession::resumeIngress(HTTPTransaction* txn) noexcept {
-  VLOG(4) << *this << " resuming streamID=" << txn->getID()
-          << ", liveTransactions_ was " << liveTransactions_;
+  PRX_VLOG(4) << *this << " resuming streamID=" << txn->getID()
+              << ", liveTransactions_ was " << liveTransactions_;
   ++liveTransactions_;
 
   // This function can be called from detach(), in which case liveTransactions_
@@ -1191,7 +1195,7 @@ void HTTPSession::transactionTimeout(HTTPTransaction* txn) noexcept {
   // a Handler yet, because we haven't yet received the full request
   // headers, we give it a DirectResponseHandler that generates an
   // error page.
-  VLOG(3) << "Transaction timeout for streamID=" << txn->getID();
+  PRX_VLOG(3) << "Transaction timeout for streamID=" << txn->getID();
   if (!codec_->supportsParallelRequests()) {
     // this error should only prevent us from reading/handling more errors
     // on serial streams
@@ -1200,7 +1204,7 @@ void HTTPSession::transactionTimeout(HTTPTransaction* txn) noexcept {
 
   if (!txn->getHandler() &&
       txn->getEgressState() == HTTPTransactionEgressSM::State::Start) {
-    VLOG(4) << *this << " Timed out receiving headers";
+    PRX_VLOG(4) << *this << " Timed out receiving headers";
     if (infoCallback_) {
       infoCallback_->onIngressError(*this, kErrorTimeout);
     }
@@ -1214,7 +1218,7 @@ void HTTPSession::transactionTimeout(HTTPTransaction* txn) noexcept {
       return;
     }
 
-    VLOG(4) << *this << " creating direct error handler";
+    PRX_VLOG(4) << *this << " creating direct error handler";
     auto handler = getTransactionTimeoutHandler(txn);
     txn->setHandler(handler);
   }
@@ -1229,7 +1233,7 @@ void HTTPSession::sendHeaders(HTTPTransaction* txn,
                               const HTTPMessage& headers,
                               HTTPHeaderSize* size,
                               bool includeEOM) noexcept {
-  CHECK(started_);
+  PRX_CHECK(started_);
   unique_ptr<IOBuf> goawayBuf;
   if (draining_ && isUpstream() && codec_->isReusable() &&
       allTransactionsStarted()) {
@@ -1268,15 +1272,15 @@ void HTTPSession::sendHeaders(HTTPTransaction* txn,
   }
 
   if (size) {
-    VLOG(4) << *this << " sending headers, size=" << size->compressed
-            << ", uncompressedSize=" << size->uncompressed;
+    PRX_VLOG(4) << *this << " sending headers, size=" << size->compressed
+                << ", uncompressedSize=" << size->uncompressed;
   }
   if (goawayBuf) {
-    VLOG(4) << *this << " moved GOAWAY to end of writeBuf";
+    PRX_VLOG(4) << *this << " moved GOAWAY to end of writeBuf";
     writeBuf_.append(std::move(goawayBuf));
   }
   if (includeEOM) {
-    CHECK_GE(newOffset, oldOffset);
+    PRX_CHECK_GE(newOffset, oldOffset);
     commonEom(txn, newOffset - oldOffset, true);
   }
   scheduleWrite();
@@ -1327,7 +1331,7 @@ size_t HTTPSession::sendBody(HTTPTransaction* txn,
                                             std::move(body),
                                             HTTPCodec::NoPadding,
                                             includeEOM);
-  CHECK(inLoopCallback_);
+  PRX_CHECK(inLoopCallback_);
   bodyBytesPerWriteBuf_ += bodyLen;
   if (httpSessionActivityTracker_) {
     httpSessionActivityTracker_->addTrackedEgressByteEvent(
@@ -1342,7 +1346,8 @@ size_t HTTPSession::sendBody(HTTPTransaction* txn,
   }
 
   if (includeEOM) {
-    VLOG(5) << *this << " sending EOM in body for streamID=" << txn->getID();
+    PRX_VLOG(5) << *this
+                << " sending EOM in body for streamID=" << txn->getID();
     commonEom(txn, encodedSize, true);
   }
   return encodedSize;
@@ -1366,7 +1371,7 @@ void HTTPSession::onEgressMessageFinished(HTTPTransaction* txn, bool withRST) {
   // If the semantics of the protocol don't permit more messages
   // to be read or sent on this connection, close the socket in one or
   // more directions.
-  CHECK(!transactions_.empty());
+  PRX_CHECK(!transactions_.empty());
 
   if (infoCallback_) {
     infoCallback_->onRequestEnd(*this, txn->getMaxDeferredSize());
@@ -1380,7 +1385,7 @@ void HTTPSession::onEgressMessageFinished(HTTPTransaction* txn, bool withRST) {
   // need not be shutdown on egress finish.
   if (withRST) {
     // Let any queued writes complete, but send a RST when done.
-    VLOG(4) << *this << " resetting egress after this message";
+    PRX_VLOG(4) << *this << " resetting egress after this message";
     resetAfterDrainingWrites_ = true;
     setCloseReason(ConnectionCloseReason::TRANSACTION_ABORT);
     shutdownTransport(true, true);
@@ -1417,7 +1422,7 @@ void HTTPSession::onEgressMessageFinished(HTTPTransaction* txn, bool withRST) {
 }
 
 void HTTPSession::ShutdownTransportCallback::runSessionLoopCallback() noexcept {
-  VLOG(4) << *session_ << " shutdown from onEgressMessageFinished";
+  PRX_VLOG(4) << *session_ << " shutdown from onEgressMessageFinished";
   // Continuation of the above logic.  Writes will be shutdown, reads are
   // forced shutdown in specific cases:
   //  1. There's an ingress error
@@ -1437,7 +1442,7 @@ void HTTPSession::ShutdownTransportCallback::runSessionLoopCallback() noexcept {
   if (session_->isDownstream() && !session_->readsShutdown() &&
       !shutdownReads) {
     auto to = session_->getDrainTimeout();
-    VLOG(4) << "Starting drain timer t=" << to.count();
+    PRX_VLOG(4) << "Starting drain timer t=" << to.count();
     session_->resetTimeoutTo(to);
   }
   auto dg = dg_.release();
@@ -1447,9 +1452,9 @@ void HTTPSession::ShutdownTransportCallback::runSessionLoopCallback() noexcept {
 
 size_t HTTPSession::sendPadding(HTTPTransaction* txn, uint16_t bytes) noexcept {
   auto encodedSize = codec_->generatePadding(writeBuf_, txn->getID(), bytes);
-  VLOG(4) << *this << " sending " << bytes
-          << " bytes of padding, encodedSize=" << encodedSize
-          << " for streamID=" << txn->getID();
+  PRX_VLOG(4) << *this << " sending " << bytes
+              << " bytes of padding, encodedSize=" << encodedSize
+              << " for streamID=" << txn->getID();
   if (encodedSize > 0) {
     scheduleWrite();
   }
@@ -1459,8 +1464,8 @@ size_t HTTPSession::sendPadding(HTTPTransaction* txn, uint16_t bytes) noexcept {
 size_t HTTPSession::sendEOM(HTTPTransaction* txn,
                             const HTTPHeaders* trailers) noexcept {
 
-  VLOG(4) << *this << " sending EOM for streamID=" << txn->getID()
-          << " trailers=" << (trailers ? "yes" : "no");
+  PRX_VLOG(4) << *this << " sending EOM for streamID=" << txn->getID()
+              << " trailers=" << (trailers ? "yes" : "no");
 
   size_t encodedSize = 0;
   if (trailers) {
@@ -1479,7 +1484,7 @@ size_t HTTPSession::sendAbort(HTTPTransaction* txn,
   // Depending on the protocol, this may be a no-op.
   // Schedule a network write to send out whatever egress we might
   // have queued up.
-  VLOG(4) << *this << " sending abort for streamID=" << txn->getID();
+  PRX_VLOG(4) << *this << " sending abort for streamID=" << txn->getID();
   // drain this transaction's writeBuf instead of flushing it
   // then enqueue the abort directly into the Session buffer,
   // hence with max priority.
@@ -1514,12 +1519,12 @@ void HTTPSession::decrementTransactionCount(HTTPTransaction* txn,
   if ((isUpstream() && !txn->isPushed()) ||
       (isDownstream() && txn->isPushed())) {
     if (ingressEOM && txn->testAndClearIsCountedTowardsStreamLimit()) {
-      DCHECK_NE(outgoingStreams_, 0);
+      PRX_DCHECK_NE(outgoingStreams_, 0u);
       outgoingStreams_--;
     }
   } else {
     if (egressEOM && txn->testAndClearIsCountedTowardsStreamLimit()) {
-      DCHECK_NE(incomingStreams_, 0);
+      PRX_DCHECK_NE(incomingStreams_, 0u);
       incomingStreams_--;
     }
   }
@@ -1538,13 +1543,13 @@ bool HTTPSession::maybeResumePausedPipelinedTransaction(size_t oldStreamCount,
       // For H1, StreamID = txnSeqn + 1
       auto curStreamId = txnSeqn + 1;
       auto txnIt = transactions_.find(curStreamId + 1);
-      CHECK(txnIt != transactions_.end());
-      DCHECK(transactionIds_.contains(curStreamId + 1));
+      PRX_CHECK(txnIt != transactions_.end());
+      PRX_DCHECK(transactionIds_.contains(curStreamId + 1));
       auto& nextTxn = txnIt->second;
-      DCHECK_EQ(nextTxn.getSequenceNumber(), txnSeqn + 1);
-      DCHECK(!nextTxn.isIngressComplete());
-      DCHECK(nextTxn.isIngressPaused());
-      VLOG(4) << "Resuming paused pipelined txn " << nextTxn;
+      PRX_DCHECK_EQ(nextTxn.getSequenceNumber(), txnSeqn + 1);
+      PRX_DCHECK(!nextTxn.isIngressComplete());
+      PRX_DCHECK(nextTxn.isIngressPaused());
+      PRX_VLOG(4) << "Resuming paused pipelined txn " << nextTxn;
       nextTxn.resumeIngress();
     }
     return true;
@@ -1557,19 +1562,19 @@ void HTTPSession::detach(HTTPTransaction* txn) noexcept {
   HTTPCodec::StreamID streamID = txn->getID();
   auto txnSeqn = txn->getSequenceNumber();
   auto it = transactions_.find(txn->getID());
-  DCHECK(it != transactions_.end());
-  DCHECK(transactionIds_.contains(txn->getID()));
+  PRX_DCHECK(it != transactions_.end());
+  PRX_DCHECK(transactionIds_.contains(txn->getID()));
 
   if (txn->isIngressPaused()) {
     // Someone detached a transaction that was paused.  Make the resumeIngress
     // call to keep liveTransactions_ in order
-    VLOG(4) << *this << " detached paused transaction=" << streamID;
+    PRX_VLOG(4) << *this << " detached paused transaction=" << streamID;
     resumeIngress(txn);
   }
 
-  VLOG(4) << *this << " removing streamID=" << streamID
-          << ", liveTransactions was " << liveTransactions_;
-  CHECK_GT(liveTransactions_, 0);
+  PRX_VLOG(4) << *this << " removing streamID=" << streamID
+              << ", liveTransactions was " << liveTransactions_;
+  PRX_CHECK_GT(liveTransactions_, 0u);
   liveTransactions_--;
 
   if (txn->isPushed()) {
@@ -1587,7 +1592,7 @@ void HTTPSession::detach(HTTPTransaction* txn) noexcept {
   if (lastTxn_ == txn) {
     lastTxn_ = nullptr;
   }
-  DCHECK(transactionIds_.contains(it->first));
+  PRX_DCHECK(transactionIds_.contains(it->first));
   transactionIds_.erase(it->first);
   transactions_.erase(it);
 
@@ -1769,8 +1774,8 @@ unique_ptr<IOBuf> HTTPSession::getNextToSend(bool* cork,
   // limit ourselves to one outstanding write at a time (onWriteSuccess calls
   // scheduleWrite)
   if (numActiveWrites_ > 0 || writesShutdown()) {
-    VLOG(4) << "skipping write during this loop, numActiveWrites_="
-            << numActiveWrites_ << " writesShutdown()=" << writesShutdown();
+    PRX_VLOG(4) << "skipping write during this loop, numActiveWrites_="
+                << numActiveWrites_ << " writesShutdown()=" << writesShutdown();
     return nullptr;
   }
 
@@ -1780,14 +1785,15 @@ unique_ptr<IOBuf> HTTPSession::getNextToSend(bool* cork,
     uint32_t toSend = kWriteReadyMax;
     if (connFlowControl_) {
       if (connFlowControl_->getAvailableSend() == 0) {
-        VLOG(4) << "Session-level send window is full, skipping remaining "
-                << "body writes this loop";
+        PRX_VLOG(4) << "Session-level send window is full, skipping remaining "
+                    << "body writes this loop";
         break;
       }
       toSend = std::min(toSend, connFlowControl_->getAvailableSend());
     }
     txnEgressQueue_.nextEgress(nextEgressResults_);
-    CHECK(!nextEgressResults_.empty()); // Queue was non empty, so this must be
+    PRX_CHECK(!nextEgressResults_.empty()); // Queue was non empty, so this must
+                                            // be
     // The maximum we will send for any transaction in this loop
     uint32_t txnMaxToSend = toSend * nextEgressResults_.front().second;
     if (txnMaxToSend == 0) {
@@ -1807,19 +1813,19 @@ unique_ptr<IOBuf> HTTPSession::getNextToSend(bool* cork,
     for (auto txnPair : nextEgressResults_) {
       uint32_t txnAllowed = txnPair.second * toSend;
       if (nextEgressResults_.size() > 1) {
-        CHECK_LE(txnAllowed, egressBodySizeLimit_);
+        PRX_CHECK_LE(txnAllowed, egressBodySizeLimit_);
       }
       if (connFlowControl_) {
-        CHECK_LE(txnAllowed, connFlowControl_->getAvailableSend());
+        PRX_CHECK_LE(txnAllowed, connFlowControl_->getAvailableSend());
       }
       if (txnAllowed == 0) {
         // The ratio * toSend was so small this txn gets nothing.
-        VLOG(4) << *this << " breaking egress loop on 0 txnAllowed";
+        PRX_VLOG(4) << *this << " breaking egress loop on 0 txnAllowed";
         break;
       }
 
-      VLOG(4) << *this << " egressing txnID=" << txnPair.first->getID()
-              << " allowed=" << txnAllowed;
+      PRX_VLOG(4) << *this << " egressing txnID=" << txnPair.first->getID()
+                  << " allowed=" << txnAllowed;
       txnPair.first->onWriteReady(txnAllowed, txnPair.second);
     }
     nextEgressResults_.clear();
@@ -1835,14 +1841,14 @@ unique_ptr<IOBuf> HTTPSession::getNextToSend(bool* cork,
     uint64_t needed = byteEventTracker_->preSend(
         cork, timestampTx, timestampAck, bytesWritten_);
     if (needed > 0) {
-      VLOG(5) << *this
-              << " writeBuf_.chainLength(): " << writeBuf_.chainLength()
-              << " txnEgressQueue_.empty(): " << txnEgressQueue_.empty();
+      PRX_VLOG(5) << *this
+                  << " writeBuf_.chainLength(): " << writeBuf_.chainLength()
+                  << " txnEgressQueue_.empty(): " << txnEgressQueue_.empty();
 
       if (needed < writeBuf_.chainLength()) {
         // split the next SOM / EOM chunk
-        VLOG(5) << *this << " splitting " << needed << " bytes out of a "
-                << writeBuf_.chainLength() << " bytes IOBuf";
+        PRX_VLOG(5) << *this << " splitting " << needed << " bytes out of a "
+                    << writeBuf_.chainLength() << " bytes IOBuf";
         *cork = true;
         if (sessionStats_) {
           sessionStats_->recordPresendIOSplit();
@@ -1850,7 +1856,7 @@ unique_ptr<IOBuf> HTTPSession::getNextToSend(bool* cork,
         writeBufSplit_ = true;
         return writeBuf_.split(needed);
       } else {
-        CHECK_EQ(needed, writeBuf_.chainLength());
+        PRX_CHECK_EQ(needed, writeBuf_.chainLength());
       }
     }
   }
@@ -1873,7 +1879,7 @@ void HTTPSession::runSessionLoopCallback() noexcept {
     updatePendingWrites();
     checkForShutdown();
   });
-  VLOG(5) << *this << " in loop callback";
+  PRX_VLOG(5) << *this << " in loop callback";
 
   if (isDownstream() && !txnEgressQueue_.empty()) {
     const auto event =
@@ -1901,9 +1907,9 @@ void HTTPSession::runSessionLoopCallback() noexcept {
       break;
     }
     uint64_t len = writeBuf->computeChainDataLength();
-    VLOG(11) << *this << " bytes of egress to be written: " << len
-             << " cork:" << cork << " timestampTx:" << timestampTx
-             << " timestampAck:" << timestampAck;
+    PRX_VLOG(11) << *this << " bytes of egress to be written: " << len
+                 << " cork:" << cork << " timestampTx:" << timestampTx
+                 << " timestampAck:" << timestampAck;
     if (len == 0) {
       checkForShutdown();
       return;
@@ -1914,7 +1920,7 @@ void HTTPSession::runSessionLoopCallback() noexcept {
     flags |= (timestampTx) ? folly::WriteFlags::TIMESTAMP_TX
                            : folly::WriteFlags::NONE;
     flags |= (timestampAck) ? folly::WriteFlags::EOR : folly::WriteFlags::NONE;
-    CHECK(!pendingWrite_.hasValue());
+    PRX_CHECK(!pendingWrite_.hasValue());
     pendingWrite_.emplace(len, DestructorGuard(this));
 
     if (!writeTimeout_.isScheduled()) {
@@ -1922,10 +1928,10 @@ void HTTPSession::runSessionLoopCallback() noexcept {
       wheelTimer_.scheduleTimeout(&writeTimeout_);
     }
     numActiveWrites_++;
-    VLOG(4) << *this << " writing " << len
-            << ", activeWrites=" << numActiveWrites_ << " cork:" << cork
-            << " timestampTx:" << timestampTx
-            << " timestampAck:" << timestampAck;
+    PRX_VLOG(4) << *this << " writing " << len
+                << ", activeWrites=" << numActiveWrites_ << " cork:" << cork
+                << " timestampTx:" << timestampTx
+                << " timestampAck:" << timestampAck;
     bytesScheduled_ += len;
     sock_->writeChain(this, std::move(writeBuf), flags);
     if (numActiveWrites_ > 0) {
@@ -1964,7 +1970,7 @@ void HTTPSession::scheduleWrite() {
   // as well as saving a few system calls.
   if (!isLoopCallbackScheduled() &&
       (writeBuf_.front() || !txnEgressQueue_.empty())) {
-    VLOG(5) << *this << " scheduling write callback";
+    PRX_VLOG(5) << *this << " scheduling write callback";
     scheduleInLoop(sock_->getEventBase());
   }
 }
@@ -1972,11 +1978,11 @@ void HTTPSession::scheduleWrite() {
 void HTTPSession::updateWriteCount() {
   if (numActiveWrites_ > 0 && writesUnpaused()) {
     // Exceeded limit. Pause reading on the incoming stream.
-    VLOG(3) << "Pausing egress for " << *this;
+    PRX_VLOG(3) << "Pausing egress for " << *this;
     writes_ = SocketState::PAUSED;
   } else if (numActiveWrites_ == 0 && writesPaused()) {
     // Dropped below limit. Resume reading on the incoming stream if needed.
-    VLOG(3) << "Resuming egress for " << *this;
+    PRX_VLOG(3) << "Resuming egress for " << *this;
     writes_ = SocketState::UNPAUSED;
   }
 }
@@ -1990,9 +1996,10 @@ void HTTPSession::shutdownTransport(bool shutdownReads,
   // shutdowns not accounted for, shouldn't see any
   setCloseReason(ConnectionCloseReason::UNKNOWN);
 
-  VLOG(4) << "shutdown request for " << *this << ": reads=" << shutdownReads
-          << " (currently " << readsShutdown() << "), writes=" << shutdownWrites
-          << " (currently " << writesShutdown() << ")";
+  PRX_VLOG(4) << "shutdown request for " << *this << ": reads=" << shutdownReads
+              << " (currently " << readsShutdown()
+              << "), writes=" << shutdownWrites << " (currently "
+              << writesShutdown() << ")";
 
   bool notifyEgressShutdown = false;
   bool notifyIngressShutdown = false;
@@ -2000,8 +2007,8 @@ void HTTPSession::shutdownTransport(bool shutdownReads,
   if (!transportInfo_.sslError.empty()) {
     error = kErrorSSL;
   } else if (sock_->error()) {
-    VLOG(3) << "shutdown request for " << *this
-            << " on bad socket. Shutting down writes too.";
+    PRX_VLOG(3) << "shutdown request for " << *this
+                << " on bad socket. Shutting down writes too.";
     if (getConnectionCloseReason() == ConnectionCloseReason::IO_WRITE_ERROR) {
       error = kErrorWrite;
     } else {
@@ -2015,9 +2022,9 @@ void HTTPSession::shutdownTransport(bool shutdownReads,
   if (shutdownReads && !shutdownWrites && flowControlTimeout_.isScheduled()) {
     // reads are dead and writes are blocked on a window update that will never
     // come.  shutdown writes too.
-    VLOG(4) << *this
-            << " Converting read shutdown to read/write due to"
-               " flow control";
+    PRX_VLOG(4) << *this
+                << " Converting read shutdown to read/write due to"
+                   " flow control";
     shutdownWrites = true;
   }
 
@@ -2033,11 +2040,11 @@ void HTTPSession::shutdownTransport(bool shutdownReads,
         byteEventTracker_->drainByteEvents();
       }
       if (resetAfterDrainingWrites_) {
-        VLOG(4) << *this << " writes drained, sending RST";
+        PRX_VLOG(4) << *this << " writes drained, sending RST";
         resetSocketOnShutdown_ = true;
         shutdownReads = true;
       } else {
-        VLOG(4) << *this << " writes drained, closing";
+        PRX_VLOG(4) << *this << " writes drained, closing";
         if (isUpstream() || !codec_->supportsParallelRequests()) {
           sock_->shutdownWriteNow();
         }
@@ -2097,7 +2104,7 @@ void HTTPSession::shutdownTransport(bool shutdownReads,
 void HTTPSession::shutdownTransportWithReset(ProxygenError errorCode,
                                              const std::string& errorMsg) {
   DestructorGuard guard(this);
-  VLOG(4) << "shutdownTransportWithReset";
+  PRX_VLOG(4) << "shutdownTransportWithReset";
 
   if (!readsShutdown()) {
     shutdownRead();
@@ -2109,7 +2116,7 @@ void HTTPSession::shutdownTransportWithReset(ProxygenError errorCode,
     if (pendingWrite_.hasValue()) {
       numActiveWrites_--;
     }
-    VLOG(4) << *this << " cancel write timer";
+    PRX_VLOG(4) << *this << " cancel write timer";
     writeTimeout_.cancelTimeout();
     resetSocketOnShutdown_ = true;
   }
@@ -2139,7 +2146,7 @@ void HTTPSession::shutdownTransportWithReset(ProxygenError errorCode,
 }
 
 void HTTPSession::shutdownRead() {
-  VLOG(10) << *this << " shutting down reads";
+  PRX_VLOG(10) << *this << " shutting down reads";
   sock_->setReadCB(nullptr);
   reads_ = SocketState::SHUTDOWN;
   // disable socket timestamp events as we're shutting down reads
@@ -2147,23 +2154,23 @@ void HTTPSession::shutdownRead() {
   if (byteEventTracker_) {
     const auto numEventDrained =
         byteEventTracker_->disableSocketTimestampEvents();
-    VLOG(10) << *this << " drained " << numEventDrained
-             << " pending socket timestamp events when shutting down reads";
+    PRX_VLOG(10) << *this << " drained " << numEventDrained
+                 << " pending socket timestamp events when shutting down reads";
   }
 }
 
 void HTTPSession::checkForShutdown() {
-  VLOG(10) << *this
-           << " checking for shutdown, readShutdown=" << readsShutdown()
-           << ", writesShutdown=" << writesShutdown()
-           << ", transaction set empty=" << transactions_.empty();
+  PRX_VLOG(10) << *this
+               << " checking for shutdown, readShutdown=" << readsShutdown()
+               << ", writesShutdown=" << writesShutdown()
+               << ", transaction set empty=" << transactions_.empty();
 
   // Two conditions are required to destroy the HTTPSession:
   //   * All writes have been finished.
   //   * There are no transactions remaining on the session.
   if (writesShutdown() && transactions_.empty() && !isLoopCallbackScheduled() &&
       (isUpstream() || readsShutdown())) {
-    VLOG(4) << "destroying " << *this;
+    PRX_VLOG(4) << "destroying " << *this;
     shutdownRead();
     auto asyncSocket = sock_->getUnderlyingTransport<folly::AsyncSocket>();
     if (asyncSocket) {
@@ -2180,7 +2187,7 @@ void HTTPSession::checkForShutdown() {
 
 void HTTPSession::drain() {
   if (!draining_) {
-    VLOG(4) << *this << " draining";
+    PRX_VLOG(4) << *this << " draining";
     draining_ = true;
     setCloseReason(ConnectionCloseReason::SHUTDOWN);
 
@@ -2190,11 +2197,11 @@ void HTTPSession::drain() {
     if (transactions_.empty() && isUpstream()) {
       // We don't do this for downstream since we need to wait for
       // inflight requests to arrive
-      VLOG(4) << *this << " shutdown from drain";
+      PRX_VLOG(4) << *this << " shutdown from drain";
       shutdownTransport(true, true);
     }
   } else {
-    VLOG(4) << *this << " already draining";
+    PRX_VLOG(4) << *this << " already draining";
   }
 }
 
@@ -2212,7 +2219,7 @@ void HTTPSession::drainImpl() {
       wheelTimer_.scheduleTimeout(&drainTimeout_, getDrainTimeout());
     } else if (transactions_.empty() && isDownstream() && !readsShutdown()) {
       // Codec is not reusable, but we need to wait for peer FIN
-      VLOG(4) << "Starting drain timer sess=" << *this;
+      PRX_VLOG(4) << "Starting drain timer sess=" << *this;
       resetTimeoutTo(getDrainTimeout());
     } // else
     //   1. there's an txn - FIN timeout set from
@@ -2272,7 +2279,7 @@ void HTTPSession::PingProber::startProbes() {
 
 void HTTPSession::PingProber::cancelProbes() {
   if (pingVal_) {
-    VLOG(4) << "Canceling active probe sess=" << session_;
+    PRX_VLOG(4) << "Canceling active probe sess=" << session_;
     pingVal_.reset();
   }
   cancelTimeout();
@@ -2280,22 +2287,23 @@ void HTTPSession::PingProber::cancelProbes() {
 
 void HTTPSession::PingProber::refreshTimeout(bool onIngress) {
   if (!pingVal_ && (!onIngress || extendIntervalOnIngress_)) {
-    VLOG(4) << "Scheduling next ping probe for sess=" << session_;
+    PRX_VLOG(4) << "Scheduling next ping probe for sess=" << session_;
     session_.getEventBase()->timer().scheduleTimeout(this, interval_);
   }
 }
 
 void HTTPSession::PingProber::timeoutExpired() noexcept {
   if (pingVal_) {
-    VLOG(3) << "Ping probe timed out, dropping connection sess=" << session_;
+    PRX_VLOG(3) << "Ping probe timed out, dropping connection sess="
+                << session_;
     if (auto sessionStats = session_.sessionStats_) {
       sessionStats->recordSessionPeriodicPingProbeTimeout();
     }
     session_.dropConnection("Ping probe timed out");
   } else {
     pingVal_ = folly::Random::rand64();
-    VLOG(4) << "Sending ping probe with value=" << *pingVal_
-            << " sess=" << session_;
+    PRX_VLOG(4) << "Sending ping probe with value=" << *pingVal_
+                << " sess=" << session_;
     session_.sendPing(*pingVal_);
     session_.getEventBase()->timer().scheduleTimeout(this, timeout_);
   }
@@ -2304,12 +2312,12 @@ void HTTPSession::PingProber::timeoutExpired() noexcept {
 void HTTPSession::PingProber::onPingReply(uint64_t pingVal) {
   if (!pingVal_ || *pingVal_ != pingVal) {
     // This can happen if someone calls sendPing() manually
-    VLOG(3) << "Received unexpected PING reply=" << pingVal << " expecting="
-            << ((pingVal_) ? folly::to<std::string>(*pingVal_)
-                           : std::string("none"));
+    PRX_VLOG(3) << "Received unexpected PING reply=" << pingVal << " expecting="
+                << ((pingVal_) ? folly::to<std::string>(*pingVal_)
+                               : std::string("none"));
     return;
   }
-  VLOG(4) << "Received expected ping, rescheduling";
+  PRX_VLOG(4) << "Received expected ping, rescheduling";
   pingVal_.reset();
   refreshTimeout(/*onIngress=*/false);
 }
@@ -2320,10 +2328,10 @@ HTTPTransaction* HTTPSession::findTransaction(HTTPCodec::StreamID streamID) {
   }
   auto it = transactions_.find(streamID);
   if (it == transactions_.end()) {
-    DCHECK(!transactionIds_.contains(streamID));
+    PRX_DCHECK(!transactionIds_.contains(streamID));
     return nullptr;
   } else {
-    DCHECK(transactionIds_.contains(streamID));
+    PRX_DCHECK(transactionIds_.contains(streamID));
     lastTxn_ = &it->second;
     return lastTxn_;
   }
@@ -2377,8 +2385,8 @@ HTTPTransaction* HTTPSession::createTransaction(
                             assocStreamID,
                             setIngressTimeoutAfterEom_));
 
-  CHECK(matchPair.second) << "Emplacement failed, despite earlier "
-                             "existence check.";
+  PRX_CHECK(matchPair.second) << "Emplacement failed, despite earlier "
+                                 "existence check.";
   transactionIds_.emplace(streamID);
 
   HTTPTransaction* txn = &matchPair.first->second;
@@ -2390,8 +2398,8 @@ HTTPTransaction* HTTPSession::createTransaction(
     }
   }
 
-  VLOG(5) << *this << " adding streamID=" << txn->getID()
-          << ", liveTransactions_ was " << liveTransactions_;
+  PRX_VLOG(5) << *this << " adding streamID=" << txn->getID()
+              << ", liveTransactions_ was " << liveTransactions_;
 
   ++liveTransactions_;
   incrementSeqNo();
@@ -2413,26 +2421,26 @@ HTTPTransaction* HTTPSession::createTransaction(
 }
 
 void HTTPSession::incrementOutgoingStreams(HTTPTransaction* txn) {
-  DCHECK(txn);
+  PRX_DCHECK(txn);
   outgoingStreams_++;
   txn->setIsCountedTowardsStreamLimit();
   HTTPSessionBase::onNewOutgoingStream(outgoingStreams_);
 }
 
 void HTTPSession::incrementIncomingStreams(HTTPTransaction* txn) {
-  DCHECK(txn);
+  PRX_DCHECK(txn);
   incomingStreams_++;
   txn->setIsCountedTowardsStreamLimit();
 }
 
 void HTTPSession::writeSuccess() noexcept {
-  CHECK(pendingWrite_.hasValue());
+  PRX_CHECK(pendingWrite_.hasValue());
   DestructorGuard dg(this);
   auto bytesWritten = pendingWrite_->first;
   bytesWritten_ += bytesWritten;
   transportInfo_.totalBytes += bytesWritten;
-  CHECK(writeTimeout_.isScheduled());
-  VLOG(10) << "Cancel write timer on last successful write";
+  PRX_CHECK(writeTimeout_.isScheduled());
+  PRX_VLOG(10) << "Cancel write timer on last successful write";
   writeTimeout_.cancelTimeout();
   pendingWrite_.reset();
 
@@ -2440,7 +2448,7 @@ void HTTPSession::writeSuccess() noexcept {
     infoCallback_->onWrite(*this, bytesWritten);
   }
 
-  VLOG(5) << "total bytesWritten_: " << bytesWritten_;
+  PRX_VLOG(5) << "total bytesWritten_: " << bytesWritten_;
 
   // processByteEvents will return true if it has been replaced with another
   // tracker in the middle and needs to be re-run.  Should happen at most
@@ -2455,7 +2463,7 @@ void HTTPSession::writeSuccess() noexcept {
       // someone calls shutdownTransport, but did not specify a reason before.
       setCloseReason(ConnectionCloseReason::UNKNOWN);
     }
-    VLOG(4) << *this << " shutdown from onWriteSuccess";
+    PRX_VLOG(4) << *this << " shutdown from onWriteSuccess";
     // downstream needs to listen for fin to shutdown reads
     shutdownTransport(isUpstream(), true);
   }
@@ -2475,18 +2483,19 @@ void HTTPSession::writeSuccess() noexcept {
   onWriteCompleted();
 
   if (egressBytesLimit_ > 0 && bytesWritten_ >= egressBytesLimit_) {
-    VLOG(4) << "Egress limit reached, shutting down "
-               "session (egressed "
-            << bytesWritten_ << ", limit set to " << egressBytesLimit_ << ")";
+    PRX_VLOG(4) << "Egress limit reached, shutting down "
+                   "session (egressed "
+                << bytesWritten_ << ", limit set to " << egressBytesLimit_
+                << ")";
     shutdownTransport(true, true);
   }
 }
 
 void HTTPSession::writeErr(size_t bytesWritten,
                            const AsyncSocketException& ex) noexcept {
-  VLOG(4) << *this << " write error: " << ex.what();
+  PRX_VLOG(4) << *this << " write error: " << ex.what();
   DestructorGuard dg(this);
-  DCHECK(pendingWrite_.hasValue());
+  PRX_DCHECK(pendingWrite_.hasValue());
   pendingWrite_.reset();
   if (infoCallback_) {
     infoCallback_->onWrite(*this, bytesWritten);
@@ -2521,7 +2530,7 @@ void HTTPSession::onWriteCompleted() {
 }
 
 void HTTPSession::onSessionParseError(const HTTPException& error) {
-  VLOG(4) << *this << " session layer parse error. Terminate the session.";
+  PRX_VLOG(4) << *this << " session layer parse error. Terminate the session.";
   if (error.hasCodecStatusCode()) {
     std::unique_ptr<folly::IOBuf> errorMsg =
         folly::IOBuf::copyBuffer(error.what());
@@ -2545,7 +2554,7 @@ void HTTPSession::onSessionParseError(const HTTPException& error) {
 
 void HTTPSession::onNewTransactionParseError(HTTPCodec::StreamID streamID,
                                              const HTTPException& error) {
-  VLOG(4) << *this << " parse error with new transaction";
+  PRX_VLOG(4) << *this << " parse error with new transaction";
   if (error.hasCodecStatusCode()) {
     codec_->generateRstStream(writeBuf_, streamID, error.getCodecStatusCode());
     scheduleWrite();
@@ -2569,7 +2578,7 @@ void HTTPSession::pauseReads() {
 }
 
 void HTTPSession::pauseReadsImpl() {
-  VLOG(4) << *this << ": pausing reads";
+  PRX_VLOG(4) << *this << ": pausing reads";
   if (infoCallback_) {
     infoCallback_->onIngressPaused(*this);
   }
@@ -2587,7 +2596,7 @@ void HTTPSession::resumeReads() {
 }
 
 void HTTPSession::resumeReadsImpl() {
-  VLOG(4) << *this << ": resuming reads";
+  PRX_VLOG(4) << *this << ": resuming reads";
   resetTimeout();
   reads_ = SocketState::UNPAUSED;
   codec_->setParserPaused(false);
@@ -2597,9 +2606,10 @@ void HTTPSession::resumeReadsImpl() {
 }
 
 bool HTTPSession::hasMoreWrites() const {
-  VLOG(10) << __PRETTY_FUNCTION__ << " numActiveWrites_: " << numActiveWrites_
-           << " pendingWrite_.hasValue(): " << pendingWrite_.hasValue()
-           << " txnEgressQueue_.empty(): " << txnEgressQueue_.empty();
+  PRX_VLOG(10) << __PRETTY_FUNCTION__
+               << " numActiveWrites_: " << numActiveWrites_
+               << " pendingWrite_.hasValue(): " << pendingWrite_.hasValue()
+               << " txnEgressQueue_.empty(): " << txnEgressQueue_.empty();
 
   return (numActiveWrites_ != 0) || pendingWrite_.hasValue() ||
          writeBuf_.front() || !txnEgressQueue_.empty();
@@ -2649,12 +2659,12 @@ void HTTPSession::onConnectionSendWindowOpen() {
 
 void HTTPSession::onConnectionSendWindowClosed() {
   if (!txnEgressQueue_.empty()) {
-    VLOG(4) << *this << " session stalled by flow control";
+    PRX_VLOG(4) << *this << " session stalled by flow control";
     if (sessionStats_) {
       sessionStats_->recordSessionStalled();
     }
   }
-  DCHECK(!flowControlTimeout_.isScheduled());
+  PRX_DCHECK(!flowControlTimeout_.isScheduled());
   if (infoCallback_) {
     infoCallback_->onFlowControlWindowClosed(*this);
   }
@@ -2668,7 +2678,7 @@ void HTTPSession::onConnectionSendWindowClosed() {
 
 void HTTPSession::invalidStream(HTTPCodec::StreamID stream, ErrorCode code) {
   if (!codec_->supportsParallelRequests()) {
-    LOG(ERROR) << "Invalid stream on non-parallel codec.";
+    PRX_LOG(ERROR) << "Invalid stream on non-parallel codec.";
     return;
   }
 
@@ -2705,7 +2715,7 @@ void HTTPSession::onEgressBufferCleared() {
 }
 
 void HTTPSession::onReplaySafe() noexcept {
-  CHECK(sock_);
+  PRX_CHECK(sock_);
   sock_->setReplaySafetyCallback(nullptr);
 
   if (infoCallback_) {
@@ -2776,10 +2786,10 @@ bool HTTPSession::tryWtSession(HTTPTransaction& txn,
   const bool upgraded = txn.isWebTransportConnectStream() &&
                         (msg.isRequest() || msg.is2xxResponse());
   const bool makeWtSession = !eom && upgraded && wtCtx.hasWtHandler();
-  VLOG(6) << "eom=" << eom << "; upgraded=" << upgraded
-          << "; wtConnect=" << txn.isWebTransportConnectStream()
-          << "; supportsWebTransport=" << supportsWebTransport()
-          << "; wtHandler=" << wtCtx.hasWtHandler();
+  PRX_VLOG(6) << "eom=" << eom << "; upgraded=" << upgraded
+              << "; wtConnect=" << txn.isWebTransportConnectStream()
+              << "; supportsWebTransport=" << supportsWebTransport()
+              << "; wtHandler=" << wtCtx.hasWtHandler();
   if (!makeWtSession) {
     return false;
   }
diff --git a/proxygen/lib/http/session/HTTPSessionAcceptor.cpp b/proxygen/lib/http/session/HTTPSessionAcceptor.cpp
index e1e5dc6d65..3c8ea8af7b 100644
--- a/proxygen/lib/http/session/HTTPSessionAcceptor.cpp
+++ b/proxygen/lib/http/session/HTTPSessionAcceptor.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HTTPSessionAcceptor.h>
 
 #include <proxygen/lib/http/session/HTTPDefaultSessionCodecFactory.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::SocketAddress;
 using std::string;
@@ -55,7 +56,7 @@ void HTTPSessionAcceptor::onNewConnection(folly::AsyncTransport::UniquePtr sock,
       !sock->getSecurityProtocol().empty());
 
   if (!codec) {
-    VLOG(2) << "codecFactory_ failed to provide codec";
+    PRX_VLOG(2) << "codecFactory_ failed to provide codec";
     onSessionCreationError(ProxygenError::kErrorUnsupportedScheme);
     return;
   }
@@ -69,7 +70,7 @@ void HTTPSessionAcceptor::onNewConnection(folly::AsyncTransport::UniquePtr sock,
   try {
     sock->getLocalAddress(&localAddress);
   } catch (...) {
-    VLOG(3) << "couldn't get local address for socket";
+    PRX_VLOG(3) << "couldn't get local address for socket";
     localAddress = unknownSocketAddress_;
   }
 
@@ -80,12 +81,12 @@ void HTTPSessionAcceptor::onNewConnection(folly::AsyncTransport::UniquePtr sock,
     } else {
       localAddress = unknownSocketAddress_;
     }
-    VLOG(4) << "set localAddress=" << localAddress.describe();
+    PRX_VLOG(4) << "set localAddress=" << localAddress.describe();
   }
 
   auto sessionInfoCb = sessionInfoCb_ ? sessionInfoCb_ : this;
-  VLOG(4) << "Created new " << nextProtocol << " session for peer "
-          << *peerAddress;
+  PRX_VLOG(4) << "Created new " << nextProtocol << " session for peer "
+              << *peerAddress;
   auto codecProtocol = codec->getProtocol();
   auto* session = new HTTPDownstreamSession(getTransactionTimeoutSet(),
                                             std::move(sock),
@@ -124,7 +125,7 @@ void HTTPSessionAcceptor::onNewConnection(folly::AsyncTransport::UniquePtr sock,
 
 size_t HTTPSessionAcceptor::dropIdleConnections(size_t num) {
   // release in batch for more efficiency
-  VLOG(6) << "attempt to drop downstream idle connections";
+  PRX_VLOG(6) << "attempt to drop downstream idle connections";
   return downstreamConnectionManager_->dropIdleConnections(num);
 }
 
diff --git a/proxygen/lib/http/session/HTTPSessionBase.cpp b/proxygen/lib/http/session/HTTPSessionBase.cpp
index 0bfe37f4f2..9268f9a5e8 100644
--- a/proxygen/lib/http/session/HTTPSessionBase.cpp
+++ b/proxygen/lib/http/session/HTTPSessionBase.cpp
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/session/HTTPSessionController.h>
 #include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
 #include <proxygen/lib/http/webtransport/WebTransportSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::SocketAddress;
 using wangle::TransportInfo;
@@ -106,8 +107,8 @@ bool HTTPSessionBase::onBodyImpl(std::unique_ptr<folly::IOBuf> chain,
                                  HTTPTransaction* txn) {
   DestructorGuard dg(this);
   auto oldSize = pendingReadSize_;
-  CHECK_LE(pendingReadSize_,
-           std::numeric_limits<uint32_t>::max() - length - padding);
+  PRX_CHECK_LE(pendingReadSize_,
+               std::numeric_limits<uint32_t>::max() - length - padding);
   pendingReadSize_ += length + padding;
   if (httpSessionActivityTracker_) {
     httpSessionActivityTracker_->onIngressBody(length + padding);
@@ -119,8 +120,8 @@ bool HTTPSessionBase::onBodyImpl(std::unique_ptr<folly::IOBuf> chain,
   if (oldSize < pendingReadSize_) {
     // Transaction must have buffered something and not called
     // notifyBodyProcessed() on it.
-    VLOG(4) << *this << " Enqueued ingress. Ingress buffer uses "
-            << pendingReadSize_ << " of " << readBufLimit_ << " bytes.";
+    PRX_VLOG(4) << *this << " Enqueued ingress. Ingress buffer uses "
+                << pendingReadSize_ << " of " << readBufLimit_ << " bytes.";
     if (ingressLimitExceeded() && oldSize <= readBufLimit_) {
       if (infoCallback_) {
         infoCallback_->onIngressLimitExceeded(*this);
@@ -132,16 +133,16 @@ bool HTTPSessionBase::onBodyImpl(std::unique_ptr<folly::IOBuf> chain,
 }
 
 bool HTTPSessionBase::notifyBodyProcessed(uint32_t bytes) {
-  CHECK_GE(pendingReadSize_, bytes);
+  PRX_CHECK_GE(pendingReadSize_, bytes);
   auto oldSize = pendingReadSize_;
   pendingReadSize_ -= bytes;
   if (sessionStats_) {
     sessionStats_->recordPendingBufferedReadBytes(-1 * (int64_t)bytes);
   }
 
-  VLOG(4) << *this << " Dequeued " << bytes << " bytes of ingress. "
-          << "Ingress buffer uses " << pendingReadSize_ << " of "
-          << readBufLimit_ << " bytes.";
+  PRX_VLOG(4) << *this << " Dequeued " << bytes << " bytes of ingress. "
+              << "Ingress buffer uses " << pendingReadSize_ << " of "
+              << readBufLimit_ << " bytes.";
   if (oldSize > readBufLimit_ && pendingReadSize_ <= readBufLimit_) {
     return true;
   }
@@ -150,7 +151,7 @@ bool HTTPSessionBase::notifyBodyProcessed(uint32_t bytes) {
 
 bool HTTPSessionBase::notifyEgressBodyBuffered(int64_t bytes, bool update) {
   pendingWriteSizeDelta_ += bytes;
-  VLOG(4) << __func__ << " pwsd=" << pendingWriteSizeDelta_;
+  PRX_VLOG(4) << __func__ << " pwsd=" << pendingWriteSizeDelta_;
   // any net change requires us to update pause/resume state in the
   // loop callback
   if (pendingWriteSizeDelta_ >= 0 && update) {
@@ -166,7 +167,7 @@ void HTTPSessionBase::updateWriteBufSize(int64_t delta) {
   // the sock_'s write buffer.
   delta += pendingWriteSizeDelta_;
   pendingWriteSizeDelta_ = 0;
-  DCHECK(delta >= 0 || uint64_t(-delta) <= pendingWriteSize_);
+  PRX_DCHECK(delta >= 0 || uint64_t(-delta) <= pendingWriteSize_);
   if (sessionStats_) {
     sessionStats_->recordPendingBufferedWriteBytes(delta);
   }
@@ -181,8 +182,8 @@ void HTTPSessionBase::updatePendingWrites() {
 
 void HTTPSessionBase::handleErrorDirectly(HTTPTransaction* txn,
                                           const HTTPException& error) {
-  VLOG(4) << *this << " creating direct error handler";
-  DCHECK(txn);
+  PRX_VLOG(4) << *this << " creating direct error handler";
+  PRX_DCHECK(txn);
   auto handler = getParseErrorHandler(txn, error);
   if (!handler) {
     txn->sendAbort();
@@ -260,12 +261,12 @@ using WtReqResult = std::unique_ptr<HTTPMessage>;
 folly::SemiFuture<std::unique_ptr<HTTPMessage>>
 HTTPSessionBase::sendWebTransportRequest(
     const HTTPMessage& req, WebTransportHandler::Ptr wtHandler) noexcept {
-  CHECK(isUpstream(codec_->getTransportDirection()));
+  PRX_CHECK(isUpstream(codec_->getTransportDirection()));
   bool supportsWt = supportsWebTransport();
   bool validWtReq = HTTPWebTransport::isConnectMessage(req);
   if (!(supportsWt && validWtReq)) {
     auto err = !validWtReq ? kInvalidWtReq : kWtNotSupported;
-    VLOG(4) << __func__ << " err=" << err << "; sess=" << *this;
+    PRX_VLOG(4) << __func__ << " err=" << err << "; sess=" << *this;
     return makeHttpEx(std::string(err));
   }
 
diff --git a/proxygen/lib/http/session/HTTPSessionBase.h b/proxygen/lib/http/session/HTTPSessionBase.h
index 076cee407a..63d8ae13f5 100644
--- a/proxygen/lib/http/session/HTTPSessionBase.h
+++ b/proxygen/lib/http/session/HTTPSessionBase.h
@@ -18,6 +18,7 @@
 #include <proxygen/lib/http/observer/HTTPSessionObserverInterface.h>
 #include <proxygen/lib/http/session/HTTPSessionActivityTracker.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Time.h>
 #include <wangle/acceptor/ManagedConnection.h>
 #include <wangle/acceptor/TransportInfo.h>
@@ -138,7 +139,7 @@ class HTTPSessionBase : public wangle::ManagedConnection {
    */
   static void setDefaultReadBufferLimit(uint32_t limit) {
     kDefaultReadBufLimit = limit;
-    VLOG(3) << "read buffer limit: " << int(limit / 1000) << "KB";
+    PRX_VLOG(3) << "read buffer limit: " << int(limit / 1000) << "KB";
   }
 
   static void setMaxReadBufferSize(uint32_t bytes) {
@@ -283,7 +284,7 @@ class HTTPSessionBase : public wangle::ManagedConnection {
    * since the remote side can change this value.
    */
   void setMaxConcurrentOutgoingStreams(uint32_t num) {
-    // TODO: CHECK(started_);
+    // TODO: PRX_CHECK(started_);
     maxConcurrentOutgoingStreamsConfig_ = num;
   }
 
@@ -302,7 +303,7 @@ class HTTPSessionBase : public wangle::ManagedConnection {
 
   void setWriteBufferLimit(uint32_t limit) {
     writeBufLimit_ = limit;
-    VLOG(4) << "write buffer limit: " << int(limit / 1000) << "KB";
+    PRX_VLOG(4) << "write buffer limit: " << int(limit / 1000) << "KB";
   }
 
   void setReadBufferLimit(uint32_t limit) {
@@ -349,9 +350,9 @@ class HTTPSessionBase : public wangle::ManagedConnection {
   }
 
   [[nodiscard]] std::chrono::seconds getLatestIdleTime() const /*override*/ {
-    DCHECK_GT(transactionSeqNo_, 0u)
+    PRX_DCHECK_GT(transactionSeqNo_, 0u)
         << "No idle time for the first transaction";
-    DCHECK(latestActive_ > TimePoint::min());
+    PRX_DCHECK(latestActive_ > TimePoint::min());
     return latestIdleDuration_;
   }
 
@@ -558,7 +559,8 @@ class HTTPSessionBase : public wangle::ManagedConnection {
   }
 
   void enableServerEarlyResponse() noexcept {
-    CHECK_EQ(codec_->getTransportDirection(), TransportDirection::DOWNSTREAM);
+    PRX_CHECK_EQ(codec_->getTransportDirection(),
+                 TransportDirection::DOWNSTREAM);
     enableServerEarlyResponse_ = codec_->supportsParallelRequests();
   }
   [[nodiscard]] bool getServerEarlyResponseEnabled() const {
diff --git a/proxygen/lib/http/session/HTTPSessionController.h b/proxygen/lib/http/session/HTTPSessionController.h
index 3acf5e9c3f..02cd3bbfab 100644
--- a/proxygen/lib/http/session/HTTPSessionController.h
+++ b/proxygen/lib/http/session/HTTPSessionController.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include <chrono>
-#include <glog/logging.h>
 #include <proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace folly {
 class SocketAddress;
@@ -116,7 +116,7 @@ class HTTPSessionController {
 class HTTPUpstreamSessionController : public HTTPSessionController {
   HTTPTransactionHandler* getRequestHandler(HTTPTransaction& /*txn*/,
                                             HTTPMessage* /*msg*/) final {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   /**
@@ -129,7 +129,7 @@ class HTTPUpstreamSessionController : public HTTPSessionController {
       HTTPTransaction* /*txn*/,
       const HTTPException& /*error*/,
       const folly::SocketAddress& /*localAddress*/) final {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 
   /**
@@ -138,7 +138,7 @@ class HTTPUpstreamSessionController : public HTTPSessionController {
   HTTPTransactionHandler* getTransactionTimeoutHandler(
       HTTPTransaction* /*txn*/,
       const folly::SocketAddress& /*localAddress*/) final {
-    LOG(FATAL) << "Unreachable";
+    PRX_LOG(FATAL) << "Unreachable";
   }
 };
 
diff --git a/proxygen/lib/http/session/HTTPTransaction.cpp b/proxygen/lib/http/session/HTTPTransaction.cpp
index 848fe64b0f..07ec8ebec8 100644
--- a/proxygen/lib/http/session/HTTPTransaction.cpp
+++ b/proxygen/lib/http/session/HTTPTransaction.cpp
@@ -12,12 +12,12 @@
 #include <folly/Conv.h>
 #include <folly/io/async/EventBaseManager.h>
 #include <folly/tracing/ScopedTraceSection.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/HTTPHeaderSize.h>
 #include <proxygen/lib/http/RFC2616.h>
 #include <proxygen/lib/http/codec/webtransport/WebTransportFramer.h>
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
 #include <proxygen/lib/http/webtransport/HTTPWebTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <sstream>
 
 using folly::IOBuf;
@@ -60,7 +60,7 @@ bool isConnectUdp(const HTTPMessage& msg) noexcept {
 
 auto tryParseContentLength(const std::string& cl, const HTTPTransaction& txn) {
   auto tryCl = folly::tryTo<uint64_t>(cl);
-  LOG_IF(ERROR, tryCl.hasError())
+  PRX_LOG_IF(ERROR, tryCl.hasError())
       << "Invalid content-length: " << cl << ", ex=" << int(tryCl.error())
       << " " << txn;
   return tryCl;
@@ -169,7 +169,7 @@ void HTTPTransaction::onDelayedDestroy(bool delayed) {
       pendingByteEvents_ > 0 || deleting_) {
     return;
   }
-  VLOG(4) << "destroying transaction " << *this;
+  PRX_VLOG(4) << "destroying transaction " << *this;
   deleting_ = true;
   if (webTransportImpl_) {
     webTransportImpl_->destroy();
@@ -273,8 +273,8 @@ void HTTPTransaction::onIngressHeadersComplete(
     checkCreateDeferredIngress();
     deferredIngress_->emplace(
         id_, HTTPEvent::Type::HEADERS_COMPLETE, std::move(msg));
-    VLOG(4) << "Queued ingress event of type "
-            << HTTPEvent::Type::HEADERS_COMPLETE << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type "
+                << HTTPEvent::Type::HEADERS_COMPLETE << " " << *this;
   } else {
     processIngressHeadersComplete(std::move(msg));
   }
@@ -303,7 +303,7 @@ bool HTTPTransaction::updateContentLengthRemaining(size_t len) {
           len,
           " expecting no more than ",
           expectedIngressContentLengthRemaining_.value());
-      LOG(ERROR) << errorMsg << " " << *this;
+      PRX_LOG(ERROR) << errorMsg << " " << *this;
       if (handler_) {
         HTTPException ex(HTTPException::Direction::INGRESS, errorMsg);
         ex.setProxygenError(kErrorParseBody);
@@ -318,12 +318,13 @@ bool HTTPTransaction::updateContentLengthRemaining(size_t len) {
 void HTTPTransaction::onIngressBody(unique_ptr<IOBuf> chain, uint16_t padding) {
   FOLLY_SCOPED_TRACE_SECTION("HTTPTransaction - onIngressBody");
   DestructorGuard g(this);
-  VLOG(6) << __func__ << " chain_length=" << chain->computeChainDataLength();
+  PRX_VLOG(6) << __func__
+              << " chain_length=" << chain->computeChainDataLength();
   if (isIngressEOMSeen()) {
     std::stringstream ss;
     // Use stringstream to invoke operator << for this
     ss << "onIngressBody after ingress closed " << *this;
-    VLOG(4) << ss.str();
+    PRX_VLOG(4) << ss.str();
     abortAndDeliverError(ErrorCode::STREAM_CLOSED, ss.str());
     return;
   }
@@ -356,7 +357,7 @@ void HTTPTransaction::onIngressBody(unique_ptr<IOBuf> chain, uint16_t padding) {
     ss << "recvWindow_.reserve failed with len=" << len
        << " padding=" << padding << " capacity=" << recvWindow_.getCapacity()
        << " outstanding=" << recvWindow_.getOutstanding() << " " << *this;
-    LOG(ERROR) << ss.str();
+    PRX_LOG(ERROR) << ss.str();
     abortAndDeliverError(ErrorCode::FLOW_CONTROL_ERROR, ss.str());
     return;
   } else {
@@ -373,12 +374,12 @@ void HTTPTransaction::onIngressBody(unique_ptr<IOBuf> chain, uint16_t padding) {
         (tailEvent->getBodyLength() + len <= kMaxBufferPerTxn);
 
     if (shouldCoalesce) {
-      VLOG(4) << "Coalesced ingress event of type " << HTTPEvent::Type::BODY
-              << " size=" << len << " " << *this;
+      PRX_VLOG(4) << "Coalesced ingress event of type " << HTTPEvent::Type::BODY
+                  << " size=" << len << " " << *this;
       tailEvent->appendChunk(std::move(chain));
     } else {
-      VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::BODY
-              << " size=" << len << " " << *this;
+      PRX_VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::BODY
+                  << " size=" << len << " " << *this;
       deferredIngress_->emplace(id_, HTTPEvent::Type::BODY, std::move(chain));
     }
   } else {
@@ -427,8 +428,9 @@ void HTTPTransaction::onIngressChunkHeader(size_t length) {
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::CHUNK_HEADER, length);
-    VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::CHUNK_HEADER
-            << " size=" << length << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type "
+                << HTTPEvent::Type::CHUNK_HEADER << " size=" << length << " "
+                << *this;
   } else {
     processIngressChunkHeader(length);
   }
@@ -452,8 +454,8 @@ void HTTPTransaction::onIngressChunkComplete() {
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::CHUNK_COMPLETE);
-    VLOG(4) << "Queued ingress event of type "
-            << HTTPEvent::Type::CHUNK_COMPLETE << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type "
+                << HTTPEvent::Type::CHUNK_COMPLETE << " " << *this;
   } else {
     processIngressChunkComplete();
   }
@@ -478,8 +480,8 @@ void HTTPTransaction::onIngressTrailers(unique_ptr<HTTPHeaders> trailers) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(
         id_, HTTPEvent::Type::TRAILERS_COMPLETE, std::move(trailers));
-    VLOG(4) << "Queued ingress event of type "
-            << HTTPEvent::Type::TRAILERS_COMPLETE << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type "
+                << HTTPEvent::Type::TRAILERS_COMPLETE << " " << *this;
   } else {
     processIngressTrailers(std::move(trailers));
   }
@@ -504,8 +506,8 @@ void HTTPTransaction::onIngressUpgrade(UpgradeProtocol protocol) {
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::UPGRADE, protocol);
-    VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::UPGRADE
-            << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type " << HTTPEvent::Type::UPGRADE
+                << " " << *this;
   } else {
     processIngressUpgrade(protocol);
   }
@@ -527,7 +529,7 @@ void HTTPTransaction::onIngressEOM() {
     std::stringstream ss;
     // Use stringstream to invoke operator << for this
     ss << "onIngressEOM after ingress closed " << *this;
-    VLOG(4) << ss.str();
+    PRX_VLOG(4) << ss.str();
     abortAndDeliverError(ErrorCode::STREAM_CLOSED, ss.str());
     return;
   }
@@ -536,7 +538,7 @@ void HTTPTransaction::onIngressEOM() {
     auto errorMsg = folly::to<std::string>(
         "Content-Length/body mismatch onIngressEOM: expecting another ",
         expectedIngressContentLengthRemaining_.value());
-    LOG(ERROR) << errorMsg << " " << *this;
+    PRX_LOG(ERROR) << errorMsg << " " << *this;
     if (handler_) {
       HTTPException ex(HTTPException::Direction::INGRESS, errorMsg);
       ex.setProxygenError(kErrorParseBody);
@@ -555,8 +557,8 @@ void HTTPTransaction::onIngressEOM() {
   if (mustQueueIngress()) {
     checkCreateDeferredIngress();
     deferredIngress_->emplace(id_, HTTPEvent::Type::MESSAGE_COMPLETE);
-    VLOG(4) << "Queued ingress event of type "
-            << HTTPEvent::Type::MESSAGE_COMPLETE << " " << *this;
+    PRX_VLOG(4) << "Queued ingress event of type "
+                << HTTPEvent::Type::MESSAGE_COMPLETE << " " << *this;
   } else {
     processIngressEOM();
   }
@@ -567,7 +569,7 @@ void HTTPTransaction::processIngressEOM() {
   if (aborted_) {
     return;
   }
-  VLOG(4) << "ingress EOM on " << *this;
+  PRX_VLOG(4) << "ingress EOM on " << *this;
   const bool wasComplete = isIngressComplete();
   if (!validateIngressStateTransition(IngressSmEvent::eomFlushed)) {
     return;
@@ -605,14 +607,14 @@ void HTTPTransaction::updateReadTimeout() {
 }
 
 void HTTPTransaction::markIngressComplete() {
-  VLOG(4) << "Marking ingress complete on " << *this;
+  PRX_VLOG(4) << "Marking ingress complete on " << *this;
   ingressState_ = IngressSmState::ReceivingDone;
   deferredIngress_.reset();
   cancelTimeout();
 }
 
 void HTTPTransaction::markEgressComplete() {
-  VLOG(4) << "Marking egress complete on " << *this;
+  PRX_VLOG(4) << "Marking egress complete on " << *this;
   auto pendingBytes = getOutstandingEgressBodyBytes();
   if (pendingBytes) {
     int64_t deferredEgressBodyBytes = folly::to<int64_t>(pendingBytes);
@@ -649,7 +651,7 @@ bool HTTPTransaction::validateEgressStateTransition(EgressSmEvent event) {
     std::stringstream ss;
     ss << "Invalid egress state transition, state=" << egressState_
        << ", event=" << event << ", streamID=" << id_;
-    LOG(ERROR) << ss.str() << " " << *this;
+    PRX_LOG(ERROR) << ss.str() << " " << *this;
     invariantViolation(
         stateMachineError(HTTPException::Direction::EGRESS, ss.str()));
     return false;
@@ -659,12 +661,12 @@ bool HTTPTransaction::validateEgressStateTransition(EgressSmEvent event) {
 
 void HTTPTransaction::invariantViolation(HTTPException ex) {
   DestructorGuard g(this);
-  LOG(ERROR) << "invariantViolation msg=" << ex.what()
-             << " aborted_=" << uint32_t(aborted_) << " " << *this;
+  PRX_LOG(ERROR) << "invariantViolation msg=" << ex.what()
+                 << " aborted_=" << uint32_t(aborted_) << " " << *this;
   if (handler_) {
     handler_->onInvariantViolation(ex);
   } else {
-    LOG(FATAL) << "Invariant violation with no handler; ex=" << ex.what();
+    PRX_LOG(FATAL) << "Invariant violation with no handler; ex=" << ex.what();
   }
   // In http/1.1, this will send TCP reset and ungracefully terminate the
   // connection. In h2, this will send stream reset but keep the connection
@@ -711,20 +713,20 @@ void HTTPTransaction::processIngressError(const HTTPException& error) {
     // we got an ingress error, we've seen the entire message, but we're
     // expecting more (window updates).  These aren't coming, convert to
     // INGRESS_AND_EGRESS
-    VLOG(4) << "Converting ingress error to ingress+egress due to"
-               " flow control, and aborting "
-            << *this;
+    PRX_VLOG(4) << "Converting ingress error to ingress+egress due to"
+                   " flow control, and aborting "
+                << *this;
     direction = HTTPException::Direction::INGRESS_AND_EGRESS;
     sendAbort(ErrorCode::FLOW_CONTROL_ERROR);
   }
 
   if (error.getProxygenError() == kErrorStreamAbort) {
-    DCHECK(error.getDirection() ==
-           HTTPException::Direction::INGRESS_AND_EGRESS);
+    PRX_DCHECK(error.getDirection() ==
+               HTTPException::Direction::INGRESS_AND_EGRESS);
     aborted_ = true;
   } else if (error.hasCodecStatusCode()) {
-    DCHECK(error.getDirection() ==
-           HTTPException::Direction::INGRESS_AND_EGRESS);
+    PRX_DCHECK(error.getDirection() ==
+               HTTPException::Direction::INGRESS_AND_EGRESS);
     sendAbort(error.getCodecStatusCode());
   }
 
@@ -774,7 +776,7 @@ void HTTPTransaction::processIngressError(const HTTPException& error) {
 
 void HTTPTransaction::onGoaway(ErrorCode code) {
   DestructorGuard g(this);
-  VLOG(4) << "received GOAWAY notification on " << *this;
+  PRX_VLOG(4) << "received GOAWAY notification on " << *this;
   // This callback can be received at any time and does not affect this
   // transaction's ingress or egress state machines. If it would have
   // affected this transaction's state, we would have received onError()
@@ -786,7 +788,7 @@ void HTTPTransaction::onGoaway(ErrorCode code) {
 
 void HTTPTransaction::onIngressTimeout() {
   DestructorGuard g(this);
-  VLOG(4) << "ingress timeout on " << *this;
+  PRX_VLOG(4) << "ingress timeout on " << *this;
   pauseIngress();
   bool windowUpdateTimeout = !isEgressComplete() && isExpectingWindowUpdate();
   if (handler_) {
@@ -834,7 +836,7 @@ void HTTPTransaction::onIngressWindowUpdate(const uint32_t amount) {
     return;
   }
   DestructorGuard g(this);
-  VLOG(4) << "Remote side ack'd " << amount << " bytes " << *this;
+  PRX_VLOG(4) << "Remote side ack'd " << amount << " bytes " << *this;
   updateReadTimeout();
   if (sendWindow_.free(amount)) {
     notifyTransportPendingEgress();
@@ -844,7 +846,7 @@ void HTTPTransaction::onIngressWindowUpdate(const uint32_t amount) {
     ss << "sendWindow_.free failed with amount=" << amount
        << " capacity=" << sendWindow_.getCapacity()
        << " outstanding=" << sendWindow_.getOutstanding() << " " << *this;
-    LOG(ERROR) << ss.str();
+    PRX_LOG(ERROR) << ss.str();
     abortAndDeliverError(ErrorCode::FLOW_CONTROL_ERROR, ss.str());
   }
 }
@@ -862,14 +864,14 @@ void HTTPTransaction::onIngressSetSendWindow(const uint32_t newWindowSize) {
     ss << "sendWindow_.setCapacity failed with newWindowSize=" << newWindowSize
        << " capacity=" << sendWindow_.getCapacity()
        << " outstanding=" << sendWindow_.getOutstanding() << " " << *this;
-    LOG(ERROR) << ss.str();
+    PRX_LOG(ERROR) << ss.str();
     abortAndDeliverError(ErrorCode::FLOW_CONTROL_ERROR, ss.str());
   }
 }
 
 void HTTPTransaction::onEgressTimeout() {
   DestructorGuard g(this);
-  VLOG(4) << "egress timeout on " << *this;
+  PRX_VLOG(4) << "egress timeout on " << *this;
   if (handler_) {
     HTTPException ex(HTTPException::Direction::EGRESS,
                      folly::to<std::string>("egress timeout, streamID=", id_));
@@ -1014,7 +1016,7 @@ void HTTPTransaction::sendHeadersWithOptionalEOM(const HTTPMessage& headers,
   if (!validateEgressStateTransition(EgressSmEvent::sendHeaders)) {
     return;
   }
-  DCHECK(!isEgressComplete());
+  PRX_DCHECK(!isEgressComplete());
   if (!headers.isRequest() && !isPushed()) {
     lastResponseStatus_ = headers.getStatusCode();
   }
@@ -1093,7 +1095,7 @@ void HTTPTransaction::sendWtHeaders(
     HttpWtClientCallbackPtr wtClientCb) noexcept {
   wtCtx_.wtHandler_ = std::move(wtHandler);
   wtCtx_.upstreamWtCb_ = std::move(wtClientCb);
-  CHECK(wtCtx_.wtHandler_);
+  PRX_CHECK(wtCtx_.wtHandler_);
   sendHeadersWithOptionalEOM(headers, /*eom=*/false);
 }
 
@@ -1116,8 +1118,8 @@ void HTTPTransaction::sendBody(std::unique_ptr<folly::IOBuf> body) {
       // Note, this check doesn't account for cases where sendBody is called
       // multiple times for a single chunk, and the total length exceeds the
       // header.
-      DCHECK(!chunkHeaders_.empty());
-      DCHECK_LE(bodyLen, chunkHeaders_.back().length)
+      PRX_DCHECK(!chunkHeaders_.empty());
+      PRX_DCHECK_LE(bodyLen, chunkHeaders_.back().length)
           << "Sent body longer than chunk header ";
     }
     deferredEgressBody_.append(std::move(body));
@@ -1128,7 +1130,7 @@ void HTTPTransaction::sendBody(std::unique_ptr<folly::IOBuf> body) {
 
 bool HTTPTransaction::onWriteReady(const uint32_t maxEgress, double ratio) {
   DestructorGuard g(this);
-  DCHECK(isEnqueued());
+  PRX_DCHECK(isEnqueued());
   cumulativeRatio_ += ratio;
   egressCalls_++;
   sendDeferredBody(maxEgress);
@@ -1174,7 +1176,7 @@ size_t HTTPTransaction::sendDeferredBody(uint32_t maxEgress) {
       }
       curLen = std::min<size_t>(chunk.length, canSend);
       std::unique_ptr<folly::IOBuf> cur = deferredEgressBody_.split(curLen);
-      VLOG(4) << "sending " << curLen << " fin=false";
+      PRX_VLOG(4) << "sending " << curLen << " fin=false";
       nbytes += sendBodyNow(std::move(cur), curLen, false);
       canSend -= curLen;
       chunk.length -= curLen;
@@ -1182,7 +1184,7 @@ size_t HTTPTransaction::sendDeferredBody(uint32_t maxEgress) {
         nbytes += transport_.sendChunkTerminator(this);
         chunkHeaders_.pop_front();
       } else {
-        DCHECK_EQ(canSend, 0);
+        PRX_DCHECK_EQ(canSend, 0u);
       }
     }
     willSendEOM = hasPendingEOM();
@@ -1246,8 +1248,8 @@ bool HTTPTransaction::maybeDelayForRateLimit() {
 
   if (requiredDelay > kRateLimitMaxDelay) {
     // The delay should never be this long
-    VLOG(4) << "ratelim: Required delay too long (" << requiredDelay.count()
-            << "ms), ignoring";
+    PRX_VLOG(4) << "ratelim: Required delay too long (" << requiredDelay.count()
+                << "ms), ignoring";
     return false;
   }
 
@@ -1272,21 +1274,21 @@ size_t HTTPTransaction::maybeSendDeferredNoError() {
   size_t bytes = 0;
   if (deferredNoError_) {
     deferredNoError_ = false;
-    VLOG(4) << "sending deferred NO_ERROR";
+    PRX_VLOG(4) << "sending deferred NO_ERROR";
     bytes += sendAbortImpl(ErrorCode::NO_ERROR);
   }
   return bytes;
 }
 
 void HTTPTransaction::sendPadding(uint16_t bytes) {
-  VLOG(4) << "egress padding=" << bytes << " on " << *this;
+  PRX_VLOG(4) << "egress padding=" << bytes << " on " << *this;
   // Padding is allowed at any time, even before headers and after EOM
   transport_.sendPadding(this, bytes);
 }
 
 size_t HTTPTransaction::sendEOMNow() {
   DestructorGuard g(this);
-  VLOG(4) << "egress EOM on " << *this;
+  PRX_VLOG(4) << "egress EOM on " << *this;
   // TODO: with ByteEvent refactor, we will have to delay changing this
   // state until later
   if (!validateEgressStateTransition(EgressSmEvent::eomFlushed)) {
@@ -1308,23 +1310,25 @@ size_t HTTPTransaction::sendBodyNow(std::unique_ptr<folly::IOBuf> body,
                                     size_t bodyLen,
                                     bool sendEom) {
   constexpr std::string_view kNoneStr = "None";
-  DCHECK(body);
-  DCHECK_GT(bodyLen, 0);
+  PRX_DCHECK(body);
+  PRX_DCHECK_GT(bodyLen, 0u);
   size_t nbytes = 0;
   if (useFlowControl_) {
     // Because of how sendBodyNow is embedded in HTTPTransaction code flow,
     // calling INVARIANT here is not safe
-    CHECK(sendWindow_.reserve(bodyLen));
-  }
-  VLOG(4) << "Sending " << bodyLen
-          << " bytes of body. eom=" << ((sendEom) ? "yes" : "no")
-          << " send_window is "
-          << (useFlowControl_
-                  ? folly::to<std::string>(
-                        sendWindow_.getSize(), " / ", sendWindow_.getCapacity())
-                  : kNoneStr)
-          << " trailers=" << ((trailers_) ? "yes" : "no") << " " << *this;
-  DCHECK_LT(bodyLen, std::numeric_limits<int64_t>::max());
+    PRX_CHECK(sendWindow_.reserve(bodyLen));
+  }
+  PRX_VLOG(4)
+      << "Sending " << bodyLen
+      << " bytes of body. eom=" << ((sendEom) ? "yes" : "no")
+      << " send_window is "
+      << (useFlowControl_
+              ? folly::to<std::string>(
+                    sendWindow_.getSize(), " / ", sendWindow_.getCapacity())
+              : kNoneStr)
+      << " trailers=" << ((trailers_) ? "yes" : "no") << " " << *this;
+  PRX_DCHECK_LT(bodyLen,
+                static_cast<size_t>(std::numeric_limits<int64_t>::max()));
   transport_.notifyEgressBodyBuffered(-static_cast<int64_t>(bodyLen));
   const bool sendDataFin = sendEom && !trailers_;
   if (sendDataFin) {
@@ -1382,7 +1386,7 @@ void HTTPTransaction::sendEOM() {
         *expectedResponseLength_,
         ", actual= ",
         *actualResponseLength_);
-    LOG(ERROR) << errorMsg << " " << *this;
+    PRX_LOG(ERROR) << errorMsg << " " << *this;
   }
 
   if (getOutstandingEgressBodyBytes() == 0 && chunkHeaders_.empty()) {
@@ -1405,18 +1409,18 @@ void HTTPTransaction::sendEOM() {
       // If the txn is enqueued, sendDeferredBody()
       // should take care of sending the EOM.
       // This can happen for some uses of the egress queue
-      VLOG(4) << "Queued egress EOM with no body"
-              << "[egressState=" << egressState_ << ", "
-              << "ingressState=" << ingressState_ << ", "
-              << "egressPaused=" << egressPaused_ << ", "
-              << "ingressPaused=" << ingressPaused_ << ", "
-              << "aborted=" << aborted_ << ", "
-              << "enqueued=" << isEnqueued() << ", "
-              << "chainLength=" << deferredEgressBody_.chainLength() << "]"
-              << " on " << *this;
+      PRX_VLOG(4) << "Queued egress EOM with no body"
+                  << "[egressState=" << egressState_ << ", "
+                  << "ingressState=" << ingressState_ << ", "
+                  << "egressPaused=" << egressPaused_ << ", "
+                  << "ingressPaused=" << ingressPaused_ << ", "
+                  << "aborted=" << aborted_ << ", "
+                  << "enqueued=" << isEnqueued() << ", "
+                  << "chainLength=" << deferredEgressBody_.chainLength() << "]"
+                  << " on " << *this;
     }
   } else {
-    VLOG(4) << "Queued egress EOM on " << *this;
+    PRX_VLOG(4) << "Queued egress EOM on " << *this;
     notifyTransportPendingEgress();
   }
 }
@@ -1439,14 +1443,14 @@ void HTTPTransaction::sendAbort(ErrorCode statusCode) {
         getEgressState() == HTTPTransactionEgressSMData::State::EOMQueued;
 
     if (deferredNoError_) {
-      VLOG(4) << "deferring abort ErrorCode=NO_ERROR";
+      PRX_VLOG(4) << "deferring abort ErrorCode=NO_ERROR";
       return;
     }
 
     // if statusCode == NO_ERROR and eom has not been flushed; default to CANCEL
     // for upstream & INTERNAL_ERROR for downstream
     if (!canSendNoError) {
-      VLOG(4) << "cannot send NO_ERROR; falling back to default ErrorCode";
+      PRX_VLOG(4) << "cannot send NO_ERROR; falling back to default ErrorCode";
       statusCode = getDefaultAbortErrorCode(isUpstream());
     }
   }
@@ -1460,10 +1464,10 @@ size_t HTTPTransaction::sendAbortImpl(ErrorCode statusCode) {
   if (aborted_) {
     // This can happen in cases where the abort is sent before notifying the
     // handler, but its logic also wants to abort
-    VLOG(4) << "skipping redundant abort";
+    PRX_VLOG(4) << "skipping redundant abort";
     return 0;
   }
-  VLOG(4) << "aborting transaction " << *this;
+  PRX_VLOG(4) << "aborting transaction " << *this;
   aborted_ = true;
   size_t nbytes = transport_.sendAbort(this, statusCode);
   if (transportCallback_) {
@@ -1518,10 +1522,10 @@ HTTPTransaction::getConnectionToken() const noexcept {
 }
 
 void HTTPTransaction::pauseIngress() {
-  VLOG(4) << "pauseIngress request " << *this;
+  PRX_VLOG(4) << "pauseIngress request " << *this;
   DestructorGuard g(this);
   if (ingressPaused_) {
-    VLOG(4) << "can't pause ingress; ingressPaused=" << ingressPaused_;
+    PRX_VLOG(4) << "can't pause ingress; ingressPaused=" << ingressPaused_;
     return;
   }
   ingressPaused_ = true;
@@ -1530,18 +1534,18 @@ void HTTPTransaction::pauseIngress() {
 }
 
 void HTTPTransaction::resumeIngress() {
-  VLOG(4) << "resumeIngress request " << *this;
+  PRX_VLOG(4) << "resumeIngress request " << *this;
   DestructorGuard g(this);
   if (!ingressPaused_ || isIngressComplete()) {
-    VLOG(4) << "can't resume ingress, ingressPaused=" << ingressPaused_
-            << ", ingressComplete=" << isIngressComplete()
-            << ", inResume_=" << inResume_ << " " << *this;
+    PRX_VLOG(4) << "can't resume ingress, ingressPaused=" << ingressPaused_
+                << ", ingressComplete=" << isIngressComplete()
+                << ", inResume_=" << inResume_ << " " << *this;
     return;
   }
   ingressPaused_ = false;
   transport_.resumeIngress(this);
   if (inResume_) {
-    VLOG(4) << "skipping recursive resume loop " << *this;
+    PRX_VLOG(4) << "skipping recursive resume loop " << *this;
     return;
   }
   inResume_ = true;
@@ -1560,8 +1564,8 @@ void HTTPTransaction::resumeIngress() {
   // the transaction.
   while (!ingressPaused_ && deferredIngress_ && !deferredIngress_->empty()) {
     HTTPEvent& callback(deferredIngress_->front());
-    VLOG(5) << "Processing deferred ingress callback of type "
-            << callback.getEvent() << " " << *this;
+    PRX_VLOG(5) << "Processing deferred ingress callback of type "
+                << callback.getEvent() << " " << *this;
     SCOPE_EXIT {
       if (deferredIngress_) {
         deferredIngress_->pop();
@@ -1569,7 +1573,7 @@ void HTTPTransaction::resumeIngress() {
     };
     switch (callback.getEvent()) {
       case HTTPEvent::Type::MESSAGE_BEGIN:
-        LOG(FATAL) << "unreachable";
+        PRX_LOG(FATAL) << "unreachable";
       case HTTPEvent::Type::HEADERS_COMPLETE:
         processIngressHeadersComplete(callback.getHeaders());
         break;
@@ -1601,10 +1605,10 @@ void HTTPTransaction::resumeIngress() {
 }
 
 void HTTPTransaction::pauseEgress() {
-  VLOG(4) << "asked to pause egress " << *this;
+  PRX_VLOG(4) << "asked to pause egress " << *this;
   DestructorGuard g(this);
   if (egressPaused_) {
-    VLOG(4) << "egress already paused " << *this;
+    PRX_VLOG(4) << "egress already paused " << *this;
     return;
   }
   egressPaused_ = true;
@@ -1612,10 +1616,10 @@ void HTTPTransaction::pauseEgress() {
 }
 
 void HTTPTransaction::resumeEgress() {
-  VLOG(4) << "asked to resume egress " << *this;
+  PRX_VLOG(4) << "asked to resume egress " << *this;
   DestructorGuard g(this);
   if (!egressPaused_) {
-    VLOG(4) << "egress already not paused " << *this;
+    PRX_VLOG(4) << "egress already not paused " << *this;
     return;
   }
   egressPaused_ = false;
@@ -1625,7 +1629,7 @@ void HTTPTransaction::resumeEgress() {
 void HTTPTransaction::setEgressRateLimit(uint64_t bitsPerSecond) {
   egressLimitBytesPerMs_ = bitsPerSecond / 8000;
   if (bitsPerSecond > 0 && egressLimitBytesPerMs_ == 0) {
-    VLOG(4) << "ratelim: Limit too low (" << bitsPerSecond << "), ignoring";
+    PRX_VLOG(4) << "ratelim: Limit too low (" << bitsPerSecond << "), ignoring";
   }
   startRateLimit_ = getCurrentTime();
   numLimitedBytesEgressed_ = 0;
@@ -1633,7 +1637,7 @@ void HTTPTransaction::setEgressRateLimit(uint64_t bitsPerSecond) {
 
 void HTTPTransaction::notifyTransportPendingEgress() {
   DestructorGuard guard(this);
-  CHECK(queueHandle_);
+  PRX_CHECK(queueHandle_);
   if (!egressRateLimited_ &&
       (getOutstandingEgressBodyBytes() > 0 || isEgressEOMQueued()) &&
       (!useFlowControl_ || sendWindow_.getSize() > 0)) {
@@ -1653,15 +1657,16 @@ void HTTPTransaction::notifyTransportPendingEgress() {
 
 void HTTPTransaction::updateHandlerPauseState() {
   if (isEgressEOMSeen()) {
-    VLOG(4) << "transaction already egress complete, not updating pause state "
-            << *this;
+    PRX_VLOG(4)
+        << "transaction already egress complete, not updating pause state "
+        << *this;
     return;
   }
   int64_t availWindow = sendWindow_.getSize() - getOutstandingEgressBodyBytes();
   // do not count transaction stalled if no more bytes to send,
   // i.e. when availWindow == 0
   if (useFlowControl_ && availWindow < 0 && !flowControlPaused_) {
-    VLOG(4) << "transaction stalled by flow control txn=" << *this;
+    PRX_VLOG(4) << "transaction stalled by flow control txn=" << *this;
     if (stats_) {
       stats_->recordTransactionStalled();
     }
@@ -1672,22 +1677,22 @@ void HTTPTransaction::updateHandlerPauseState() {
       egressPaused_ || flowControlPaused_ || egressRateLimited_ || bufferFull;
 
   if (!egressPaused_ && bufferFull) {
-    VLOG(4) << "Not resuming handler, buffer full, txn=" << *this;
+    PRX_VLOG(4) << "Not resuming handler, buffer full, txn=" << *this;
   }
 
   if (handler_ && handlerShouldBePaused != handlerEgressPaused_) {
     if (handlerShouldBePaused) {
       if (canSendHeaders()) {
-        VLOG(4) << "txn hasn't egressed headers, not updating pause state "
-                << *this;
+        PRX_VLOG(4) << "txn hasn't egressed headers, not updating pause state "
+                    << *this;
         return;
       }
       handlerEgressPaused_ = true;
-      VLOG(4) << "egress paused txn=" << *this;
+      PRX_VLOG(4) << "egress paused txn=" << *this;
       handler_->onEgressPaused();
     } else {
       handlerEgressPaused_ = false;
-      VLOG(4) << "egress resumed txn=" << *this;
+      PRX_VLOG(4) << "egress resumed txn=" << *this;
       handler_->onEgressResumed();
     }
   }
@@ -1721,13 +1726,13 @@ bool HTTPTransaction::onPushedTransaction(HTTPTransaction* pushTxn) {
   DestructorGuard g(this);
   INVARIANT_RETURN(*pushTxn->assocStreamId_ == id_, false);
   if (!handler_) {
-    VLOG(4) << "Cannot add a pushed txn to an unhandled txn";
+    PRX_VLOG(4) << "Cannot add a pushed txn to an unhandled txn";
     return false;
   }
   refreshTimeout();
   handler_->onPushedTransaction(pushTxn);
   if (!pushTxn->getHandler()) {
-    VLOG(4) << "Failed to create a handler for push transaction";
+    PRX_VLOG(4) << "Failed to create a handler for push transaction";
     return false;
   }
   pushedTransactions_.insert(pushTxn->getID());
@@ -1736,9 +1741,10 @@ bool HTTPTransaction::onPushedTransaction(HTTPTransaction* pushTxn) {
 
 void HTTPTransaction::setIdleTimeout(std::chrono::milliseconds idleTimeout) {
   idleTimeout_ = idleTimeout;
-  VLOG(4) << "HTTPTransaction: idle timeout is set to  "
-          << std::chrono::duration_cast<std::chrono::milliseconds>(idleTimeout)
-                 .count();
+  PRX_VLOG(4)
+      << "HTTPTransaction: idle timeout is set to  "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(idleTimeout)
+             .count();
   updateReadTimeout();
 }
 
@@ -1762,7 +1768,7 @@ void HTTPTransaction::setReceiveWindow(uint32_t capacity) {
   if (delta < 0) {
     // For now, we're disallowing shrinking the window, since it can lead
     // to FLOW_CONTROL_ERRORs if there is data in flight.
-    VLOG(4) << "Refusing to shrink the recv window";
+    PRX_VLOG(4) << "Refusing to shrink the recv window";
     return;
   }
   if (!recvWindow_.setCapacity(capacity)) {
@@ -1777,9 +1783,9 @@ void HTTPTransaction::flushWindowUpdate() {
       (isDownstream() || egressState_ != EgressSmState::Start ||
        ingressState_ != IngressSmState::Start)) {
     // Down egress upstream window updates until after headers
-    VLOG(4) << "recv_window is " << recvWindow_.getSize() << " / "
-            << recvWindow_.getCapacity() << " after acking " << recvToAck_
-            << " " << *this;
+    PRX_VLOG(4) << "recv_window is " << recvWindow_.getSize() << " / "
+                << recvWindow_.getCapacity() << " after acking " << recvToAck_
+                << " " << *this;
     transport_.sendWindowUpdate(this, recvToAck_);
     recvToAck_ = 0;
   }
@@ -1813,7 +1819,7 @@ void HTTPTransaction::onDatagram(
   if (aborted_) {
     return;
   }
-  VLOG(4) << "datagram received on " << *this;
+  PRX_VLOG(4) << "datagram received on " << *this;
   if (!validateIngressStateTransition(IngressSmEvent::onDatagram)) {
     return;
   }
@@ -1870,9 +1876,10 @@ bool HTTPTransaction::onWebTransportStopSending(HTTPCodec::StreamID id,
 void HTTPTransaction::sendCloseWebTransportSessionCapsule(
     uint32_t errorCode, const std::string& errorMessage) {
   if (isEgressComplete()) {
-    VLOG(4) << "Ignoring sendCloseWebTransportSessionCapsule: egress already "
-               "complete for streamID="
-            << id_;
+    PRX_VLOG(4)
+        << "Ignoring sendCloseWebTransportSessionCapsule: egress already "
+           "complete for streamID="
+        << id_;
     return;
   }
   CloseWebTransportSessionCapsule capsule{.applicationErrorCode = errorCode,
@@ -1881,7 +1888,7 @@ void HTTPTransaction::sendCloseWebTransportSessionCapsule(
   folly::IOBufQueue queue;
   if (auto res = writeCloseWebTransportSession(queue, capsule);
       !res.has_value()) {
-    VLOG(4) << "Failed to write CLOSE_WEBTRANSPORT_SESSION capsule";
+    PRX_VLOG(4) << "Failed to write CLOSE_WEBTRANSPORT_SESSION capsule";
     return;
   }
 
diff --git a/proxygen/lib/http/session/HTTPTransaction.h b/proxygen/lib/http/session/HTTPTransaction.h
index 110dd12c83..1b459c050b 100644
--- a/proxygen/lib/http/session/HTTPTransaction.h
+++ b/proxygen/lib/http/session/HTTPTransaction.h
@@ -32,6 +32,7 @@
 #include <proxygen/lib/http/sink/FlowControlInfo.h>
 #include <proxygen/lib/http/webtransport/WebTransport.h>
 #include <proxygen/lib/http/webtransport/WebTransportImpl.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Time.h>
 #include <proxygen/lib/utils/TraceEvent.h>
 #include <proxygen/lib/utils/TraceEventObserver.h>
@@ -240,7 +241,7 @@ class HTTPTransactionHandler : public TraceEventObserver {
    * example is mis-use of the egress APIs (sendBody() before sendHeaders()).
    */
   virtual void onInvariantViolation(const HTTPException& error) noexcept {
-    LOG(FATAL) << error.what();
+    PRX_LOG(FATAL) << error.what();
   }
   /**
    * If the remote side's receive buffer fills up, this callback will be
@@ -335,40 +336,40 @@ class HTTPPushTransactionHandler : public HTTPTransactionHandler {
   ~HTTPPushTransactionHandler() override = default;
 
   void onHeadersComplete(std::unique_ptr<HTTPMessage>) noexcept final {
-    LOG(FATAL) << "push txn received headers";
+    PRX_LOG(FATAL) << "push txn received headers";
   }
 
   void onBody(std::unique_ptr<folly::IOBuf>) noexcept final {
-    LOG(FATAL) << "push txn received body";
+    PRX_LOG(FATAL) << "push txn received body";
   }
 
   void onBodyWithOffset(uint64_t,
                         std::unique_ptr<folly::IOBuf>) noexcept final {
-    LOG(FATAL) << "push txn received body with offset";
+    PRX_LOG(FATAL) << "push txn received body with offset";
   }
 
   void onChunkHeader(size_t /* length */) noexcept final {
-    LOG(FATAL) << "push txn received chunk header";
+    PRX_LOG(FATAL) << "push txn received chunk header";
   }
 
   void onChunkComplete() noexcept final {
-    LOG(FATAL) << "push txn received chunk complete";
+    PRX_LOG(FATAL) << "push txn received chunk complete";
   }
 
   void onTrailers(std::unique_ptr<HTTPHeaders>) noexcept final {
-    LOG(FATAL) << "push txn received trailers";
+    PRX_LOG(FATAL) << "push txn received trailers";
   }
 
   void onEOM() noexcept final {
-    LOG(FATAL) << "push txn received EOM";
+    PRX_LOG(FATAL) << "push txn received EOM";
   }
 
   void onUpgrade(UpgradeProtocol) noexcept final {
-    LOG(FATAL) << "push txn received upgrade";
+    PRX_LOG(FATAL) << "push txn received upgrade";
   }
 
   void onPushedTransaction(HTTPTransaction*) noexcept final {
-    LOG(FATAL) << "push txn received push txn";
+    PRX_LOG(FATAL) << "push txn received push txn";
   }
 };
 
@@ -574,7 +575,7 @@ class HTTPTransaction
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode> sendDatagram(
         std::unique_ptr<folly::IOBuf> /*datagram*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -583,7 +584,7 @@ class HTTPTransaction
     }
 
     bool isPeerInitiatedStream(HTTPCodec::StreamID /*id*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -593,33 +594,33 @@ class HTTPTransaction
 
     folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
     newWebTransportBidiStream() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
     newWebTransportUniStream() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::SemiFuture<folly::Unit> awaitUniStreamCredit() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::SemiFuture<folly::Unit> awaitBidiStreamCredit() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     bool canCreateUniStream() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     bool canCreateBidiStream() override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -629,28 +630,28 @@ class HTTPTransaction
         std::unique_ptr<folly::IOBuf> /*data*/,
         bool /*eof*/,
         WebTransport::ByteEventCallback* /* deliveryCallback */) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode>
     notifyPendingWriteOnStream(HTTPCodec::StreamID,
                                quic::StreamWriteCallback*) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode>
     resetWebTransportEgress(HTTPCodec::StreamID /*id*/,
                             uint32_t /*errorCode*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<std::pair<std::unique_ptr<folly::IOBuf>, bool>,
                     WebTransport::ErrorCode>
     readWebTransportData(HTTPCodec::StreamID /*id*/, size_t /*max*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -658,7 +659,7 @@ class HTTPTransaction
     initiateReadOnBidiStream(
         HTTPCodec::StreamID /*id*/,
         quic::StreamReadCallback* /*readCallback*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -666,26 +667,26 @@ class HTTPTransaction
     setWebTransportStreamPriority(
         HTTPCodec::StreamID /*id*/,
         quic::PriorityQueue::Priority /*pri*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode>
     setWebTransportPriorityQueue(
         std::unique_ptr<quic::PriorityQueue> /*queue*/) noexcept override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode>
     pauseWebTransportIngress(HTTPCodec::StreamID /*id*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
     folly::Expected<folly::Unit, WebTransport::ErrorCode>
     resumeWebTransportIngress(HTTPCodec::StreamID /*id*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -693,7 +694,7 @@ class HTTPTransaction
     stopReadingWebTransportIngress(
         HTTPCodec::StreamID /*id*/,
         folly::Optional<uint32_t> /*errorCode*/) override {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -702,7 +703,7 @@ class HTTPTransaction
      */
     virtual void trackEgressBodyOffset(uint64_t /* bodyOffset */,
                                        ByteEvent::EventFlags /*flags*/) {
-      LOG(FATAL) << __func__ << " not supported";
+      PRX_LOG(FATAL) << __func__ << " not supported";
       folly::assume_unreachable();
     }
 
@@ -1503,14 +1504,14 @@ class HTTPTransaction
    * to decrementPendingByteEvents or the transaction will never be destroyed.
    */
   void incrementPendingByteEvents() {
-    CHECK_LT(pendingByteEvents_,
-             std::numeric_limits<decltype(pendingByteEvents_)>::max());
+    PRX_CHECK_LT(pendingByteEvents_,
+                 std::numeric_limits<decltype(pendingByteEvents_)>::max());
     pendingByteEvents_++;
   }
 
   void decrementPendingByteEvents() {
     DestructorGuard dg(this);
-    CHECK_GT(pendingByteEvents_, 0);
+    PRX_CHECK_GT(pendingByteEvents_, 0u);
     pendingByteEvents_--;
   }
 
@@ -1612,7 +1613,7 @@ class HTTPTransaction
       return nullptr;
     }
     if (!webTransportImpl_) {
-      CHECK(wtTransportProvider_);
+      PRX_CHECK(wtTransportProvider_);
       webTransportImpl_ =
           std::make_unique<WebTransportImpl>(*wtTransportProvider_, *this);
     }
@@ -1685,7 +1686,7 @@ class HTTPTransaction
   HTTPTransaction& operator=(const HTTPTransaction&) = delete;
 
   void dequeue() {
-    CHECK(isEnqueued());
+    PRX_CHECK(isEnqueued());
     egressQueue_.clearPendingEgress(queueHandle_);
   }
 
diff --git a/proxygen/lib/http/session/HTTPTransactionEgressSM.cpp b/proxygen/lib/http/session/HTTPTransactionEgressSM.cpp
index e303e27ba7..be9d00deb5 100644
--- a/proxygen/lib/http/session/HTTPTransactionEgressSM.cpp
+++ b/proxygen/lib/http/session/HTTPTransactionEgressSM.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HTTPTransactionEgressSM.h>
 
 #include <folly/Indestructible.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -104,7 +105,7 @@ std::ostream& operator<<(std::ostream& os,
       os << "SendingDone";
       break;
     case HTTPTransactionEgressSMData::State::NumStates:
-      CHECK(false) << "Bad state";
+      PRX_CHECK(false) << "Bad state";
   }
 
   return os;
@@ -138,7 +139,7 @@ std::ostream& operator<<(std::ostream& os,
       os << "eomFlushed";
       break;
     case HTTPTransactionEgressSMData::Event::NumEvents:
-      CHECK(false) << "Bad event";
+      PRX_CHECK(false) << "Bad event";
   }
 
   return os;
diff --git a/proxygen/lib/http/session/HTTPTransactionIngressSM.cpp b/proxygen/lib/http/session/HTTPTransactionIngressSM.cpp
index 64e0d3df67..62ba094452 100644
--- a/proxygen/lib/http/session/HTTPTransactionIngressSM.cpp
+++ b/proxygen/lib/http/session/HTTPTransactionIngressSM.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HTTPTransactionIngressSM.h>
 
 #include <folly/Indestructible.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -127,7 +128,7 @@ std::ostream& operator<<(std::ostream& os,
       os << "ReceivingDone";
       break;
     case HTTPTransactionIngressSMData::State::NumStates:
-      CHECK(false) << "Bad state";
+      PRX_CHECK(false) << "Bad state";
   }
 
   return os;
@@ -167,7 +168,7 @@ std::ostream& operator<<(std::ostream& os,
       os << "eomFlushed";
       break;
     case HTTPTransactionIngressSMData::Event::NumEvents:
-      CHECK(false) << "Bad event";
+      PRX_CHECK(false) << "Bad event";
   }
 
   return os;
diff --git a/proxygen/lib/http/session/HTTPUpstreamSession.cpp b/proxygen/lib/http/session/HTTPUpstreamSession.cpp
index 1305c2a7f8..eef42c4ccb 100644
--- a/proxygen/lib/http/session/HTTPUpstreamSession.cpp
+++ b/proxygen/lib/http/session/HTTPUpstreamSession.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/session/HTTPUpstreamSession.h>
 
 #include <folly/io/async/AsyncSSLSocket.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/ConnectionManager.h>
 
 namespace proxygen {
@@ -35,7 +36,7 @@ HTTPUpstreamSession::HTTPUpstreamSession(
       asyncSocket->setBufferCallback(this);
     }
   }
-  CHECK_EQ(codec_->getTransportDirection(), TransportDirection::UPSTREAM);
+  PRX_CHECK_EQ(codec_->getTransportDirection(), TransportDirection::UPSTREAM);
 }
 
 // uses folly::HHWheelTimer instance which is used on client side & thrift
@@ -63,18 +64,18 @@ bool HTTPUpstreamSession::isReplaySafe() const {
 }
 
 bool HTTPUpstreamSession::isReusable() const {
-  VLOG(4) << "isReusable: " << *this
-          << ", liveTransactions_=" << liveTransactions_
-          << ", isClosing()=" << isClosing()
-          << ", sock_->connecting()=" << sock_->connecting()
-          << ", codec_->isReusable()=" << codec_->isReusable()
-          << ", codec_->isBusy()=" << codec_->isBusy()
-          << ", numActiveWrites_=" << numActiveWrites_
-          << ", writeTimeout_.isScheduled()=" << writeTimeout_.isScheduled()
-          << ", ingressError_=" << ingressError_
-          << ", hasMoreWrites()=" << hasMoreWrites()
-          << ", codec_->supportsParallelRequests()="
-          << codec_->supportsParallelRequests();
+  PRX_VLOG(4) << "isReusable: " << *this
+              << ", liveTransactions_=" << liveTransactions_
+              << ", isClosing()=" << isClosing()
+              << ", sock_->connecting()=" << sock_->connecting()
+              << ", codec_->isReusable()=" << codec_->isReusable()
+              << ", codec_->isBusy()=" << codec_->isBusy()
+              << ", numActiveWrites_=" << numActiveWrites_
+              << ", writeTimeout_.isScheduled()=" << writeTimeout_.isScheduled()
+              << ", ingressError_=" << ingressError_
+              << ", hasMoreWrites()=" << hasMoreWrites()
+              << ", codec_->supportsParallelRequests()="
+              << codec_->supportsParallelRequests();
   return !isClosing() && !sock_->connecting() && codec_->isReusable() &&
          !codec_->isBusy() && !ingressError_ &&
          (codec_->supportsParallelRequests() ||
@@ -85,12 +86,12 @@ bool HTTPUpstreamSession::isReusable() const {
 }
 
 bool HTTPUpstreamSession::isClosing() const {
-  VLOG(5) << "isClosing: " << *this << ", sock_->good()=" << sock_->good()
-          << ", draining_=" << draining_
-          << ", readsShutdown()=" << readsShutdown()
-          << ", writesShutdown()=" << writesShutdown()
-          << ", writesDraining_=" << writesDraining_
-          << ", resetAfterDrainingWrites_=" << resetAfterDrainingWrites_;
+  PRX_VLOG(5) << "isClosing: " << *this << ", sock_->good()=" << sock_->good()
+              << ", draining_=" << draining_
+              << ", readsShutdown()=" << readsShutdown()
+              << ", writesShutdown()=" << writesShutdown()
+              << ", writesDraining_=" << writesDraining_
+              << ", resetAfterDrainingWrites_=" << resetAfterDrainingWrites_;
   return !sock_->good() || draining_ || readsShutdown() || writesShutdown() ||
          writesDraining_ || resetAfterDrainingWrites_;
 }
@@ -142,7 +143,7 @@ HTTPUpstreamSession::newTransactionWithError(
   }
 
   DestructorGuard dg(this);
-  txn->setHandler(CHECK_NOTNULL(handler));
+  txn->setHandler(PRX_CHECK_NOTNULL(handler));
   return txn;
 }
 
@@ -197,7 +198,7 @@ void HTTPUpstreamSession::maybeAttachSSLContext(
 }
 
 void HTTPUpstreamSession::detachThreadLocals(bool detachSSLContext) {
-  CHECK(transactions_.empty());
+  PRX_CHECK(transactions_.empty());
   cancelLoopCallbacks();
   pauseReadsImpl();
   if (sock_) {
diff --git a/proxygen/lib/http/session/SimpleController.cpp b/proxygen/lib/http/session/SimpleController.cpp
index c9f5409b33..1d24132115 100644
--- a/proxygen/lib/http/session/SimpleController.cpp
+++ b/proxygen/lib/http/session/SimpleController.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/session/CodecErrorResponseHandler.h>
 #include <proxygen/lib/http/session/HTTPDirectResponseHandler.h>
 #include <proxygen/lib/http/session/HTTPSessionAcceptor.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -20,7 +21,7 @@ SimpleController::SimpleController(HTTPSessionAcceptor* acceptor)
 
 HTTPTransactionHandler* SimpleController::getRequestHandler(
     HTTPTransaction& txn, HTTPMessage* msg) {
-  CHECK(acceptor_) << "Requires an acceptor, or override this method";
+  PRX_CHECK(acceptor_) << "Requires an acceptor, or override this method";
   return acceptor_->newHandler(txn, msg);
 }
 
diff --git a/proxygen/lib/http/session/WebTransportFilter.h b/proxygen/lib/http/session/WebTransportFilter.h
index ba5ad76c26..bf84284e76 100644
--- a/proxygen/lib/http/session/WebTransportFilter.h
+++ b/proxygen/lib/http/session/WebTransportFilter.h
@@ -8,12 +8,12 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/HTTPMessageFilters.h>
 #include <proxygen/lib/http/codec/HQUtils.h>
 #include <proxygen/lib/http/codec/webtransport/WebTransportCapsuleCodec.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
 #include <proxygen/lib/http/webtransport/WebTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -77,8 +77,9 @@ class WebTransportFilter
 
   void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
     if (sessionClosed_) {
-      XLOG(ERR) << "Received additional data after WT_CLOSE_SESSION capsule, "
-                << "resetting CONNECT stream with H3_MESSAGE_ERROR";
+      PRX_LOG(ERROR)
+          << "Received additional data after WT_CLOSE_SESSION capsule, "
+          << "resetting CONNECT stream with H3_MESSAGE_ERROR";
       if (txn_) {
         auto errorCode =
             hq::hqToHttpErrorCode(HTTP3::ErrorCode::HTTP_MESSAGE_ERROR);
@@ -347,72 +348,72 @@ class WebTransportFilter
   }
 
   void onConnectionError(CapsuleCodec::ErrorCode error) noexcept override {
-    XLOG(DBG1) << __func__ << " error=" << static_cast<int>(error);
+    PRX_VLOG(1) << __func__ << " error=" << static_cast<int>(error);
   }
   void onPadding(PaddingCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onResetStream(WTResetStreamCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onStopSending(WTStopSendingCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onStream(WTStreamCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onMaxData(WTMaxDataCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     if (wtImpl_) {
       wtImpl_->onMaxData(capsule.maximumData);
     }
   }
   void onMaxStreamData(WTMaxStreamDataCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onMaxStreamsBidi(WTMaxStreamsCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     maxWTBidiStreams_ = capsule.maximumStreams;
     if (wtImpl_) {
       wtImpl_->onMaxStreams(capsule.maximumStreams, true);
     }
   }
   void onMaxStreamsUni(WTMaxStreamsCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     maxWTUniStreams_ = capsule.maximumStreams;
     if (wtImpl_) {
       wtImpl_->onMaxStreams(capsule.maximumStreams, false);
     }
   }
   void onDataBlocked(WTDataBlockedCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     if (wtImpl_) {
       wtImpl_->onDataBlocked(capsule.maximumData);
     }
   }
   void onStreamDataBlocked(
       WTStreamDataBlockedCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onStreamsBlockedBidi(WTStreamsBlockedCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     if (wtImpl_) {
       wtImpl_->onStreamsBlocked(capsule.maximumStreams, true);
     }
   }
   void onStreamsBlockedUni(WTStreamsBlockedCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     if (wtImpl_) {
       wtImpl_->onStreamsBlocked(capsule.maximumStreams, false);
     }
   }
   void onDatagram(DatagramCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
   }
   void onCloseSession(
       CloseWebTransportSessionCapsule capsule) noexcept override {
-    XLOG(DBG1) << __func__ << " errorCode=" << capsule.applicationErrorCode
-               << " message=" << capsule.applicationErrorMessage;
+    PRX_VLOG(1) << __func__ << " errorCode=" << capsule.applicationErrorCode
+                << " message=" << capsule.applicationErrorMessage;
 
     if (wtImpl_) {
       wtImpl_->terminateSession(capsule.applicationErrorCode);
@@ -431,7 +432,7 @@ class WebTransportFilter
   }
   void onDrainSession(
       DrainWebTransportSessionCapsule /*capsule*/) noexcept override {
-    XLOG(DBG1) << __func__;
+    PRX_VLOG(1) << __func__;
     if (handler_) {
       handler_->onSessionDrain();
     }
diff --git a/proxygen/lib/http/session/test/DownstreamTransactionTest.cpp b/proxygen/lib/http/session/test/DownstreamTransactionTest.cpp
index 2a0fd83478..4de4d5e033 100644
--- a/proxygen/lib/http/session/test/DownstreamTransactionTest.cpp
+++ b/proxygen/lib/http/session/test/DownstreamTransactionTest.cpp
@@ -13,6 +13,7 @@
 #include <proxygen/lib/http/codec/test/TestUtils.h>
 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
 #include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace testing;
@@ -62,7 +63,7 @@ class DownstreamTransactionTest : public testing::Test {
     } else {
       EXPECT_CALL(transport_, sendEOM(txn, _))
           .WillOnce(InvokeWithoutArgs([=, this]() {
-            CHECK_EQ(sent_, size);
+            PRX_CHECK_EQ(sent_, size);
             txn->onIngressBody(makeBuf(size), 0);
             txn->onIngressEOM();
             return 5;
@@ -74,7 +75,7 @@ class DownstreamTransactionTest : public testing::Test {
               received_ += body->computeChainDataLength();
             }));
     EXPECT_CALL(handler_, _onEOM()).WillOnce(InvokeWithoutArgs([=, this] {
-      CHECK_EQ(received_, size);
+      PRX_CHECK_EQ(received_, size);
     }));
     EXPECT_CALL(transport_, notifyPendingEgress())
         .WillOnce(InvokeWithoutArgs([=] { txn->onWriteReady(size, 1); }))
diff --git a/proxygen/lib/http/session/test/HQDownstreamSessionTest.cpp b/proxygen/lib/http/session/test/HQDownstreamSessionTest.cpp
index 95fd75802f..531c50500d 100644
--- a/proxygen/lib/http/session/test/HQDownstreamSessionTest.cpp
+++ b/proxygen/lib/http/session/test/HQDownstreamSessionTest.cpp
@@ -25,6 +25,7 @@
 
 #include <folly/futures/Future.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::hq;
@@ -166,9 +167,9 @@ void HQDownstreamSessionTest::flushRequestsAndWaitForReads(
     std::chrono::milliseconds initialDelay,
     std::function<void()> extraEventsFn) {
   while (!flushRequests(eof, eofDelay, initialDelay, extraEventsFn)) {
-    CHECK(eventBase_.loop());
+    PRX_CHECK(eventBase_.loop());
   }
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
 }
 
 void HQDownstreamSessionTest::flushRequestsAndLoop(
@@ -177,7 +178,7 @@ void HQDownstreamSessionTest::flushRequestsAndLoop(
     std::chrono::milliseconds initialDelay,
     std::function<void()> extraEventsFn) {
   flushRequests(eof, eofDelay, initialDelay, extraEventsFn);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
 }
 
 void HQDownstreamSessionTest::flushRequestsAndLoopN(
@@ -250,7 +251,7 @@ std::unique_ptr<proxygen::HTTPCodec> HQDownstreamSessionTest::makeCodec(
 HQDownstreamSessionTest::ClientStream& HQDownstreamSessionTest::getStream(
     proxygen::HTTPCodec::StreamID id) {
   auto it = requests_.find(id);
-  CHECK(it != requests_.end());
+  PRX_CHECK(it != requests_.end());
   return it->second;
 }
 
@@ -305,7 +306,7 @@ TEST_P(HQDownstreamSessionTest, SimpleGet) {
   EXPECT_GT(socketDriver_->streams_[idh.first].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[idh.first].writeEOF);
   // Checks that the server response is sent using the QPACK dynamic table
-  CHECK_GE(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0);
+  PRX_CHECK_GE(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0u);
   hqSession_->closeWhenIdle();
 }
 
@@ -477,7 +478,7 @@ TEST_P(HQDownstreamSessionTest, OnPriorityCallback) {
   hqSession_->onPriority(0, HTTPPriority(3, false));
   socketDriver_->expectSetPriority(0, Priority(3, false));
   auto id = sendRequest(getProgressiveGetRequest());
-  CHECK_EQ(id, 0);
+  PRX_CHECK_EQ(id, 0u);
   auto handler = addSimpleStrictHandler();
   handler->expectHeaders([&]() {
     handler->sendHeaders(200, 1000);
@@ -731,7 +732,7 @@ TEST_P(HQDownstreamSessionTest, OnFlowControlUpdate) {
   socketDriver_->expectStreamWritesPaused(id);
   // Open the flow control window
   socketDriver_->getSocket()->setStreamFlowControlWindow(id, 200);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GT(socketDriver_->streams_[id].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -772,7 +773,7 @@ TEST_P(HQDownstreamSessionTest, OnConnectionWindowPartialHeaders) {
   EXPECT_FALSE(socketDriver_->streams_[id].writeEOF);
   // Open the flow control window
   socketDriver_->getSocket()->setConnectionFlowControlWindow(200);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GT(socketDriver_->streams_[id].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -805,7 +806,7 @@ TEST_P(HQDownstreamSessionTest, OnConnectionWindowPartialBody) {
   // Open the flow control window
   socketDriver_->getSocket()->setConnectionFlowControlWindow(200 +
                                                              numCtrlStreams_);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GT(socketDriver_->streams_[id].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -827,7 +828,7 @@ TEST_P(HQDownstreamSessionTest, SeparateEom) {
 
   handler->sendEOM();
   // Open the flow control window
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GT(socketDriver_->streams_[id].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -935,7 +936,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomBuffered) {
   // the codec
   socketDriver_->setStreamFlowControlWindow(id, estimatedSize - bytesWithheld);
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(),
             estimatedSize - bytesWithheld);
   EXPECT_FALSE(socketDriver_->streams_[id].writeEOF);
@@ -943,7 +944,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomBuffered) {
   handler->expectDetachTransaction();
   socketDriver_->getSocket()->setStreamFlowControlWindow(id, estimatedSize);
 
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(), estimatedSize);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -959,7 +960,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushed) {
   size_t eomSize = 0;
   std::tie(estimatedSize, framingOverhead, eomSize) =
       estimateResponseSize(true, *reply, 1, 0);
-  CHECK_EQ(eomSize, 0);
+  PRX_CHECK_EQ(eomSize, 0u);
   auto bytesWithheld = framingOverhead;
 
   auto id = sendRequest(getGetRequest());
@@ -974,7 +975,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushed) {
   });
 
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(),
             estimatedSize - bytesWithheld);
   EXPECT_FALSE(socketDriver_->streams_[id].writeEOF);
@@ -982,7 +983,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushed) {
   handler->expectDetachTransaction();
   socketDriver_->getSocket()->setStreamFlowControlWindow(id, estimatedSize);
 
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(), estimatedSize);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -991,7 +992,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushed) {
 TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushedConn) {
   // flush control streams first
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
 
   auto reply = makeResponse(200);
   reply->setWantsKeepalive(true);
@@ -1018,7 +1019,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushedConn) {
   // for the framing overhead
   auto remaining = framingOverhead + eomSize;
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(),
             estimatedSize - remaining);
   EXPECT_FALSE(socketDriver_->streams_[id].writeEOF);
@@ -1027,7 +1028,7 @@ TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushedConn) {
   for (size_t i = 0; i < remaining; i++) {
     socketDriver_->getSocket()->setConnectionFlowControlWindow(1);
 
-    CHECK(eventBase_.loop());
+    PRX_CHECK(eventBase_.loop());
     EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(),
               estimatedSize - remaining + i);
 
@@ -1053,7 +1054,7 @@ TEST_P(HQDownstreamSessionTest, SendEomLaterChunked) {
   handler->expectDetachTransaction();
 
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(), contentLength);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -1071,7 +1072,7 @@ TEST_P(HQDownstreamSessionTest, SendEomLater) {
   handler->expectDetachTransaction();
 
   flushRequestsAndLoop();
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
   EXPECT_GE(socketDriver_->streams_[id].writeBuf.chainLength(), contentLength);
   EXPECT_TRUE(socketDriver_->streams_[id].writeEOF);
   hqSession_->closeWhenIdle();
@@ -1327,7 +1328,7 @@ TEST_P(HQDownstreamSessionTest, ConnectionErrorIdle) {
 TEST_P(HQDownstreamSessionTest, ConnectionEnd) {
   nextStreamId();
   socketDriver_->addOnConnectionEndEvent(10);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
 }
 
 TEST_P(HQDownstreamSessionTest, BadHttpHeaders) {
@@ -2387,9 +2388,9 @@ TEST_P(HQDownstreamSessionTest, ProcessReadDataOnDetachedStream) {
           // schedule a few events to run in the eventbase back-to-back
           // call readAvailable with just the EOF
           auto& stream = socketDriver_->streams_[id];
-          CHECK(!stream.readEOF);
+          PRX_CHECK(!stream.readEOF);
           stream.readEOF = true;
-          CHECK(stream.readCB);
+          PRX_CHECK(stream.readCB);
           stream.readCB->readAvailable(id);
           // now send an error so that the stream gets marked for detach
           stream.readCB->readError(
@@ -2427,7 +2428,7 @@ TEST_P(HQDownstreamSessionTestNoSettings, SimpleGet) {
   EXPECT_GT(socketDriver_->streams_[idh.first].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[idh.first].writeEOF);
   // Checks that the server response is sent without the QPACK dynamic table
-  CHECK_EQ(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0);
+  PRX_CHECK_EQ(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0u);
 
   // TODO: Check that QPACK does not use the dynamic table for the response
   hqSession_->closeWhenIdle();
@@ -2551,7 +2552,7 @@ TEST_P(HQDownstreamSessionTest, StopSendingOnUnknownUnidirectionalStreams) {
   EXPECT_GT(socketDriver_->streams_[idh.first].writeBuf.chainLength(), 110);
   EXPECT_TRUE(socketDriver_->streams_[idh.first].writeEOF);
   // Checks that the server response is sent using the QPACK dynamic table
-  CHECK_GE(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0);
+  PRX_CHECK_GE(qpackCodec_.getCompressionInfo().ingress.headerTableSize_, 0u);
   hqSession_->closeWhenIdle();
 }
 
@@ -3012,7 +3013,7 @@ TEST_P(HQDownstreamSessionTestPush, SimplePush) {
     // Generate a push request (PUSH_PROMISE)
     pushTxn->sendHeaders(promiseReq);
     pushStreamId = pushTxn->getID();
-    LOG(INFO) << "pushStreamId=" << pushStreamId;
+    PRX_LOG(INFO) << "pushStreamId=" << pushStreamId;
     pushTxn->sendHeaders(res);
     pushTxn->sendBody(makeBuf(200));
     pushTxn->sendEOM();
@@ -3114,7 +3115,7 @@ TEST_P(HQDownstreamSessionTestPush, StopSending) {
     // Generate a push request (PUSH_PROMISE)
     pushTxn->sendHeaders(req);
     pushStreamId = pushTxn->getID();
-    LOG(INFO) << "pushStreamId=" << pushStreamId;
+    PRX_LOG(INFO) << "pushStreamId=" << pushStreamId;
     pushTxn->sendHeaders(res);
     pushTxn->sendBody(makeBuf(200));
     // NO EOM
@@ -3240,8 +3241,8 @@ TEST_P(HQDownstreamSessionTestDeliveryAck,
                 it->second.nextWriteOffset >= offset) {
               return quic::make_unexpected(LocalErrorCode::STREAM_NOT_EXISTS);
             }
-            CHECK_NE(it->second.writeState,
-                     MockQuicSocketDriver::StateEnum::CLOSED);
+            PRX_CHECK_NE(it->second.writeState,
+                         MockQuicSocketDriver::StateEnum::CLOSED);
             it->second.deliveryCallbacks.emplace_back(offset, cb);
             return {};
           }));
@@ -3401,8 +3402,8 @@ TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyDeliveryErr) {
                 it->second.nextWriteOffset >= offset) {
               return quic::make_unexpected(LocalErrorCode::STREAM_NOT_EXISTS);
             }
-            CHECK_NE(it->second.writeState,
-                     MockQuicSocketDriver::StateEnum::CLOSED);
+            PRX_CHECK_NE(it->second.writeState,
+                         MockQuicSocketDriver::StateEnum::CLOSED);
             it->second.deliveryCallbacks.emplace_back(offset, cb);
             return {};
           }));
diff --git a/proxygen/lib/http/session/test/HQSessionMocks.h b/proxygen/lib/http/session/test/HQSessionMocks.h
index f2a1ffed9c..add8a3f3cb 100644
--- a/proxygen/lib/http/session/test/HQSessionMocks.h
+++ b/proxygen/lib/http/session/test/HQSessionMocks.h
@@ -14,6 +14,7 @@
 #include <proxygen/lib/http/session/HQStreamDispatcher.h>
 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
 #include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -221,7 +222,7 @@ class MockHQSession : public HQSession {
         direction_(direction.value_or(getMockDefaultDirection())),
         quicProtocolInfo_(std::make_shared<QuicProtocolInfo>()),
         quicStreamProtocolInfo_(std::make_shared<QuicStreamProtocolInfo>()) {
-    LOG(INFO) << "Creating mock transaction on stream " << lastStreamId_;
+    PRX_LOG(INFO) << "Creating mock transaction on stream " << lastStreamId_;
     makeMockTransaction(lastStreamId_++);
 
     ON_CALL(*this, newTransaction(::testing::_))
@@ -229,8 +230,8 @@ class MockHQSession : public HQSession {
             ::testing::SaveArg<0>(&handler_),
             ::testing::WithArgs<0>(
                 ::testing::Invoke([&](HTTPTransaction::Handler* handler) {
-                  CHECK(txn_);
-                  LOG(INFO) << "Setting transaction handler to " << handler;
+                  PRX_CHECK(txn_);
+                  PRX_LOG(INFO) << "Setting transaction handler to " << handler;
                   txn_->HTTPTransaction::setHandler(handler);
                 })),
             ::testing::Return(txn_.get())));
@@ -301,7 +302,7 @@ class MockHQSession : public HQSession {
   MOCK_CONST_METHOD0(getQuicSocket, quic::QuicSocket*());
 
   MockHTTPTransaction* makeMockTransaction(HTTPCodec::StreamID id) {
-    LOG(INFO) << "Creating mocked transaction on stream " << id;
+    PRX_LOG(INFO) << "Creating mocked transaction on stream " << id;
 
     txn_ = std::make_unique<::testing::StrictMock<MockHTTPTransaction>>(
         direction_,
@@ -311,13 +312,13 @@ class MockHQSession : public HQSession {
         nullptr, /* timer */
         transactionTimeout_);
 
-    LOG(INFO) << "Setting default handlers on the new transaction "
-              << txn_.get();
+    PRX_LOG(INFO) << "Setting default handlers on the new transaction "
+                  << txn_.get();
 
     EXPECT_CALL(*txn_, setHandler(::testing::_))
         .WillRepeatedly(
             ::testing::Invoke([txn = txn_.get()](HTTPTransactionHandler* hdlr) {
-              LOG(INFO) << "Setting handler on " << txn << " to " << hdlr;
+              PRX_LOG(INFO) << "Setting handler on " << txn << " to " << hdlr;
               txn->HTTPTransaction::setHandler(hdlr);
             }));
 
@@ -336,7 +337,7 @@ class MockHQSession : public HQSession {
                 })),
             ::testing::Return(true)));
 
-    LOG(INFO) << "Returning the new mocked transaction " << txn_.get();
+    PRX_LOG(INFO) << "Returning the new mocked transaction " << txn_.get();
 
     return txn_.get();
   }
diff --git a/proxygen/lib/http/session/test/HQSessionTestCommon.cpp b/proxygen/lib/http/session/test/HQSessionTestCommon.cpp
index 0d1af53974..aefc29f6af 100644
--- a/proxygen/lib/http/session/test/HQSessionTestCommon.cpp
+++ b/proxygen/lib/http/session/test/HQSessionTestCommon.cpp
@@ -11,6 +11,7 @@
 
 #include <folly/Random.h>
 #include <folly/String.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::hq;
@@ -18,9 +19,9 @@ using namespace proxygen::hq;
 size_t encodeQuicIntegerWithAtLeast(uint64_t value,
                                     uint8_t atLeast,
                                     folly::io::QueueAppender& appender) {
-  CHECK(atLeast == 1 || atLeast == 2 || atLeast == 4 || atLeast == 8);
+  PRX_CHECK(atLeast == 1 || atLeast == 2 || atLeast == 4 || atLeast == 8);
 
-  CHECK_LE(value, quic::kEightByteLimit);
+  PRX_CHECK_LE(value, quic::kEightByteLimit);
   uint8_t numBytes = 0;
   if (value <= quic::kOneByteLimit) {
     numBytes = 1;
@@ -31,9 +32,9 @@ size_t encodeQuicIntegerWithAtLeast(uint64_t value,
   } else if (value <= quic::kEightByteLimit) {
     numBytes = 8;
   }
-  CHECK_NE(numBytes, 0);
+  PRX_CHECK_NE(numBytes, 0);
   numBytes = std::max(numBytes, atLeast);
-  CHECK(numBytes == 1 || numBytes == 2 || numBytes == 4 || numBytes == 8);
+  PRX_CHECK(numBytes == 1 || numBytes == 2 || numBytes == 4 || numBytes == 8);
   if (numBytes == 1) {
     auto modified = static_cast<uint8_t>(value);
     appender.writeBE<uint8_t>(modified);
@@ -53,7 +54,7 @@ size_t encodeQuicIntegerWithAtLeast(uint64_t value,
     appender.writeBE<uint64_t>(modified);
     return sizeof(modified);
   }
-  CHECK(false);
+  PRX_CHECK(false);
 }
 
 size_t generateStreamPreface(folly::IOBufQueue& writeBuf,
@@ -62,7 +63,7 @@ size_t generateStreamPreface(folly::IOBufQueue& writeBuf,
   uint8_t size = 1 << (folly::Random::rand32() % 4);
   auto bytesWritten = encodeQuicIntegerWithAtLeast(
       static_cast<hq::StreamTypeType>(type), size, appender);
-  CHECK_GE(bytesWritten, size);
+  PRX_CHECK_GE(bytesWritten, size);
   return bytesWritten;
 }
 
@@ -141,7 +142,7 @@ void createControlStream(quic::MockQuicSocketDriver* socketDriver,
                          UnidirectionalStreamType streamType) {
   folly::IOBufQueue writeBuf{folly::IOBufQueue::cacheChainLength()};
   auto length = generateStreamPreface(writeBuf, streamType);
-  CHECK_EQ(length, writeBuf.chainLength());
+  PRX_CHECK_EQ(length, writeBuf.chainLength());
   socketDriver->sock_->setControlStream(id);
   for (size_t i = 0; i < length; i++) {
     socketDriver->addReadEvent(
@@ -154,7 +155,7 @@ bool HQSessionTest::WtStreams::streamExists(quic::StreamId id) const noexcept {
 }
 
 void HQSessionTest::WtStreams::addStream(quic::StreamId id) noexcept {
-  CHECK(!streamExists(id));
+  PRX_CHECK(!streamExists(id));
   streams_.emplace(id, Ctx{});
 }
 
@@ -169,7 +170,7 @@ void HQSessionTest::WtStreams::waitForWtStream(folly::EventBase& evb,
 // loops evb until *new* data is received by a stream
 void HQSessionTest::WtStreams::waitForWtStreamData(folly::EventBase& evb,
                                                    quic::StreamId id) noexcept {
-  CHECK(streamExists(id));
+  PRX_CHECK(streamExists(id));
   auto& stream = streams_[id];
   auto computeBytesFn = [&stream]() {
     return stream.bufferedData.chainLength() + stream.eom;
@@ -193,7 +194,7 @@ void HQSessionTest::WtStreams::appendData(quic::StreamId id,
 
 auto HQSessionTest::WtStreams::moveData(quic::StreamId id) noexcept
     -> BufferedData {
-  CHECK(streamExists(id));
+  PRX_CHECK(streamExists(id));
   auto& stream = streams_[id];
   return {stream.bufferedData.move(), stream.eom};
 }
diff --git a/proxygen/lib/http/session/test/HQSessionTestCommon.h b/proxygen/lib/http/session/test/HQSessionTestCommon.h
index 646b02b25e..263fba805a 100644
--- a/proxygen/lib/http/session/test/HQSessionTestCommon.h
+++ b/proxygen/lib/http/session/test/HQSessionTestCommon.h
@@ -21,6 +21,7 @@
 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
 #include <proxygen/lib/http/session/test/MockQuicSocketDriver.h>
 #include <proxygen/lib/http/session/test/TestUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 constexpr unsigned int kTransactionTimeout = 500;
@@ -118,7 +119,7 @@ class HQSessionTest
           nullptr);
       nextUnidirectionalStreamId_ = 3;
     } else {
-      LOG(FATAL) << "wrong TransportEnum";
+      PRX_LOG(FATAL) << "wrong TransportEnum";
     }
 
     if (GetParam().datagrams_) {
@@ -240,7 +241,7 @@ class HQSessionTest
   void readCallback(quic::StreamId id,
                     std::unique_ptr<folly::IOBuf> buf,
                     bool eof) override {
-    CHECK(buf);
+    PRX_CHECK(buf);
     if (wtStreams_.streamExists(id)) {
       wtStreams_.appendData(id, std::move(buf), eof);
       return;
@@ -271,8 +272,8 @@ class HQSessionTest
     if (it == controlStreams_.end()) {
       folly::io::Cursor cursor(buf.get());
       auto preface = parseUniStreamPreface(cursor, getProtocolString());
-      CHECK(preface) << "Preface can not be parsed protocolString="
-                     << getProtocolString();
+      PRX_CHECK(preface) << "Preface can not be parsed protocolString="
+                         << getProtocolString();
       switch (preface->first) {
         case proxygen::hq::UnidirectionalStreamType::CONTROL:
           ingressControlCodec_ = std::make_unique<proxygen::hq::HQControlCodec>(
@@ -301,7 +302,7 @@ class HQSessionTest
           wtStreams_.appendData(id, std::move(buf), eof);
           return;
         default:
-          CHECK(false) << "Unknown stream preface=" << preface->first;
+          PRX_CHECK(false) << "Unknown stream preface=" << preface->first;
       }
       socketDriver_->sock_->setControlStream(id);
       auto res = controlStreams_.emplace(id, preface->first);
@@ -324,19 +325,19 @@ class HQSessionTest
         parseReadData(&qpackDecoderCodec_, decoderReadBuf_, std::move(buf));
         break;
       case proxygen::hq::UnidirectionalStreamType::PUSH:
-        VLOG(4) << "Ingress push streams should not go through "
-                << "the unidirectional read path";
+        PRX_VLOG(4) << "Ingress push streams should not go through "
+                    << "the unidirectional read path";
         break;
       default:
-        CHECK(false) << "Unknown stream type=" << it->second;
+        PRX_CHECK(false) << "Unknown stream type=" << it->second;
     }
   }
 
   void onError(proxygen::HTTPCodec::StreamID streamID,
                const proxygen::HTTPException& error,
                bool /*newTxn*/) override {
-    LOG(FATAL) << __func__ << " streamID=" << streamID
-               << " error=" << error.what();
+    PRX_LOG(FATAL) << __func__ << " streamID=" << streamID
+                   << " error=" << error.what();
   }
 
   quic::StreamId nextUnidirectionalStreamId() {
diff --git a/proxygen/lib/http/session/test/HQUpstreamSessionTest.cpp b/proxygen/lib/http/session/test/HQUpstreamSessionTest.cpp
index 14688f1809..994bc20bdf 100644
--- a/proxygen/lib/http/session/test/HQUpstreamSessionTest.cpp
+++ b/proxygen/lib/http/session/test/HQUpstreamSessionTest.cpp
@@ -26,6 +26,7 @@
 #include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
 #include <proxygen/lib/http/session/test/MockQuicSocketDriver.h>
 #include <proxygen/lib/http/session/test/MockSessionObserver.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/test/MockQuicSocket.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 
@@ -77,7 +78,7 @@ void HQUpstreamSessionTest::sendPartialBody(quic::StreamId id,
                                             std::unique_ptr<folly::IOBuf> body,
                                             bool eom) {
   auto it = streams_.find(id);
-  CHECK(it != streams_.end());
+  PRX_CHECK(it != streams_.end());
   auto& stream = it->second;
 
   stream.readEOF = eom;
@@ -151,7 +152,7 @@ void HQUpstreamSessionTest::flushAndLoop(bool eof,
                                          milliseconds initialDelay,
                                          std::function<void()> extraEventsFn) {
   flush(eof, eofDelay, initialDelay, extraEventsFn);
-  CHECK(eventBase_.loop());
+  PRX_CHECK(eventBase_.loop());
 }
 
 void HQUpstreamSessionTest::flushAndLoopN(uint64_t n,
@@ -257,7 +258,7 @@ TEST_P(HQUpstreamSessionTest, GetWithTrailers) {
   auto id = handler->txn_->getID();
   sendResponse(id, *std::get<0>(resp), std::move(std::get<1>(resp)), false);
   auto it = streams_.find(id);
-  CHECK(it != streams_.end());
+  PRX_CHECK(it != streams_.end());
   auto& stream = it->second;
   trailers.remove("x-trailer-1");
   trailers.add("x-trailer-2", "trailer2");
@@ -285,7 +286,7 @@ TEST_P(HQUpstreamSessionTest, AbortOnBodyWithBlockedQPACKTrailers) {
   auto control1 = encoderWriteBuf_.move();
   flushAndLoopN(1);
   auto it = streams_.find(id);
-  CHECK(it != streams_.end());
+  PRX_CHECK(it != streams_.end());
   auto& stream = it->second;
   trailers.remove("x-trailer-1");
   trailers.add("x-trailer-2", "trailer2");
@@ -1006,9 +1007,9 @@ TEST_P(HQUpstreamSessionTest, DelayedQPACKAfterReset) {
   });
 
   auto streamIt1 = streams_.find(handler1->txn_->getID());
-  CHECK(streamIt1 != streams_.end());
+  PRX_CHECK(streamIt1 != streams_.end());
   auto streamIt2 = streams_.find(handler2->txn_->getID());
-  CHECK(streamIt2 != streams_.end());
+  PRX_CHECK(streamIt2 != streams_.end());
   // add all the events in the same callback, with the stream data coming
   // before the QPACK data
   std::vector<MockQuicSocketDriver::ReadEvent> events;
@@ -1384,7 +1385,7 @@ class HQUpstreamSessionTestPush : public HQUpstreamSessionTest {
 
     auto eventbuf = tmpbuf.splitAtMost(maxlen);
     auto wlen = eventbuf->length();
-    CHECK_LE(wlen, maxlen) << "The written len must not exceed the max len";
+    PRX_CHECK_LE(wlen, maxlen) << "The written len must not exceed the max len";
     socketDriver_->addReadEvent(id, std::move(eventbuf), milliseconds(0));
     return wlen;
   }
@@ -1407,7 +1408,7 @@ class HQUpstreamSessionTestPush : public HQUpstreamSessionTest {
       folly::io::QueueAppender appender(&outbuf, 8);
       uint8_t size = 1 << (folly::Random::rand32() % 4);
       auto wlen = encodeQuicIntegerWithAtLeast(pushId, size, appender);
-      CHECK_GE(wlen, size);
+      PRX_CHECK_GE(wlen, size);
       return wlen;
     };
 
@@ -2104,7 +2105,7 @@ TEST_P(HQUpstreamSessionTestDatagram, TestReceiveDatagram) {
   handler->expectDatagram();
   flushAndLoopN(1);
   auto it = streams_.find(id);
-  CHECK(it != streams_.end());
+  PRX_CHECK(it != streams_.end());
   auto& stream = it->second;
   stream.readEOF = true;
   handler->expectEOM();
@@ -2133,7 +2134,7 @@ TEST_P(HQUpstreamSessionTestDatagram, TestReceiveEarlyDatagramsSingleStream) {
       .Times(kDefaultMaxBufferedDatagrams);
   flushAndLoopN(1);
   auto it = streams_.find(id);
-  CHECK(it != streams_.end());
+  PRX_CHECK(it != streams_.end());
   auto& stream = it->second;
   stream.readEOF = true;
   handler->expectEOM();
@@ -2169,7 +2170,7 @@ TEST_P(HQUpstreamSessionTestDatagram, TestReceiveEarlyDatagramsMultiStream) {
         .WillRepeatedly(InvokeWithoutArgs([&]() { deliveredDatagrams++; }));
     flushAndLoopN(1);
     auto it = streams_.find(id);
-    CHECK(it != streams_.end());
+    PRX_CHECK(it != streams_.end());
     auto& stream = it->second;
     stream.readEOF = true;
     handler->expectEOM();
@@ -2344,7 +2345,7 @@ TEST_P(HQUpstreamSessionTestWebTransport, BidirectionalStream) {
       .value()
       .via(&eventBase_)
       .then([&, writeHandle, cancelToken](const auto&) {
-        VLOG(4) << "big write complete";
+        PRX_VLOG(4) << "big write complete";
         if (!cancelToken.isCancellationRequested()) {
           // after it completes, write FIN
           writeHandle->writeStreamData(nullptr, true, nullptr);
@@ -2353,14 +2354,14 @@ TEST_P(HQUpstreamSessionTestWebTransport, BidirectionalStream) {
             .value()
             .via(&eventBase_)
             .then([&](auto) {
-              VLOG(4) << "fin write complete";
+              PRX_VLOG(4) << "fin write complete";
               writeComplete = true;
             });
         // ug, can't determine fin write complete;
 #endif
           writeComplete = true;
         } else {
-          VLOG(4) << "Stream was cancelled, skipping FIN write";
+          PRX_VLOG(4) << "Stream was cancelled, skipping FIN write";
           writeComplete = true;
         }
       });
@@ -2376,34 +2377,34 @@ TEST_P(HQUpstreamSessionTestWebTransport, BidirectionalStream) {
 
   // Wait for a read
   stream.readHandle->awaitNextRead(&eventBase_, [&](auto, auto, auto) {
-    VLOG(4) << "read 1, adding 70k";
+    PRX_VLOG(4) << "read 1, adding 70k";
     // Now add a big buf, which will pause ingress
     socketDriver_->addReadEvent(
         id, makeBuf(70000), std::chrono::milliseconds(0));
   });
   // add a small read to trigger the above handler
   socketDriver_->addReadEvent(id, makeBuf(10), std::chrono::milliseconds(0));
-  VLOG(4) << "flushLoop 1";
+  PRX_VLOG(4) << "flushLoop 1";
   flushAndLoopN(4);
   EXPECT_TRUE(socketDriver_->isStreamPaused(id));
 
   // Read again
   stream.readHandle->awaitNextRead(
       &eventBase_, [&](auto, auto, auto streamData) {
-        VLOG(4) << "read 2, adding EOF";
+        PRX_VLOG(4) << "read 2, adding EOF";
         EXPECT_EQ(streamData->data->computeChainDataLength(), 65535);
         // Add EOF and wait for it
         socketDriver_->addReadEOF(id, std::chrono::milliseconds(0));
       });
-  VLOG(4) << "flushLoop 2";
+  PRX_VLOG(4) << "flushLoop 2";
   flushAndLoopN(2);
   stream.readHandle->awaitNextRead(
       &eventBase_, [&](auto, auto, auto streamData) {
-        LOG(INFO) << "read 3";
+        PRX_LOG(INFO) << "read 3";
         EXPECT_EQ(streamData->data->computeChainDataLength(), 4465);
         EXPECT_TRUE(streamData->fin);
       });
-  VLOG(4) << "flushLoop 3";
+  PRX_VLOG(4) << "flushLoop 3";
   flushAndLoopN(1);
   closeWTSession();
 }
@@ -2573,7 +2574,7 @@ TEST_P(HQUpstreamSessionTestWebTransport, CloseSessionCapsuleWithStreams) {
   // Send data using a bidi stream, then try to close the WebTransport session.
   auto bidiStream = wt_->createBidiStream().value();
   auto bidiStreamId = bidiStream.readHandle->getID();
-  VLOG(4) << "Created bidi stream with ID: " << bidiStreamId;
+  PRX_VLOG(4) << "Created bidi stream with ID: " << bidiStreamId;
 
   auto wtImpl = dynamic_cast<WebTransportImpl*>(wt_);
   ASSERT_NE(wtImpl, nullptr);
@@ -2585,13 +2586,13 @@ TEST_P(HQUpstreamSessionTestWebTransport, CloseSessionCapsuleWithStreams) {
       bidiStream.writeHandle->writeStreamData(makeBuf(100), false, nullptr);
   EXPECT_TRUE(writeRes.hasValue());
   eventBase_.loopOnce();
-  VLOG(4) << "Successfully wrote 100 bytes to bidi stream";
+  PRX_VLOG(4) << "Successfully wrote 100 bytes to bidi stream";
 
   bool dataReceived = false;
   bidiStream.readHandle->awaitNextRead(
       &eventBase_, [&](auto, auto, auto streamData) {
-        VLOG(4) << "Received " << streamData->data->computeChainDataLength()
-                << " bytes on bidi stream";
+        PRX_VLOG(4) << "Received " << streamData->data->computeChainDataLength()
+                    << " bytes on bidi stream";
         EXPECT_EQ(streamData->data->computeChainDataLength(), 50);
         dataReceived = true;
       });
@@ -2962,11 +2963,11 @@ class H3WtUpstreamTest : public HQUpstreamSessionTest {
     wt.handlerCtx = wtHandler->ctx;
     auto wtReq =
         upstreamSession()->sendWebTransportRequest(req, std::move(wtHandler));
-    CHECK(!wtReq.isReady());
+    PRX_CHECK(!wtReq.isReady());
     loopN(2);
 
     // ::onWebTransportSession notified prior to 2xx
-    CHECK(wt.handlerCtx->wtSession);
+    PRX_CHECK(wt.handlerCtx->wtSession);
 
     // notify HqSession of datagrams, verify buffering simulating reordering
     socketDriver_->addDatagram(getH3Datagram(0, makeBuf(10), folly::none));
@@ -2979,7 +2980,7 @@ class H3WtUpstreamTest : public HQUpstreamSessionTest {
 
     // wait for session to parse/receive resp
     auto res = waitForFut(std::move(wtReq), eventBase_);
-    CHECK(res.hasValue());
+    PRX_CHECK(res.hasValue());
     EXPECT_EQ(res.value()->getStatusCode(), 200);
     wt.sess = std::move(wt.handlerCtx->wtSession);
     loopN(1);
@@ -3039,7 +3040,7 @@ TEST_P(H3WtUpstreamTest, SimpleUniEgress) {
   EXPECT_TRUE(wt.sess->awaitUniStreamCredit().isReady());
   // peer advertised uni credit => ::createUniStream now yields handle
   createStream = wt.sess->createUniStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto* wh = createStream.value();
   auto id = wh->getID();
   socketDriver_->setStreamFlowControlWindow(id, kLargeFc);
@@ -3143,7 +3144,7 @@ TEST_P(H3WtUpstreamTest, SimpleBidiEcho) {
 
   // peer advertised bidi credit => ::createBidiStream now yields handle
   createStream = wt.sess->createBidiStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto handle = createStream.value();
   auto id = handle.readHandle->getID();
 
@@ -3173,7 +3174,7 @@ TEST_P(H3WtUpstreamTest, SimpleBidiEcho) {
     socketDriver_->addReadEvent(id, buf->clone());
     // expect to client to rx same bytes
     auto read = waitForFut(wt.sess->readStreamData(id).value(), eventBase_);
-    CHECK(read.hasValue());
+    PRX_CHECK(read.hasValue());
     EXPECT_EQ(*read->data->data(), idx);
   }
 
@@ -3215,7 +3216,7 @@ TEST_P(H3WtUpstreamTest, ConnectStreamEom) {
 
   auto uni = wt.sess->createUniStream();
   auto bidi = wt.sess->createBidiStream();
-  CHECK(uni && bidi);
+  PRX_CHECK(uni && bidi);
   uint64_t uniId = uni.value()->getID(), bidiId = bidi->writeHandle->getID();
 
   // ingress eom on connect stream => close
diff --git a/proxygen/lib/http/session/test/HTTP2PriorityQueueTest.cpp b/proxygen/lib/http/session/test/HTTP2PriorityQueueTest.cpp
index 80434bdfa1..657ae3fee6 100644
--- a/proxygen/lib/http/session/test/HTTP2PriorityQueueTest.cpp
+++ b/proxygen/lib/http/session/test/HTTP2PriorityQueueTest.cpp
@@ -15,6 +15,7 @@
 #include <folly/io/async/test/UndelayedDestruction.h>
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/http/session/HTTP2PriorityQueue.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace std::placeholders;
 using namespace testing;
@@ -691,7 +692,7 @@ TEST_F(QueueTest, ChromeTest) {
       HTTPCodec::StreamID dep = pris[pri];
       txn = nextId;
       nextId += 2;
-      VLOG(2) << "Adding txn=" << txn << " with dep=" << dep;
+      PRX_VLOG(2) << "Adding txn=" << txn << " with dep=" << dep;
       addTransaction(
           txn,
           {.streamDependency = (uint32_t)dep, .exclusive = true, .weight = 99});
@@ -701,7 +702,7 @@ TEST_F(QueueTest, ChromeTest) {
       // signal an inactive txn
       idx = rand32(inactive.size(), gen);
       txn = inactive[idx];
-      VLOG(2) << "Activating txn=" << txn;
+      PRX_VLOG(2) << "Activating txn=" << txn;
       signalEgress(txn, true);
       inactive.erase(inactive.begin() + idx);
       active.push_back(txn);
@@ -709,7 +710,7 @@ TEST_F(QueueTest, ChromeTest) {
       // clear an active transaction
       idx = rand32(active.size(), gen);
       txn = active[idx];
-      VLOG(2) << "Deactivating txn=" << txn;
+      PRX_VLOG(2) << "Deactivating txn=" << txn;
       signalEgress(txn, false);
       active.erase(active.begin() + idx);
       inactive.push_back(txn);
@@ -717,7 +718,7 @@ TEST_F(QueueTest, ChromeTest) {
       // remove a transaction
       idx = rand32(txns.size(), gen);
       txn = txns[idx];
-      VLOG(2) << "Removing txn=" << txn;
+      PRX_VLOG(2) << "Removing txn=" << txn;
       removeTransaction(txn);
       txns.erase(txns.begin() + idx);
       auto it = std::find(active.begin(), active.end(), txn);
@@ -729,7 +730,7 @@ TEST_F(QueueTest, ChromeTest) {
         inactive.erase(it);
       }
     }
-    VLOG(2) << "Active nodes=" << q_.numPendingEgress();
+    PRX_VLOG(2) << "Active nodes=" << q_.numPendingEgress();
     if (!q_.empty()) {
       nextEgress();
       EXPECT_GT(nodes_.size(), 0);
diff --git a/proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp b/proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp
index 90dec16e96..6eabd701aa 100644
--- a/proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp
+++ b/proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp
@@ -34,6 +34,7 @@
 #include <proxygen/lib/http/session/test/TestUtils.h>
 #include <proxygen/lib/http/webtransport/test/Mocks.h>
 #include <proxygen/lib/test/TestAsyncTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/ConnectionManager.h>
 
 using namespace proxygen;
@@ -2813,7 +2814,7 @@ TEST_F(HTTP2DownstreamSessionTest, NewTxnEgressPaused) {
       handler1->sendBody(750); // over the limit
       req2p.setValue();
     });
-    handler1->expectEgressPaused([] { LOG(INFO) << "paused 1"; });
+    handler1->expectEgressPaused([] { PRX_LOG(INFO) << "paused 1"; });
 
     handler2 = addSimpleStrictHandler();
     handler2->expectHeaders();
@@ -4152,7 +4153,7 @@ TEST_F(HTTPDownstreamSessionTest, InvariantViolation) {
 
   EXPECT_CALL(*handler, _onInvariantViolation(_)).WillOnce([&]() {
     // invariantViolation callback can send headers if allowed
-    CHECK(txn->canSendHeaders());
+    PRX_CHECK(txn->canSendHeaders());
     txn->sendHeaders(getResponse(500, 0));
   });
 
@@ -4214,7 +4215,7 @@ TEST_F(HTTP2DownstreamSessionTest, InvariantViolation) {
 
   EXPECT_CALL(*handler, _onInvariantViolation(_)).WillOnce([&]() {
     // invariantViolation callback can send headers if allowed
-    CHECK(txn->canSendHeaders());
+    PRX_CHECK(txn->canSendHeaders());
     txn->sendHeaders(getResponse(500, 0));
     txn->sendEOM();
   });
diff --git a/proxygen/lib/http/session/test/HTTPSessionAcceptorTest.cpp b/proxygen/lib/http/session/test/HTTPSessionAcceptorTest.cpp
index 4d54db6b03..0363552b6f 100644
--- a/proxygen/lib/http/session/test/HTTPSessionAcceptorTest.cpp
+++ b/proxygen/lib/http/session/test/HTTPSessionAcceptorTest.cpp
@@ -15,6 +15,7 @@
 #include <folly/io/async/test/MockAsyncSocket.h>
 #include <folly/logging/xlog.h>
 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/TestUtils.h>
 
 using namespace proxygen;
diff --git a/proxygen/lib/http/session/test/HTTPSessionMocks.h b/proxygen/lib/http/session/test/HTTPSessionMocks.h
index 3e74e74104..ccbdc0e2e9 100644
--- a/proxygen/lib/http/session/test/HTTPSessionMocks.h
+++ b/proxygen/lib/http/session/test/HTTPSessionMocks.h
@@ -19,6 +19,7 @@
 #include <proxygen/lib/http/session/HTTPSessionStats.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
 #include <proxygen/lib/http/session/test/MockHTTPSessionStats.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -162,7 +163,7 @@ class MockHTTPHandler
   void setupInvariantViolation() {
     ON_CALL(*this, _onInvariantViolation(testing::_))
         .WillByDefault(testing::Invoke(
-            [](const HTTPException& ex) { LOG(FATAL) << ex.what(); }));
+            [](const HTTPException& ex) { PRX_LOG(FATAL) << ex.what(); }));
   }
 
   void setTransaction(HTTPTransaction* txn) noexcept override {
diff --git a/proxygen/lib/http/session/test/HTTPTransactionWebTransportTest.cpp b/proxygen/lib/http/session/test/HTTPTransactionWebTransportTest.cpp
index b9125b6151..30cd3de81a 100644
--- a/proxygen/lib/http/session/test/HTTPTransactionWebTransportTest.cpp
+++ b/proxygen/lib/http/session/test/HTTPTransactionWebTransportTest.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/session/HTTPTransaction.h>
 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
 #include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 using WTFCState = proxygen::WebTransport::FCState;
@@ -107,9 +108,9 @@ class HTTPTransactionWebTransportTest : public testing::Test {
       size_t expectedLength,
       bool expectFin,
       folly::Optional<uint32_t> expectedErrorCode = folly::none) {
-    VLOG(4) << __func__ << " expectException=" << uint64_t(expectException)
-            << " expectedLength=" << expectedLength
-            << " expectFin=" << expectFin;
+    PRX_VLOG(4) << __func__ << " expectException=" << uint64_t(expectException)
+                << " expectedLength=" << expectedLength
+                << " expectFin=" << expectFin;
     EXPECT_EQ(streamData.hasException(), expectException);
     if (expectException || streamData.hasException()) {
       if (expectedErrorCode) {
@@ -564,14 +565,14 @@ TEST_F(HTTPTransactionWebTransportTest, StreamDetachWithOpenStreams) {
             .thenValue([](auto) {})
             .thenError(folly::tag_t<const WebTransport::Exception&>{},
                        [](auto const& ex) {
-                         VLOG(4) << "readCancelled";
+                         PRX_VLOG(4) << "readCancelled";
                          EXPECT_EQ(ex.error, WebTransport::kInternalError);
                        });
         readCancelled = true;
       });
   folly::CancellationCallback writeCancel(res->writeHandle->getCancelToken(),
                                           [&] {
-                                            VLOG(4) << "writeCancelled";
+                                            PRX_VLOG(4) << "writeCancelled";
                                             writeCancelled = true;
                                           });
   HTTPException ex(HTTPException::Direction::INGRESS_AND_EGRESS, "aborted");
diff --git a/proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp b/proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp
index 84ce781c03..26c018b2aa 100644
--- a/proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp
+++ b/proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp
@@ -25,6 +25,7 @@
 #include <proxygen/lib/http/webtransport/WtUtils.h>
 #include <proxygen/lib/http/webtransport/test/Mocks.h>
 #include <proxygen/lib/test/TestAsyncTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/ConnectionManager.h>
 
 using folly::test::MockAsyncTransport;
@@ -221,14 +222,14 @@ class HTTPUpstreamTest
   }
 
   void readAndLoop(const uint8_t* input, size_t length) {
-    CHECK_NOTNULL(readCallback_);
+    PRX_CHECK_NOTNULL(readCallback_);
     void* buf;
     size_t bufSize;
     while (length > 0) {
       readCallback_->getReadBuffer(&buf, &bufSize);
       // This is somewhat specific to our implementation, but currently we
       // always return at least some space from getReadBuffer
-      CHECK_GT(bufSize, 0);
+      PRX_CHECK_GT(bufSize, 0u);
       bufSize = std::min(bufSize, length);
       memcpy(buf, input, bufSize);
       readCallback_->readDataAvailable(bufSize);
@@ -672,13 +673,13 @@ TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteNoError) {
   eventBase_.loop();
 
   // txn should still exist
-  CHECK_NOTNULL(handler->txn_);
+  PRX_CHECK_NOTNULL(handler->txn_);
 
   // resume ingress and loop again
   EXPECT_CALL(*handler, _onBodyWithOffset(_, _)).Times(1);
   EXPECT_CALL(*handler, _onEOM()).Times(1);
   handler->expectError([this](auto&& ex) {
-    CHECK(ex.hasCodecStatusCode());
+    PRX_CHECK(ex.hasCodecStatusCode());
     EXPECT_EQ(ex.getCodecStatusCode(), ErrorCode::NO_ERROR);
     eventBase_.terminateLoopSoon();
   });
@@ -686,7 +687,7 @@ TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteNoError) {
   eventBase_.loop();
 
   // txn should have detached here
-  CHECK(handler->txn_ == nullptr);
+  PRX_CHECK(handler->txn_ == nullptr);
 
   httpSession_->dropConnection();
 }
@@ -742,11 +743,11 @@ TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteCancelError) {
   eventBase_.loop();
 
   // txn should still exist
-  CHECK_NOTNULL(handler->txn_);
+  PRX_CHECK_NOTNULL(handler->txn_);
 
   // keep ingress paused; ErrorCode::CANCEL should invoke ::onError
   handler->expectError([this](auto&& ex) {
-    CHECK(ex.hasCodecStatusCode());
+    PRX_CHECK(ex.hasCodecStatusCode());
     EXPECT_EQ(ex.getCodecStatusCode(), ErrorCode::CANCEL);
     eventBase_.terminateLoopSoon();
   });
@@ -757,7 +758,7 @@ TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteCancelError) {
   readAndLoop(input->data(), input->length());
 
   // txn should have detached here
-  CHECK(handler->txn_ == nullptr);
+  PRX_CHECK(handler->txn_ == nullptr);
 
   httpSession_->dropConnection();
 }
@@ -849,8 +850,8 @@ void HTTPUpstreamTest<CodecPair>::testBasicRequest() {
       "Transfer-Encoding: chunked\r\n\r\n"
       "0\r\n\r\n");
 
-  CHECK(httpSession_->supportsMoreTransactions());
-  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
+  PRX_CHECK(httpSession_->supportsMoreTransactions());
+  PRX_CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0u);
 }
 
 TEST_F(HTTPUpstreamSessionTest, BasicRequest) {
@@ -927,8 +928,8 @@ TEST_F(HTTPUpstreamSessionTest, TestFirstHeaderByteEventTracker) {
       "Transfer-Encoding: chunked\r\n\r\n"
       "0\r\n\r\n");
 
-  CHECK(httpSession_->supportsMoreTransactions());
-  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
+  PRX_CHECK(httpSession_->supportsMoreTransactions());
+  PRX_CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0u);
   handler->txn_->decrementPendingByteEvents();
   httpSession_->destroy();
 }
@@ -995,8 +996,8 @@ TEST_F(HTTPUpstreamSessionTest, BasicTrailers) {
       "X-Trailer1: foo\r\n"
       "\r\n");
 
-  CHECK(httpSession_->supportsMoreTransactions());
-  CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0);
+  PRX_CHECK(httpSession_->supportsMoreTransactions());
+  PRX_CHECK_EQ(httpSession_->getNumOutgoingStreams(), 0u);
   httpSession_->destroy();
 }
 
@@ -2889,12 +2890,12 @@ class H2WtUpstreamTest : public HTTPUpstreamTest<HTTP2CodecPair> {
     // pipe every http/2 ingress data on the CONNECT stream to WtCapsuleCodec
     EXPECT_CALL(server.codecCb, onBody(1, _, _))
         .WillRepeatedly([this](auto id, auto buf, auto pad) {
-          VLOG(5) << "::onBody len=" << buf->computeChainDataLength();
+          PRX_VLOG(5) << "::onBody len=" << buf->computeChainDataLength();
           server.wtCodec.onIngress(buf->clone(), false);
         });
     EXPECT_CALL(server.codecCb, onMessageComplete(1, _))
         .WillRepeatedly([this]() {
-          VLOG(5) << "::onMessageComplete";
+          PRX_VLOG(5) << "::onMessageComplete";
           server.wtCodec.onIngress(nullptr, true);
         });
   }
@@ -2918,9 +2919,9 @@ class H2WtUpstreamTest : public HTTPUpstreamTest<HTTP2CodecPair> {
     // serialize final 2xx
     deliverRespHeaders(/*id=*/1, makeResponse(200), /*eom=*/false);
     auto res = waitForFut(std::move(wtReq), eventBase_);
-    CHECK(res.hasValue());
+    PRX_CHECK(res.hasValue());
     EXPECT_EQ(res.value()->getStatusCode(), 200);
-    CHECK(wt.handlerCtx->wtSession);
+    PRX_CHECK(wt.handlerCtx->wtSession);
     wt.sess = std::move(wt.handlerCtx->wtSession);
 
     constexpr uint32_t kWindowUpdate = 1 << 20; // 1MiB
@@ -2978,7 +2979,7 @@ class H2WtUpstreamTest : public HTTPUpstreamTest<HTTP2CodecPair> {
   // pipe every session write into the peer's codec, which then pipes everything
   // into peer's wt codec
   void onWrite(const HTTPSessionBase&, size_t) override {
-    CHECK(!writes_.empty());
+    PRX_CHECK(!writes_.empty());
     server.codec->onIngress(*writes_.move());
   }
 
@@ -3032,7 +3033,7 @@ TEST_F(H2WtUpstreamTest, SimpleUniEgress) {
   wt.sess->awaitUniStreamCredit().isReady();
   // peer advertised uni credit => ::createUniStream now yields handle
   createStream = wt.sess->createUniStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto* wh = createStream.value();
   auto id = wh->getID();
 
@@ -3060,7 +3061,7 @@ TEST_F(H2WtUpstreamTest, SimpleUniEgress) {
 
   // validate we've rx'd a wt_stream capsule with expected values
   auto streamEvent = std::exchange(server.wtCodecCb.stream, {});
-  CHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), kBufLen);
 
@@ -3087,7 +3088,7 @@ TEST_F(H2WtUpstreamTest, SimpleUniEgress) {
   grantMaxData(detail::kInvalidVarint, kBufLen + 1);
   server.wtCodecCb.waitForEvent(eventBase_);
   streamEvent = std::exchange(server.wtCodecCb.stream, {});
-  CHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), 1);
 
@@ -3098,7 +3099,7 @@ TEST_F(H2WtUpstreamTest, SimpleUniEgress) {
 
   server.wtCodecCb.waitForEvent(eventBase_);
   streamEvent = std::exchange(server.wtCodecCb.stream, {});
-  CHECK(streamEvent.has_value());
+  PRX_CHECK(streamEvent.has_value());
   EXPECT_EQ(streamEvent->streamId, id);
   EXPECT_EQ(streamEvent->streamData->computeChainDataLength(), 0);
   EXPECT_EQ(streamEvent->fin, true);
@@ -3172,7 +3173,7 @@ TEST_F(H2WtUpstreamTest, SimpleBidiEcho) {
 
   // peer advertised bidi credit => ::createBidiStream now yields handle
   createStream = wt.sess->createBidiStream();
-  CHECK(createStream.hasValue());
+  PRX_CHECK(createStream.hasValue());
   auto handle = createStream.value();
   auto id = handle.readHandle->getID();
 
@@ -3210,7 +3211,7 @@ TEST_F(H2WtUpstreamTest, SimpleBidiEcho) {
 
     // validate we've rx'd a wt_stream capsule with val idx
     auto streamEvent = std::exchange(server.wtCodecCb.stream, {});
-    CHECK(streamEvent.has_value());
+    PRX_CHECK(streamEvent.has_value());
     EXPECT_EQ(streamEvent->streamId, id);
     EXPECT_EQ(streamEvent->streamData->length(), 1);
     EXPECT_EQ(*streamEvent->streamData->data(), idx);
@@ -3224,7 +3225,7 @@ TEST_F(H2WtUpstreamTest, SimpleBidiEcho) {
 
     // expect to client to rx same byte
     auto read = waitForFut(wt.sess->readStreamData(id).value(), eventBase_);
-    CHECK(read.hasValue());
+    PRX_CHECK(read.hasValue());
     EXPECT_EQ(*read->data->data(), idx);
   }
 
diff --git a/proxygen/lib/http/session/test/MockCodecDownstreamTest.cpp b/proxygen/lib/http/session/test/MockCodecDownstreamTest.cpp
index 49ea94687d..fd4924a0b1 100644
--- a/proxygen/lib/http/session/test/MockCodecDownstreamTest.cpp
+++ b/proxygen/lib/http/session/test/MockCodecDownstreamTest.cpp
@@ -19,6 +19,7 @@
 #include <proxygen/lib/http/session/test/HTTPSessionTest.h>
 #include <proxygen/lib/http/session/test/TestUtils.h>
 #include <proxygen/lib/test/TestAsyncTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::test::MockAsyncTransport;
 
@@ -93,7 +94,7 @@ class MockCodecDownstreamTest : public testing::Test {
                                       HTTPCodec::StreamID /*lastStream*/,
                                       ErrorCode,
                                       std::shared_ptr<folly::IOBuf>) {
-          LOG(INFO) << "MOCK GENERATE GOAWAY";
+          PRX_LOG(INFO) << "MOCK GENERATE GOAWAY";
           if (reusable_) {
             reusable_ = false;
             drainPending_ = doubleGoaway_;
@@ -151,7 +152,7 @@ class MockCodecDownstreamTest : public testing::Test {
   template <class T>
   void onIngressImpl(T f) {
     EXPECT_CALL(*codec_, onIngress(_)).WillOnce(Invoke([&f](const IOBuf& buf) {
-      CHECK_GT(buf.computeChainDataLength(), 0);
+      PRX_CHECK_GT(buf.computeChainDataLength(), 0u);
       // The test should be independent of the dummy buffer,
       // so don't pass it in.
       f();
@@ -333,13 +334,13 @@ TEST_F(MockCodecDownstreamTest, ServerPushAfterGoaway) {
       .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage>) {
         // Initiate server push transactions.
         pushTxn = handler.txn_->newPushedTransaction(&pushHandler1);
-        CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(2));
+        PRX_CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(2));
         pushHandler1.sendPushHeaders("/foo", "www.foo.com", 100);
         pushHandler1.sendBody(100);
         pushTxn->sendEOM();
         // Initiate the second push transaction which will be aborted
         pushTxn = handler.txn_->newPushedTransaction(&pushHandler2);
-        CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(4));
+        PRX_CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(4));
         pushHandler2.sendPushHeaders("/foo", "www.foo.com", 100);
         pushHandler2.sendBody(100);
         pushTxn->sendEOM();
@@ -410,12 +411,12 @@ TEST_F(MockCodecDownstreamTest, ServerPushAbort) {
       .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage>) {
         // Initiate server push transactions
         pushTxn1 = handler.txn_->newPushedTransaction(&pushHandler1);
-        CHECK_EQ(pushTxn1->getID(), HTTPCodec::StreamID(2));
+        PRX_CHECK_EQ(pushTxn1->getID(), HTTPCodec::StreamID(2));
         pushHandler1.sendPushHeaders("/foo", "www.foo.com", 100);
         pushHandler1.sendBody(100);
 
         pushTxn2 = handler.txn_->newPushedTransaction(&pushHandler2);
-        CHECK_EQ(pushTxn2->getID(), HTTPCodec::StreamID(4));
+        PRX_CHECK_EQ(pushTxn2->getID(), HTTPCodec::StreamID(4));
         pushHandler2.sendPushHeaders("/bar", "www.bar.com", 200);
         pushHandler2.sendBody(200);
         pushTxn2->sendEOM();
@@ -479,12 +480,12 @@ TEST_F(MockCodecDownstreamTest, ServerPushAbortAssoc) {
       .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage>) {
         // Initiate server push transactions
         auto pushTxn = handler.txn_->newPushedTransaction(&pushHandler1);
-        CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(2));
+        PRX_CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(2));
         pushHandler1.sendPushHeaders("/foo", "www.foo.com", 100);
         pushHandler1.sendBody(100);
 
         pushTxn = handler.txn_->newPushedTransaction(&pushHandler2);
-        CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(4));
+        PRX_CHECK_EQ(pushTxn->getID(), HTTPCodec::StreamID(4));
         pushHandler2.sendPushHeaders("/foo", "www.foo.com", 100);
         pushHandler2.sendBody(100);
       }));
@@ -947,8 +948,9 @@ void MockCodecDownstreamTest::testConnFlowControlBlocked(bool timeout) {
   handler1.txn_->sendHeaders(*resp1);
   handler1.txn_->sendBody(makeBuf(wantToWrite)); // conn blocked, stream open
   handler1.txn_->sendEOM();
-  eventBase_.loopOnce();                    // actually send (most of) the body
-  CHECK_EQ(bodyLen, http2::kInitialWindow); // should have written a full window
+  eventBase_.loopOnce(); // actually send (most of) the body
+  PRX_CHECK_EQ(bodyLen,
+               http2::kInitialWindow); // should have written a full window
 
   EXPECT_CALL(mockController_, getRequestHandler(_, _))
       .WillOnce(Return(&handler2));
diff --git a/proxygen/lib/http/session/test/MockQuicSocketDriver.h b/proxygen/lib/http/session/test/MockQuicSocketDriver.h
index 2da02fed82..e4c4dc15e9 100644
--- a/proxygen/lib/http/session/test/MockQuicSocketDriver.h
+++ b/proxygen/lib/http/session/test/MockQuicSocketDriver.h
@@ -12,6 +12,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <proxygen/lib/transport/test/MockAsyncTransportCertificate.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/test/MockQuicSocket.h>
 #include <quic/common/events/FollyQuicEventBase.h>
 #include <quic/priority/HTTPPriorityQueue.h>
@@ -34,9 +35,9 @@ constexpr uint64_t kConnectionStreamId = std::numeric_limits<uint64_t>::max();
   {                                                    \
     if (condition) {                                   \
       if (strictErrorCheck_) {                         \
-        CHECK(!(condition)) << message;                \
+        PRX_CHECK(!(condition)) << message;            \
       } else {                                         \
-        LOG(ERROR) << message;                         \
+        PRX_LOG(ERROR) << message;                     \
         softErrorHandler;                              \
       }                                                \
     }                                                  \
@@ -524,7 +525,7 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
                    MockQuicSocket::SharedBuf data,
                    bool eof,
                    ByteEventCallback* cb) -> quic::MockQuicSocket::WriteResult {
-              CHECK(data || eof) << "no-op write";
+              PRX_CHECK(data || eof) << "no-op write";
               ERROR_IF(id == kConnectionStreamId,
                        "writeChain(kConnectionStreamId) not handled",
                        return quic::make_unexpected(
@@ -571,9 +572,9 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
                 auto finOffset =
                     stream.nextWriteOffset + stream.unsentBuf.chainLength();
                 auto type = quic::ByteEvent::Type::ACK;
-                VLOG(4) << "onByteEventRegistered id=" << id
-                        << " offset=" << finOffset
-                        << " type=" << uint64_t(type);
+                PRX_VLOG(4)
+                    << "onByteEventRegistered id=" << id
+                    << " offset=" << finOffset << " type=" << uint64_t(type);
                 cb->onByteEventRegistered(
                     {.id = id, .offset = finOffset, .type = type});
                 stream.deliveryCallbacks.emplace_back(finOffset, cb);
@@ -583,8 +584,9 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
                   flushWrites();
                 }
               });
-              CHECK(stream.unsentBuf.empty() || stream.flowControlWindow == 0 ||
-                    connState.flowControlWindow == 0);
+              PRX_CHECK(stream.unsentBuf.empty() ||
+                        stream.flowControlWindow == 0 ||
+                        connState.flowControlWindow == 0);
               return {};
             }));
 
@@ -778,16 +780,17 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
                               id),
                   return quic::make_unexpected(
                       LocalErrorCode::STREAM_NOT_EXISTS));
-              VLOG(4) << "onByteEventRegistered id=" << id
-                      << " offset=" << offset << " type=" << uint64_t(type);
+              PRX_VLOG(4) << "onByteEventRegistered id=" << id
+                          << " offset=" << offset << " type=" << uint64_t(type);
               cb->onByteEventRegistered(
                   {.id = id, .offset = offset, .type = type});
               if (it->second.fireByteEventAt(offset)) {
                 // already available, fire the cb from the loop
                 eventBase_->runInLoop(
                     [id, offset, type, cb] {
-                      VLOG(4) << "onByteEvent id=" << id << " offset=" << offset
-                              << " type=" << uint64_t(type);
+                      PRX_VLOG(4)
+                          << "onByteEvent id=" << id << " offset=" << offset
+                          << " type=" << uint64_t(type);
                       cb->onByteEvent(
                           {.id = id, .offset = offset, .type = type});
                     },
@@ -890,12 +893,12 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
   }
 
   void checkNotReadOnlyStream(quic::StreamId id) {
-    CHECK(!isReceivingStream(id))
+    PRX_CHECK(!isReceivingStream(id))
         << "API not supported on read-only unidirectional stream. streamID="
         << id;
   }
   void checkNotWriteOnlyStream(quic::StreamId id) {
-    CHECK(!isSendingStream(id))
+    PRX_CHECK(!isSendingStream(id))
         << "API not supported on write-only unidirectional stream. streamID="
         << id;
   }
@@ -1123,8 +1126,8 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
       if (!stream.fireByteEventAt(cb.first)) {
         break;
       }
-      VLOG(4) << "onByteEvent id=" << id << " offset=" << cb.first
-              << " type=" << uint64_t(type);
+      PRX_VLOG(4) << "onByteEvent id=" << id << " offset=" << cb.first
+                  << " type=" << uint64_t(type);
       cb.second->onByteEvent({.id = id, .offset = cb.first, .type = type});
       callbacks.pop_front();
     }
@@ -1461,7 +1464,7 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
                     stream.writeState = CLOSED;
                     sock_->connCb_->onNewUnidirectionalStream(event.streamId);
                   } else {
-                    CHECK(event.error) << "Non-error on self-uni stream";
+                    PRX_CHECK(event.error) << "Non-error on self-uni stream";
                   }
                 } else {
                   sock_->connCb_->onNewBidirectionalStream(event.streamId);
@@ -1666,9 +1669,9 @@ class MockQuicSocketDriver : public folly::EventBase::LoopCallback {
             copyBuf = streamState.readBuf.front()->clone();
             copyBufLen = copyBuf->computeChainDataLength();
           }
-          VLOG(6) << "peek onDataAvailable id=" << it.first
-                  << " len=" << copyBufLen
-                  << " offset=" << streamState.readOffset;
+          PRX_VLOG(6) << "peek onDataAvailable id=" << it.first
+                      << " len=" << copyBufLen
+                      << " offset=" << streamState.readOffset;
           ERROR_IF(streamState.readBufOffset < copyBufLen,
                    fmt::format("readOffset({}) is lower than current read "
                                "buffer offset({}) for streamId={}",
diff --git a/proxygen/lib/http/sink/CMakeLists.txt b/proxygen/lib/http/sink/CMakeLists.txt
index 47b5d1c487..bcc052ee11 100644
--- a/proxygen/lib/http/sink/CMakeLists.txt
+++ b/proxygen/lib/http/sink/CMakeLists.txt
@@ -15,7 +15,7 @@ proxygen_add_library(proxygen_http_sink_client_sink
     proxygen_http_observer_session_observer_container
     proxygen_http_session_http_transaction
     proxygen_http_sink_client_sink_interface
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
 )
 
 proxygen_add_library(proxygen_http_sink_flow_control_info)
diff --git a/proxygen/lib/http/sink/HTTPTransactionSink.h b/proxygen/lib/http/sink/HTTPTransactionSink.h
index bf8abbe20b..9796c4addb 100644
--- a/proxygen/lib/http/sink/HTTPTransactionSink.h
+++ b/proxygen/lib/http/sink/HTTPTransactionSink.h
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/observer/HTTPSessionObserverContainer.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include "proxygen/lib/http/sink/HTTPSink.h"
 
@@ -23,7 +23,7 @@ class HTTPTransactionSink : public HTTPSink {
  public:
   explicit HTTPTransactionSink(HTTPTransaction* clientTxn)
       : httpTransaction_{clientTxn} {
-    XCHECK(clientTxn)
+    PRX_CHECK(clientTxn)
         << "HTTPTransactionSink must be created with a valid clientTxn.";
     if (httpTransaction_->getSequenceNumber() > 0) {
       // TODO: There can be a gap between session open and first req
@@ -76,7 +76,7 @@ class HTTPTransactionSink : public HTTPSink {
     return httpTransaction_->getCompressionInfo();
   }
   void detachAndAbortIfIncomplete(std::unique_ptr<HTTPSink> self) override {
-    CHECK_EQ(self.get(), this);
+    PRX_CHECK_EQ(self.get(), this);
     httpTransaction_->setTransportCallback(nullptr);
     httpTransaction_->setHandler(nullptr);
     if (!(httpTransaction_->isEgressComplete() ||
diff --git a/proxygen/lib/http/sink/HTTPTunnelSink.cpp b/proxygen/lib/http/sink/HTTPTunnelSink.cpp
index 7fb31891ae..b0cd0a9b9d 100644
--- a/proxygen/lib/http/sink/HTTPTunnelSink.cpp
+++ b/proxygen/lib/http/sink/HTTPTunnelSink.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/sink/HTTPTunnelSink.h>
 
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -24,7 +24,7 @@ void HTTPTunnelSink::detachAndAbortIfIncomplete(
   if (!egressEOMSeen_ && !ingressEOMRead_) {
     sock_->closeWithReset();
   }
-  XCHECK(self.get() == this);
+  PRX_CHECK(self.get() == this);
   if (outstandingWrites_ > 0) {
     destroyOnWriteComplete_ = true;
     void(self.release());
@@ -92,7 +92,7 @@ void HTTPTunnelSink::resumeIngress() {
 }
 
 void HTTPTunnelSink::timeoutExpired() noexcept {
-  XLOG(DBG4) << "Closing socket now";
+  PRX_VLOG(4) << "Closing socket now";
   sock_->closeNow();
   if (handler_) {
     DestructorCheck::Safety safety(*this);
diff --git a/proxygen/lib/http/sink/HTTPTunnelSink.h b/proxygen/lib/http/sink/HTTPTunnelSink.h
index 5867317034..8124d8790d 100644
--- a/proxygen/lib/http/sink/HTTPTunnelSink.h
+++ b/proxygen/lib/http/sink/HTTPTunnelSink.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/session/HTTPTransaction.h>
 #include <proxygen/lib/http/sink/HTTPSink.h>
 #include <proxygen/lib/utils/ConditionalGate.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -29,7 +30,7 @@ class HTTPTunnelSink
   explicit HTTPTunnelSink(folly::AsyncTransport::UniquePtr socket,
                           HTTPTransactionHandler* handler)
       : sock_(std::move(socket)), handler_(handler) {
-    CHECK(sock_);
+    PRX_CHECK(sock_);
     sock_->getLocalAddress(&localAddress_);
     sock_->getPeerAddress(&peerAddress_);
   }
@@ -64,7 +65,8 @@ class HTTPTunnelSink
   }
 
   [[nodiscard]] int getTCPTransportFD() const override {
-    return CHECK_NOTNULL(sock_->getUnderlyingTransport<folly::AsyncSocket>())
+    return PRX_CHECK_NOTNULL(
+               sock_->getUnderlyingTransport<folly::AsyncSocket>())
         ->getNetworkSocket()
         .toFd();
   }
diff --git a/proxygen/lib/http/stats/HTTPCodecStats.cpp b/proxygen/lib/http/stats/HTTPCodecStats.cpp
index 72c8d8a617..314738decf 100644
--- a/proxygen/lib/http/stats/HTTPCodecStats.cpp
+++ b/proxygen/lib/http/stats/HTTPCodecStats.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/stats/HTTPCodecStats.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using facebook::fb303::RATE;
 using facebook::fb303::SUM;
@@ -99,7 +100,7 @@ void TLHTTPCodecStats::recordIngressRst(ErrorCode statusCode) {
   ingressRst_.add(1);
   auto index = uint32_t(statusCode);
   if (index >= kErrorStrings.size()) {
-    LOG(ERROR) << "Unknown ingress reset status code=" << index;
+    PRX_LOG(ERROR) << "Unknown ingress reset status code=" << index;
     index = (uint32_t)ErrorCode::PROTOCOL_ERROR;
   }
   ingressRstStatus_[index].add(1);
@@ -117,7 +118,7 @@ void TLHTTPCodecStats::recordIngressGoaway(ErrorCode statusCode) {
   ingressGoaway_.add(1);
   auto index = uint32_t(statusCode);
   if (index >= kErrorStrings.size()) {
-    LOG(ERROR) << "Unknown ingress goaway status code=" << index;
+    PRX_LOG(ERROR) << "Unknown ingress goaway status code=" << index;
     index = (uint32_t)ErrorCode::PROTOCOL_ERROR;
   }
   ingressGoawayStatus_[index].add(1);
@@ -150,7 +151,7 @@ void TLHTTPCodecStats::recordEgressRst(ErrorCode statusCode) {
   egressRst_.add(1);
   auto index = uint32_t(statusCode);
   if (index >= kErrorStrings.size()) {
-    LOG(ERROR) << "Unknown egress reset status code=" << index;
+    PRX_LOG(ERROR) << "Unknown egress reset status code=" << index;
     index = (uint32_t)ErrorCode::PROTOCOL_ERROR;
   }
   egressRstStatus_[index].add(1);
@@ -168,7 +169,7 @@ void TLHTTPCodecStats::recordEgressGoaway(ErrorCode statusCode) {
   egressGoaway_.add(1);
   auto index = uint32_t(statusCode);
   if (index >= kErrorStrings.size()) {
-    LOG(ERROR) << "Unknown egress goaway status code=" << index;
+    PRX_LOG(ERROR) << "Unknown egress goaway status code=" << index;
     index = (uint32_t)ErrorCode::PROTOCOL_ERROR;
   }
   egressGoawayStatus_[index].add(1);
diff --git a/proxygen/lib/http/stats/HeaderCodecStats.cpp b/proxygen/lib/http/stats/HeaderCodecStats.cpp
index 584744b3dd..5621f39533 100644
--- a/proxygen/lib/http/stats/HeaderCodecStats.cpp
+++ b/proxygen/lib/http/stats/HeaderCodecStats.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/stats/HeaderCodecStats.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using facebook::fb303::AVG;
 using facebook::fb303::SUM;
@@ -82,34 +83,34 @@ TLHeaderCodecStats::TLHeaderCodecStats(const string& prefix) {
 void TLHeaderCodecStats::recordEncode(HeaderCodec::Type type,
                                       HTTPHeaderSize& size) {
   auto i = (uint32_t)type;
-  CHECK(i < encodes_.size());
+  PRX_CHECK(i < encodes_.size());
   encodes_[i].add(1);
-  CHECK(i < encodeCompr_.size());
+  PRX_CHECK(i < encodeCompr_.size());
   encodeCompr_[i]->add(size.compressed);
-  CHECK(i < encodeUncompr_.size());
+  PRX_CHECK(i < encodeUncompr_.size());
   encodeUncompr_[i]->add(size.uncompressed);
 }
 
 void TLHeaderCodecStats::recordDecode(HeaderCodec::Type type,
                                       HTTPHeaderSize& size) {
   auto i = (uint32_t)type;
-  CHECK(i < decodes_.size());
+  PRX_CHECK(i < decodes_.size());
   decodes_[i].add(1);
-  CHECK(i < decodeCompr_.size());
+  PRX_CHECK(i < decodeCompr_.size());
   decodeCompr_[i]->add(size.compressed);
-  CHECK(i < decodeUncompr_.size());
+  PRX_CHECK(i < decodeUncompr_.size());
   decodeUncompr_[i]->add(size.uncompressed);
 }
 
 void TLHeaderCodecStats::recordDecodeError(HeaderCodec::Type type) {
   auto i = (uint32_t)type;
-  CHECK(i < decodeErrors_.size());
+  PRX_CHECK(i < decodeErrors_.size());
   decodeErrors_[i].add(1);
 }
 
 void TLHeaderCodecStats::recordDecodeTooLarge(HeaderCodec::Type type) {
   auto i = (uint32_t)type;
-  CHECK(i < decodeTooLarge_.size());
+  PRX_CHECK(i < decodeTooLarge_.size());
   decodeTooLarge_[i].add(1);
 }
 
diff --git a/proxygen/lib/http/structuredheaders/CMakeLists.txt b/proxygen/lib/http/structuredheaders/CMakeLists.txt
index 19f7e3e0c4..497bef4865 100644
--- a/proxygen/lib/http/structuredheaders/CMakeLists.txt
+++ b/proxygen/lib/http/structuredheaders/CMakeLists.txt
@@ -10,10 +10,10 @@ proxygen_add_library(proxygen_http_structuredheaders_structured_headers
   SRCS
     StructuredHeadersBuffer.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_base64
     Folly::folly_conv
     Folly::folly_try
-    glog::glog
   EXPORTED_DEPS
     proxygen_http_structuredheaders_utils
     Folly::folly_range
@@ -23,8 +23,8 @@ proxygen_add_library(proxygen_http_structuredheaders_encoder
   SRCS
     StructuredHeadersEncoder.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_base64
-    glog::glog
   EXPORTED_DEPS
     proxygen_http_structuredheaders_utils
 )
diff --git a/proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp b/proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp
index 42ef015ba0..c8440a53de 100644
--- a/proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp
+++ b/proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp
@@ -12,7 +12,7 @@
 #include <folly/Conv.h>
 #include <folly/Try.h>
 #include <folly/base64.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersUtilities.h>
 
@@ -100,7 +100,7 @@ DecodeError StructuredHeadersBuffer::parseNumber(StructuredHeaderItem& result) {
 DecodeError StructuredHeadersBuffer::parseBoolean(
     StructuredHeaderItem& result) {
   if (removeSymbol("?", true) != DecodeError::OK) {
-    CHECK(false) << "Only invoked after peeking a '?'";
+    PRX_CHECK(false) << "Only invoked after peeking a '?'";
   }
   if (isEmpty()) {
     return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
@@ -284,7 +284,7 @@ DecodeError StructuredHeadersBuffer::removeSymbol(const std::string& symbol,
 }
 
 DecodeError StructuredHeadersBuffer::handleDecodeError(const DecodeError& err) {
-  LOG_EVERY_N(ERROR, 1000)
+  PRX_LOG_EVERY_N(ERROR, 1000)
       << "Error message: " << decodeErrToString(err)
       << ". Number of characters parsed before error:" << getNumCharsParsed()
       << ". Header Content:" << originalContent_.str();
diff --git a/proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.cpp b/proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.cpp
index a5c00dcc35..480e90adfe 100644
--- a/proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.cpp
+++ b/proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.cpp
@@ -7,9 +7,9 @@
  */
 
 #include <folly/base64.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.h>
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersUtilities.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -223,14 +223,14 @@ EncodeError StructuredHeadersEncoder::encodeIdentifier(
 // was involved in the error
 EncodeError StructuredHeadersEncoder::handleEncodeError(
     EncodeError err, const std::string& culprit) {
-  LOG_EVERY_N(ERROR, 1000) << "Error message: " << encodeErrToString(err)
-                           << ", culprit: " << culprit;
+  PRX_LOG_EVERY_N(ERROR, 1000) << "Error message: " << encodeErrToString(err)
+                               << ", culprit: " << culprit;
   return err;
 }
 
 // Used to print more general error messages (eg: empty data structure)
 EncodeError StructuredHeadersEncoder::handleEncodeError(EncodeError err) {
-  LOG_EVERY_N(ERROR, 1000) << "Error message: " << encodeErrToString(err);
+  PRX_LOG_EVERY_N(ERROR, 1000) << "Error message: " << encodeErrToString(err);
   return err;
 }
 
diff --git a/proxygen/lib/http/structuredheaders/test/StructuredHeadersStandardTest.cpp b/proxygen/lib/http/structuredheaders/test/StructuredHeadersStandardTest.cpp
index a0d3c0941a..02f9fc4735 100644
--- a/proxygen/lib/http/structuredheaders/test/StructuredHeadersStandardTest.cpp
+++ b/proxygen/lib/http/structuredheaders/test/StructuredHeadersStandardTest.cpp
@@ -8,9 +8,9 @@
 
 #include <algorithm>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersDecoder.h>
 #include <proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -134,7 +134,7 @@ class StructuredHeadersStandardTest : public testing::Test {
   bool decode32Block(std::string input,
                      uint32_t blockNum,
                      std::string& outputBuffer) {
-    CHECK_GE(input.size(), (blockNum + 1) * 8);
+    PRX_CHECK_GE(input.size(), (blockNum + 1) * 8);
     // Remove any padding and make each character of the input represent the
     // byte value of that character, as per the rfc4648 encoding
     input.erase(std::find_if(input.rbegin(),
diff --git a/proxygen/lib/http/test/HTTPHeadersBenchmark.cpp b/proxygen/lib/http/test/HTTPHeadersBenchmark.cpp
index 5ea3133352..03ed8c752f 100644
--- a/proxygen/lib/http/test/HTTPHeadersBenchmark.cpp
+++ b/proxygen/lib/http/test/HTTPHeadersBenchmark.cpp
@@ -10,6 +10,7 @@
 #include <folly/Benchmark.h>
 #include <proxygen/lib/http/HTTPCommonHeaders.h>
 #include <proxygen/lib/http/HTTPHeaders.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 
@@ -90,9 +91,9 @@ void memchrBench(int iters) {
     for (uint64_t j = HTTPHeaderCodeCommonOffset;
          j < HTTPCommonHeaders::num_codes;
          ++j) {
-      CHECK(memchr((void*)testHeaderCodes.data(),
-                   static_cast<HTTPHeaderCode>(j),
-                   testHeaderCodes.size()) != nullptr);
+      PRX_CHECK(memchr((void*)testHeaderCodes.data(),
+                       static_cast<HTTPHeaderCode>(j),
+                       testHeaderCodes.size()) != nullptr);
     }
   }
 }
@@ -104,9 +105,9 @@ void stdFindBench(int iters) {
          ++j) {
       auto address =
           HTTPCommonHeaders::getPointerToName(static_cast<HTTPHeaderCode>(j));
-      CHECK(std::find(testHeaderStrings.begin(),
-                      testHeaderStrings.end(),
-                      address) != testHeaderStrings.end());
+      PRX_CHECK(std::find(testHeaderStrings.begin(),
+                          testHeaderStrings.end(),
+                          address) != testHeaderStrings.end());
     }
   }
 }
diff --git a/proxygen/lib/http/test/HTTPMessageTest.cpp b/proxygen/lib/http/test/HTTPMessageTest.cpp
index aa90559228..ba878c4614 100644
--- a/proxygen/lib/http/test/HTTPMessageTest.cpp
+++ b/proxygen/lib/http/test/HTTPMessageTest.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/http/HTTPPriorityFunctions.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/TestUtils.h>
 
 using namespace proxygen;
@@ -297,7 +298,7 @@ TEST(HTTPMessage, TestCombine) {
   headers.add("Combine", "third value");
   EXPECT_EQ(headers.combine("Combine"),
             "first value, second value, third value");
-  VLOG(4) << msg;
+  PRX_VLOG(4) << msg;
 }
 
 TEST(HTTPMessage, TestProxification) {
@@ -863,7 +864,7 @@ TEST(HTTPHeaders, MoveFromTest) {
   HTTPHeaders h2(std::move(h1));
   EXPECT_FALSE(h1.exists(HTTP_HEADER_CONNECTION));
   h1.forEachValueOfHeader(HTTP_HEADER_HOST, [](const std::string&) -> bool {
-    CHECK(false) << "Unreachable";
+    PRX_CHECK(false) << "Unreachable";
   });
   h1.add(HTTP_HEADER_CONNECTION, "close");
 
diff --git a/proxygen/lib/http/test/MockHTTPMessageFilter.h b/proxygen/lib/http/test/MockHTTPMessageFilter.h
index 8502d80c5c..8b00999efd 100644
--- a/proxygen/lib/http/test/MockHTTPMessageFilter.h
+++ b/proxygen/lib/http/test/MockHTTPMessageFilter.h
@@ -12,6 +12,7 @@
 
 #include "proxygen/facebook/revproxy/caching/filter/FilterNames.h"
 #include <proxygen/lib/http/HTTPMessageFilters.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -71,8 +72,8 @@ class MockHTTPMessageFilter : public HTTPMessageFilter {
   }
 
   [[noreturn]] std::unique_ptr<HTTPMessageFilter> clone() noexcept override {
-    LOG(FATAL) << "clone() not implemented for filter: "
-               << this->getFilterName();
+    PRX_LOG(FATAL) << "clone() not implemented for filter: "
+                   << this->getFilterName();
   };
 
   void nextOnEOMPublic() {
@@ -121,7 +122,7 @@ class MockWritebackFilter : public HTTPMessageFilter {
   }
 
   [[noreturn]] std::unique_ptr<HTTPMessageFilter> clone() noexcept override {
-    LOG(FATAL) << "clone() not implemented for MockWritebackFilter";
+    PRX_LOG(FATAL) << "clone() not implemented for MockWritebackFilter";
   }
 };
 
diff --git a/proxygen/lib/http/webtransport/CMakeLists.txt b/proxygen/lib/http/webtransport/CMakeLists.txt
index b03d0a53a4..c7b5d7614c 100644
--- a/proxygen/lib/http/webtransport/CMakeLists.txt
+++ b/proxygen/lib/http/webtransport/CMakeLists.txt
@@ -9,6 +9,8 @@
 proxygen_add_library(proxygen_http_webtransport
   SRCS
     WebTransport.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     mvfst::mvfst_api_quic_callbacks
     mvfst::mvfst_api_transport_info
@@ -39,7 +41,7 @@ proxygen_add_library(proxygen_http_webtransport_webtransportimpl
   SRCS
     WebTransportImpl.cpp
   DEPS
-    glog::glog
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_codec_codec_common
     proxygen_http_webtransport
@@ -52,8 +54,8 @@ proxygen_add_library(proxygen_http_webtransport_quicwebtransport
     QuicWebTransport.cpp
   EXPORTED_DEPS
     proxygen_http_webtransport_webtransportimpl
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_webtransport_quic_wt_session
@@ -65,20 +67,19 @@ proxygen_add_library(proxygen_http_webtransport_quic_wt_session
     proxygen_http_webtransport
     proxygen_http_webtransport_wt_stream_manager
     proxygen_http_webtransport_wt_util
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     mvfst::mvfst_priority_http_priority_queue
-    Folly::folly_logging_logging
 )
 
 proxygen_add_library(proxygen_http_webtransport_wt_stream_manager
   SRCS
     WtEgressContainer.cpp
     WtStreamManager.cpp
-  DEPS
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_webtransport
     proxygen_http_webtransport_flow_controller
+    proxygen_utils_log_shim
     mvfst::mvfst_priority_priority_queue
     Folly::folly_container_f14_hash
     Folly::folly_io_iobuf
@@ -89,7 +90,7 @@ proxygen_add_library(proxygen_http_webtransport_wt_util
     WtUtils.cpp
   DEPS
     proxygen_http_codec_codec_common
-    Folly::folly_logging_logging
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_codec_direction
     proxygen_http_codec_webtransport_webtransport_capsule_codec
@@ -99,6 +100,8 @@ proxygen_add_library(proxygen_http_webtransport_wt_util
 proxygen_add_library(proxygen_http_webtransport_webtransport_session
   SRCS
     WebTransportSession.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_session_http_transaction
     proxygen_http_webtransport_wt_stream_manager
@@ -109,6 +112,8 @@ proxygen_add_library(proxygen_http_webtransport_webtransport_session
 proxygen_add_library(proxygen_http_webtransport_wt_hq_session
   SRCS
     HqWtSession.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_http_webtransport_quic_wt_session
     proxygen_http_webtransport_webtransport_session
diff --git a/proxygen/lib/http/webtransport/HqWtSession.cpp b/proxygen/lib/http/webtransport/HqWtSession.cpp
index 31491d2107..19654b2d59 100644
--- a/proxygen/lib/http/webtransport/HqWtSession.cpp
+++ b/proxygen/lib/http/webtransport/HqWtSession.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/webtransport/HqWtSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 using namespace proxygen;
@@ -18,28 +19,28 @@ struct H3CapsuleCodecCb final : public WebTransportCapsuleCodec::Callback {
   }
 
   void onMaxData(WTMaxDataCapsule c) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     wtSess.onConnMaxData({.maxData = c.maximumData});
   }
   void onMaxStreamsBidi(WTMaxStreamsCapsule c) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     wtSess.onMaxStreams(WtStreamManager::MaxStreamsBidi{c.maximumStreams});
   }
   void onMaxStreamsUni(WTMaxStreamsCapsule c) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     wtSess.onMaxStreams(WtStreamManager::MaxStreamsUni{c.maximumStreams});
   }
   void onDrainSession(DrainWebTransportSessionCapsule) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     wtSess.onDrainSession({});
   }
   void onCloseSession(CloseWebTransportSessionCapsule c) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     wtSess.onCloseSession(WtStreamManager::CloseSession{
         c.applicationErrorCode, std::move(c.applicationErrorMessage)});
   }
   void onConnectionError(CapsuleCodec::ErrorCode error) noexcept override {
-    VLOG(4) << __func__;
+    PRX_VLOG(4) << __func__;
     onCloseSession({uint8_t(error), "onConnectionError"});
   }
 
@@ -92,8 +93,8 @@ struct WtReadLooper : public WtLooper {
 
 void WtReadLooper::runLoopCallback() noexcept {
   auto [buf, eom] = wtTxnHandler_.moveBufferedIngress();
-  VLOG(4) << "WtReadLooper buf=" << buf.get() << "; eom=" << eom
-          << "; ex=" << wtTxnHandler_.ex_;
+  PRX_VLOG(4) << "WtReadLooper buf=" << buf.get() << "; eom=" << eom
+              << "; ex=" << wtTxnHandler_.ex_;
   codec_.onIngress(std::move(buf), eom);
   const bool ingressDone = eom || wtTxnHandler_.ex_;
   if (ingressDone) {
@@ -135,14 +136,14 @@ void WtWriteLooper::runLoopCallback() noexcept {
   // serialize all control frames
   auto* txn = wtTxnHandler_.txn_;
   const bool canWrite = !wtSess_.writesDone_ && txn;
-  VLOG(4) << "WtWriteLooper canWrite=" << canWrite;
+  PRX_VLOG(4) << "WtWriteLooper canWrite=" << canWrite;
   if (!canWrite) {
     return;
   }
   txn->sendBody(buf_.move());
   // if we've visited CloseSession, send eom & mark writes done
   if (visitor.sessionClosed) {
-    VLOG(4) << "WtWriteLooper sessionClosed";
+    PRX_VLOG(4) << "WtWriteLooper sessionClosed";
     txn->sendEOM();
     wtSess_.writesDone();
   }
@@ -164,13 +165,13 @@ HqWtSession::HqWtSession(WtLooper& readLooper,
 }
 
 void HqWtSession::onHttpError(const HTTPException& err) noexcept {
-  VLOG(4) << __func__ << "; err=" << err.describe();
+  PRX_VLOG(4) << __func__ << "; err=" << err.describe();
   wtSess_.onCloseSession({WebTransport::kInternalError, err.describe()});
   WtHttpSession::onHttpError(err);
 }
 
 void HqWtSession::onDone() noexcept {
-  VLOG(4) << __func__;
+  PRX_VLOG(4) << __func__;
   wtSess_.closeSession(folly::none);
 }
 
diff --git a/proxygen/lib/http/webtransport/QuicWebTransport.cpp b/proxygen/lib/http/webtransport/QuicWebTransport.cpp
index c26ab129c2..f52b418cc2 100644
--- a/proxygen/lib/http/webtransport/QuicWebTransport.cpp
+++ b/proxygen/lib/http/webtransport/QuicWebTransport.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/webtransport/QuicWebTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using FCState = proxygen::WebTransport::FCState;
 
@@ -16,7 +17,7 @@ void QuicWebTransport::onFlowControlUpdate(quic::StreamId /*id*/) noexcept {
 }
 
 void QuicWebTransport::onNewBidirectionalStream(quic::StreamId id) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (!handler_) {
     resetWebTransportEgress(id, WebTransport::kInternalError);
     // resetWebTransportEgress may have closed the session
@@ -35,9 +36,9 @@ void QuicWebTransport::onNewBidirectionalStream(quic::StreamId id) noexcept {
 }
 
 void QuicWebTransport::onNewUnidirectionalStream(quic::StreamId id) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (!handler_) {
-    LOG(ERROR) << "Handler not set";
+    PRX_LOG(ERROR) << "Handler not set";
     stopReadingWebTransportIngress(id, WebTransport::kInternalError);
     return;
   }
@@ -73,7 +74,7 @@ void QuicWebTransport::onConnectionEndImpl(
     if (error->code.type() == quic::QuicErrorCode::Type::ApplicationErrorCode) {
       wtError = static_cast<uint32_t>(*error->code.asApplicationErrorCode());
     } else {
-      XLOG(DBG2) << "QUIC Connection Error: " << *error;
+      PRX_VLOG(2) << "QUIC Connection Error: " << *error;
       wtError = std::numeric_limits<uint32_t>::max();
     }
   }
@@ -85,7 +86,7 @@ void QuicWebTransport::onConnectionEndImpl(
 
 folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
 QuicWebTransport::newWebTransportBidiStream() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto id = quicSocket_->createBidirectionalStream();
   if (id.hasError()) {
     return folly::makeUnexpected(ErrorCode::GENERIC_ERROR);
@@ -95,7 +96,7 @@ QuicWebTransport::newWebTransportBidiStream() {
 
 folly::Expected<HTTPCodec::StreamID, WebTransport::ErrorCode>
 QuicWebTransport::newWebTransportUniStream() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto id = quicSocket_->createUnidirectionalStream();
   if (id.hasError()) {
     return folly::makeUnexpected(ErrorCode::GENERIC_ERROR);
@@ -109,20 +110,20 @@ QuicWebTransport::sendWebTransportStreamData(
     std::unique_ptr<folly::IOBuf> data,
     bool eof,
     ByteEventCallback* deliveryCallback) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res =
       quicSocket_->writeChain(id, std::move(data), eof, deliveryCallback);
   if (!res) {
-    LOG(ERROR) << "Failed to write WT stream data, res=" << res.error();
+    PRX_LOG(ERROR) << "Failed to write WT stream data, res=" << res.error();
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
   }
   auto flowControl = quicSocket_->getStreamFlowControl(id);
   if (!flowControl) {
-    LOG(ERROR) << "Failed to get flow control";
+    PRX_LOG(ERROR) << "Failed to get flow control";
     return folly::makeUnexpected(WebTransport::ErrorCode::SEND_ERROR);
   }
   if (!eof && flowControl->sendWindowAvailable == 0) {
-    VLOG(4) << "fc window closed";
+    PRX_VLOG(4) << "fc window closed";
     return FCState::BLOCKED;
   } else {
     return FCState::UNBLOCKED;
@@ -132,7 +133,7 @@ QuicWebTransport::sendWebTransportStreamData(
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::notifyPendingWriteOnStream(HTTPCodec::StreamID id,
                                              quic::StreamWriteCallback* wcb) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   quicSocket_->notifyPendingWriteOnStream(id, wcb);
   return folly::unit;
 }
@@ -140,7 +141,7 @@ QuicWebTransport::notifyPendingWriteOnStream(HTTPCodec::StreamID id,
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::resetWebTransportEgress(HTTPCodec::StreamID id,
                                           uint32_t errorCode) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res = quicSocket_->resetStream(id, errorCode);
   if (!res) {
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
@@ -151,7 +152,7 @@ QuicWebTransport::resetWebTransportEgress(HTTPCodec::StreamID id,
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::setWebTransportStreamPriority(
     HTTPCodec::StreamID id, quic::PriorityQueue::Priority pri) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res = quicSocket_->setStreamPriority(id, pri);
   if (res.hasError()) {
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
@@ -163,7 +164,7 @@ QuicWebTransport::setWebTransportStreamPriority(
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::setWebTransportPriorityQueue(
     std::unique_ptr<quic::PriorityQueue> queue) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res = quicSocket_->setPriorityQueue(std::move(queue));
   if (res.hasError()) {
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
@@ -173,7 +174,7 @@ QuicWebTransport::setWebTransportPriorityQueue(
 
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::pauseWebTransportIngress(HTTPCodec::StreamID id) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res = quicSocket_->pauseRead(id);
   if (res.hasError()) {
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
@@ -183,7 +184,7 @@ QuicWebTransport::pauseWebTransportIngress(HTTPCodec::StreamID id) {
 
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::resumeWebTransportIngress(HTTPCodec::StreamID id) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto res = quicSocket_->resumeRead(id);
   if (res.hasError()) {
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
@@ -210,10 +211,11 @@ QuicWebTransport::stopReadingWebTransportIngress(
 
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWebTransport::sendDatagram(std::unique_ptr<folly::IOBuf> datagram) {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto writeRes = quicSocket_->writeDatagram(std::move(datagram));
   if (writeRes.hasError()) {
-    LOG(ERROR) << "Failed to send datagram, error code: " << writeRes.error();
+    PRX_LOG(ERROR) << "Failed to send datagram, error code: "
+                   << writeRes.error();
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
   }
   return folly::unit;
@@ -263,12 +265,12 @@ void QuicWebTransport::onUnidirectionalStreamsAvailable(
 }
 
 folly::SemiFuture<folly::Unit> QuicWebTransport::awaitUniStreamCredit() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto numOpenable = quicSocket_->getNumOpenableUnidirectionalStreams();
   if (numOpenable > 0) {
     return folly::makeFuture(folly::unit);
   }
-  CHECK(!waitingForUniStreams_);
+  PRX_CHECK(!waitingForUniStreams_);
   auto [promise, future] = folly::makePromiseContract<folly::Unit>();
   waitingForUniStreams_ = std::move(promise);
   return std::move(future);
@@ -283,37 +285,37 @@ void QuicWebTransport::onBidirectionalStreamsAvailable(
 }
 
 folly::SemiFuture<folly::Unit> QuicWebTransport::awaitBidiStreamCredit() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto numOpenable = quicSocket_->getNumOpenableBidirectionalStreams();
   if (numOpenable > 0) {
     return folly::makeFuture(folly::unit);
   }
-  CHECK(!waitingForBidiStreams_);
+  PRX_CHECK(!waitingForBidiStreams_);
   auto [promise, future] = folly::makePromiseContract<folly::Unit>();
   waitingForBidiStreams_ = std::move(promise);
   return std::move(future);
 }
 
 bool QuicWebTransport::canCreateUniStream() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   return quicSocket_->getNumOpenableUnidirectionalStreams() > 0;
 }
 
 bool QuicWebTransport::canCreateBidiStream() {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   return quicSocket_->getNumOpenableBidirectionalStreams() > 0;
 }
 
 void QuicWebTransport::onDatagramsAvailable() noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto result = quicSocket_->readDatagramBufs();
   if (result.hasError()) {
-    LOG(ERROR) << "Got error while reading datagrams: error="
-               << toString(result.error());
+    PRX_LOG(ERROR) << "Got error while reading datagrams: error="
+                   << toString(result.error());
     closeSession(0);
     return;
   }
-  VLOG(4) << "Received " << result.value().size() << " datagrams";
+  PRX_VLOG(4) << "Received " << result.value().size() << " datagrams";
   if (handler_) {
     for (auto& datagram : result.value()) {
       handler_->onDatagram(std::move(datagram));
diff --git a/proxygen/lib/http/webtransport/QuicWebTransport.h b/proxygen/lib/http/webtransport/QuicWebTransport.h
index 39dd86b9ac..1b32cd7a0a 100644
--- a/proxygen/lib/http/webtransport/QuicWebTransport.h
+++ b/proxygen/lib/http/webtransport/QuicWebTransport.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/webtransport/WebTransportImpl.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 
 namespace proxygen {
@@ -42,14 +42,14 @@ class QuicWebTransport
   }
 
   [[nodiscard]] quic::TransportInfo getTransportInfo() const override {
-    XCHECK(quicSocket_);
+    PRX_CHECK(quicSocket_);
     return quicSocket_->getTransportInfo();
   }
 
   [[nodiscard]] quic::Expected<quic::QuicSocketLite::FlowControlState,
                                quic::LocalErrorCode>
   getConnectionFlowControl() const {
-    XCHECK(quicSocket_);
+    PRX_CHECK(quicSocket_);
     return quicSocket_->getConnectionFlowControl();
   }
 
diff --git a/proxygen/lib/http/webtransport/QuicWtSession.cpp b/proxygen/lib/http/webtransport/QuicWtSession.cpp
index 5cb3340445..ec1c1a63b8 100644
--- a/proxygen/lib/http/webtransport/QuicWtSession.cpp
+++ b/proxygen/lib/http/webtransport/QuicWtSession.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/http/webtransport/QuicWtSession.h>
 
 #include <proxygen/lib/http/codec/HQFramer.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::detail;
@@ -118,7 +119,7 @@ auto QuicWtSessionBase::createWtEgressHandle(StreamId id) noexcept
   const bool success = res.writeHandle;
   const bool bidi = success && res.readHandle;
   // canCreate(Uni|Bidi) checked in ::create(Uni|Bidi)Stream
-  XCHECK(success);
+  PRX_CHECK(success);
   quicSocket_->setStopSendingCallback(id, &stopSendingCb_);
   if (bidi) {
     sm_.setReadCb(*res.readHandle, &smCb_);
@@ -138,33 +139,33 @@ bool QuicWtSessionBase::hasEgressBidiCredit() const noexcept {
 
 folly::Expected<WebTransport::StreamWriteHandle*, WebTransport::ErrorCode>
 QuicWtSessionBase::createUniStream() noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (!hasEgressUniCredit()) {
     return folly::makeUnexpected(ErrorCode::STREAM_CREATION_ERROR);
   }
   auto id = quicSocket_->createUnidirectionalStream();
-  XCHECK(id);
-  XLOG(DBG6) << __func__ << "; id=" << *id;
-  return CHECK_NOTNULL(createWtEgressHandle(*id).writeHandle);
+  PRX_CHECK(id);
+  PRX_VLOG(6) << __func__ << "; id=" << *id;
+  return PRX_CHECK_NOTNULL(createWtEgressHandle(*id).writeHandle);
 }
 
 folly::Expected<WebTransport::BidiStreamHandle, WebTransport::ErrorCode>
 QuicWtSessionBase::createBidiStream() noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (!hasEgressBidiCredit()) {
     return folly::makeUnexpected(ErrorCode::STREAM_CREATION_ERROR);
   }
   auto id = quicSocket_->createBidirectionalStream();
-  XCHECK(id);
+  PRX_CHECK(id);
   auto res = createWtEgressHandle(*id);
-  XCHECK(res.readHandle && res.writeHandle);
-  XLOG(DBG6) << __func__ << "; id=" << *id;
+  PRX_CHECK(res.readHandle && res.writeHandle);
+  PRX_VLOG(6) << __func__ << "; id=" << *id;
   return res;
 }
 
 folly::SemiFuture<folly::Unit>
 QuicWtSessionBase::awaitUniStreamCredit() noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (hasEgressUniCredit()) {
     return folly::makeFuture(folly::unit);
   }
@@ -175,7 +176,7 @@ QuicWtSessionBase::awaitUniStreamCredit() noexcept {
 
 folly::SemiFuture<folly::Unit>
 QuicWtSessionBase::awaitBidiStreamCredit() noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   if (hasEgressBidiCredit()) {
     return folly::makeFuture(folly::unit);
   }
@@ -186,10 +187,10 @@ QuicWtSessionBase::awaitBidiStreamCredit() noexcept {
 
 folly::Expected<folly::Unit, WebTransport::ErrorCode>
 QuicWtSessionBase::sendDatagram(IoBufPtr datagram) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   auto writeRes = quicSocket_->writeDatagram(std::move(datagram));
   if (writeRes.hasError()) {
-    XLOG(ERR) << __func__ << "; err= " << writeRes.error();
+    PRX_LOG(ERROR) << __func__ << "; err= " << writeRes.error();
     return folly::makeUnexpected(ErrorCode::GENERIC_ERROR);
   }
   return folly::unit;
@@ -212,13 +213,13 @@ void QuicWtSessionBase::onDatagram(IoBufPtr dgram) noexcept {
 
 // -- QuicReadCallback overrides --
 void QuicWtSessionBase::QuicReadCallback::readAvailable(StreamId id) noexcept {
-  XCHECK(sess.quicSocket_);
+  PRX_CHECK(sess.quicSocket_);
   auto& sm = sess.sm_;
   auto& quicSocket = sess.quicSocket_;
 
   auto* rh = sm.getBidiHandle(id).readHandle;
   if (!rh) {
-    XLOG(ERR) << "nullptr rh id=" << id;
+    PRX_LOG(ERROR) << "nullptr rh id=" << id;
     return;
   }
   const auto canRead = sm.recvBytesAvail(*rh);
@@ -228,13 +229,13 @@ void QuicWtSessionBase::QuicReadCallback::readAvailable(StreamId id) noexcept {
   }
   auto readRes = quicSocket->read(id, canRead);
   if (readRes.hasError()) {
-    XLOG(ERR) << "::read err id=" << id;
+    PRX_LOG(ERROR) << "::read err id=" << id;
     return;
   }
   auto& [data, eof] = readRes.value();
   auto res = sm.enqueue(
       *rh, WebTransport::StreamData{.data = std::move(data), .fin = eof});
-  XCHECK_NE(res, WtStreamManager::Result::Fail);
+  PRX_CHECK_NE(res, WtStreamManager::Result::Fail);
   if (!eof) { // ::enqueue w/ eof=true may deallocate rh
     sess.maybePauseIngress(*rh);
   }
@@ -242,14 +243,14 @@ void QuicWtSessionBase::QuicReadCallback::readAvailable(StreamId id) noexcept {
 
 void QuicWtSessionBase::QuicReadCallback::readError(StreamId id,
                                                     QuicError error) noexcept {
-  XLOG(DBG4) << __func__ << "; id=" << id << "; err=" << error;
+  PRX_VLOG(4) << __func__ << "; id=" << id << "; err=" << error;
   sess.sm_.onResetStream(
       WtStreamManager::ResetStream{id, getQuicAppErrCode(error)});
 }
 
 void QuicWtSessionBase::QuicStopSendingCallback::onStopSending(
     StreamId id, quic::ApplicationErrorCode ec) noexcept {
-  XLOG(DBG4) << __func__ << "; id=" << id << "; err=" << ec;
+  PRX_VLOG(4) << __func__ << "; id=" << id << "; err=" << ec;
   sess.sm_.onStopSending(WtStreamManager::StopSending{id, ec});
 }
 
@@ -260,7 +261,7 @@ void QuicWtSessionBase::StreamManagerCallback::readReady(
 }
 
 void QuicWtSessionBase::StreamManagerCallback::eventsAvailable() noexcept {
-  XCHECK(sess.quicSocket_);
+  PRX_CHECK(sess.quicSocket_);
   // process control events first
   QuicWtEventVisitor visitor{*sess.quicSocket_, sess.observer_};
   auto events = sess.sm_.moveEvents();
@@ -270,29 +271,29 @@ void QuicWtSessionBase::StreamManagerCallback::eventsAvailable() noexcept {
   // then process writable streams
   while (!sess.priorityQueue_->empty()) {
     auto id = sess.priorityQueue_->getNextScheduledID(std::nullopt);
-    XCHECK(id.isStreamID());
+    PRX_CHECK(id.isStreamID());
     auto streamId = id.asStreamID();
     auto maxData = sess.quicSocket_->getMaxWritableOnStream(streamId);
     auto* wh = sess.sm_.getBidiHandle(streamId).writeHandle;
     if (!wh || !maxData) {
-      XLOG(DBG4) << "nullptr wh id=" << streamId;
+      PRX_VLOG(4) << "nullptr wh id=" << streamId;
       sess.priorityQueue_->erase(id);
       continue;
     }
     if (*maxData == 0) {
-      XLOG(DBG4) << "egress conn-fc blocked id=" << streamId;
+      PRX_VLOG(4) << "egress conn-fc blocked id=" << streamId;
       sess.priorityQueue_->erase(id);
       sess.quicSocket_->notifyPendingWriteOnStream(streamId, &sess);
       continue;
     }
     auto streamData = sess.sm_.dequeue(*wh, *maxData);
-    XCHECK(streamData.data || streamData.fin);
+    PRX_CHECK(streamData.data || streamData.fin);
     auto res = sess.quicSocket_->writeChain(streamId,
                                             std::move(streamData.data),
                                             streamData.fin,
                                             streamData.deliveryCallback);
     if (res.hasError()) {
-      XLOG(ERR) << "QuicSocket::writeChain err id=" << streamId;
+      PRX_LOG(ERROR) << "QuicSocket::writeChain err id=" << streamId;
       wh->resetStream(WebTransport::kInternalError);
     }
   }
@@ -315,7 +316,7 @@ void QuicWtSessionBase::onStreamWriteReady(quic::StreamId streamId,
 
 void QuicWtSessionBase::onStreamWriteError(quic::StreamId id,
                                            QuicError error) noexcept {
-  XLOG(ERR) << __func__ << "; id=" << id << "; err=" << error;
+  PRX_LOG(ERROR) << __func__ << "; id=" << id << "; err=" << error;
   if (auto* wh = sm_.getBidiHandle(id).writeHandle) {
     wh->resetStream(WebTransport::kInternalError);
   }
@@ -323,34 +324,35 @@ void QuicWtSessionBase::onStreamWriteError(quic::StreamId id,
 
 void QuicWtSessionBase::maybePauseIngress(
     WtStreamManager::WtReadHandle& handle) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   const auto id = handle.getID();
   if (sm_.recvBytesAvail(handle) == 0) {
-    XLOG(DBG4) << __func__ << "; id=" << id;
+    PRX_VLOG(4) << __func__ << "; id=" << id;
     auto res = quicSocket_->pauseRead(id);
-    XLOG_IF(ERR, res.hasError()) << __func__ << "; err id=" << id;
+    PRX_LOG_IF(ERROR, res.hasError()) << __func__ << "; err id=" << id;
   }
 }
 
 void QuicWtSessionBase::maybeResumeIngress(
     WtStreamManager::WtReadHandle& handle) noexcept {
-  XCHECK(quicSocket_);
+  PRX_CHECK(quicSocket_);
   const auto id = handle.getID();
   if (sm_.recvBytesAvail(handle) > 0) {
-    XLOG(DBG4) << __func__ << "; id=" << id;
+    PRX_VLOG(4) << __func__ << "; id=" << id;
     auto res = quicSocket_->resumeRead(id);
-    XLOG_IF(ERR, res.hasError()) << __func__ << "; err id=" << id;
+    PRX_LOG_IF(ERROR, res.hasError()) << __func__ << "; err id=" << id;
   }
 }
 
 bool QuicWtSessionBase::acquireIngressStream(uint64_t id) noexcept {
-  XCHECK(quicSocket_ && quic::isRemoteStream(quicSocket_->getNodeType(), id));
-  XCHECK(wtHandler_);
+  PRX_CHECK(quicSocket_ &&
+            quic::isRemoteStream(quicSocket_->getNodeType(), id));
+  PRX_CHECK(wtHandler_);
   // WtStreamManager deduces type from id (i.e. works whether uni or bidi)
   auto handle = sm_.getOrCreateBidiHandle(id);
   const bool success = handle.readHandle;
   const bool bidi = success && handle.writeHandle;
-  XLOG(DBG6) << __func__ << "; id=" << id << "; ok=" << success;
+  PRX_VLOG(6) << __func__ << "; id=" << id << "; ok=" << success;
   if (success) {
     sm_.setReadCb(*handle.readHandle, &smCb_);
     quicSocket_->setReadCallback(id, &readCb_);
@@ -410,13 +412,13 @@ QuicWtSession::closeSession(folly::Optional<uint32_t> error) noexcept {
 void QuicWtSession::QuicConnectionCallback::onNewBidirectionalStream(
     StreamId id) noexcept {
   // always expected to succeed as config.peerMaxStreamsBidi = inf
-  XCHECK(sess.acquireIngressStream(id));
+  PRX_CHECK(sess.acquireIngressStream(id));
 }
 
 void QuicWtSession::QuicConnectionCallback::onNewUnidirectionalStream(
     StreamId id) noexcept {
   // always expected to succeed as config.peerMaxStreamsUni = inf
-  XCHECK(sess.acquireIngressStream(id));
+  PRX_CHECK(sess.acquireIngressStream(id));
 }
 
 void QuicWtSession::QuicConnectionCallback::onConnectionEnd() noexcept {
@@ -448,17 +450,17 @@ void QuicWtSession::QuicConnectionCallback::onUnidirectionalStreamsAvailable(
 }
 
 void QuicWtSession::QuicDgramCallback::onDatagramsAvailable() noexcept {
-  XCHECK(sess.quicSocket_);
+  PRX_CHECK(sess.quicSocket_);
   auto& quicSocket = sess.quicSocket_;
 
   auto result = quicSocket->readDatagramBufs();
   if (result.hasError()) {
-    XLOG(ERR) << __func__ << "; err=" << toString(result.error());
+    PRX_LOG(ERROR) << __func__ << "; err=" << toString(result.error());
     sess.closeSession(WebTransport::kInternalError);
     return;
   }
 
-  XLOG(DBG4) << "rx nDatagrams=" << result->size();
+  PRX_VLOG(4) << "rx nDatagrams=" << result->size();
   for (auto& dgram : result.value()) {
     sess.onDatagram(std::move(dgram));
   }
@@ -475,7 +477,7 @@ H3WtSession::H3WtSession(std::shared_ptr<quic::QuicSocket> quicSocket,
           std::move(wtConfig),
           &observer),
       connectStreamId_(connectStreamId) {
-  XCHECK_LE(connectStreamId, detail::kMaxVarint);
+  PRX_CHECK_LE(connectStreamId, detail::kMaxVarint);
 }
 
 H3WtSession::~H3WtSession() noexcept {
@@ -483,14 +485,14 @@ H3WtSession::~H3WtSession() noexcept {
 }
 
 void H3WtSession::onWtSession(std::shared_ptr<WebTransport> wt) noexcept {
-  CHECK_NOTNULL(wtHandler_.get())->onWebTransportSession(std::move(wt));
+  PRX_CHECK_NOTNULL(wtHandler_.get())->onWebTransportSession(std::move(wt));
 }
 
 folly::Expected<folly::Unit, WebTransport::ErrorCode> H3WtSession::closeSession(
     folly::Optional<uint32_t> error) noexcept {
   // we need to bidi reset all assoc quic streams (ss+rst_stream)
   auto streamIds = sm_.streamIds();
-  XLOG(DBG4) << __func__ << "; nStreams=" << streamIds.size();
+  PRX_VLOG(4) << __func__ << "; nStreams=" << streamIds.size();
   const uint32_t ec = error.value_or(0);
   // bidirectionally reset all assoc quic streams
   for (uint64_t id : streamIds) {
@@ -516,7 +518,7 @@ folly::Expected<folly::Unit, WebTransport::ErrorCode> H3WtSession::sendDatagram(
   folly::io::QueueAppender appender(&queue, kGrowth);
   auto encodeRes = quic::encodeQuicInteger(
       quarterStreamId, [&appender](auto val) { appender.writeBE(val); });
-  XCHECK(encodeRes);
+  PRX_CHECK(encodeRes);
   queue.append(std::move(datagram));
   return QuicWtSessionBase::sendDatagram(queue.move());
 }
@@ -544,8 +546,8 @@ void H3WtSession::writeWtFramePrefix(uint64_t id) noexcept {
                         ? hq::WebTransportStreamType::BIDI
                         : hq::WebTransportStreamType::UNI;
   folly::IOBufQueue writeBuf{folly::IOBufQueue::cacheChainLength()};
-  XCHECK(hq::writeWTStreamPreface(writeBuf, streamType, connectStreamId_));
-  XCHECK(quicSocket_->writeChain(id, writeBuf.move(), false));
+  PRX_CHECK(hq::writeWTStreamPreface(writeBuf, streamType, connectStreamId_));
+  PRX_CHECK(quicSocket_->writeChain(id, writeBuf.move(), false));
 }
 
 auto H3WtSession::onConnMaxData(WtStreamManager::MaxConnData mcd) noexcept
@@ -575,7 +577,7 @@ void H3WtSession::onDrainSession(WtStreamManager::DrainSession ds) noexcept {
 }
 void H3WtSession::onCloseSession(WtStreamManager::CloseSession&& cs) noexcept {
   // TODO(@damlaj): change WebTransport::closeSession to take a std::string msg?
-  XLOG(DBG4) << __func__ << "; cs=" << cs.err << "; msg=" << cs.msg;
+  PRX_VLOG(4) << __func__ << "; cs=" << cs.err << "; msg=" << cs.msg;
   closeSession(cs.err);
 }
 
diff --git a/proxygen/lib/http/webtransport/QuicWtSession.h b/proxygen/lib/http/webtransport/QuicWtSession.h
index 352b7909c6..f7c443bdac 100644
--- a/proxygen/lib/http/webtransport/QuicWtSession.h
+++ b/proxygen/lib/http/webtransport/QuicWtSession.h
@@ -8,10 +8,10 @@
 
 #pragma once
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/webtransport/WebTransport.h>
 #include <proxygen/lib/http/webtransport/WtStreamManager.h>
 #include <proxygen/lib/http/webtransport/WtUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 
@@ -43,7 +43,7 @@ class QuicWtSessionBase
     , private quic::StreamWriteCallback {
  public:
   [[nodiscard]] quic::TransportInfo getTransportInfo() const noexcept override {
-    XCHECK(quicSocket_);
+    PRX_CHECK(quicSocket_);
     return quicSocket_->getTransportInfo();
   }
 
diff --git a/proxygen/lib/http/webtransport/WebTransport.cpp b/proxygen/lib/http/webtransport/WebTransport.cpp
index 0122124c01..8878f75ff0 100644
--- a/proxygen/lib/http/webtransport/WebTransport.cpp
+++ b/proxygen/lib/http/webtransport/WebTransport.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/http/webtransport/WebTransport.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -39,7 +40,7 @@ WebTransport::toApplicationErrorCode(uint64_t h) {
   }
   uint64_t shifted = h - kFirstErrorCode;
   uint64_t appErrorCode = shifted - (shifted / 0x1f);
-  DCHECK_LE(appErrorCode, std::numeric_limits<uint32_t>::max());
+  PRX_DCHECK_LE(appErrorCode, std::numeric_limits<uint32_t>::max());
   return static_cast<uint32_t>(appErrorCode);
 }
 
diff --git a/proxygen/lib/http/webtransport/WebTransportImpl.cpp b/proxygen/lib/http/webtransport/WebTransportImpl.cpp
index 7c75d39c69..70565279c5 100644
--- a/proxygen/lib/http/webtransport/WebTransportImpl.cpp
+++ b/proxygen/lib/http/webtransport/WebTransportImpl.cpp
@@ -8,7 +8,7 @@
 
 #include <proxygen/lib/http/webtransport/WebTransportImpl.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -39,8 +39,8 @@ void WebTransportImpl::terminateSessionStreams(uint32_t errorCode,
   auto wtIngressStreams = std::move(wtIngressStreams_);
   for (auto& [id, stream] : wtIngressStreams) {
     // Deliver an error to the application if needed
-    VLOG(4) << "aborting wt ingress id=" << id << " err=" << errorCode
-            << "; open=" << int(stream.open());
+    PRX_VLOG(4) << "aborting wt ingress id=" << id << " err=" << errorCode
+                << "; open=" << int(stream.open());
     if (stream.open()) {
       stream.deliverReadError(WebTransport::Exception(errorCode, reason));
       stopReadingWebTransportIngress(id, errorCode);
@@ -67,7 +67,7 @@ void WebTransportImpl::onMaxData(uint64_t maxData) noexcept {
       currIt->second.flushBufferedWrites();
     }
   } else {
-    VLOG(4) << __func__ << " failed to grant maxData=" << maxData;
+    PRX_VLOG(4) << __func__ << " failed to grant maxData=" << maxData;
   }
 }
 
@@ -85,8 +85,8 @@ void WebTransportImpl::onMaxStreams(uint64_t maxStreams, bool isBidi) noexcept {
 void WebTransportImpl::onStreamsBlocked(uint64_t maxStreams,
                                         bool isBidi) noexcept {
   if (shouldGrantStreamCredit(isBidi)) {
-    LOG(ERROR) << __func__ << " maxStreams=" << maxStreams
-               << "; shouldGrantStreamCredit";
+    PRX_LOG(ERROR) << __func__ << " maxStreams=" << maxStreams
+                   << "; shouldGrantStreamCredit";
     auto& flowControl =
         isBidi ? peerBidiStreamFlowControl_ : peerUniStreamFlowControl_;
     flowControl.maxStreamID += flowControl.targetConcurrentStreams / 2;
@@ -99,8 +99,8 @@ void WebTransportImpl::onDataBlocked(uint64_t maxData) noexcept {
     return;
   }
   if (shouldGrantFlowControl()) {
-    LOG(ERROR) << __func__ << " maxData=" << maxData
-               << "; shouldGrantFlowControl";
+    PRX_LOG(ERROR) << __func__ << " maxData=" << maxData
+                   << "; shouldGrantFlowControl";
     auto newMaxData =
         recvFlowController_.getMaxOffset() + kDefaultWTReceiveWindow;
     recvFlowController_.grant(newMaxData);
@@ -235,58 +235,58 @@ WebTransportImpl::StreamWriteHandle::writeStreamData(
     std::unique_ptr<folly::IOBuf> data,
     bool fin,
     ByteEventCallback* deliveryCallback) {
-  VLOG(4) << __func__ << " data=" << data.get() << " fin=" << fin
-          << " deliveryCallback=" << deliveryCallback << " ex=" << bool(ex_)
-          << " bufferedWrites_.size()=" << bufferedWrites_.size();
+  PRX_VLOG(4) << __func__ << " data=" << data.get() << " fin=" << fin
+              << " deliveryCallback=" << deliveryCallback << " ex=" << bool(ex_)
+              << " bufferedWrites_.size()=" << bufferedWrites_.size();
 
   if (ex_) {
     return folly::makeUnexpected(WebTransport::ErrorCode::STOP_SENDING);
   }
   if (!data && !fin) {
-    LOG(ERROR) << "Empty write with no FIN";
+    PRX_LOG(ERROR) << "Empty write with no FIN";
     return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
   }
 
   impl_.sp_.refreshTimeout();
 
   if (bufferedWrites_.empty()) {
-    VLOG(4) << __func__ << " Emplacing new buffered write (empty queue)";
+    PRX_VLOG(4) << __func__ << " Emplacing new buffered write (empty queue)";
     bufferedWrites_.emplace_back(std::move(data), deliveryCallback, fin);
   } else {
     auto& last = bufferedWrites_.back();
     if (last.fin) {
-      LOG(ERROR) << __func__
-                 << " Last buffered write has FIN, ret=GENERIC_ERROR";
+      PRX_LOG(ERROR) << __func__
+                     << " Last buffered write has FIN, ret=GENERIC_ERROR";
       return folly::makeUnexpected(WebTransport::ErrorCode::GENERIC_ERROR);
     }
     if (last.deliveryCallback == nullptr) {
-      VLOG(4) << __func__ << " Updating last buffered write";
+      PRX_VLOG(4) << __func__ << " Updating last buffered write";
       if (data) {
         last.buf.append(std::move(data));
       }
       last.deliveryCallback = deliveryCallback;
       last.fin = fin;
     } else {
-      VLOG(4) << __func__ << " Emplacing new buffered write";
+      PRX_VLOG(4) << __func__ << " Emplacing new buffered write";
       bufferedWrites_.emplace_back(std::move(data), deliveryCallback, fin);
     }
   }
 
-  VLOG(4) << __func__
-          << " Flushing buffered writes, size=" << bufferedWrites_.size();
+  PRX_VLOG(4) << __func__
+              << " Flushing buffered writes, size=" << bufferedWrites_.size();
   return flushBufferedWrites();
 }
 
 folly::Expected<folly::SemiFuture<uint64_t>, WebTransport::ErrorCode>
 WebTransportImpl::StreamWriteHandle::awaitWritable() {
-  CHECK(!writePromise_.valid()) << "awaitWritable already called";
+  PRX_CHECK(!writePromise_.valid()) << "awaitWritable already called";
   auto contract = folly::makePromiseContract<uint64_t>();
   writePromise_ = std::move(contract.promise);
   writePromise_.setInterruptHandler([this](const folly::exception_wrapper& ex) {
-    VLOG(4) << "Exception from interrupt handler ex=" << ex.what();
+    PRX_VLOG(4) << "Exception from interrupt handler ex=" << ex.what();
     // if awaitWritable is cancelled, just reset it
-    CHECK(ex.with_exception([this](const folly::FutureCancellation& ex) {
-      VLOG(5) << "Setting exception ex=" << ex.what();
+    PRX_CHECK(ex.with_exception([this](const folly::FutureCancellation& ex) {
+      PRX_VLOG(5) << "Setting exception ex=" << ex.what();
       writePromise_.setException(ex);
       writePromise_ = emptyWritePromise();
     })) << "Unexpected exception type";
@@ -326,14 +326,14 @@ void WebTransportImpl::StreamWriteHandle::onStreamWriteReady(
 folly::Expected<WebTransport::FCState, WebTransport::ErrorCode>
 WebTransportImpl::StreamWriteHandle::flushBufferedWrites() {
   auto availableSpace = impl_.sendFlowController_.getAvailable();
-  VLOG(4) << __func__ << " availableSpace=" << availableSpace
-          << " bufferedWrites_.size()=" << bufferedWrites_.size();
+  PRX_VLOG(4) << __func__ << " availableSpace=" << availableSpace
+              << " bufferedWrites_.size()=" << bufferedWrites_.size();
 
   while (availableSpace > 0 && !bufferedWrites_.empty()) {
     auto& frontEntry = bufferedWrites_.front();
-    VLOG(4) << __func__ << " Processing frontEntry, buf.len="
-            << frontEntry.buf.chainLength() << " fin=" << frontEntry.fin
-            << " deliveryCallback=" << frontEntry.deliveryCallback;
+    PRX_VLOG(4) << __func__ << " Processing frontEntry, buf.len="
+                << frontEntry.buf.chainLength() << " fin=" << frontEntry.fin
+                << " deliveryCallback=" << frontEntry.deliveryCallback;
     // Prefer move when we can send the entire buffer; avoid computing chain
     // length
     std::unique_ptr<folly::IOBuf> bufToSend;
@@ -345,7 +345,7 @@ WebTransportImpl::StreamWriteHandle::flushBufferedWrites() {
       bufToSend = frontEntry.buf.splitAtMost(availableSpace); // partial send
     }
 
-    VLOG(4) << __func__ << " bufToSendLen=" << bufToSendLen;
+    PRX_VLOG(4) << __func__ << " bufToSendLen=" << bufToSendLen;
     availableSpace -= bufToSendLen;
     ByteEventCallback* sendDeliveryCallback = nullptr;
     bool sendFin = false;
@@ -353,31 +353,31 @@ WebTransportImpl::StreamWriteHandle::flushBufferedWrites() {
     if (frontEntry.buf.empty()) {
       sendDeliveryCallback = frontEntry.deliveryCallback;
       sendFin = frontEntry.fin;
-      VLOG(4) << __func__ << " frontEntry.buf empty, sendFin=" << sendFin;
+      PRX_VLOG(4) << __func__ << " frontEntry.buf empty, sendFin=" << sendFin;
       bufferedWrites_.pop_front();
     }
 
-    VLOG(4) << __func__ << " Sending data on stream id=" << id_
-            << " sendFin=" << sendFin
-            << " sendDeliveryCallback=" << sendDeliveryCallback;
+    PRX_VLOG(4) << __func__ << " Sending data on stream id=" << id_
+                << " sendFin=" << sendFin
+                << " sendDeliveryCallback=" << sendDeliveryCallback;
     auto res = impl_.sendWebTransportStreamData(
         id_, std::move(bufToSend), sendFin, sendDeliveryCallback);
 
     if (res.hasError()) {
-      VLOG(4) << __func__
-              << " sendWebTransportStreamData error=" << uint32_t(res.error());
+      PRX_VLOG(4) << __func__ << " sendWebTransportStreamData error="
+                  << uint32_t(res.error());
       return folly::makeUnexpected(res.error());
     }
 
     if (sendFin || *res == WebTransport::FCState::BLOCKED) {
-      VLOG(4) << __func__ << " sendFin=" << sendFin
-              << " or FCState::BLOCKED, ret=" << uint32_t(*res);
+      PRX_VLOG(4) << __func__ << " sendFin=" << sendFin
+                  << " or FCState::BLOCKED, ret=" << uint32_t(*res);
       return *res;
     }
   }
 
-  VLOG(4) << __func__
-          << " Done, bufferedWrites_.empty()=" << bufferedWrites_.empty();
+  PRX_VLOG(4) << __func__
+              << " Done, bufferedWrites_.empty()=" << bufferedWrites_.empty();
 
   if (!bufferedWrites_.empty()) {
     impl_.tp_.sendWTDataBlocked(impl_.sendFlowController_.getMaxOffset());
@@ -419,29 +419,29 @@ WebTransportImpl::StreamReadHandle::StreamReadHandle(WebTransportImpl& impl,
 
 folly::SemiFuture<StreamData>
 WebTransportImpl::StreamReadHandle::readStreamData() {
-  VLOG(4) << __func__;
-  CHECK(!readPromise_.valid()) << "One read at a time";
+  PRX_VLOG(4) << __func__;
+  PRX_CHECK(!readPromise_.valid()) << "One read at a time";
   if (ex_) {
     auto ex = ex_;
     impl_.closeIngressStream(getID());
     return folly::makeSemiFuture<StreamData>(std::move(ex));
   } else if (buf_.empty() && !eof_) {
-    VLOG(4) << __func__ << " waiting for data";
+    PRX_VLOG(4) << __func__ << " waiting for data";
     auto contract = folly::makePromiseContract<StreamData>();
     readPromise_ = std::move(contract.promise);
-    readPromise_.setInterruptHandler(
-        [this](const folly::exception_wrapper& ex) {
-          VLOG(4) << "Exception from interrupt handler ex=" << ex.what();
-          CHECK(ex.with_exception([this](const folly::FutureCancellation& ex) {
-            // TODO: allow app to configure the reset code on cancellation?
-            impl_.tp_.stopReadingWebTransportIngress(
-                id_, WebTransport::kInternalError);
-            deliverReadError(ex);
-          })) << "Unexpected exception type";
-        });
+    readPromise_.setInterruptHandler([this](
+                                         const folly::exception_wrapper& ex) {
+      PRX_VLOG(4) << "Exception from interrupt handler ex=" << ex.what();
+      PRX_CHECK(ex.with_exception([this](const folly::FutureCancellation& ex) {
+        // TODO: allow app to configure the reset code on cancellation?
+        impl_.tp_.stopReadingWebTransportIngress(id_,
+                                                 WebTransport::kInternalError);
+        deliverReadError(ex);
+      })) << "Unexpected exception type";
+    });
     return std::move(contract.future);
   } else {
-    VLOG(4) << __func__ << " returning data len=" << buf_.chainLength();
+    PRX_VLOG(4) << __func__ << " returning data len=" << buf_.chainLength();
     auto bufLen = buf_.chainLength();
     StreamData streamData({.data = buf_.move(), .fin = eof_});
     impl_.maybeGrantFlowControl(bufLen);
@@ -450,7 +450,7 @@ WebTransportImpl::StreamReadHandle::readStreamData() {
       // unregister the read callback, but don't send STOP_SENDING
       impl_.stopReadingWebTransportIngress(id_, folly::none);
     } else if (bufLen >= kMaxWTIngressBuf) {
-      VLOG(4) << __func__ << " resuming reads";
+      PRX_VLOG(4) << __func__ << " resuming reads";
       impl_.tp_.resumeWebTransportIngress(getID());
     }
     return folly::makeFuture(std::move(streamData));
@@ -462,7 +462,8 @@ void WebTransportImpl::StreamReadHandle::readAvailable(
   impl_.sp_.refreshTimeout();
   auto readRes = impl_.tp_.readWebTransportData(id, 65535);
   if (readRes.hasError()) {
-    LOG(ERROR) << "Got synchronous read error=" << uint32_t(readRes.error());
+    PRX_LOG(ERROR) << "Got synchronous read error="
+                   << uint32_t(readRes.error());
     readError(id,
               quic::QuicError(quic::LocalErrorCode::INTERNAL_ERROR,
                               "sync read error"));
@@ -478,14 +479,14 @@ void WebTransportImpl::StreamReadHandle::readAvailable(
     return;
   }
   if (state == WebTransport::FCState::BLOCKED && !eof) {
-    VLOG(4) << __func__ << " pausing reads";
+    PRX_VLOG(4) << __func__ << " pausing reads";
     impl_.tp_.pauseWebTransportIngress(id);
   }
 }
 
 WebTransport::FCState WebTransportImpl::StreamReadHandle::dataAvailable(
     std::unique_ptr<folly::IOBuf> data, bool eof) {
-  VLOG(4)
+  PRX_VLOG(4)
       << "dataAvailable buflen=" << (data ? data->computeChainDataLength() : 0)
       << " eof=" << uint64_t(eof);
 
@@ -507,7 +508,7 @@ WebTransport::FCState WebTransportImpl::StreamReadHandle::dataAvailable(
   } else {
     buf_.append(std::move(data)); // ok if nullptr
   }
-  VLOG(4) << "dataAvailable buflen=" << buf_.chainLength();
+  PRX_VLOG(4) << "dataAvailable buflen=" << buf_.chainLength();
   return (eof || buf_.chainLength() < kMaxWTIngressBuf)
              ? WebTransport::FCState::UNBLOCKED
              : WebTransport::FCState::BLOCKED;
@@ -534,7 +535,7 @@ void WebTransportImpl::StreamReadHandle::readError(
         WebTransport::Exception(*appErrorCode, "received reset_stream"));
     return;
   } else {
-    VLOG(4) << error;
+    PRX_VLOG(4) << error;
   }
   // any other error
   deliverReadError(WebTransport::Exception(
@@ -567,7 +568,7 @@ void WebTransportImpl::maybeGrantStreamCredit(HTTPCodec::StreamID id,
   if (isSessionTerminated()) {
     return;
   }
-  CHECK(closingReadHandle || closingWriteHandle);
+  PRX_CHECK(closingReadHandle || closingWriteHandle);
   bool isBidi = isBidirectional(id);
   bool canGrantCredit = false;
 
@@ -598,7 +599,7 @@ bool WebTransportImpl::shouldGrantFlowControl() const {
 bool WebTransportImpl::shouldGrantStreamCredit(bool isBidi) const {
   auto& streamLimits =
       isBidi ? peerBidiStreamFlowControl_ : peerUniStreamFlowControl_;
-  CHECK(streamLimits.numClosedStreams <= streamLimits.maxStreamID);
+  PRX_CHECK(streamLimits.numClosedStreams <= streamLimits.maxStreamID);
   return streamLimits.maxStreamID - streamLimits.numClosedStreams <
          (streamLimits.targetConcurrentStreams / 2);
 }
diff --git a/proxygen/lib/http/webtransport/WebTransportSession.cpp b/proxygen/lib/http/webtransport/WebTransportSession.cpp
index d4094a7787..38ef6e73a6 100644
--- a/proxygen/lib/http/webtransport/WebTransportSession.cpp
+++ b/proxygen/lib/http/webtransport/WebTransportSession.cpp
@@ -7,6 +7,7 @@
  */
 
 #include <proxygen/lib/http/webtransport/WebTransportSession.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::detail {
 
@@ -72,7 +73,7 @@ WtHttpSession::WtHttpSession(WtLooper& readLoop, WtLooper& writeLoop) noexcept
 
 void WtHttpSession::writesDone() noexcept {
   bool wasWritesDone = std::exchange(writesDone_, true);
-  VLOG(6) << "readsDone=" << readsDone_ << "; writesDone=" << writesDone_;
+  PRX_VLOG(6) << "readsDone=" << readsDone_ << "; writesDone=" << writesDone_;
   if (!wasWritesDone && readsDone_) {
     onDone();
     self.reset();
@@ -81,7 +82,7 @@ void WtHttpSession::writesDone() noexcept {
 
 void WtHttpSession::readsDone() noexcept {
   bool wasReadsDone = std::exchange(readsDone_, true);
-  VLOG(6) << "readsDone=" << readsDone_ << "; writesDone=" << writesDone_;
+  PRX_VLOG(6) << "readsDone=" << readsDone_ << "; writesDone=" << writesDone_;
   if (!wasReadsDone && writesDone_) {
     onDone();
     self.reset();
@@ -180,7 +181,7 @@ const folly::SocketAddress& H2WtSession::getPeerAddress() const noexcept {
 
 void WtLooper::schedule() noexcept {
   bool scheduled = isLoopCallbackScheduled();
-  VLOG(6) << "type=" << type_ << "; scheduled=" << scheduled;
+  PRX_VLOG(6) << "type=" << type_ << "; scheduled=" << scheduled;
   if (!scheduled) {
     evb_->runInLoop(this);
   } // otherwise already scheduled
@@ -205,15 +206,15 @@ WebTransportReadLoop::WebTransportReadLoop(
 void WebTransportReadLoop::runLoopCallback() noexcept {
   auto& txnHandler = wtHttpSess_.txnHandler_;
   auto [data, eom] = txnHandler.moveBufferedIngress();
-  CHECK(data || eom || txnHandler.ex_);
-  VLOG(6) << __func__ << "; buf=" << data.get() << "; eom=" << eom;
+  PRX_CHECK(data || eom || txnHandler.ex_);
+  PRX_VLOG(6) << __func__ << "; buf=" << data.get() << "; eom=" << eom;
   wtCodec_.onIngress(std::move(data), eom);
   { // handle any new peer streams
     NotifyPeerStreamsGuard notify{*this, sm_, *wtHandler_};
   }
 
   if (eom || txnHandler.ex_) {
-    VLOG(4) << "h2 wt ingress eom=" << eom << "; ex=" << txnHandler.ex_;
+    PRX_VLOG(4) << "h2 wt ingress eom=" << eom << "; ex=" << txnHandler.ex_;
     sm_.shutdown(WtStreamManager::CloseSession{WebTransport::kInternalError,
                                                "h2 stream ingress closed"});
     wtHttpSess_.readsDone(); // might delete this
@@ -240,8 +241,8 @@ void WebTransportWriteLoop::runLoopCallback() noexcept {
     const bool writesDone = wtHttpSess_.writesDone_;
     const bool egressPaused = txnHandler.egressPaused_;
     const bool loop = !writesDone && txn && !egressPaused;
-    VLOG(6) << "writesDone=" << writesDone << "; txn=" << txn
-            << "; egressPaused=" << egressPaused << "; loop=" << loop;
+    PRX_VLOG(6) << "writesDone=" << writesDone << "; txn=" << txn
+                << "; egressPaused=" << egressPaused << "; loop=" << loop;
     return loop;
   };
 
@@ -257,8 +258,8 @@ void WebTransportWriteLoop::runLoopCallback() noexcept {
   txn->sendBody(buf_.move());
   // write stream data
   while (auto* wh = sm_.nextWritable()) {
-    VLOG(4) << "id=" << wh->getID() << "; wh=" << wh
-            << "; egressPaused=" << txnHandler.egressPaused_;
+    PRX_VLOG(4) << "id=" << wh->getID() << "; wh=" << wh
+                << "; egressPaused=" << txnHandler.egressPaused_;
     if (txnHandler.egressPaused_) {
       return;
     }
@@ -316,7 +317,7 @@ void WebTransportTxnHandler::onEOM() noexcept {
 }
 
 void WebTransportTxnHandler::onError(const HTTPException& error) noexcept {
-  VLOG(6) << __func__ << "; ex=" << error.describe();
+  PRX_VLOG(6) << __func__ << "; ex=" << error.describe();
   if (wtClientCb_) { // terminal event for WtClientCb
     std::exchange(wtClientCb_, nullptr)->onErr(error);
   }
@@ -330,14 +331,14 @@ void WebTransportTxnHandler::onDatagram(
 }
 
 void WebTransportTxnHandler::onEgressPaused() noexcept {
-  VLOG(6) << __func__;
+  PRX_VLOG(6) << __func__;
   // cancel writeLoopCb if scheduled
   writeLooper_.cancel();
   egressPaused_ = true;
 }
 
 void WebTransportTxnHandler::onEgressResumed() noexcept {
-  VLOG(6) << __func__;
+  PRX_VLOG(6) << __func__;
   // schedule writeLoopCb
   writeLooper_.schedule();
   egressPaused_ = false;
@@ -358,14 +359,14 @@ auto WtClientCallback::resetPromise() noexcept -> WtReqResultPromise {
 void WtClientCallback::onHeaders(std::unique_ptr<HTTPMessage> msg) noexcept {
   if (msg->isFinal()) {
     auto p = resetPromise();
-    CHECK(p.valid());
+    PRX_CHECK(p.valid());
     p.setValue(std::move(msg));
   }
 }
 
 void WtClientCallback::onErr(const HTTPException& ex) noexcept {
   auto p = resetPromise();
-  CHECK(p.valid());
+  PRX_CHECK(p.valid());
   p.setException(ex);
 }
 
diff --git a/proxygen/lib/http/webtransport/WtEgressContainer.cpp b/proxygen/lib/http/webtransport/WtEgressContainer.cpp
index 5d39ab51d8..d5e67802ae 100644
--- a/proxygen/lib/http/webtransport/WtEgressContainer.cpp
+++ b/proxygen/lib/http/webtransport/WtEgressContainer.cpp
@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/webtransport/WtEgressContainer.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::detail {
 
@@ -27,7 +27,7 @@ WtBufferedStreamData::FcRes WtBufferedStreamData::enqueue(
     std::unique_ptr<folly::IOBuf> data,
     bool fin,
     proxygen::WebTransport::ByteEventCallback* callback) noexcept {
-  XCHECK(pendingWrites_.empty() || !pendingWrites_.back().fin)
+  PRX_CHECK(pendingWrites_.empty() || !pendingWrites_.back().fin)
       << "enqueue after fin";
 
   auto len = data ? data->computeChainDataLength() : 0;
diff --git a/proxygen/lib/http/webtransport/WtEgressContainer.h b/proxygen/lib/http/webtransport/WtEgressContainer.h
index ee36dc238d..305807e0ed 100644
--- a/proxygen/lib/http/webtransport/WtEgressContainer.h
+++ b/proxygen/lib/http/webtransport/WtEgressContainer.h
@@ -15,6 +15,7 @@
 
 #include <folly/io/IOBufQueue.h>
 #include <list>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::detail {
 
@@ -43,7 +44,7 @@ struct BufferedFlowController {
   // increment)
   void commit(uint64_t len) {
     window_.reserve(len);
-    CHECK_LE(getCurrentOffset(), getBufferedOffset());
+    PRX_CHECK_LE(getCurrentOffset(), getBufferedOffset());
   }
 
   [[nodiscard]] bool grant(uint64_t offset) {
diff --git a/proxygen/lib/http/webtransport/WtStreamManager.cpp b/proxygen/lib/http/webtransport/WtStreamManager.cpp
index 1b4a36ddd5..d5cc362a16 100644
--- a/proxygen/lib/http/webtransport/WtStreamManager.cpp
+++ b/proxygen/lib/http/webtransport/WtStreamManager.cpp
@@ -64,7 +64,7 @@
 #include <proxygen/lib/http/webtransport/WtStreamManager.h>
 
 #include <deque>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 // fwd decls for Accessor
 namespace {
@@ -162,6 +162,15 @@ enum class WriteHandleState : uint8_t {
   Closed    /* invalid, tx rst_stream or eom sent */
 };
 
+[[maybe_unused]] inline std::ostream& operator<<(std::ostream& os,
+                                                 ReadHandleState s) {
+  return os << static_cast<uint32_t>(s);
+}
+[[maybe_unused]] inline std::ostream& operator<<(std::ostream& os,
+                                                 WriteHandleState s) {
+  return os << static_cast<uint32_t>(s);
+}
+
 struct ReadHandle : public WebTransport::StreamReadHandle {
   // why doesn't using StreamReadHandle::StreamReadHandle work here?
   ReadHandle(uint64_t id, uint64_t initRecvWnd, Accessor acc) noexcept;
@@ -229,14 +238,14 @@ namespace proxygen::detail {
 void Accessor::maybeGrantFc(ReadHandle* rh, uint64_t bytesRead) noexcept {
   // TODO(@damlaj): user-defined flow control values and release when 50% is
   // read
-  XLOG(DBG6) << __func__ << "; rh=" << rh;
+  PRX_VLOG(6) << __func__ << "; rh=" << rh;
   if (rh) { // handle stream-level flow control
     uint64_t initStreamRecvFc = sm_.initStreamRecvFc(rh->getID());
     auto& streamRecv = rh->streamRecvFc_;
     // if peer has less than rwnd / 2 to send, issue fc
     bool issueFc = streamRecv.getAvailable() <= (initStreamRecvFc / 2);
-    XLOG(DBG6) << __func__ << "avail=" << streamRecv.getAvailable()
-               << "; issue=" << issueFc;
+    PRX_VLOG(6) << __func__ << "avail=" << streamRecv.getAvailable()
+                << "; issue=" << issueFc;
     if (issueFc) {
       streamRecv.grant(streamRecv.getCurrentOffset() + initStreamRecvFc);
       sm_.enqueueEvent(MaxStreamData{{streamRecv.getMaxOffset()}, rh->getID()});
@@ -248,9 +257,9 @@ void Accessor::maybeGrantFc(ReadHandle* rh, uint64_t bytesRead) noexcept {
   sm_.connBytesRead_ += bytesRead;
   bool issueFc =
       (connRecv.getMaxOffset() - sm_.connBytesRead_) <= (initConnRecvFc / 2);
-  XLOG(DBG6) << __func__ << "; connMaxOffset=" << connRecv.getMaxOffset()
-             << "; connBytesRead_" << sm_.connBytesRead_
-             << "; issue=" << issueFc;
+  PRX_VLOG(6) << __func__ << "; connMaxOffset=" << connRecv.getMaxOffset()
+              << "; connBytesRead_" << sm_.connBytesRead_
+              << "; issue=" << issueFc;
   if (issueFc) {
     connRecv.grant(connRecv.getCurrentOffset() + initConnRecvFc);
     sm_.enqueueEvent(MaxConnData{connRecv.getMaxOffset()});
@@ -272,14 +281,14 @@ void Accessor::onStreamWritable(WriteHandle& wh) noexcept {
 }
 
 void Accessor::done(WriteHandle& wh) noexcept {
-  XCHECK_EQ(wh.state_, WriteHandleState::Closed);
+  PRX_CHECK_EQ(wh.state_, WriteHandleState::Closed);
   if (wh.rh_->state_ == ReadHandleState::Closed) { // bidi done
     sm_.erase(wh.getID());
   }
 }
 
 void Accessor::done(ReadHandle& rh) noexcept {
-  XCHECK_EQ(rh.state_, ReadHandleState::Closed);
+  PRX_CHECK_EQ(rh.state_, ReadHandleState::Closed);
   if (rh.wh_->state_ == WriteHandleState::Closed) { // bidi done
     sm_.erase(rh.getID());
   }
@@ -357,7 +366,7 @@ WtStreamManager::WtStreamManager(WtDir dir,
       connSendFc_(config.peerMaxConnData),
       egressCb_(egressCb),
       ingressCb_(ingressCb) {
-  XCHECK(dir <= WtDir::Server) << "invalid dir";
+  PRX_CHECK(dir <= WtDir::Server) << "invalid dir";
   if (config.trackClosedStreams) {
     closedStreams_ = std::make_unique<ClosedStreams>();
   }
@@ -399,7 +408,7 @@ void WtStreamManager::enqueueEvent(Event&& ev) noexcept {
 }
 
 WtStreamManager::Result WtStreamManager::onMaxStreams(MaxStreamsBidi bidi) {
-  XCHECK_LE(bidi.maxStreams, kMaxVarint);
+  PRX_CHECK_LE(bidi.maxStreams, kMaxVarint);
   // the "StreamType" is derived from a self bidi id, simply use
   // nextStreamIds_
   auto& maxBidi = maxStreams_.getMaxStreams(nextStreamIds_.bidi);
@@ -409,7 +418,7 @@ WtStreamManager::Result WtStreamManager::onMaxStreams(MaxStreamsBidi bidi) {
 }
 
 WtStreamManager::Result WtStreamManager::onMaxStreams(MaxStreamsUni uni) {
-  XCHECK_LE(uni.maxStreams, kMaxVarint);
+  PRX_CHECK_LE(uni.maxStreams, kMaxVarint);
   // the "StreamType" is derived from a self uni id, simply use nextStreamIds_
   auto& maxUni = maxStreams_.getMaxStreams(nextStreamIds_.uni);
   bool valid = uni.maxStreams >= maxUni;
@@ -456,8 +465,8 @@ bool WtStreamManager::streamLimitExceeded(uint64_t streamId) const noexcept {
   uint64_t opened = streamsCounter_.getCounter(streamId).opened;
   uint64_t limit = maxStreams_.getMaxStreams(streamId);
   bool exceeded = opened >= limit;
-  XLOG_IF(ERR, exceeded) << __func__ << "; opened=" << opened
-                         << "; limit=" << limit << "; id=" << streamId;
+  PRX_LOG_IF(ERROR, exceeded) << __func__ << "; opened=" << opened
+                              << "; limit=" << limit << "; id=" << streamId;
   return exceeded;
 }
 
@@ -472,7 +481,7 @@ WtStreamManager::BidiHandle* WtStreamManager::getOrCreateBidiHandleImpl(
     return nullptr;
   }
 
-  XLOG(DBG8) << "creating id=" << streamId;
+  PRX_VLOG(8) << "creating id=" << streamId;
   streamsCounter_.getCounter(streamId).opened++;
   it = streams_.emplace(streamId, BidiHandle::make(streamId, *this)).first;
   return it->second.get();
@@ -544,7 +553,7 @@ uint64_t WtStreamManager::streamBytesReceived(
 }
 
 WtStreamManager::Result WtStreamManager::onMaxData(MaxConnData data) noexcept {
-  XLOG(DBG9) << __func__ << " maxData=" << data.maxData;
+  PRX_VLOG(9) << __func__ << " maxData=" << data.maxData;
   if (!connSendFc_.grant(data.maxData)) {
     return Fail;
   }
@@ -557,8 +566,8 @@ WtStreamManager::Result WtStreamManager::onMaxData(MaxConnData data) noexcept {
     if (writeHandle.bufferedSendData_.canSendData()) {
       writableStreams_.insert(writeHandle.getID(), writeHandle.getPriority());
     } else {
-      XLOG(ERR) << "Stream " << writeHandle.getID()
-                << " in connFcBlockedStreams_ but !canSendData";
+      PRX_LOG(ERROR) << "Stream " << writeHandle.getID()
+                     << " in connFcBlockedStreams_ but !canSendData";
     }
   }
 
@@ -571,15 +580,15 @@ WtStreamManager::Result WtStreamManager::onMaxData(MaxConnData data) noexcept {
 WtStreamManager::Result WtStreamManager::onMaxData(
     MaxStreamData data) noexcept {
   // TODO(@damlaj): connection-level err if not egress stream?
-  XLOG(DBG9) << __func__ << "; id=" << data.streamId
-             << "; maxData=" << data.maxData;
+  PRX_VLOG(9) << __func__ << "; id=" << data.streamId
+              << "; maxData=" << data.maxData;
   auto* eh = writehandle_ptr_cast(getEgressHandle(data.streamId));
   return (eh && eh->onMaxData(data.maxData)) ? Ok : Fail;
 }
 
 WtStreamManager::Result WtStreamManager::onStopSending(
     StopSending data) noexcept {
-  XLOG(DBG9) << __func__ << "; id=" << data.streamId << "; err=" << data.err;
+  PRX_VLOG(9) << __func__ << "; id=" << data.streamId << "; err=" << data.err;
   if (auto* eh = writehandle_ptr_cast(getEgressHandle(data.streamId))) {
     eh->onStopSending(data.err);
     return Ok;
@@ -589,7 +598,7 @@ WtStreamManager::Result WtStreamManager::onStopSending(
 
 WtStreamManager::Result WtStreamManager::onResetStream(
     ResetStream data) noexcept {
-  XLOG(DBG9) << __func__ << "; id=" << data.streamId << "; err=" << data.err;
+  PRX_VLOG(9) << __func__ << "; id=" << data.streamId << "; err=" << data.err;
   if (auto* rh = readhandle_ptr_cast(getIngressHandle(data.streamId))) {
     auto ex = makeWtException(uint32_t(data.err), "rx reset_stream");
     rh->cancel(std::move(ex), data.reliableSize);
@@ -630,8 +639,8 @@ WtBufferedStreamData::DequeueResult WtStreamManager::dequeue(
     connFcBlockedStreams_.insert(&wh);
   }
 
-  XLOG(DBG8) << __func__ << "; atMost=" << atMost << "; len=" << len
-             << "; fin=" << res.fin;
+  PRX_VLOG(8) << __func__ << "; atMost=" << atMost << "; len=" << len
+              << "; fin=" << res.fin;
   return res;
 }
 
@@ -663,7 +672,7 @@ void WtStreamManager::shutdown(CloseSession cs) noexcept {
     return;
   }
   shutdown_ = true;
-  XLOG(DBG4) << __func__ << "; ec=" << cs.err << "; err=" << cs.msg;
+  PRX_VLOG(4) << __func__ << "; ec=" << cs.err << "; err=" << cs.msg;
   auto ex = makeWtException(cs.err, cs.msg);
   auto streams = std::move(streams_);
   for (auto& [_, handle] : streams) {
@@ -713,7 +722,7 @@ void WtStreamManager::erase(uint64_t streamId) noexcept {
   auto& counter = streamsCounter_.getCounter(streamId);
   const uint64_t opened = counter.opened;
   const uint64_t closed = ++counter.closed;
-  XCHECK_GE(opened, closed);
+  PRX_CHECK_GE(opened, closed);
   // if peer stream, we may need to advertise additional MaxStreams credit.
   if (isPeer(streamId)) {
     // compute the number of peer openable streams; if it is <= half of the
@@ -724,8 +733,8 @@ void WtStreamManager::erase(uint64_t streamId) noexcept {
                                          : wtConfig_.selfMaxStreamsUni;
     auto& maxStreams = maxStreams_.getMaxStreams(streamId);
     const uint64_t openable = maxStreams - closed;
-    XLOG(DBG6) << "init=" << initStreamLimit << "; limit=" << maxStreams
-               << "; opened=" << opened << "; closed=" << closed;
+    PRX_VLOG(6) << "init=" << initStreamLimit << "; limit=" << maxStreams
+                << "; opened=" << opened << "; closed=" << closed;
     if (openable <= initStreamLimit / 2) {
       maxStreams += (initStreamLimit - openable);
       isBidi(streamId) ? enqueueEvent(MaxStreamsBidi{maxStreams})
@@ -748,8 +757,8 @@ WtStreamManager::WtWriteHandle* WtStreamManager::nextWritable() const noexcept {
   auto streamId = writableStreams_.peek();
   auto* wh =
       writehandle_ptr_cast(streamId ? getEgressHandle(*streamId) : nullptr);
-  XLOG(DBG6) << __func__ << "; wh=" << wh
-             << "; connSendFc.avail=" << connSendFc_.getAvailable();
+  PRX_VLOG(6) << __func__ << "; wh=" << wh
+              << "; connSendFc.avail=" << connSendFc_.getAvailable();
   return (wh && (connSendFc_.getAvailable() > 0 ||
                  wh->bufferedSendData_.onlyFinPending()))
              ? wh
@@ -800,7 +809,7 @@ struct WtStreamManager::ClosedStreams {
     const int64_t id = streamId >> 2;
     Interval interval{id, id};
     auto it = std::lower_bound(deque.begin(), deque.end(), interval);
-    XCHECK_NE(it, deque.end());
+    PRX_CHECK(it != deque.end());
     it = deque.insert(it, interval); // insert after
     // potentially merge std::prev(), it, & std::next()
     for (int8_t idx = 0; idx < 2; idx++) {
@@ -820,7 +829,7 @@ struct WtStreamManager::ClosedStreams {
     Interval interval{.start = id, .end = id};
     auto it =
         std::prev(std::upper_bound(deque.cbegin(), deque.cend(), interval));
-    XCHECK_NE(it, deque.end());
+    PRX_CHECK(it != deque.end());
     return it->within(id);
   }
 
@@ -851,14 +860,14 @@ ReadHandle::ReadHandle(uint64_t id, uint64_t initRecvWnd, Accessor acc) noexcept
 }
 
 folly::SemiFuture<StreamData> ReadHandle::readStreamData() {
-  XLOG_IF(FATAL, promise_.valid()) << "one pending read at a time";
+  PRX_LOG_IF(FATAL, promise_.valid()) << "one pending read at a time";
   if (!ingress_.chain.empty() || ingress_.fin) {
     auto len = ingress_.chain.computeChainDataLength();
     bytesRead_ += len;
     // only issue conn-level fc if we've rx'd fin
     smAccessor_.maybeGrantFc(ingress_.fin ? nullptr : this, len);
     auto res = StreamData{ingress_.chain.pop(), ingress_.fin};
-    XLOG(DBG6) << __func__ << "; len=" << len << "; fin=" << res.fin;
+    PRX_VLOG(6) << __func__ << "; len=" << len << "; fin=" << res.fin;
     if (rcb_) {
       rcb_->readReady(*this);
     }
@@ -877,7 +886,7 @@ folly::SemiFuture<StreamData> ReadHandle::readStreamData() {
 
 folly::Expected<folly::Unit, ReadHandle::ErrCode> ReadHandle::stopSending(
     uint32_t error) { // wait for peer eom or rst_stream
-  XCHECK_NE(state_, ReadHandleState::Closed);
+  PRX_CHECK_NE(state_, ReadHandleState::Closed);
   const auto prevState = std::exchange(state_, ReadHandleState::HalfClosed);
   if (prevState == ReadHandleState::Open) { // egress at most one ss
     smAccessor_.stopSending(*this, error);
@@ -899,8 +908,8 @@ Result ReadHandle::enqueue(StreamData&& data) noexcept {
     ingress_.chain.appendToChain(std::move(data.data));
   }
   ingress_.fin = data.fin;
-  XLOG(DBG6) << __func__ << "; len=" << len << "; fin=" << data.fin
-             << "; p.valid()=" << promise_.valid();
+  PRX_VLOG(6) << __func__ << "; len=" << len << "; fin=" << data.fin
+              << "; p.valid()=" << promise_.valid();
   if (auto p = resetPromise(); p.valid()) {
     // issue only conn-level fc if we've rx'd fin
     smAccessor_.maybeGrantFc(ingress_.fin ? nullptr : this, len);
@@ -927,7 +936,7 @@ Result ReadHandle::enqueue(StreamData&& data) noexcept {
  */
 void ReadHandle::cancel(folly::exception_wrapper ex,
                         uint64_t reliableSize) noexcept {
-  XLOG(DBG8) << __func__ << "; ex=" << ex.what();
+  PRX_VLOG(8) << __func__ << "; ex=" << ex.what();
   // ensures future reads after reliableSize bytes have been read fail
   ex_ = std::move(ex);
   reliableSize = (reliableSize == kInvalidVarint) ? bytesRead_ : reliableSize;
@@ -973,13 +982,13 @@ WriteHandle::writeStreamData(
     WebTransport::ByteEventCallback* byteEventCallback) {
   // TODO(@damlaj): handle reset stream; elide unnecessarily recomputing len
   auto len = computeChainLength(data);
-  XLOG_IF(ERR, !(len || fin)) << "no-op writeStreamData";
+  PRX_LOG_IF(ERROR, !(len || fin)) << "no-op writeStreamData";
   bool connBlocked = smAccessor_.connSend().buffer(len);
   bool streamBlocked =
       bufferedSendData_.enqueue(std::move(data), fin, byteEventCallback);
-  XLOG(DBG6) << __func__ << "; id=" << id_ << "; len=" << len << "; fin=" << fin
-             << "; connBlocked=" << connBlocked
-             << "; streamBlocked=" << streamBlocked;
+  PRX_VLOG(6) << __func__ << "; id=" << id_ << "; len=" << len
+              << "; fin=" << fin << "; connBlocked=" << connBlocked
+              << "; streamBlocked=" << streamBlocked;
   if (bufferedSendData_.canSendData()) {
     smAccessor_.onStreamWritable(*this); // stream is now writable
   }
@@ -996,7 +1005,7 @@ folly::Expected<folly::Unit, WriteHandle::ErrCode> WriteHandle::resetStream(
 
 folly::Expected<folly::Unit, WriteHandle::ErrCode> WriteHandle::setPriority(
     quic::PriorityQueue::Priority priority) {
-  XCHECK_NE(state_, WriteHandleState::Closed) << "setPriority after close";
+  PRX_CHECK_NE(state_, WriteHandleState::Closed) << "setPriority after close";
 
   StreamWriteHandle::setPriority(priority);
   smAccessor_.writableStreams().update(getID(), getPriority());
@@ -1016,7 +1025,7 @@ Result WriteHandle::onMaxData(uint64_t offset) {
 
 folly::Expected<folly::SemiFuture<uint64_t>, WriteHandle::ErrCode>
 WriteHandle::awaitWritable() {
-  XCHECK(!promise_.valid()) << "at most one pending awaitWritable";
+  PRX_CHECK(!promise_.valid()) << "at most one pending awaitWritable";
   const auto bufferAvailable = bufferedSendData_.window().getBufferAvailable();
   if (bufferAvailable > 0) {
     return folly::makeSemiFuture(bufferAvailable);
@@ -1033,7 +1042,7 @@ WritePromise WriteHandle::resetPromise() noexcept {
 // TODO(@damlaj): StreamData and DequeueResult should be the same struct
 WtBufferedStreamData::DequeueResult WriteHandle::dequeue(
     uint64_t atMost) noexcept {
-  XCHECK_NE(state_, WriteHandleState::Closed) << "dequeue after close";
+  PRX_CHECK_NE(state_, WriteHandleState::Closed) << "dequeue after close";
 
   auto res = bufferedSendData_.dequeue(atMost);
   const auto bufferAvailable = bufferedSendData_.window().getBufferAvailable();
@@ -1044,8 +1053,8 @@ WtBufferedStreamData::DequeueResult WriteHandle::dequeue(
   }
 
   auto bytesDequeued = computeChainLength(res.data);
-  XLOG(DBG6) << __func__ << "; id=" << id_ << "; len=" << bytesDequeued
-             << "; fin=" << res.fin;
+  PRX_VLOG(6) << __func__ << "; id=" << id_ << "; len=" << bytesDequeued
+              << "; fin=" << res.fin;
 
   // Erase if blocked (wrote nothing) or done (!canSendData)
   // Consume if wrote data and still have more
@@ -1060,7 +1069,7 @@ WtBufferedStreamData::DequeueResult WriteHandle::dequeue(
 }
 
 void WriteHandle::cancel(folly::exception_wrapper ex) noexcept {
-  XLOG(DBG8) << __func__ << "; ex=" << ex.what();
+  PRX_VLOG(8) << __func__ << "; ex=" << ex.what();
   ex_ = std::move(ex);
   bufferedSendData_.clear(id_);
   // any pending awaitWritable should be resolved with ex
diff --git a/proxygen/lib/http/webtransport/WtUtils.cpp b/proxygen/lib/http/webtransport/WtUtils.cpp
index a6e2db5239..2b1434ed36 100644
--- a/proxygen/lib/http/webtransport/WtUtils.cpp
+++ b/proxygen/lib/http/webtransport/WtUtils.cpp
@@ -6,9 +6,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/http/codec/HTTPSettings.h>
 #include <proxygen/lib/http/webtransport/WtUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 constexpr uint64_t kWtInitMaxData = std::numeric_limits<uint16_t>::max();
@@ -84,7 +84,7 @@ WtStreamManager::WtConfig getWtConfig(const HTTPSettings* ingress,
   WtStreamManager::WtConfig config;
   // either both ingress&egress are nullptr (e.g. http/1.1) or both non-nullptr
   if (egress || ingress) {
-    XCHECK(egress && ingress);
+    PRX_CHECK(egress && ingress);
     // set peer's WtConfig via ingress HTTPSettings
     config.peerMaxConnData =
         ingress->getSetting(SettingsId::WT_INITIAL_MAX_DATA, /*defaultVal=*/0);
@@ -114,13 +114,13 @@ WtStreamManager::WtConfig getWtConfig(const HTTPSettings* ingress,
                            /*defaultVal=*/0);
   }
 
-  XLOG(DBG6) << config.selfMaxStreamsBidi << "; " << config.selfMaxStreamsUni
-             << "; " << config.selfMaxConnData << "; "
-             << config.selfMaxStreamDataBidi << "; "
-             << config.selfMaxStreamDataUni << "; " << config.peerMaxStreamsBidi
-             << "; " << config.peerMaxStreamsUni << "; "
-             << config.peerMaxConnData << "; " << config.peerMaxStreamDataBidi
-             << "; " << config.peerMaxStreamDataUni;
+  PRX_VLOG(6)
+      << config.selfMaxStreamsBidi << "; " << config.selfMaxStreamsUni << "; "
+      << config.selfMaxConnData << "; " << config.selfMaxStreamDataBidi << "; "
+      << config.selfMaxStreamDataUni << "; " << config.peerMaxStreamsBidi
+      << "; " << config.peerMaxStreamsUni << "; " << config.peerMaxConnData
+      << "; " << config.peerMaxStreamDataBidi << "; "
+      << config.peerMaxStreamDataUni;
 
   return config;
 }
@@ -165,8 +165,8 @@ bool supportsH3Wt(TransportDirection dir,
 
 void WtEventVisitor::operator()(
     WtStreamManager::ResetStream rst) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " rst.id=" << rst.streamId
-             << "; rst.err=" << rst.err;
+  PRX_VLOG(6) << kWtEventVisitor << " rst.id=" << rst.streamId
+              << "; rst.err=" << rst.err;
   writeWTResetStream(
       egress,
       WTResetStreamCapsule{.streamId = rst.streamId,
@@ -177,8 +177,8 @@ void WtEventVisitor::operator()(
 
 void WtEventVisitor::operator()(
     WtStreamManager::StopSending ss) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " ss.id=" << ss.streamId
-             << "; ss.err=" << ss.err;
+  PRX_VLOG(6) << kWtEventVisitor << " ss.id=" << ss.streamId
+              << "; ss.err=" << ss.err;
   writeWTStopSending(
       egress,
       WTStopSendingCapsule{.streamId = ss.streamId,
@@ -188,14 +188,14 @@ void WtEventVisitor::operator()(
 
 void WtEventVisitor::operator()(
     WtStreamManager::MaxConnData md) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " md.offset=" << md.maxData;
+  PRX_VLOG(6) << kWtEventVisitor << " md.offset=" << md.maxData;
   writeWTMaxData(egress, WTMaxDataCapsule{md.maxData}, protocol);
 }
 
 void WtEventVisitor::operator()(
     WtStreamManager::MaxStreamData msd) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " msd.id=" << msd.streamId
-             << " msd.offset=" << msd.maxData;
+  PRX_VLOG(6) << kWtEventVisitor << " msd.id=" << msd.streamId
+              << " msd.offset=" << msd.maxData;
   writeWTMaxStreamData(egress,
                        WTMaxStreamDataCapsule{.streamId = msd.streamId,
                                               .maximumStreamData = msd.maxData},
@@ -204,7 +204,7 @@ void WtEventVisitor::operator()(
 
 void WtEventVisitor::operator()(
     WtStreamManager::MaxStreamsBidi ms) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " msd.maxStreamsBidi=" << ms.maxStreams;
+  PRX_VLOG(6) << kWtEventVisitor << " msd.maxStreamsBidi=" << ms.maxStreams;
   writeWTMaxStreams(egress,
                     WTMaxStreamsCapsule{.maximumStreams = ms.maxStreams},
                     /*isBidi=*/true,
@@ -213,7 +213,7 @@ void WtEventVisitor::operator()(
 
 void WtEventVisitor::operator()(
     WtStreamManager::MaxStreamsUni ms) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " msd.maxStreamsUni=" << ms.maxStreams;
+  PRX_VLOG(6) << kWtEventVisitor << " msd.maxStreamsUni=" << ms.maxStreams;
   writeWTMaxStreams(egress,
                     WTMaxStreamsCapsule{.maximumStreams = ms.maxStreams},
                     /*isBidi=*/false,
@@ -221,12 +221,13 @@ void WtEventVisitor::operator()(
 }
 
 void WtEventVisitor::operator()(WtStreamManager::DrainSession) const noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " ds";
+  PRX_VLOG(6) << kWtEventVisitor << " ds";
   writeDrainWebTransportSession(egress);
 }
 
 void WtEventVisitor::operator()(WtStreamManager::CloseSession cs) noexcept {
-  XLOG(DBG6) << kWtEventVisitor << " cs.err=" << cs.err << " cs.msg=" << cs.msg;
+  PRX_VLOG(6) << kWtEventVisitor << " cs.err=" << cs.err
+              << " cs.msg=" << cs.msg;
   sessionClosed = true;
   writeCloseWebTransportSession(
       egress,
@@ -240,8 +241,8 @@ void WtCapsuleCallback::onPadding(PaddingCapsule) noexcept {
 }
 
 void WtCapsuleCallback::onResetStream(WTResetStreamCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; id=" << c.streamId
-             << "; err=" << c.appProtocolErrorCode;
+  PRX_VLOG(6) << __func__ << "; id=" << c.streamId
+              << "; err=" << c.appProtocolErrorCode;
   sm_.onResetStream(
       WtStreamManager::ResetStream{.streamId = c.streamId,
                                    .err = c.appProtocolErrorCode,
@@ -249,33 +250,33 @@ void WtCapsuleCallback::onResetStream(WTResetStreamCapsule c) noexcept {
 }
 
 void WtCapsuleCallback::onStopSending(WTStopSendingCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; id=" << c.streamId
-             << "; err=" << c.appProtocolErrorCode;
+  PRX_VLOG(6) << __func__ << "; id=" << c.streamId
+              << "; err=" << c.appProtocolErrorCode;
   sm_.onStopSending(WtStreamManager::StopSending{
       .streamId = c.streamId, .err = c.appProtocolErrorCode});
 }
 
 void WtCapsuleCallback::onStream(WTStreamCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; id=" << c.streamId;
+  PRX_VLOG(6) << __func__ << "; id=" << c.streamId;
   if (auto* rh = sm_.getOrCreateIngressHandle(c.streamId)) {
     sm_.enqueue(*rh, {std::move(c.streamData), c.fin});
   }
 }
 
 void WtCapsuleCallback::onMaxData(WTMaxDataCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; offset=" << c.maximumData;
+  PRX_VLOG(6) << __func__ << "; offset=" << c.maximumData;
   sm_.onMaxData(WtStreamManager::MaxConnData{.maxData = c.maximumData});
 }
 
 void WtCapsuleCallback::onMaxStreamData(WTMaxStreamDataCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; id=" << c.streamId
-             << "; offset=" << c.maximumStreamData;
+  PRX_VLOG(6) << __func__ << "; id=" << c.streamId
+              << "; offset=" << c.maximumStreamData;
   sm_.onMaxData(
       WtStreamManager::MaxStreamData{{c.maximumStreamData}, c.streamId});
 }
 
 void WtCapsuleCallback::onMaxStreamsBidi(WTMaxStreamsCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; max=" << c.maximumStreams;
+  PRX_VLOG(6) << __func__ << "; max=" << c.maximumStreams;
   bool wasAvail = sm_.canCreateBidi();
   sm_.onMaxStreams(WtStreamManager::MaxStreamsBidi{c.maximumStreams});
   if (!wasAvail && sm_.canCreateBidi()) {
@@ -284,7 +285,7 @@ void WtCapsuleCallback::onMaxStreamsBidi(WTMaxStreamsCapsule c) noexcept {
 }
 
 void WtCapsuleCallback::onMaxStreamsUni(WTMaxStreamsCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; max=" << c.maximumStreams;
+  PRX_VLOG(6) << __func__ << "; max=" << c.maximumStreams;
   bool wasAvail = sm_.canCreateUni();
   sm_.onMaxStreams(WtStreamManager::MaxStreamsUni{c.maximumStreams});
   if (!wasAvail && sm_.canCreateUni()) {
@@ -293,49 +294,49 @@ void WtCapsuleCallback::onMaxStreamsUni(WTMaxStreamsCapsule c) noexcept {
 }
 
 void WtCapsuleCallback::onDataBlocked(WTDataBlockedCapsule) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
 }
 
 void WtCapsuleCallback::onStreamDataBlocked(
     WTStreamDataBlockedCapsule) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
 }
 
 void WtCapsuleCallback::onStreamsBlockedBidi(WTStreamsBlockedCapsule) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
 }
 
 void WtCapsuleCallback::onStreamsBlockedUni(WTStreamsBlockedCapsule) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
 }
 
 void WtCapsuleCallback::onDatagram(DatagramCapsule dgram) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
   wtSess_.onDatagram(std::move(dgram.httpDatagramPayload));
 }
 
 void WtCapsuleCallback::onCloseSession(
     CloseWebTransportSessionCapsule c) noexcept {
-  XLOG(DBG6) << __func__ << "; err=" << c.applicationErrorCode
-             << "; c.msg=" << c.applicationErrorMessage;
+  PRX_VLOG(6) << __func__ << "; err=" << c.applicationErrorCode
+              << "; c.msg=" << c.applicationErrorMessage;
   sm_.onCloseSession(WtStreamManager::CloseSession{
       .err = c.applicationErrorCode, .msg = c.applicationErrorMessage});
 }
 
 void WtCapsuleCallback::onDrainSession(
     DrainWebTransportSessionCapsule) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
   sm_.onDrainSession(WtStreamManager::DrainSession{});
 }
 
 void WtCapsuleCallback::onCapsule(uint64_t capsuleType,
                                   uint64_t capsuleLength) noexcept {
-  XLOG(DBG7) << __func__ << "; capsuleType=" << capsuleType
-             << "; capsuleLength=" << capsuleLength;
+  PRX_VLOG(7) << __func__ << "; capsuleType=" << capsuleType
+              << "; capsuleLength=" << capsuleLength;
 }
 
 void WtCapsuleCallback::onConnectionError(CapsuleCodec::ErrorCode) noexcept {
-  XLOG(DBG6) << __func__;
+  PRX_VLOG(6) << __func__;
   sm_.onCloseSession(
       WtStreamManager::CloseSession{.err = 0, .msg = "onConnectionError"});
 }
@@ -343,7 +344,7 @@ void WtCapsuleCallback::onConnectionError(CapsuleCodec::ErrorCode) noexcept {
 NotifyPeerStreamsGuard::~NotifyPeerStreamsGuard() noexcept {
   auto peerIds = std::move(cb.peerStreams);
   for (auto id : peerIds) {
-    VLOG(6) << "new peer wt stream id=" << id;
+    PRX_VLOG(6) << "new peer wt stream id=" << id;
     auto handle = sm.getOrCreateBidiHandle(id);
     if (handle.writeHandle) { // write handle iff bidi stream
       wtHandler.onNewBidiStream(handle);
@@ -371,7 +372,7 @@ WtExpected<StreamWriteHandle*>::Type WtSessionBase::createUniStream() noexcept {
 WtExpected<BidiStreamHandle>::Type WtSessionBase::createBidiStream() noexcept {
   auto res = sm_.createBidiHandle();
   if (res.readHandle || res.writeHandle) {
-    XCHECK(res.readHandle && res.writeHandle);
+    PRX_CHECK(res.readHandle && res.writeHandle);
     return BidiStreamHandle{res.readHandle, res.writeHandle};
   }
   return folly::makeUnexpected(WtErrCode::STREAM_CREATION_ERROR);
diff --git a/proxygen/lib/http/webtransport/test/FakeSharedWebTransport.h b/proxygen/lib/http/webtransport/test/FakeSharedWebTransport.h
index d27fdbf1ca..b8c126cf1f 100644
--- a/proxygen/lib/http/webtransport/test/FakeSharedWebTransport.h
+++ b/proxygen/lib/http/webtransport/test/FakeSharedWebTransport.h
@@ -11,6 +11,7 @@
 #include <folly/ExceptionWrapper.h>
 #include <folly/portability/GMock.h>
 #include <proxygen/lib/http/webtransport/WebTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 
 namespace proxygen::test {
@@ -51,7 +52,7 @@ class FakeStreamHandle
   }
 
   folly::SemiFuture<WebTransport::StreamData> readStreamData() override {
-    XCHECK(!promise_) << "One read at a time";
+    PRX_CHECK(!promise_) << "One read at a time";
     if (writeErr_) {
       auto exwrapper =
           folly::make_exception_wrapper<WebTransport::Exception>(*writeErr_);
@@ -84,10 +85,10 @@ class FakeStreamHandle
   }
 
   void deliverInflightData(size_t bytes = std::numeric_limits<size_t>::max()) {
-    CHECK_GT(bytes, 0);
-    XLOG(DBG4) << "deliverInflightData bytes=" << bytes
-               << " inflightBuf_ size=" << inflightBuf_.chainLength()
-               << " fin=" << (fin_ ? "true" : "false");
+    PRX_CHECK_GT(bytes, 0);
+    PRX_VLOG(4) << "deliverInflightData bytes=" << bytes
+                << " inflightBuf_ size=" << inflightBuf_.chainLength()
+                << " fin=" << (fin_ ? "true" : "false");
     auto buf = inflightBuf_.splitAtMost(bytes);
     dataDelivered_ += buf->computeChainDataLength();
     buf_.append(std::move(buf));
diff --git a/proxygen/lib/http/webtransport/test/Mocks.h b/proxygen/lib/http/webtransport/test/Mocks.h
index 2056c52c77..52085ccc5e 100644
--- a/proxygen/lib/http/webtransport/test/Mocks.h
+++ b/proxygen/lib/http/webtransport/test/Mocks.h
@@ -12,6 +12,7 @@
 #include <proxygen/lib/http/codec/HTTPCodec.h>
 #include <proxygen/lib/http/codec/HTTPSettings.h>
 #include <proxygen/lib/http/webtransport/WebTransport.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen::test {
 
@@ -173,7 +174,7 @@ struct DummyWtHandler : public WebTransportHandler {
   }
   void onWebTransportSession(
       std::shared_ptr<WebTransport> wtSession) noexcept override {
-    CHECK(wtSession);
+    PRX_CHECK(wtSession);
     ctx->wtSession = std::move(wtSession);
   }
 
diff --git a/proxygen/lib/http/webtransport/test/QuicWtSessionTest.cpp b/proxygen/lib/http/webtransport/test/QuicWtSessionTest.cpp
index 3fa4781b39..8a94e516c4 100644
--- a/proxygen/lib/http/webtransport/test/QuicWtSessionTest.cpp
+++ b/proxygen/lib/http/webtransport/test/QuicWtSessionTest.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/http/session/test/MockQuicSocketDriver.h>
 #include <proxygen/lib/http/webtransport/QuicWtSession.h>
 #include <proxygen/lib/http/webtransport/test/Mocks.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace proxygen::test;
@@ -842,7 +843,7 @@ TEST_F(H3WtSessionTest, CreateUniBidiStream) {
   { // uni&bidi stream credit now available
     auto uni = session_->createUniStream();
     auto bidi = session_->createBidiStream();
-    CHECK(uni && bidi);
+    PRX_CHECK(uni && bidi);
 
     // validate the wt stream prefix was written to the quic stream
     auto uniId = (*uni)->getID();
@@ -909,7 +910,7 @@ TEST_F(H3WtSessionTest, CreateUniBidiStream) {
   { // can no longer create bidi/uni streams after ::shutdown
     auto uni = session_->createUniStream();
     auto bidi = session_->createBidiStream();
-    CHECK(!uni && !bidi);
+    PRX_CHECK(!uni && !bidi);
   }
 }
 
@@ -926,12 +927,12 @@ TEST_F(H3WtSessionTest, AcquireIngressStream) {
 
   // acquire uni stream and verify handler notification
   EXPECT_TRUE(session_->acquireIngressStream(kClientUniId));
-  XCHECK(uni && uni->getID() == kClientUniId);
+  PRX_CHECK(uni && uni->getID() == kClientUniId);
 
   // acquire bidi stream and verify handler notification
   EXPECT_TRUE(session_->acquireIngressStream(kClientBidiId));
-  XCHECK(bidi.readHandle && bidi.writeHandle &&
-         bidi.readHandle->getID() == kClientBidiId);
+  PRX_CHECK(bidi.readHandle && bidi.writeHandle &&
+            bidi.readHandle->getID() == kClientBidiId);
 
   // enqueue data on uni&bidi stream and verify read handle receives it
   constexpr std::string_view body = "abcdefghijklmnopqrstuvwxyz";
@@ -945,7 +946,7 @@ TEST_F(H3WtSessionTest, AcquireIngressStream) {
   auto uniRead = uni->readStreamData();
   auto bidiRead = bidi.readHandle->readStreamData();
   for (auto& read : {&uniRead, &bidiRead}) {
-    CHECK(read->isReady()); // fut should be ready;
+    PRX_CHECK(read->isReady()); // fut should be ready;
     EXPECT_EQ(read->value().data->toString(), body);
     EXPECT_TRUE(read->value().fin);
   }
diff --git a/proxygen/lib/http/webtransport/test/WtStreamManagerTest.cpp b/proxygen/lib/http/webtransport/test/WtStreamManagerTest.cpp
index cbe9e24f29..cff9aab172 100644
--- a/proxygen/lib/http/webtransport/test/WtStreamManagerTest.cpp
+++ b/proxygen/lib/http/webtransport/test/WtStreamManagerTest.cpp
@@ -11,6 +11,7 @@
 
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/priority/HTTPPriorityQueue.h>
 
 namespace proxygen::coro::test {
@@ -141,7 +142,7 @@ TEST(WtStreamManager, BasicPeerBidi) {
   EXPECT_EQ(bidiRes.readHandle, nullptr);
   EXPECT_EQ(bidiRes.writeHandle, nullptr);
 
-  CHECK_EQ(ingressCb.peerIds.size(), 2);
+  PRX_CHECK_EQ(ingressCb.peerIds.size(), 2u);
   EXPECT_EQ(ingressCb.peerIds[0], 0x01);
   EXPECT_EQ(ingressCb.peerIds[1], 0x09);
 }
@@ -171,7 +172,7 @@ TEST(WtStreamManager, BasicPeerUni) {
   EXPECT_EQ(bidiRes.writeHandle, nullptr); // ingress only
 
   // validate peer streams
-  CHECK_EQ(ingressCb.peerIds.size(), 2);
+  PRX_CHECK_EQ(ingressCb.peerIds.size(), 2u);
   EXPECT_EQ(ingressCb.peerIds[0], 0x03);
   EXPECT_EQ(ingressCb.peerIds[1], 0x0b);
 }
@@ -185,7 +186,7 @@ TEST(WtStreamManager, NextBidiUniHandle) {
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
   // next egress handle tests
-  auto uni = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto uni = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   EXPECT_EQ(uni->getID(), 0x02);
   uni = streamManager.createEgressHandle();
   EXPECT_EQ(uni->getID(), 0x06);
@@ -235,7 +236,7 @@ TEST(WtStreamManager, StreamLimits) {
   EXPECT_TRUE(streamManager.onMaxStreams(MaxStreamsUni{2}));
 
   // next egress handle should succeed
-  uni = CHECK_NOTNULL(streamManager.createEgressHandle());
+  uni = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   EXPECT_NE(uni, nullptr);
 
   // next bidi handle should succeed
@@ -254,7 +255,7 @@ TEST(WtStreamManager, EnqueueIngressData) {
 
   // next createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle);
   constexpr std::string_view kData = "abcdefghijklmnopqrstuvwxyz";
   for (auto c : kData) {
     EXPECT_TRUE(streamManager.enqueue(
@@ -282,7 +283,8 @@ TEST(WtStreamManager, EnqueueIngressDataRwnd) {
   // next createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
   auto two = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle && two.readHandle && two.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle && two.readHandle &&
+            two.writeHandle);
 
   constexpr auto kBufLen = 65'535;
 
@@ -323,7 +325,8 @@ TEST(WtStreamManager, WriteEgressHandle) {
   // next two ::createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
   auto two = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle && two.readHandle && two.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle && two.readHandle &&
+            two.writeHandle);
 
   // Set priorities to make ordering predictable (urgency, incremental)
   one.writeHandle->setPriority(quic::HTTPPriorityQueue::Priority(
@@ -404,7 +407,7 @@ TEST(WtStreamManager, DequeueWriteConnFcBlocked) {
   WtStreamManager streamManager{
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
-  auto uni = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto uni = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   // write kBufLen & fin into stream (fills egress buffer)
   constexpr auto kBufLen = 65'535;
   auto res = uni->writeStreamData(
@@ -427,7 +430,7 @@ TEST(WtStreamManager, BidiHandleCancellation) {
 
   // next ::createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle);
 
   auto res = one.writeHandle->writeStreamData(
       /*data=*/makeBuf(100), /*fin=*/false, /*byteEventCallback=*/nullptr);
@@ -439,7 +442,7 @@ TEST(WtStreamManager, BidiHandleCancellation) {
   // reset stream on cancellation
   folly::CancellationCallback cancelCb{
       ct, [eh = one.writeHandle]() {
-        CHECK(eh->exception() && eh->exception()->error == 0xface);
+        PRX_CHECK(eh->exception() && eh->exception()->error == 0xface);
         eh->resetStream(0); // reset stream
       }};
   streamManager.onStopSending({one.writeHandle->getID(), 0xface});
@@ -468,7 +471,7 @@ TEST(WtStreamManager, GrantFlowControlCredit) {
 
   // next ::createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle);
   // fills up both conn- & stream-level flow control
   EXPECT_TRUE(streamManager.enqueue(*one.readHandle,
                                     {makeBuf(kBufLen), /*fin=*/false}));
@@ -479,7 +482,7 @@ TEST(WtStreamManager, GrantFlowControlCredit) {
   EXPECT_TRUE(std::exchange(egressCb.evAvail_, false)); // callback should have
                                                         // triggered
   auto events = streamManager.moveEvents();
-  CHECK_GE(events.size(), 2); // one conn & one stream fc
+  PRX_CHECK_GE(events.size(), 2u); // one conn & one stream fc
   auto maxStreamData = std::get<MaxStreamData>(events[0]);
   auto maxConnData = std::get<MaxConnData>(events[1]);
   EXPECT_EQ(maxStreamData.streamId, one.readHandle->getID());
@@ -488,7 +491,7 @@ TEST(WtStreamManager, GrantFlowControlCredit) {
 
   // next ::createBidiHandle should succeed
   auto two = streamManager.createBidiHandle();
-  CHECK(two.readHandle && two.writeHandle);
+  PRX_CHECK(two.readHandle && two.writeHandle);
   // fills up both conn- & stream-level flow control
   fut = two.readHandle->readStreamData();
   EXPECT_TRUE(
@@ -500,11 +503,12 @@ TEST(WtStreamManager, GrantFlowControlCredit) {
 
   // validate that receiving a reset_stream releases connection-level flow
   // control
-  auto* ingress = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
+  auto* ingress =
+      PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
   streamManager.enqueue(*ingress, {makeBuf(kBufLen), /*fin=*/false});
   streamManager.onResetStream(ResetStream{ingress->getID(), 0x00});
   events = streamManager.moveEvents();
-  CHECK_GE(events.size(), 1);
+  PRX_CHECK_GE(events.size(), 1u);
   maxConnData = std::get<MaxConnData>(events[0]);
   EXPECT_EQ(maxConnData.maxData,
             kBufLen * 4); // we've previously already issued 2x kBufLen
@@ -524,7 +528,8 @@ TEST(WtStreamManager, GrantConnFlowControlCreditAfterRead) {
   // enqueue a total of kBufLen bytes across handles one & two
   auto one = streamManager.createBidiHandle();
   auto two = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle && two.readHandle && two.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle && two.readHandle &&
+            two.writeHandle);
 
   EXPECT_TRUE(streamManager.enqueue(*one.readHandle,
                                     {makeBuf(kBufLen - 1), /*fin=*/true}));
@@ -563,7 +568,7 @@ TEST(WtStreamManager, NonDefaultFlowControlValues) {
 
   // enqueue 100 bytes of data
   auto one = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle);
   EXPECT_TRUE(streamManager.enqueue(*one.readHandle,
                                     {makeBuf(kBufLen), /*fin=*/false}));
 
@@ -574,7 +579,7 @@ TEST(WtStreamManager, NonDefaultFlowControlValues) {
   EXPECT_TRUE(std::exchange(egressCb.evAvail_, false)); // callback should have
                                                         // triggered
   auto events = streamManager.moveEvents();
-  CHECK_GE(events.size(), 2); // one conn & one stream fc
+  PRX_CHECK_GE(events.size(), 2u); // one conn & one stream fc
   auto maxStreamData = std::get<MaxStreamData>(events[0]);
   auto maxConnData = std::get<MaxConnData>(events[1]);
   EXPECT_EQ(maxStreamData.streamId, one.readHandle->getID());
@@ -595,7 +600,7 @@ TEST(WtStreamManager, NonDefaultFlowControlValues) {
 
   // dequeuing data from two's writeHandle is now limited by conn egress fc,
   // which is 100-60=40
-  auto* two = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* two = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   two->writeStreamData(
       makeBuf(kBufLen), /*fin=*/true, /*byteEventCallback=*/nullptr);
   EXPECT_EQ(streamManager.nextWritable(), two);
@@ -615,9 +620,9 @@ TEST(WtStreamManager, ResetStreamReleasesConnFlowControl) {
   constexpr auto kBufLen = 65'535;
   constexpr auto kHalfBufLen = (kBufLen / 2) + 1;
 
-  auto* one = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
-  auto* two = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x07));
-  auto* three = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x0b));
+  auto* one = PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
+  auto* two = PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x07));
+  auto* three = PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x0b));
 
   // queue kHalfBufLen across all handles; ensure the last reset releases
   // conn fc
@@ -651,7 +656,7 @@ TEST(WtStreamManager, StopSendingResetStreamTest) {
 
   // next ::createBidiHandle should succeed
   auto one = streamManager.createBidiHandle();
-  CHECK(one.readHandle && one.writeHandle);
+  PRX_CHECK(one.readHandle && one.writeHandle);
   auto id = one.readHandle->getID();
 
   // ReadHandle::stopSending invokes ::eventsAvailable & resolve pending promise
@@ -688,7 +693,7 @@ TEST(WtStreamManager, StopSendingResetStreamTest) {
   EXPECT_FALSE(streamManager.hasStreams());
 
   // ::resetStream on a unidirectional egress stream should erase the stream
-  auto* egress = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* egress = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   EXPECT_TRUE(streamManager.hasStreams());
   egress->resetStream(/*error=*/0); // read side is closed for an egress-only
                                     // handle; bidirectionally complete after
@@ -710,7 +715,7 @@ TEST(WtStreamManager, StopSendingTest) {
     // StopSending on an ingress stream marks it as half closed; stream is only
     // closed when we rx a reset_stream or eom from peer (to account for flow
     // control)
-    auto* uni = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
+    auto* uni = PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
     uni->stopSending(0x00);
 
     // validate StopSending event is enqueued
@@ -739,7 +744,7 @@ TEST(WtStreamManager, StopSendingTest) {
     // StopSending on an ingress stream marks it as half closed; stream is only
     // closed when we rx a reset_stream or eom from peer (to account for flow
     // control)
-    auto* uni = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x07));
+    auto* uni = PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x07));
     uni->stopSending(0x00);
 
     // validate StopSending event is enqueued
@@ -775,7 +780,7 @@ TEST(WtStreamManager, AwaitWritableTest) {
 
   constexpr auto kBufLen = 65'535;
   // next ::createBidiHandle should succeed
-  auto eh = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto eh = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
 
   // await writable future should be synchronously ready & equal to kBufLen
   // (default egress stream fc)
@@ -815,8 +820,8 @@ TEST(WtStreamManager, WritableStreams) {
   constexpr auto kAtMost = std::numeric_limits<uint64_t>::max();
 
   // next two ::createEgressHandle should succeed
-  auto one = CHECK_NOTNULL(streamManager.createEgressHandle());
-  auto two = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto one = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto two = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
 
   // 1 byte + eof; next writableStream == one
   auto writeRes = one->writeStreamData(
@@ -870,7 +875,7 @@ TEST(WtStreamManager, WritableStreams) {
   EXPECT_FALSE(dequeue.fin);
 
   // FIN-only stream should still be writable even when connection FC is blocked
-  auto three = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto three = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   three->writeStreamData(nullptr, /*fin=*/true, /*byteEventCallback=*/nullptr);
   EXPECT_EQ(streamManager.nextWritable(), three);
   expectNextWritable(*priorityQueue, three->getID());
@@ -889,7 +894,7 @@ TEST(WtStreamManager, DrainWtSession) {
   streamManager.drain();
   EXPECT_TRUE(egressCb.evAvail_);
   auto events = streamManager.moveEvents();
-  CHECK(!events.empty() && std::holds_alternative<DrainSession>(events[0]));
+  PRX_CHECK(!events.empty() && std::holds_alternative<DrainSession>(events[0]));
 
   // streams can still be created after drain
   auto bidi = streamManager.createBidiHandle();
@@ -951,7 +956,8 @@ TEST(WtStreamManager, ResetStreamReliableSize) {
 
   // enqueue 100 bytes, ensure ::onResetStream does not deallocate stream until
   // after 100 bytes are read
-  auto ingress = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
+  auto ingress =
+      PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
   streamManager.enqueue(*ingress, {makeBuf(100), /*fin=*/false});
 
   auto ct = ingress->getCancelToken();
@@ -1006,8 +1012,9 @@ TEST(WtStreamManager, IssueMaxStreamsBidiUni) {
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
   auto peerBidi = streamManager.getOrCreateBidiHandle(0x01);
-  CHECK(peerBidi.readHandle && peerBidi.writeHandle);
-  auto peerUni = CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
+  PRX_CHECK(peerBidi.readHandle && peerBidi.writeHandle);
+  auto peerUni =
+      PRX_CHECK_NOTNULL(streamManager.getOrCreateIngressHandle(0x03));
 
   // tx & rx rst_stream on peerBidi will close stream => issue
   // MaxStreamsBidi
@@ -1041,7 +1048,7 @@ TEST(WtStreamManager, ShutdownOpenStreams) {
 
   // create bidi stream
   auto bidi = streamManager.createBidiHandle();
-  CHECK(bidi.readHandle && bidi.writeHandle);
+  PRX_CHECK(bidi.readHandle && bidi.writeHandle);
 
   // reset one direction
   bidi.writeHandle->resetStream(0);
@@ -1089,8 +1096,8 @@ TEST(WtStreamManager, OnlyFinPending) {
   WtStreamManager streamManager{
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
-  auto one = CHECK_NOTNULL(streamManager.createEgressHandle());
-  auto two = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto one = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto two = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
 
   // Set priorities to make ordering predictable (urgency, incremental)
   one->setPriority(quic::HTTPPriorityQueue::Priority(
@@ -1123,7 +1130,7 @@ TEST(WtStreamManager, NextWritableReturnsNullptrWhenQueueEmpty) {
   EXPECT_EQ(streamManager.nextWritable(), nullptr);
 
   // Create a stream but don't write data - queue should still be empty
-  auto one = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto one = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   EXPECT_EQ(streamManager.nextWritable(), nullptr);
 
   // Write data to make stream writable
@@ -1153,7 +1160,7 @@ TEST(WtStreamManager, NextWritableReturnsNullptrWhenHeadIsDatagram) {
   EXPECT_EQ(streamManager.nextWritable(), nullptr);
 
   // Now add a stream with lower priority
-  auto one = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto one = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   one->setPriority(quic::HTTPPriorityQueue::Priority(1, false));
   one->writeStreamData(
       makeBuf(10), /*fin=*/false, /*byteEventCallback=*/nullptr);
@@ -1196,7 +1203,7 @@ TEST(WtStreamManager, PerStreamCallbacks) {
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
   auto bidi = streamManager.createBidiHandle();
-  CHECK(bidi.readHandle && bidi.writeHandle);
+  PRX_CHECK(bidi.readHandle && bidi.writeHandle);
 
   // set stream callbacks
   WtReadCallback rcb;
@@ -1231,7 +1238,7 @@ TEST(WtStreamManager, DeliveryCallback) {
   MockDeliveryCallback cb1, cb2, cb3, cb4, cb5;
 
   // single write with callback
-  auto* h1 = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h1 = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   h1->writeStreamData(makeBuf(100), /*fin=*/true, &cb1);
   auto deq1 = streamManager.dequeue(*h1, 100);
   EXPECT_EQ(deq1.data->computeChainDataLength(), 100);
@@ -1240,7 +1247,7 @@ TEST(WtStreamManager, DeliveryCallback) {
   EXPECT_EQ(deq1.lastByteStreamOffset, 99);
 
   // multiple writes with different callbacks
-  auto* h2 = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h2 = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   h2->writeStreamData(makeBuf(100), /*fin=*/false, &cb1);
   h2->writeStreamData(makeBuf(50), /*fin=*/false, &cb2);
   h2->writeStreamData(makeBuf(75), /*fin=*/true, &cb3);
@@ -1262,7 +1269,7 @@ TEST(WtStreamManager, DeliveryCallback) {
   EXPECT_EQ(d2c.lastByteStreamOffset, 224);
 
   // writes without callbacks coalesce with final callback write
-  auto* h3 = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h3 = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   h3->writeStreamData(makeBuf(100), /*fin=*/false, nullptr);
   h3->writeStreamData(makeBuf(100), /*fin=*/false, nullptr);
   h3->writeStreamData(makeBuf(50), /*fin=*/true, &cb4);
@@ -1274,7 +1281,7 @@ TEST(WtStreamManager, DeliveryCallback) {
   EXPECT_EQ(deq3.lastByteStreamOffset, 249);
 
   // callback delivered only when write completes
-  auto* h4 = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h4 = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   h4->writeStreamData(makeBuf(100), /*fin=*/true, &cb5);
 
   auto d4a = streamManager.dequeue(*h4, 60);
@@ -1289,7 +1296,7 @@ TEST(WtStreamManager, DeliveryCallback) {
   EXPECT_EQ(d4b.lastByteStreamOffset, 99);
 
   // fin-only write with callback
-  auto* h5 = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h5 = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   h5->writeStreamData(makeBuf(50), /*fin=*/false, nullptr);
   auto d5a = streamManager.dequeue(*h5, 100);
   EXPECT_EQ(d5a.data->computeChainDataLength(), 50);
@@ -1314,7 +1321,7 @@ TEST(WtStreamManager, ByteEventCancellation) {
 
   ::testing::StrictMock<MockDeliveryCallback> cb1, cb2;
 
-  auto* h = CHECK_NOTNULL(streamManager.createEgressHandle());
+  auto* h = PRX_CHECK_NOTNULL(streamManager.createEgressHandle());
   auto id = h->getID();
 
   // first write: 100 bytes at offset 0 => last byte offset = 99
@@ -1337,21 +1344,21 @@ TEST(WtStreamManager, CannotOpenPreviouslyClosedStreams) {
       detail::WtDir::Client, config, egressCb, ingressCb, *priorityQueue};
 
   // create stream 2 then immediately dealloc
-  auto* handle = CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(2));
+  auto* handle = PRX_CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(2));
   handle->resetStream(0);
   // attempt to re-create stream id 2 should fail
   handle = streamManager.getOrCreateEgressHandle(2);
   EXPECT_EQ(handle, nullptr);
 
   // create stream 10 then immediately dealloc
-  handle = CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(10));
+  handle = PRX_CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(10));
   handle->resetStream(0);
   // attempt to re-create stream id 10 should fail
   handle = streamManager.getOrCreateEgressHandle(10);
   EXPECT_EQ(handle, nullptr);
 
   // create stream 6 then immediately dealloc
-  handle = CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(6));
+  handle = PRX_CHECK_NOTNULL(streamManager.getOrCreateEgressHandle(6));
   handle->resetStream(0);
   // attempt to re-create stream id 6 should fail
   handle = streamManager.getOrCreateEgressHandle(6);
diff --git a/proxygen/lib/pools/generators/CMakeLists.txt b/proxygen/lib/pools/generators/CMakeLists.txt
index 2da970b3e3..65bfa1bee3 100644
--- a/proxygen/lib/pools/generators/CMakeLists.txt
+++ b/proxygen/lib/pools/generators/CMakeLists.txt
@@ -20,15 +20,16 @@ proxygen_add_library(proxygen_pools_generators_server_list_generator
   EXPORTED_DEPS
     proxygen_pools_generators_member_group_config
     proxygen_pools_generators_server_config
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_base
     Folly::folly_network_address
-    glog::glog
 )
 
 proxygen_add_library(proxygen_pools_generators_file_server_list_generator
   SRCS
     FileServerListGenerator.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_file_util
     Folly::folly_json_dynamic
     Folly::folly_network_address
diff --git a/proxygen/lib/pools/generators/FileServerListGenerator.cpp b/proxygen/lib/pools/generators/FileServerListGenerator.cpp
index 949c35a410..8ec0b68b86 100644
--- a/proxygen/lib/pools/generators/FileServerListGenerator.cpp
+++ b/proxygen/lib/pools/generators/FileServerListGenerator.cpp
@@ -11,6 +11,7 @@
 #include <folly/json/dynamic.h>
 #include <folly/json/json.h>
 #include <proxygen/lib/pools/generators/FileServerListGenerator.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <sstream>
 
 using folly::dynamic;
@@ -33,7 +34,8 @@ void FileServerListGenerator::FileGenerator::cancelServerListRequest() {
 void FileServerListGenerator::FileGenerator::run(milliseconds /*timeout*/) {
   // Read the file
 
-  VLOG(4) << "Looking up server list from File Handle " << params_->fileName;
+  PRX_VLOG(4) << "Looking up server list from File Handle "
+              << params_->fileName;
 
   std::string content;
   try {
@@ -81,11 +83,11 @@ void FileServerListGenerator::FileGenerator::run(milliseconds /*timeout*/) {
     }
   } else {
     // Unsupported FileType yet.
-    LOG(FATAL) << "Unsupported FileServerListGenerator::FileType!";
+    PRX_LOG(FATAL) << "Unsupported FileServerListGenerator::FileType!";
   }
 
-  VLOG(4) << "Found " << servers.size() << " usable servers from File "
-          << params_->fileName;
+  PRX_VLOG(4) << "Found " << servers.size() << " usable servers from File "
+              << params_->fileName;
   callback_->serverListAvailable(std::move(servers));
   delete this;
 }
diff --git a/proxygen/lib/pools/generators/ServerListGenerator.cpp b/proxygen/lib/pools/generators/ServerListGenerator.cpp
index aa1bef5b3e..e5f6eca196 100644
--- a/proxygen/lib/pools/generators/ServerListGenerator.cpp
+++ b/proxygen/lib/pools/generators/ServerListGenerator.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/pools/generators/ServerListGenerator.h>
 
 #include <folly/io/async/EventBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::EventBase;
 using std::vector;
@@ -17,14 +18,14 @@ using std::chrono::milliseconds;
 namespace proxygen {
 
 void ServerListGeneratorIf::attachEventBase(EventBase* eventBase) {
-  CHECK(!eventBase_);
-  CHECK(eventBase->isInEventBaseThread());
+  PRX_CHECK(!eventBase_);
+  PRX_CHECK(eventBase->isInEventBaseThread());
 
   eventBase_ = eventBase;
 }
 
 void ServerListGeneratorIf::detachEventBase() {
-  CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
+  PRX_CHECK(!eventBase_ || eventBase_->isInEventBaseThread());
 
   eventBase_ = nullptr;
 }
@@ -42,7 +43,7 @@ void ServerListGenerator::listServersBlocking(vector<ServerConfig>* results,
 
   if (callback.status != ServerListCallback::SUCCESS) {
     if (!callback.errorPtr) {
-      LOG(FATAL)
+      PRX_LOG(FATAL)
           << "ServerListGenerator finished without invoking callback, timeout:"
           << timeout.count();
     }
diff --git a/proxygen/lib/pools/generators/ServerListGenerator.h b/proxygen/lib/pools/generators/ServerListGenerator.h
index b9f949d3e7..39ecec32d6 100644
--- a/proxygen/lib/pools/generators/ServerListGenerator.h
+++ b/proxygen/lib/pools/generators/ServerListGenerator.h
@@ -14,7 +14,7 @@
 
 #include <folly/SocketAddress.h>
 #include <folly/io/async/AsyncTimeout.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <proxygen/lib/pools/generators/MemberGroupConfig.h>
 #include <proxygen/lib/pools/generators/ServerConfig.h>
@@ -152,7 +152,7 @@ class ServerListGenerator : public ServerListGeneratorIf {
       if ((gen_ == nullptr) && (g == nullptr)) {
         return;
       }
-      CHECK((gen_ == nullptr) ^ (g == nullptr)) << gen_ << " " << g;
+      PRX_CHECK((gen_ == nullptr) ^ (g == nullptr)) << gen_ << " " << g;
 
       // Subclasses first call resetGenerator(gen, takeOwnership) after creating
       // a generator. After a success/error/timeout callback is called, this
diff --git a/proxygen/lib/pools/generators/coro/CMakeLists.txt b/proxygen/lib/pools/generators/coro/CMakeLists.txt
index 3982afc995..0f03c44e5f 100644
--- a/proxygen/lib/pools/generators/coro/CMakeLists.txt
+++ b/proxygen/lib/pools/generators/coro/CMakeLists.txt
@@ -18,6 +18,7 @@ proxygen_add_library(proxygen_pools_generators_coro_file_server_list_generator
   SRCS
     FileCoroServerListGenerator.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_file_util
   EXPORTED_DEPS
     proxygen_pools_generators_coro_server_list_generator
diff --git a/proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.cpp b/proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.cpp
index a6983c59df..2a983fa934 100644
--- a/proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.cpp
+++ b/proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.cpp
@@ -8,6 +8,7 @@
 
 #include <folly/FileUtil.h>
 #include <proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -17,7 +18,7 @@ FileCoroServerListGenerator::FileCoroServerListGenerator(std::string fileName)
 
 folly::coro::Task<std::vector<ServerConfig>>
 FileCoroServerListGenerator::listServers() {
-  VLOG(4) << "Looking up server list from File Handle " << fileName_;
+  PRX_VLOG(4) << "Looking up server list from File Handle " << fileName_;
 
   std::string content;
   if (!folly::readFile(fileName_.c_str(), content)) {
@@ -27,8 +28,8 @@ FileCoroServerListGenerator::listServers() {
 
   auto servers = parseFile(content);
 
-  VLOG(4) << "Found " << servers.size() << " usable servers from File "
-          << fileName_;
+  PRX_VLOG(4) << "Found " << servers.size() << " usable servers from File "
+              << fileName_;
   co_return servers;
 }
 
diff --git a/proxygen/lib/sampling/CMakeLists.txt b/proxygen/lib/sampling/CMakeLists.txt
index f58d05f9d0..206f9f0162 100644
--- a/proxygen/lib/sampling/CMakeLists.txt
+++ b/proxygen/lib/sampling/CMakeLists.txt
@@ -21,9 +21,9 @@ proxygen_add_library(proxygen_sampling
   SRCS
     Sampling.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_hash_hash
     Folly::folly_random
-    glog::glog
   EXPORTED_DEPS
     Folly::folly_function
     Folly::folly_range
diff --git a/proxygen/lib/sampling/Sampling.cpp b/proxygen/lib/sampling/Sampling.cpp
index c3762682e7..6051590385 100644
--- a/proxygen/lib/sampling/Sampling.cpp
+++ b/proxygen/lib/sampling/Sampling.cpp
@@ -10,7 +10,7 @@
 
 #include <limits>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/Random.h>
 #include <folly/hash/Hash.h>
@@ -24,7 +24,7 @@ Sampling::Sampling(double rate) {
 Sampling::~Sampling() = default;
 
 void Sampling::updateRate(double rate) {
-  CHECK(rate >= 0.0 && rate <= 1.0);
+  PRX_CHECK(rate >= 0.0 && rate <= 1.0);
   rate_ = rate;
   weight_ = rateToWeight(rate);
 }
diff --git a/proxygen/lib/services/CMakeLists.txt b/proxygen/lib/services/CMakeLists.txt
index e4321bc3bb..82894ff84f 100644
--- a/proxygen/lib/services/CMakeLists.txt
+++ b/proxygen/lib/services/CMakeLists.txt
@@ -36,6 +36,7 @@ proxygen_add_library(proxygen_services
   EXPORTED_DEPS
     proxygen_services_worker
     proxygen_utils_acceptor_address
+    proxygen_utils_log_shim
     wangle::wangle_acceptor
     wangle::wangle_acceptor_acceptor_core
     Folly::folly_io_async_async_base
@@ -46,10 +47,10 @@ proxygen_add_library(proxygen_services_worker
   SRCS
     WorkerThread.cpp
   DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_event_base_manager
     Folly::folly_io_async_io_uring_backend
     Folly::folly_string
-    glog::glog
   EXPORTED_DEPS
     Folly::folly_io_async_async_base
     Folly::folly_portability
diff --git a/proxygen/lib/services/RequestWorkerThread.cpp b/proxygen/lib/services/RequestWorkerThread.cpp
index 9cbb34243f..732825f9d7 100644
--- a/proxygen/lib/services/RequestWorkerThread.cpp
+++ b/proxygen/lib/services/RequestWorkerThread.cpp
@@ -11,6 +11,7 @@
 #include <csignal>
 #include <folly/io/async/EventBaseManager.h>
 #include <proxygen/lib/services/ServiceWorker.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -44,14 +45,14 @@ uint64_t RequestWorkerThread::nextRequestId() {
 }
 
 void RequestWorkerThread::flushStats() {
-  CHECK(getEventBase()->isInEventBaseThread());
+  PRX_CHECK(getEventBase()->isInEventBaseThread());
   for (auto& p : serviceWorkers_) {
     p.second->flushStats();
   }
 }
 
 void RequestWorkerThread::setup() {
-  CHECK(evb_);
+  PRX_CHECK(evb_);
   evb_->runImmediatelyOrRunInEventBaseThreadAndWait([&]() {
     sigset_t ss;
 
@@ -67,7 +68,7 @@ void RequestWorkerThread::setup() {
     sigaddset(&ss, SIGTERM);
     sigaddset(&ss, SIGCHLD);
     sigaddset(&ss, SIGIO);
-    PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
+    PRX_PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
 
     currentRequestWorker_ = this;
     callback_.workerStarted(this);
@@ -79,7 +80,7 @@ void RequestWorkerThread::forceStop() {
 }
 
 void RequestWorkerThread::cleanup() {
-  LOG(INFO) << "Worker " << unsigned(getWorkerId()) << " in cleanup";
+  PRX_LOG(INFO) << "Worker " << unsigned(getWorkerId()) << " in cleanup";
   callback_.workerFinished(this);
 }
 
diff --git a/proxygen/lib/services/RequestWorkerThread.h b/proxygen/lib/services/RequestWorkerThread.h
index 747639cce2..c7e7c5e68d 100644
--- a/proxygen/lib/services/RequestWorkerThread.h
+++ b/proxygen/lib/services/RequestWorkerThread.h
@@ -11,6 +11,7 @@
 #include <cstdint>
 #include <folly/io/async/EventBase.h>
 #include <map>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/LoadShedConfiguration.h>
 
 namespace proxygen {
@@ -62,7 +63,7 @@ class RequestWorkerThread {
    * Track the ServiceWorker objects in-use by this worker.
    */
   void addServiceWorker(Service* service, ServiceWorker* sw) {
-    CHECK(serviceWorkers_.find(service) == serviceWorkers_.end());
+    PRX_CHECK(serviceWorkers_.find(service) == serviceWorkers_.end());
     serviceWorkers_[service] = sw;
   }
 
@@ -72,7 +73,7 @@ class RequestWorkerThread {
    */
   ServiceWorker* getServiceWorker(Service* service) const {
     auto it = serviceWorkers_.find(service);
-    CHECK(it != serviceWorkers_.end());
+    PRX_CHECK(it != serviceWorkers_.end());
     return it->second;
   }
 
diff --git a/proxygen/lib/services/RequestWorkerThreadNoExecutor.cpp b/proxygen/lib/services/RequestWorkerThreadNoExecutor.cpp
index abffcf7ba8..75799821ac 100644
--- a/proxygen/lib/services/RequestWorkerThreadNoExecutor.cpp
+++ b/proxygen/lib/services/RequestWorkerThreadNoExecutor.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/io/async/EventBaseManager.h>
 #include <proxygen/lib/services/ServiceWorker.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -42,7 +43,7 @@ uint64_t RequestWorkerThreadNoExecutor::nextRequestId() {
 }
 
 void RequestWorkerThreadNoExecutor::flushStats() {
-  CHECK(getEventBase()->isInEventBaseThread());
+  PRX_CHECK(getEventBase()->isInEventBaseThread());
   for (auto& p : serviceWorkers_) {
     p.second->flushStats();
   }
diff --git a/proxygen/lib/services/RequestWorkerThreadNoExecutor.h b/proxygen/lib/services/RequestWorkerThreadNoExecutor.h
index b5c2e85a8e..bb47b01014 100644
--- a/proxygen/lib/services/RequestWorkerThreadNoExecutor.h
+++ b/proxygen/lib/services/RequestWorkerThreadNoExecutor.h
@@ -11,6 +11,7 @@
 #include <cstdint>
 #include <map>
 #include <proxygen/lib/services/WorkerThread.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/LoadShedConfiguration.h>
 
 namespace proxygen {
@@ -60,7 +61,7 @@ class RequestWorkerThreadNoExecutor : public WorkerThread {
   static RequestWorkerThreadNoExecutor* getRequestWorkerThreadNoExecutor() {
     auto* self = dynamic_cast<RequestWorkerThreadNoExecutor*>(
         WorkerThread::getCurrentWorkerThread());
-    CHECK_NOTNULL(self);
+    PRX_CHECK_NOTNULL(self);
     return self;
   }
 
@@ -68,7 +69,7 @@ class RequestWorkerThreadNoExecutor : public WorkerThread {
    * Track the ServiceWorker objects in-use by this worker.
    */
   void addServiceWorker(Service* service, ServiceWorker* sw) {
-    CHECK(serviceWorkers_.find(service) == serviceWorkers_.end());
+    PRX_CHECK(serviceWorkers_.find(service) == serviceWorkers_.end());
     serviceWorkers_[service] = sw;
   }
 
@@ -78,7 +79,7 @@ class RequestWorkerThreadNoExecutor : public WorkerThread {
    */
   ServiceWorker* getServiceWorker(Service* service) const {
     auto it = serviceWorkers_.find(service);
-    CHECK(it != serviceWorkers_.end());
+    PRX_CHECK(it != serviceWorkers_.end());
     return it->second;
   }
 
diff --git a/proxygen/lib/services/ServiceWorker.h b/proxygen/lib/services/ServiceWorker.h
index 1dbe696067..44a910cbd4 100644
--- a/proxygen/lib/services/ServiceWorker.h
+++ b/proxygen/lib/services/ServiceWorker.h
@@ -12,6 +12,7 @@
 #include <list>
 #include <memory>
 #include <proxygen/lib/utils/AcceptorAddress.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/acceptor/Acceptor.h>
 #include <wangle/acceptor/ConnectionCounter.h>
 
@@ -131,7 +132,7 @@ class ServiceWorker {
   void addAcceptor(const AcceptorAddress& accAddress,
                    std::unique_ptr<wangle::Acceptor> acceptor,
                    AcceptorMap& acceptors) {
-    CHECK(acceptors.find(accAddress) == acceptors.end());
+    PRX_CHECK(acceptors.find(accAddress) == acceptors.end());
     acceptors.insert(std::make_pair(accAddress, std::move(acceptor)));
   }
 
diff --git a/proxygen/lib/services/WorkerThread.cpp b/proxygen/lib/services/WorkerThread.cpp
index ba0e182c36..d601d74cf3 100644
--- a/proxygen/lib/services/WorkerThread.cpp
+++ b/proxygen/lib/services/WorkerThread.cpp
@@ -13,7 +13,7 @@
 #include <folly/String.h>
 #include <folly/io/async/EventBaseManager.h>
 #include <folly/io/async/IoUringBackend.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <signal.h>
 
 #if !FOLLY_MOBILE && __has_include(<liburing.h>)
@@ -36,14 +36,15 @@ std::unique_ptr<folly::EventBaseBackendBase> getEventBaseBackend() {
           .setUseRegisteredFds(FLAGS_pwt_io_uring_use_registered_fds);
 
       auto ret = std::make_unique<folly::IoUringBackend>(std::move(options));
-      LOG(INFO) << "Allocating io_uring backend(" << FLAGS_pwt_io_uring_capacity
-                << "," << FLAGS_pwt_io_uring_max_submit << ","
-                << FLAGS_pwt_io_uring_max_get << ","
-                << FLAGS_pwt_io_uring_use_registered_fds << "): " << ret.get();
+      PRX_LOG(INFO)
+          << "Allocating io_uring backend(" << FLAGS_pwt_io_uring_capacity
+          << "," << FLAGS_pwt_io_uring_max_submit << ","
+          << FLAGS_pwt_io_uring_max_get << ","
+          << FLAGS_pwt_io_uring_use_registered_fds << "): " << ret.get();
 
       return ret;
     } catch (const std::exception& ex) {
-      LOG(INFO) << "Failure creating io_uring backend: " << ex.what();
+      PRX_LOG(INFO) << "Failure creating io_uring backend: " << ex.what();
     }
   }
   return folly::EventBase::getDefaultBackend();
@@ -77,11 +78,11 @@ WorkerThread::WorkerThread(folly::EventBaseManager* eventBaseManager,
     eventBase_->setName(evbName);
   }
 
-  LOG(INFO) << "Created WorkerThread " << this << ", evb =  " << evbName;
+  PRX_LOG(INFO) << "Created WorkerThread " << this << ", evb =  " << evbName;
 }
 
 WorkerThread::~WorkerThread() {
-  CHECK(state_ == State::IDLE);
+  PRX_CHECK(state_ == State::IDLE);
 
   // Reset the underlying event base.  This will execute all associated
   // execution pending funcs if not already reset.
@@ -89,7 +90,7 @@ WorkerThread::~WorkerThread() {
 }
 
 void WorkerThread::start() {
-  CHECK(state_ == State::IDLE);
+  PRX_CHECK(state_ == State::IDLE);
   state_ = State::STARTING;
 
   {
@@ -118,8 +119,8 @@ void WorkerThread::stopWhenIdle() {
       // state_ could be IDLE if we don't execute this callback until the
       // EventBase is destroyed in the WorkerThread destructor
     } else if (state_ != State::IDLE && state_ != State::STOP_WHEN_IDLE) {
-      LOG(FATAL) << "stopWhenIdle() called in unexpected state "
-                 << static_cast<int>(state_);
+      PRX_LOG(FATAL) << "stopWhenIdle() called in unexpected state "
+                     << static_cast<int>(state_);
     }
   });
 }
@@ -136,8 +137,8 @@ void WorkerThread::forceStop() {
       // state_ could be IDLE if we don't execute this callback until the
       // EventBase is destroyed in the WorkerThread destructor
     } else if (state_ != State::IDLE) {
-      LOG(FATAL) << "forceStop() called in unexpected state "
-                 << static_cast<int>(state_);
+      PRX_LOG(FATAL) << "forceStop() called in unexpected state "
+                     << static_cast<int>(state_);
     }
   });
 }
@@ -165,11 +166,11 @@ void WorkerThread::setup() {
   sigaddset(&ss, SIGTERM);
   sigaddset(&ss, SIGCHLD);
   sigaddset(&ss, SIGIO);
-  PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
+  PRX_PCHECK(pthread_sigmask(SIG_BLOCK, &ss, nullptr) == 0);
 #endif
 
   // Update the currentWorker_ thread-local pointer
-  CHECK(nullptr == currentWorker_);
+  PRX_CHECK(nullptr == currentWorker_);
   currentWorker_ = this;
 
   // Update the manager with the event base this worker runs on
@@ -191,10 +192,10 @@ void WorkerThread::resetEventBase() {
 
 void WorkerThread::runLoop() {
   // Update state_
-  CHECK(state_ == State::STARTING);
+  PRX_CHECK(state_ == State::STARTING);
   state_ = State::RUNNING;
 
-  VLOG(1) << "WorkerThread " << this << " starting";
+  PRX_VLOG(1) << "WorkerThread " << this << " starting";
 
   // Call loopForever().  This will only return after stopWhenIdle() or
   // forceStop() has been called.
@@ -204,14 +205,14 @@ void WorkerThread::runLoop() {
     // We have been asked to stop when there are no more events left.
     // Call loop() to finish processing events.  This will return when there
     // are no more events to process, or after forceStop() has been called.
-    VLOG(1) << "WorkerThread " << this << " finishing non-internal events";
+    PRX_VLOG(1) << "WorkerThread " << this << " finishing non-internal events";
     eventBase_->loop();
   }
 
-  CHECK(state_ == State::STOP_WHEN_IDLE || state_ == State::FORCE_STOP);
+  PRX_CHECK(state_ == State::STOP_WHEN_IDLE || state_ == State::FORCE_STOP);
   state_ = State::IDLE;
 
-  VLOG(1) << "WorkerThread " << this << " terminated";
+  PRX_VLOG(1) << "WorkerThread " << this << " terminated";
 }
 
 } // namespace proxygen
diff --git a/proxygen/lib/services/test/AcceptorTest.cpp b/proxygen/lib/services/test/AcceptorTest.cpp
index 684faea4a4..1e0e405744 100644
--- a/proxygen/lib/services/test/AcceptorTest.cpp
+++ b/proxygen/lib/services/test/AcceptorTest.cpp
@@ -10,7 +10,7 @@
 
 #include <folly/io/async/EventBase.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace folly;
 using namespace wangle;
@@ -81,9 +81,9 @@ TEST(AcceptorTest, Basic) {
 
   base.loopForever();
 
-  CHECK_EQ(acceptor.getNumConnections(), 1);
+  PRX_CHECK_EQ(acceptor.getNumConnections(), 1u);
 
-  CHECK(acceptor.getState() == Acceptor::State::kRunning);
+  PRX_CHECK(acceptor.getState() == Acceptor::State::kRunning);
   acceptor.forceStop();
   socket->stopAccepting();
   base.loop();
diff --git a/proxygen/lib/ssl/CMakeLists.txt b/proxygen/lib/ssl/CMakeLists.txt
index 86b03e0f6e..a1b7fb9051 100644
--- a/proxygen/lib/ssl/CMakeLists.txt
+++ b/proxygen/lib/ssl/CMakeLists.txt
@@ -8,8 +8,8 @@
 
 proxygen_add_library(proxygen_ssl
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_portability_openssl
-    glog::glog
 )
 
 proxygen_add_library(proxygen_ssl_fizz_handshake_error_type
diff --git a/proxygen/lib/ssl/ProxygenSSL.h b/proxygen/lib/ssl/ProxygenSSL.h
index f34e7fbd63..ab9690d4e9 100644
--- a/proxygen/lib/ssl/ProxygenSSL.h
+++ b/proxygen/lib/ssl/ProxygenSSL.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include <folly/portability/OpenSSL.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -23,7 +23,7 @@ class ProxygenSSL {
                                    nullptr,
                                    nullptr,
                                    nullptr);
-      CHECK(idx >= 0);
+      PRX_CHECK(idx >= 0);
       return idx;
     }();
     return index;
@@ -33,7 +33,7 @@ class ProxygenSSL {
     static auto index = [] {
       auto idx = SSL_CTX_get_ex_new_index(
           0, (void*)"proxygen wangle::SSLStats", nullptr, nullptr, nullptr);
-      CHECK(idx >= 0);
+      PRX_CHECK(idx >= 0);
       return idx;
     }();
     return index;
diff --git a/proxygen/lib/stats/PeriodicStats.h b/proxygen/lib/stats/PeriodicStats.h
index a344c80e95..f5b1d2f5ee 100644
--- a/proxygen/lib/stats/PeriodicStats.h
+++ b/proxygen/lib/stats/PeriodicStats.h
@@ -15,6 +15,7 @@
 #include <folly/executors/FunctionScheduler.h>
 #include <folly/synchronization/Rcu.h>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -67,7 +68,7 @@ class PeriodicStats {
    */
   void setRefreshCB(folly::Function<void()>&& cb) {
     std::lock_guard<std::mutex> guard(schedulerMutex_);
-    CHECK(!scheduler_);
+    PRX_CHECK(!scheduler_);
     refreshCb_ = std::move(cb);
   }
 
@@ -85,7 +86,7 @@ class PeriodicStats {
   void refreshWithPeriod(
       std::chrono::milliseconds periodMs,
       std::chrono::milliseconds initialDelayMs = std::chrono::milliseconds(0)) {
-    CHECK_GE(periodMs.count(), 0);
+    PRX_CHECK_GE(periodMs.count(), 0);
     std::lock_guard<std::mutex> guard(schedulerMutex_);
     refreshPeriodMs_ = periodMs;
     if (!scheduler_) {
diff --git a/proxygen/lib/stats/ResourceData.h b/proxygen/lib/stats/ResourceData.h
index 722391b27a..82b19e4ddc 100644
--- a/proxygen/lib/stats/ResourceData.h
+++ b/proxygen/lib/stats/ResourceData.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include <chrono>
-#include <folly/logging/xlog.h>
 #include <glog/stl_logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <stdint.h>
 #include <vector>
 
diff --git a/proxygen/lib/test/CMakeLists.txt b/proxygen/lib/test/CMakeLists.txt
index 60af94c225..a3c3338ae4 100644
--- a/proxygen/lib/test/CMakeLists.txt
+++ b/proxygen/lib/test/CMakeLists.txt
@@ -25,6 +25,8 @@ add_library(testmain TestMain.cpp)
 target_include_directories(
     testmain PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${PROXYGEN_FBCODE_ROOT}>
+    $<BUILD_INTERFACE:${PROXYGEN_GENERATED_ROOT}>
     ${LIBGMOCK_INCLUDE_DIR}
     ${LIBGTEST_INCLUDE_DIR}
 )
diff --git a/proxygen/lib/test/TestAsyncTransport.cpp b/proxygen/lib/test/TestAsyncTransport.cpp
index fce5cd00fc..b1670f18e3 100644
--- a/proxygen/lib/test/TestAsyncTransport.cpp
+++ b/proxygen/lib/test/TestAsyncTransport.cpp
@@ -12,6 +12,7 @@
 #include <folly/io/IOBuf.h>
 #include <folly/io/async/AsyncSocketException.h>
 #include <folly/io/async/EventBase.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <vector>
 
 using folly::AsyncSocketException;
@@ -42,7 +43,7 @@ class TestAsyncTransport::ReadEvent {
       // This means EOF
       return;
     }
-    CHECK_NOTNULL(buf);
+    PRX_CHECK_NOTNULL(buf);
 
     buffer_ = static_cast<char*>(malloc(buflen));
     if (buffer_ == nullptr) {
@@ -94,7 +95,7 @@ class TestAsyncTransport::ReadEvent {
   }
 
   void consumeData(size_t length) {
-    CHECK_LE(readStart_ + length, dataEnd_);
+    PRX_CHECK_LE(readStart_ + length, dataEnd_);
     readStart_ += length;
   }
 
@@ -219,7 +220,7 @@ void TestAsyncTransport::setReadCB(AsyncTransport::ReadCallback* callback) {
     return;
   }
 
-  CHECK_EQ(readState_, kStateOpen);
+  PRX_CHECK_EQ(readState_, kStateOpen);
   readCallback_ = callback;
 
   // If the callback was previously nullptr, read events were paused, so we need
@@ -235,7 +236,7 @@ void TestAsyncTransport::setReadCB(AsyncTransport::ReadCallback* callback) {
     // Either readEvents_ is empty, or startReadEvents() hasn't been called yet
     return;
   }
-  CHECK(!readEvents_.empty());
+  PRX_CHECK(!readEvents_.empty());
   scheduleNextReadEvent(proxygen::getCurrentTime());
 }
 
@@ -266,7 +267,7 @@ void TestAsyncTransport::writev(AsyncTransport::WriteCallback* callback,
     AsyncSocketException ex(AsyncSocketException::NOT_OPEN,
                             "write() called on non-open TestAsyncTransport");
     auto cb = dynamic_cast<WriteCallback*>(callback);
-    DCHECK(cb);
+    PRX_DCHECK(cb);
     cb->writeErr(0, ex);
     return;
   }
@@ -275,7 +276,7 @@ void TestAsyncTransport::writev(AsyncTransport::WriteCallback* callback,
   if (writeState_ == kStatePaused || pendingWriteEvents_.size() > 0) {
     pendingWriteEvents_.emplace_back(event, callback);
   } else {
-    CHECK_EQ(writeState_, kStateOpen);
+    PRX_CHECK_EQ(writeState_, kStateOpen);
     writeEvents_.push_back(event);
     callback->writeSuccess();
   }
@@ -353,14 +354,14 @@ bool TestAsyncTransport::error() const {
 }
 
 void TestAsyncTransport::attachEventBase(EventBase* eventBase) {
-  CHECK(nullptr == eventBase_);
-  CHECK(nullptr == readCallback_);
+  PRX_CHECK(nullptr == eventBase_);
+  PRX_CHECK(nullptr == readCallback_);
   eventBase_ = eventBase;
 }
 
 void TestAsyncTransport::detachEventBase() {
-  CHECK_NOTNULL(eventBase_);
-  CHECK(nullptr == readCallback_);
+  PRX_CHECK_NOTNULL(eventBase_);
+  PRX_CHECK(nullptr == readCallback_);
   eventBase_ = nullptr;
 }
 
@@ -382,16 +383,16 @@ uint32_t TestAsyncTransport::getSendTimeout() const {
 
 void TestAsyncTransport::pauseWrites() {
   if (writeState_ != kStateOpen) {
-    LOG(FATAL) << "cannot pause writes on non-open transport; state="
-               << writeState_;
+    PRX_LOG(FATAL) << "cannot pause writes on non-open transport; state="
+                   << writeState_;
   }
   writeState_ = kStatePaused;
 }
 
 void TestAsyncTransport::resumeWrites() {
   if (writeState_ != kStatePaused) {
-    LOG(FATAL) << "cannot resume writes on non-paused transport; state="
-               << writeState_;
+    PRX_LOG(FATAL) << "cannot resume writes on non-paused transport; state="
+                   << writeState_;
   }
   writeState_ = kStateOpen;
   for (auto event = pendingWriteEvents_.begin();
@@ -434,7 +435,7 @@ void TestAsyncTransport::addReadEvent(
     size_t buflen,
     std::chrono::milliseconds delayFromPrevious) {
   if (!readEvents_.empty() && readEvents_.back()->isFinalEvent()) {
-    LOG(FATAL) << "cannot add more read events after an error or EOF";
+    PRX_LOG(FATAL) << "cannot add more read events after an error or EOF";
   }
 
   auto event = std::make_shared<ReadEvent>(buf, buflen, delayFromPrevious);
@@ -460,7 +461,7 @@ void TestAsyncTransport::addReadError(
     const folly::AsyncSocketException& ex,
     std::chrono::milliseconds delayFromPrevious) {
   if (!readEvents_.empty() && readEvents_.back()->isFinalEvent()) {
-    LOG(FATAL) << "cannot add a read error after an error or EOF";
+    PRX_LOG(FATAL) << "cannot add a read error after an error or EOF";
   }
 
   auto event = std::make_shared<ReadEvent>(ex, delayFromPrevious);
@@ -513,8 +514,8 @@ void TestAsyncTransport::scheduleNextReadEvent(TimePoint now) {
 
 void TestAsyncTransport::fireNextReadEvent() {
   DestructorGuard dg(this);
-  CHECK(!readEvents_.empty());
-  CHECK_NOTNULL(readCallback_);
+  PRX_CHECK(!readEvents_.empty());
+  PRX_CHECK_NOTNULL(readCallback_);
 
   // maxReadAtOnce prevents us from starving other users of this EventBase
   unsigned int const maxReadAtOnce = 30;
@@ -539,14 +540,14 @@ void TestAsyncTransport::fireNextReadEvent() {
 }
 
 void TestAsyncTransport::fireOneReadEvent() {
-  CHECK(!readEvents_.empty());
-  CHECK_NOTNULL(readCallback_);
+  PRX_CHECK(!readEvents_.empty());
+  PRX_CHECK_NOTNULL(readCallback_);
 
   const shared_ptr<ReadEvent>& event = readEvents_.front();
 
   // Handle a read event using a movable buffer
   if (event->isMovableBuffer()) {
-    CHECK(readCallback_->isBufferMovable());
+    PRX_CHECK(readCallback_->isBufferMovable());
     readCallback_->readBufferAvailable(event->getMovableBuffer());
     readEvents_.pop_front();
 
@@ -570,12 +571,12 @@ void TestAsyncTransport::fireOneReadEvent() {
   } catch (...) {
     // TODO: we should convert the error to a AsyncSocketException and call
     // readError() here.
-    LOG(FATAL) << "readCallback_->getReadBuffer() threw an error";
+    PRX_LOG(FATAL) << "readCallback_->getReadBuffer() threw an error";
   }
   if (buf == nullptr || buflen == 0) {
     // TODO: we should just call readError() here.
-    LOG(FATAL) << "readCallback_->getReadBuffer() returned a nullptr or "
-                  "empty buffer";
+    PRX_LOG(FATAL) << "readCallback_->getReadBuffer() returned a nullptr or "
+                      "empty buffer";
   }
 
   // Handle errors
@@ -588,7 +589,7 @@ void TestAsyncTransport::fireOneReadEvent() {
     // pointer before popping it off the readEvents_ list.
     shared_ptr<ReadEvent> eventPointerCopy = readEvents_.front();
     readEvents_.pop_front();
-    CHECK(readEvents_.empty());
+    PRX_CHECK(readEvents_.empty());
     nextReadEventTime_ = {};
 
     auto callback = readCallback_;
@@ -603,7 +604,7 @@ void TestAsyncTransport::fireOneReadEvent() {
     readState_ = kStateClosed;
 
     readEvents_.pop_front();
-    CHECK(readEvents_.empty());
+    PRX_CHECK(readEvents_.empty());
     nextReadEventTime_ = {};
 
     auto callback = readCallback_;
@@ -641,7 +642,7 @@ void TestAsyncTransport::fireOneReadEvent() {
 }
 
 void TestAsyncTransport::timeoutExpired() noexcept {
-  CHECK_NOTNULL(readCallback_);
-  CHECK(!readEvents_.empty());
+  PRX_CHECK_NOTNULL(readCallback_);
+  PRX_CHECK(!readEvents_.empty());
   fireNextReadEvent();
 }
diff --git a/proxygen/lib/test/TestMain.cpp b/proxygen/lib/test/TestMain.cpp
index 919ca689b2..250690285b 100644
--- a/proxygen/lib/test/TestMain.cpp
+++ b/proxygen/lib/test/TestMain.cpp
@@ -9,13 +9,13 @@
 // Use this main function in gtest unit tests to enable glog
 #include <folly/portability/GFlags.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   google::InitGoogleLogging(argv[0]);
   google::InstallFailureSignalHandler();
-  LOG(INFO) << "Running tests from TestMain.cpp";
+  PRX_LOG(INFO) << "Running tests from TestMain.cpp";
   return RUN_ALL_TESTS();
 }
diff --git a/proxygen/lib/transport/AsyncUDPSocketFactory.cpp b/proxygen/lib/transport/AsyncUDPSocketFactory.cpp
index b5da28dd7b..a192e5526f 100644
--- a/proxygen/lib/transport/AsyncUDPSocketFactory.cpp
+++ b/proxygen/lib/transport/AsyncUDPSocketFactory.cpp
@@ -7,6 +7,7 @@
  */
 
 #include "proxygen/lib/transport/AsyncUDPSocketFactory.h"
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -15,7 +16,7 @@ AsyncUDPSocketFactory::AsyncUDPSocketFactory(
     folly::SocketAddress v6Address,
     std::optional<folly::SocketAddress> v4Address)
     : v6Address_(std::move(v6Address)), v4Address_(std::move(v4Address)) {
-  CHECK(eventBase);
+  PRX_CHECK(eventBase);
   eventBase_ = eventBase;
 }
 
diff --git a/proxygen/lib/transport/CMakeLists.txt b/proxygen/lib/transport/CMakeLists.txt
index 7f3f093e08..7b7a3d83da 100644
--- a/proxygen/lib/transport/CMakeLists.txt
+++ b/proxygen/lib/transport/CMakeLists.txt
@@ -10,6 +10,7 @@ proxygen_add_library(proxygen_transport_persistent_fizz_psk_cache
   SRCS
     PersistentFizzPskCache.cpp
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     wangle::wangle_client_persistence
     fizz::fizz
 )
@@ -18,6 +19,7 @@ proxygen_add_library(proxygen_transport_persistent_quic_psk_cache
   SRCS
     PersistentQuicPskCache.cpp
   DEPS
+    proxygen_utils_log_shim
     mvfst::mvfst_client_cached_server_tp_serialization
     fizz::fizz
     Folly::folly_conv
@@ -44,6 +46,7 @@ proxygen_add_library(proxygen_transport_h3_datagram_async_socket
   EXPORTED_DEPS
     proxygen_http_session_hq_upstream_session
     proxygen_http_session_http_transaction
+    proxygen_utils_log_shim
     mvfst::mvfst_api_transport
     mvfst::mvfst_client
     fizz::fizz
@@ -55,6 +58,7 @@ proxygen_add_library(proxygen_transport_connect_udp_utils
   SRCS
     ConnectUDPUtils.cpp
   DEPS
+    proxygen_utils_log_shim
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
     Folly::folly_string
@@ -74,6 +78,8 @@ proxygen_add_library(proxygen_transport_persistent_quic_token_cache
 proxygen_add_library(proxygen_transport_async_udp_socket_factory
   SRCS
     AsyncUDPSocketFactory.cpp
+  DEPS
+    proxygen_utils_log_shim
   EXPORTED_DEPS
     proxygen_utils_exception
     Folly::folly_expected
diff --git a/proxygen/lib/transport/ConnectUDPUtils.cpp b/proxygen/lib/transport/ConnectUDPUtils.cpp
index 0cc4d29ad1..34ec913614 100644
--- a/proxygen/lib/transport/ConnectUDPUtils.cpp
+++ b/proxygen/lib/transport/ConnectUDPUtils.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/String.h>
 #include <folly/io/Cursor.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -89,7 +90,7 @@ std::unique_ptr<folly::IOBuf> prependContextId(
   folly::io::Appender appender(contextIdBuf.get(), 1);
   auto res =
       quic::encodeQuicInteger(0, [&](auto val) { appender.writeBE(val); });
-  CHECK(res.has_value());
+  PRX_CHECK(res.has_value());
   contextIdBuf->appendToChain(std::move(payload));
   return contextIdBuf;
 }
diff --git a/proxygen/lib/transport/H3DatagramAsyncSocket.cpp b/proxygen/lib/transport/H3DatagramAsyncSocket.cpp
index c4bb887fdc..1c0f817200 100644
--- a/proxygen/lib/transport/H3DatagramAsyncSocket.cpp
+++ b/proxygen/lib/transport/H3DatagramAsyncSocket.cpp
@@ -13,6 +13,7 @@
 #include <folly/FileUtil.h>
 #include <proxygen/httpserver/samples/hq/HQParams.h>
 #include <proxygen/lib/transport/ConnectUDPUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/common/udpsocket/FollyQuicAsyncUDPSocket.h>
 #include <quic/fizz/client/handshake/FizzClientQuicHandshakeContext.h>
 #include <utility>
@@ -53,12 +54,12 @@ const folly::SocketAddress& H3DatagramAsyncSocket::address() const {
 
 void H3DatagramAsyncSocket::closeWithError(const AsyncSocketException& ex) {
   if (pendingError_.has_value()) {
-    LOG(ERROR) << "Multiple errors. Previous error: '" << pendingError_->what()
-               << "'";
+    PRX_LOG(ERROR) << "Multiple errors. Previous error: '"
+                   << pendingError_->what() << "'";
     return;
   }
   if (!readCallback_) {
-    LOG(ERROR)
+    PRX_LOG(ERROR)
         << "Error with readCallback not set. Will deliver when resuming reads.";
     pendingError_ = ex;
     return;
@@ -103,11 +104,11 @@ void H3DatagramAsyncSocket::connectError(quic::QuicError error) {
 
 void H3DatagramAsyncSocket::setTransaction(
     proxygen::HTTPTransaction* /*txn*/) noexcept {
-  CHECK(!txn_);
+  PRX_CHECK(!txn_);
 }
 
 void H3DatagramAsyncSocket::detachTransaction() noexcept {
-  VLOG(4) << "Transaction Detached";
+  PRX_VLOG(4) << "Transaction Detached";
   txn_ = nullptr;
 }
 
@@ -133,7 +134,7 @@ void H3DatagramAsyncSocket::onDatagram(
     auto stripped = stripContextId(std::move(datagram));
     if (!stripped.has_value()) {
       // Non-zero context ID or malformed — silently drop
-      VLOG(4) << "Dropping datagram with non-zero or invalid context ID";
+      PRX_VLOG(4) << "Dropping datagram with non-zero or invalid context ID";
       return;
     }
     datagram = std::move(stripped.value());
@@ -157,15 +158,15 @@ void H3DatagramAsyncSocket::deliverDatagram(
   void* buf{nullptr};
   size_t len{0};
   ReadCallback::OnDataAvailableParams params;
-  CHECK(readCallback_);
-  CHECK(datagram);
+  PRX_CHECK(readCallback_);
+  PRX_CHECK(datagram);
   if (!readCallback_->shouldOnlyNotify()) {
 
     readCallback_->getReadBuffer(&buf, &len);
     if (buf == nullptr || len == 0 ||
         len < datagram->computeChainDataLength()) {
-      LOG(ERROR) << "Buffer too small to deliver "
-                 << datagram->computeChainDataLength() << " bytes datagram";
+      PRX_LOG(ERROR) << "Buffer too small to deliver "
+                     << datagram->computeChainDataLength() << " bytes datagram";
       return;
     }
     datagram->coalesce();
@@ -204,7 +205,7 @@ int H3DatagramAsyncSocket::recvmmsg(struct mmsghdr* msgvec,
                                     unsigned int vlen,
                                     unsigned int flags,
                                     struct timespec* /*timeout*/) {
-  CHECK_GT(vlen, 0);
+  PRX_CHECK_GT(vlen, 0u);
   auto bytesReceived = recvmsg(&msgvec->msg_hdr, flags);
   if (bytesReceived < 0) {
     return -1;
@@ -225,7 +226,7 @@ void H3DatagramAsyncSocket::onBody(
   while (leftToParse > 0) {
     auto typeRes = quic::follyutils::decodeQuicInteger(cursor, leftToParse);
     if (!typeRes) {
-      LOG(ERROR) << "Failed to decode capsule type.";
+      PRX_LOG(ERROR) << "Failed to decode capsule type.";
       return;
     }
     auto [type, typeLen] = typeRes.value();
@@ -233,14 +234,14 @@ void H3DatagramAsyncSocket::onBody(
     auto capLengthRes =
         quic::follyutils::decodeQuicInteger(cursor, leftToParse);
     if (!capLengthRes) {
-      LOG(ERROR) << "Failed to decode capsule length: type=" << type;
+      PRX_LOG(ERROR) << "Failed to decode capsule length: type=" << type;
       return;
     }
     auto [capLength, capLengthLen] = capLengthRes.value();
     leftToParse -= capLengthLen;
     if (capLength > leftToParse) {
-      LOG(ERROR) << "Not enough data for capsule: type=" << type
-                 << " length=" << capLength;
+      PRX_LOG(ERROR) << "Not enough data for capsule: type=" << type
+                     << " length=" << capLength;
       return;
     }
     H3Capsule ret{.type = type, .length = capLength, .data = nullptr};
@@ -300,7 +301,7 @@ void H3DatagramAsyncSocket::startClient() {
             .build();
     auto client = std::make_shared<quic::QuicClientTransport>(
         qEvb, std::move(sock), fizzClientContext);
-    CHECK(connectAddress_.isInitialized());
+    PRX_CHECK(connectAddress_.isInitialized());
     client->addNewPeerAddress(connectAddress_);
     if (!options_.hostname_.empty()) {
       client->setHostname(options_.hostname_);
@@ -337,7 +338,7 @@ void H3DatagramAsyncSocket::startClient() {
           {{proxygen::SettingsId::_HQ_DATAGRAM, 1}});
     }
 
-    VLOG(4) << "connecting to " << connectAddress_.describe();
+    PRX_VLOG(4) << "connecting to " << connectAddress_.describe();
     upstreamSession_->startNow();
     client->start(upstreamSession_, upstreamSession_);
   }
@@ -373,25 +374,25 @@ H3DatagramAsyncSocket::createFizzClientContext() {
 ssize_t H3DatagramAsyncSocket::write(const folly::SocketAddress& address,
                                      const std::unique_ptr<folly::IOBuf>& buf) {
   if (!buf) {
-    LOG(ERROR) << "Invalid write data";
+    PRX_LOG(ERROR) << "Invalid write data";
     errno = EINVAL;
     return -1;
   }
   if (!connectAddress_.isInitialized()) {
-    LOG(ERROR) << "Socket not connected. Must call connect()";
+    PRX_LOG(ERROR) << "Socket not connected. Must call connect()";
     errno = ENOTCONN;
     return -1;
   }
   // Can only write to the one address we are connected to
   if (address != connectAddress_) {
-    LOG(ERROR) << "Socket can only write to address " << connectAddress_;
+    PRX_LOG(ERROR) << "Socket can only write to address " << connectAddress_;
     errno = EINVAL;
     return -1;
   }
   auto size = buf->computeChainDataLength();
   if (!transportConnected_) {
     if (writeBuf_.size() < sndBufPkts_) {
-      VLOG(10) << "Socket not connected yet. Buffering datagram";
+      PRX_VLOG(10) << "Socket not connected yet. Buffering datagram";
       auto bufCopy = buf->clone();
       if (options_.rfcMode_) {
         bufCopy = prependContextId(std::move(bufCopy));
@@ -399,19 +400,20 @@ ssize_t H3DatagramAsyncSocket::write(const folly::SocketAddress& address,
       writeBuf_.emplace_back(std::move(bufCopy));
       return size;
     }
-    LOG(ERROR) << "Socket write buffer is full. Discarding datagram";
+    PRX_LOG(ERROR) << "Socket write buffer is full. Discarding datagram";
     errno = ENOBUFS;
     return -1;
   }
   if (!txn_) {
-    LOG(ERROR) << "Unable to create HTTP/3 transaction. Discarding datagram";
+    PRX_LOG(ERROR)
+        << "Unable to create HTTP/3 transaction. Discarding datagram";
     errno = ECANCELED;
     return -1;
   }
   if (size > txn_->getDatagramSizeLimit()) {
-    LOG(ERROR) << "Datagram too large len=" << size
-               << " transport max datagram size len="
-               << txn_->getDatagramSizeLimit() << ". Discarding datagram";
+    PRX_LOG(ERROR) << "Datagram too large len=" << size
+                   << " transport max datagram size len="
+                   << txn_->getDatagramSizeLimit() << ". Discarding datagram";
     errno = EMSGSIZE;
     return -1;
   }
@@ -420,7 +422,7 @@ ssize_t H3DatagramAsyncSocket::write(const folly::SocketAddress& address,
     datagramBuf = prependContextId(std::move(datagramBuf));
   }
   if (!txn_->sendDatagram(std::move(datagramBuf))) {
-    LOG(ERROR) << "Transport write buffer is full. Discarding datagram";
+    PRX_LOG(ERROR) << "Transport write buffer is full. Discarding datagram";
     // sendDatagram can only fail for exceeding the maximum size (checked
     // above) and if the write buffer is full
     errno = ENOBUFS;
@@ -438,7 +440,7 @@ void H3DatagramAsyncSocket::resumeRead(ReadCallback* cob) {
     inResumeRead_ = false;
   };
   inResumeRead_ = true;
-  readCallback_ = CHECK_NOTNULL(cob);
+  readCallback_ = PRX_CHECK_NOTNULL(cob);
   folly::DelayedDestruction::DestructorGuard dg(this);
   // if there are buffered datagrams, deliver those first.
   auto it = readBuf_.begin();
diff --git a/proxygen/lib/transport/H3DatagramAsyncSocket.h b/proxygen/lib/transport/H3DatagramAsyncSocket.h
index 904d6619ac..441f5b53a3 100644
--- a/proxygen/lib/transport/H3DatagramAsyncSocket.h
+++ b/proxygen/lib/transport/H3DatagramAsyncSocket.h
@@ -12,6 +12,7 @@
 #include <folly/io/async/AsyncUDPSocket.h>
 #include <proxygen/lib/http/session/HQUpstreamSession.h>
 #include <proxygen/lib/http/session/HTTPTransaction.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/api/QuicSocket.h>
 #include <quic/client/QuicClientTransport.h>
 
@@ -89,21 +90,21 @@ class H3DatagramAsyncSocket
   }
 
   void connect(const folly::SocketAddress& address) override {
-    CHECK(options_.mode_ == Mode::CLIENT);
+    PRX_CHECK(options_.mode_ == Mode::CLIENT);
     connectAddress_ = address;
     startClient();
   }
 
   void setFD(folly::NetworkSocket /*fd*/, FDOwnership /*ownership*/) override {
-    LOG(FATAL) << __func__ << " not supported";
+    PRX_LOG(FATAL) << __func__ << " not supported";
   }
 
   void setCmsgs(const folly::SocketCmsgMap& /*cmsgs*/) override {
-    LOG(FATAL) << __func__ << " not supported";
+    PRX_LOG(FATAL) << __func__ << " not supported";
   }
 
   void appendCmsgs(const folly::SocketCmsgMap& /*cmsgs*/) override {
-    LOG(FATAL) << __func__ << " not supported";
+    PRX_LOG(FATAL) << __func__ << " not supported";
   }
 
   ssize_t write(const folly::SocketAddress& address,
@@ -171,7 +172,7 @@ class H3DatagramAsyncSocket
 
   folly::NetworkSocket getNetworkSocket() const override {
     // Not great but better than crashing.
-    VLOG(4) << "getNetworkSocket returning fake socket";
+    PRX_VLOG(4) << "getNetworkSocket returning fake socket";
     return {};
   }
 
@@ -200,7 +201,7 @@ class H3DatagramAsyncSocket
   }
 
   void setBusyPoll(int /*busyPollUs*/) override {
-    VLOG(4) << "busy poll not supported";
+    PRX_VLOG(4) << "busy poll not supported";
   }
 
   void dontFragment(bool /*df*/) override {
@@ -213,7 +214,7 @@ class H3DatagramAsyncSocket
 
   void setErrMessageCallback(ErrMessageCallback*) override {
     // TODO do we want to support this and convey errors this way?
-    VLOG(4) << "err message callback not supported";
+    PRX_VLOG(4) << "err message callback not supported";
   }
 
   bool isBound() const override {
@@ -225,12 +226,12 @@ class H3DatagramAsyncSocket
   }
 
   void detachEventBase() override {
-    LOG(FATAL) << __func__ << " unsupported";
+    PRX_LOG(FATAL) << __func__ << " unsupported";
     folly::assume_unreachable();
   }
 
   void attachEventBase(folly::EventBase* /*evb*/) override {
-    LOG(FATAL) << __func__ << " unsupported";
+    PRX_LOG(FATAL) << __func__ << " unsupported";
     folly::assume_unreachable();
   }
 
@@ -240,13 +241,13 @@ class H3DatagramAsyncSocket
 
   void setOverrideNetOpsDispatcher(
       std::shared_ptr<folly::netops::Dispatcher> /*dispatcher*/) override {
-    LOG(FATAL) << __func__ << " unsupported";
+    PRX_LOG(FATAL) << __func__ << " unsupported";
     folly::assume_unreachable();
   }
 
   std::shared_ptr<folly::netops::Dispatcher> getOverrideNetOpsDispatcher()
       const override {
-    LOG(FATAL) << __func__ << " unsupported";
+    PRX_LOG(FATAL) << __func__ << " unsupported";
     folly::assume_unreachable();
   }
 
@@ -275,7 +276,7 @@ class H3DatagramAsyncSocket
 
   // Set the HTTP/3 Session. for testing only
   void setUpstreamSession(proxygen::HQUpstreamSession* session) {
-    CHECK(!upstreamSession_);
+    PRX_CHECK(!upstreamSession_);
     upstreamSession_ = session;
     upstreamSession_->setConnectCallback(this);
     upstreamSession_->setInfoCallback(this);
diff --git a/proxygen/lib/transport/PersistentFizzPskCache.h b/proxygen/lib/transport/PersistentFizzPskCache.h
index 746c7ff1e2..bd1aa2adfa 100644
--- a/proxygen/lib/transport/PersistentFizzPskCache.h
+++ b/proxygen/lib/transport/PersistentFizzPskCache.h
@@ -11,6 +11,7 @@
 #include <fizz/backend/openssl/certificate/CertUtils.h>
 #include <fizz/client/PskCache.h>
 #include <fizz/client/PskSerializationUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <wangle/client/persistence/FilePersistentCache.h>
 
 namespace proxygen {
@@ -63,7 +64,7 @@ class PersistentFizzPskCache : public fizz::client::PskCache {
                             err);
         return deserialized;
       } catch (const std::exception& ex) {
-        LOG(ERROR) << "Error deserializing PSK: " << ex.what();
+        PRX_LOG(ERROR) << "Error deserializing PSK: " << ex.what();
         cache_.remove(identity);
       }
     }
@@ -91,7 +92,7 @@ class PersistentFizzPskCache : public fizz::client::PskCache {
         }
         return deserialized;
       } catch (const std::exception& ex) {
-        LOG(ERROR) << "Error deserializing PSK: " << ex.what();
+        PRX_LOG(ERROR) << "Error deserializing PSK: " << ex.what();
         cache_.remove(identity);
       }
     }
diff --git a/proxygen/lib/transport/PersistentQuicPskCache.cpp b/proxygen/lib/transport/PersistentQuicPskCache.cpp
index 8785bbbb68..b14eaa4ed2 100644
--- a/proxygen/lib/transport/PersistentQuicPskCache.cpp
+++ b/proxygen/lib/transport/PersistentQuicPskCache.cpp
@@ -12,6 +12,7 @@
 #include <fizz/record/Types.h>
 #include <folly/Conv.h>
 #include <folly/json/dynamic.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/client/handshake/CachedServerTransportParametersSerialization.h>
 
 namespace {
@@ -73,7 +74,7 @@ quic::Optional<quic::QuicCachedPsk> PersistentQuicPskCache::getPsk(
     }
     return std::move(quicCachedPsk);
   } catch (const std::exception& ex) {
-    LOG(ERROR) << "Error deserializing PSK: " << ex.what();
+    PRX_LOG(ERROR) << "Error deserializing PSK: " << ex.what();
     cache_.remove(identity);
     return std::nullopt;
   }
diff --git a/proxygen/lib/transport/qmux/CMakeLists.txt b/proxygen/lib/transport/qmux/CMakeLists.txt
index b1901ede5c..7cb73916c5 100644
--- a/proxygen/lib/transport/qmux/CMakeLists.txt
+++ b/proxygen/lib/transport/qmux/CMakeLists.txt
@@ -11,6 +11,7 @@ proxygen_add_library(proxygen_transport_qmux_qmux_framer
     QmuxFramer.cpp
   DEPS
     proxygen_http_codec_varint_utils
+    proxygen_utils_log_shim
     mvfst::mvfst_codec_types
     mvfst::mvfst_folly_utils
   EXPORTED_DEPS
@@ -38,8 +39,8 @@ proxygen_add_library(proxygen_transport_qmux_qmux_session
     QmuxSession.cpp
   DEPS
     proxygen_transport_qmux_qmux_codec
+    proxygen_utils_log_shim
     Folly::folly_io_coro_socket
-    Folly::folly_logging_logging
   EXPORTED_DEPS
     proxygen_http_coro_util_CoroWtSession
     proxygen_http_webtransport_wt_stream_manager
@@ -52,12 +53,12 @@ proxygen_add_library(proxygen_transport_qmux_qmux_connector
   SRCS
     QmuxConnector.cpp
   DEPS
+    proxygen_utils_log_shim
     mvfst::mvfst_folly_utils
     Folly::folly_coro_timeout
     Folly::folly_futures_core
     Folly::folly_io_coro_socket
     Folly::folly_io_iobuf
-    Folly::folly_logging_logging
     fmt::fmt
   EXPORTED_DEPS
     proxygen_http_webtransport_wt_stream_manager
diff --git a/proxygen/lib/transport/qmux/QmuxConnector.cpp b/proxygen/lib/transport/qmux/QmuxConnector.cpp
index 72cbc39f94..798e7f967f 100644
--- a/proxygen/lib/transport/qmux/QmuxConnector.cpp
+++ b/proxygen/lib/transport/qmux/QmuxConnector.cpp
@@ -15,7 +15,7 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBufQueue.h>
 #include <folly/io/coro/Transport.h>
-#include <folly/logging/xlog.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/folly_utils/Utils.h>
 #include <stdexcept>
 
@@ -201,8 +201,8 @@ folly::coro::Task<QmuxSession::Ptr> QmuxConnector::connect(
     std::unique_ptr<folly::coro::TransportIf> transport,
     std::chrono::milliseconds timeout,
     QmuxSession::Config sessionConfig) {
-  XLOG(DBG4) << "QmuxConnector::connect dir=" << static_cast<int>(dir)
-             << " timeout=" << timeout.count() << "ms";
+  PRX_VLOG(4) << "QmuxConnector::connect dir=" << static_cast<int>(dir)
+              << " timeout=" << timeout.count() << "ms";
 
   // 1) Send our QX_TRANSPORT_PARAMETERS, wrapped as a QMux record.
   folly::IOBufQueue framesBuf{folly::IOBufQueue::cacheChainLength()};
@@ -213,7 +213,8 @@ folly::coro::Task<QmuxSession::Ptr> QmuxConnector::connect(
   auto writeRes =
       co_await folly::coro::co_awaitTry(transport->write(recordBuf, timeout));
   if (writeRes.hasException()) {
-    XLOG(ERR) << "QmuxConnector: TP write failed: " << writeRes.exception();
+    PRX_LOG(ERROR) << "QmuxConnector: TP write failed: "
+                   << writeRes.exception();
     co_yield co_error(writeRes.exception());
   }
 
@@ -226,7 +227,8 @@ folly::coro::Task<QmuxSession::Ptr> QmuxConnector::connect(
   auto peerParams = co_await folly::coro::co_awaitTry(folly::coro::timeout(
       readPeerTransportParams(*transport, ingressBuf, timeout), timeout, &tk));
   if (peerParams.hasException()) {
-    XLOG(ERR) << "QmuxConnector: TP read failed: " << peerParams.exception();
+    PRX_LOG(ERROR) << "QmuxConnector: TP read failed: "
+                   << peerParams.exception();
     co_yield co_error(peerParams.exception());
   }
 
diff --git a/proxygen/lib/transport/qmux/QmuxFramer.cpp b/proxygen/lib/transport/qmux/QmuxFramer.cpp
index 8da4582a0b..f6c47150c3 100644
--- a/proxygen/lib/transport/qmux/QmuxFramer.cpp
+++ b/proxygen/lib/transport/qmux/QmuxFramer.cpp
@@ -11,6 +11,7 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBufQueue.h>
 #include <proxygen/lib/http/codec/VarintUtils.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <quic/codec/QuicInteger.h>
 #include <quic/folly_utils/Utils.h>
 
@@ -294,7 +295,7 @@ folly::Expected<QxPing, QmuxErrorCode> parsePing(folly::io::Cursor& cursor,
 
 WriteResult writeRecord(folly::IOBufQueue& queue,
                         std::unique_ptr<folly::IOBuf> frames) {
-  CHECK(frames) << "frames must be non-null";
+  PRX_CHECK(frames) << "frames must be non-null";
   size_t size = 0;
   bool error = false;
   auto framesLen = frames->computeChainDataLength();
diff --git a/proxygen/lib/transport/qmux/QmuxSession.cpp b/proxygen/lib/transport/qmux/QmuxSession.cpp
index 902262e506..d3ec9a438f 100644
--- a/proxygen/lib/transport/qmux/QmuxSession.cpp
+++ b/proxygen/lib/transport/qmux/QmuxSession.cpp
@@ -9,8 +9,8 @@
 #include <proxygen/lib/transport/qmux/QmuxSession.h>
 
 #include <folly/io/coro/Transport.h>
-#include <folly/logging/xlog.h>
 #include <proxygen/lib/transport/qmux/QmuxCodec.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 using namespace proxygen::qmux;
@@ -25,11 +25,11 @@ struct QmuxEventVisitor : proxygen::detail::WtEventVisitor {
   using WtEventVisitor::operator();
 
   void operator()(WtStreamManager::DrainSession) const noexcept {
-    XLOG(DBG6) << "QmuxEventVisitor DrainSession (no-op)";
+    PRX_VLOG(6) << "QmuxEventVisitor DrainSession (no-op)";
   }
 
   void operator()(WtStreamManager::CloseSession cs) noexcept {
-    XLOG(DBG6) << "QmuxEventVisitor cs.err=" << cs.err << " cs.msg=" << cs.msg;
+    PRX_VLOG(6) << "QmuxEventVisitor cs.err=" << cs.err << " cs.msg=" << cs.msg;
     sessionClosed = true;
     writeConnectionClose(egress,
                          QxConnectionClose{.errorCode = cs.err,
@@ -58,8 +58,8 @@ class QmuxCallback : public QmuxCodec::Callback {
 
   // QMUX-specific callbacks
   void onConnectionClose(QxConnectionClose c) noexcept override {
-    XLOG(DBG6) << __func__ << "; err=" << c.errorCode
-               << "; reason=" << c.reasonPhrase;
+    PRX_VLOG(6) << __func__ << "; err=" << c.errorCode
+                << "; reason=" << c.reasonPhrase;
     sm_.onCloseSession(
         WtStreamManager::CloseSession{.err = static_cast<uint64_t>(c.errorCode),
                                       .msg = std::move(c.reasonPhrase)});
@@ -69,21 +69,21 @@ class QmuxCallback : public QmuxCodec::Callback {
   // runs, so any TP frame reaching the steady-state codec is a peer protocol
   // violation.
   void onTransportParameters(QxTransportParams) noexcept override {
-    XLOG(DFATAL) << "unexpected QX_TRANSPORT_PARAMETERS after handshake";
+    PRX_LOG(DFATAL) << "unexpected QX_TRANSPORT_PARAMETERS after handshake";
   }
 
   void onPing(QxPing p) noexcept override {
-    XLOG(DBG6) << __func__ << "; seq=" << p.sequenceNumber;
+    PRX_VLOG(6) << __func__ << "; seq=" << p.sequenceNumber;
     session_.pendingPongs_.emplace_back(p);
     session_.wtSmEgressCb.waitForEvent.signal();
   }
 
   void onPong(QxPing p) noexcept override {
-    XLOG(DBG6) << __func__ << "; seq=" << p.sequenceNumber;
+    PRX_VLOG(6) << __func__ << "; seq=" << p.sequenceNumber;
   }
 
   void onConnectionError(QmuxErrorCode err) noexcept override {
-    XLOG(DBG6) << __func__ << "; err=" << static_cast<uint32_t>(err);
+    PRX_VLOG(6) << __func__ << "; err=" << static_cast<uint32_t>(err);
     sm_.onCloseSession(
         WtStreamManager::CloseSession{.err = 0, .msg = "onConnectionError"});
   }
@@ -93,7 +93,7 @@ class QmuxCallback : public QmuxCodec::Callback {
   // dropped when they cannot be promptly delivered, so dropping when no
   // handler is attached is acceptable.
   void onDatagram(DatagramCapsule dgram) noexcept override {
-    XLOG(DBG6) << __func__;
+    PRX_VLOG(6) << __func__;
     if (auto* handler = session_.wtHandler_) {
       handler->onDatagram(std::move(dgram.httpDatagramPayload));
     }
@@ -146,7 +146,7 @@ proxygen::detail::WtExpected<folly::Unit>::Type QmuxSession::sendDatagram(
 }
 
 void QmuxSession::start(Ptr self) {
-  XLOG(DBG4) << "QmuxSession::start dir=" << (peerAddr_.describe());
+  PRX_VLOG(4) << "QmuxSession::start dir=" << (peerAddr_.describe());
   if (wtHandler_) {
     wtHandler_->onWebTransportSession(self);
   }
@@ -157,7 +157,7 @@ void QmuxSession::start(Ptr self) {
 }
 
 folly::coro::Task<void> QmuxSession::readLoop(Ptr self) {
-  XLOG(DBG4) << "QmuxSession::readLoop started dir=" << peerAddr_.describe();
+  PRX_VLOG(4) << "QmuxSession::readLoop started dir=" << peerAddr_.describe();
   QmuxCallback qmuxCallback{sm, *self, *self};
   QmuxCodec codec{&qmuxCallback,
                   [&sm = this->sm](uint64_t streamId, uint64_t offset) {
@@ -184,7 +184,7 @@ folly::coro::Task<void> QmuxSession::readLoop(Ptr self) {
                            /*newAllocationSize=*/4000,
                            /*timeout=*/std::chrono::milliseconds(0)));
       if (readRes.hasException()) {
-        XLOG(DBG4) << __func__ << "; ex=" << readRes.exception();
+        PRX_VLOG(4) << __func__ << "; ex=" << readRes.exception();
         break;
       }
       eom = (*readRes == 0);
@@ -201,7 +201,7 @@ folly::coro::Task<void> QmuxSession::readLoop(Ptr self) {
     }
   }
   idleTimeout_.cancelTimeout();
-  XLOG(DBG4) << "QmuxSession::readLoop exiting";
+  PRX_VLOG(4) << "QmuxSession::readLoop exiting";
   sm.shutdown(WtStreamManager::CloseSession{.err = 0x00,
                                             .msg = "stream ingress closed"});
   readLoopFinished();
@@ -219,14 +219,14 @@ void QmuxSession::resetIdleTimeout() {
 }
 
 void QmuxSession::onIdleTimeout() {
-  XLOG(DBG4) << "QmuxSession::onIdleTimeout sess=" << this
-             << " effectiveMaxIdleTimeoutMs=" << effectiveMaxIdleTimeoutMs_;
+  PRX_VLOG(4) << "QmuxSession::onIdleTimeout sess=" << this
+              << " effectiveMaxIdleTimeoutMs=" << effectiveMaxIdleTimeoutMs_;
   cs_.requestCancellation();
   sm.shutdown(WtStreamManager::CloseSession{.err = 0, .msg = "idle timeout"});
 }
 
 folly::coro::Task<void> QmuxSession::writeLoop(Ptr self) {
-  XLOG(DBG4) << "QmuxSession::writeLoop started dir=" << peerAddr_.describe();
+  PRX_VLOG(4) << "QmuxSession::writeLoop started dir=" << peerAddr_.describe();
   folly::IOBufQueue egressBuf{folly::IOBufQueue::cacheChainLength()};
   QmuxEventVisitor eventVisitor{
       {.egress = egressBuf, .protocol = FrameProtocol::QMUX}};
@@ -235,11 +235,11 @@ folly::coro::Task<void> QmuxSession::writeLoop(Ptr self) {
   // sessionClosed flips to true once the visitor has serialized a
   // QxConnectionClose for sm's CloseSession event.
   while (!eventVisitor.sessionClosed) {
-    XLOG(DBG6) << "waiting for WtStreamManager event";
+    PRX_VLOG(6) << "waiting for WtStreamManager event";
     co_await waitForEventBaton.wait();
     waitForEventBaton.reset();
 
-    XLOG(DBG6) << "received WtStreamManager event";
+    PRX_VLOG(6) << "received WtStreamManager event";
     // Always write control frames first
     auto ctrl = sm.moveEvents();
     for (auto& ev : ctrl) {
@@ -259,7 +259,7 @@ folly::coro::Task<void> QmuxSession::writeLoop(Ptr self) {
         self->peerMaxRecordSize_ > kStreamFrameOverhead
             ? self->peerMaxRecordSize_ - kStreamFrameOverhead
             : 0;
-    XCHECK(!(wh && maxStreamData == 0))
+    PRX_CHECK(!(wh && maxStreamData == 0))
         << "peer max_record_size too small. The framer rejects undersized "
            "max_record_size at TP parse time";
     while (wh && egressBuf.chainLength() < kMaxWriteSize) {
@@ -300,7 +300,7 @@ folly::coro::Task<void> QmuxSession::writeLoop(Ptr self) {
       if (writeRes.hasException()) {
         sm.onCloseSession(
             WtStreamManager::CloseSession{.err = 0, .msg = "write error"});
-        XLOG(DBG4) << __func__ << "; ex=" << writeRes.exception();
+        PRX_VLOG(4) << __func__ << "; ex=" << writeRes.exception();
         break;
       }
       // QMux draft "Closing the Connection": endpoints reset the idle
@@ -310,7 +310,7 @@ folly::coro::Task<void> QmuxSession::writeLoop(Ptr self) {
     }
   }
 
-  XLOG(DBG4) << "QmuxSession::writeLoop exiting";
+  PRX_VLOG(4) << "QmuxSession::writeLoop exiting";
   transport_->shutdownWrite();
   writeLoopFinished();
   co_return;
diff --git a/proxygen/lib/transport/test/H3DatagramAsyncSocketTest.cpp b/proxygen/lib/transport/test/H3DatagramAsyncSocketTest.cpp
index 7d06208311..59dd3a88d1 100644
--- a/proxygen/lib/transport/test/H3DatagramAsyncSocketTest.cpp
+++ b/proxygen/lib/transport/test/H3DatagramAsyncSocketTest.cpp
@@ -11,6 +11,7 @@
 #include <proxygen/lib/transport/test/H3DatagramAsyncSocketTest.h>
 
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace proxygen;
 using namespace quic;
@@ -83,7 +84,7 @@ folly::SocketAddress& H3DatagramAsyncSocketTest::getRemoteAddress() {
 
 ssize_t H3DatagramAsyncSocketTest::sendDatagramUpstream(
     std::unique_ptr<folly::IOBuf> datagram) {
-  CHECK(datagramSocket_);
+  PRX_CHECK(datagramSocket_);
   return datagramSocket_->write(getRemoteAddress(), datagram);
 }
 
diff --git a/proxygen/lib/utils/AcceptorAddress.h b/proxygen/lib/utils/AcceptorAddress.h
index 06fa795629..a8201df21f 100644
--- a/proxygen/lib/utils/AcceptorAddress.h
+++ b/proxygen/lib/utils/AcceptorAddress.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/SocketAddress.h>
 
@@ -48,7 +48,7 @@ inline std::ostream& operator<<(std::ostream& os,
       os << "UDP";
       break;
     default:
-      LOG(FATAL) << "Unknown Acceptor type.";
+      PRX_LOG(FATAL) << "Unknown Acceptor type.";
   }
   return os;
 }
diff --git a/proxygen/lib/utils/CMakeLists.txt b/proxygen/lib/utils/CMakeLists.txt
index 3667c614e3..04c5ad2c69 100644
--- a/proxygen/lib/utils/CMakeLists.txt
+++ b/proxygen/lib/utils/CMakeLists.txt
@@ -6,6 +6,15 @@
 
 # Auto-generated by proxygen/facebook/generate_cmake.py - DO NOT EDIT MANUALLY
 
+proxygen_add_library(proxygen_utils_config)
+
+proxygen_add_library(proxygen_utils_log_shim
+  EXPORTED_DEPS
+    proxygen_utils_config
+    Folly::folly_glog
+    Folly::folly_logging_logging
+)
+
 proxygen_add_library(proxygen_utils_headers
   EXPORTED_DEPS
     Folly::folly_conv
@@ -24,6 +33,7 @@ proxygen_add_library(proxygen_utils_headers
 
 proxygen_add_library(proxygen_utils_cob_helper
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     glog::glog
 )
 
@@ -47,6 +57,7 @@ proxygen_add_library(proxygen_utils_exception
 
 proxygen_add_library(proxygen_utils_filter_chain
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_function
     Folly::folly_memory
     glog::glog
@@ -61,6 +72,7 @@ proxygen_add_library(proxygen_utils_logging
     Folly::folly_string
     fmt::fmt
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_iobuf
     Folly::folly_optional
 )
@@ -92,6 +104,7 @@ proxygen_add_library(proxygen_utils_sockopts
 
 proxygen_add_library(proxygen_utils_state_machine
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     glog::glog
 )
 
@@ -122,6 +135,7 @@ proxygen_add_library(proxygen_utils_parse_url
     Folly::folly_portability_sockets
   EXPORTED_DEPS
     proxygen_utils_export
+    proxygen_utils_log_shim
     Folly::folly_portability_windows
     Folly::folly_string
     glog::glog
@@ -153,6 +167,7 @@ proxygen_add_library(proxygen_utils_trace
   EXPORTED_DEPS
     proxygen_utils_exception
     proxygen_utils_export
+    proxygen_utils_log_shim
     proxygen_utils_time_util
     Folly::folly_conv
     Folly::folly_lang_exception
@@ -163,6 +178,7 @@ proxygen_add_library(proxygen_utils_compression_filter_utils
   EXPORTED_DEPS
     proxygen_http_http_headers
     proxygen_http_message
+    proxygen_utils_log_shim
     proxygen_utils_stream_compressor
     proxygen_utils_zlib_stream_compressor
     proxygen_utils_zstd_stream_compressor
@@ -184,6 +200,7 @@ proxygen_add_library(proxygen_utils_zlib_stream_decompressor
   DEPS
     Folly::folly_io_iobuf
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     proxygen_utils_stream_decompressor
     ZLIB::ZLIB
 )
@@ -194,6 +211,7 @@ proxygen_add_library(proxygen_utils_zlib_stream_compressor
   DEPS
     Folly::folly_io_iobuf
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     proxygen_utils_stream_compressor
     proxygen_utils_zlib_stream_decompressor
     Folly::folly_portability_gflags
@@ -204,6 +222,7 @@ proxygen_add_library(proxygen_utils_zstd_stream_compressor
   SRCS
     ZstdStreamCompressor.cpp
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     proxygen_utils_stream_compressor
     Folly::folly_compression_compression
 )
@@ -214,6 +233,7 @@ proxygen_add_library(proxygen_utils_zstd_stream_decompressor
   DEPS
     Folly::folly_io_iobuf
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     proxygen_utils_stream_decompressor
     Folly::folly_memory
     ${ZSTD_LIBRARIES}
@@ -233,6 +253,7 @@ proxygen_add_library(proxygen_utils_shared_wheel_timer
     Folly::folly_io_async_event_base_manager
     Folly::folly_singleton
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_io_async_async_base
 )
 
@@ -243,12 +264,14 @@ proxygen_add_library(proxygen_utils_null_trace_event_observer
 
 proxygen_add_library(proxygen_utils_acceptor_address
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_network_address
     glog::glog
 )
 
 proxygen_add_library(proxygen_utils_perfect_index_map
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     proxygen_utils_util_inl
     Folly::folly_fbvector
     Folly::folly_optional
@@ -257,12 +280,14 @@ proxygen_add_library(proxygen_utils_perfect_index_map
 
 proxygen_add_library(proxygen_utils_conditional_gate
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     Folly::folly_function
     glog::glog
 )
 
 proxygen_add_library(proxygen_utils_weak_ref_counted_ptr
   EXPORTED_DEPS
+    proxygen_utils_log_shim
     glog::glog
 )
 
diff --git a/proxygen/lib/utils/CobHelper.h b/proxygen/lib/utils/CobHelper.h
index 71cc96c746..c22b82d48d 100644
--- a/proxygen/lib/utils/CobHelper.h
+++ b/proxygen/lib/utils/CobHelper.h
@@ -11,7 +11,7 @@
 #include <atomic>
 #include <functional>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -28,7 +28,7 @@ class CobHelper {
   }
 
   void setError(const std::string& emsg) {
-    CHECK(!emsg.empty());
+    PRX_CHECK(!emsg.empty());
     emsg_ = emsg;
   }
 
diff --git a/proxygen/lib/utils/CompressionFilterUtils.h b/proxygen/lib/utils/CompressionFilterUtils.h
index b433878feb..737c9990b4 100644
--- a/proxygen/lib/utils/CompressionFilterUtils.h
+++ b/proxygen/lib/utils/CompressionFilterUtils.h
@@ -10,6 +10,7 @@
 
 #include <proxygen/lib/http/HTTPMessage.h>
 #include <proxygen/lib/http/RFC2616.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/StreamCompressor.h>
 #include <proxygen/lib/utils/ZlibStreamCompressor.h>
 #include <proxygen/lib/utils/ZstdStreamCompressor.h>
@@ -153,7 +154,7 @@ class CompressionFilterUtils {
     } else if (it->first == "gzip") {
       return CodecType::ZLIB;
     } else {
-      DCHECK(false) << "found unexpected content-coding selection";
+      PRX_DCHECK(false) << "found unexpected content-coding selection";
       return CodecType::NO_COMPRESSION;
     }
   }
diff --git a/proxygen/lib/utils/ConditionalGate.h b/proxygen/lib/utils/ConditionalGate.h
index 4c556595da..83faa18294 100644
--- a/proxygen/lib/utils/ConditionalGate.h
+++ b/proxygen/lib/utils/ConditionalGate.h
@@ -10,8 +10,8 @@
 
 #include <bitset>
 #include <folly/Function.h>
-#include <glog/logging.h>
 #include <ostream>
+#include <proxygen/lib/utils/LogShim.h>
 #include <vector>
 
 namespace proxygen {
@@ -57,8 +57,8 @@ class ConditionalGate {
     set(static_cast<size_t>(e));
   }
   void set(size_t i = 0) {
-    CHECK_LT(i, conditions_.size());
-    CHECK(!conditions_[i]);
+    PRX_CHECK_LT(i, conditions_.size());
+    PRX_CHECK(!conditions_[i]);
     conditions_[i] = true;
     if (conditions_.all()) {
       invoke();
@@ -70,7 +70,7 @@ class ConditionalGate {
     return get(static_cast<size_t>(e));
   }
   [[nodiscard]] bool get(size_t i = 0) const {
-    CHECK_LT(i, conditions_.size());
+    PRX_CHECK_LT(i, conditions_.size());
     return conditions_[i];
   }
 
diff --git a/proxygen/lib/utils/FilterChain.h b/proxygen/lib/utils/FilterChain.h
index 5188e9809d..cb530e6dba 100644
--- a/proxygen/lib/utils/FilterChain.h
+++ b/proxygen/lib/utils/FilterChain.h
@@ -10,8 +10,8 @@
 
 #include <folly/Function.h>
 #include <folly/Memory.h>
-#include <glog/logging.h>
 #include <memory>
+#include <proxygen/lib/utils/LogShim.h>
 #include <utility>
 
 namespace proxygen {
@@ -217,7 +217,7 @@ class FilterChain : private FilterType {
     static_assert(TakeOwnership,
                   "unique_ptr constructor only available "
                   "if the chain owns the filters.");
-    this->call_ = CHECK_NOTNULL(destination.release());
+    this->call_ = PRX_CHECK_NOTNULL(destination.release());
     this->callback_ = nullptr; // must call setCallback() explicitly
     this->callSource_ = this;
     this->callbackSource_ = this->call_;
@@ -228,7 +228,7 @@ class FilterChain : private FilterType {
     static_assert(!TakeOwnership,
                   "raw pointer constructor only available "
                   "if the chain doesn't own the filters.");
-    this->call_ = CHECK_NOTNULL(destination);
+    this->call_ = PRX_CHECK_NOTNULL(destination);
     this->callback_ = nullptr; // must call setCallback() explicitly
     this->callSource_ = this;
     this->callbackSource_ = this->call_;
@@ -294,7 +294,7 @@ class FilterChain : private FilterType {
     if (lastFilter->kWantsCallbacks_) {
       lastCallback = lastFilter;
     }
-    lastFilter->call_ = CHECK_NOTNULL(destination.release());
+    lastFilter->call_ = PRX_CHECK_NOTNULL(destination.release());
     lastCall->call_ = lastFilter->call_;
     lastCallback->callbackSource_ = lastFilter->call_;
     auto oldChainEnd = this->chainEnd_;
diff --git a/proxygen/lib/utils/LogShim.h b/proxygen/lib/utils/LogShim.h
new file mode 100644
index 0000000000..d16c53b8da
--- /dev/null
+++ b/proxygen/lib/utils/LogShim.h
@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <proxygen/proxygen-config.h>
+
+/**
+ * proxygen/lib/utils/LogShim.h defines the PRX_LOG, PRX_VLOG, PRX_CHECK,
+ * PRX_DCHECK, and PRX_PCHECK macros.
+ *
+ * The backend is selected by exactly one of PRX_LOGGING_GLOG,
+ * PRX_LOGGING_XLOG, or PRX_LOGGING_DISABLED being defined to 1
+ * in <proxygen/proxygen-config.h>. CMake derives that from
+ * -DPROXYGEN_LOGGING_BACKEND ({GLOG,XLOG,DISABLED}); Buck consumers select
+ * the variant via `-c proxygen.logging_backend={glog,xlog,disabled}` (default
+ * glog), which the //proxygen/lib/utils:config rule reads to pick the
+ * appropriate hand-written header.
+ *
+ * Macro authoring constraints:
+ *   - PRX_LOG(level): `level` must be one of the unqualified glog tokens
+ *     INFO, WARNING, ERROR, FATAL, DFATAL.
+ *   - PRX_VLOG(n): `n` must be an integer literal 0..9. Values >9 are
+ *     accepted (saturated to DBG9 in folly-logging mode) but for granularity
+ *     finer than 0..9, use the appropriate PRX_LOG level instead.
+ *   - PRX_PCHECK loses the `: <strerror(errno)>` suffix in folly-logging
+ *     and disabled modes. TODO: fix once folly exposes XPCHECK.
+ */
+
+#if PRX_LOGGING_GLOG
+
+#include <folly/GLog.h>
+#define PRX_VLOG VLOG
+#define PRX_VLOG_LEVEL VLOG
+#define PRX_VLOG_IF VLOG_IF
+#define PRX_VLOG_IS_ON VLOG_IS_ON
+#define PRX_DLOG DLOG
+#define PRX_DVLOG DVLOG
+#define PRX_DVLOG_LEVEL DVLOG
+#define PRX_LOG LOG
+#define PRX_LOG_IF LOG_IF
+#define PRX_LOG_EVERY_MS FB_LOG_EVERY_MS
+#define PRX_LOG_EVERY_N LOG_EVERY_N
+#define PRX_CHECK CHECK
+#define PRX_CHECK_EQ CHECK_EQ
+#define PRX_CHECK_NE CHECK_NE
+#define PRX_CHECK_GE CHECK_GE
+#define PRX_CHECK_GT CHECK_GT
+#define PRX_CHECK_LE CHECK_LE
+#define PRX_CHECK_LT CHECK_LT
+#define PRX_CHECK_NOTNULL CHECK_NOTNULL
+#define PRX_PCHECK PCHECK
+#define PRX_DCHECK DCHECK
+#define PRX_DCHECK_EQ DCHECK_EQ
+#define PRX_DCHECK_NE DCHECK_NE
+#define PRX_DCHECK_GE DCHECK_GE
+#define PRX_DCHECK_GT DCHECK_GT
+#define PRX_DCHECK_LE DCHECK_LE
+#define PRX_DCHECK_LT DCHECK_LT
+
+#elif PRX_LOGGING_XLOG
+
+#include <folly/logging/LogLevel.h>
+#include <folly/logging/Logger.h>
+#include <folly/logging/xlog.h>
+
+// Mapping from glog level tokens to the corresponding folly::xlog values.
+#define PRX_LOGLEVEL_INFO INFO
+#define PRX_LOGLEVEL_WARNING WARN
+#define PRX_LOGLEVEL_ERROR ERR
+#define PRX_LOGLEVEL_FATAL FATAL
+#define PRX_LOGLEVEL_DFATAL DFATAL
+
+// glog's VLOG(n) accepts arbitrary integer verbosity; folly's xlog only
+// defines DBG0..DBG9. Map 0..9 directly; saturate higher values to DBG9 so
+// VLOG(10+) call sites still compile in folly-logging mode. The cap is
+// documented at the top of this header.
+#define PRX_LOGGING_DBG_0 DBG0
+#define PRX_LOGGING_DBG_1 DBG1
+#define PRX_LOGGING_DBG_2 DBG2
+#define PRX_LOGGING_DBG_3 DBG3
+#define PRX_LOGGING_DBG_4 DBG4
+#define PRX_LOGGING_DBG_5 DBG5
+#define PRX_LOGGING_DBG_6 DBG6
+#define PRX_LOGGING_DBG_7 DBG7
+#define PRX_LOGGING_DBG_8 DBG8
+#define PRX_LOGGING_DBG_9 DBG9
+#define PRX_LOGGING_DBG_10 DBG9
+#define PRX_LOGGING_DBG_11 DBG9
+#define PRX_LOGGING_DBG_12 DBG9
+#define PRX_LOGGING_DBG_13 DBG9
+#define PRX_LOGGING_DBG_14 DBG9
+#define PRX_LOGGING_DBG_15 DBG9
+
+#define PRX_VLOG(n) XLOG(PRX_LOGGING_DBG_##n)
+#define PRX_VLOG_IF(n, cond) XLOG_IF(PRX_LOGGING_DBG_##n, (cond))
+#define PRX_VLOG_IS_ON(n) XLOG_IS_ON(PRX_LOGGING_DBG_##n)
+#define PRX_DLOG(level) XLOG(PRX_LOGLEVEL_##level)
+#define PRX_DVLOG(n) XLOG(PRX_LOGGING_DBG_##n)
+
+namespace proxygen::logging::detail {
+// PRX_VLOG_LEVEL(n) runtime path: convert int -> folly::LogLevel. n in 0..9
+// maps to DBG0..DBG9 (more verbose as n grows). Values >9 saturate at DBG9.
+inline constexpr ::folly::LogLevel prxVLogLevel(int n) {
+  return static_cast<::folly::LogLevel>(
+      static_cast<::std::uint32_t>(::folly::LogLevel::DBG0) -
+      static_cast<::std::uint32_t>(n < 0 ? 0 : (n > 9 ? 9 : n)));
+}
+} // namespace proxygen::logging::detail
+
+// Runtime-level variants for callers that need to pass a non-literal n.
+// Uses FB_LOG_RAW with a per-call-site cached Logger so the category lookup
+// happens once per site, not once per call. Prefer PRX_VLOG(n) when n is a
+// literal — that path stays on the fast XLOG static-cached check.
+#define PRX_VLOG_LEVEL(n)                                                    \
+  FB_LOG_RAW(([]() -> ::folly::Logger& {                                     \
+               static ::folly::Logger _prx_logger{XLOG_GET_CATEGORY_NAME()}; \
+               return _prx_logger;                                           \
+             }()),                                                           \
+             ::proxygen::logging::detail::prxVLogLevel(n),                   \
+             XLOG_FILENAME,                                                  \
+             __LINE__,                                                       \
+             __func__)
+#define PRX_DVLOG_LEVEL(n) PRX_VLOG_LEVEL(n)
+
+#define PRX_LOG(level) XLOG(PRX_LOGLEVEL_##level)
+#define PRX_LOG_IF(level, cond) XLOG_IF(PRX_LOGLEVEL_##level, (cond))
+#define PRX_LOG_EVERY_MS(level, ms) XLOG_EVERY_MS(PRX_LOGLEVEL_##level, ms)
+#define PRX_LOG_EVERY_N(level, n) XLOG_EVERY_N(PRX_LOGLEVEL_##level, n)
+
+#define PRX_CHECK XCHECK
+#define PRX_CHECK_EQ XCHECK_EQ
+#define PRX_CHECK_NE XCHECK_NE
+#define PRX_CHECK_GE XCHECK_GE
+#define PRX_CHECK_GT XCHECK_GT
+#define PRX_CHECK_LE XCHECK_LE
+#define PRX_CHECK_LT XCHECK_LT
+// XCHECK_NOTNULL is not provided by folly; emulate via a generic lambda that
+// asserts non-null and returns the original (possibly-rvalue) pointer so call
+// sites like `auto p = PRX_CHECK_NOTNULL(expr);` keep working.
+#define PRX_CHECK_NOTNULL(p)                       \
+  ([](auto&& _prx_p) -> decltype(auto) {           \
+    XCHECK(_prx_p != nullptr);                     \
+    return std::forward<decltype(_prx_p)>(_prx_p); \
+  }(p))
+// XCHECK does not append : <strerror(errno)> the way glog's PCHECK does.
+// TODO: replace with XPCHECK once folly provides one.
+#define PRX_PCHECK XCHECK
+#define PRX_DCHECK XDCHECK
+#define PRX_DCHECK_EQ XDCHECK_EQ
+#define PRX_DCHECK_NE XDCHECK_NE
+#define PRX_DCHECK_GE XDCHECK_GE
+#define PRX_DCHECK_GT XDCHECK_GT
+#define PRX_DCHECK_LE XDCHECK_LE
+#define PRX_DCHECK_LT XDCHECK_LT
+
+#else // PRX_LOGGING_DISABLED
+
+// Proxygen logging disabled
+//
+// PRX_DCHECK()s are mapped to assert(...)
+// PRX_CHECK()s and PRX_PCHECK()s are mapped to if (!(expr)) { abort(); }
+//   (PCHECK loses the strerror(errno) suffix glog provides; see TODO above.)
+//
+// All log output is silently dropped.
+
+#include <cassert>
+#include <cstdlib>
+#include <utility>
+
+namespace proxygen::logging::detail {
+struct NoopStream {};
+
+template <class T>
+inline NoopStream operator<<(NoopStream stream, T&&) {
+  return stream;
+}
+
+} // namespace proxygen::logging::detail
+
+// The value of this is not important. These definitions are here to make sure
+// that the loglevel of PRX_LOG() is either {INFO, WARNING, ERROR, FATAL,
+// DFATAL} tokens since anything else will cause the comma operator expansion
+// to fail.
+#define PRX_LOGLEVEL_INFO 0
+#define PRX_LOGLEVEL_WARNING 0
+#define PRX_LOGLEVEL_ERROR 0
+#define PRX_LOGLEVEL_FATAL 0
+#define PRX_LOGLEVEL_DFATAL 0
+
+#define PRX_DCHECK_BINOP_(a, op, b)                   \
+  ([&] {                                              \
+    assert((a)op(b));                                 \
+    return ::proxygen::logging::detail::NoopStream{}; \
+  }())
+#define PRX_CHECK_BINOP_(a, op, b)                    \
+  ([&] {                                              \
+    if (!((a)op(b))) {                                \
+      std::abort();                                   \
+    }                                                 \
+    return ::proxygen::logging::detail::NoopStream{}; \
+  }())
+#define PRX_VLOG(level) \
+  ([](int) { return ::proxygen::logging::detail::NoopStream{}; }((level)))
+#define PRX_VLOG_LEVEL(level) PRX_VLOG(level)
+#define PRX_DVLOG_LEVEL(level) PRX_VLOG(level)
+#define PRX_VLOG_IF(level, cond)                      \
+  ([](int, bool) {                                    \
+    return ::proxygen::logging::detail::NoopStream{}; \
+  }((level), static_cast<bool>(cond)))
+#define PRX_VLOG_IS_ON(level) ([](int) { return false; }((level)))
+#define PRX_DLOG(level) PRX_LOG(level)
+#define PRX_DVLOG(level) PRX_VLOG(level)
+#define PRX_LOG(level) \
+  ((void)PRX_LOGLEVEL_##level, ::proxygen::logging::detail::NoopStream{})
+#define PRX_LOG_IF(level, cond)   \
+  ((void)PRX_LOGLEVEL_##level,    \
+   (void)static_cast<bool>(cond), \
+   ::proxygen::logging::detail::NoopStream{})
+#define PRX_LOG_EVERY_MS(level, ms) \
+  ((void)PRX_LOGLEVEL_##level,      \
+   (void)(ms),                      \
+   ::proxygen::logging::detail::NoopStream{})
+#define PRX_LOG_EVERY_N(level, n) \
+  ((void)PRX_LOGLEVEL_##level,    \
+   (void)(n),                     \
+   ::proxygen::logging::detail::NoopStream{})
+#define PRX_CHECK(expr)                               \
+  ([&] {                                              \
+    if (!(expr)) {                                    \
+      std::abort();                                   \
+    }                                                 \
+    return ::proxygen::logging::detail::NoopStream{}; \
+  }())
+#define PRX_CHECK_EQ(a, b) PRX_CHECK_BINOP_(a, ==, b)
+#define PRX_CHECK_NE(a, b) PRX_CHECK_BINOP_(a, !=, b)
+#define PRX_CHECK_GE(a, b) PRX_CHECK_BINOP_(a, >=, b)
+#define PRX_CHECK_GT(a, b) PRX_CHECK_BINOP_(a, >, b)
+#define PRX_CHECK_LE(a, b) PRX_CHECK_BINOP_(a, <=, b)
+#define PRX_CHECK_LT(a, b) PRX_CHECK_BINOP_(a, <, b)
+#define PRX_CHECK_NOTNULL(p)                       \
+  ([](auto&& _prx_p) -> decltype(auto) {           \
+    if (_prx_p == nullptr) {                       \
+      std::abort();                                \
+    }                                              \
+    return std::forward<decltype(_prx_p)>(_prx_p); \
+  }(p))
+// PCHECK loses the strerror(errno) suffix glog provides; see TODO above.
+#define PRX_PCHECK PRX_CHECK
+#define PRX_DCHECK(expr)                              \
+  ([&] {                                              \
+    assert((expr));                                   \
+    return ::proxygen::logging::detail::NoopStream{}; \
+  }())
+#define PRX_DCHECK_EQ(a, b) PRX_DCHECK_BINOP_(a, ==, b)
+#define PRX_DCHECK_NE(a, b) PRX_DCHECK_BINOP_(a, !=, b)
+#define PRX_DCHECK_GE(a, b) PRX_DCHECK_BINOP_(a, >=, b)
+#define PRX_DCHECK_GT(a, b) PRX_DCHECK_BINOP_(a, >, b)
+#define PRX_DCHECK_LE(a, b) PRX_DCHECK_BINOP_(a, <=, b)
+#define PRX_DCHECK_LT(a, b) PRX_DCHECK_BINOP_(a, <, b)
+
+#endif
diff --git a/proxygen/lib/utils/Logging.cpp b/proxygen/lib/utils/Logging.cpp
index b9376246e2..7accda311c 100644
--- a/proxygen/lib/utils/Logging.cpp
+++ b/proxygen/lib/utils/Logging.cpp
@@ -15,6 +15,7 @@
 #include <fstream>
 #include <memory>
 #include <ostream>
+#include <proxygen/lib/utils/LogShim.h>
 #include <sstream>
 #include <sys/stat.h>
 #include <vector>
@@ -98,7 +99,7 @@ string IOBufPrinter::printChain(const IOBuf* buf,
                                 bool coalesce) {
   auto index = (uint8_t)format;
   if (printers.size() <= index) {
-    LOG(ERROR) << "invalid format: " << index;
+    PRX_LOG(ERROR) << "invalid format: " << index;
     return "";
   }
   auto printer = printers[index];
@@ -131,7 +132,7 @@ void dumpBinToFile(const string& filename, const IOBuf* buf) {
   }
   std::ofstream file(filename, std::ofstream::binary);
   if (!file.is_open()) {
-    LOG(ERROR) << "cannot open file " << filename;
+    PRX_LOG(ERROR) << "cannot open file " << filename;
     return;
   }
   if (!buf) {
@@ -144,7 +145,7 @@ void dumpBinToFile(const string& filename, const IOBuf* buf) {
     buf = buf->next();
   } while (buf != first);
   file.close();
-  LOG(INFO) << "wrote chain " << IOBufPrinter::printChainInfo(buf) << " to "
-            << filename;
+  PRX_LOG(INFO) << "wrote chain " << IOBufPrinter::printChainInfo(buf) << " to "
+                << filename;
 }
 } // namespace proxygen
diff --git a/proxygen/lib/utils/ParseURL.cpp b/proxygen/lib/utils/ParseURL.cpp
index f3d25311f5..8bd509387e 100644
--- a/proxygen/lib/utils/ParseURL.cpp
+++ b/proxygen/lib/utils/ParseURL.cpp
@@ -15,6 +15,7 @@
 #include <proxygen/lib/utils/UtilInl.h>
 
 #include <proxygen/external/http_parser/http_parser.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace {
 
@@ -90,7 +91,7 @@ std::optional<std::string> ParseURL::getRedirectDestination(
     std::string_view headerHost) noexcept {
   auto newUrl = ParseURL::parseURL(location);
   if (!newUrl) {
-    DLOG(INFO) << "Unparsable location header=" << location;
+    PRX_DLOG(INFO) << "Unparsable location header=" << location;
     return std::nullopt;
   }
   if (!newUrl->hasHost()) {
@@ -100,9 +101,9 @@ std::optional<std::string> ParseURL::getRedirectDestination(
       // Old URL was relative, try host header
       oldURL = ParseURL::parseURL(headerHost);
       if (!oldURL || !oldURL->hasHost()) {
-        VLOG(2) << "Cannot determine destination for relative redirect "
-                << "location=" << location << " orig url=" << url
-                << " host=" << headerHost;
+        PRX_VLOG(2) << "Cannot determine destination for relative redirect "
+                    << "location=" << location << " orig url=" << url
+                    << " host=" << headerHost;
         return std::nullopt;
       }
     } // else oldURL was absolute and has a host
diff --git a/proxygen/lib/utils/ParseURL.h b/proxygen/lib/utils/ParseURL.h
index bebca080f3..238ace11e9 100644
--- a/proxygen/lib/utils/ParseURL.h
+++ b/proxygen/lib/utils/ParseURL.h
@@ -13,8 +13,8 @@
 #include <string>
 #include <string_view>
 
-#include <glog/logging.h>
 #include <proxygen/lib/utils/Export.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -88,7 +88,7 @@ class ParseURL {
   ParseURL() = default;
 
   void init(std::string_view urlVal, bool strict = false) {
-    CHECK(!initialized_);
+    PRX_CHECK(!initialized_);
     url_ = urlVal;
     parse(strict);
     initialized_ = true;
diff --git a/proxygen/lib/utils/PerfectIndexMap.h b/proxygen/lib/utils/PerfectIndexMap.h
index f3bd7a87de..3f0f3e167e 100644
--- a/proxygen/lib/utils/PerfectIndexMap.h
+++ b/proxygen/lib/utils/PerfectIndexMap.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/FBVector.h>
 #include <folly/Optional.h>
@@ -67,7 +67,7 @@ class PerfectIndexMap {
 
   [[nodiscard]] folly::Optional<std::string> getSingleOtherKeyOrNone(
       const std::string &keyStr) const {
-    CHECK(PerfectHashStrToKey(keyStr) == OtherKey);
+    PRX_CHECK(PerfectHashStrToKey(keyStr) == OtherKey);
     const std::string *result = getSingleOtherKey(keyStr);
     return (result == nullptr ? folly::none
                               : folly::Optional<std::string>(*result));
@@ -76,7 +76,7 @@ class PerfectIndexMap {
   bool update(Key key,
               const std::string &checkValue,
               const std::string &newValue) {
-    CHECK(key != OtherKey && key != NoneKey);
+    PRX_CHECK(key != OtherKey && key != NoneKey);
     std::string *getResult = getSingleKeyForUpdate(key);
     if (getResult != nullptr && stringsEqual(*getResult, checkValue)) {
       *getResult = newValue;
@@ -86,7 +86,7 @@ class PerfectIndexMap {
   }
 
   folly::Optional<std::string> getSingleOrNone(Key key) const {
-    CHECK(key != OtherKey && key != NoneKey);
+    PRX_CHECK(key != OtherKey && key != NoneKey);
     const std::string *result = getSingleKey(key);
     return (result == nullptr ? folly::none
                               : folly::Optional<std::string>(*result));
@@ -95,7 +95,7 @@ class PerfectIndexMap {
   // Adders into the underlying map.
 
   void add(const std::string &keyStr, const std::string &value) {
-    CHECK(AllowDuplicates);
+    PRX_CHECK(AllowDuplicates);
     auto key = PerfectHashStrToKey(keyStr);
     if (key == OtherKey) {
       addOtherKeyToIndex(keyStr, value);
@@ -105,7 +105,7 @@ class PerfectIndexMap {
   }
 
   void add(Key key, const std::string &value) {
-    CHECK(AllowDuplicates && key != OtherKey && key != NoneKey);
+    PRX_CHECK(AllowDuplicates && key != OtherKey && key != NoneKey);
     addKeyToIndex(key, value);
   }
 
@@ -123,7 +123,7 @@ class PerfectIndexMap {
   }
 
   void set(Key key, const std::string &value) {
-    CHECK(key != OtherKey && key != NoneKey);
+    PRX_CHECK(key != OtherKey && key != NoneKey);
     setKey(key, value);
   }
 
@@ -140,7 +140,7 @@ class PerfectIndexMap {
     }
   }
   bool remove(Key key) {
-    CHECK(key != OtherKey && key != NoneKey);
+    PRX_CHECK(key != OtherKey && key != NoneKey);
     return removeKey(key);
   }
 
@@ -335,7 +335,7 @@ class PerfectIndexMap {
 
   // Utility methods for removing from our index.
   void removeAtIndex(std::ptrdiff_t index) {
-    CHECK(keys_[index] != NoneKey);
+    PRX_CHECK(keys_[index] != NoneKey);
     if (keys_[index] == OtherKey) {
       --otherKeyCount_;
     }
diff --git a/proxygen/lib/utils/StateMachine.h b/proxygen/lib/utils/StateMachine.h
index b757a66642..9fb0f9b3e9 100644
--- a/proxygen/lib/utils/StateMachine.h
+++ b/proxygen/lib/utils/StateMachine.h
@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <glog/logging.h>
 #include <limits>
+#include <proxygen/lib/utils/LogShim.h>
 #include <tuple>
 
 namespace proxygen {
@@ -30,13 +30,13 @@ class StateMachine {
 
     std::tie(newState, ok) = T::find(state, event);
     if (!ok) {
-      LOG_EVERY_N(ERROR, 100)
+      PRX_LOG_EVERY_N(ERROR, 100)
           << T::getName() << ": invalid transition tried: " << state << " "
           << event;
       return false;
     } else {
-      VLOG(6) << T::getName() << ": transitioning from " << state << " to "
-              << newState;
+      PRX_VLOG(6) << T::getName() << ": transitioning from " << state << " to "
+                  << newState;
       state = newState;
       return true;
     }
@@ -75,8 +75,8 @@ class TransitionTable {
       size_t nEvents,
       std::vector<std::pair<std::pair<State, Event>, State>> transitions)
       : nStates_(nStates), nEvents_(nEvents) {
-    CHECK_LT(static_cast<uint64_t>(nStates),
-             std::numeric_limits<uint8_t>::max());
+    PRX_CHECK_LT(static_cast<uint64_t>(nStates),
+                 std::numeric_limits<uint8_t>::max());
     // Set all transitions to invalid
     transitions_.resize(nStates * nEvents, std::numeric_limits<uint8_t>::max());
 
@@ -98,8 +98,8 @@ class TransitionTable {
   }
 
   std::pair<State, bool> find(State s, Event e) const {
-    CHECK_LT(static_cast<uint64_t>(s), nStates_);
-    CHECK_LT(static_cast<uint64_t>(e), nEvents_);
+    PRX_CHECK_LT(static_cast<uint64_t>(s), nStates_);
+    PRX_CHECK_LT(static_cast<uint64_t>(e), nEvents_);
     uint8_t result = transitions_[index(s, e)];
     if (result == std::numeric_limits<uint8_t>::max()) {
       return std::make_pair(s, false);
diff --git a/proxygen/lib/utils/TraceEvent.h b/proxygen/lib/utils/TraceEvent.h
index 0079e0306b..2b8c8447a1 100644
--- a/proxygen/lib/utils/TraceEvent.h
+++ b/proxygen/lib/utils/TraceEvent.h
@@ -14,7 +14,7 @@
 #include <proxygen/lib/utils/TraceEventType.h>
 #include <proxygen/lib/utils/TraceFieldType.h>
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 #include <folly/Conv.h>
 #include <folly/lang/Exception.h>
@@ -193,7 +193,7 @@ class TraceEvent {
   template <typename T>
   T getTraceFieldDataAs(TraceFieldType field) const {
     const auto itr = metaData_.find(field);
-    CHECK(itr != metaData_.end());
+    PRX_CHECK(itr != metaData_.end());
     return itr->second.getValueAs<T>();
   }
 
diff --git a/proxygen/lib/utils/WeakRefCountedPtr.h b/proxygen/lib/utils/WeakRefCountedPtr.h
index 4cfa977dd8..a117e3b2d8 100644
--- a/proxygen/lib/utils/WeakRefCountedPtr.h
+++ b/proxygen/lib/utils/WeakRefCountedPtr.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -218,14 +218,15 @@ class WeakRefCountedPtr {
    *   - Increments reference count.
    */
   void initPtr(WeakRefCountedPtrState<T1>* state) {
-    CHECK(!state_);
+    PRX_CHECK(!state_);
     state_ = state;
     if (state_) {
       state_->count++;
       if (state_->ptr) {
         state_->ptr->onWeakRefCountedPtrCreate();
       }
-      CHECK_GE(state_->count, 1); // sanity if state_->count is ever unsigned
+      PRX_CHECK_GE(state_->count,
+                   1u); // sanity if state_->count is ever unsigned
     }
   }
 
@@ -239,7 +240,7 @@ class WeakRefCountedPtr {
     if (!state_) {
       return;
     }
-    CHECK_GE(state_->count, 1);
+    PRX_CHECK_GE(state_->count, 1u);
     state_->count--;
     if (state_->ptr) {
       state_->ptr->onWeakRefCountedPtrDestroy();
diff --git a/proxygen/lib/utils/WheelTimerInstance.cpp b/proxygen/lib/utils/WheelTimerInstance.cpp
index b998dcb684..56cb05389a 100644
--- a/proxygen/lib/utils/WheelTimerInstance.cpp
+++ b/proxygen/lib/utils/WheelTimerInstance.cpp
@@ -11,6 +11,7 @@
 #include <folly/Singleton.h>
 #include <folly/io/async/EventBase.h>
 #include <folly/io/async/EventBaseManager.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -58,13 +59,13 @@ void WheelTimerInstance::scheduleTimeout(
   if (wheelTimerPtr_) {
     wheelTimerPtr_->scheduleTimeout(callback, timeout);
   } else {
-    VLOG(2) << "Ingoring scheduleTimeout on an empty WheelTimerInstance";
+    PRX_VLOG(2) << "Ingoring scheduleTimeout on an empty WheelTimerInstance";
   }
 }
 
 void WheelTimerInstance::scheduleTimeout(
     folly::HHWheelTimer::Callback* callback) {
-  CHECK_GE(defaultTimeoutMS_.count(), 0);
+  PRX_CHECK_GE(defaultTimeoutMS_.count(), 0);
   scheduleTimeout(callback, defaultTimeoutMS_);
 }
 
diff --git a/proxygen/lib/utils/ZlibStreamCompressor.cpp b/proxygen/lib/utils/ZlibStreamCompressor.cpp
index 37fa80f214..1d2ceb04f6 100644
--- a/proxygen/lib/utils/ZlibStreamCompressor.cpp
+++ b/proxygen/lib/utils/ZlibStreamCompressor.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/utils/ZlibStreamCompressor.h>
 
 #include <folly/io/Cursor.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 
@@ -24,7 +25,7 @@ namespace proxygen {
 namespace {
 
 std::unique_ptr<IOBuf> addOutputBuffer(z_stream* stream, uint32_t length) {
-  CHECK_EQ(stream->avail_out, 0);
+  PRX_CHECK_EQ(stream->avail_out, 0u);
 
   auto buf = IOBuf::create(length);
   buf->append(buf->capacity());
@@ -62,8 +63,8 @@ void ZlibStreamCompressor::init() {
   zlibStream_.avail_out = 0;
   zlibStream_.next_out = Z_NULL;
 
-  DCHECK(level_ == Z_DEFAULT_COMPRESSION ||
-         (level_ >= Z_NO_COMPRESSION && level_ <= Z_BEST_COMPRESSION))
+  PRX_DCHECK(level_ == Z_DEFAULT_COMPRESSION ||
+             (level_ >= Z_NO_COMPRESSION && level_ <= Z_BEST_COMPRESSION))
       << "Invalid Zlib compression level. level=" << level_;
 
   switch (type_) {
@@ -81,12 +82,12 @@ void ZlibStreamCompressor::init() {
       status_ = deflateInit(&zlibStream_, level_);
       break;
     default:
-      DCHECK(false) << "Unsupported zlib compression type.";
+      PRX_DCHECK(false) << "Unsupported zlib compression type.";
       break;
   }
 
   if (status_ != Z_OK) {
-    LOG(ERROR) << "error initializing zlib stream. r=" << status_;
+    PRX_LOG(ERROR) << "error initializing zlib stream. r=" << status_;
   }
 }
 
@@ -123,7 +124,7 @@ std::unique_ptr<IOBuf> ZlibStreamCompressor::compress(const IOBuf* in,
       while (zlibStream_.avail_in != 0) {
         status_ = deflateHelper(&zlibStream_, out.get(), Z_NO_FLUSH);
         if (status_ != Z_OK) {
-          LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
+          PRX_LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
           return nullptr;
         }
       }
@@ -136,7 +137,7 @@ std::unique_ptr<IOBuf> ZlibStreamCompressor::compress(const IOBuf* in,
     } while (status_ == Z_OK);
 
     if (status_ != Z_STREAM_END) {
-      LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
+      PRX_LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
       return nullptr;
     }
   } else {
@@ -145,7 +146,7 @@ std::unique_ptr<IOBuf> ZlibStreamCompressor::compress(const IOBuf* in,
     } while (zlibStream_.avail_out == 0);
 
     if (status_ != Z_OK) {
-      LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
+      PRX_LOG(DFATAL) << "Deflate failed: " << zlibStream_.msg;
       return nullptr;
     }
   }
diff --git a/proxygen/lib/utils/ZlibStreamDecompressor.cpp b/proxygen/lib/utils/ZlibStreamDecompressor.cpp
index f251b7a17f..77c1a459c1 100644
--- a/proxygen/lib/utils/ZlibStreamDecompressor.cpp
+++ b/proxygen/lib/utils/ZlibStreamDecompressor.cpp
@@ -10,13 +10,14 @@
 
 #include <folly/io/Cursor.h>
 #include <limits>
+#include <proxygen/lib/utils/LogShim.h>
 
 using folly::IOBuf;
 
 namespace proxygen {
 
 void ZlibStreamDecompressor::init(CompressionType type) {
-  DCHECK(type_ == CompressionType::NONE) << "Must be uninitialized";
+  PRX_DCHECK(type_ == CompressionType::NONE) << "Must be uninitialized";
   type_ = type;
   status_ = Z_OK;
   zlibStream_.zalloc = Z_NULL;
@@ -28,7 +29,7 @@ void ZlibStreamDecompressor::init(CompressionType type) {
   zlibStream_.avail_out = 0;
   zlibStream_.next_out = Z_NULL;
 
-  DCHECK(type == CompressionType::DEFLATE || type == CompressionType::GZIP);
+  PRX_DCHECK(type == CompressionType::DEFLATE || type == CompressionType::GZIP);
   auto windowBits =
       type_ == CompressionType::GZIP ? GZIP_WINDOW_BITS : DEFLATE_WINDOW_BITS;
   status_ = inflateInit2(&zlibStream_, windowBits);
@@ -61,7 +62,7 @@ std::unique_ptr<IOBuf> ZlibStreamDecompressor::decompress(const IOBuf* in) {
   size_t offset = 0;
   while (true) {
     // Advance to the next IOBuf if necessary
-    DCHECK_GE(crtBuf->length(), offset);
+    PRX_DCHECK_GE(crtBuf->length(), offset);
     if (crtBuf->length() == offset) {
       crtBuf = crtBuf->next();
       offset = 0;
@@ -75,14 +76,14 @@ std::unique_ptr<IOBuf> ZlibStreamDecompressor::decompress(const IOBuf* in) {
       // we convert this into a stream error
       status_ = Z_STREAM_ERROR;
       // we should probably bump up a counter here
-      LOG(ERROR) << "error uncompressing buffer: reached end of zlib data "
-                    "before the end of the buffer";
+      PRX_LOG(ERROR) << "error uncompressing buffer: reached end of zlib data "
+                        "before the end of the buffer";
       return nullptr;
     }
 
     // Ensure there is space in the output IOBuf
     appender.ensure(decompressor_buffer_minsize_);
-    DCHECK_GT(appender.length(), 0);
+    PRX_DCHECK_GT(appender.length(), 0u);
 
     const size_t origAvailIn = crtBuf->length() - offset;
     zlibStream_.next_in = const_cast<uint8_t*>(crtBuf->data() + offset);
@@ -91,7 +92,7 @@ std::unique_ptr<IOBuf> ZlibStreamDecompressor::decompress(const IOBuf* in) {
     zlibStream_.avail_out = appender.length();
     status_ = inflate(&zlibStream_, Z_PARTIAL_FLUSH);
     if (status_ != Z_OK && status_ != Z_STREAM_END) {
-      LOG(INFO) << "error uncompressing buffer: r=" << status_;
+      PRX_LOG(INFO) << "error uncompressing buffer: r=" << status_;
       return nullptr;
     }
 
diff --git a/proxygen/lib/utils/ZstdStreamCompressor.cpp b/proxygen/lib/utils/ZstdStreamCompressor.cpp
index c3b6dd1763..853f0b7f1a 100644
--- a/proxygen/lib/utils/ZstdStreamCompressor.cpp
+++ b/proxygen/lib/utils/ZstdStreamCompressor.cpp
@@ -9,6 +9,7 @@
 #include <proxygen/lib/utils/ZstdStreamCompressor.h>
 
 #include <folly/compression/Compression.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -66,8 +67,8 @@ std::unique_ptr<folly::IOBuf> ZstdStreamCompressor::compress(
       return {};
     }
 
-    DCHECK_EQ(inrange.size(), 0);
-    DCHECK_GT(outrange.size(), 0);
+    PRX_DCHECK_EQ(inrange.size(), 0u);
+    PRX_DCHECK_GT(outrange.size(), 0u);
 
     out->append(outrange.begin() - out->tail());
 
diff --git a/proxygen/lib/utils/ZstdStreamDecompressor.cpp b/proxygen/lib/utils/ZstdStreamDecompressor.cpp
index 344756d28f..0d9e470d50 100644
--- a/proxygen/lib/utils/ZstdStreamDecompressor.cpp
+++ b/proxygen/lib/utils/ZstdStreamDecompressor.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 namespace proxygen {
 
@@ -51,7 +52,7 @@ std::unique_ptr<folly::IOBuf> ZstdStreamDecompressor::decompress(
     while (ibuf.pos < ibuf.size) {
       status_ = ZstdStatusType::CONTINUE;
       appender.ensure(outBufAllocSize);
-      DCHECK_GT(appender.length(), 0);
+      PRX_DCHECK_GT(appender.length(), 0u);
 
       auto prevIbufPos = ibuf.pos;
       ZSTD_outBuffer obuf = {appender.writableData(), appender.length(), 0};
diff --git a/proxygen/lib/utils/proxygen-config.h.in b/proxygen/lib/utils/proxygen-config.h.in
new file mode 100644
index 0000000000..03be57dca1
--- /dev/null
+++ b/proxygen/lib/utils/proxygen-config.h.in
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <proxygen/proxygen-config.h> holds compile time configuration options for
+ * Proxygen.
+ */
+#pragma once
+
+// Logging backend. PROXYGEN_LOGGING_BACKEND is one of GLOG, XLOG, DISABLED.
+#define PRX_LOGGING_@PROXYGEN_LOGGING_BACKEND@ 1
diff --git a/proxygen/lib/utils/test/GenericFilterTest.cpp b/proxygen/lib/utils/test/GenericFilterTest.cpp
index a29fafabdb..c2a036bf34 100644
--- a/proxygen/lib/utils/test/GenericFilterTest.cpp
+++ b/proxygen/lib/utils/test/GenericFilterTest.cpp
@@ -11,6 +11,7 @@
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
 #include <proxygen/lib/utils/FilterChain.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <stdlib.h>
 
 using namespace proxygen;
@@ -146,7 +147,7 @@ class GenericFilterTest : public testing::Test {
                                           &TesterInterface::setCallback,
                                           Owned>>(getTester<Owned>());
     chain().setCallback(&callback_);
-    actor_ = CHECK_NOTNULL(static_cast<MockTester*>(chain_->call()));
+    actor_ = PRX_CHECK_NOTNULL(static_cast<MockTester*>(chain_->call()));
   }
   FilterChain<TesterInterface,
               TesterInterface::Callback,
@@ -213,7 +214,7 @@ void GenericFilterTest<Owned>::basicTest() {
 
   // Now poke the callback side
   EXPECT_CALL(callback_, onA());
-  CHECK_NOTNULL(actor_->cb_);
+  PRX_CHECK_NOTNULL(actor_->cb_);
   actor_->cb_->onA();
 }
 
@@ -231,7 +232,7 @@ void GenericFilterTest<Owned>::testFilters(
   // Callback
   if (expectedCb) {
     EXPECT_CALL(*expectedCb, onA());
-    CHECK_NOTNULL(actor_->cb_);
+    PRX_CHECK_NOTNULL(actor_->cb_);
     actor_->cb_->onA();
   }
   for (auto f : filters) {
@@ -412,7 +413,7 @@ TEST_F(OwnedGenericFilterTest, SetNullCb) {
   // nullptr. So in this case, we need to make sure it propagates
   auto filters = getRandomFilters(100);
   chain().setCallback(nullptr);
-  CHECK(nullptr == actor_->cb_);
+  PRX_CHECK(nullptr == actor_->cb_);
 
   testFilters(filters, nullptr);
 
@@ -436,7 +437,8 @@ TEST_F(OwnedGenericFilterTest, SetNullCb) {
 class TestFilterOddDeleteDo : public TestFilter<false> {
  public:
   explicit TestFilterOddDeleteDo(int* deletions)
-      : TestFilter<false>(true, true), deletions_(CHECK_NOTNULL(deletions)) {
+      : TestFilter<false>(true, true),
+        deletions_(PRX_CHECK_NOTNULL(deletions)) {
   }
   ~TestFilterOddDeleteDo() override {
     ++*deletions_;
@@ -478,7 +480,7 @@ template <bool Owned = false>
 class TestFilterOddDeleteOn : public TestFilter<Owned> {
  public:
   explicit TestFilterOddDeleteOn(int* deletions)
-      : deletions_(CHECK_NOTNULL(deletions)) {
+      : deletions_(PRX_CHECK_NOTNULL(deletions)) {
   }
   ~TestFilterOddDeleteOn() override {
     ++*deletions_;
diff --git a/proxygen/lib/utils/test/MockTime.h b/proxygen/lib/utils/test/MockTime.h
index 283cc84d8f..88934a9158 100644
--- a/proxygen/lib/utils/test/MockTime.h
+++ b/proxygen/lib/utils/test/MockTime.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/Time.h>
 
 namespace proxygen {
@@ -21,7 +21,7 @@ class MockTimeUtilGeneric : public TimeUtilGeneric<ClockType> {
   }
 
   void setCurrentTime(std::chrono::time_point<ClockType> t) {
-    CHECK(t.time_since_epoch() > t_.time_since_epoch())
+    PRX_CHECK(t.time_since_epoch() > t_.time_since_epoch())
         << "Time can not move backwards";
     t_ = t;
   }
diff --git a/proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp b/proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp
index c0703f7729..118c5515a6 100644
--- a/proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp
+++ b/proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp
@@ -10,6 +10,7 @@
 #include <folly/Benchmark.h>
 #include <folly/container/F14Map.h>
 #include <proxygen/lib/http/HTTPCommonHeaders.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/PerfectIndexMap.h>
 #include <unordered_map>
 
@@ -118,7 +119,7 @@ void F14GetBench(folly::F14FastMap<std::string, std::string>& testMap,
       folly::Optional<std::string> result =
           (it == testMap.end() ? folly::none
                                : (folly::Optional<std::string>)it->second);
-      CHECK(result != folly::none);
+      PRX_CHECK(result != folly::none);
     }
   }
 }
@@ -156,7 +157,7 @@ void UnorderedMapGetBench(std::unordered_map<std::string, std::string>& testMap,
       folly::Optional<std::string> result =
           (it == testMap.end() ? folly::none
                                : (folly::Optional<std::string>)it->second);
-      CHECK(result != folly::none);
+      PRX_CHECK(result != folly::none);
     }
   }
 }
@@ -166,7 +167,7 @@ void PerfectIndexMapGetCodeBench(DefaultPerfectIndexMap& map,
                                  int iters) {
   for (int i = 0; i < iters; ++i) {
     for (auto const& key : keys) {
-      CHECK(map.getSingleOrNone(key) != folly::none);
+      PRX_CHECK(map.getSingleOrNone(key) != folly::none);
     }
   }
 }
@@ -176,7 +177,7 @@ void PerfectIndexMapGetStringBench(DefaultPerfectIndexMap& map,
                                    int iters) {
   for (int i = 0; i < iters; ++i) {
     for (auto const& key : keys) {
-      CHECK(map.getSingleOrNone(*key) != folly::none);
+      PRX_CHECK(map.getSingleOrNone(*key) != folly::none);
     }
   }
 }
diff --git a/proxygen/lib/utils/test/WeakRefCountedPtrTest.cpp b/proxygen/lib/utils/test/WeakRefCountedPtrTest.cpp
index ecd28579e8..96bc7ac6ef 100644
--- a/proxygen/lib/utils/test/WeakRefCountedPtrTest.cpp
+++ b/proxygen/lib/utils/test/WeakRefCountedPtrTest.cpp
@@ -10,6 +10,7 @@
 
 #include <folly/portability/GMock.h>
 #include <folly/portability/GTest.h>
+#include <proxygen/lib/utils/LogShim.h>
 
 using namespace testing;
 
@@ -77,7 +78,7 @@ TEST(WeakRefCountedPtrTest, DestroyTargetDerived) {
   EXPECT_CALL(*target, onWeakRefCountedPtrCreate());
   auto kaPtr = target->getWeakRefCountedPtr<TestDerivedClass>();
   EXPECT_TRUE(kaPtr);
-  CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
+  PRX_CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
   EXPECT_EQ(target.get(), kaPtr.get());
   target = nullptr;
   EXPECT_FALSE(kaPtr);
@@ -90,7 +91,7 @@ TEST(WeakRefCountedPtrTest, DestroyPtrDerived) {
     EXPECT_CALL(*target, onWeakRefCountedPtrCreate());
     auto kaPtr = target->getWeakRefCountedPtr<TestDerivedClass>();
     EXPECT_TRUE(kaPtr);
-    CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
+    PRX_CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
     kaPtr->onlyDerivedFunc();
     EXPECT_EQ(1, target->numWeakRefCountedPtrs());
     EXPECT_EQ(target.get(), kaPtr.get());
@@ -102,7 +103,7 @@ TEST(WeakRefCountedPtrTest, DestroyPtrDerived) {
     EXPECT_CALL(*target, onWeakRefCountedPtrCreate());
     auto kaPtr = target->getWeakRefCountedPtr<TestDerivedClass>();
     EXPECT_TRUE(kaPtr);
-    CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
+    PRX_CHECK_NOTNULL(kaPtr.get())->onlyDerivedFunc();
     kaPtr->onlyDerivedFunc();
     EXPECT_EQ(1, target->numWeakRefCountedPtrs());
     EXPECT_EQ(target.get(), kaPtr.get());
diff --git a/proxygen/lib/utils/test/ZlibTests.cpp b/proxygen/lib/utils/test/ZlibTests.cpp
index 3b164cb309..2996699a3e 100644
--- a/proxygen/lib/utils/test/ZlibTests.cpp
+++ b/proxygen/lib/utils/test/ZlibTests.cpp
@@ -13,7 +13,7 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/ZlibStreamCompressor.h>
 #include <proxygen/lib/utils/ZlibStreamDecompressor.h>
 
diff --git a/proxygen/lib/utils/test/ZstdTests.cpp b/proxygen/lib/utils/test/ZstdTests.cpp
index b06b80f762..1fa3554f06 100644
--- a/proxygen/lib/utils/test/ZstdTests.cpp
+++ b/proxygen/lib/utils/test/ZstdTests.cpp
@@ -12,7 +12,7 @@
 #include <folly/io/Cursor.h>
 #include <folly/io/IOBuf.h>
 #include <folly/portability/GTest.h>
-#include <glog/logging.h>
+#include <proxygen/lib/utils/LogShim.h>
 #include <proxygen/lib/utils/ZstdStreamCompressor.h>
 #include <proxygen/lib/utils/ZstdStreamDecompressor.h>