diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index 4ed9b45..578eea5 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 << "Cannot write value " << value << " with write_length "
-             << write_length;
+    QUIC_BUG_V2(quic_bug_10347_1) << "Cannot write value " << value
+                                  << " with write_length " << write_length;
     return false;
   }
   if (write_length == min_length) {
@@ -220,15 +220,16 @@
            WriteUInt32(value);
   }
 
-  QUIC_BUG << "Invalid write_length " << static_cast<int>(write_length);
+  QUIC_BUG_V2(quic_bug_10347_2)
+      << "Invalid write_length " << static_cast<int>(write_length);
   return false;
 }
 
 // static
 QuicVariableLengthIntegerLength QuicDataWriter::GetVarInt62Len(uint64_t value) {
   if ((value & kVarInt62ErrorMask) != 0) {
-    QUIC_BUG << "Attempted to encode a value, " << value
-             << ", that is too big for VarInt62";
+    QUIC_BUG_V2(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 d0d44b6..8f37b92 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 << "Unable to add frame to an empty packet";
+      QUIC_BUG_V2(quic_bug_10287_1) << "Unable to add frame to an empty packet";
       delete frame;
       return;
     }
@@ -265,9 +265,10 @@
   }
   if (legacy_version_encapsulation_inner_packet.length() >=
       packet_info.packet.length()) {
-    QUIC_BUG << "Inner packet cannot be larger than outer "
-             << legacy_version_encapsulation_inner_packet.length() << " vs "
-             << packet_info.packet.length();
+    QUIC_BUG_V2(quic_bug_10287_2)
+        << "Inner packet cannot be larger than outer "
+        << legacy_version_encapsulation_inner_packet.length() << " vs "
+        << packet_info.packet.length();
     return false;
   }
 
@@ -1002,10 +1003,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 << "ConnectionId " << server_connection_id
-               << " does not exist in the session map.  Error: "
-               << QuicErrorCodeToString(error);
-      QUIC_BUG << QuicStackTrace();
+      QUIC_BUG_V2(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();
       return;
     }
 
@@ -1039,10 +1041,11 @@
   } else {
     auto it = session_map_.find(server_connection_id);
     if (it == session_map_.end()) {
-      QUIC_BUG << "ConnectionId " << server_connection_id
-               << " does not exist in the session map.  Error: "
-               << QuicErrorCodeToString(error);
-      QUIC_BUG << QuicStackTrace();
+      QUIC_BUG_V2(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();
       return;
     }
 
@@ -1092,10 +1095,10 @@
   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 << "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;
+    QUIC_BUG_V2(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;
     return;
   }
   auto insertion_result = reference_counted_session_map_.insert(
@@ -1322,10 +1325,11 @@
       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 << "CreateQuicSession returned nullptr for "
-             << packet_info->destination_connection_id << " from "
-             << packet_info->peer_address << " to " << packet_info->self_address
-             << " ALPN \"" << alpn << "\" version " << packet_info->version;
+    QUIC_BUG_V2(quic_bug_10287_8)
+        << "CreateQuicSession returned nullptr for "
+        << packet_info->destination_connection_id << " from "
+        << packet_info->peer_address << " to " << packet_info->self_address
+        << " ALPN \"" << alpn << "\" version " << packet_info->version;
     return;
   }
   if (original_connection_id != packet_info->destination_connection_id) {
@@ -1342,9 +1346,10 @@
             packet_info->destination_connection_id,
             std::shared_ptr<QuicSession>(std::move(session.release()))));
     if (!insertion_result.second) {
-      QUIC_BUG << "Tried to add a session to session_map with existing "
-                  "connection id: "
-               << packet_info->destination_connection_id;
+      QUIC_BUG_V2(quic_bug_10287_9)
+          << "Tried to add a session to session_map with existing "
+             "connection id: "
+          << packet_info->destination_connection_id;
     } else if (support_multiple_cid_per_connection_) {
       ++num_sessions_in_session_map_;
     }
diff --git a/quic/core/quic_flow_controller.cc b/quic/core/quic_flow_controller.cc
index 01fb72c..53202bf 100644
--- a/quic/core/quic_flow_controller.cc
+++ b/quic/core/quic_flow_controller.cc
@@ -91,9 +91,10 @@
 
 void QuicFlowController::AddBytesSent(QuicByteCount bytes_sent) {
   if (bytes_sent_ + bytes_sent > send_window_offset_) {
-    QUIC_BUG << ENDPOINT << LogLabel() << " Trying to send an extra "
-             << bytes_sent << " bytes, when bytes_sent = " << bytes_sent_
-             << ", and send_window_offset_ = " << send_window_offset_;
+    QUIC_BUG_V2(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_;
     bytes_sent_ = send_window_offset_;
 
     // This is an error on our side, close the connection as soon as possible.
@@ -298,8 +299,9 @@
   QUIC_DVLOG(1) << ENDPOINT << "UpdateReceiveWindowSize for " << LogLabel()
                 << ": " << size;
   if (receive_window_size_ != receive_window_offset_) {
-    QUIC_BUG << "receive_window_size_:" << receive_window_size_
-             << " != receive_window_offset:" << receive_window_offset_;
+    QUIC_BUG_V2(quic_bug_10836_2)
+        << "receive_window_size_:" << receive_window_size_
+        << " != receive_window_offset:" << receive_window_offset_;
     return;
   }
   receive_window_size_ = size;
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 74d73d9..78008d1 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 << "Unreachable case statement.";
+      QUIC_BUG_V2(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 << "Unreachable case statement.";
+      QUIC_BUG_V2(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 << "Invalid long header type: " << type;
+      QUIC_BUG_V2(quic_bug_10850_3) << "Invalid long header type: " << type;
       return 0xFF;
   }
 }
@@ -232,7 +232,7 @@
       *long_header_type = RETRY;
       break;
     default:
-      QUIC_BUG << "Unreachable statement";
+      QUIC_BUG_V2(quic_bug_10850_4) << "Unreachable statement";
       *long_header_type = INVALID_PACKET_TYPE;
       return false;
   }
@@ -247,7 +247,8 @@
 PacketNumberSpace GetPacketNumberSpace(const QuicPacketHeader& header) {
   switch (header.form) {
     case GOOGLE_QUIC_PACKET:
-      QUIC_BUG << "Try to get packet number space of Google QUIC packet";
+      QUIC_BUG_V2(quic_bug_10850_5)
+          << "Try to get packet number space of Google QUIC packet";
       break;
     case IETF_QUIC_SHORT_HEADER_PACKET:
       return APPLICATION_DATA;
@@ -262,9 +263,9 @@
         case VERSION_NEGOTIATION:
         case RETRY:
         case INVALID_PACKET_TYPE:
-          QUIC_BUG << "Try to get packet number space of long header type: "
-                   << QuicUtils::QuicLongHeaderTypetoString(
-                          header.long_packet_type);
+          QUIC_BUG_V2(quic_bug_10850_6)
+              << "Try to get packet number space of long header type: "
+              << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
           break;
       }
   }
@@ -275,7 +276,8 @@
 EncryptionLevel GetEncryptionLevel(const QuicPacketHeader& header) {
   switch (header.form) {
     case GOOGLE_QUIC_PACKET:
-      QUIC_BUG << "Cannot determine EncryptionLevel from Google QUIC header";
+      QUIC_BUG_V2(quic_bug_10850_7)
+          << "Cannot determine EncryptionLevel from Google QUIC header";
       break;
     case IETF_QUIC_SHORT_HEADER_PACKET:
       return ENCRYPTION_FORWARD_SECURE;
@@ -290,9 +292,9 @@
         case VERSION_NEGOTIATION:
         case RETRY:
         case INVALID_PACKET_TYPE:
-          QUIC_BUG << "No encryption used with type "
-                   << QuicUtils::QuicLongHeaderTypetoString(
-                          header.long_packet_type);
+          QUIC_BUG_V2(quic_bug_10850_8)
+              << "No encryption used with type "
+              << QuicUtils::QuicLongHeaderTypetoString(header.long_packet_type);
       }
   }
   return NUM_ENCRYPTION_LEVELS;
@@ -590,9 +592,10 @@
 size_t QuicFramer::GetMaxStreamsFrameSize(QuicTransportVersion version,
                                           const QuicMaxStreamsFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
-    QUIC_BUG << "In version " << version
-             << ", which does not support IETF Frames, and tried to serialize "
-                "MaxStreams Frame.";
+    QUIC_BUG_V2(quic_bug_10850_9)
+        << "In version " << version
+        << ", which does not support IETF Frames, and tried to serialize "
+           "MaxStreams Frame.";
   }
   return kQuicFrameTypeSize +
          QuicDataWriter::GetVarInt62Len(frame.stream_count);
@@ -603,9 +606,10 @@
     QuicTransportVersion version,
     const QuicStreamsBlockedFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
-    QUIC_BUG << "In version " << version
-             << ", which does not support IETF frames, and tried to serialize "
-                "StreamsBlocked Frame.";
+    QUIC_BUG_V2(quic_bug_10850_10)
+        << "In version " << version
+        << ", which does not support IETF frames, and tried to serialize "
+           "StreamsBlocked Frame.";
   }
 
   return kQuicFrameTypeSize +
@@ -726,7 +730,7 @@
       return i;
     }
   }
-  QUIC_BUG << "Failed to determine StreamIDSize.";
+  QUIC_BUG_V2(quic_bug_10850_11) << "Failed to determine StreamIDSize.";
   return 4;
 }
 
@@ -744,7 +748,7 @@
       return i;
     }
   }
-  QUIC_BUG << "Failed to determine StreamOffsetSize.";
+  QUIC_BUG_V2(quic_bug_10850_12) << "Failed to determine StreamOffsetSize.";
   return 8;
 }
 
@@ -800,10 +804,11 @@
     QuicPacketNumberLength packet_number_length) {
   // Prevent a rare crash reported in b/19458523.
   if (frame.type == ACK_FRAME && frame.ack_frame == nullptr) {
-    QUIC_BUG << "Cannot compute the length of a null ack frame. free_bytes:"
-             << free_bytes << " first_frame:" << first_frame
-             << " last_frame:" << last_frame
-             << " seq num length:" << packet_number_length;
+    QUIC_BUG_V2(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
+        << " seq num length:" << packet_number_length;
     set_error(QUIC_INTERNAL_ERROR);
     visitor_->OnError(this);
     return 0;
@@ -866,7 +871,7 @@
       writer->length() - length_field_offset <
           kQuicDefaultLongHeaderLengthLength) {
     set_detailed_error("Invalid length_field_offset.");
-    QUIC_BUG << "Invalid length_field_offset.";
+    QUIC_BUG_V2(quic_bug_10850_14) << "Invalid length_field_offset.";
     return false;
   }
   size_t length_to_write = writer->length() - length_field_offset -
@@ -879,7 +884,7 @@
   if (!length_writer.WriteVarInt62(length_to_write,
                                    kQuicDefaultLongHeaderLengthLength)) {
     set_detailed_error("Failed to overwrite long header length.");
-    QUIC_BUG << "Failed to overwrite long header length.";
+    QUIC_BUG_V2(quic_bug_10850_15) << "Failed to overwrite long header length.";
     return false;
   }
   return true;
@@ -896,7 +901,7 @@
   QuicDataWriter writer(packet_length, buffer);
   size_t length_field_offset = 0;
   if (!AppendPacketHeader(header, &writer, &length_field_offset)) {
-    QUIC_BUG << "AppendPacketHeader failed";
+    QUIC_BUG_V2(quic_bug_10850_16) << "AppendPacketHeader failed";
     return 0;
   }
 
@@ -916,35 +921,37 @@
     // 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 << "AppendTypeByte failed";
+      QUIC_BUG_V2(quic_bug_10850_17) << "AppendTypeByte failed";
       return 0;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         if (!AppendPaddingFrame(frame.padding_frame, &writer)) {
-          QUIC_BUG << "AppendPaddingFrame of "
-                   << frame.padding_frame.num_padding_bytes << " failed";
+          QUIC_BUG_V2(quic_bug_10850_18)
+              << "AppendPaddingFrame of "
+              << frame.padding_frame.num_padding_bytes << " failed";
           return 0;
         }
         break;
       case STREAM_FRAME:
         if (!AppendStreamFrame(frame.stream_frame, last_frame_in_packet,
                                &writer)) {
-          QUIC_BUG << "AppendStreamFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_19) << "AppendStreamFrame failed";
           return 0;
         }
         break;
       case ACK_FRAME:
         if (!AppendAckFrameAndTypeByte(*frame.ack_frame, &writer)) {
-          QUIC_BUG << "AppendAckFrameAndTypeByte failed: " << detailed_error_;
+          QUIC_BUG_V2(quic_bug_10850_20)
+              << "AppendAckFrameAndTypeByte failed: " << detailed_error_;
           return 0;
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(header, frame.stop_waiting_frame,
                                     &writer)) {
-          QUIC_BUG << "AppendStopWaitingFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
           return 0;
         }
         break;
@@ -956,32 +963,32 @@
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
-          QUIC_BUG << "AppendRstStreamFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_22) << "AppendRstStreamFrame failed";
           return 0;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
                                         &writer)) {
-          QUIC_BUG << "AppendConnectionCloseFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_23) << "AppendConnectionCloseFrame failed";
           return 0;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
-          QUIC_BUG << "AppendGoAwayFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_24) << "AppendGoAwayFrame failed";
           return 0;
         }
         break;
       case WINDOW_UPDATE_FRAME:
         if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) {
-          QUIC_BUG << "AppendWindowUpdateFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_25) << "AppendWindowUpdateFrame failed";
           return 0;
         }
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) {
-          QUIC_BUG << "AppendBlockedFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_26) << "AppendBlockedFrame failed";
           return 0;
         }
         break;
@@ -1021,7 +1028,7 @@
       case MESSAGE_FRAME:
         if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
                                            last_frame_in_packet, &writer)) {
-          QUIC_BUG << "AppendMessageFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_27) << "AppendMessageFrame failed";
           return 0;
         }
         break;
@@ -1032,7 +1039,7 @@
           return RaiseError(QUIC_INTERNAL_ERROR);
         }
         if (!AppendCryptoFrame(*frame.crypto_frame, &writer)) {
-          QUIC_BUG << "AppendCryptoFrame failed";
+          QUIC_BUG_V2(quic_bug_10850_28) << "AppendCryptoFrame failed";
           return 0;
         }
         break;
@@ -1041,7 +1048,7 @@
         break;
       default:
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        QUIC_BUG << "QUIC_INVALID_FRAME_DATA";
+        QUIC_BUG_V2(quic_bug_10850_29) << "QUIC_INVALID_FRAME_DATA";
         return 0;
     }
     ++i;
@@ -1061,30 +1068,33 @@
     // 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 << "AppendIetfFrameType failed: " << detailed_error();
+      QUIC_BUG_V2(quic_bug_10850_30)
+          << "AppendIetfFrameType failed: " << detailed_error();
       return 0;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         if (!AppendPaddingFrame(frame.padding_frame, writer)) {
-          QUIC_BUG << "AppendPaddingFrame of "
-                   << frame.padding_frame.num_padding_bytes
-                   << " failed: " << detailed_error();
+          QUIC_BUG_V2(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 << "AppendStreamFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_32)
+              << "AppendStreamFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case ACK_FRAME:
         if (!AppendIetfAckFrameAndTypeByte(*frame.ack_frame, writer)) {
-          QUIC_BUG << "AppendIetfAckFrameAndTypeByte failed: "
-                   << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_33)
+              << "AppendIetfAckFrameAndTypeByte failed: " << detailed_error();
           return 0;
         }
         break;
@@ -1092,7 +1102,7 @@
         set_detailed_error(
             "Attempt to append STOP WAITING frame in IETF QUIC.");
         RaiseError(QUIC_INTERNAL_ERROR);
-        QUIC_BUG << detailed_error();
+        QUIC_BUG_V2(quic_bug_10850_34) << detailed_error();
         return 0;
       case MTU_DISCOVERY_FRAME:
         // MTU discovery frames are serialized as ping frames.
@@ -1102,22 +1112,23 @@
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, writer)) {
-          QUIC_BUG << "AppendRstStreamFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_35)
+              << "AppendRstStreamFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
         if (!AppendIetfConnectionCloseFrame(*frame.connection_close_frame,
                                             writer)) {
-          QUIC_BUG << "AppendIetfConnectionCloseFrame failed: "
-                   << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_36)
+              << "AppendIetfConnectionCloseFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case GOAWAY_FRAME:
         set_detailed_error("Attempt to append GOAWAY frame in IETF QUIC.");
         RaiseError(QUIC_INTERNAL_ERROR);
-        QUIC_BUG << detailed_error();
+        QUIC_BUG_V2(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
@@ -1125,83 +1136,95 @@
         if (frame.window_update_frame->stream_id ==
             QuicUtils::GetInvalidStreamId(transport_version())) {
           if (!AppendMaxDataFrame(*frame.window_update_frame, writer)) {
-            QUIC_BUG << "AppendMaxDataFrame failed: " << detailed_error();
+            QUIC_BUG_V2(quic_bug_10850_38)
+                << "AppendMaxDataFrame failed: " << detailed_error();
             return 0;
           }
         } else {
           if (!AppendMaxStreamDataFrame(*frame.window_update_frame, writer)) {
-            QUIC_BUG << "AppendMaxStreamDataFrame failed: " << detailed_error();
+            QUIC_BUG_V2(quic_bug_10850_39)
+                << "AppendMaxStreamDataFrame failed: " << detailed_error();
             return 0;
           }
         }
         break;
       case BLOCKED_FRAME:
         if (!AppendBlockedFrame(*frame.blocked_frame, writer)) {
-          QUIC_BUG << "AppendBlockedFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_40)
+              << "AppendBlockedFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case MAX_STREAMS_FRAME:
         if (!AppendMaxStreamsFrame(frame.max_streams_frame, writer)) {
-          QUIC_BUG << "AppendMaxStreamsFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_41)
+              << "AppendMaxStreamsFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case STREAMS_BLOCKED_FRAME:
         if (!AppendStreamsBlockedFrame(frame.streams_blocked_frame, writer)) {
-          QUIC_BUG << "AppendStreamsBlockedFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_42)
+              << "AppendStreamsBlockedFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case NEW_CONNECTION_ID_FRAME:
         if (!AppendNewConnectionIdFrame(*frame.new_connection_id_frame,
                                         writer)) {
-          QUIC_BUG << "AppendNewConnectionIdFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_43)
+              << "AppendNewConnectionIdFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case RETIRE_CONNECTION_ID_FRAME:
         if (!AppendRetireConnectionIdFrame(*frame.retire_connection_id_frame,
                                            writer)) {
-          QUIC_BUG << "AppendRetireConnectionIdFrame failed: "
-                   << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_44)
+              << "AppendRetireConnectionIdFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case NEW_TOKEN_FRAME:
         if (!AppendNewTokenFrame(*frame.new_token_frame, writer)) {
-          QUIC_BUG << "AppendNewTokenFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_45)
+              << "AppendNewTokenFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case STOP_SENDING_FRAME:
         if (!AppendStopSendingFrame(*frame.stop_sending_frame, writer)) {
-          QUIC_BUG << "AppendStopSendingFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_46)
+              << "AppendStopSendingFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case PATH_CHALLENGE_FRAME:
         if (!AppendPathChallengeFrame(*frame.path_challenge_frame, writer)) {
-          QUIC_BUG << "AppendPathChallengeFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_47)
+              << "AppendPathChallengeFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case PATH_RESPONSE_FRAME:
         if (!AppendPathResponseFrame(*frame.path_response_frame, writer)) {
-          QUIC_BUG << "AppendPathResponseFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_48)
+              << "AppendPathResponseFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case MESSAGE_FRAME:
         if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
                                            last_frame_in_packet, writer)) {
-          QUIC_BUG << "AppendMessageFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_49)
+              << "AppendMessageFrame failed: " << detailed_error();
           return 0;
         }
         break;
       case CRYPTO_FRAME:
         if (!AppendCryptoFrame(*frame.crypto_frame, writer)) {
-          QUIC_BUG << "AppendCryptoFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_50)
+              << "AppendCryptoFrame failed: " << detailed_error();
           return 0;
         }
         break;
@@ -1210,14 +1233,16 @@
         break;
       case ACK_FREQUENCY_FRAME:
         if (!AppendAckFrequencyFrame(*frame.ack_frequency_frame, writer)) {
-          QUIC_BUG << "AppendAckFrequencyFrame failed: " << detailed_error();
+          QUIC_BUG_V2(quic_bug_10850_51)
+              << "AppendAckFrequencyFrame failed: " << detailed_error();
           return 0;
         }
         break;
       default:
         set_detailed_error("Tried to append unknown frame type.");
         RaiseError(QUIC_INVALID_FRAME_DATA);
-        QUIC_BUG << "QUIC_INVALID_FRAME_DATA: " << frame.type;
+        QUIC_BUG_V2(quic_bug_10850_52)
+            << "QUIC_INVALID_FRAME_DATA: " << frame.type;
         return 0;
     }
     ++i;
@@ -1532,9 +1557,9 @@
       rv = ProcessDataPacket(&reader, &header, packet, large_buffer.get(),
                              packet.length());
     }
-    QUIC_BUG_IF(rv) << "QUIC should never successfully process packets larger"
-                    << "than kMaxIncomingPacketSize. packet size:"
-                    << packet.length();
+    QUIC_BUG_IF_V2(quic_bug_10850_53, rv)
+        << "QUIC should never successfully process packets larger"
+        << "than kMaxIncomingPacketSize. packet size:" << packet.length();
   }
   return rv;
 }
@@ -1713,7 +1738,7 @@
 
   if (!encrypted_reader->TruncateRemaining(header->remaining_packet_length)) {
     set_detailed_error("Length TruncateRemaining failed.");
-    QUIC_BUG << "Length TruncateRemaining failed.";
+    QUIC_BUG_V2(quic_bug_10850_54) << "Length TruncateRemaining failed.";
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
   return true;
@@ -2083,8 +2108,9 @@
     case NUM_PACKET_NUMBER_SPACES:
       break;
   }
-  QUIC_BUG << ENDPOINT
-           << "Try to send data of space: " << PacketNumberSpaceToString(space);
+  QUIC_BUG_V2(quic_bug_10850_55)
+      << ENDPOINT
+      << "Try to send data of space: " << PacketNumberSpaceToString(space);
   return false;
 }
 
@@ -2472,7 +2498,7 @@
     case PACKET_8BYTE_PACKET_NUMBER:
       return PACKET_FLAGS_8BYTE_PACKET;
     default:
-      QUIC_BUG << "Unreachable case statement.";
+      QUIC_BUG_V2(quic_bug_10850_56) << "Unreachable case statement.";
       return PACKET_FLAGS_8BYTE_PACKET;
   }
 }
@@ -3138,7 +3164,7 @@
     case ENCRYPTION_FORWARD_SECURE:
       return true;
     default:
-      QUIC_BUG << "Unknown encryption level: " << level;
+      QUIC_BUG_V2(quic_bug_10850_57) << "Unknown encryption level: " << level;
   }
   return false;
 }
@@ -4355,7 +4381,7 @@
   std::unique_ptr<QuicEncrypter> next_encrypter =
       visitor_->CreateCurrentOneRttEncrypter();
   if (!next_decrypter_ || !next_encrypter) {
-    QUIC_BUG << "Failed to create next crypters";
+    QUIC_BUG_V2(quic_bug_10850_58) << "Failed to create next crypters";
     return false;
   }
   key_update_performed_ = true;
@@ -4419,9 +4445,9 @@
                                   char* buffer) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG << ENDPOINT
-             << "Attempted to encrypt in place without encrypter at level "
-             << level;
+    QUIC_BUG_V2(quic_bug_10850_59)
+        << ENDPOINT
+        << "Attempted to encrypt in place without encrypter at level " << level;
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return 0;
   }
@@ -4474,9 +4500,9 @@
   absl::string_view sample;
   if (!sample_reader.Seek(sample_offset) ||
       !sample_reader.ReadStringPiece(&sample, kHPSampleLen)) {
-    QUIC_BUG << "Not enough bytes to sample: sample_offset " << sample_offset
-             << ", sample len: " << kHPSampleLen
-             << ", buffer len: " << buffer_len;
+    QUIC_BUG_V2(quic_bug_10850_60)
+        << "Not enough bytes to sample: sample_offset " << sample_offset
+        << ", sample len: " << kHPSampleLen << ", buffer len: " << buffer_len;
     return false;
   }
 
@@ -4490,7 +4516,8 @@
 
   std::string mask = encrypter_[level]->GenerateHeaderProtectionMask(sample);
   if (mask.empty()) {
-    QUIC_BUG << "Unable to generate header protection mask.";
+    QUIC_BUG_V2(quic_bug_10850_61)
+        << "Unable to generate header protection mask.";
     return false;
   }
   QuicDataReader mask_reader(mask.data(), mask.size());
@@ -4519,7 +4546,8 @@
       perspective_ == Perspective::IS_SERVER &&
       version_.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
     if (pn_offset <= kDiversificationNonceSize) {
-      QUIC_BUG << "Expected diversification nonce, but not enough bytes";
+      QUIC_BUG_V2(quic_bug_10850_62)
+          << "Expected diversification nonce, but not enough bytes";
       return false;
     }
     pn_offset -= kDiversificationNonceSize;
@@ -4674,8 +4702,9 @@
                                   size_t buffer_len) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG << ENDPOINT << "Attempted to encrypt without encrypter at level "
-             << level;
+    QUIC_BUG_V2(quic_bug_10850_63)
+        << ENDPOINT << "Attempted to encrypt without encrypter at level "
+        << level;
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return 0;
   }
@@ -4686,10 +4715,10 @@
   // plaintext content.
   const size_t ad_len = associated_data.length();
   if (packet.length() < ad_len) {
-    QUIC_BUG << ENDPOINT
-             << "packet is shorter than associated data length. version:"
-             << version() << ", packet length:" << packet.length()
-             << ", associated data length:" << ad_len;
+    QUIC_BUG_V2(quic_bug_10850_64)
+        << ENDPOINT << "packet is shorter than associated data length. version:"
+        << version() << ", packet length:" << packet.length()
+        << ", associated data length:" << ad_len;
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return 0;
   }
@@ -4716,9 +4745,10 @@
 size_t QuicFramer::GetCiphertextSize(EncryptionLevel level,
                                      size_t plaintext_size) const {
   if (encrypter_[level] == nullptr) {
-    QUIC_BUG << ENDPOINT
-             << "Attempted to get ciphertext size without encrypter at level "
-             << level << " using " << version_;
+    QUIC_BUG_V2(quic_bug_10850_65)
+        << ENDPOINT
+        << "Attempted to get ciphertext size without encrypter at level "
+        << level << " using " << version_;
     return plaintext_size;
   }
   return encrypter_[level]->GetCiphertextSize(plaintext_size);
@@ -4743,7 +4773,7 @@
 
 QuicPacketCount QuicFramer::GetOneRttEncrypterConfidentialityLimit() const {
   if (!encrypter_[ENCRYPTION_FORWARD_SECURE]) {
-    QUIC_BUG << "1-RTT encrypter not set";
+    QUIC_BUG_V2(quic_bug_10850_66) << "1-RTT encrypter not set";
     return 0;
   }
   return encrypter_[ENCRYPTION_FORWARD_SECURE]->GetConfidentialityLimit();
@@ -4758,7 +4788,8 @@
                                 size_t* decrypted_length,
                                 EncryptionLevel* decrypted_level) {
   if (!EncryptionLevelIsValid(decrypter_level_)) {
-    QUIC_BUG << "Attempted to decrypt with bad decrypter_level_";
+    QUIC_BUG_V2(quic_bug_10850_67)
+        << "Attempted to decrypt with bad decrypter_level_";
     return false;
   }
   EncryptionLevel level = decrypter_level_;
@@ -4769,13 +4800,14 @@
   bool attempt_key_update = false;
   if (version().KnowsWhichDecrypterToUse()) {
     if (header.form == GOOGLE_QUIC_PACKET) {
-      QUIC_BUG << "Attempted to decrypt GOOGLE_QUIC_PACKET with a version that "
-                  "knows which decrypter to use";
+      QUIC_BUG_V2(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 << "Attempted to decrypt with bad level";
+      QUIC_BUG_V2(quic_bug_10850_69) << "Attempted to decrypt with bad level";
       return false;
     }
     decrypter = decrypter_[level].get();
@@ -4807,7 +4839,8 @@
             next_decrypter_ =
                 visitor_->AdvanceKeysAndCreateCurrentOneRttDecrypter();
             if (!next_decrypter_) {
-              QUIC_BUG << "Failed to create next_decrypter";
+              QUIC_BUG_V2(quic_bug_10850_70)
+                  << "Failed to create next_decrypter";
               return false;
             }
           }
@@ -4832,15 +4865,17 @@
     }
   } else if (alternative_decrypter_level_ != NUM_ENCRYPTION_LEVELS) {
     if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
-      QUIC_BUG << "Attempted to decrypt with bad alternative_decrypter_level_";
+      QUIC_BUG_V2(quic_bug_10850_71)
+          << "Attempted to decrypt with bad alternative_decrypter_level_";
       return false;
     }
     alternative_decrypter = decrypter_[alternative_decrypter_level_].get();
   }
 
   if (decrypter == nullptr) {
-    QUIC_BUG << "Attempting to decrypt without decrypter, encryption level:"
-             << level << " version:" << version();
+    QUIC_BUG_V2(quic_bug_10850_72)
+        << "Attempting to decrypt without decrypter, encryption level:" << level
+        << " version:" << version();
     return false;
   }
 
@@ -4911,8 +4946,9 @@
       *decrypted_level = decrypter_level_;
       if (alternative_decrypter_latch_) {
         if (!EncryptionLevelIsValid(alternative_decrypter_level_)) {
-          QUIC_BUG << "Attempted to latch alternate decrypter with bad "
-                      "alternative_decrypter_level_";
+          QUIC_BUG_V2(quic_bug_10850_73)
+              << "Attempted to latch alternate decrypter with bad "
+                 "alternative_decrypter_level_";
           return false;
         }
         // Switch to the alternative decrypter and latch so that we cannot
@@ -4947,7 +4983,7 @@
   ack_frame_size += QuicDataWriter::GetVarInt62Len(ack_delay_time_us);
 
   if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
-    QUIC_BUG << "Malformed ack frame";
+    QUIC_BUG_V2(quic_bug_10850_74) << "Malformed ack frame";
     // ACK frame serialization will fail and connection will be closed.
     return ack_frame_size;
   }
@@ -5230,8 +5266,9 @@
       type_byte = IETF_ACK_FREQUENCY;
       break;
     default:
-      QUIC_BUG << "Attempt to generate a frame type for an unsupported value: "
-               << frame.type;
+      QUIC_BUG_V2(quic_bug_10850_75)
+          << "Attempt to generate a frame type for an unsupported value: "
+          << frame.type;
       return false;
   }
   return writer->WriteVarInt62(type_byte);
@@ -5243,7 +5280,8 @@
                                     QuicDataWriter* writer) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (!IsValidPacketNumberLength(packet_number_length)) {
-    QUIC_BUG << "Invalid packet_number_length: " << packet_number_length;
+    QUIC_BUG_V2(quic_bug_10850_76)
+        << "Invalid packet_number_length: " << packet_number_length;
     return false;
   }
   return writer->WriteBytesToUInt64(packet_number_length,
@@ -5255,7 +5293,8 @@
                                 QuicStreamId stream_id,
                                 QuicDataWriter* writer) {
   if (stream_id_length == 0 || stream_id_length > 4) {
-    QUIC_BUG << "Invalid stream_id_length: " << stream_id_length;
+    QUIC_BUG_V2(quic_bug_10850_77)
+        << "Invalid stream_id_length: " << stream_id_length;
     return false;
   }
   return writer->WriteBytesToUInt64(stream_id_length, stream_id);
@@ -5266,7 +5305,8 @@
                                     QuicStreamOffset offset,
                                     QuicDataWriter* writer) {
   if (offset_length == 1 || offset_length > 8) {
-    QUIC_BUG << "Invalid stream_offset_length: " << offset_length;
+    QUIC_BUG_V2(quic_bug_10850_78)
+        << "Invalid stream_offset_length: " << offset_length;
     return false;
   }
 
@@ -5280,7 +5320,8 @@
                                 QuicDataWriter* writer) {
   if (length == 0) {
     if (!IsValidPacketNumberLength(length_length)) {
-      QUIC_BUG << "Invalid packet_number_length: " << length_length;
+      QUIC_BUG_V2(quic_bug_10850_79)
+          << "Invalid packet_number_length: " << length_length;
       return false;
     }
     return writer->WriteUInt8(gap) &&
@@ -5298,12 +5339,12 @@
   }
   if (!AppendStreamId(GetStreamIdSize(frame.stream_id), frame.stream_id,
                       writer)) {
-    QUIC_BUG << "Writing stream id size failed.";
+    QUIC_BUG_V2(quic_bug_10850_80) << "Writing stream id size failed.";
     return false;
   }
   if (!AppendStreamOffset(GetStreamOffsetSize(frame.offset), frame.offset,
                           writer)) {
-    QUIC_BUG << "Writing offset size failed.";
+    QUIC_BUG_V2(quic_bug_10850_81) << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
@@ -5313,7 +5354,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 << "Writing stream frame length failed";
+      QUIC_BUG_V2(quic_bug_10850_82) << "Writing stream frame length failed";
       return false;
     }
   }
@@ -5326,14 +5367,14 @@
     if (data_producer_->WriteStreamData(frame.stream_id, frame.offset,
                                         frame.data_length,
                                         writer) != WRITE_SUCCESS) {
-      QUIC_BUG << "Writing frame data failed.";
+      QUIC_BUG_V2(quic_bug_10850_83) << "Writing frame data failed.";
       return false;
     }
     return true;
   }
 
   if (!writer->WriteBytes(frame.data_buffer, frame.data_length)) {
-    QUIC_BUG << "Writing frame data failed.";
+    QUIC_BUG_V2(quic_bug_10850_84) << "Writing frame data failed.";
     return false;
   }
   return true;
@@ -5585,8 +5626,9 @@
       }
       if (num_ack_blocks_written >= num_ack_blocks) {
         if (QUIC_PREDICT_FALSE(num_ack_blocks_written != num_ack_blocks)) {
-          QUIC_BUG << "Wrote " << num_ack_blocks_written
-                   << ", expected to write " << num_ack_blocks;
+          QUIC_BUG_V2(quic_bug_10850_85)
+              << "Wrote " << num_ack_blocks_written << ", expected to write "
+              << num_ack_blocks;
         }
         break;
       }
@@ -5696,11 +5738,12 @@
   const uint64_t length_shift = header.packet_number_length * 8;
 
   if (least_unacked_delta >> length_shift > 0) {
-    QUIC_BUG << "packet_number_length " << header.packet_number_length
-             << " is too small for least_unacked_delta: " << least_unacked_delta
-             << " packet_number:" << header.packet_number
-             << " least_unacked:" << frame.least_unacked
-             << " version:" << version_.transport_version;
+    QUIC_BUG_V2(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
+        << " least_unacked:" << frame.least_unacked
+        << " version:" << version_.transport_version;
     return false;
   }
   if (least_unacked_delta == 0) {
@@ -5709,7 +5752,8 @@
   }
   if (!AppendPacketNumber(header.packet_number_length,
                           QuicPacketNumber(least_unacked_delta), writer)) {
-    QUIC_BUG << " seq failed: " << header.packet_number_length;
+    QUIC_BUG_V2(quic_bug_10850_87)
+        << " seq failed: " << header.packet_number_length;
     return false;
   }
 
@@ -5753,7 +5797,7 @@
   }
 
   if (frame.packets.Empty() || frame.packets.Max() != largest_acked) {
-    QUIC_BUG << "Malformed ack frame: " << frame;
+    QUIC_BUG_V2(quic_bug_10850_88) << "Malformed ack frame: " << frame;
     set_detailed_error("Malformed ack frame");
     return false;
   }
@@ -5800,9 +5844,9 @@
         !count_writer.WriteVarInt62(appended_ack_blocks)) {
       // This should never happen as ack_block_count is limited by
       // max_ack_ranges_.
-      QUIC_BUG << "Ack frame truncation fails. ack_block_count: "
-               << ack_block_count
-               << ", appended count: " << appended_ack_blocks;
+      QUIC_BUG_V2(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");
       return false;
     }
@@ -5976,7 +6020,8 @@
     QuicDataWriter* writer) {
   if (frame.close_type != IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
       frame.close_type != IETF_QUIC_APPLICATION_CONNECTION_CLOSE) {
-    QUIC_BUG << "Invalid close_type for writing IETF CONNECTION CLOSE.";
+    QUIC_BUG_V2(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;
   }
@@ -6467,12 +6512,14 @@
 
 void QuicFramer::EnableMultiplePacketNumberSpacesSupport() {
   if (supports_multiple_packet_number_spaces_) {
-    QUIC_BUG << "Multiple packet number spaces has already been enabled";
+    QUIC_BUG_V2(quic_bug_10850_91)
+        << "Multiple packet number spaces has already been enabled";
     return;
   }
   if (largest_packet_number_.IsInitialized()) {
-    QUIC_BUG << "Try to enable multiple packet number spaces support after any "
-                "packet has been received.";
+    QUIC_BUG_V2(quic_bug_10850_92)
+        << "Try to enable multiple packet number spaces support after any "
+           "packet has been received.";
     return;
   }
 
@@ -6762,17 +6809,17 @@
     const char* destination_connection_id_bytes,
     uint8_t destination_connection_id_length) {
   if (packet_bytes == nullptr) {
-    QUIC_BUG << "Invalid packet_bytes";
+    QUIC_BUG_V2(quic_bug_10850_93) << "Invalid packet_bytes";
     return false;
   }
   if (packet_length < kMinPacketSizeForVersionNegotiation ||
       packet_length > 65535) {
-    QUIC_BUG << "Invalid packet_length";
+    QUIC_BUG_V2(quic_bug_10850_94) << "Invalid packet_length";
     return false;
   }
   if (destination_connection_id_length > kQuicMaxConnectionId4BitLength ||
       destination_connection_id_length < kQuicDefaultConnectionIdLength) {
-    QUIC_BUG << "Invalid connection_id_length";
+    QUIC_BUG_V2(quic_bug_10850_95) << "Invalid connection_id_length";
     return false;
   }
   // clang-format off
@@ -6788,7 +6835,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 << "Failed to write packet start";
+    QUIC_BUG_V2(quic_bug_10850_96) << "Failed to write packet start";
     return false;
   }
 
@@ -6797,7 +6844,7 @@
   if (!AppendIetfConnectionIds(
           /*version_flag=*/true, /*use_length_prefix=*/true,
           destination_connection_id, EmptyQuicConnectionId(), &writer)) {
-    QUIC_BUG << "Failed to write connection IDs";
+    QUIC_BUG_V2(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
@@ -6807,14 +6854,14 @@
   // valid frame type.
   if (!writer.WriteUInt64(0) ||
       !writer.WriteUInt64(std::numeric_limits<uint64_t>::max())) {
-    QUIC_BUG << "Failed to write 18 bytes";
+    QUIC_BUG_V2(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 << "Failed to write padding byte";
+      QUIC_BUG_V2(quic_bug_10850_99) << "Failed to write padding byte";
       return false;
     }
   }
@@ -6824,7 +6871,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 << "Failed to write polite greeting";
+    QUIC_BUG_V2(quic_bug_10850_100) << "Failed to write polite greeting";
     return false;
   }
   // Fill the rest of the packet with zeroes.
@@ -6841,7 +6888,7 @@
     uint8_t* source_connection_id_length_out,
     std::string* detailed_error) {
   if (detailed_error == nullptr) {
-    QUIC_BUG << "Invalid error_details";
+    QUIC_BUG_V2(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 1ecd036..c0eac56 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 << "should not be called";
+    QUIC_BUG_V2(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 d4e82e2..94ce1bd 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 << "Iterator out of bounds.";
+        QUIC_BUG_V2(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 << "Trying to pop from an empty container.";
+    QUIC_BUG_V2(quic_bug_10862_2) << "Trying to pop from an empty container.";
     return;
   }
   container_.pop_front();
@@ -362,7 +362,8 @@
   QuicInterval<std::size_t> interval = item.interval();
   // Adding an empty interval is a bug.
   if (interval.Empty()) {
-    QUIC_BUG << "Trying to save empty interval to QuicCircularDeque.";
+    QUIC_BUG_V2(quic_bug_10862_3)
+        << "Trying to save empty interval to QuicCircularDeque.";
     return;
   }
   container_.push_back(std::forward<U>(item));
diff --git a/quic/core/quic_legacy_version_encapsulator.cc b/quic/core/quic_legacy_version_encapsulator.cc
index bfe2df2..54880f1 100644
--- a/quic/core/quic_legacy_version_encapsulator.cc
+++ b/quic/core/quic_legacy_version_encapsulator.cc
@@ -46,12 +46,13 @@
     SerializedPacket serialized_packet) {
   if (encrypted_length_ != 0) {
     unrecoverable_failure_encountered_ = true;
-    QUIC_BUG << "OnSerializedPacket called twice";
+    QUIC_BUG_V2(quic_bug_10615_1) << "OnSerializedPacket called twice";
     return;
   }
   if (serialized_packet.encrypted_length == 0) {
     unrecoverable_failure_encountered_ = true;
-    QUIC_BUG << "OnSerializedPacket called with empty packet";
+    QUIC_BUG_V2(quic_bug_10615_2)
+        << "OnSerializedPacket called with empty packet";
     return;
   }
   encrypted_length_ = serialized_packet.encrypted_length;
@@ -61,8 +62,9 @@
     QuicErrorCode error,
     const std::string& error_details) {
   unrecoverable_failure_encountered_ = true;
-  QUIC_BUG << "QuicLegacyVersionEncapsulator received error " << error << ": "
-           << error_details;
+  QUIC_BUG_V2(quic_bug_10615_3)
+      << "QuicLegacyVersionEncapsulator received error " << error << ": "
+      << error_details;
 }
 
 bool QuicLegacyVersionEncapsulator::ShouldGeneratePacket(
@@ -120,23 +122,26 @@
   outer_creator.SetTransmissionType(NOT_RETRANSMISSION);
   if (!outer_creator.AddPaddedSavedFrame(QuicFrame(outer_stream_frame),
                                          NOT_RETRANSMISSION)) {
-    QUIC_BUG << "Failed to add Legacy Version Encapsulation stream frame "
-                "(max packet length is "
-             << outer_creator.max_packet_length() << ") " << outer_stream_frame;
+    QUIC_BUG_V2(quic_bug_10615_4)
+        << "Failed to add Legacy Version Encapsulation stream frame "
+           "(max packet length is "
+        << outer_creator.max_packet_length() << ") " << outer_stream_frame;
     return 0;
   }
   outer_creator.FlushCurrentPacket();
   const QuicPacketLength encrypted_length = creator_delegate.encrypted_length_;
   if (creator_delegate.unrecoverable_failure_encountered_ ||
       encrypted_length == 0) {
-    QUIC_BUG << "Failed to perform Legacy Version Encapsulation of "
-             << inner_packet.length() << " bytes";
+    QUIC_BUG_V2(quic_bug_10615_5)
+        << "Failed to perform Legacy Version Encapsulation of "
+        << inner_packet.length() << " bytes";
     return 0;
   }
   if (encrypted_length > kMaxOutgoingPacketSize) {
-    QUIC_BUG << "Legacy Version Encapsulation outer creator generated a "
-                "packet with unexpected length "
-             << encrypted_length;
+    QUIC_BUG_V2(quic_bug_10615_6)
+        << "Legacy Version Encapsulation outer creator generated a "
+           "packet with unexpected length "
+        << encrypted_length;
     return 0;
   }
 
diff --git a/quic/core/quic_linux_socket_utils.cc b/quic/core/quic_linux_socket_utils.cc
index c2931af..500a9a8 100644
--- a/quic/core/quic_linux_socket_utils.cc
+++ b/quic/core/quic_linux_socket_utils.cc
@@ -229,7 +229,7 @@
     in6_pktinfo* pktinfo = static_cast<in6_pktinfo*>(cmsg_data);
     memcpy(&pktinfo->ipi6_addr, address_str.c_str(), address_str.length());
   } else {
-    QUIC_BUG << "Unrecognized IPAddress";
+    QUIC_BUG_V2(quic_bug_10598_1) << "Unrecognized IPAddress";
   }
 }
 
@@ -259,7 +259,7 @@
            address_string.length());
     return sizeof(in6_pktinfo);
   } else {
-    QUIC_BUG << "Unrecognized IPAddress";
+    QUIC_BUG_V2(quic_bug_10598_2) << "Unrecognized IPAddress";
     return 0;
   }
 }
@@ -300,8 +300,9 @@
 
     return WriteResult(WRITE_STATUS_OK, mhdr->num_bytes_sent(rc));
   } else if (rc == 0) {
-    QUIC_BUG << "sendmmsg returned 0, returning WRITE_STATUS_ERROR. errno: "
-             << errno;
+    QUIC_BUG_V2(quic_bug_10598_3)
+        << "sendmmsg returned 0, returning WRITE_STATUS_ERROR. errno: "
+        << errno;
     errno = EIO;
   }
 
diff --git a/quic/core/quic_network_blackhole_detector.cc b/quic/core/quic_network_blackhole_detector.cc
index a79810f..e65013f 100644
--- a/quic/core/quic_network_blackhole_detector.cc
+++ b/quic/core/quic_network_blackhole_detector.cc
@@ -36,7 +36,8 @@
 void QuicNetworkBlackholeDetector::OnAlarm() {
   QuicTime next_deadline = GetEarliestDeadline();
   if (!next_deadline.IsInitialized()) {
-    QUIC_BUG << "BlackholeDetector alarm fired unexpectedly";
+    QUIC_BUG_V2(quic_bug_10328_1)
+        << "BlackholeDetector alarm fired unexpectedly";
     return;
   }
 
diff --git a/quic/core/quic_one_block_arena.h b/quic/core/quic_one_block_arena.h
index 8311477..ee319c2 100644
--- a/quic/core/quic_one_block_arena.h
+++ b/quic/core/quic_one_block_arena.h
@@ -38,9 +38,10 @@
     static_assert(alignof(T) > 1,
                   "Objects added to the arena must be at least 2B aligned.");
     if (QUIC_PREDICT_FALSE(offset_ > ArenaSize - AlignedSize<T>())) {
-      QUIC_BUG << "Ran out of space in QuicOneBlockArena at " << this
-               << ", max size was " << ArenaSize << ", failing request was "
-               << AlignedSize<T>() << ", end of arena was " << offset_;
+      QUIC_BUG_V2(quic_bug_10593_1)
+          << "Ran out of space in QuicOneBlockArena at " << this
+          << ", max size was " << ArenaSize << ", failing request was "
+          << AlignedSize<T>() << ", end of arena was " << offset_;
       return QuicArenaScopedPtr<T>(new T(std::forward<Args>(args)...));
     }