grpc 1.64.3 → 1.65.0

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

@@ -26,7 +26,7 @@
 #include "src/core/lib/config/load_config.h"
 
 #ifndef GPR_DEFAULT_LOG_VERBOSITY_STRING
-#define GPR_DEFAULT_LOG_VERBOSITY_STRING "ERROR"
+#define GPR_DEFAULT_LOG_VERBOSITY_STRING ""
 #endif  // !GPR_DEFAULT_LOG_VERBOSITY_STRING
 
 #ifdef GRPC_ENABLE_FORK_SUPPORT
@@ -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