grpc 1.62.0 → 1.65.1

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

@@ -16,105 +16,87 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/debug/trace.h"
 
 #include <string>
 #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
 
@@ -123,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 <grpc/support/port_platform.h>
-
-#include <atomic>
-#include <map>
-#include <string>
-
-#include "absl/strings/string_view.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

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

@@ -0,0 +1,133 @@
+// 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
+//
+
+#ifndef GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H
+#define GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H
+
+#include "src/core/lib/debug/trace_impl.h"
+
+namespace grpc_core {
+
+extern DebugOnlyTraceFlag auth_context_refcount_trace;
+extern DebugOnlyTraceFlag call_combiner_trace;
+extern DebugOnlyTraceFlag call_refcount_trace;
+extern DebugOnlyTraceFlag closure_trace;
+extern DebugOnlyTraceFlag combiner_trace;
+extern DebugOnlyTraceFlag cq_refcount_trace;
+extern DebugOnlyTraceFlag error_refcount_trace;
+extern DebugOnlyTraceFlag fd_refcount_trace;
+extern DebugOnlyTraceFlag fd_trace_trace;
+extern DebugOnlyTraceFlag lb_policy_refcount_trace;
+extern DebugOnlyTraceFlag party_state_trace;
+extern DebugOnlyTraceFlag pending_tags_trace;
+extern DebugOnlyTraceFlag polling_trace;
+extern DebugOnlyTraceFlag polling_api_trace;
+extern DebugOnlyTraceFlag promise_primitives_trace;
+extern DebugOnlyTraceFlag resolver_refcount_trace;
+extern DebugOnlyTraceFlag security_connector_refcount_trace;
+extern DebugOnlyTraceFlag slice_refcount_trace;
+extern DebugOnlyTraceFlag stream_refcount_trace;
+extern DebugOnlyTraceFlag subchannel_refcount_trace;
+extern DebugOnlyTraceFlag work_serializer_trace;
+extern TraceFlag api_trace;
+extern TraceFlag apple_polling_trace;
+extern TraceFlag backend_metric_trace;
+extern TraceFlag backend_metric_filter_trace;
+extern TraceFlag bdp_estimator_trace;
+extern TraceFlag call_trace;
+extern TraceFlag call_error_trace;
+extern TraceFlag cares_address_sorting_trace;
+extern TraceFlag cares_resolver_trace;
+extern TraceFlag cds_lb_trace;
+extern TraceFlag channel_trace;
+extern TraceFlag channel_stack_trace;
+extern TraceFlag chaotic_good_trace;
+extern TraceFlag chttp2_hpack_parser_trace;
+extern TraceFlag chttp2_new_stream_trace;
+extern TraceFlag client_channel_trace;
+extern TraceFlag client_channel_call_trace;
+extern TraceFlag client_channel_lb_call_trace;
+extern TraceFlag client_idle_filter_trace;
+extern TraceFlag compression_trace;
+extern TraceFlag connectivity_state_trace;
+extern TraceFlag cronet_trace;
+extern TraceFlag dns_resolver_trace;
+extern TraceFlag environment_autodetect_trace;
+extern TraceFlag event_engine_trace;
+extern TraceFlag event_engine_client_channel_resolver_trace;
+extern TraceFlag event_engine_dns_trace;
+extern TraceFlag event_engine_endpoint_trace;
+extern TraceFlag event_engine_endpoint_data_trace;
+extern TraceFlag event_engine_poller_trace;
+extern TraceFlag executor_trace;
+extern TraceFlag fault_injection_filter_trace;
+extern TraceFlag flowctl_trace;
+extern TraceFlag fork_trace;
+extern TraceFlag fuzzing_ee_timers_trace;
+extern TraceFlag fuzzing_ee_writes_trace;
+extern TraceFlag glb_trace;
+extern TraceFlag grpc_authz_api_trace;
+extern TraceFlag handshaker_trace;
+extern TraceFlag health_check_client_trace;
+extern TraceFlag http_trace;
+extern TraceFlag http1_trace;
+extern TraceFlag http2_ping_trace;
+extern TraceFlag http2_stream_state_trace;
+extern TraceFlag http_keepalive_trace;
+extern TraceFlag inproc_trace;
+extern TraceFlag metadata_query_trace;
+extern TraceFlag op_failure_trace;
+extern TraceFlag orca_client_trace;
+extern TraceFlag outlier_detection_lb_trace;
+extern TraceFlag pick_first_trace;
+extern TraceFlag plugin_credentials_trace;
+extern TraceFlag priority_lb_trace;
+extern TraceFlag queue_pluck_trace;
+extern TraceFlag resource_quota_trace;
+extern TraceFlag retry_trace;
+extern TraceFlag ring_hash_lb_trace;
+extern TraceFlag rls_lb_trace;
+extern TraceFlag round_robin_trace;
+extern TraceFlag secure_endpoint_trace;
+extern TraceFlag server_channel_trace;
+extern TraceFlag stateful_session_filter_trace;
+extern TraceFlag subchannel_trace;
+extern TraceFlag subchannel_pool_trace;
+extern TraceFlag tcp_trace;
+extern TraceFlag timer_trace;
+extern TraceFlag timer_check_trace;
+extern TraceFlag tsi_trace;
+extern TraceFlag weighted_round_robin_lb_trace;
+extern TraceFlag weighted_target_lb_trace;
+extern TraceFlag xds_client_trace;
+extern TraceFlag xds_client_refcount_trace;
+extern TraceFlag xds_cluster_impl_lb_trace;
+extern TraceFlag xds_cluster_manager_lb_trace;
+extern TraceFlag xds_cluster_resource_type_test_trace;
+extern TraceFlag xds_common_types_test_trace;
+extern TraceFlag xds_endpoint_resource_type_test_trace;
+extern TraceFlag xds_listener_resource_type_test_trace;
+extern TraceFlag xds_override_host_lb_trace;
+extern TraceFlag xds_resolver_trace;
+extern TraceFlag xds_route_config_resource_type_test_trace;
+extern TraceFlag xds_server_config_fetcher_trace;
+extern TraceFlag xds_wrr_locality_lb_trace;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_FLAGS_H