grpc 1.72.0 → 1.73.0

data/src/core/ext/transport/chttp2/transport/frame_goaway.cc

@@ -138,6 +138,11 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       p->debug_pos += static_cast<uint32_t>(end - cur);
       p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
       if (is_last) {
+        t->http2_ztrace_collector.Append([p]() {
+          return grpc_core::H2GoAwayTrace<true>{
+              p->last_stream_id, p->error_code,
+              std::string(absl::string_view(p->debug_data, p->debug_length))};
+        });
         grpc_chttp2_add_incoming_goaway(
             t, p->error_code, p->last_stream_id,
             absl::string_view(p->debug_data, p->debug_length));
@@ -149,15 +154,22 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE("Should never reach here"));
 }
 
-void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,
-                               const grpc_slice& debug_data,
-                               grpc_slice_buffer* slice_buffer) {
+void grpc_chttp2_goaway_append(
+    uint32_t last_stream_id, uint32_t error_code, const grpc_slice& debug_data,
+    grpc_slice_buffer* slice_buffer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector) {
   grpc_slice header = GRPC_SLICE_MALLOC(9 + 4 + 4);
   uint8_t* p = GRPC_SLICE_START_PTR(header);
   uint32_t frame_length;
   CHECK(GRPC_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);
   frame_length = 4 + 4 + static_cast<uint32_t> GRPC_SLICE_LENGTH(debug_data);
 
+  ztrace_collector->Append([last_stream_id, error_code, debug_data]() {
+    return grpc_core::H2GoAwayTrace<false>{
+        last_stream_id, error_code,
+        std::string(grpc_core::StringViewFromSlice(debug_data))};
+  });
+
   // frame header: length
   *p++ = static_cast<uint8_t>(frame_length >> 16);
   *p++ = static_cast<uint8_t>(frame_length >> 8);

data/src/core/ext/transport/chttp2/transport/frame_goaway.h

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 
@@ -56,8 +57,9 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
                                                   const grpc_slice& slice,
                                                   int is_last);
 
-void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,
-                               const grpc_slice& debug_data,
-                               grpc_slice_buffer* slice_buffer);
+void grpc_chttp2_goaway_append(
+    uint32_t last_stream_id, uint32_t error_code, const grpc_slice& debug_data,
+    grpc_slice_buffer* slice_buffer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector);
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_GOAWAY_H

data/src/core/ext/transport/chttp2/transport/frame_ping.cc

@@ -90,6 +90,8 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
 
   if (p->byte == 8) {
     CHECK(is_last);
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2PingTrace<true>{p->is_ack != 0, p->opaque_8bytes});
     if (p->is_ack) {
       GRPC_TRACE_LOG(http2_ping, INFO)
           << (t->is_client ? "CLIENT" : "SERVER") << "[" << t

data/src/core/ext/transport/chttp2/transport/frame_rst_stream.cc

@@ -36,17 +36,20 @@
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 
 using grpc_core::http2::Http2ErrorCode;
 
 grpc_slice grpc_chttp2_rst_stream_create(
-    uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer) {
+    uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector) {
   static const size_t frame_size = 13;
   grpc_slice slice = GRPC_SLICE_MALLOC(frame_size);
   if (call_tracer != nullptr) {
     call_tracer->RecordOutgoingBytes({frame_size, 0, 0});
   }
+  ztrace_collector->Append(grpc_core::H2RstStreamTrace<false>{id, code});
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
 
   // Frame size.
@@ -75,8 +78,9 @@ void grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer) {
   t->num_pending_induced_frames++;
-  grpc_slice_buffer_add(&t->qbuf,
-                        grpc_chttp2_rst_stream_create(id, code, call_tracer));
+  grpc_slice_buffer_add(
+      &t->qbuf, grpc_chttp2_rst_stream_create(id, code, call_tracer,
+                                              &t->http2_ztrace_collector));
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
@@ -114,6 +118,8 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
                       ((static_cast<uint32_t>(p->reason_bytes[1])) << 16) |
                       ((static_cast<uint32_t>(p->reason_bytes[2])) << 8) |
                       ((static_cast<uint32_t>(p->reason_bytes[3])));
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2RstStreamTrace<true>{t->incoming_stream_id, reason});
     GRPC_TRACE_LOG(http, INFO)
         << "[chttp2 transport=" << t << " stream=" << s
         << "] received RST_STREAM(reason=" << reason << ")";
@@ -128,8 +134,9 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
+    grpc_core::SharedBitGen g;
     if (!t->is_client &&
-        absl::Bernoulli(t->bitgen, t->ping_on_rst_stream_percent / 100.0)) {
+        absl::Bernoulli(g, t->ping_on_rst_stream_percent / 100.0)) {
       ++t->num_pending_induced_frames;
       t->ping_callbacks.RequestPing();
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING);

data/src/core/ext/transport/chttp2/transport/frame_rst_stream.h

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
@@ -34,7 +35,8 @@ struct grpc_chttp2_rst_stream_parser {
 };
 grpc_slice grpc_chttp2_rst_stream_create(
     uint32_t stream_id, uint32_t code,
-    grpc_core::CallTracerInterface* call_tracer);
+    grpc_core::CallTracerInterface* call_tracer,
+    grpc_core::Http2ZTraceCollector* ztrace_collector);
 
 // Adds RST_STREAM frame to t->qbuf (buffer for the next write). Should be
 // called when we want to add RST_STREAM and we are not in

data/src/core/ext/transport/chttp2/transport/frame_settings.cc

@@ -31,6 +31,7 @@
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/debug/trace.h"
@@ -94,6 +95,8 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
 
   if (parser->is_ack) {
+    t->http2_ztrace_collector.Append(
+        grpc_core::H2SettingsTrace<true>{true, {}});
     return absl::OkStatus();
   }
 
@@ -118,6 +121,20 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
             grpc_core::global_stats()
                 .IncrementHttp2PreferredReceiveCryptoMessageSize(
                     target_settings->preferred_receive_crypto_message_size());
+            t->http2_ztrace_collector.Append([parser]() {
+              grpc_core::H2SettingsTrace<true> settings{false, {}};
+              // TODO(ctiller): produce actual wire settings here, not a
+              // diff. Likely this needs to wait for PH2 where we separate
+              // the parse loop from the application loop.
+              parser->incoming_settings->Diff(
+                  false, *parser->target_settings,
+                  [&settings](uint16_t key, uint32_t value) {
+                    settings.settings.push_back({key, value});
+                  });
+              return settings;
+            });
+            t->http2_ztrace_collector.Append(
+                []() { return grpc_core::H2SettingsTrace<false>{true, {}}; });
             *parser->target_settings = *parser->incoming_settings;
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
@@ -198,7 +215,8 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (error != Http2ErrorCode::kNoError) {
           grpc_chttp2_goaway_append(
               t->last_new_stream_id, static_cast<uint32_t>(error),
-              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf);
+              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf,
+              &t->http2_ztrace_collector);
           return GRPC_ERROR_CREATE(absl::StrFormat(
               "invalid value %u passed for %s", parser->value,
               grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));

data/src/core/ext/transport/chttp2/transport/frame_window_update.cc

@@ -27,6 +27,7 @@
 #include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/stream_lists.h"
 #include "src/core/telemetry/stats.h"
@@ -101,6 +102,9 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
     }
     CHECK(is_last);
 
+    t->http2_ztrace_collector.Append(grpc_core::H2WindowUpdateTrace<true>{
+        t->incoming_stream_id, received_update});
+
     if (t->incoming_stream_id != 0) {
       if (s != nullptr) {
         grpc_core::Timestamp now = grpc_core::Timestamp::Now();

data/src/core/ext/transport/chttp2/transport/hpack_encoder.cc

@@ -101,6 +101,13 @@ void HPackCompressor::Frame(const EncodeHeaderOptions& options,
     FillHeader(grpc_slice_buffer_tiny_add(output, kHeadersFrameHeaderSize),
                frame_type, options.stream_id, len, flags);
     options.call_tracer->RecordOutgoingBytes({kHeadersFrameHeaderSize, 0, 0});
+    options.ztrace_collector->Append([&]() {
+      return H2HeaderTrace<false>{
+          options.stream_id, (flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0,
+          (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0,
+          frame_type == GRPC_CHTTP2_FRAME_CONTINUATION,
+          static_cast<uint32_t>(len)};
+    });
     grpc_slice_buffer_move_first(raw.c_slice_buffer(), len, output);
 
     frame_type = GRPC_CHTTP2_FRAME_CONTINUATION;

data/src/core/ext/transport/chttp2/transport/hpack_encoder.h

@@ -35,6 +35,7 @@
 #include "src/core/call/metadata_compression_traits.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/timeout_encoding.h"
@@ -353,6 +354,7 @@ class HPackCompressor {
     bool use_true_binary_metadata;
     size_t max_frame_size;
     CallTracerInterface* call_tracer;
+    Http2ZTraceCollector* ztrace_collector;
   };
 
   template <typename HeaderSet>

data/src/core/ext/transport/chttp2/transport/http2_settings.h

@@ -27,6 +27,7 @@
 #include "absl/strings/string_view.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/util/json/json.h"
 #include "src/core/util/useful.h"
 
 namespace grpc_core {
@@ -132,6 +133,22 @@ class Http2Settings {
 
   bool operator!=(const Http2Settings& rhs) const { return !operator==(rhs); }
 
+  Json::Object ToJsonObject() const {
+    Json::Object object;
+    object["headerTableSize"] = Json::FromNumber(header_table_size());
+    object["maxConcurrentStreams"] = Json::FromNumber(max_concurrent_streams());
+    object["initialWindowSize"] = Json::FromNumber(initial_window_size());
+    object["maxFrameSize"] = Json::FromNumber(max_frame_size());
+    object["maxHeaderListSize"] = Json::FromNumber(max_header_list_size());
+    object["preferredReceiveCryptoMessageSize"] =
+        Json::FromNumber(preferred_receive_crypto_message_size());
+    object["enablePush"] = Json::FromBool(enable_push());
+    object["allowTrueBinaryMetadata"] =
+        Json::FromBool(allow_true_binary_metadata());
+    object["allowSecurityFrame"] = Json::FromBool(allow_security_frame());
+    return object;
+  }
+
  private:
   uint32_t header_table_size_ = 4096;
   uint32_t max_concurrent_streams_ = 4294967295u;
@@ -152,6 +169,15 @@ class Http2SettingsManager {
   Http2Settings& mutable_peer() { return peer_; }
   const Http2Settings& peer() const { return peer_; }
 
+  Json::Object ToJsonObject() const {
+    Json::Object object;
+    object["local"] = Json::FromObject(local_.ToJsonObject());
+    object["sent"] = Json::FromObject(sent_.ToJsonObject());
+    object["peer"] = Json::FromObject(peer_.ToJsonObject());
+    object["acked"] = Json::FromObject(acked_.ToJsonObject());
+    return object;
+  }
+
   std::optional<Http2SettingsFrame> MaybeSendUpdate();
   GRPC_MUST_USE_RESULT bool AckLastSend();
 

data/src/core/ext/transport/chttp2/transport/http2_status.h

@@ -19,13 +19,21 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_STATUS_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_STATUS_H
 
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <string>
+#include <variant>
+
 #include "absl/log/check.h"
 #include "absl/status/status.h"
-#include "absl/strings/string_view.h"
+#include "absl/strings/str_cat.h"
+#include "src/core/util/time.h"
 
 namespace grpc_core {
 namespace http2 {
 
+// These error codes are as per RFC9113
 // https://www.rfc-editor.org/rfc/rfc9113.html#name-error-codes
 // The RFC tells us to use 32 bit, but since this is our internal
 // representation, we can use a smaller value.
@@ -46,6 +54,355 @@ enum class Http2ErrorCode : uint8_t {
   kDoNotUse = 0xffu  // Force use of a default clause
 };
 
+inline absl::StatusCode ErrorCodeToAbslStatusCode(
+    const Http2ErrorCode http2_code,
+    const Timestamp deadline = Timestamp::InfFuture()) {
+  switch (http2_code) {
+    case Http2ErrorCode::kNoError:
+      return absl::StatusCode::kOk;
+    case Http2ErrorCode::kEnhanceYourCalm:
+      return absl::StatusCode::kResourceExhausted;
+    case Http2ErrorCode::kInadequateSecurity:
+      return absl::StatusCode::kPermissionDenied;
+    case Http2ErrorCode::kRefusedStream:
+      return absl::StatusCode::kUnavailable;
+    case Http2ErrorCode::kCancel:
+      return (Timestamp::Now() > deadline) ? absl::StatusCode::kDeadlineExceeded
+                                           : absl::StatusCode::kCancelled;
+    default:
+      return absl::StatusCode::kInternal;
+  }
+  GPR_UNREACHABLE_CODE(return absl::StatusCode::kUnknown);
+}
+
+inline Http2ErrorCode AbslStatusCodeToErrorCode(const absl::StatusCode status) {
+  switch (status) {
+    case absl::StatusCode::kOk:
+      return Http2ErrorCode::kNoError;
+    case absl::StatusCode::kCancelled:
+      return Http2ErrorCode::kCancel;
+    case absl::StatusCode::kDeadlineExceeded:
+      return Http2ErrorCode::kCancel;
+    case absl::StatusCode::kResourceExhausted:
+      return Http2ErrorCode::kEnhanceYourCalm;
+    case absl::StatusCode::kPermissionDenied:
+      return Http2ErrorCode::kInadequateSecurity;
+    case absl::StatusCode::kUnavailable:
+      return Http2ErrorCode::kRefusedStream;
+    default:
+      return Http2ErrorCode::kInternalError;
+  };
+}
+
+class GRPC_MUST_USE_RESULT Http2Status {
+ public:
+  // Classifying if an error is a stream error or a connection Http2Status must
+  // be done at the time of error object creation. Once the Http2Status object
+  // is created, its Http2ErrorType is immutable. This is intentional.
+  enum class Http2ErrorType : uint8_t {
+    kOk = 0x0,
+    kConnectionError = 0x1,
+    kStreamError = 0x2,
+  };
+
+  static Http2Status Ok() { return Http2Status(); }
+
+  // To pass message :
+  // Either pass a absl::string_view which is then copied into a std::string.
+  // Or, pass a local std::string using std::move
+  static Http2Status Http2ConnectionError(const Http2ErrorCode error_code,
+                                          std::string message) {
+    return Http2Status(error_code, Http2ErrorType::kConnectionError, message);
+  }
+
+  static Http2Status Http2StreamError(const Http2ErrorCode error_code,
+                                      std::string message) {
+    return Http2Status(error_code, Http2ErrorType::kStreamError, message);
+  }
+
+  static Http2Status AbslConnectionError(const absl::StatusCode code,
+                                         std::string message) {
+    return Http2Status(code, Http2ErrorType::kConnectionError, message);
+  }
+
+  static Http2Status AbslStreamError(const absl::StatusCode code,
+                                     std::string message) {
+    return Http2Status(code, Http2ErrorType::kStreamError, message);
+  }
+
+  GRPC_MUST_USE_RESULT Http2ErrorType GetType() const { return error_type_; }
+
+  // We only expect to use this in 2 places
+  // 1. To know what error code to send in a HTTP2 GOAWAY frame.
+  // 2. In tests
+  // Any other usage is strongly discouraged.
+  GRPC_MUST_USE_RESULT Http2ErrorCode GetConnectionErrorCode() const {
+    switch (error_type_) {
+      case Http2ErrorType::kOk:
+        CHECK(false);
+      case Http2ErrorType::kConnectionError:
+        return http2_code_;
+      case Http2ErrorType::kStreamError:
+        CHECK(false);
+      default:
+        CHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return http2_code_);
+  }
+
+  // We only expect to use this in 2 places
+  // 1. To know what error code to send in a HTTP2 RST_STREAM.
+  // 2. In tests
+  // Any other usage is strongly discouraged.
+  GRPC_MUST_USE_RESULT Http2ErrorCode GetStreamErrorCode() const {
+    switch (error_type_) {
+      case Http2ErrorType::kOk:
+        CHECK(false);
+      case Http2ErrorType::kConnectionError:
+        CHECK(false);
+      case Http2ErrorType::kStreamError:
+        return http2_code_;
+      default:
+        CHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return http2_code_);
+  }
+
+  // If an error code needs to be used along with promises, or passed out of the
+  // transport, this function should be used.
+  GRPC_MUST_USE_RESULT absl::Status GetAbslConnectionError() const {
+    switch (error_type_) {
+      case Http2ErrorType::kOk:
+        CHECK(false);
+      case Http2ErrorType::kConnectionError:
+        return AbslError();
+      case Http2ErrorType::kStreamError:
+        CHECK(false);
+      default:
+        CHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return absl::OkStatus());
+  }
+
+  // If an error code needs to be used along with promises, or passed out of the
+  // transport, this function should be used.
+  GRPC_MUST_USE_RESULT absl::Status GetAbslStreamError() const {
+    switch (error_type_) {
+      case Http2ErrorType::kOk:
+        CHECK(false);
+      case Http2ErrorType::kConnectionError:
+        CHECK(false);
+      case Http2ErrorType::kStreamError:
+        return AbslError();
+      default:
+        CHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return absl::OkStatus());
+  }
+
+  bool IsOk() const { return (http2_code_ == Http2ErrorCode::kNoError); }
+
+  std::string DebugString() const {
+    return absl::StrCat(DebugGetType(), ": {Error Code:", DebugGetCode(),
+                        ", Message:", message_, "}");
+  }
+
+  ~Http2Status() = default;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const Http2Status& frame) {
+    sink.Append(frame.DebugString());
+  }
+
+  Http2Status(Http2Status&& move_status) = default;
+
+  // Our http2_code_ code is a const, which makes an assignment illegal.
+  Http2Status& operator=(Http2Status&& rhs) = delete;
+
+  Http2Status(const Http2Status&) = delete;
+  Http2Status& operator=(const Http2Status&) = delete;
+
+ private:
+  explicit Http2Status()
+      : http2_code_(Http2ErrorCode::kNoError),
+        error_type_(Http2ErrorType::kOk),
+        absl_code_(absl::StatusCode::kOk) {
+    Validate();
+  }
+
+  explicit Http2Status(const absl::StatusCode code, const Http2ErrorType type,
+                       std::string& message)
+      : http2_code_((code == absl::StatusCode::kOk)
+                        ? Http2ErrorCode::kNoError
+                        : Http2ErrorCode::kInternalError),
+        error_type_(type),
+        absl_code_(code),
+        message_(std::move(message)) {
+    Validate();
+  }
+
+  explicit Http2Status(const Http2ErrorCode code, const Http2ErrorType type,
+                       std::string& message)
+      : http2_code_(code),
+        error_type_(type),
+        absl_code_(ErrorCodeToAbslStatusCode(http2_code_)),
+        message_(std::move(message)) {
+    Validate();
+  }
+
+  absl::Status AbslError() const {
+    if (IsOk()) return absl::OkStatus();
+    return absl::Status(absl_code_, message_);
+  }
+
+  void Validate() const {
+    DCHECK((http2_code_ == Http2ErrorCode::kNoError &&
+            error_type_ == Http2ErrorType::kOk &&
+            absl_code_ == absl::StatusCode::kOk) ||
+           (http2_code_ > Http2ErrorCode::kNoError &&
+            error_type_ > Http2ErrorType::kOk &&
+            absl_code_ != absl::StatusCode::kOk));
+    DCHECK((IsOk() && message_.empty()) || (!IsOk() && !message_.empty()));
+  }
+
+  std::string DebugGetType() const {
+    switch (error_type_) {
+      case Http2ErrorType::kOk:
+        return "Ok";
+      case Http2ErrorType::kConnectionError:
+        return "Connection Error";
+      case Http2ErrorType::kStreamError:
+        return "Stream Error";
+      default:
+        DCHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return "Invalid");
+  }
+
+  std::string DebugGetCode() const {
+    switch (http2_code_) {
+      case Http2ErrorCode::kNoError:
+        return "NO_ERROR";
+      case Http2ErrorCode::kProtocolError:
+        return "PROTOCOL_ERROR";
+      case Http2ErrorCode::kInternalError:
+        return "INTERNAL_ERROR";
+      case Http2ErrorCode::kFlowControlError:
+        return "FLOW_CONTROL_ERROR";
+      case Http2ErrorCode::kSettingsTimeout:
+        return "SETTINGS_TIMEOUT";
+      case Http2ErrorCode::kStreamClosed:
+        return "STREAM_CLOSED";
+      case Http2ErrorCode::kFrameSizeError:
+        return "FRAME_SIZE_ERROR";
+      case Http2ErrorCode::kRefusedStream:
+        return "REFUSED_STREAM";
+      case Http2ErrorCode::kCancel:
+        return "CANCEL";
+      case Http2ErrorCode::kCompressionError:
+        return "COMPRESSION_ERROR";
+      case Http2ErrorCode::kConnectError:
+        return "CONNECT_ERROR";
+      case Http2ErrorCode::kEnhanceYourCalm:
+        return "ENHANCE_YOUR_CALM";
+      case Http2ErrorCode::kInadequateSecurity:
+        return "INADEQUATE_SECURITY";
+      case Http2ErrorCode::kDoNotUse:
+        return "HTTP_1_1_REQUIRED";
+      default:
+        DCHECK(false);
+    }
+    GPR_UNREACHABLE_CODE(return "Invalid");
+  }
+
+  const Http2ErrorCode http2_code_;
+  const Http2ErrorType error_type_;
+  const absl::StatusCode absl_code_;
+
+  std::string message_;
+};
+
+// We can add more methods and helpers as needed.
+// This class is similar to ValueOrFailure but a more minamilasit version.
+// Reference :
+// https://github.com/grpc/grpc/blob/master/src/core/lib/promise/status_flag.h
+
+// A value if an operation was successful, or a Http2Status if not.
+template <typename T>
+class GRPC_MUST_USE_RESULT ValueOrHttp2Status {
+ public:
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ValueOrHttp2Status(T value) : value_(std::move(value)) {
+    DCHECK(std::holds_alternative<T>(value_));
+  }
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  ValueOrHttp2Status(Http2Status status) : value_(std::move(status)) {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    CHECK(std::get<Http2Status>(value_).GetType() !=
+          Http2Status::Http2ErrorType::kOk);
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION const T& value() const {
+    DCHECK(std::holds_alternative<T>(value_));
+    return std::get<T>(value_);
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T& value() {
+    DCHECK(std::holds_alternative<T>(value_));
+    return std::get<T>(value_);
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Http2Status TakeStatus(
+      ValueOrHttp2Status<T>&& status) {
+    DCHECK(std::holds_alternative<Http2Status>(status.value_));
+    return std::move(std::get<Http2Status>(status.value_));
+  }
+
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION bool IsOk() const {
+    return std::holds_alternative<T>(value_);
+  }
+
+  GRPC_MUST_USE_RESULT Http2Status::Http2ErrorType GetErrorType() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).GetType();
+  }
+
+  GRPC_MUST_USE_RESULT Http2ErrorCode GetConnectionErrorCode() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).GetConnectionErrorCode();
+  }
+
+  GRPC_MUST_USE_RESULT Http2ErrorCode GetStreamErrorCode() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).GetStreamErrorCode();
+  }
+
+  GRPC_MUST_USE_RESULT absl::Status GetAbslConnectionError() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).GetAbslConnectionError();
+  }
+
+  GRPC_MUST_USE_RESULT absl::Status GetAbslStreamError() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).GetAbslStreamError();
+  }
+
+  std::string DebugString() const {
+    DCHECK(std::holds_alternative<Http2Status>(value_));
+    return std::get<Http2Status>(value_).DebugString();
+  }
+
+ private:
+  std::variant<T, Http2Status> value_;
+};
+
+template <typename T>
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T TakeValue(
+    ValueOrHttp2Status<T>&& value) {
+  return std::move(value.value());
+}
+
 }  // namespace http2
 }  // namespace grpc_core