diff --git a/http2/core/http2_trace_logging.cc b/http2/core/http2_trace_logging.cc
new file mode 100644
index 0000000..d2ef702
--- /dev/null
+++ b/http2/core/http2_trace_logging.cc
@@ -0,0 +1,454 @@
+#include "http2/core/http2_trace_logging.h"
+
+#include <cstdint>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_bug_tracker.h"
+#include "common/platform/api/quiche_logging.h"
+#include "spdy/core/spdy_protocol.h"
+
+// Convenience macros for printing function arguments in log lines in the
+// format arg_name=value.
+#define FORMAT_ARG(arg) " " #arg "=" << arg
+#define FORMAT_INT_ARG(arg) " " #arg "=" << static_cast<int>(arg)
+
+// Convenience macros for printing Spdy*IR attributes in log lines in the
+// format attrib_name=value.
+#define FORMAT_ATTR(ir, attrib) " " #attrib "=" << ir.attrib()
+#define FORMAT_INT_ATTR(ir, attrib) \
+  " " #attrib "=" << static_cast<int>(ir.attrib())
+
+namespace {
+
+// Logs a container, using a user-provided object to log each individual item.
+template <typename T, typename ItemLogger>
+struct ContainerLogger {
+  explicit ContainerLogger(const T& c, ItemLogger l)
+      : container(c), item_logger(l) {}
+
+  friend std::ostream& operator<<(std::ostream& out,
+                                  const ContainerLogger& logger) {
+    out << "[";
+    auto begin = logger.container.begin();
+    for (auto it = begin; it != logger.container.end(); ++it) {
+      if (it != begin) {
+        out << ", ";
+      }
+      logger.item_logger.Log(out, *it);
+    }
+    out << "]";
+    return out;
+  }
+  const T& container;
+  ItemLogger item_logger;
+};
+
+// Returns a ContainerLogger that will log |container| using |item_logger|.
+template <typename T, typename ItemLogger>
+auto LogContainer(const T& container, ItemLogger item_logger)
+    -> decltype(ContainerLogger<T, ItemLogger>(container, item_logger)) {
+  return ContainerLogger<T, ItemLogger>(container, item_logger);
+}
+
+}  // anonymous namespace
+
+#define FORMAT_HEADER_BLOCK(ir) \
+  " header_block=" << LogContainer(ir.header_block(), LogHeaderBlockEntry())
+
+namespace http2 {
+
+using spdy::SettingsMap;
+using spdy::SpdyAltSvcIR;
+using spdy::SpdyContinuationIR;
+using spdy::SpdyDataIR;
+using spdy::SpdyGoAwayIR;
+using spdy::SpdyHeaderBlock;
+using spdy::SpdyHeadersIR;
+using spdy::SpdyPingIR;
+using spdy::SpdyPriorityIR;
+using spdy::SpdyPushPromiseIR;
+using spdy::SpdyRstStreamIR;
+using spdy::SpdySettingsIR;
+using spdy::SpdyStreamId;
+using spdy::SpdyUnknownIR;
+using spdy::SpdyWindowUpdateIR;
+
+namespace {
+
+// Defines how elements of SpdyHeaderBlocks are logged.
+struct LogHeaderBlockEntry {
+  void Log(std::ostream& out,
+           const SpdyHeaderBlock::value_type& entry) const {  // NOLINT
+    out << "\"" << entry.first << "\": \"" << entry.second << "\"";
+  }
+};
+
+// Defines how elements of SettingsMap are logged.
+struct LogSettingsEntry {
+  void Log(std::ostream& out,
+           const SettingsMap::value_type& entry) const {  // NOLINT
+    out << spdy::SettingsIdToString(entry.first) << ": " << entry.second;
+  }
+};
+
+// Defines how elements of AlternativeServiceVector are logged.
+struct LogAlternativeService {
+  void Log(std::ostream& out,
+           const spdy::SpdyAltSvcWireFormat::AlternativeService& altsvc)
+      const {  // NOLINT
+    out << "{"
+        << "protocol_id=" << altsvc.protocol_id << " host=" << altsvc.host
+        << " port=" << altsvc.port << " max_age=" << altsvc.max_age
+        << " version=";
+    for (auto v : altsvc.version) {
+      out << v << ",";
+    }
+    out << "}";
+  }
+};
+
+}  // anonymous namespace
+
+Http2TraceLogger::Http2TraceLogger(SpdyFramerVisitorInterface* parent,
+                                   absl::string_view perspective,
+                                   std::function<bool()> is_enabled,
+                                   const void* connection_id)
+    : wrapped_(parent),
+      perspective_(perspective),
+      is_enabled_(std::move(is_enabled)),
+      connection_id_(connection_id) {}
+
+Http2TraceLogger::~Http2TraceLogger() {
+  if (recording_headers_handler_ != nullptr &&
+      !recording_headers_handler_->decoded_block().empty()) {
+    HTTP2_TRACE_LOG(perspective_, is_enabled_)
+        << "connection_id=" << connection_id_
+        << " Received headers that were never logged! keys/values:"
+        << recording_headers_handler_->decoded_block().DebugString();
+  }
+}
+
+void Http2TraceLogger::OnError(Http2DecoderAdapter::SpdyFramerError error,
+                               std::string detailed_error) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnError:" << FORMAT_ARG(connection_id_)
+      << ", error=" << Http2DecoderAdapter::SpdyFramerErrorToString(error);
+  wrapped_->OnError(error, detailed_error);
+}
+
+void Http2TraceLogger::OnCommonHeader(SpdyStreamId stream_id, size_t length,
+                                      uint8_t type, uint8_t flags) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnCommonHeader:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(length) << FORMAT_INT_ARG(type)
+      << FORMAT_INT_ARG(flags);
+  wrapped_->OnCommonHeader(stream_id, length, type, flags);
+}
+
+void Http2TraceLogger::OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
+                                        bool fin) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnDataFrameHeader:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(length) << FORMAT_ARG(fin);
+  wrapped_->OnDataFrameHeader(stream_id, length, fin);
+}
+
+void Http2TraceLogger::OnStreamFrameData(SpdyStreamId stream_id,
+                                        const char* data, size_t len) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnStreamFrameData:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(len);
+  wrapped_->OnStreamFrameData(stream_id, data, len);
+}
+
+void Http2TraceLogger::OnStreamEnd(SpdyStreamId stream_id) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnStreamEnd:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id);
+  wrapped_->OnStreamEnd(stream_id);
+}
+
+void Http2TraceLogger::OnStreamPadLength(SpdyStreamId stream_id, size_t value) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnStreamPadLength:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(value);
+  wrapped_->OnStreamPadLength(stream_id, value);
+}
+
+void Http2TraceLogger::OnStreamPadding(SpdyStreamId stream_id, size_t len) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnStreamPadding:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(len);
+  wrapped_->OnStreamPadding(stream_id, len);
+}
+
+spdy::SpdyHeadersHandlerInterface* Http2TraceLogger::OnHeaderFrameStart(
+    SpdyStreamId stream_id) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnHeaderFrameStart:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id);
+  spdy::SpdyHeadersHandlerInterface* result =
+      wrapped_->OnHeaderFrameStart(stream_id);
+  recording_headers_handler_ =
+      absl::make_unique<spdy::RecordingHeadersHandler>(result);
+  result = recording_headers_handler_.get();
+  return result;
+}
+
+void Http2TraceLogger::OnHeaderFrameEnd(SpdyStreamId stream_id) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnHeaderFrameEnd:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id);
+  LogReceivedHeaders();
+  wrapped_->OnHeaderFrameEnd(stream_id);
+  recording_headers_handler_ = nullptr;
+}
+
+void Http2TraceLogger::OnRstStream(SpdyStreamId stream_id,
+                                  SpdyErrorCode error_code) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnRstStream:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id)
+      << " error_code=" << spdy::ErrorCodeToString(error_code);
+  wrapped_->OnRstStream(stream_id, error_code);
+}
+
+void Http2TraceLogger::OnSettings() { wrapped_->OnSettings(); }
+
+void Http2TraceLogger::OnSetting(SpdySettingsId id, uint32_t value) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnSetting:" << FORMAT_ARG(connection_id_)
+      << " id=" << spdy::SettingsIdToString(id) << FORMAT_ARG(value);
+  wrapped_->OnSetting(id, value);
+}
+
+void Http2TraceLogger::OnSettingsEnd() {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnSettingsEnd:" << FORMAT_ARG(connection_id_);
+  wrapped_->OnSettingsEnd();
+}
+
+void Http2TraceLogger::OnSettingsAck() {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnSettingsAck:" << FORMAT_ARG(connection_id_);
+  wrapped_->OnSettingsAck();
+}
+
+void Http2TraceLogger::OnPing(SpdyPingId unique_id, bool is_ack) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnPing:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(unique_id)
+      << FORMAT_ARG(is_ack);
+  wrapped_->OnPing(unique_id, is_ack);
+}
+
+void Http2TraceLogger::OnGoAway(SpdyStreamId last_accepted_stream_id,
+                               SpdyErrorCode error_code) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnGoAway:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(last_accepted_stream_id)
+      << " error_code=" << spdy::ErrorCodeToString(error_code);
+  wrapped_->OnGoAway(last_accepted_stream_id, error_code);
+}
+
+bool Http2TraceLogger::OnGoAwayFrameData(const char* goaway_data, size_t len) {
+  return wrapped_->OnGoAwayFrameData(goaway_data, len);
+}
+
+void Http2TraceLogger::OnHeaders(SpdyStreamId stream_id, bool has_priority,
+                                int weight, SpdyStreamId parent_stream_id,
+                                bool exclusive, bool fin, bool end) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnHeaders:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id)
+      << FORMAT_ARG(has_priority) << FORMAT_INT_ARG(weight)
+      << FORMAT_ARG(parent_stream_id) << FORMAT_ARG(exclusive)
+      << FORMAT_ARG(fin) << FORMAT_ARG(end);
+  wrapped_->OnHeaders(stream_id, has_priority, weight, parent_stream_id,
+                      exclusive, fin, end);
+}
+
+void Http2TraceLogger::OnWindowUpdate(SpdyStreamId stream_id,
+                                     int delta_window_size) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnWindowUpdate:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(delta_window_size);
+  wrapped_->OnWindowUpdate(stream_id, delta_window_size);
+}
+
+void Http2TraceLogger::OnPushPromise(SpdyStreamId original_stream_id,
+                                    SpdyStreamId promised_stream_id, bool end) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnPushPromise:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(original_stream_id) << FORMAT_ARG(promised_stream_id)
+      << FORMAT_ARG(end);
+  wrapped_->OnPushPromise(original_stream_id, promised_stream_id, end);
+}
+
+void Http2TraceLogger::OnContinuation(SpdyStreamId stream_id, bool end) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnContinuation:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_ARG(end);
+  wrapped_->OnContinuation(stream_id, end);
+}
+
+void Http2TraceLogger::OnAltSvc(
+    SpdyStreamId stream_id, absl::string_view origin,
+    const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnAltSvc:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id)
+      << FORMAT_ARG(origin) << " altsvc_vector="
+      << LogContainer(altsvc_vector, LogAlternativeService());
+  wrapped_->OnAltSvc(stream_id, origin, altsvc_vector);
+}
+
+void Http2TraceLogger::OnPriority(SpdyStreamId stream_id,
+                                 SpdyStreamId parent_stream_id, int weight,
+                                 bool exclusive) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnPriority:" << FORMAT_ARG(connection_id_) << FORMAT_ARG(stream_id)
+      << FORMAT_ARG(parent_stream_id) << FORMAT_INT_ARG(weight)
+      << FORMAT_ARG(exclusive);
+  wrapped_->OnPriority(stream_id, parent_stream_id, weight, exclusive);
+}
+
+void Http2TraceLogger::OnPriorityUpdate(
+    SpdyStreamId prioritized_stream_id,
+    absl::string_view priority_field_value) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnPriorityUpdate:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(prioritized_stream_id) << FORMAT_ARG(priority_field_value);
+  wrapped_->OnPriorityUpdate(prioritized_stream_id, priority_field_value);
+}
+
+bool Http2TraceLogger::OnUnknownFrame(SpdyStreamId stream_id,
+                                     uint8_t frame_type) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "OnUnknownFrame:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ARG(stream_id) << FORMAT_INT_ARG(frame_type);
+  return wrapped_->OnUnknownFrame(stream_id, frame_type);
+}
+
+void Http2TraceLogger::LogReceivedHeaders() const {
+  if (recording_headers_handler_ == nullptr) {
+    QUICHE_BUG(bug_2794_1) << "Cannot log headers before creating handler.";
+    return;
+  }
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Received headers;" << FORMAT_ARG(connection_id_) << " keys/values:"
+      << recording_headers_handler_->decoded_block().DebugString()
+      << " compressed_bytes="
+      << recording_headers_handler_->compressed_header_bytes()
+      << " uncompressed_bytes="
+      << recording_headers_handler_->uncompressed_header_bytes();
+}
+
+void Http2FrameLogger::VisitRstStream(const SpdyRstStreamIR& rst_stream) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyRstStreamIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(rst_stream, stream_id)
+      << " error_code=" << spdy::ErrorCodeToString(rst_stream.error_code());
+}
+
+void Http2FrameLogger::VisitSettings(const SpdySettingsIR& settings) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdySettingsIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(settings, is_ack)
+      << " values=" << LogContainer(settings.values(), LogSettingsEntry());
+}
+
+void Http2FrameLogger::VisitPing(const SpdyPingIR& ping) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyPingIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(ping, id) << FORMAT_ATTR(ping, is_ack);
+}
+
+void Http2FrameLogger::VisitGoAway(const SpdyGoAwayIR& goaway) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyGoAwayIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(goaway, last_good_stream_id)
+      << " error_code=" << spdy::ErrorCodeToString(goaway.error_code())
+      << FORMAT_ATTR(goaway, description);
+}
+
+void Http2FrameLogger::VisitHeaders(const SpdyHeadersIR& headers) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyHeadersIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(headers, stream_id) << FORMAT_ATTR(headers, fin)
+      << FORMAT_ATTR(headers, has_priority) << FORMAT_INT_ATTR(headers, weight)
+      << FORMAT_ATTR(headers, parent_stream_id)
+      << FORMAT_ATTR(headers, exclusive) << FORMAT_ATTR(headers, padded)
+      << FORMAT_ATTR(headers, padding_payload_len)
+      << FORMAT_HEADER_BLOCK(headers);
+}
+
+void Http2FrameLogger::VisitWindowUpdate(
+    const SpdyWindowUpdateIR& window_update) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyWindowUpdateIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(window_update, stream_id)
+      << FORMAT_ATTR(window_update, delta);
+}
+
+void Http2FrameLogger::VisitPushPromise(const SpdyPushPromiseIR& push_promise) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyPushPromiseIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(push_promise, stream_id) << FORMAT_ATTR(push_promise, fin)
+      << FORMAT_ATTR(push_promise, promised_stream_id)
+      << FORMAT_ATTR(push_promise, padded)
+      << FORMAT_ATTR(push_promise, padding_payload_len)
+      << FORMAT_HEADER_BLOCK(push_promise);
+}
+
+void Http2FrameLogger::VisitContinuation(
+    const SpdyContinuationIR& continuation) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyContinuationIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(continuation, stream_id)
+      << FORMAT_ATTR(continuation, end_headers);
+}
+
+void Http2FrameLogger::VisitAltSvc(const SpdyAltSvcIR& altsvc) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyAltSvcIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(altsvc, stream_id) << FORMAT_ATTR(altsvc, origin)
+      << " altsvc_vector="
+      << LogContainer(altsvc.altsvc_vector(), LogAlternativeService());
+}
+
+void Http2FrameLogger::VisitPriority(const SpdyPriorityIR& priority) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyPriorityIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(priority, stream_id)
+      << FORMAT_ATTR(priority, parent_stream_id)
+      << FORMAT_INT_ATTR(priority, weight) << FORMAT_ATTR(priority, exclusive);
+}
+
+void Http2FrameLogger::VisitData(const SpdyDataIR& data) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyDataIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(data, stream_id) << FORMAT_ATTR(data, fin)
+      << " data_len=" << data.data_len() << FORMAT_ATTR(data, padded)
+      << FORMAT_ATTR(data, padding_payload_len);
+}
+
+void Http2FrameLogger::VisitPriorityUpdate(
+    const spdy::SpdyPriorityUpdateIR& priority_update) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyPriorityUpdateIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(priority_update, stream_id)
+      << FORMAT_ATTR(priority_update, prioritized_stream_id)
+      << FORMAT_ATTR(priority_update, priority_field_value);
+}
+
+void Http2FrameLogger::VisitAcceptCh(
+    const spdy::SpdyAcceptChIR& /*accept_ch*/) {
+  QUICHE_BUG(bug_2794_2)
+      << "Sending ACCEPT_CH frames is currently unimplemented.";
+}
+
+void Http2FrameLogger::VisitUnknown(const SpdyUnknownIR& ir) {
+  HTTP2_TRACE_LOG(perspective_, is_enabled_)
+      << "Wrote SpdyUnknownIR:" << FORMAT_ARG(connection_id_)
+      << FORMAT_ATTR(ir, stream_id) << FORMAT_INT_ATTR(ir, type)
+      << FORMAT_INT_ATTR(ir, flags) << FORMAT_ATTR(ir, length);
+}
+
+}  // namespace http2
diff --git a/http2/core/http2_trace_logging.h b/http2/core/http2_trace_logging.h
new file mode 100644
index 0000000..e1185bf
--- /dev/null
+++ b/http2/core/http2_trace_logging.h
@@ -0,0 +1,140 @@
+// Classes and utilities for supporting HTTP/2 trace logging, which logs
+// information about all control and data frames sent and received over
+// HTTP/2 connections.
+
+#ifndef QUICHE_HTTP2_CORE_HTTP2_TRACE_LOGGING_H_
+#define QUICHE_HTTP2_CORE_HTTP2_TRACE_LOGGING_H_
+
+#include <cstdint>
+
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_export.h"
+#include "common/platform/api/quiche_logging.h"
+#include "spdy/core/http2_frame_decoder_adapter.h"
+#include "spdy/core/recording_headers_handler.h"
+#include "spdy/core/spdy_headers_handler_interface.h"
+#include "spdy/core/spdy_protocol.h"
+
+// Logging macro to use for all HTTP/2 trace logging. Iff trace logging is
+// enabled, logs at level INFO with a common prefix prepended (to facilitate
+// post-hoc filtering of trace logging output).
+#define HTTP2_TRACE_LOG(perspective, is_enabled) \
+  QUICHE_LOG_IF(INFO, is_enabled()) << "[HTTP2_TRACE " << perspective << "] "
+
+namespace http2 {
+
+// Intercepts deframing events to provide detailed logs. Intended to be used for
+// manual debugging.
+//
+// Note any new methods in SpdyFramerVisitorInterface MUST be overridden here to
+// properly forward the event. This could be ensured by making every event in
+// SpdyFramerVisitorInterface a pure virtual.
+class QUICHE_EXPORT_PRIVATE Http2TraceLogger
+    : public spdy::SpdyFramerVisitorInterface {
+ public:
+  typedef spdy::SpdyAltSvcWireFormat SpdyAltSvcWireFormat;
+  typedef spdy::SpdyErrorCode SpdyErrorCode;
+  typedef spdy::SpdyFramerVisitorInterface SpdyFramerVisitorInterface;
+  typedef spdy::SpdyPingId SpdyPingId;
+  typedef spdy::SpdyPriority SpdyPriority;
+  typedef spdy::SpdySettingsId SpdySettingsId;
+  typedef spdy::SpdyStreamId SpdyStreamId;
+
+  Http2TraceLogger(SpdyFramerVisitorInterface* parent,
+                   absl::string_view perspective,
+                   std::function<bool()> is_enabled, const void* connection_id);
+  ~Http2TraceLogger() override;
+
+  Http2TraceLogger(const Http2TraceLogger&) = delete;
+  Http2TraceLogger& operator=(const Http2TraceLogger&) = delete;
+
+  void OnError(http2::Http2DecoderAdapter::SpdyFramerError error,
+               std::string detailed_error) override;
+  void OnCommonHeader(SpdyStreamId stream_id, size_t length, uint8_t type,
+                      uint8_t flags) override;
+  spdy::SpdyHeadersHandlerInterface* OnHeaderFrameStart(
+      SpdyStreamId stream_id) override;
+  void OnHeaderFrameEnd(SpdyStreamId stream_id) override;
+  void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
+                         bool fin) override;
+  void OnStreamFrameData(SpdyStreamId stream_id, const char* data,
+                         size_t len) override;
+  void OnStreamEnd(SpdyStreamId stream_id) override;
+  void OnStreamPadLength(SpdyStreamId stream_id, size_t value) override;
+  void OnStreamPadding(SpdyStreamId stream_id, size_t len) override;
+  void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override;
+  void OnSetting(spdy::SpdySettingsId id, uint32_t value) override;
+  void OnPing(SpdyPingId unique_id, bool is_ack) override;
+  void OnSettings() override;
+  void OnSettingsEnd() override;
+  void OnSettingsAck() override;
+  void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                SpdyErrorCode error_code) override;
+  bool OnGoAwayFrameData(const char* goaway_data, size_t len) override;
+  void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
+                 SpdyStreamId parent_stream_id, bool exclusive, bool fin,
+                 bool end) override;
+  void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override;
+  void OnPushPromise(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
+                     bool end) override;
+  void OnContinuation(SpdyStreamId stream_id, bool end) override;
+  void OnAltSvc(SpdyStreamId stream_id, absl::string_view origin,
+                const SpdyAltSvcWireFormat::AlternativeServiceVector&
+                    altsvc_vector) override;
+  void OnPriority(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                  int weight, bool exclusive) override;
+  void OnPriorityUpdate(SpdyStreamId prioritized_stream_id,
+                        absl::string_view priority_field_value) override;
+  bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override;
+
+ private:
+  void LogReceivedHeaders() const;
+
+  std::unique_ptr<spdy::RecordingHeadersHandler> recording_headers_handler_;
+
+  SpdyFramerVisitorInterface* wrapped_;
+  const absl::string_view perspective_;
+  const std::function<bool()> is_enabled_;
+  const void* connection_id_;
+};
+
+// Visitor to log control frames that have been written.
+class QUICHE_EXPORT_PRIVATE Http2FrameLogger : public spdy::SpdyFrameVisitor {
+ public:
+  // This class will preface all of its log messages with the value of
+  // |connection_id| in hexadecimal.
+  Http2FrameLogger(absl::string_view perspective,
+                   std::function<bool()> is_enabled, const void* connection_id)
+      : perspective_(perspective),
+        is_enabled_(std::move(is_enabled)),
+        connection_id_(connection_id) {}
+
+  Http2FrameLogger(const Http2FrameLogger&) = delete;
+  Http2FrameLogger& operator=(const Http2FrameLogger&) = delete;
+
+  void VisitRstStream(const spdy::SpdyRstStreamIR& rst_stream) override;
+  void VisitSettings(const spdy::SpdySettingsIR& settings) override;
+  void VisitPing(const spdy::SpdyPingIR& ping) override;
+  void VisitGoAway(const spdy::SpdyGoAwayIR& goaway) override;
+  void VisitHeaders(const spdy::SpdyHeadersIR& headers) override;
+  void VisitWindowUpdate(
+      const spdy::SpdyWindowUpdateIR& window_update) override;
+  void VisitPushPromise(const spdy::SpdyPushPromiseIR& push_promise) override;
+  void VisitContinuation(const spdy::SpdyContinuationIR& continuation) override;
+  void VisitAltSvc(const spdy::SpdyAltSvcIR& altsvc) override;
+  void VisitPriority(const spdy::SpdyPriorityIR& priority) override;
+  void VisitData(const spdy::SpdyDataIR& data) override;
+  void VisitPriorityUpdate(
+      const spdy::SpdyPriorityUpdateIR& priority_update) override;
+  void VisitAcceptCh(const spdy::SpdyAcceptChIR& accept_ch) override;
+  void VisitUnknown(const spdy::SpdyUnknownIR& ir) override;
+
+ private:
+  const absl::string_view perspective_;
+  const std::function<bool()> is_enabled_;
+  const void* connection_id_;
+};
+
+}  // namespace http2
+
+#endif  // QUICHE_HTTP2_CORE_HTTP2_TRACE_LOGGING_H_