grpc 1.64.0 → 1.65.0.pre1

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

@@ -27,7 +27,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 struct status_string_entry {
   const char* str;

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

@@ -28,9 +28,9 @@
 
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
+#include "src/core/util/useful.h"
 
 int grpc_compression_algorithm_is_message(grpc_compression_algorithm) {
   return 1;

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

@@ -24,10 +24,10 @@
 #include <zlib.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice.h"
@@ -62,17 +62,17 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
-        gpr_log(GPR_INFO, "zlib error (%d)", r);
+        LOG(INFO) << "zlib error (" << r << ")";
         goto error;
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
-      gpr_log(GPR_INFO, "zlib: not all input consumed");
+      LOG(INFO) << "zlib: not all input consumed";
       goto error;
     }
   }
   if (r != Z_STREAM_END) {
-    gpr_log(GPR_INFO, "zlib: Data error");
+    LOG(INFO) << "zlib: Data error";
     goto error;
   }
 
@@ -165,7 +165,7 @@ static int compress_inner(grpc_compression_algorithm algorithm,
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
-  gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
   return 0;
 }
 
@@ -190,6 +190,6 @@ int grpc_msg_decompress(grpc_compression_algorithm algorithm,
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
-  gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
+  LOG(ERROR) << "invalid compression algorithm " << algorithm;
   return 0;
 }

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

@@ -54,7 +54,7 @@ ABSL_FLAG(std::vector<std::string>, grpc_trace, {},
           "A comma separated list of tracers that provide additional insight "
           "into how gRPC C core is processing requests via debug logs.");
 ABSL_FLAG(absl::optional<std::string>, grpc_verbosity, {},
-          "Default gRPC logging verbosity");
+          "Logging verbosity.");
 ABSL_FLAG(absl::optional<std::string>, grpc_stacktrace_minloglevel, {},
           "Messages logged at the same or higher level than this will print "
           "stacktrace");
@@ -75,8 +75,6 @@ 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 {
 
@@ -94,8 +92,6 @@ 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",
@@ -147,8 +143,7 @@ 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()), "\"",
-      ", absl_logging: ", AbslLogging() ? "true" : "false");
+      ", ssl_cipher_suites: ", "\"", absl::CEscape(SslCipherSuites()), "\"");
 }
 
 }  // namespace grpc_core

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

@@ -38,7 +38,6 @@ class GPR_DLL ConfigVars {
     absl::optional<bool> enable_fork_support;
     absl::optional<bool> abort_on_leaks;
     absl::optional<bool> not_use_system_ssl_roots;
-    absl::optional<bool> absl_logging;
     absl::optional<std::string> dns_resolver;
     absl::optional<std::string> verbosity;
     absl::optional<std::string> stacktrace_minloglevel;
@@ -80,7 +79,7 @@ class GPR_DLL ConfigVars {
   // A comma separated list of tracers that provide additional insight into how
   // gRPC C core is processing requests via debug logs.
   absl::string_view Trace() const { return trace_; }
-  // Default gRPC logging verbosity
+  // Logging verbosity.
   absl::string_view Verbosity() const { return verbosity_; }
   // Messages logged at the same or higher level than this will print stacktrace
   absl::string_view StacktraceMinloglevel() const {
@@ -103,8 +102,6 @@ class GPR_DLL ConfigVars {
   bool NotUseSystemSslRoots() const { return not_use_system_ssl_roots_; }
   // A colon separated list of cipher suites to use with OpenSSL
   absl::string_view SslCipherSuites() const { return ssl_cipher_suites_; }
-  // Use absl logging from within gpr_log.
-  bool AbslLogging() const { return absl_logging_; }
 
  private:
   explicit ConfigVars(const Overrides& overrides);
@@ -114,7 +111,6 @@ class GPR_DLL ConfigVars {
   bool enable_fork_support_;
   bool abort_on_leaks_;
   bool not_use_system_ssl_roots_;
-  bool absl_logging_;
   std::string dns_resolver_;
   std::string verbosity_;
   std::string stacktrace_minloglevel_;

data/src/core/lib/debug/event_log.h

@@ -27,9 +27,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/util/time_precise.h"
 
 namespace grpc_core {
 

data/src/core/lib/debug/trace.cc

@@ -22,98 +22,81 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/gprpp/glob.h"
 
 int grpc_tracer_set_enabled(const char* name, int enabled);
 
 namespace grpc_core {
-
-TraceFlag* TraceFlagList::root_tracer_ = nullptr;
-
-bool TraceFlagList::Set(absl::string_view name, bool enabled) {
-  TraceFlag* t;
-  if (name == "all") {
-    for (t = root_tracer_; t; t = t->next_tracer_) {
-      t->set_enabled(enabled);
-    }
-  } else if (name == "list_tracers") {
-    LogAllTracers();
-  } else if (name == "refcount") {
-    for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (absl::StrContains(t->name_, "refcount")) {
-        t->set_enabled(enabled);
-      }
-    }
-  } else {
-    bool found = false;
-    for (t = root_tracer_; t; t = t->next_tracer_) {
-      if (name == t->name_) {
-        t->set_enabled(enabled);
-        found = true;
-      }
-    }
-    // check for unknowns, but ignore "", to allow to GRPC_TRACE=
-    if (!found && !name.empty()) {
-      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", std::string(name).c_str());
-      return false;  // early return
-    }
-  }
-  return true;
-}
-
-void TraceFlagList::Add(TraceFlag* flag) {
-  flag->next_tracer_ = root_tracer_;
-  root_tracer_ = flag;
-}
-
-void TraceFlagList::LogAllTracers() {
+namespace {
+void LogAllTracers() {
   gpr_log(GPR_DEBUG, "available tracers:");
-  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
-    gpr_log(GPR_DEBUG, "\t%s", t->name_);
+  for (const auto& name : GetAllTraceFlags()) {
+    LOG(INFO) << "  " << name.first;
   }
 }
 
-void TraceFlagList::SaveTo(std::map<std::string, bool>& values) {
-  for (TraceFlag* t = root_tracer_; t != nullptr; t = t->next_tracer_) {
-    values[t->name_] = t->enabled();
-  }
-}
+}  // namespace
 
 // Flags register themselves on the list during construction
 TraceFlag::TraceFlag(bool default_enabled, const char* name) : name_(name) {
   static_assert(std::is_trivially_destructible<TraceFlag>::value,
                 "TraceFlag needs to be trivially destructible.");
   set_enabled(default_enabled);
-  TraceFlagList::Add(this);
 }
 
-SavedTraceFlags::SavedTraceFlags() { TraceFlagList::SaveTo(values_); }
+SavedTraceFlags::SavedTraceFlags() {
+  for (const auto& flag : GetAllTraceFlags()) {
+    values_[flag.first] = {flag.second->enabled(), flag.second};
+  }
+}
 
 void SavedTraceFlags::Restore() {
   for (const auto& flag : values_) {
-    TraceFlagList::Set(flag.first, flag.second);
+    flag.second.second->set_enabled(flag.second.first);
   }
 }
 
-namespace {
-void ParseTracers(absl::string_view tracers) {
-  for (auto s : absl::StrSplit(tracers, ',', absl::SkipWhitespace())) {
-    if (s[0] == '-') {
-      TraceFlagList::Set(s.substr(1), false);
-    } else {
-      TraceFlagList::Set(s, true);
+bool ParseTracers(absl::string_view tracers) {
+  std::string enabled_tracers;
+  bool some_trace_was_found = false;
+  for (auto trace_glob : absl::StrSplit(tracers, ',', absl::SkipWhitespace())) {
+    if (trace_glob == "list_tracers") {
+      LogAllTracers();
+      continue;
     }
+    bool enabled = !absl::ConsumePrefix(&trace_glob, "-");
+    if (trace_glob == "all") trace_glob = "*";
+    if (trace_glob == "refcount") trace_glob = "*refcount*";
+    bool found = false;
+    for (const auto& flag : GetAllTraceFlags()) {
+      if (GlobMatch(flag.first, trace_glob)) {
+        flag.second->set_enabled(enabled);
+        if (enabled) absl::StrAppend(&enabled_tracers, flag.first, ", ");
+        found = true;
+        some_trace_was_found = true;
+      }
+    }
+    if (!found) LOG(ERROR) << "Unknown tracer: " << trace_glob;
+  }
+  if (!enabled_tracers.empty()) {
+    absl::string_view enabled_tracers_view(enabled_tracers);
+    absl::ConsumeSuffix(&enabled_tracers_view, ", ");
+    LOG(INFO) << "gRPC Tracers: " << enabled_tracers_view;
   }
+  return some_trace_was_found;
 }
-}  // namespace
 
 }  // namespace grpc_core
 
@@ -122,5 +105,6 @@ void grpc_tracer_init() {
 }
 
 int grpc_tracer_set_enabled(const char* name, int enabled) {
-  return grpc_core::TraceFlagList::Set(name, enabled != 0);
+  if (enabled != 0) return grpc_core::ParseTracers(name);
+  return grpc_core::ParseTracers(absl::StrCat("-", name));
 }

data/src/core/lib/debug/trace.h

@@ -1,5 +1,3 @@
-//
-//
 // Copyright 2015 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,104 +11,11 @@
 // 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_DEBUG_TRACE_H
 #define GRPC_SRC_CORE_LIB_DEBUG_TRACE_H
 
-#include <atomic>
-#include <map>
-#include <string>
-
-#include "absl/strings/string_view.h"
-
-#include <grpc/support/port_platform.h>
-
-void grpc_tracer_init();
-void grpc_tracer_shutdown(void);
-
-namespace grpc_core {
-
-class TraceFlag;
-class TraceFlagList {
- public:
-  static bool Set(absl::string_view name, bool enabled);
-  static void Add(TraceFlag* flag);
-  static void SaveTo(std::map<std::string, bool>& values);
-
- private:
-  static void LogAllTracers();
-  static TraceFlag* root_tracer_;
-};
-
-namespace testing {
-void grpc_tracer_enable_flag(TraceFlag* flag);
-}
-
-class TraceFlag {
- public:
-  TraceFlag(bool default_enabled, const char* name);
-  // TraceFlag needs to be trivially destructible since it is used as global
-  // variable.
-  ~TraceFlag() = default;
-
-  const char* name() const { return name_; }
-
-// Use the symbol GRPC_USE_TRACERS to determine if tracers will be enabled in
-// opt builds (tracers are always on in dbg builds). The default in OSS is for
-// tracers to be on since we support binary distributions of gRPC for the
-// wrapped language (wr don't want to force recompilation to get tracing).
-// Internally, however, for performance reasons, we compile them out by
-// default, since internal build systems make recompiling trivial.
-//
-// Prefer GRPC_TRACE_FLAG_ENABLED() macro instead of using enabled() directly.
-#define GRPC_USE_TRACERS  // tracers on by default in OSS
-#if defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
-  bool enabled() { return value_.load(std::memory_order_relaxed); }
-#else
-  bool enabled() { return false; }
-#endif  // defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
-
- private:
-  friend void testing::grpc_tracer_enable_flag(TraceFlag* flag);
-  friend class TraceFlagList;
-
-  void set_enabled(bool enabled) {
-    value_.store(enabled, std::memory_order_relaxed);
-  }
-
-  TraceFlag* next_tracer_;
-  const char* const name_;
-  std::atomic<bool> value_;
-};
-
-#define GRPC_TRACE_FLAG_ENABLED(f) GPR_UNLIKELY((f).enabled())
-
-#ifndef NDEBUG
-typedef TraceFlag DebugOnlyTraceFlag;
-#else
-class DebugOnlyTraceFlag {
- public:
-  constexpr DebugOnlyTraceFlag(bool /*default_enabled*/, const char* /*name*/) {
-  }
-  constexpr bool enabled() const { return false; }
-  constexpr const char* name() const { return "DebugOnlyTraceFlag"; }
-
- private:
-  void set_enabled(bool /*enabled*/) {}
-};
-#endif
-
-class SavedTraceFlags {
- public:
-  SavedTraceFlags();
-  void Restore();
-
- private:
-  std::map<std::string, bool> values_;
-};
-
-}  // namespace grpc_core
+#include "src/core/lib/debug/trace_flags.h"  // IWYU pragma: export
+#include "src/core/lib/debug/trace_impl.h"   // IWYU pragma: export
 
 #endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_H

data/src/core/lib/debug/trace_flags.cc

@@ -0,0 +1,255 @@
+// Copyright 2024 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.
+
+//
+// Automatically generated by tools/codegen/core/gen_trace_flags.py
+//
+
+#include "absl/container/flat_hash_map.h"
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/no_destruct.h"
+
+namespace grpc_core {
+
+DebugOnlyTraceFlag auth_context_refcount_trace(false, "auth_context_refcount");
+DebugOnlyTraceFlag call_combiner_trace(false, "call_combiner");
+DebugOnlyTraceFlag call_refcount_trace(false, "call_refcount");
+DebugOnlyTraceFlag closure_trace(false, "closure");
+DebugOnlyTraceFlag combiner_trace(false, "combiner");
+DebugOnlyTraceFlag cq_refcount_trace(false, "cq_refcount");
+DebugOnlyTraceFlag error_refcount_trace(false, "error_refcount");
+DebugOnlyTraceFlag fd_refcount_trace(false, "fd_refcount");
+DebugOnlyTraceFlag fd_trace_trace(false, "fd_trace");
+DebugOnlyTraceFlag lb_policy_refcount_trace(false, "lb_policy_refcount");
+DebugOnlyTraceFlag party_state_trace(false, "party_state");
+DebugOnlyTraceFlag pending_tags_trace(false, "pending_tags");
+DebugOnlyTraceFlag polling_trace(false, "polling");
+DebugOnlyTraceFlag polling_api_trace(false, "polling_api");
+DebugOnlyTraceFlag promise_primitives_trace(false, "promise_primitives");
+DebugOnlyTraceFlag resolver_refcount_trace(false, "resolver_refcount");
+DebugOnlyTraceFlag security_connector_refcount_trace(
+    false, "security_connector_refcount");
+DebugOnlyTraceFlag slice_refcount_trace(false, "slice_refcount");
+DebugOnlyTraceFlag stream_refcount_trace(false, "stream_refcount");
+DebugOnlyTraceFlag subchannel_refcount_trace(false, "subchannel_refcount");
+DebugOnlyTraceFlag work_serializer_trace(false, "work_serializer");
+TraceFlag api_trace(false, "api");
+TraceFlag apple_polling_trace(false, "apple_polling");
+TraceFlag backend_metric_trace(false, "backend_metric");
+TraceFlag backend_metric_filter_trace(false, "backend_metric_filter");
+TraceFlag bdp_estimator_trace(false, "bdp_estimator");
+TraceFlag call_trace(false, "call");
+TraceFlag call_error_trace(false, "call_error");
+TraceFlag cares_address_sorting_trace(false, "cares_address_sorting");
+TraceFlag cares_resolver_trace(false, "cares_resolver");
+TraceFlag cds_lb_trace(false, "cds_lb");
+TraceFlag channel_trace(false, "channel");
+TraceFlag channel_stack_trace(false, "channel_stack");
+TraceFlag chaotic_good_trace(false, "chaotic_good");
+TraceFlag chttp2_hpack_parser_trace(false, "chttp2_hpack_parser");
+TraceFlag chttp2_new_stream_trace(false, "chttp2_new_stream");
+TraceFlag client_channel_trace(false, "client_channel");
+TraceFlag client_channel_call_trace(false, "client_channel_call");
+TraceFlag client_channel_lb_call_trace(false, "client_channel_lb_call");
+TraceFlag client_idle_filter_trace(false, "client_idle_filter");
+TraceFlag compression_trace(false, "compression");
+TraceFlag connectivity_state_trace(false, "connectivity_state");
+TraceFlag cronet_trace(false, "cronet");
+TraceFlag dns_resolver_trace(false, "dns_resolver");
+TraceFlag environment_autodetect_trace(false, "environment_autodetect");
+TraceFlag event_engine_trace(false, "event_engine");
+TraceFlag event_engine_client_channel_resolver_trace(
+    false, "event_engine_client_channel_resolver");
+TraceFlag event_engine_dns_trace(false, "event_engine_dns");
+TraceFlag event_engine_endpoint_trace(false, "event_engine_endpoint");
+TraceFlag event_engine_endpoint_data_trace(false, "event_engine_endpoint_data");
+TraceFlag event_engine_poller_trace(false, "event_engine_poller");
+TraceFlag executor_trace(false, "executor");
+TraceFlag fault_injection_filter_trace(false, "fault_injection_filter");
+TraceFlag flowctl_trace(false, "flowctl");
+TraceFlag fork_trace(false, "fork");
+TraceFlag fuzzing_ee_timers_trace(false, "fuzzing_ee_timers");
+TraceFlag fuzzing_ee_writes_trace(false, "fuzzing_ee_writes");
+TraceFlag glb_trace(false, "glb");
+TraceFlag grpc_authz_api_trace(false, "grpc_authz_api");
+TraceFlag handshaker_trace(false, "handshaker");
+TraceFlag health_check_client_trace(false, "health_check_client");
+TraceFlag http_trace(false, "http");
+TraceFlag http1_trace(false, "http1");
+TraceFlag http2_ping_trace(false, "http2_ping");
+TraceFlag http2_stream_state_trace(false, "http2_stream_state");
+TraceFlag http_keepalive_trace(false, "http_keepalive");
+TraceFlag inproc_trace(false, "inproc");
+TraceFlag metadata_query_trace(false, "metadata_query");
+TraceFlag op_failure_trace(false, "op_failure");
+TraceFlag orca_client_trace(false, "orca_client");
+TraceFlag outlier_detection_lb_trace(false, "outlier_detection_lb");
+TraceFlag pick_first_trace(false, "pick_first");
+TraceFlag plugin_credentials_trace(false, "plugin_credentials");
+TraceFlag priority_lb_trace(false, "priority_lb");
+TraceFlag queue_pluck_trace(false, "queue_pluck");
+TraceFlag resource_quota_trace(false, "resource_quota");
+TraceFlag retry_trace(false, "retry");
+TraceFlag ring_hash_lb_trace(false, "ring_hash_lb");
+TraceFlag rls_lb_trace(false, "rls_lb");
+TraceFlag round_robin_trace(false, "round_robin");
+TraceFlag secure_endpoint_trace(false, "secure_endpoint");
+TraceFlag server_channel_trace(false, "server_channel");
+TraceFlag stateful_session_filter_trace(false, "stateful_session_filter");
+TraceFlag subchannel_trace(false, "subchannel");
+TraceFlag subchannel_pool_trace(false, "subchannel_pool");
+TraceFlag tcp_trace(false, "tcp");
+TraceFlag timer_trace(false, "timer");
+TraceFlag timer_check_trace(false, "timer_check");
+TraceFlag tsi_trace(false, "tsi");
+TraceFlag weighted_round_robin_lb_trace(false, "weighted_round_robin_lb");
+TraceFlag weighted_target_lb_trace(false, "weighted_target_lb");
+TraceFlag xds_client_trace(false, "xds_client");
+TraceFlag xds_client_refcount_trace(false, "xds_client_refcount");
+TraceFlag xds_cluster_impl_lb_trace(false, "xds_cluster_impl_lb");
+TraceFlag xds_cluster_manager_lb_trace(false, "xds_cluster_manager_lb");
+TraceFlag xds_cluster_resource_type_test_trace(
+    true, "xds_cluster_resource_type_test");
+TraceFlag xds_common_types_test_trace(true, "xds_common_types_test");
+TraceFlag xds_endpoint_resource_type_test_trace(
+    true, "xds_endpoint_resource_type_test");
+TraceFlag xds_listener_resource_type_test_trace(
+    true, "xds_listener_resource_type_test");
+TraceFlag xds_override_host_lb_trace(false, "xds_override_host_lb");
+TraceFlag xds_resolver_trace(false, "xds_resolver");
+TraceFlag xds_route_config_resource_type_test_trace(
+    true, "xds_route_config_resource_type_test");
+TraceFlag xds_server_config_fetcher_trace(false, "xds_server_config_fetcher");
+TraceFlag xds_wrr_locality_lb_trace(false, "xds_wrr_locality_lb");
+
+const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
+  static const NoDestruct<absl::flat_hash_map<std::string, TraceFlag*>> all(
+      absl::flat_hash_map<std::string, TraceFlag*>({
+          {"api", &api_trace},
+          {"apple_polling", &apple_polling_trace},
+          {"backend_metric", &backend_metric_trace},
+          {"backend_metric_filter", &backend_metric_filter_trace},
+          {"bdp_estimator", &bdp_estimator_trace},
+          {"call", &call_trace},
+          {"call_error", &call_error_trace},
+          {"cares_address_sorting", &cares_address_sorting_trace},
+          {"cares_resolver", &cares_resolver_trace},
+          {"cds_lb", &cds_lb_trace},
+          {"channel", &channel_trace},
+          {"channel_stack", &channel_stack_trace},
+          {"chaotic_good", &chaotic_good_trace},
+          {"chttp2_hpack_parser", &chttp2_hpack_parser_trace},
+          {"chttp2_new_stream", &chttp2_new_stream_trace},
+          {"client_channel", &client_channel_trace},
+          {"client_channel_call", &client_channel_call_trace},
+          {"client_channel_lb_call", &client_channel_lb_call_trace},
+          {"client_idle_filter", &client_idle_filter_trace},
+          {"compression", &compression_trace},
+          {"connectivity_state", &connectivity_state_trace},
+          {"cronet", &cronet_trace},
+          {"dns_resolver", &dns_resolver_trace},
+          {"environment_autodetect", &environment_autodetect_trace},
+          {"event_engine", &event_engine_trace},
+          {"event_engine_client_channel_resolver",
+           &event_engine_client_channel_resolver_trace},
+          {"event_engine_dns", &event_engine_dns_trace},
+          {"event_engine_endpoint", &event_engine_endpoint_trace},
+          {"event_engine_endpoint_data", &event_engine_endpoint_data_trace},
+          {"event_engine_poller", &event_engine_poller_trace},
+          {"executor", &executor_trace},
+          {"fault_injection_filter", &fault_injection_filter_trace},
+          {"flowctl", &flowctl_trace},
+          {"fork", &fork_trace},
+          {"fuzzing_ee_timers", &fuzzing_ee_timers_trace},
+          {"fuzzing_ee_writes", &fuzzing_ee_writes_trace},
+          {"glb", &glb_trace},
+          {"grpc_authz_api", &grpc_authz_api_trace},
+          {"handshaker", &handshaker_trace},
+          {"health_check_client", &health_check_client_trace},
+          {"http", &http_trace},
+          {"http1", &http1_trace},
+          {"http2_ping", &http2_ping_trace},
+          {"http2_stream_state", &http2_stream_state_trace},
+          {"http_keepalive", &http_keepalive_trace},
+          {"inproc", &inproc_trace},
+          {"metadata_query", &metadata_query_trace},
+          {"op_failure", &op_failure_trace},
+          {"orca_client", &orca_client_trace},
+          {"outlier_detection_lb", &outlier_detection_lb_trace},
+          {"pick_first", &pick_first_trace},
+          {"plugin_credentials", &plugin_credentials_trace},
+          {"priority_lb", &priority_lb_trace},
+          {"queue_pluck", &queue_pluck_trace},
+          {"resource_quota", &resource_quota_trace},
+          {"retry", &retry_trace},
+          {"ring_hash_lb", &ring_hash_lb_trace},
+          {"rls_lb", &rls_lb_trace},
+          {"round_robin", &round_robin_trace},
+          {"secure_endpoint", &secure_endpoint_trace},
+          {"server_channel", &server_channel_trace},
+          {"stateful_session_filter", &stateful_session_filter_trace},
+          {"subchannel", &subchannel_trace},
+          {"subchannel_pool", &subchannel_pool_trace},
+          {"tcp", &tcp_trace},
+          {"timer", &timer_trace},
+          {"timer_check", &timer_check_trace},
+          {"tsi", &tsi_trace},
+          {"weighted_round_robin_lb", &weighted_round_robin_lb_trace},
+          {"weighted_target_lb", &weighted_target_lb_trace},
+          {"xds_client", &xds_client_trace},
+          {"xds_client_refcount", &xds_client_refcount_trace},
+          {"xds_cluster_impl_lb", &xds_cluster_impl_lb_trace},
+          {"xds_cluster_manager_lb", &xds_cluster_manager_lb_trace},
+          {"xds_cluster_resource_type_test",
+           &xds_cluster_resource_type_test_trace},
+          {"xds_common_types_test", &xds_common_types_test_trace},
+          {"xds_endpoint_resource_type_test",
+           &xds_endpoint_resource_type_test_trace},
+          {"xds_listener_resource_type_test",
+           &xds_listener_resource_type_test_trace},
+          {"xds_override_host_lb", &xds_override_host_lb_trace},
+          {"xds_resolver", &xds_resolver_trace},
+          {"xds_route_config_resource_type_test",
+           &xds_route_config_resource_type_test_trace},
+          {"xds_server_config_fetcher", &xds_server_config_fetcher_trace},
+          {"xds_wrr_locality_lb", &xds_wrr_locality_lb_trace},
+#ifndef NDEBUG
+          {"auth_context_refcount", &auth_context_refcount_trace},
+          {"call_combiner", &call_combiner_trace},
+          {"call_refcount", &call_refcount_trace},
+          {"closure", &closure_trace},
+          {"combiner", &combiner_trace},
+          {"cq_refcount", &cq_refcount_trace},
+          {"error_refcount", &error_refcount_trace},
+          {"fd_refcount", &fd_refcount_trace},
+          {"fd_trace", &fd_trace_trace},
+          {"lb_policy_refcount", &lb_policy_refcount_trace},
+          {"party_state", &party_state_trace},
+          {"pending_tags", &pending_tags_trace},
+          {"polling", &polling_trace},
+          {"polling_api", &polling_api_trace},
+          {"promise_primitives", &promise_primitives_trace},
+          {"resolver_refcount", &resolver_refcount_trace},
+          {"security_connector_refcount", &security_connector_refcount_trace},
+          {"slice_refcount", &slice_refcount_trace},
+          {"stream_refcount", &stream_refcount_trace},
+          {"subchannel_refcount", &subchannel_refcount_trace},
+          {"work_serializer", &work_serializer_trace},
+#endif
+      }));
+  return *all;
+}
+
+}  // namespace grpc_core