grpc 1.63.0 → 1.65.2

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/status_util.h"
 
 #include <string.h>
@@ -27,7 +25,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
-#include "src/core/lib/gpr/useful.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/useful.h"
 
 struct status_string_entry {
   const char* str;

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

@@ -19,14 +19,13 @@
 #ifndef GRPC_SRC_CORE_LIB_CHANNEL_STATUS_UTIL_H
 #define GRPC_SRC_CORE_LIB_CHANNEL_STATUS_UTIL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/status.h>
+#include <grpc/support/port_platform.h>
 
 /// If \a status_str is a valid status string, sets \a status to the
 /// corresponding status value and returns true.

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <string.h>
 
@@ -26,12 +24,13 @@
 #include <grpc/compression.h>
 #include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #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/compression_internal.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/compression/compression_internal.h"
 
 #include <stdlib.h>
@@ -25,12 +23,14 @@
 #include <string>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/log/check.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 
 #include <grpc/compression.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -121,7 +121,7 @@ CompressionAlgorithmSet::CompressionAlgorithmForLevel(
     return GRPC_COMPRESS_NONE;
   }
 
-  GPR_ASSERT(level > 0);
+  CHECK_GT(level, 0);
 
   // Establish a "ranking" or compression algorithms in increasing order of
   // compression.

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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H
 #define GRPC_SRC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <initializer_list>
@@ -29,6 +27,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/compression_types.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/bitset.h"

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/compression/message_compress.h"
 
 #include <string.h>
@@ -25,9 +23,12 @@
 #include <zconf.h>
 #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"
 
@@ -42,40 +43,40 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
   const uInt uint_max = ~uInt{0};
 
-  GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
+  CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
   zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
   zs->next_out = GRPC_SLICE_START_PTR(outbuf);
   flush = Z_NO_FLUSH;
   for (i = 0; i < input->count; i++) {
     if (i == input->count - 1) flush = Z_FINISH;
-    GPR_ASSERT(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
+    CHECK(GRPC_SLICE_LENGTH(input->slices[i]) <= uint_max);
     zs->avail_in = static_cast<uInt> GRPC_SLICE_LENGTH(input->slices[i]);
     zs->next_in = GRPC_SLICE_START_PTR(input->slices[i]);
     do {
       if (zs->avail_out == 0) {
         grpc_slice_buffer_add_indexed(output, outbuf);
         outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
-        GPR_ASSERT(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
+        CHECK(GRPC_SLICE_LENGTH(outbuf) <= uint_max);
         zs->avail_out = static_cast<uInt> GRPC_SLICE_LENGTH(outbuf);
         zs->next_out = GRPC_SLICE_START_PTR(outbuf);
       }
       r = flate(zs, flush);
       if (r < 0 && r != Z_BUF_ERROR /* not fatal */) {
-        gpr_log(GPR_INFO, "zlib error (%d)", r);
+        VLOG(2) << "zlib error (" << r << ")";
         goto error;
       }
     } while (zs->avail_out == 0);
     if (zs->avail_in) {
-      gpr_log(GPR_INFO, "zlib: not all input consumed");
+      VLOG(2) << "zlib: not all input consumed";
       goto error;
     }
   }
   if (r != Z_STREAM_END) {
-    gpr_log(GPR_INFO, "zlib: Data error");
+    VLOG(2) << "zlib: Data error";
     goto error;
   }
 
-  GPR_ASSERT(outbuf.refcount);
+  CHECK(outbuf.refcount);
   outbuf.data.refcounted.length -= zs->avail_out;
   grpc_slice_buffer_add_indexed(output, outbuf);
 
@@ -105,7 +106,7 @@ static int zlib_compress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   zs.zfree = zfree_gpr;
   r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
                    8, Z_DEFAULT_STRATEGY);
-  GPR_ASSERT(r == Z_OK);
+  CHECK(r == Z_OK);
   r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
   if (!r) {
     for (i = count_before; i < output->count; i++) {
@@ -129,7 +130,7 @@ static int zlib_decompress(grpc_slice_buffer* input, grpc_slice_buffer* output,
   zs.zalloc = zalloc_gpr;
   zs.zfree = zfree_gpr;
   r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
-  GPR_ASSERT(r == Z_OK);
+  CHECK(r == Z_OK);
   r = zlib_body(&zs, input, output, inflate);
   if (!r) {
     for (i = count_before; i < output->count; i++) {
@@ -164,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;
 }
 
@@ -189,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/compression/message_compress.h

@@ -19,10 +19,9 @@
 #ifndef GRPC_SRC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
 #define GRPC_SRC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 // compress 'input' to 'output' using 'algorithm'.
 // On success, appends compressed slices to output and returns 1.

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

@@ -16,17 +16,17 @@
 // Automatically generated by tools/codegen/core/gen_config_vars.py
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/config/config_vars.h"
 
 #include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
 
+#include <grpc/support/port_platform.h>
+
 #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

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_LIB_CONFIG_CONFIG_VARS_H
 #define GRPC_SRC_CORE_LIB_CONFIG_CONFIG_VARS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <atomic>
@@ -29,6 +27,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class GPR_DLL ConfigVars {
@@ -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/config/config_vars_non_generated.cc

@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <string>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/config/config_vars.h"
 
 namespace grpc_core {

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

@@ -12,15 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/config/core_configuration.h"
 
 #include <atomic>
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
@@ -50,18 +51,18 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
 
 void CoreConfiguration::RegisterBuilder(
     absl::AnyInvocable<void(Builder*)> builder) {
-  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
-             "CoreConfiguration was already instantiated before builder "
-             "registration was completed");
+  CHECK(config_.load(std::memory_order_relaxed) == nullptr)
+      << "CoreConfiguration was already instantiated before builder "
+         "registration was completed";
   RegisteredBuilder* n = new RegisteredBuilder();
   n->builder = std::move(builder);
   n->next = builders_.load(std::memory_order_relaxed);
   while (!builders_.compare_exchange_weak(n->next, n, std::memory_order_acq_rel,
                                           std::memory_order_relaxed)) {
   }
-  GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&
-             "CoreConfiguration was already instantiated before builder "
-             "registration was completed");
+  CHECK(config_.load(std::memory_order_relaxed) == nullptr)
+      << "CoreConfiguration was already instantiated before builder "
+         "registration was completed";
 }
 
 const CoreConfiguration& CoreConfiguration::BuildNewAndMaybeSet() {

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

@@ -15,20 +15,20 @@
 #ifndef GRPC_SRC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 #define GRPC_SRC_CORE_LIB_CONFIG_CORE_CONFIGURATION_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/handshaker/handshaker_registry.h"
+#include "src/core/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/surface/channel_init.h"
-#include "src/core/lib/transport/handshaker_registry.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/service_config/service_config_parser.h"
@@ -130,10 +130,10 @@ class GRPC_DLL CoreConfiguration {
     ~WithSubstituteBuilder() {
       // Reset and restore.
       Reset();
-      GPR_ASSERT(CoreConfiguration::config_.exchange(
-                     config_restore_, std::memory_order_acquire) == nullptr);
-      GPR_ASSERT(CoreConfiguration::builders_.exchange(
-                     builders_restore_, std::memory_order_acquire) == nullptr);
+      CHECK(CoreConfiguration::config_.exchange(
+                config_restore_, std::memory_order_acquire) == nullptr);
+      CHECK(CoreConfiguration::builders_.exchange(
+                builders_restore_, std::memory_order_acquire) == nullptr);
     }
 
    private:

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

@@ -12,18 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/config/load_config.h"
 
 #include <stdio.h>
 
 #include "absl/flags/marshalling.h"
+#include "absl/log/check.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_join.h"
 #include "absl/types/optional.h"
 
-#include "src/core/lib/gpr/log_internal.h"
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/env.h"
 
 namespace grpc_core {
@@ -36,7 +36,7 @@ absl::optional<std::string> LoadEnv(absl::string_view environment_variable) {
 
 std::string LoadConfigFromEnv(absl::string_view environment_variable,
                               const char* default_value) {
-  GPR_ASSERT_INTERNAL(!environment_variable.empty());
+  CHECK(!environment_variable.empty());
   return LoadEnv(environment_variable).value_or(default_value);
 }
 

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H
 #define GRPC_SRC_CORE_LIB_CONFIG_LOAD_CONFIG_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <string>
@@ -26,6 +24,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 std::string LoadConfigFromEnv(absl::string_view environment_variable,

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

@@ -12,24 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/debug/event_log.h"
 
 #include <algorithm>
 #include <atomic>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
 std::atomic<EventLog*> EventLog::g_instance_{nullptr};
 
 EventLog::~EventLog() {
-  GPR_ASSERT(g_instance_.load(std::memory_order_acquire) != this);
+  CHECK(g_instance_.load(std::memory_order_acquire) != this);
 }
 
 void EventLog::BeginCollection() {

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_DEBUG_EVENT_LOG_H
 #define GRPC_SRC_CORE_LIB_DEBUG_EVENT_LOG_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <atomic>
@@ -27,9 +25,11 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 
-#include "src/core/lib/gpr/time_precise.h"
+#include <grpc/support/port_platform.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 {