diff --git a/quic/core/quic_crypto_client_stream.cc b/quic/core/quic_crypto_client_stream.cc
index dfa5b86..78d2f10 100644
--- a/quic/core/quic_crypto_client_stream.cc
+++ b/quic/core/quic_crypto_client_stream.cc
@@ -49,7 +49,7 @@
           proof_handler, has_application_state);
       break;
     case PROTOCOL_UNSUPPORTED:
-      QUIC_BUG_V2(quic_bug_10296_1)
+      QUIC_BUG(quic_bug_10296_1)
           << "Attempting to create QuicCryptoClientStream for unknown "
              "handshake protocol";
   }
diff --git a/quic/core/quic_crypto_server_stream_base.cc b/quic/core/quic_crypto_server_stream_base.cc
index 368f47b..708b175 100644
--- a/quic/core/quic_crypto_server_stream_base.cc
+++ b/quic/core/quic_crypto_server_stream_base.cc
@@ -42,7 +42,7 @@
     case PROTOCOL_UNSUPPORTED:
       break;
   }
-  QUIC_BUG_V2(quic_bug_10492_1)
+  QUIC_BUG(quic_bug_10492_1)
       << "Unknown handshake protocol: "
       << static_cast<int>(session->connection()->version().handshake_protocol);
   return nullptr;
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index 93e4ca4..f8f34df 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -71,8 +71,8 @@
 }
 
 void QuicCryptoStream::OnCryptoFrame(const QuicCryptoFrame& frame) {
-  QUIC_BUG_IF_V2(quic_bug_12573_1,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_1,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 shouldn't receive CRYPTO frames";
   EncryptionLevel level = session()->connection()->last_decrypted_level();
   substreams_[level].sequencer.OnCryptoFrame(frame);
@@ -86,7 +86,7 @@
 
 void QuicCryptoStream::OnStreamFrame(const QuicStreamFrame& frame) {
   if (QuicVersionUsesCryptoFrames(session()->transport_version())) {
-    QUIC_PEER_BUG_V2(quic_peer_bug_12573_2)
+    QUIC_PEER_BUG(quic_peer_bug_12573_2)
         << "Crypto data received in stream frame instead of crypto frame";
     OnUnrecoverableError(QUIC_INVALID_STREAM_DATA, "Unexpected stream frame");
   }
@@ -156,7 +156,7 @@
     return;
   }
   if (data.empty()) {
-    QUIC_BUG_V2(quic_bug_10322_1) << "Empty crypto data being written";
+    QUIC_BUG(quic_bug_10322_1) << "Empty crypto data being written";
     return;
   }
   const bool had_buffered_data = HasBufferedCryptoFrames();
@@ -167,7 +167,7 @@
   send_buffer->SaveStreamData(&iov, /*iov_count=*/1, /*iov_offset=*/0,
                               data.length());
   if (kMaxStreamLength - offset < data.length()) {
-    QUIC_BUG_V2(quic_bug_10322_2) << "Writing too much crypto handshake data";
+    QUIC_BUG(quic_bug_10322_2) << "Writing too much crypto handshake data";
     // TODO(nharper): Switch this to an IETF QUIC error code, possibly
     // INTERNAL_ERROR?
     OnUnrecoverableError(QUIC_STREAM_LENGTH_OVERFLOW,
@@ -232,7 +232,7 @@
 
 void QuicCryptoStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
   if (QuicVersionUsesCryptoFrames(session()->transport_version())) {
-    QUIC_BUG_V2(quic_bug_10322_3)
+    QUIC_BUG(quic_bug_10322_3)
         << "Stream data consumed when CRYPTO frames should be in use";
   }
   if (bytes_consumed > 0) {
@@ -265,8 +265,8 @@
 }
 
 void QuicCryptoStream::WritePendingCryptoRetransmission() {
-  QUIC_BUG_IF_V2(quic_bug_12573_3,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_3,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames";
   for (EncryptionLevel level : AllEncryptionLevels()) {
     QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
@@ -384,16 +384,16 @@
                                         QuicStreamOffset offset,
                                         QuicByteCount data_length,
                                         QuicDataWriter* writer) {
-  QUIC_BUG_IF_V2(quic_bug_12573_4,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_4,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames (2)";
   return substreams_[level].send_buffer.WriteStreamData(offset, data_length,
                                                         writer);
 }
 
 void QuicCryptoStream::OnCryptoFrameLost(QuicCryptoFrame* crypto_frame) {
-  QUIC_BUG_IF_V2(quic_bug_12573_5,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_5,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't lose CRYPTO frames";
   substreams_[crypto_frame->level].send_buffer.OnStreamDataLost(
       crypto_frame->offset, crypto_frame->data_length);
@@ -401,8 +401,8 @@
 
 void QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
                                       TransmissionType type) {
-  QUIC_BUG_IF_V2(quic_bug_12573_6,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_6,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't retransmit CRYPTO frames";
   QuicIntervalSet<QuicStreamOffset> retransmission(
       crypto_frame->offset, crypto_frame->offset + crypto_frame->data_length);
@@ -427,8 +427,8 @@
 }
 
 void QuicCryptoStream::WriteBufferedCryptoFrames() {
-  QUIC_BUG_IF_V2(quic_bug_12573_7,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_7,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
   for (EncryptionLevel level : AllEncryptionLevels()) {
     QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
@@ -450,8 +450,8 @@
 }
 
 bool QuicCryptoStream::HasBufferedCryptoFrames() const {
-  QUIC_BUG_IF_V2(quic_bug_12573_8,
-                 !QuicVersionUsesCryptoFrames(session()->transport_version()))
+  QUIC_BUG_IF(quic_bug_12573_8,
+              !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
   for (EncryptionLevel level : AllEncryptionLevels()) {
     const QuicStreamSendBuffer& send_buffer = substreams_[level].send_buffer;
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index 578eea5..ee3c861 100644
--- a/quic/core/quic_data_writer.cc
+++ b/quic/core/quic_data_writer.cc
@@ -201,8 +201,8 @@
 
   const QuicVariableLengthIntegerLength min_length = GetVarInt62Len(value);
   if (write_length < min_length) {
-    QUIC_BUG_V2(quic_bug_10347_1) << "Cannot write value " << value
-                                  << " with write_length " << write_length;
+    QUIC_BUG(quic_bug_10347_1) << "Cannot write value " << value
+                               << " with write_length " << write_length;
     return false;
   }
   if (write_length == min_length) {
@@ -220,7 +220,7 @@
            WriteUInt32(value);
   }
 
-  QUIC_BUG_V2(quic_bug_10347_2)
+  QUIC_BUG(quic_bug_10347_2)
       << "Invalid write_length " << static_cast<int>(write_length);
   return false;
 }
@@ -228,8 +228,8 @@
 // static
 QuicVariableLengthIntegerLength QuicDataWriter::GetVarInt62Len(uint64_t value) {
   if ((value & kVarInt62ErrorMask) != 0) {
-    QUIC_BUG_V2(quic_bug_10347_3) << "Attempted to encode a value, " << value
-                                  << ", that is too big for VarInt62";
+    QUIC_BUG(quic_bug_10347_3) << "Attempted to encode a value, " << value
+                               << ", that is too big for VarInt62";
     return VARIABLE_LENGTH_INTEGER_LENGTH_0;
   }
   if ((value & kVarInt62Mask8Bytes) != 0) {
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index ab5a147..73d636a 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -176,7 +176,7 @@
                                      /*transport_close_frame_type=*/0);
 
     if (!creator_.AddFrame(QuicFrame(frame), NOT_RETRANSMISSION)) {
-      QUIC_BUG_V2(quic_bug_10287_1) << "Unable to add frame to an empty packet";
+      QUIC_BUG(quic_bug_10287_1) << "Unable to add frame to an empty packet";
       delete frame;
       return;
     }
@@ -265,7 +265,7 @@
   }
   if (legacy_version_encapsulation_inner_packet.length() >=
       packet_info.packet.length()) {
-    QUIC_BUG_V2(quic_bug_10287_2)
+    QUIC_BUG(quic_bug_10287_2)
         << "Inner packet cannot be larger than outer "
         << legacy_version_encapsulation_inner_packet.length() << " vs "
         << packet_info.packet.length();
@@ -328,7 +328,7 @@
   if (use_reference_counted_session_map_) {
     QUIC_RESTART_FLAG_COUNT(quic_use_reference_counted_sesssion_map);
   }
-  QUIC_BUG_IF_V2(quic_bug_12724_1, GetSupportedVersions().empty())
+  QUIC_BUG_IF(quic_bug_12724_1, GetSupportedVersions().empty())
       << "Trying to create dispatcher without any supported versions";
   QUIC_DLOG(INFO) << "Created QuicDispatcher with versions: "
                   << ParsedQuicVersionVectorToString(GetSupportedVersions());
@@ -917,7 +917,7 @@
     if (!write_blocked_list_.empty()) {
       for (const auto& session : closed_ref_counted_session_list_) {
         if (write_blocked_list_.erase(session->connection()) != 0) {
-          QUIC_BUG_V2(quic_bug_12724_2)
+          QUIC_BUG(quic_bug_12724_2)
               << "QuicConnection was in WriteBlockedList before destruction "
               << session->connection()->connection_id();
         }
@@ -928,7 +928,7 @@
     if (!write_blocked_list_.empty()) {
       for (const std::unique_ptr<QuicSession>& session : closed_session_list_) {
         if (write_blocked_list_.erase(session->connection()) != 0) {
-          QUIC_BUG_V2(quic_bug_12724_3)
+          QUIC_BUG(quic_bug_12724_3)
               << "QuicConnection was in WriteBlockedList before destruction "
               << session->connection()->connection_id();
         }
@@ -1004,11 +1004,11 @@
   if (use_reference_counted_session_map_) {
     auto it = reference_counted_session_map_.find(server_connection_id);
     if (it == reference_counted_session_map_.end()) {
-      QUIC_BUG_V2(quic_bug_10287_3)
+      QUIC_BUG(quic_bug_10287_3)
           << "ConnectionId " << server_connection_id
           << " does not exist in the session map.  Error: "
           << QuicErrorCodeToString(error);
-      QUIC_BUG_V2(quic_bug_10287_4) << QuicStackTrace();
+      QUIC_BUG(quic_bug_10287_4) << QuicStackTrace();
       return;
     }
 
@@ -1042,11 +1042,11 @@
   } else {
     auto it = session_map_.find(server_connection_id);
     if (it == session_map_.end()) {
-      QUIC_BUG_V2(quic_bug_10287_5)
+      QUIC_BUG(quic_bug_10287_5)
           << "ConnectionId " << server_connection_id
           << " does not exist in the session map.  Error: "
           << QuicErrorCodeToString(error);
-      QUIC_BUG_V2(quic_bug_10287_6) << QuicStackTrace();
+      QUIC_BUG(quic_bug_10287_6) << QuicStackTrace();
       return;
     }
 
@@ -1075,7 +1075,7 @@
   if (!blocked_writer->IsWriterBlocked()) {
     // It is a programming error if this ever happens. When we are sure it is
     // not happening, replace it with a QUICHE_DCHECK.
-    QUIC_BUG_V2(quic_bug_12724_4)
+    QUIC_BUG(quic_bug_12724_4)
         << "Tried to add writer into blocked list when it shouldn't be added";
     // Return without adding the connection to the blocked list, to avoid
     // infinite loops in OnCanWrite.
@@ -1096,7 +1096,7 @@
   QUICHE_DCHECK(support_multiple_cid_per_connection_);
   auto it = reference_counted_session_map_.find(server_connection_id);
   if (it == reference_counted_session_map_.end()) {
-    QUIC_BUG_V2(quic_bug_10287_7)
+    QUIC_BUG(quic_bug_10287_7)
         << "Couldn't locate the session that issues the connection ID in "
            "reference_counted_session_map_.  server_connection_id:"
         << server_connection_id << " new_connection_id: " << new_connection_id;
@@ -1230,7 +1230,7 @@
           std::make_pair(server_connection_id,
                          std::shared_ptr<QuicSession>(std::move(session))));
       if (!insertion_result.second) {
-        QUIC_BUG_V2(quic_bug_12724_5)
+        QUIC_BUG(quic_bug_12724_5)
             << "Tried to add a session to session_map with existing connection "
                "id: "
             << server_connection_id;
@@ -1241,7 +1241,7 @@
     } else {
       auto insertion_result = session_map_.insert(
           std::make_pair(server_connection_id, std::move(session)));
-      QUIC_BUG_IF_V2(quic_bug_12724_6, !insertion_result.second)
+      QUIC_BUG_IF(quic_bug_12724_6, !insertion_result.second)
           << "Tried to add a session to session_map with existing connection "
              "id: "
           << server_connection_id;
@@ -1306,9 +1306,8 @@
   if (GetQuicFlag(FLAGS_quic_allow_chlo_buffering) &&
       new_sessions_allowed_per_event_loop_ <= 0) {
     // Can't create new session any more. Wait till next event loop.
-    QUIC_BUG_IF_V2(quic_bug_12724_7,
-                   buffered_packets_.HasChloForConnection(
-                       packet_info->destination_connection_id));
+    QUIC_BUG_IF(quic_bug_12724_7, buffered_packets_.HasChloForConnection(
+                                      packet_info->destination_connection_id));
     EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
         packet_info->destination_connection_id,
         packet_info->form != GOOGLE_QUIC_PACKET, packet_info->packet,
@@ -1330,7 +1329,7 @@
       packet_info->destination_connection_id, packet_info->self_address,
       packet_info->peer_address, alpn, packet_info->version);
   if (QUIC_PREDICT_FALSE(session == nullptr)) {
-    QUIC_BUG_V2(quic_bug_10287_8)
+    QUIC_BUG(quic_bug_10287_8)
         << "CreateQuicSession returned nullptr for "
         << packet_info->destination_connection_id << " from "
         << packet_info->peer_address << " to " << packet_info->self_address
@@ -1351,7 +1350,7 @@
             packet_info->destination_connection_id,
             std::shared_ptr<QuicSession>(std::move(session.release()))));
     if (!insertion_result.second) {
-      QUIC_BUG_V2(quic_bug_10287_9)
+      QUIC_BUG(quic_bug_10287_9)
           << "Tried to add a session to session_map with existing "
              "connection id: "
           << packet_info->destination_connection_id;
@@ -1362,7 +1361,7 @@
   } else {
     auto insertion_result = session_map_.insert(std::make_pair(
         packet_info->destination_connection_id, std::move(session)));
-    QUIC_BUG_IF_V2(quic_bug_12724_8, !insertion_result.second)
+    QUIC_BUG_IF(quic_bug_12724_8, !insertion_result.second)
         << "Tried to add a session to session_map with existing connection id: "
         << packet_info->destination_connection_id;
     session_ptr = insertion_result.first->second.get();
diff --git a/quic/core/quic_flow_controller.cc b/quic/core/quic_flow_controller.cc
index 53202bf..88dc3ed 100644
--- a/quic/core/quic_flow_controller.cc
+++ b/quic/core/quic_flow_controller.cc
@@ -91,7 +91,7 @@
 
 void QuicFlowController::AddBytesSent(QuicByteCount bytes_sent) {
   if (bytes_sent_ + bytes_sent > send_window_offset_) {
-    QUIC_BUG_V2(quic_bug_10836_1)
+    QUIC_BUG(quic_bug_10836_1)
         << ENDPOINT << LogLabel() << " Trying to send an extra " << bytes_sent
         << " bytes, when bytes_sent = " << bytes_sent_
         << ", and send_window_offset_ = " << send_window_offset_;
@@ -299,7 +299,7 @@
   QUIC_DVLOG(1) << ENDPOINT << "UpdateReceiveWindowSize for " << LogLabel()
                 << ": " << size;
   if (receive_window_size_ != receive_window_offset_) {
-    QUIC_BUG_V2(quic_bug_10836_2)
+    QUIC_BUG(quic_bug_10836_2)
         << "receive_window_size_:" << receive_window_size_
         << " != receive_window_offset:" << receive_window_offset_;
     return;
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 25f8a55..36d1cca 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -166,7 +166,7 @@
     case PACKET_FLAGS_1BYTE_PACKET:
       return PACKET_1BYTE_PACKET_NUMBER;
     default:
-      QUIC_BUG_V2(quic_bug_10850_1) << "Unreachable case statement.";
+      QUIC_BUG(quic_bug_10850_1) << "Unreachable case statement.";
       return PACKET_6BYTE_PACKET_NUMBER;
   }
 }
@@ -183,7 +183,7 @@
     case PACKET_FLAGS_1BYTE_PACKET:
       return PACKET_1BYTE_PACKET_NUMBER;
     default:
-      QUIC_BUG_V2(quic_bug_10850_2) << "Unreachable case statement.";
+      QUIC_BUG(quic_bug_10850_2) << "Unreachable case statement.";
       return PACKET_6BYTE_PACKET_NUMBER;
   }
 }
@@ -211,7 +211,7 @@
     case VERSION_NEGOTIATION:
       return 0xF0;  // Value does not matter
     default:
-      QUIC_BUG_V2(quic_bug_10850_3) << "Invalid long header type: " << type;
+      QUIC_BUG(quic_bug_10850_3) << "Invalid long header type: " << type;
       return 0xFF;
   }
 }
@@ -232,7 +232,7 @@
       *long_header_type = RETRY;
       break;
     default:
-      QUIC_BUG_V2(quic_bug_10850_4) << "Unreachable statement";
+      QUIC_BUG(quic_bug_10850_4) << "Unreachable statement";
       *long_header_type = INVALID_PACKET_TYPE;
       return false;
   }
@@ -247,7 +247,7 @@
 PacketNumberSpace GetPacketNumberSpace(const QuicPacketHeader& header) {
   switch (header.form) {
     case GOOGLE_QUIC_PACKET:
-      QUIC_BUG_V2(quic_bug_10850_5)
+      QUIC_BUG(quic_bug_10850_5)
           << "Try to get packet number space of Google QUIC packet";
       break;
     case IETF_QUIC_SHORT_HEADER_PACKET:
@@ -263,7 +263,7 @@
         case VERSION_NEGOTIATION:
         case RETRY:
         case INVALID_PACKET_TYPE:
-          QUIC_BUG_V2(quic_bug_10850_6)
+          QUIC_BUG(quic_bug_10850_6)
               << "Try to get packet number space of long header type: "
               << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
           break;
@@ -276,7 +276,7 @@
 EncryptionLevel GetEncryptionLevel(const QuicPacketHeader& header) {
   switch (header.form) {
     case GOOGLE_QUIC_PACKET:
-      QUIC_BUG_V2(quic_bug_10850_7)
+      QUIC_BUG(quic_bug_10850_7)
           << "Cannot determine EncryptionLevel from Google QUIC header";
       break;
     case IETF_QUIC_SHORT_HEADER_PACKET:
@@ -292,7 +292,7 @@
         case VERSION_NEGOTIATION:
         case RETRY:
         case INVALID_PACKET_TYPE:
-          QUIC_BUG_V2(quic_bug_10850_8)
+          QUIC_BUG(quic_bug_10850_8)
               << "No encryption used with type "
               << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
       }
@@ -472,7 +472,7 @@
 size_t QuicFramer::GetMessageFrameSize(QuicTransportVersion version,
                                        bool last_frame_in_packet,
                                        QuicByteCount length) {
-  QUIC_BUG_IF_V2(quic_bug_12975_1, !VersionSupportsMessageFrames(version))
+  QUIC_BUG_IF(quic_bug_12975_1, !VersionSupportsMessageFrames(version))
       << "Try to serialize MESSAGE frame in " << version;
   return kQuicFrameTypeSize +
          (last_frame_in_packet ? 0 : QuicDataWriter::GetVarInt62Len(length)) +
@@ -592,7 +592,7 @@
 size_t QuicFramer::GetMaxStreamsFrameSize(QuicTransportVersion version,
                                           const QuicMaxStreamsFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
-    QUIC_BUG_V2(quic_bug_10850_9)
+    QUIC_BUG(quic_bug_10850_9)
         << "In version " << version
         << ", which does not support IETF Frames, and tried to serialize "
            "MaxStreams Frame.";
@@ -606,7 +606,7 @@
     QuicTransportVersion version,
     const QuicStreamsBlockedFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
-    QUIC_BUG_V2(quic_bug_10850_10)
+    QUIC_BUG(quic_bug_10850_10)
         << "In version " << version
         << ", which does not support IETF frames, and tried to serialize "
            "StreamsBlocked Frame.";
@@ -730,7 +730,7 @@
       return i;
     }
   }
-  QUIC_BUG_V2(quic_bug_10850_11) << "Failed to determine StreamIDSize.";
+  QUIC_BUG(quic_bug_10850_11) << "Failed to determine StreamIDSize.";
   return 4;
 }
 
@@ -748,7 +748,7 @@
       return i;
     }
   }
-  QUIC_BUG_V2(quic_bug_10850_12) << "Failed to determine StreamOffsetSize.";
+  QUIC_BUG(quic_bug_10850_12) << "Failed to determine StreamOffsetSize.";
   return 8;
 }
 
@@ -804,7 +804,7 @@
     QuicPacketNumberLength packet_number_length) {
   // Prevent a rare crash reported in b/19458523.
   if (frame.type == ACK_FRAME && frame.ack_frame == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_13)
+    QUIC_BUG(quic_bug_10850_13)
         << "Cannot compute the length of a null ack frame. free_bytes:"
         << free_bytes << " first_frame:" << first_frame
         << " last_frame:" << last_frame
@@ -871,7 +871,7 @@
       writer->length() - length_field_offset <
           kQuicDefaultLongHeaderLengthLength) {
     set_detailed_error("Invalid length_field_offset.");
-    QUIC_BUG_V2(quic_bug_10850_14) << "Invalid length_field_offset.";
+    QUIC_BUG(quic_bug_10850_14) << "Invalid length_field_offset.";
     return false;
   }
   size_t length_to_write = writer->length() - length_field_offset -
@@ -884,7 +884,7 @@
   if (!length_writer.WriteVarInt62(length_to_write,
                                    kQuicDefaultLongHeaderLengthLength)) {
     set_detailed_error("Failed to overwrite long header length.");
-    QUIC_BUG_V2(quic_bug_10850_15) << "Failed to overwrite long header length.";
+    QUIC_BUG(quic_bug_10850_15) << "Failed to overwrite long header length.";
     return false;
   }
   return true;
@@ -895,14 +895,14 @@
                                    char* buffer,
                                    size_t packet_length,
                                    EncryptionLevel level) {
-  QUIC_BUG_IF_V2(quic_bug_12975_2,
-                 header.version_flag && version().HasIetfInvariantHeader() &&
-                     header.long_packet_type == RETRY && !frames.empty())
+  QUIC_BUG_IF(quic_bug_12975_2,
+              header.version_flag && version().HasIetfInvariantHeader() &&
+                  header.long_packet_type == RETRY && !frames.empty())
       << "IETF RETRY packets cannot contain frames " << header;
   QuicDataWriter writer(packet_length, buffer);
   size_t length_field_offset = 0;
   if (!AppendPacketHeader(header, &writer, &length_field_offset)) {
-    QUIC_BUG_V2(quic_bug_10850_16) << "AppendPacketHeader failed";
+    QUIC_BUG(quic_bug_10850_16) << "AppendPacketHeader failed";
     return 0;
   }
 
@@ -922,14 +922,14 @@
     // Determine if we should write stream frame length in header.
     const bool last_frame_in_packet = i == frames.size() - 1;
     if (!AppendTypeByte(frame, last_frame_in_packet, &writer)) {
-      QUIC_BUG_V2(quic_bug_10850_17) << "AppendTypeByte failed";
+      QUIC_BUG(quic_bug_10850_17) << "AppendTypeByte failed";
       return 0;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         if (!AppendPaddingFrame(frame.padding_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_18)
+          QUIC_BUG(quic_bug_10850_18)
               << "AppendPaddingFrame of "
               << frame.padding_frame.num_padding_bytes << " failed";
           return 0;
@@ -938,13 +938,13 @@
       case STREAM_FRAME:
         if (!AppendStreamFrame(frame.stream_frame, last_frame_in_packet,
                                &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_19) << "AppendStreamFrame failed";
+          QUIC_BUG(quic_bug_10850_19) << "AppendStreamFrame failed";
           return 0;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_20)
+          QUIC_BUG(quic_bug_10850_20)
               << "AppendAckFrameAndTypeByte failed: " << detailed_error_;
           return 0;
         }
@@ -952,7 +952,7 @@
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(header, frame.stop_waiting_frame,
                                     &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
+          QUIC_BUG(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
           return 0;
         }
         break;
@@ -964,32 +964,32 @@
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_22) << "AppendRstStreamFrame failed";
+          QUIC_BUG(quic_bug_10850_22) << "AppendRstStreamFrame failed";
           return 0;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
                                         &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_23) << "AppendConnectionCloseFrame failed";
+          QUIC_BUG(quic_bug_10850_23) << "AppendConnectionCloseFrame failed";
           return 0;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_24) << "AppendGoAwayFrame failed";
+          QUIC_BUG(quic_bug_10850_24) << "AppendGoAwayFrame failed";
           return 0;
         }
         break;
       case WINDOW_UPDATE_FRAME:
         if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_25) << "AppendWindowUpdateFrame failed";
+          QUIC_BUG(quic_bug_10850_25) << "AppendWindowUpdateFrame failed";
           return 0;
         }
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_26) << "AppendBlockedFrame failed";
+          QUIC_BUG(quic_bug_10850_26) << "AppendBlockedFrame failed";
           return 0;
         }
         break;
@@ -1029,7 +1029,7 @@
       case MESSAGE_FRAME:
         if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
                                            last_frame_in_packet, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_27) << "AppendMessageFrame failed";
+          QUIC_BUG(quic_bug_10850_27) << "AppendMessageFrame failed";
           return 0;
         }
         break;
@@ -1040,7 +1040,7 @@
           return RaiseError(QUIC_INTERNAL_ERROR);
         }
         if (!AppendCryptoFrame(*frame.crypto_frame, &writer)) {
-          QUIC_BUG_V2(quic_bug_10850_28) << "AppendCryptoFrame failed";
+          QUIC_BUG(quic_bug_10850_28) << "AppendCryptoFrame failed";
           return 0;
         }
         break;
@@ -1049,7 +1049,7 @@
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        QUIC_BUG_V2(quic_bug_10850_29) << "QUIC_INVALID_FRAME_DATA";
+        QUIC_BUG(quic_bug_10850_29) << "QUIC_INVALID_FRAME_DATA";
         return 0;
     }
     ++i;
@@ -1069,7 +1069,7 @@
     // Determine if we should write stream frame length in header.
     const bool last_frame_in_packet = i == frames.size() - 1;
     if (!AppendIetfFrameType(frame, last_frame_in_packet, writer)) {
-      QUIC_BUG_V2(quic_bug_10850_30)
+      QUIC_BUG(quic_bug_10850_30)
           << "AppendIetfFrameType failed: " << detailed_error();
       return 0;
     }
@@ -1077,17 +1077,16 @@
     switch (frame.type) {
       case PADDING_FRAME:
         if (!AppendPaddingFrame(frame.padding_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_31)
-              << "AppendPaddingFrame of "
-              << frame.padding_frame.num_padding_bytes
-              << " failed: " << detailed_error();
+          QUIC_BUG(quic_bug_10850_31) << "AppendPaddingFrame of "
+                                      << frame.padding_frame.num_padding_bytes
+                                      << " failed: " << detailed_error();
           return 0;
         }
         break;
       case STREAM_FRAME:
         if (!AppendStreamFrame(frame.stream_frame, last_frame_in_packet,
                                writer)) {
-          QUIC_BUG_V2(quic_bug_10850_32)
+          QUIC_BUG(quic_bug_10850_32)
               << "AppendStreamFrame " << frame.stream_frame
               << " failed: " << detailed_error();
           return 0;
@@ -1095,7 +1094,7 @@
         break;
       case ACK_FRAME:
         if (!AppendIetfAckFrameAndTypeByte(*frame.ack_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_33)
+          QUIC_BUG(quic_bug_10850_33)
               << "AppendIetfAckFrameAndTypeByte failed: " << detailed_error();
           return 0;
         }
@@ -1104,7 +1103,7 @@
         set_detailed_error(
             "Attempt to append STOP WAITING frame in IETF QUIC.");
         RaiseError(QUIC_INTERNAL_ERROR);
-        QUIC_BUG_V2(quic_bug_10850_34) << detailed_error();
+        QUIC_BUG(quic_bug_10850_34) << detailed_error();
         return 0;
       case MTU_DISCOVERY_FRAME:
         // MTU discovery frames are serialized as ping frames.
@@ -1114,7 +1113,7 @@
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_35)
+          QUIC_BUG(quic_bug_10850_35)
               << "AppendRstStreamFrame failed: " << detailed_error();
           return 0;
         }
@@ -1122,7 +1121,7 @@
       case CONNECTION_CLOSE_FRAME:
         if (!AppendIetfConnectionCloseFrame(*frame.connection_close_frame,
                                             writer)) {
-          QUIC_BUG_V2(quic_bug_10850_36)
+          QUIC_BUG(quic_bug_10850_36)
               << "AppendIetfConnectionCloseFrame failed: " << detailed_error();
           return 0;
         }
@@ -1130,7 +1129,7 @@
       case GOAWAY_FRAME:
         set_detailed_error("Attempt to append GOAWAY frame in IETF QUIC.");
         RaiseError(QUIC_INTERNAL_ERROR);
-        QUIC_BUG_V2(quic_bug_10850_37) << detailed_error();
+        QUIC_BUG(quic_bug_10850_37) << detailed_error();
         return 0;
       case WINDOW_UPDATE_FRAME:
         // Depending on whether there is a stream ID or not, will be either a
@@ -1138,13 +1137,13 @@
         if (frame.window_update_frame->stream_id ==
             QuicUtils::GetInvalidStreamId(transport_version())) {
           if (!AppendMaxDataFrame(*frame.window_update_frame, writer)) {
-            QUIC_BUG_V2(quic_bug_10850_38)
+            QUIC_BUG(quic_bug_10850_38)
                 << "AppendMaxDataFrame failed: " << detailed_error();
             return 0;
           }
         } else {
           if (!AppendMaxStreamDataFrame(*frame.window_update_frame, writer)) {
-            QUIC_BUG_V2(quic_bug_10850_39)
+            QUIC_BUG(quic_bug_10850_39)
                 << "AppendMaxStreamDataFrame failed: " << detailed_error();
             return 0;
           }
@@ -1152,21 +1151,21 @@
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_40)
+          QUIC_BUG(quic_bug_10850_40)
               << "AppendBlockedFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case MAX_STREAMS_FRAME:
         if (!AppendMaxStreamsFrame(frame.max_streams_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_41)
+          QUIC_BUG(quic_bug_10850_41)
               << "AppendMaxStreamsFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case STREAMS_BLOCKED_FRAME:
         if (!AppendStreamsBlockedFrame(frame.streams_blocked_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_42)
+          QUIC_BUG(quic_bug_10850_42)
               << "AppendStreamsBlockedFrame failed: " << detailed_error();
           return 0;
         }
@@ -1174,7 +1173,7 @@
       case NEW_CONNECTION_ID_FRAME:
         if (!AppendNewConnectionIdFrame(*frame.new_connection_id_frame,
                                         writer)) {
-          QUIC_BUG_V2(quic_bug_10850_43)
+          QUIC_BUG(quic_bug_10850_43)
               << "AppendNewConnectionIdFrame failed: " << detailed_error();
           return 0;
         }
@@ -1182,35 +1181,35 @@
       case RETIRE_CONNECTION_ID_FRAME:
         if (!AppendRetireConnectionIdFrame(*frame.retire_connection_id_frame,
                                            writer)) {
-          QUIC_BUG_V2(quic_bug_10850_44)
+          QUIC_BUG(quic_bug_10850_44)
               << "AppendRetireConnectionIdFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case NEW_TOKEN_FRAME:
         if (!AppendNewTokenFrame(*frame.new_token_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_45)
+          QUIC_BUG(quic_bug_10850_45)
               << "AppendNewTokenFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case STOP_SENDING_FRAME:
         if (!AppendStopSendingFrame(*frame.stop_sending_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_46)
+          QUIC_BUG(quic_bug_10850_46)
               << "AppendStopSendingFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case PATH_CHALLENGE_FRAME:
         if (!AppendPathChallengeFrame(*frame.path_challenge_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_47)
+          QUIC_BUG(quic_bug_10850_47)
               << "AppendPathChallengeFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case PATH_RESPONSE_FRAME:
         if (!AppendPathResponseFrame(*frame.path_response_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_48)
+          QUIC_BUG(quic_bug_10850_48)
               << "AppendPathResponseFrame failed: " << detailed_error();
           return 0;
         }
@@ -1218,14 +1217,14 @@
       case MESSAGE_FRAME:
         if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
                                            last_frame_in_packet, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_49)
+          QUIC_BUG(quic_bug_10850_49)
               << "AppendMessageFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case CRYPTO_FRAME:
         if (!AppendCryptoFrame(*frame.crypto_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_50)
+          QUIC_BUG(quic_bug_10850_50)
               << "AppendCryptoFrame failed: " << detailed_error();
           return 0;
         }
@@ -1235,7 +1234,7 @@
         break;
       case ACK_FREQUENCY_FRAME:
         if (!AppendAckFrequencyFrame(*frame.ack_frequency_frame, writer)) {
-          QUIC_BUG_V2(quic_bug_10850_51)
+          QUIC_BUG(quic_bug_10850_51)
               << "AppendAckFrequencyFrame failed: " << detailed_error();
           return 0;
         }
@@ -1243,7 +1242,7 @@
       default:
         set_detailed_error("Tried to append unknown frame type.");
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        QUIC_BUG_V2(quic_bug_10850_52)
+        QUIC_BUG(quic_bug_10850_52)
             << "QUIC_INVALID_FRAME_DATA: " << frame.type;
         return 0;
     }
@@ -1312,7 +1311,7 @@
   QUIC_DVLOG(1) << "Building IETF stateless reset packet.";
   if (GetQuicReloadableFlag(quic_fix_stateless_reset)) {
     if (received_packet_length <= GetMinStatelessResetPacketLength()) {
-      QUIC_BUG_V2(362045737_1)
+      QUIC_BUG(362045737_1)
           << "Tried to build stateless reset packet with received packet "
              "length "
           << received_packet_length;
@@ -1328,8 +1327,8 @@
     // Append random bytes.
     if (!writer.WriteInsecureRandomBytes(QuicRandom::GetInstance(),
                                          len - sizeof(quic::QuicUint128))) {
-      QUIC_BUG_V2(362045737_2) << "Failed to append random bytes of length: "
-                               << len - sizeof(quic::QuicUint128);
+      QUIC_BUG(362045737_2) << "Failed to append random bytes of length: "
+                            << len - sizeof(quic::QuicUint128);
       return nullptr;
     }
     // Change first 2 fixed bits to 01.
@@ -1339,7 +1338,7 @@
     // Append stateless reset token.
     if (!writer.WriteBytes(&stateless_reset_token,
                            sizeof(stateless_reset_token))) {
-      QUIC_BUG_V2(362045737_3) << "Failed to write stateless reset token";
+      QUIC_BUG(362045737_3) << "Failed to write stateless reset token";
       return nullptr;
     }
     QUIC_RELOADABLE_FLAG_COUNT(quic_fix_stateless_reset);
@@ -1603,7 +1602,7 @@
       rv = ProcessDataPacket(&reader, &header, packet, large_buffer.get(),
                              packet.length());
     }
-    QUIC_BUG_IF_V2(quic_bug_10850_53, rv)
+    QUIC_BUG_IF(quic_bug_10850_53, rv)
         << "QUIC should never successfully process packets larger"
         << "than kMaxIncomingPacketSize. packet size:" << packet.length();
   }
@@ -1784,7 +1783,7 @@
 
   if (!encrypted_reader->TruncateRemaining(header->remaining_packet_length)) {
     set_detailed_error("Length TruncateRemaining failed.");
-    QUIC_BUG_V2(quic_bug_10850_54) << "Length TruncateRemaining failed.";
+    QUIC_BUG(quic_bug_10850_54) << "Length TruncateRemaining failed.";
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
   return true;
@@ -2125,8 +2124,8 @@
 
 bool QuicFramer::IsIetfStatelessResetPacket(
     const QuicPacketHeader& header) const {
-  QUIC_BUG_IF_V2(quic_bug_12975_3, header.has_possible_stateless_reset_token &&
-                                       perspective_ != Perspective::IS_CLIENT)
+  QUIC_BUG_IF(quic_bug_12975_3, header.has_possible_stateless_reset_token &&
+                                    perspective_ != Perspective::IS_CLIENT)
       << "has_possible_stateless_reset_token can only be true at client side.";
   return header.form == IETF_QUIC_SHORT_HEADER_PACKET &&
          header.has_possible_stateless_reset_token &&
@@ -2154,7 +2153,7 @@
     case NUM_PACKET_NUMBER_SPACES:
       break;
   }
-  QUIC_BUG_V2(quic_bug_10850_55)
+  QUIC_BUG(quic_bug_10850_55)
       << ENDPOINT
       << "Try to send data of space: " << PacketNumberSpaceToString(space);
   return false;
@@ -2162,7 +2161,7 @@
 
 EncryptionLevel QuicFramer::GetEncryptionLevelToSendApplicationData() const {
   if (!HasAnEncrypterForSpace(APPLICATION_DATA)) {
-    QUIC_BUG_V2(quic_bug_12975_4)
+    QUIC_BUG(quic_bug_12975_4)
         << "Tried to get encryption level to send application data with no "
            "encrypter available.";
     return NUM_ENCRYPTION_LEVELS;
@@ -2214,9 +2213,9 @@
       }
       break;
     case CONNECTION_ID_PRESENT:
-      QUIC_BUG_IF_V2(quic_bug_12975_5,
-                     !QuicUtils::IsConnectionIdValidForVersion(
-                         server_connection_id, transport_version()))
+      QUIC_BUG_IF(quic_bug_12975_5,
+                  !QuicUtils::IsConnectionIdValidForVersion(
+                      server_connection_id, transport_version()))
           << "AppendPacketHeader: attempted to use connection ID "
           << server_connection_id << " which is invalid with version "
           << version();
@@ -2279,9 +2278,8 @@
   QUIC_DVLOG(1) << ENDPOINT << "Appending IETF header: " << header;
   QuicConnectionId server_connection_id =
       GetServerConnectionIdAsSender(header, perspective_);
-  QUIC_BUG_IF_V2(quic_bug_12975_6,
-                 !QuicUtils::IsConnectionIdValidForVersion(server_connection_id,
-                                                           transport_version()))
+  QUIC_BUG_IF(quic_bug_12975_6, !QuicUtils::IsConnectionIdValidForVersion(
+                                    server_connection_id, transport_version()))
       << "AppendIetfPacketHeader: attempted to use connection ID "
       << server_connection_id << " which is invalid with version " << version();
   if (!AppendIetfHeaderTypeByte(header, writer)) {
@@ -2321,8 +2319,8 @@
   }
 
   // TODO(b/141924462) Remove this QUIC_BUG once we do support sending RETRY.
-  QUIC_BUG_IF_V2(quic_bug_12975_7,
-                 header.version_flag && header.long_packet_type == RETRY)
+  QUIC_BUG_IF(quic_bug_12975_7,
+              header.version_flag && header.long_packet_type == RETRY)
       << "Sending IETF RETRY packets is not currently supported " << header;
 
   if (QuicVersionHasLongHeaderLengths(transport_version()) &&
@@ -2547,7 +2545,7 @@
     case PACKET_8BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_8BYTE_PACKET;
     default:
-      QUIC_BUG_V2(quic_bug_10850_56) << "Unreachable case statement.";
+      QUIC_BUG(quic_bug_10850_56) << "Unreachable case statement.";
       return PACKET_FLAGS_8BYTE_PACKET;
   }
 }
@@ -3213,7 +3211,7 @@
     case ENCRYPTION_FORWARD_SECURE:
       return true;
     default:
-      QUIC_BUG_V2(quic_bug_10850_57) << "Unknown encryption level: " << level;
+      QUIC_BUG(quic_bug_10850_57) << "Unknown encryption level: " << level;
   }
   return false;
 }
@@ -4430,7 +4428,7 @@
   std::unique_ptr<QuicEncrypter> next_encrypter =
       visitor_->CreateCurrentOneRttEncrypter();
   if (!next_decrypter_ || !next_encrypter) {
-    QUIC_BUG_V2(quic_bug_10850_58) << "Failed to create next crypters";
+    QUIC_BUG(quic_bug_10850_58) << "Failed to create next crypters";
     return false;
   }
   key_update_performed_ = true;
@@ -4494,7 +4492,7 @@
                                   char* buffer) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_59)
+    QUIC_BUG(quic_bug_10850_59)
         << ENDPOINT
         << "Attempted to encrypt in place without encrypter at level " << level;
     RaiseError(QUIC_ENCRYPTION_FAILURE);
@@ -4549,14 +4547,14 @@
   absl::string_view sample;
   if (!sample_reader.Seek(sample_offset) ||
       !sample_reader.ReadStringPiece(&sample, kHPSampleLen)) {
-    QUIC_BUG_V2(quic_bug_10850_60)
+    QUIC_BUG(quic_bug_10850_60)
         << "Not enough bytes to sample: sample_offset " << sample_offset
         << ", sample len: " << kHPSampleLen << ", buffer len: " << buffer_len;
     return false;
   }
 
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG_V2(quic_bug_12975_8)
+    QUIC_BUG(quic_bug_12975_8)
         << ENDPOINT
         << "Attempted to apply header protection without encrypter at level "
         << level << " using " << version_;
@@ -4565,8 +4563,7 @@
 
   std::string mask = encrypter_[level]->GenerateHeaderProtectionMask(sample);
   if (mask.empty()) {
-    QUIC_BUG_V2(quic_bug_10850_61)
-        << "Unable to generate header protection mask.";
+    QUIC_BUG(quic_bug_10850_61) << "Unable to generate header protection mask.";
     return false;
   }
   QuicDataReader mask_reader(mask.data(), mask.size());
@@ -4595,7 +4592,7 @@
       perspective_ == Perspective::IS_SERVER &&
       version_.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
     if (pn_offset <= kDiversificationNonceSize) {
-      QUIC_BUG_V2(quic_bug_10850_62)
+      QUIC_BUG(quic_bug_10850_62)
           << "Expected diversification nonce, but not enough bytes";
       return false;
     }
@@ -4751,7 +4748,7 @@
                                   size_t buffer_len) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_63)
+    QUIC_BUG(quic_bug_10850_63)
         << ENDPOINT << "Attempted to encrypt without encrypter at level "
         << level;
     RaiseError(QUIC_ENCRYPTION_FAILURE);
@@ -4764,7 +4761,7 @@
   // plaintext content.
   const size_t ad_len = associated_data.length();
   if (packet.length() < ad_len) {
-    QUIC_BUG_V2(quic_bug_10850_64)
+    QUIC_BUG(quic_bug_10850_64)
         << ENDPOINT << "packet is shorter than associated data length. version:"
         << version() << ", packet length:" << packet.length()
         << ", associated data length:" << ad_len;
@@ -4794,7 +4791,7 @@
 size_t QuicFramer::GetCiphertextSize(EncryptionLevel level,
                                      size_t plaintext_size) const {
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_65)
+    QUIC_BUG(quic_bug_10850_65)
         << ENDPOINT
         << "Attempted to get ciphertext size without encrypter at level "
         << level << " using " << version_;
@@ -4822,7 +4819,7 @@
 
 QuicPacketCount QuicFramer::GetOneRttEncrypterConfidentialityLimit() const {
   if (!encrypter_[ENCRYPTION_FORWARD_SECURE]) {
-    QUIC_BUG_V2(quic_bug_10850_66) << "1-RTT encrypter not set";
+    QUIC_BUG(quic_bug_10850_66) << "1-RTT encrypter not set";
     return 0;
   }
   return encrypter_[ENCRYPTION_FORWARD_SECURE]->GetConfidentialityLimit();
@@ -4837,7 +4834,7 @@
                                 size_t* decrypted_length,
                                 EncryptionLevel* decrypted_level) {
   if (!EncryptionLevelIsValid(decrypter_level_)) {
-    QUIC_BUG_V2(quic_bug_10850_67)
+    QUIC_BUG(quic_bug_10850_67)
         << "Attempted to decrypt with bad decrypter_level_";
     return false;
   }
@@ -4849,14 +4846,14 @@
   bool attempt_key_update = false;
   if (version().KnowsWhichDecrypterToUse()) {
     if (header.form == GOOGLE_QUIC_PACKET) {
-      QUIC_BUG_V2(quic_bug_10850_68)
+      QUIC_BUG(quic_bug_10850_68)
           << "Attempted to decrypt GOOGLE_QUIC_PACKET with a version that "
              "knows which decrypter to use";
       return false;
     }
     level = GetEncryptionLevel(header);
     if (!EncryptionLevelIsValid(level)) {
-      QUIC_BUG_V2(quic_bug_10850_69) << "Attempted to decrypt with bad level";
+      QUIC_BUG(quic_bug_10850_69) << "Attempted to decrypt with bad level";
       return false;
     }
     decrypter = decrypter_[level].get();
@@ -4888,8 +4885,7 @@
             next_decrypter_ =
                 visitor_->AdvanceKeysAndCreateCurrentOneRttDecrypter();
             if (!next_decrypter_) {
-              QUIC_BUG_V2(quic_bug_10850_70)
-                  << "Failed to create next_decrypter";
+              QUIC_BUG(quic_bug_10850_70) << "Failed to create next_decrypter";
               return false;
             }
           }
@@ -4914,7 +4910,7 @@
     }
   } else if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
     if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
-      QUIC_BUG_V2(quic_bug_10850_71)
+      QUIC_BUG(quic_bug_10850_71)
           << "Attempted to decrypt with bad alternative_decrypter_level_";
       return false;
     }
@@ -4922,7 +4918,7 @@
   }
 
   if (decrypter == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_72)
+    QUIC_BUG(quic_bug_10850_72)
         << "Attempting to decrypt without decrypter, encryption level:" << level
         << " version:" << version();
     return false;
@@ -4995,7 +4991,7 @@
       *decrypted_level = decrypter_level_;
       if (alternative_decrypter_latch_) {
         if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
-          QUIC_BUG_V2(quic_bug_10850_73)
+          QUIC_BUG(quic_bug_10850_73)
               << "Attempted to latch alternate decrypter with bad "
                  "alternative_decrypter_level_";
           return false;
@@ -5032,7 +5028,7 @@
   ack_frame_size += QuicDataWriter::GetVarInt62Len(ack_delay_time_us);
 
   if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
-    QUIC_BUG_V2(quic_bug_10850_74) << "Malformed ack frame";
+    QUIC_BUG(quic_bug_10850_74) << "Malformed ack frame";
     // ACK frame serialization will fail and connection will be closed.
     return ack_frame_size;
   }
@@ -5315,7 +5311,7 @@
       type_byte = IETF_ACK_FREQUENCY;
       break;
     default:
-      QUIC_BUG_V2(quic_bug_10850_75)
+      QUIC_BUG(quic_bug_10850_75)
           << "Attempt to generate a frame type for an unsupported value: "
           << frame.type;
       return false;
@@ -5329,7 +5325,7 @@
                                     QuicDataWriter* writer) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (!IsValidPacketNumberLength(packet_number_length)) {
-    QUIC_BUG_V2(quic_bug_10850_76)
+    QUIC_BUG(quic_bug_10850_76)
         << "Invalid packet_number_length: " << packet_number_length;
     return false;
   }
@@ -5342,7 +5338,7 @@
                                 QuicStreamId stream_id,
                                 QuicDataWriter* writer) {
   if (stream_id_length == 0 || stream_id_length > 4) {
-    QUIC_BUG_V2(quic_bug_10850_77)
+    QUIC_BUG(quic_bug_10850_77)
         << "Invalid stream_id_length: " << stream_id_length;
     return false;
   }
@@ -5354,7 +5350,7 @@
                                     QuicStreamOffset offset,
                                     QuicDataWriter* writer) {
   if (offset_length == 1 || offset_length > 8) {
-    QUIC_BUG_V2(quic_bug_10850_78)
+    QUIC_BUG(quic_bug_10850_78)
         << "Invalid stream_offset_length: " << offset_length;
     return false;
   }
@@ -5369,7 +5365,7 @@
                                 QuicDataWriter* writer) {
   if (length == 0) {
     if (!IsValidPacketNumberLength(length_length)) {
-      QUIC_BUG_V2(quic_bug_10850_79)
+      QUIC_BUG(quic_bug_10850_79)
           << "Invalid packet_number_length: " << length_length;
       return false;
     }
@@ -5388,12 +5384,12 @@
   }
   if (!AppendStreamId(GetStreamIdSize(frame.stream_id), frame.stream_id,
                       writer)) {
-    QUIC_BUG_V2(quic_bug_10850_80) << "Writing stream id size failed.";
+    QUIC_BUG(quic_bug_10850_80) << "Writing stream id size failed.";
     return false;
   }
   if (!AppendStreamOffset(GetStreamOffsetSize(frame.offset), frame.offset,
                           writer)) {
-    QUIC_BUG_V2(quic_bug_10850_81) << "Writing offset size failed.";
+    QUIC_BUG(quic_bug_10850_81) << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
@@ -5403,7 +5399,7 @@
         "If frame.data_length can hold more than a uint16_t than we need to "
         "check that frame.data_length <= std::numeric_limits<uint16_t>::max()");
     if (!writer->WriteUInt16(static_cast<uint16_t>(frame.data_length))) {
-      QUIC_BUG_V2(quic_bug_10850_82) << "Writing stream frame length failed";
+      QUIC_BUG(quic_bug_10850_82) << "Writing stream frame length failed";
       return false;
     }
   }
@@ -5416,14 +5412,14 @@
     if (data_producer_->WriteStreamData(frame.stream_id, frame.offset,
                                         frame.data_length,
                                         writer) != WRITE_SUCCESS) {
-      QUIC_BUG_V2(quic_bug_10850_83) << "Writing frame data failed.";
+      QUIC_BUG(quic_bug_10850_83) << "Writing frame data failed.";
       return false;
     }
     return true;
   }
 
   if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
-    QUIC_BUG_V2(quic_bug_10850_84) << "Writing frame data failed.";
+    QUIC_BUG(quic_bug_10850_84) << "Writing frame data failed.";
     return false;
   }
   return true;
@@ -5675,7 +5671,7 @@
       }
       if (num_ack_blocks_written >= num_ack_blocks) {
         if (QUIC_PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
-          QUIC_BUG_V2(quic_bug_10850_85)
+          QUIC_BUG(quic_bug_10850_85)
               << "Wrote " << num_ack_blocks_written << ", expected to write "
               << num_ack_blocks;
         }
@@ -5787,7 +5783,7 @@
   const uint64_t length_shift = header.packet_number_length * 8;
 
   if (least_unacked_delta >> length_shift > 0) {
-    QUIC_BUG_V2(quic_bug_10850_86)
+    QUIC_BUG(quic_bug_10850_86)
         << "packet_number_length " << header.packet_number_length
         << " is too small for least_unacked_delta: " << least_unacked_delta
         << " packet_number:" << header.packet_number
@@ -5801,7 +5797,7 @@
   }
   if (!AppendPacketNumber(header.packet_number_length,
                           QuicPacketNumber(least_unacked_delta), writer)) {
-    QUIC_BUG_V2(quic_bug_10850_87)
+    QUIC_BUG(quic_bug_10850_87)
         << " seq failed: " << header.packet_number_length;
     return false;
   }
@@ -5846,7 +5842,7 @@
   }
 
   if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
-    QUIC_BUG_V2(quic_bug_10850_88) << "Malformed ack frame: " << frame;
+    QUIC_BUG(quic_bug_10850_88) << "Malformed ack frame: " << frame;
     set_detailed_error("Malformed ack frame");
     return false;
   }
@@ -5893,7 +5889,7 @@
         !count_writer.WriteVarInt62(appended_ack_blocks)) {
       // This should never happen as ack_block_count is limited by
       // max_ack_ranges_.
-      QUIC_BUG_V2(quic_bug_10850_89)
+      QUIC_BUG(quic_bug_10850_89)
           << "Ack frame truncation fails. ack_block_count: " << ack_block_count
           << ", appended count: " << appended_ack_blocks;
       set_detailed_error("ACK frame truncation fails");
@@ -6008,7 +6004,7 @@
     return false;
   }
   if (frame.num_padding_bytes < 0) {
-    QUIC_BUG_IF_V2(quic_bug_12975_9, frame.num_padding_bytes != -1);
+    QUIC_BUG_IF(quic_bug_12975_9, frame.num_padding_bytes != -1);
     writer->WritePadding();
     return true;
   }
@@ -6069,7 +6065,7 @@
     QuicDataWriter* writer) {
   if (frame.close_type != IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
       frame.close_type != IETF_QUIC_APPLICATION_CONNECTION_CLOSE) {
-    QUIC_BUG_V2(quic_bug_10850_90)
+    QUIC_BUG(quic_bug_10850_90)
         << "Invalid close_type for writing IETF CONNECTION CLOSE.";
     set_detailed_error("Invalid close_type for writing IETF CONNECTION CLOSE.");
     return false;
@@ -6561,12 +6557,12 @@
 
 void QuicFramer::EnableMultiplePacketNumberSpacesSupport() {
   if (supports_multiple_packet_number_spaces_) {
-    QUIC_BUG_V2(quic_bug_10850_91)
+    QUIC_BUG(quic_bug_10850_91)
         << "Multiple packet number spaces has already been enabled";
     return;
   }
   if (largest_packet_number_.IsInitialized()) {
-    QUIC_BUG_V2(quic_bug_10850_92)
+    QUIC_BUG(quic_bug_10850_92)
         << "Try to enable multiple packet number spaces support after any "
            "packet has been received.";
     return;
@@ -6858,17 +6854,17 @@
     const char* destination_connection_id_bytes,
     uint8_t destination_connection_id_length) {
   if (packet_bytes == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_93) << "Invalid packet_bytes";
+    QUIC_BUG(quic_bug_10850_93) << "Invalid packet_bytes";
     return false;
   }
   if (packet_length < kMinPacketSizeForVersionNegotiation ||
       packet_length > 65535) {
-    QUIC_BUG_V2(quic_bug_10850_94) << "Invalid packet_length";
+    QUIC_BUG(quic_bug_10850_94) << "Invalid packet_length";
     return false;
   }
   if (destination_connection_id_length > kQuicMaxConnectionId4BitLength ||
       destination_connection_id_length < kQuicDefaultConnectionIdLength) {
-    QUIC_BUG_V2(quic_bug_10850_95) << "Invalid connection_id_length";
+    QUIC_BUG(quic_bug_10850_95) << "Invalid connection_id_length";
     return false;
   }
   // clang-format off
@@ -6884,7 +6880,7 @@
   static_assert(sizeof(packet_start_bytes) == 5, "bad packet_start_bytes size");
   QuicDataWriter writer(packet_length, packet_bytes);
   if (!writer.WriteBytes(packet_start_bytes, sizeof(packet_start_bytes))) {
-    QUIC_BUG_V2(quic_bug_10850_96) << "Failed to write packet start";
+    QUIC_BUG(quic_bug_10850_96) << "Failed to write packet start";
     return false;
   }
 
@@ -6893,7 +6889,7 @@
   if (!AppendIetfConnectionIds(
           /*version_flag=*/true, /*use_length_prefix=*/true,
           destination_connection_id, EmptyQuicConnectionId(), &writer)) {
-    QUIC_BUG_V2(quic_bug_10850_97) << "Failed to write connection IDs";
+    QUIC_BUG(quic_bug_10850_97) << "Failed to write connection IDs";
     return false;
   }
   // Add 8 bytes of zeroes followed by 8 bytes of ones to ensure that this does
@@ -6903,14 +6899,14 @@
   // valid frame type.
   if (!writer.WriteUInt64(0) ||
       !writer.WriteUInt64(std::numeric_limits<uint64_t>::max())) {
-    QUIC_BUG_V2(quic_bug_10850_98) << "Failed to write 18 bytes";
+    QUIC_BUG(quic_bug_10850_98) << "Failed to write 18 bytes";
     return false;
   }
   // Make sure the polite greeting below is padded to a 16-byte boundary to
   // make it easier to read in tcpdump.
   while (writer.length() % 16 != 0) {
     if (!writer.WriteUInt8(0)) {
-      QUIC_BUG_V2(quic_bug_10850_99) << "Failed to write padding byte";
+      QUIC_BUG(quic_bug_10850_99) << "Failed to write padding byte";
       return false;
     }
   }
@@ -6920,7 +6916,7 @@
       "Please respond with a Version Negotiation packet indicating what "
       "versions you support. Thank you and have a nice day.";
   if (!writer.WriteBytes(polite_greeting, sizeof(polite_greeting))) {
-    QUIC_BUG_V2(quic_bug_10850_100) << "Failed to write polite greeting";
+    QUIC_BUG(quic_bug_10850_100) << "Failed to write polite greeting";
     return false;
   }
   // Fill the rest of the packet with zeroes.
@@ -6937,7 +6933,7 @@
     uint8_t* source_connection_id_length_out,
     std::string* detailed_error) {
   if (detailed_error == nullptr) {
-    QUIC_BUG_V2(quic_bug_10850_101) << "Invalid error_details";
+    QUIC_BUG(quic_bug_10850_101) << "Invalid error_details";
     return false;
   }
   *detailed_error = "";
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index a627213..5217f87 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -153,7 +153,7 @@
     return true;
   }
   bool SetPreliminaryKey(absl::string_view /*key*/) override {
-    QUIC_BUG_V2(quic_bug_10486_1) << "should not be called";
+    QUIC_BUG(quic_bug_10486_1) << "should not be called";
     return false;
   }
   bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
diff --git a/quic/core/quic_interval_deque.h b/quic/core/quic_interval_deque.h
index 94ce1bd..ba27aa9 100644
--- a/quic/core/quic_interval_deque.h
+++ b/quic/core/quic_interval_deque.h
@@ -162,7 +162,7 @@
       // Don't increment when we are at the end.
       const std::size_t container_size = deque_->container_.size();
       if (index_ >= container_size) {
-        QUIC_BUG_V2(quic_bug_10862_1) << "Iterator out of bounds.";
+        QUIC_BUG(quic_bug_10862_1) << "Iterator out of bounds.";
         return *this;
       }
       index_++;
@@ -279,7 +279,7 @@
 template <class T, class C>
 void QuicIntervalDeque<T, C>::PopFront() {
   if (container_.size() == 0) {
-    QUIC_BUG_V2(quic_bug_10862_2) << "Trying to pop from an empty container.";
+    QUIC_BUG(quic_bug_10862_2) << "Trying to pop from an empty container.";
     return;
   }
   container_.pop_front();
@@ -362,7 +362,7 @@
   QuicInterval<std::size_t> interval = item.interval();
   // Adding an empty interval is a bug.
   if (interval.Empty()) {
-    QUIC_BUG_V2(quic_bug_10862_3)
+    QUIC_BUG(quic_bug_10862_3)
         << "Trying to save empty interval to QuicCircularDeque.";
     return;
   }
diff --git a/quic/core/quic_legacy_version_encapsulator.cc b/quic/core/quic_legacy_version_encapsulator.cc
index 54880f1..27dbb9b 100644
--- a/quic/core/quic_legacy_version_encapsulator.cc
+++ b/quic/core/quic_legacy_version_encapsulator.cc
@@ -46,13 +46,12 @@
     SerializedPacket serialized_packet) {
   if (encrypted_length_ != 0) {
     unrecoverable_failure_encountered_ = true;
-    QUIC_BUG_V2(quic_bug_10615_1) << "OnSerializedPacket called twice";
+    QUIC_BUG(quic_bug_10615_1) << "OnSerializedPacket called twice";
     return;
   }
   if (serialized_packet.encrypted_length == 0) {
     unrecoverable_failure_encountered_ = true;
-    QUIC_BUG_V2(quic_bug_10615_2)
-        << "OnSerializedPacket called with empty packet";
+    QUIC_BUG(quic_bug_10615_2) << "OnSerializedPacket called with empty packet";
     return;
   }
   encrypted_length_ = serialized_packet.encrypted_length;
@@ -62,9 +61,8 @@
     QuicErrorCode error,
     const std::string& error_details) {
   unrecoverable_failure_encountered_ = true;
-  QUIC_BUG_V2(quic_bug_10615_3)
-      << "QuicLegacyVersionEncapsulator received error " << error << ": "
-      << error_details;
+  QUIC_BUG(quic_bug_10615_3) << "QuicLegacyVersionEncapsulator received error "
+                             << error << ": " << error_details;
 }
 
 bool QuicLegacyVersionEncapsulator::ShouldGeneratePacket(
@@ -122,7 +120,7 @@
   outer_creator.SetTransmissionType(NOT_RETRANSMISSION);
   if (!outer_creator.AddPaddedSavedFrame(QuicFrame(outer_stream_frame),
                                          NOT_RETRANSMISSION)) {
-    QUIC_BUG_V2(quic_bug_10615_4)
+    QUIC_BUG(quic_bug_10615_4)
         << "Failed to add Legacy Version Encapsulation stream frame "
            "(max packet length is "
         << outer_creator.max_packet_length() << ") " << outer_stream_frame;
@@ -132,13 +130,13 @@
   const QuicPacketLength encrypted_length = creator_delegate.encrypted_length_;
   if (creator_delegate.unrecoverable_failure_encountered_ ||
       encrypted_length == 0) {
-    QUIC_BUG_V2(quic_bug_10615_5)
+    QUIC_BUG(quic_bug_10615_5)
         << "Failed to perform Legacy Version Encapsulation of "
         << inner_packet.length() << " bytes";
     return 0;
   }
   if (encrypted_length > kMaxOutgoingPacketSize) {
-    QUIC_BUG_V2(quic_bug_10615_6)
+    QUIC_BUG(quic_bug_10615_6)
         << "Legacy Version Encapsulation outer creator generated a "
            "packet with unexpected length "
         << encrypted_length;