grpc 1.64.0 → 1.65.0.pre2

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

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

@@ -0,0 +1,115 @@
+// Copyright 2015 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_DEBUG_TRACE_IMPL_H
+#define GRPC_SRC_CORE_LIB_DEBUG_TRACE_IMPL_H
+
+#include <atomic>
+#include <map>
+#include <string>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/port_platform.h>
+
+void grpc_tracer_init();
+void grpc_tracer_shutdown(void);
+
+namespace grpc_core {
+bool ParseTracers(absl::string_view tracers);
+class SavedTraceFlags;
+
+class TraceFlag;
+
+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 bool ParseTracers(absl::string_view tracers);
+  friend SavedTraceFlags;
+
+  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_OBJ(obj) GPR_UNLIKELY((obj).enabled())
+#define GRPC_TRACE_FLAG_ENABLED(tracer) \
+  GPR_UNLIKELY((grpc_core::tracer##_trace).enabled())
+#define GRPC_TRACE_LOG(tracer, level) \
+  LOG_IF(level, GRPC_TRACE_FLAG_ENABLED(tracer))
+#define GRPC_TRACE_VLOG(tracer, level) \
+  if (GRPC_TRACE_FLAG_ENABLED(tracer)) VLOG(level)
+
+#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, std::pair<bool, TraceFlag*>> values_;
+};
+
+const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_DEBUG_TRACE_IMPL_H

data/src/core/lib/event_engine/ares_resolver.cc

@@ -53,6 +53,7 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -80,8 +81,6 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-grpc_core::TraceFlag grpc_trace_ares_resolver(false, "cares_resolver");
-
 namespace {
 
 absl::Status AresStatusToAbslStatus(int status, absl::string_view error_msg) {
@@ -200,7 +199,7 @@ AresResolver::CreateAresResolver(
   ares_channel channel;
   int status = ares_init_options(&channel, &opts, ARES_OPT_FLAGS);
   if (status != ARES_SUCCESS) {
-    gpr_log(GPR_ERROR, "ares_init_options failed, status: %d", status);
+    LOG(ERROR) << "ares_init_options failed, status: " << status;
     return AresStatusToAbslStatus(
         status,
         absl::StrCat("Failed to init c-ares channel: ", ares_strerror(status)));
@@ -221,8 +220,7 @@ AresResolver::AresResolver(
     std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory,
     std::shared_ptr<EventEngine> event_engine, ares_channel channel)
     : RefCountedDNSResolverInterface(
-          GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver) ? "AresResolver"
-                                                            : nullptr),
+          GRPC_TRACE_FLAG_ENABLED(cares_resolver) ? "AresResolver" : nullptr),
       channel_(channel),
       polled_fd_factory_(std::move(polled_fd_factory)),
       event_engine_(std::move(event_engine)) {
@@ -767,9 +765,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   }
   GRPC_ARES_RESOLVER_TRACE_LOG("resolver:%p Got %zu TXT records", ares_resolver,
                                result.size());
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {
+  if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {
     for (const auto& record : result) {
-      gpr_log(GPR_INFO, "%s", record.c_str());
+      LOG(INFO) << record;
     }
   }
   // Clean up.

data/src/core/lib/event_engine/ares_resolver.h

@@ -46,11 +46,9 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-extern grpc_core::TraceFlag grpc_trace_ares_resolver;
-
 #define GRPC_ARES_RESOLVER_TRACE_LOG(format, ...)                              \
   do {                                                                         \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_ares_resolver)) {                   \
+    if (GRPC_TRACE_FLAG_ENABLED(cares_resolver)) {                             \
       gpr_log(GPR_INFO, "(EventEngine c-ares resolver) " format, __VA_ARGS__); \
     }                                                                          \
   } while (0)

data/src/core/lib/event_engine/cf_engine/cf_engine.cc

@@ -63,7 +63,7 @@ CFEventEngine::CFEventEngine()
 CFEventEngine::~CFEventEngine() {
   {
     grpc_core::MutexLock lock(&task_mu_);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
       for (auto handle : known_handles_) {
         gpr_log(GPR_ERROR,
                 "CFEventEngine:%p uncleared TaskHandle at shutdown:%s", this,

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -35,11 +35,9 @@ namespace experimental {
 void DNSServiceResolverImpl::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
     absl::string_view name, absl::string_view default_port) {
-  GRPC_EVENT_ENGINE_DNS_TRACE(
-      "DNSServiceResolverImpl::LookupHostname: name: %.*s, default_port: %.*s, "
-      "this: %p",
-      static_cast<int>(name.length()), name.data(),
-      static_cast<int>(default_port.length()), default_port.data(), this);
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "DNSServiceResolverImpl::LookupHostname: name: " << name
+      << ", default_port: " << default_port << ", this: " << this;
 
   absl::string_view host;
   absl::string_view port_string;
@@ -139,13 +137,12 @@ void DNSServiceResolverImpl::ResolveCallback(
     DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex,
     DNSServiceErrorType errorCode, const char* hostname,
     const struct sockaddr* address, uint32_t ttl, void* context) {
-  GRPC_EVENT_ENGINE_DNS_TRACE(
-      "DNSServiceResolverImpl::ResolveCallback: sdRef: %p, flags: %x, "
-      "interface: %d, errorCode: %d, hostname: %s, addressFamily: %d, ttl: "
-      "%d, "
-      "this: %p",
-      sdRef, flags, interfaceIndex, errorCode, hostname, address->sa_family,
-      ttl, context);
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "DNSServiceResolverImpl::ResolveCallback: sdRef: " << sdRef
+      << ", flags: " << flags << ", interface: " << interfaceIndex
+      << ", errorCode: " << errorCode << ", hostname: " << hostname
+      << ", addressFamily: " << address->sa_family << ", ttl: " << ttl
+      << ", this: " << context;
 
   // no need to increase refcount here, since ResolveCallback and Shutdown is
   // called from the serial queue and it is guarenteed that it won't be called
@@ -195,12 +192,11 @@ void DNSServiceResolverImpl::ResolveCallback(
           ->sin6_port = htons(request.port);
     }
 
-    GRPC_EVENT_ENGINE_DNS_TRACE(
-        "DNSServiceResolverImpl::ResolveCallback: "
-        "sdRef: %p, hostname: %s, addressPort: %s, this: %p",
-        sdRef, hostname,
-        ResolvedAddressToString(resolved_address).value_or("ERROR").c_str(),
-        context);
+    GRPC_TRACE_LOG(event_engine_dns, INFO)
+        << "DNSServiceResolverImpl::ResolveCallback: sdRef: " << sdRef
+        << ", hostname: " << hostname << ", addressPort: "
+        << ResolvedAddressToString(resolved_address).value_or("ERROR")
+        << ", this: " << context;
   }
 
   // received both ipv4 and ipv6 responses, and no more responses (e.g. multiple
@@ -231,10 +227,9 @@ void DNSServiceResolverImpl::Shutdown() {
     for (auto& kv : that->requests_) {
       auto& sdRef = kv.first;
       auto& request = kv.second;
-      GRPC_EVENT_ENGINE_DNS_TRACE(
-          "DNSServiceResolverImpl::Shutdown sdRef: %p, this: %p", sdRef,
-          thatPtr);
-
+      GRPC_TRACE_LOG(event_engine_dns, INFO)
+          << "DNSServiceResolverImpl::Shutdown sdRef: " << sdRef
+          << ", this: " << thatPtr;
       request.on_resolve(
           absl::CancelledError("DNSServiceResolverImpl::Shutdown"));
       DNSServiceRefDeallocate(static_cast<DNSServiceRef>(sdRef));