grpc 1.70.1 → 1.72.0

data/src/core/telemetry/metrics.h

@@ -209,7 +209,7 @@ class GlobalInstrumentsRegistry {
       absl::FunctionRef<void(const GlobalInstrumentDescriptor&)> f);
   static const GlobalInstrumentDescriptor& GetInstrumentDescriptor(
       GlobalInstrumentHandle handle);
-  static absl::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
+  static std::optional<GlobalInstrumentsRegistry::GlobalInstrumentHandle>
   FindInstrumentByName(absl::string_view name);
 
  private:
@@ -275,6 +275,10 @@ class StatsPlugin {
   class ScopeConfig {
    public:
     virtual ~ScopeConfig() = default;
+
+    // NOTE: This is safe to invoke ONLY if both ScopeConfig objects
+    // come from the same StatsPlugin.
+    virtual int Compare(const ScopeConfig& other) const = 0;
   };
 
   virtual ~StatsPlugin() = default;
@@ -369,7 +373,8 @@ class GlobalStatsPluginRegistry {
   // stats plugins. They got a stats plugin group which contains all the stats
   // plugins for a specific scope and all operations on the stats plugin group
   // will be applied to all the stats plugins within the group.
-  class StatsPluginGroup {
+  class StatsPluginGroup
+      : public std::enable_shared_from_this<StatsPluginGroup> {
    public:
     // Adds a stats plugin and a scope config (per-channel or per-server) to the
     // group.
@@ -471,6 +476,12 @@ class GlobalStatsPluginRegistry {
     // within the group to \a call_context.
     void AddServerCallTracers(Arena* arena);
 
+    static absl::string_view ChannelArgName() {
+      return "grpc.internal.stats_plugin_group";
+    }
+    static int ChannelArgsCompare(const StatsPluginGroup* a,
+                                  const StatsPluginGroup* b);
+
    private:
     friend class RegisteredMetricCallback;
 
@@ -479,7 +490,6 @@ class GlobalStatsPluginRegistry {
       std::shared_ptr<StatsPlugin> plugin;
     };
 
-    // C++17 has fold expression that may simplify this.
     template <GlobalInstrumentsRegistry::ValueType V,
               GlobalInstrumentsRegistry::InstrumentType I, size_t M, size_t N>
     static constexpr void AssertIsCallbackGaugeHandle(
@@ -491,11 +501,6 @@ class GlobalStatsPluginRegistry {
           I == GlobalInstrumentsRegistry::InstrumentType::kCallbackGauge,
           "InstrumentType must be kCallbackGauge");
     }
-    template <typename T, typename... Args>
-    static constexpr void AssertIsCallbackGaugeHandle(T t, Args&&... args) {
-      AssertIsCallbackGaugeHandle(t);
-      AssertIsCallbackGaugeHandle(args...);
-    }
 
     std::vector<PluginState> plugins_state_;
   };
@@ -505,9 +510,10 @@ class GlobalStatsPluginRegistry {
 
   // The following functions can be invoked to get a StatsPluginGroup for
   // a specified scope.
-  static StatsPluginGroup GetStatsPluginsForChannel(
+  static std::shared_ptr<StatsPluginGroup> GetStatsPluginsForChannel(
       const experimental::StatsPluginChannelScope& scope);
-  static StatsPluginGroup GetStatsPluginsForServer(const ChannelArgs& args);
+  static std::shared_ptr<StatsPluginGroup> GetStatsPluginsForServer(
+      const ChannelArgs& args);
 
  private:
   struct GlobalStatsPluginNode {
@@ -557,7 +563,7 @@ inline std::unique_ptr<RegisteredMetricCallback>
 GlobalStatsPluginRegistry::StatsPluginGroup::RegisterCallback(
     absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
     Duration min_interval, Args... args) {
-  AssertIsCallbackGaugeHandle(args...);
+  (AssertIsCallbackGaugeHandle(args), ...);
   return std::make_unique<RegisteredMetricCallback>(
       *this, std::move(callback),
       std::vector<GlobalInstrumentsRegistry::GlobalInstrumentHandle>{args...},

data/src/core/telemetry/stats_data.cc

@@ -119,6 +119,20 @@ Histogram_1800000_40 operator-(const Histogram_1800000_40& left,
   }
   return result;
 }
+void HistogramCollector_16777216_50::Collect(
+    Histogram_16777216_50* result) const {
+  for (int i = 0; i < 50; i++) {
+    result->buckets_[i] += buckets_[i].load(std::memory_order_relaxed);
+  }
+}
+Histogram_16777216_50 operator-(const Histogram_16777216_50& left,
+                                const Histogram_16777216_50& right) {
+  Histogram_16777216_50 result;
+  for (int i = 0; i < 50; i++) {
+    result.buckets_[i] = left.buckets_[i] - right.buckets_[i];
+  }
+  return result;
+}
 const absl::string_view
     GlobalStats::counter_name[static_cast<int>(Counter::COUNT)] = {
         "client_calls_created",
@@ -226,6 +240,9 @@ const absl::string_view
         "http2_transport_remote_window_update",
         "http2_transport_window_update_period",
         "http2_stream_window_update_period",
+        "http2_write_target_size",
+        "http2_write_data_frame_size",
+        "http2_read_data_frame_size",
         "wrr_subchannel_list_size",
         "wrr_subchannel_ready_size",
         "work_serializer_run_time_ms",
@@ -269,6 +286,9 @@ const absl::string_view GlobalStats::histogram_doc[static_cast<int>(
     "Transport window update sent by peer",
     "Period in milliseconds at which peer sends transport window update",
     "Period in milliseconds at which peer sends stream window update",
+    "Number of bytes targetted for http2 writes",
+    "Number of bytes for each data frame written",
+    "Number of bytes for each data frame read",
     "Number of subchannels in a subchannel list at picker creation time",
     "Number of READY subchannels in a subchannel list at picker creation time",
     "Number of milliseconds work serializers run for",
@@ -333,6 +353,20 @@ const int kStatsTable12[41] = {
 const uint8_t kStatsTable13[37] = {
     4,  5,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
     22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39};
+const int kStatsTable14[51] = {
+    0,       1,        2,       3,       5,       7,       10,      14,
+    20,      28,       39,      54,      75,      104,     144,     200,
+    277,     383,      530,     733,     1014,    1402,    1939,    2681,
+    3706,    5123,     7082,    9790,    13533,   18707,   25859,   35746,
+    49412,   68303,    94416,   130512,  180408,  249380,  344720,  476509,
+    658682,  910501,   1258592, 1739760, 2404882, 3324285, 4595181, 6351949,
+    8780340, 12137120, 16777216};
+const uint8_t kStatsTable15[88] = {
+    4,  4,  5,  5,  6,  6,  7,  7,  8,  8,  9,  9,  10, 11, 11, 12, 12, 13,
+    13, 14, 14, 15, 15, 16, 16, 17, 18, 18, 18, 19, 20, 20, 21, 21, 22, 22,
+    23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31, 32,
+    32, 33, 33, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40, 40, 41, 42,
+    42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, 49, 50, 50};
 }  // namespace
 int Histogram_100000_20::BucketFor(int value) {
   if (value < 3) {
@@ -483,6 +517,25 @@ int Histogram_1800000_40::BucketFor(int value) {
     }
   }
 }
+int Histogram_16777216_50::BucketFor(int value) {
+  if (value < 4) {
+    if (value < 0) {
+      return 0;
+    } else {
+      return value;
+    }
+  } else {
+    if (value < 14680065) {
+      DblUint val;
+      val.dbl = value;
+      const int bucket =
+          kStatsTable15[((val.uint - 4616189618054758400ull) >> 50)];
+      return bucket - (value < kStatsTable14[bucket]);
+    } else {
+      return 49;
+    }
+  }
+}
 GlobalStats::GlobalStats()
     : client_calls_created{0},
       server_calls_created{0},
@@ -556,13 +609,13 @@ HistogramView GlobalStats::histogram(Histogram which) const {
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            http2_header_table_size.buckets()};
     case Histogram::kHttp2InitialWindowSize:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+      return HistogramView{&Histogram_16777216_50::BucketFor, kStatsTable14, 50,
                            http2_initial_window_size.buckets()};
     case Histogram::kHttp2MaxConcurrentStreams:
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
                            http2_max_concurrent_streams.buckets()};
     case Histogram::kHttp2MaxFrameSize:
-      return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
+      return HistogramView{&Histogram_16777216_50::BucketFor, kStatsTable14, 50,
                            http2_max_frame_size.buckets()};
     case Histogram::kHttp2MaxHeaderListSize:
       return HistogramView{&Histogram_16777216_20::BucketFor, kStatsTable6, 20,
@@ -583,6 +636,15 @@ HistogramView GlobalStats::histogram(Histogram which) const {
     case Histogram::kHttp2StreamWindowUpdatePeriod:
       return HistogramView{&Histogram_100000_20::BucketFor, kStatsTable0, 20,
                            http2_stream_window_update_period.buckets()};
+    case Histogram::kHttp2WriteTargetSize:
+      return HistogramView{&Histogram_16777216_50::BucketFor, kStatsTable14, 50,
+                           http2_write_target_size.buckets()};
+    case Histogram::kHttp2WriteDataFrameSize:
+      return HistogramView{&Histogram_16777216_50::BucketFor, kStatsTable14, 50,
+                           http2_write_data_frame_size.buckets()};
+    case Histogram::kHttp2ReadDataFrameSize:
+      return HistogramView{&Histogram_16777216_50::BucketFor, kStatsTable14, 50,
+                           http2_read_data_frame_size.buckets()};
     case Histogram::kWrrSubchannelListSize:
       return HistogramView{&Histogram_10000_20::BucketFor, kStatsTable10, 20,
                            wrr_subchannel_list_size.buckets()};
@@ -744,6 +806,11 @@ std::unique_ptr<GlobalStats> GlobalStatsCollector::Collect() const {
         &result->http2_transport_window_update_period);
     data.http2_stream_window_update_period.Collect(
         &result->http2_stream_window_update_period);
+    data.http2_write_target_size.Collect(&result->http2_write_target_size);
+    data.http2_write_data_frame_size.Collect(
+        &result->http2_write_data_frame_size);
+    data.http2_read_data_frame_size.Collect(
+        &result->http2_read_data_frame_size);
     data.wrr_subchannel_list_size.Collect(&result->wrr_subchannel_list_size);
     data.wrr_subchannel_ready_size.Collect(&result->wrr_subchannel_ready_size);
     data.work_serializer_run_time_ms.Collect(
@@ -874,6 +941,12 @@ std::unique_ptr<GlobalStats> GlobalStats::Diff(const GlobalStats& other) const {
   result->http2_stream_window_update_period =
       http2_stream_window_update_period -
       other.http2_stream_window_update_period;
+  result->http2_write_target_size =
+      http2_write_target_size - other.http2_write_target_size;
+  result->http2_write_data_frame_size =
+      http2_write_data_frame_size - other.http2_write_data_frame_size;
+  result->http2_read_data_frame_size =
+      http2_read_data_frame_size - other.http2_read_data_frame_size;
   result->wrr_subchannel_list_size =
       wrr_subchannel_list_size - other.wrr_subchannel_list_size;
   result->wrr_subchannel_ready_size =

data/src/core/telemetry/stats_data.h

@@ -196,6 +196,30 @@ class HistogramCollector_1800000_40 {
  private:
   std::atomic<uint64_t> buckets_[40]{};
 };
+class HistogramCollector_16777216_50;
+class Histogram_16777216_50 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 50; }
+  friend Histogram_16777216_50 operator-(const Histogram_16777216_50& left,
+                                         const Histogram_16777216_50& right);
+
+ private:
+  friend class HistogramCollector_16777216_50;
+  uint64_t buckets_[50]{};
+};
+class HistogramCollector_16777216_50 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_16777216_50::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_16777216_50* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[50]{};
+};
 struct GlobalStats {
   enum class Counter {
     kClientCallsCreated,
@@ -257,6 +281,9 @@ struct GlobalStats {
     kHttp2TransportRemoteWindowUpdate,
     kHttp2TransportWindowUpdatePeriod,
     kHttp2StreamWindowUpdatePeriod,
+    kHttp2WriteTargetSize,
+    kHttp2WriteDataFrameSize,
+    kHttp2ReadDataFrameSize,
     kWrrSubchannelListSize,
     kWrrSubchannelReadySize,
     kWorkSerializerRunTimeMs,
@@ -338,15 +365,18 @@ struct GlobalStats {
   Histogram_65536_26 http2_metadata_size;
   Histogram_1800000_40 http2_hpack_entry_lifetime;
   Histogram_16777216_20 http2_header_table_size;
-  Histogram_16777216_20 http2_initial_window_size;
+  Histogram_16777216_50 http2_initial_window_size;
   Histogram_16777216_20 http2_max_concurrent_streams;
-  Histogram_16777216_20 http2_max_frame_size;
+  Histogram_16777216_50 http2_max_frame_size;
   Histogram_16777216_20 http2_max_header_list_size;
   Histogram_16777216_20 http2_preferred_receive_crypto_message_size;
   Histogram_16777216_20 http2_stream_remote_window_update;
   Histogram_16777216_20 http2_transport_remote_window_update;
   Histogram_100000_20 http2_transport_window_update_period;
   Histogram_100000_20 http2_stream_window_update_period;
+  Histogram_16777216_50 http2_write_target_size;
+  Histogram_16777216_50 http2_write_data_frame_size;
+  Histogram_16777216_50 http2_read_data_frame_size;
   Histogram_10000_20 wrr_subchannel_list_size;
   Histogram_10000_20 wrr_subchannel_ready_size;
   Histogram_100000_20 work_serializer_run_time_ms;
@@ -557,6 +587,15 @@ class GlobalStatsCollector {
   void IncrementHttp2StreamWindowUpdatePeriod(int value) {
     data_.this_cpu().http2_stream_window_update_period.Increment(value);
   }
+  void IncrementHttp2WriteTargetSize(int value) {
+    data_.this_cpu().http2_write_target_size.Increment(value);
+  }
+  void IncrementHttp2WriteDataFrameSize(int value) {
+    data_.this_cpu().http2_write_data_frame_size.Increment(value);
+  }
+  void IncrementHttp2ReadDataFrameSize(int value) {
+    data_.this_cpu().http2_read_data_frame_size.Increment(value);
+  }
   void IncrementWrrSubchannelListSize(int value) {
     data_.this_cpu().wrr_subchannel_list_size.Increment(value);
   }
@@ -668,15 +707,18 @@ class GlobalStatsCollector {
     HistogramCollector_65536_26 http2_metadata_size;
     HistogramCollector_1800000_40 http2_hpack_entry_lifetime;
     HistogramCollector_16777216_20 http2_header_table_size;
-    HistogramCollector_16777216_20 http2_initial_window_size;
+    HistogramCollector_16777216_50 http2_initial_window_size;
     HistogramCollector_16777216_20 http2_max_concurrent_streams;
-    HistogramCollector_16777216_20 http2_max_frame_size;
+    HistogramCollector_16777216_50 http2_max_frame_size;
     HistogramCollector_16777216_20 http2_max_header_list_size;
     HistogramCollector_16777216_20 http2_preferred_receive_crypto_message_size;
     HistogramCollector_16777216_20 http2_stream_remote_window_update;
     HistogramCollector_16777216_20 http2_transport_remote_window_update;
     HistogramCollector_100000_20 http2_transport_window_update_period;
     HistogramCollector_100000_20 http2_stream_window_update_period;
+    HistogramCollector_16777216_50 http2_write_target_size;
+    HistogramCollector_16777216_50 http2_write_data_frame_size;
+    HistogramCollector_16777216_50 http2_read_data_frame_size;
     HistogramCollector_10000_20 wrr_subchannel_list_size;
     HistogramCollector_10000_20 wrr_subchannel_ready_size;
     HistogramCollector_100000_20 work_serializer_run_time_ms;

data/src/core/telemetry/tcp_tracer.h

@@ -23,15 +23,94 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 
-// Interface for TCP tracer implementations. Created by CallTracerInterface.
-class TcpTracerInterface {
+struct TcpConnectionMetrics {
+  // Congestion control name.
+  std::string congestion_ctrl;
+  // Delivery rate in Bps.
+  std::optional<uint64_t> delivery_rate;
+  // Total bytes retransmitted so far.
+  std::optional<uint64_t> data_retx;
+  // Total bytes sent so far.
+  std::optional<uint64_t> data_sent;
+  // Total packets lost so far.
+  // Includes lost or spuriously retransmitted packets.
+  std::optional<uint32_t> packet_retx;
+  // Total packets spuriously retransmitted so far.
+  std::optional<uint32_t> packet_spurious_retx;
+  // Total packets sent so far.
+  std::optional<uint32_t> packet_sent;
+  // Total packets delivered so far.
+  std::optional<uint32_t> packet_delivered;
+  // Total packets delivered so far with ECE marked.
+  // This metric is smaller than or equal to packet_delivered.
+  std::optional<uint32_t> packet_delivered_ce;
+  // Total bytes in write queue but not sent.
+  std::optional<uint64_t> data_notsent;
+  // Minimum RTT observed in usec.
+  std::optional<uint32_t> min_rtt;
+  // Smoothed RTT in usec
+  std::optional<uint32_t> srtt;
+  // TTL or hop limit of a packet received
+  // Only available with ACKED timestamps.
+  std::optional<uint32_t> ttl;
+  // Represents the number of recurring retransmissions of
+  // the first sequence that is not acknowledged yet.
+  std::optional<uint32_t> recurring_retrans;
+  // Network RTT using hardware timestamps (in usec).
+  // A value of -1 indicates that net_rtt could not be measured.
+  std::optional<int32_t> net_rtt_usec;
+  // Timeout-triggered rehash attempts.
+  std::optional<uint32_t> timeout_rehash;
+  // Rehash due to ECN congestion.
+  std::optional<uint32_t> ecn_rehash;
+  // Earliest departure time (CLOCK_MONOTONIC).
+  // Only available with SCHEDULED and SENT timestamps.
+  std::optional<uint64_t> edt;
+  // If the delivery rate is limited by the application, this is set to
+  // true.
+  std::optional<bool> is_delivery_rate_app_limited;
+  // Pacing rate of the connection in Bps.
+  std::optional<uint64_t> pacing_rate;
+  // Send congestion window in packets.
+  std::optional<uint32_t> congestion_window;
+  // Maximum degree of reordering (i.e., maximum number of packets reordered)
+  // on the connection.
+  std::optional<uint32_t> reordering;
+  // Cumulative duration (in usec) that the transport protocol
+  // was busy sending time.
+  std::optional<uint64_t> busy_usec;
+  // Cumulative duration (in usec) that the transport protocol
+  // was limited by the receive window size.
+  std::optional<uint64_t> rwnd_limited_usec;
+  // Cumulative duration (in usec) that the transport protocol
+  // was limited by the send buffer size.
+  std::optional<uint64_t> sndbuf_limited_usec;
+  // Slow start size threshold in packets.
+  // Set to TCP_INFINITE_SSTHRESH when still in slow start.
+  std::optional<uint32_t> snd_ssthresh;
+  // The extra time it takes for the receiver to generate the
+  // acknowledgement after receiving the last packet. This metric is not
+  // cumulative. Only available with ACKED timestamps.
+  std::optional<uint32_t> time_to_ack_usec;
+  // Last socket error code. Only populated for CLOSED timestamps.
+  std::optional<uint32_t> socket_errno;
+  // Peer's receive window after scaling (tcpi_snd_wnd).
+  // Only available with SENDMSG timestamps.
+  std::optional<uint32_t> peer_rwnd;
+  // Receive queue drops.
+  std::optional<uint32_t> rcvq_drops;
+  // The NIC Rx delay reported by the remote host.
+  std::optional<uint32_t> nic_rx_delay_usec;
+};
+
+class TcpCallTracer {
  public:
   enum class Type {
     kUnknown = 0,
@@ -49,93 +128,20 @@ class TcpTracerInterface {
     kClosed,
   };
 
-  struct ConnectionMetrics {
-    // Congestion control name.
-    std::string congestion_ctrl;
-    // Delivery rate in Bps.
-    absl::optional<uint64_t> delivery_rate;
-    // Total bytes retransmitted so far.
-    absl::optional<uint64_t> data_retx;
-    // Total bytes sent so far.
-    absl::optional<uint64_t> data_sent;
-    // Total packets lost so far.
-    // Includes lost or spuriously retransmitted packets.
-    absl::optional<uint32_t> packet_retx;
-    // Total packets spuriously retransmitted so far.
-    absl::optional<uint32_t> packet_spurious_retx;
-    // Total packets sent so far.
-    absl::optional<uint32_t> packet_sent;
-    // Total packets delivered so far.
-    absl::optional<uint32_t> packet_delivered;
-    // Total packets delivered so far with ECE marked.
-    // This metric is smaller than or equal to packet_delivered.
-    absl::optional<uint32_t> packet_delivered_ce;
-    // Total bytes in write queue but not sent.
-    absl::optional<uint64_t> data_notsent;
-    // Minimum RTT observed in usec.
-    absl::optional<uint32_t> min_rtt;
-    // Smoothed RTT in usec
-    absl::optional<uint32_t> srtt;
-    // TTL or hop limit of a packet received
-    // Only available with ACKED timestamps.
-    absl::optional<uint32_t> ttl;
-    // Represents the number of recurring retransmissions of
-    // the first sequence that is not acknowledged yet.
-    absl::optional<uint32_t> recurring_retrans;
-    // Network RTT using hardware timestamps (in usec).
-    // A value of -1 indicates that net_rtt could not be measured.
-    absl::optional<int32_t> net_rtt_usec;
-    // Timeout-triggered rehash attempts.
-    absl::optional<uint32_t> timeout_rehash;
-    // Rehash due to ECN congestion.
-    absl::optional<uint32_t> ecn_rehash;
-    // Earliest departure time (CLOCK_MONOTONIC).
-    // Only available with SCHEDULED and SENT timestamps.
-    absl::optional<uint64_t> edt;
-    // If the delivery rate is limited by the application, this is set to
-    // true.
-    absl::optional<bool> is_delivery_rate_app_limited;
-    // Pacing rate of the connection in Bps.
-    absl::optional<uint64_t> pacing_rate;
-    // Send congestion window in packets.
-    absl::optional<uint32_t> congestion_window;
-    // Maximum degree of reordering (i.e., maximum number of packets reodered)
-    // on the connection.
-    absl::optional<uint32_t> reordering;
-    // Cumulative duration (in usec) that the transport protocol
-    // was busy sending time.
-    absl::optional<uint64_t> busy_usec;
-    // Cumulative duration (in usec) that the transport protocol
-    // was limited by the receive window size.
-    absl::optional<uint64_t> rwnd_limited_usec;
-    // Cumulative duration (in usec) that the transport protocol
-    // was limited by the send buffer size.
-    absl::optional<uint64_t> sndbuf_limited_usec;
-    // Slow start size threshold in packets.
-    // Set to TCP_INFINITE_SSTHRESH when still in slow start.
-    absl::optional<uint32_t> snd_ssthresh;
-    // The extra time it takes for the receiver to generate the
-    // acknowledgement after receiving the last packet. This metric is not
-    // cumulative. Only available with ACKED timestamps.
-    absl::optional<uint32_t> time_to_ack_usec;
-    // Last socket error code. Only populated for CLOSED timestamps.
-    absl::optional<uint32_t> socket_errno;
-    // Peer's receive window after scaling (tcpi_snd_wnd).
-    // Only available with SENDMSG timestamps.
-    absl::optional<uint32_t> peer_rwnd;
-    // Receive queue drops.
-    absl::optional<uint32_t> rcvq_drops;
-    // The NIC Rx delay reported by the remote host.
-    absl::optional<uint32_t> nic_rx_delay_usec;
-  };
+  virtual ~TcpCallTracer() = default;
 
-  virtual ~TcpTracerInterface() = default;
   // Records a per-message event with an optional snapshot of connection
   // metrics.
   virtual void RecordEvent(Type type, absl::Time time, size_t byte_offset,
-                           absl::optional<ConnectionMetrics> metrics) = 0;
+                           std::optional<TcpConnectionMetrics> metrics) = 0;
+};
+
+class TcpConnectionTracer {
+ public:
+  virtual ~TcpConnectionTracer() = default;
+
   // Records a snapshot of connection metrics.
-  virtual void RecordConnectionMetrics(ConnectionMetrics metrics) = 0;
+  virtual void RecordConnectionMetrics(TcpConnectionMetrics metrics) = 0;
 };
 
 }  // namespace grpc_core

data/src/core/{lib/security/context/security_context.cc → transport/auth_context.cc}

@@ -1,5 +1,4 @@
 //
-//
 // Copyright 2015 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,9 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-//
 
-#include "src/core/lib/security/context/security_context.h"
+#include "src/core/transport/auth_context.h"
 
 #include <grpc/credentials.h>
 #include <grpc/grpc_security.h>
@@ -33,61 +31,9 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/util/ref_counted_ptr.h"
 
-// --- grpc_call ---
-
-grpc_call_error grpc_call_set_credentials(grpc_call* call,
-                                          grpc_call_credentials* creds) {
-  grpc_core::ExecCtx exec_ctx;
-  grpc_client_security_context* ctx = nullptr;
-  GRPC_TRACE_LOG(api, INFO) << "grpc_call_set_credentials(call=" << call
-                            << ", creds=" << creds << ")";
-  if (!grpc_call_is_client(call)) {
-    LOG(ERROR) << "Method is client-side only.";
-    return GRPC_CALL_ERROR_NOT_ON_SERVER;
-  }
-  auto* arena = grpc_call_get_arena(call);
-  ctx = grpc_core::DownCast<grpc_client_security_context*>(
-      arena->GetContext<grpc_core::SecurityContext>());
-  if (ctx == nullptr) {
-    ctx = grpc_client_security_context_create(arena, creds);
-    arena->SetContext<grpc_core::SecurityContext>(ctx);
-  } else {
-    ctx->creds = creds != nullptr ? creds->Ref() : nullptr;
-  }
-
-  return GRPC_CALL_OK;
-}
-
-grpc_auth_context* grpc_call_auth_context(grpc_call* call) {
-  auto* sec_ctx =
-      grpc_call_get_arena(call)->GetContext<grpc_core::SecurityContext>();
-  GRPC_TRACE_LOG(api, INFO) << "grpc_call_auth_context(call=" << call << ")";
-  if (sec_ctx == nullptr) return nullptr;
-  if (grpc_call_is_client(call)) {
-    auto* sc = grpc_core::DownCast<grpc_client_security_context*>(sec_ctx);
-    if (sc->auth_context == nullptr) {
-      return nullptr;
-    } else {
-      return sc->auth_context
-          ->Ref(DEBUG_LOCATION, "grpc_call_auth_context client")
-          .release();
-    }
-  } else {
-    auto* sc = grpc_core::DownCast<grpc_server_security_context*>(sec_ctx);
-    if (sc->auth_context == nullptr) {
-      return nullptr;
-    } else {
-      return sc->auth_context
-          ->Ref(DEBUG_LOCATION, "grpc_call_auth_context server")
-          .release();
-    }
-  }
-}
-
 void grpc_auth_context_release(grpc_auth_context* context) {
   GRPC_TRACE_LOG(api, INFO)
       << "grpc_auth_context_release(context=" << context << ")";
@@ -95,47 +41,6 @@ void grpc_auth_context_release(grpc_auth_context* context) {
   context->Unref(DEBUG_LOCATION, "grpc_auth_context_unref");
 }
 
-// --- grpc_client_security_context ---
-grpc_client_security_context::~grpc_client_security_context() {
-  auth_context.reset(DEBUG_LOCATION, "client_security_context");
-  if (extension.instance != nullptr && extension.destroy != nullptr) {
-    extension.destroy(extension.instance);
-  }
-}
-
-grpc_client_security_context* grpc_client_security_context_create(
-    grpc_core::Arena* arena, grpc_call_credentials* creds) {
-  return arena->New<grpc_client_security_context>(
-      creds != nullptr ? creds->Ref() : nullptr);
-}
-
-void grpc_client_security_context_destroy(void* ctx) {
-  grpc_client_security_context* c =
-      static_cast<grpc_client_security_context*>(ctx);
-  c->~grpc_client_security_context();
-}
-
-// --- grpc_server_security_context ---
-grpc_server_security_context::~grpc_server_security_context() {
-  auth_context.reset(DEBUG_LOCATION, "server_security_context");
-  if (extension.instance != nullptr && extension.destroy != nullptr) {
-    extension.destroy(extension.instance);
-  }
-}
-
-grpc_server_security_context* grpc_server_security_context_create(
-    grpc_core::Arena* arena) {
-  return arena->New<grpc_server_security_context>();
-}
-
-void grpc_server_security_context_destroy(void* ctx) {
-  grpc_server_security_context* c =
-      static_cast<grpc_server_security_context*>(ctx);
-  c->~grpc_server_security_context();
-}
-
-// --- grpc_auth_context ---
-
 static grpc_auth_property_iterator empty_iterator = {nullptr, 0, nullptr};
 
 const char* grpc_auth_context_peer_identity_property_name(