grpc 1.62.3 → 1.63.0

data/src/core/lib/channel/metrics.h

@@ -0,0 +1,406 @@
+// Copyright 2024 The gRPC Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_METRICS_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_METRICS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+
+#include <grpc/support/log.h>
+#include <grpc/support/metrics.h>
+
+#include "src/core/lib/channel/call_tracer.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+constexpr absl::string_view kMetricLabelTarget = "grpc.target";
+
+// A global registry of instruments(metrics). This API is designed to be used
+// to register instruments (Counter, Histogram, and Gauge) as part of program
+// startup, before the execution of the main function (during dynamic
+// initialization time). Using this API after the main function begins may
+// result into missing instruments. This API is thread-unsafe.
+class GlobalInstrumentsRegistry {
+ public:
+  enum class ValueType {
+    kUndefined,
+    kInt64,
+    kUInt64,
+    kDouble,
+  };
+  enum class InstrumentType {
+    kUndefined,
+    kCounter,
+    kHistogram,
+    kGauge,
+    kCallbackGauge,
+  };
+  using InstrumentID = uint32_t;
+  struct GlobalInstrumentDescriptor {
+    ValueType value_type;
+    InstrumentType instrument_type;
+    InstrumentID index;
+    bool enable_by_default;
+    absl::string_view name;
+    absl::string_view description;
+    absl::string_view unit;
+    std::vector<absl::string_view> label_keys;
+    std::vector<absl::string_view> optional_label_keys;
+  };
+  struct GlobalInstrumentHandle {
+    // This is the index for the corresponding registered instrument that
+    // StatsPlugins can use to uniquely identify an instrument in the current
+    // process. Though this is not guaranteed to be stable between different
+    // runs or between different versions.
+    InstrumentID index;
+  };
+  struct GlobalUInt64CounterHandle : public GlobalInstrumentHandle {};
+  struct GlobalDoubleCounterHandle : public GlobalInstrumentHandle {};
+  struct GlobalUInt64HistogramHandle : public GlobalInstrumentHandle {};
+  struct GlobalDoubleHistogramHandle : public GlobalInstrumentHandle {};
+  struct GlobalInt64GaugeHandle : public GlobalInstrumentHandle {};
+  struct GlobalDoubleGaugeHandle : public GlobalInstrumentHandle {};
+  struct GlobalCallbackInt64GaugeHandle : public GlobalInstrumentHandle {};
+  struct GlobalCallbackDoubleGaugeHandle : public GlobalInstrumentHandle {};
+  using GlobalCallbackHandle = absl::variant<GlobalCallbackInt64GaugeHandle,
+                                             GlobalCallbackDoubleGaugeHandle>;
+
+  // Creates instrument in the GlobalInstrumentsRegistry.
+  static GlobalUInt64CounterHandle RegisterUInt64Counter(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalDoubleCounterHandle RegisterDoubleCounter(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalUInt64HistogramHandle RegisterUInt64Histogram(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalDoubleHistogramHandle RegisterDoubleHistogram(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalInt64GaugeHandle RegisterInt64Gauge(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalDoubleGaugeHandle RegisterDoubleGauge(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalCallbackInt64GaugeHandle RegisterCallbackInt64Gauge(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+  static GlobalCallbackDoubleGaugeHandle RegisterCallbackDoubleGauge(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, absl::Span<const absl::string_view> label_keys,
+      absl::Span<const absl::string_view> optional_label_keys,
+      bool enable_by_default);
+
+  static void ForEach(
+      absl::FunctionRef<void(const GlobalInstrumentDescriptor&)> f);
+  static const GlobalInstrumentDescriptor& GetInstrumentDescriptor(
+      GlobalInstrumentHandle handle);
+
+ private:
+  friend class GlobalInstrumentsRegistryTestPeer;
+
+  GlobalInstrumentsRegistry() = delete;
+
+  static std::vector<GlobalInstrumentsRegistry::GlobalInstrumentDescriptor>&
+  GetInstrumentList();
+};
+
+// An interface for implementing callback-style metrics.
+// To be implemented by stats plugins.
+class CallbackMetricReporter {
+ public:
+  virtual ~CallbackMetricReporter() = default;
+
+  virtual void Report(
+      GlobalInstrumentsRegistry::GlobalCallbackInt64GaugeHandle handle,
+      int64_t value, absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_values) = 0;
+  virtual void Report(
+      GlobalInstrumentsRegistry::GlobalCallbackDoubleGaugeHandle handle,
+      double value, absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_values) = 0;
+};
+
+class RegisteredMetricCallback;
+
+// The StatsPlugin interface.
+class StatsPlugin {
+ public:
+  // A general-purpose way for stats plugin to store per-channel or per-server
+  // state.
+  class ScopeConfig {
+   public:
+    virtual ~ScopeConfig() = default;
+  };
+
+  virtual ~StatsPlugin() = default;
+
+  // Whether this stats plugin is enabled for the channel specified by \a scope.
+  // Returns true and a channel-specific ScopeConfig which may then be used to
+  // configure the ClientCallTracer in GetClientCallTracer().
+  virtual std::pair<bool, std::shared_ptr<ScopeConfig>> IsEnabledForChannel(
+      const experimental::StatsPluginChannelScope& scope) const = 0;
+  // Whether this stats plugin is enabled for the server specified by \a args.
+  // Returns true and a server-specific ScopeConfig which may then be used to
+  // configure the ServerCallTracer in GetServerCallTracer().
+  virtual std::pair<bool, std::shared_ptr<ScopeConfig>> IsEnabledForServer(
+      const ChannelArgs& args) const = 0;
+
+  // Adds \a value to the uint64 counter specified by \a handle. \a label_values
+  // and \a optional_label_values specify attributes that are associated with
+  // this measurement and must match with their corresponding keys in
+  // GlobalInstrumentsRegistry::RegisterUInt64Counter().
+  virtual void AddCounter(
+      GlobalInstrumentsRegistry::GlobalUInt64CounterHandle handle,
+      uint64_t value, absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Adds \a value to the double counter specified by \a handle. \a label_values
+  // and \a optional_label_values specify attributes that are associated with
+  // this measurement and must match with their corresponding keys in
+  // GlobalInstrumentsRegistry::RegisterDoubleCounter().
+  virtual void AddCounter(
+      GlobalInstrumentsRegistry::GlobalDoubleCounterHandle handle, double value,
+      absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Records a uint64 \a value to the histogram specified by \a handle. \a
+  // label_values and \a optional_label_values specify attributes that are
+  // associated with this measurement and must match with their corresponding
+  // keys in GlobalInstrumentsRegistry::RegisterUInt64Histogram().
+  virtual void RecordHistogram(
+      GlobalInstrumentsRegistry::GlobalUInt64HistogramHandle handle,
+      uint64_t value, absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Records a double \a value to the histogram specified by \a handle. \a
+  // label_values and \a optional_label_values specify attributes that are
+  // associated with this measurement and must match with their corresponding
+  // keys in GlobalInstrumentsRegistry::RegisterDoubleHistogram().
+  virtual void RecordHistogram(
+      GlobalInstrumentsRegistry::GlobalDoubleHistogramHandle handle,
+      double value, absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Sets an int64 \a value to the gauge specifed by \a handle. \a
+  // label_values and \a optional_label_values specify attributes that are
+  // associated with this measurement and must match with their corresponding
+  // keys in GlobalInstrumentsRegistry::RegisterInt64Gauge().
+  virtual void SetGauge(
+      GlobalInstrumentsRegistry::GlobalInt64GaugeHandle handle, int64_t value,
+      absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Sets a double \a value to the gauge specifed by \a handle. \a
+  // label_values and \a optional_label_values specify attributes that are
+  // associated with this measurement and must match with their corresponding
+  // keys in GlobalInstrumentsRegistry::RegisterDoubleGauge().
+  virtual void SetGauge(
+      GlobalInstrumentsRegistry::GlobalDoubleGaugeHandle handle, double value,
+      absl::Span<const absl::string_view> label_values,
+      absl::Span<const absl::string_view> optional_label_values) = 0;
+  // Adds a callback to be invoked when the stats plugin wants to
+  // populate the corresponding metrics (see callback->metrics() for list).
+  virtual void AddCallback(RegisteredMetricCallback* callback) = 0;
+  // Removes a callback previously added via AddCallback().  The stats
+  // plugin may not use the callback after this method returns.
+  virtual void RemoveCallback(RegisteredMetricCallback* callback) = 0;
+
+  // Gets a ClientCallTracer associated with this stats plugin which can be used
+  // in a call.
+  virtual ClientCallTracer* GetClientCallTracer(
+      const Slice& path, bool registered_method,
+      std::shared_ptr<ScopeConfig> scope_config) = 0;
+  // Gets a ServerCallTracer associated with this stats plugin which can be used
+  // in a call.
+  virtual ServerCallTracer* GetServerCallTracer(
+      std::shared_ptr<ScopeConfig> scope_config) = 0;
+
+  // TODO(yijiem): This is an optimization for the StatsPlugin to create its own
+  // representation of the label_values and use it multiple times. We would
+  // change AddCounter and RecordHistogram to take RefCountedPtr<LabelValueSet>
+  // and also change the StatsPluginsGroup to support this.
+  // Use the StatsPlugin to get a representation of label values that can be
+  // saved for multiple uses later.
+  // virtual RefCountedPtr<LabelValueSet> MakeLabelValueSet(
+  //     absl::Span<absl::string_view> label_values) = 0;
+};
+
+// A global registry of stats plugins. It has shared ownership to the registered
+// stats plugins. This API is supposed to be used during runtime after the main
+// function begins. This API is thread-safe.
+class GlobalStatsPluginRegistry {
+ public:
+  // A stats plugin group object is how the code in gRPC normally interacts with
+  // 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 {
+   public:
+    // Adds a stats plugin and a scope config (per-channel or per-server) to the
+    // group.
+    void AddStatsPlugin(std::shared_ptr<StatsPlugin> plugin,
+                        std::shared_ptr<StatsPlugin::ScopeConfig> config) {
+      PluginState plugin_state;
+      plugin_state.plugin = std::move(plugin);
+      plugin_state.scope_config = std::move(config);
+      plugins_state_.push_back(std::move(plugin_state));
+    }
+    // Adds a counter in all stats plugins within the group. See the StatsPlugin
+    // interface for more documentation and valid types.
+    template <class HandleType, class ValueType>
+    void AddCounter(HandleType handle, ValueType value,
+                    absl::Span<const absl::string_view> label_values,
+                    absl::Span<const absl::string_view> optional_values) {
+      for (auto& state : plugins_state_) {
+        state.plugin->AddCounter(handle, value, label_values, optional_values);
+      }
+    }
+    // Records a value to a histogram in all stats plugins within the group. See
+    // the StatsPlugin interface for more documentation and valid types.
+    template <class HandleType, class ValueType>
+    void RecordHistogram(HandleType handle, ValueType value,
+                         absl::Span<const absl::string_view> label_values,
+                         absl::Span<const absl::string_view> optional_values) {
+      for (auto& state : plugins_state_) {
+        state.plugin->RecordHistogram(handle, value, label_values,
+                                      optional_values);
+      }
+    }
+    // Sets a value to a gauge in all stats plugins within the group. See the
+    // StatsPlugin interface for more documentation and valid types.
+    template <class HandleType, class ValueType>
+    void SetGauge(HandleType handle, ValueType value,
+                  absl::Span<const absl::string_view> label_values,
+                  absl::Span<const absl::string_view> optional_values) {
+      for (auto& state : plugins_state_) {
+        state.plugin->SetGauge(handle, value, label_values, optional_values);
+      }
+    }
+
+    // Registers a callback to be used to populate callback metrics.
+    // The callback will update the specified metrics.  The callback
+    // will be invoked no more often than min_interval.  Multiple callbacks may
+    // be registered for the same metrics, as long as no two callbacks report
+    // data for the same set of labels in which case the behavior is undefined.
+    //
+    // The returned object is a handle that allows the caller to control
+    // the lifetime of the callback; when the returned object is
+    // destroyed, the callback is de-registered.  The returned object
+    // must not outlive the StatsPluginGroup object that created it.
+    GRPC_MUST_USE_RESULT std::unique_ptr<RegisteredMetricCallback>
+    RegisterCallback(
+        absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
+        std::vector<GlobalInstrumentsRegistry::GlobalCallbackHandle> metrics,
+        Duration min_interval = Duration::Seconds(5));
+
+    // Adds all available client call tracers associated with the stats plugins
+    // within the group to \a call_context.
+    void AddClientCallTracers(const Slice& path, bool registered_method,
+                              grpc_call_context_element* call_context);
+    // Adds all available server call tracers associated with the stats plugins
+    // within the group to \a call_context.
+    void AddServerCallTracers(grpc_call_context_element* call_context);
+
+   private:
+    friend class RegisteredMetricCallback;
+
+    struct PluginState {
+      std::shared_ptr<StatsPlugin::ScopeConfig> scope_config;
+      std::shared_ptr<StatsPlugin> plugin;
+    };
+
+    std::vector<PluginState> plugins_state_;
+  };
+
+  // Registers a stats plugin with the global stats plugin registry.
+  static void RegisterStatsPlugin(std::shared_ptr<StatsPlugin> plugin);
+
+  // The following functions can be invoked to get a StatsPluginGroup for
+  // a specified scope.
+  static StatsPluginGroup GetStatsPluginsForChannel(
+      const experimental::StatsPluginChannelScope& scope);
+  static StatsPluginGroup GetStatsPluginsForServer(const ChannelArgs& args);
+
+ private:
+  friend class GlobalStatsPluginRegistryTestPeer;
+
+  GlobalStatsPluginRegistry() = default;
+
+  static NoDestruct<Mutex> mutex_;
+  static NoDestruct<std::vector<std::shared_ptr<StatsPlugin>>> plugins_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+// A metric callback that is registered with a stats plugin group.
+class RegisteredMetricCallback {
+ public:
+  RegisteredMetricCallback(
+      GlobalStatsPluginRegistry::StatsPluginGroup& stats_plugin_group,
+      absl::AnyInvocable<void(CallbackMetricReporter&)> callback,
+      std::vector<GlobalInstrumentsRegistry::GlobalCallbackHandle> metrics,
+      Duration min_interval);
+
+  ~RegisteredMetricCallback();
+
+  // Invokes the callback.  The callback will report metric data via reporter.
+  void Run(CallbackMetricReporter& reporter) { callback_(reporter); }
+
+  // Returns the set of metrics that this callback will modify.
+  const std::vector<GlobalInstrumentsRegistry::GlobalCallbackHandle>& metrics()
+      const {
+    return metrics_;
+  }
+
+  // Returns the minimum interval at which a stats plugin may invoke the
+  // callback.
+  Duration min_interval() const { return min_interval_; }
+
+ private:
+  GlobalStatsPluginRegistry::StatsPluginGroup& stats_plugin_group_;
+  absl::AnyInvocable<void(CallbackMetricReporter&)> callback_;
+  std::vector<GlobalInstrumentsRegistry::GlobalCallbackHandle> metrics_;
+  Duration min_interval_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_METRICS_H

data/src/core/lib/channel/promise_based_filter.h

@@ -47,8 +47,8 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
-#include "src/core/lib/event_engine/default_event_engine.h"  // IWYU pragma: keep
-#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/event_engine/event_engine_context.h"  // IWYU pragma: keep
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
@@ -74,6 +74,12 @@
 
 namespace grpc_core {
 
+// HACK: If a filter has this type as a base class it will be skipped in
+// v3 filter stacks. This is a temporary measure to allow the v3 filter stack
+// to be bought up whilst some tests inadvertently rely on hard to convert
+// filters.
+class HackyHackyHackySkipInV3FilterStacks {};
+
 class ChannelFilter {
  public:
   class Args {
@@ -1059,8 +1065,10 @@ MakeFilterCall(Derived* derived) {
 //   the filter does not intercept call finalization.
 // - void OnFinalize(const grpc_call_final_info*):
 //   the filter intercepts call finalization.
+class ImplementChannelFilterTag {};
 template <typename Derived>
-class ImplementChannelFilter : public ChannelFilter {
+class ImplementChannelFilter : public ChannelFilter,
+                               public ImplementChannelFilterTag {
  public:
   // Natively construct a v3 call.
   void InitCall(CallSpineInterface* call_spine) {
@@ -1906,9 +1914,11 @@ struct ChannelFilterWithFlagsMethods {
 //       ChannelArgs channel_args, ChannelFilter::Args filter_args);
 // };
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value &&
-                      !std::is_base_of<ImplementChannelFilter<F>, F>::value,
-                  grpc_channel_filter>
+absl::enable_if_t<
+    std::is_base_of<ChannelFilter, F>::value &&
+        !std::is_base_of<ImplementChannelFilterTag, F>::value &&
+        !std::is_base_of<HackyHackyHackySkipInV3FilterStacks, F>::value,
+    grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
   using CallData = promise_filter_detail::CallData<kEndpoint>;
 
@@ -1947,7 +1957,53 @@ MakePromiseBasedFilter(const char* name) {
 }
 
 template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
-absl::enable_if_t<std::is_base_of<ImplementChannelFilter<F>, F>::value,
+absl::enable_if_t<
+    std::is_base_of<HackyHackyHackySkipInV3FilterStacks, F>::value,
+    grpc_channel_filter>
+MakePromiseBasedFilter(const char* name) {
+  using CallData = promise_filter_detail::CallData<kEndpoint>;
+
+  return grpc_channel_filter{
+      // start_transport_stream_op_batch
+      promise_filter_detail::BaseCallDataMethods::StartTransportStreamOpBatch,
+      // make_call_promise
+      promise_filter_detail::ChannelFilterMethods::MakeCallPromise,
+      [](grpc_channel_element* elem, CallSpineInterface*) {
+        GRPC_LOG_EVERY_N_SEC(
+            1, GPR_ERROR,
+            "gRPC V3 call stack in use, with a filter ('%s') that is not V3.",
+            elem->filter->name);
+      },
+      // start_transport_op
+      promise_filter_detail::ChannelFilterMethods::StartTransportOp,
+      // sizeof_call_data
+      sizeof(CallData),
+      // init_call_elem
+      promise_filter_detail::CallDataFilterWithFlagsMethods<
+          CallData, kFlags>::InitCallElem,
+      // set_pollset_or_pollset_set
+      promise_filter_detail::BaseCallDataMethods::SetPollsetOrPollsetSet,
+      // destroy_call_elem
+      promise_filter_detail::CallDataFilterWithFlagsMethods<
+          CallData, kFlags>::DestroyCallElem,
+      // sizeof_channel_data
+      sizeof(F),
+      // init_channel_elem
+      promise_filter_detail::ChannelFilterWithFlagsMethods<
+          F, kFlags>::InitChannelElem,
+      // post_init_channel_elem
+      promise_filter_detail::ChannelFilterMethods::PostInitChannelElem,
+      // destroy_channel_elem
+      promise_filter_detail::ChannelFilterMethods::DestroyChannelElem,
+      // get_channel_info
+      promise_filter_detail::ChannelFilterMethods::GetChannelInfo,
+      // name
+      name,
+  };
+}
+
+template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
+absl::enable_if_t<std::is_base_of<ImplementChannelFilterTag, F>::value,
                   grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
   using CallData = promise_filter_detail::CallData<kEndpoint>;

data/src/core/lib/channel/server_call_tracer_filter.cc

@@ -16,6 +16,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/server_call_tracer_filter.h"
+
 #include <functional>
 #include <utility>
 

data/src/core/lib/{surface/builtins.h → channel/server_call_tracer_filter.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 gRPC authors.
+// Copyright 2024 The gRPC Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,15 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
-#define GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_SERVER_CALL_TRACER_FILTER_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_SERVER_CALL_TRACER_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/core_configuration.h"
 
 namespace grpc_core {
-void RegisterBuiltins(CoreConfiguration::Builder* builder);
+
+void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
+
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_BUILTINS_H
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_SERVER_CALL_TRACER_FILTER_H

data/src/core/lib/channel/tcp_tracer.h

@@ -131,8 +131,12 @@ class TcpTracerInterface {
   };
 
   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;
+  // Records a snapshot of connection metrics.
+  virtual void RecordConnectionMetrics(ConnectionMetrics metrics) = 0;
 };
 
 }  // namespace grpc_core

data/src/core/lib/compression/compression_internal.cc

@@ -29,6 +29,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 
+#include <grpc/compression.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -239,4 +240,36 @@ DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
   return absl::nullopt;
 }
 
+grpc_compression_options CompressionOptionsFromChannelArgs(
+    const ChannelArgs& args) {
+  // Set compression options.
+  grpc_compression_options compression_options;
+  grpc_compression_options_init(&compression_options);
+  auto default_level = args.GetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL);
+  if (default_level.has_value()) {
+    compression_options.default_level.is_set = true;
+    compression_options.default_level.level = Clamp(
+        static_cast<grpc_compression_level>(*default_level),
+        GRPC_COMPRESS_LEVEL_NONE,
+        static_cast<grpc_compression_level>(GRPC_COMPRESS_LEVEL_COUNT - 1));
+  }
+  auto default_algorithm =
+      args.GetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
+  if (default_algorithm.has_value()) {
+    compression_options.default_algorithm.is_set = true;
+    compression_options.default_algorithm.algorithm =
+        Clamp(static_cast<grpc_compression_algorithm>(*default_algorithm),
+              GRPC_COMPRESS_NONE,
+              static_cast<grpc_compression_algorithm>(
+                  GRPC_COMPRESS_ALGORITHMS_COUNT - 1));
+  }
+  auto enabled_algorithms_bitset =
+      args.GetInt(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET);
+  if (enabled_algorithms_bitset.has_value()) {
+    compression_options.enabled_algorithms_bitset =
+        *enabled_algorithms_bitset | 1 /* always support no compression */;
+  }
+  return compression_options;
+}
+
 }  // namespace grpc_core

data/src/core/lib/compression/compression_internal.h

@@ -88,6 +88,9 @@ class CompressionAlgorithmSet {
   BitSet<GRPC_COMPRESS_ALGORITHMS_COUNT> set_;
 };
 
+grpc_compression_options CompressionOptionsFromChannelArgs(
+    const ChannelArgs& args);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H

data/src/core/lib/config/config_vars.cc

@@ -20,11 +20,8 @@
 
 #include "src/core/lib/config/config_vars.h"
 
-#include <vector>
-
 #include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
-#include "absl/strings/str_cat.h"
 
 #include "src/core/lib/config/load_config.h"
 
@@ -78,6 +75,8 @@ ABSL_FLAG(absl::optional<bool>, grpc_not_use_system_ssl_roots, {},
           "Disable loading system root certificates.");
 ABSL_FLAG(absl::optional<std::string>, grpc_ssl_cipher_suites, {},
           "A colon separated list of cipher suites to use with OpenSSL");
+ABSL_FLAG(absl::optional<bool>, grpc_absl_logging, {},
+          "Use absl logging from within gpr_log.");
 
 namespace grpc_core {
 
@@ -95,6 +94,8 @@ ConfigVars::ConfigVars(const Overrides& overrides)
       not_use_system_ssl_roots_(LoadConfig(
           FLAGS_grpc_not_use_system_ssl_roots, "GRPC_NOT_USE_SYSTEM_SSL_ROOTS",
           overrides.not_use_system_ssl_roots, false)),
+      absl_logging_(LoadConfig(FLAGS_grpc_absl_logging, "GRPC_ABSL_LOGGING",
+                               overrides.absl_logging, false)),
       dns_resolver_(LoadConfig(FLAGS_grpc_dns_resolver, "GRPC_DNS_RESOLVER",
                                overrides.dns_resolver, "")),
       verbosity_(LoadConfig(FLAGS_grpc_verbosity, "GRPC_VERBOSITY",
@@ -146,7 +147,8 @@ std::string ConfigVars::ToString() const {
       "\"", ", default_ssl_roots_file_path: ", "\"",
       absl::CEscape(DefaultSslRootsFilePath()), "\"",
       ", not_use_system_ssl_roots: ", NotUseSystemSslRoots() ? "true" : "false",
-      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"");
+      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"",
+      ", absl_logging: ", AbslLogging() ? "true" : "false");
 }
 
 }  // namespace grpc_core