grpc 1.64.0 → 1.65.0.pre2

data/src/core/{lib/http → util/http_client}/httpcli_security_connector.cc

@@ -16,10 +16,13 @@
 //
 //
 
+#include <grpc/support/port_platform.h>
+
 #include <string.h>
 
 #include <string>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -30,8 +33,6 @@
 #include <grpc/grpc_security.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/handshaker/handshaker.h"
@@ -94,8 +95,8 @@ class grpc_httpcli_ssl_channel_security_connector final
           handshaker_factory_, secure_peer_name_, /*network_bio_buf_size=*/0,
           /*ssl_bio_buf_size=*/0, &handshaker);
       if (result != TSI_OK) {
-        gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
-                tsi_result_to_string(result));
+        LOG(ERROR) << "Handshaker creation failed with error "
+                   << tsi_result_to_string(result);
       }
     }
     handshake_mgr->Add(SecurityHandshakerCreate(handshaker, this, args));
@@ -148,8 +149,7 @@ httpcli_ssl_channel_security_connector_create(
     const char* pem_root_certs, const tsi_ssl_root_certs_store* root_store,
     const char* secure_peer_name) {
   if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Cannot assert a secure peer name without a trust root.");
+    LOG(ERROR) << "Cannot assert a secure peer name without a trust root.";
     return nullptr;
   }
   RefCountedPtr<grpc_httpcli_ssl_channel_security_connector> c =
@@ -157,8 +157,8 @@ httpcli_ssl_channel_security_connector_create(
           secure_peer_name == nullptr ? nullptr : gpr_strdup(secure_peer_name));
   tsi_result result = c->InitHandshakerFactory(pem_root_certs, root_store);
   if (result != TSI_OK) {
-    gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
-            tsi_result_to_string(result));
+    LOG(ERROR) << "Handshaker factory creation failed with "
+               << tsi_result_to_string(result);
     return nullptr;
   }
   return c;
@@ -173,7 +173,7 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
     const tsi_ssl_root_certs_store* root_store =
         DefaultSslRootStore::GetRootStore();
     if (root_store == nullptr) {
-      gpr_log(GPR_ERROR, "Could not get default pem root certs.");
+      LOG(ERROR) << "Could not get default pem root certs.";
       return nullptr;
     }
     absl::optional<std::string> target_string =

data/src/core/{lib/http → util/http_client}/httpcli_ssl_credentials.h

@@ -14,12 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
-#define GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+#ifndef GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_SSL_CREDENTIALS_H
+#define GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_SSL_CREDENTIALS_H
 
-#include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
+#include <grpc/grpc.h>
+
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
@@ -35,4 +36,4 @@ RefCountedPtr<grpc_channel_credentials> CreateHttpRequestSSLCredentials();
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+#endif  // GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_SSL_CREDENTIALS_H

data/src/core/{lib/http → util/http_client}/parser.cc

@@ -16,7 +16,9 @@
 //
 //
 
-#include "src/core/lib/http/parser.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/http_client/parser.h"
 
 #include <string.h>
 
@@ -27,9 +29,6 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-
-grpc_core::TraceFlag grpc_http1_trace(false, "http1");
 
 static char* buf2str(void* buffer, size_t length) {
   char* out = static_cast<char*>(gpr_malloc(length + 1));
@@ -377,7 +376,7 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
     case GRPC_HTTP_HEADERS:
     case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(http1)) {
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
                   GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
         }

data/src/core/{lib/http → util/http_client}/parser.h

@@ -16,14 +16,15 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_HTTP_PARSER_H
-#define GRPC_SRC_CORE_LIB_HTTP_PARSER_H
+#ifndef GRPC_SRC_CORE_UTIL_HTTP_CLIENT_PARSER_H
+#define GRPC_SRC_CORE_UTIL_HTTP_CLIENT_PARSER_H
+
+#include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <grpc/slice.h>
-#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/error.h"
@@ -124,6 +125,4 @@ grpc_error_handle grpc_http_parser_eof(grpc_http_parser* parser);
 void grpc_http_request_destroy(grpc_http_request* request);
 void grpc_http_response_destroy(grpc_http_response* response);
 
-extern grpc_core::TraceFlag grpc_http1_trace;
-
-#endif  // GRPC_SRC_CORE_LIB_HTTP_PARSER_H
+#endif  // GRPC_SRC_CORE_UTIL_HTTP_CLIENT_PARSER_H

data/src/core/{lib → util}/json/json.h

@@ -14,16 +14,17 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_H
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_H
 
-#include <grpc/support/json.h>
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/json.h>
+
 namespace grpc_core {
 
 using Json = experimental::Json;
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_H

data/src/core/{lib → util}/json/json_args.h

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
-
-#include "absl/strings/string_view.h"
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_ARGS_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_ARGS_H
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 namespace grpc_core {
 
 class JsonArgs {
@@ -31,4 +31,4 @@ class JsonArgs {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_ARGS_H

data/src/core/{lib → util}/json/json_channel_args.h

@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_CHANNEL_ARGS_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_CHANNEL_ARGS_H
+
+#include <grpc/support/port_platform.h>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/json/json_args.h"
+#include "src/core/util/json/json_args.h"
 
 namespace grpc_core {
 
@@ -39,4 +39,4 @@ class JsonChannelArgs : public JsonArgs {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_CHANNEL_ARGS_H

data/src/core/{lib → util}/json/json_object_loader.cc

@@ -12,7 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/json/json_object_loader.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/json/json_object_loader.h"
 
 #include <utility>
 
@@ -21,7 +23,6 @@
 #include "absl/strings/strip.h"
 
 #include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 namespace json_detail {

data/src/core/{lib → util}/json/json_object_loader.h

@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_OBJECT_LOADER_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_OBJECT_LOADER_H
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_OBJECT_LOADER_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_OBJECT_LOADER_H
+
+#include <grpc/support/port_platform.h>
 
 #include <cstdint>
 #include <cstring>
@@ -30,14 +32,12 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
 
 // Provides a means to load JSON objects into C++ objects, with the aim of
 // minimizing object code size.
@@ -642,4 +642,4 @@ absl::optional<T> LoadJsonObjectField(const Json::Object& json,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_OBJECT_LOADER_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_OBJECT_LOADER_H

data/src/core/{lib → util}/json/json_reader.cc

@@ -14,6 +14,8 @@
 // limitations under the License.
 //
 
+#include <grpc/support/port_platform.h>
+
 #include <inttypes.h>
 #include <stdlib.h>
 
@@ -35,10 +37,9 @@
 
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/match.h"
-#include "src/core/lib/json/json.h"
+#include "src/core/util/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255
 #define GRPC_JSON_MAX_ERRORS 16

data/src/core/{lib → util}/json/json_reader.h

@@ -14,15 +14,15 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_READER_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_READER_H
+
+#include <grpc/support/port_platform.h>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/json/json.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
@@ -31,4 +31,4 @@ absl::StatusOr<Json> JsonParse(absl::string_view json_str);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_READER_H

data/src/core/{lib → util}/json/json_util.cc

@@ -16,14 +16,14 @@
 //
 //
 
-#include "src/core/lib/json/json_util.h"
-
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/json/json_util.h"
+
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 
 namespace grpc_core {
 

data/src/core/{lib → util}/json/json_util.h

@@ -16,8 +16,10 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_UTIL_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_UTIL_H
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_UTIL_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_UTIL_H
+
+#include <grpc/support/port_platform.h>
 
 #include <algorithm>
 #include <map>
@@ -30,11 +32,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/json/json.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
@@ -161,4 +161,4 @@ bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_UTIL_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_UTIL_H

data/src/core/{lib → util}/json/json_writer.cc

@@ -16,6 +16,8 @@
 //
 //
 
+#include <grpc/support/port_platform.h>
+
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -26,9 +28,7 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/json/json.h"
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 

data/src/core/{lib → util}/json/json_writer.h

@@ -14,14 +14,14 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
-#define GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
-
-#include <string>
+#ifndef GRPC_SRC_CORE_UTIL_JSON_JSON_WRITER_H
+#define GRPC_SRC_CORE_UTIL_JSON_JSON_WRITER_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/json/json.h"
+#include <string>
+
+#include "src/core/util/json/json.h"
 
 namespace grpc_core {
 
@@ -30,4 +30,4 @@ std::string JsonDump(const Json& json, int indent = 0);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
+#endif  // GRPC_SRC_CORE_UTIL_JSON_JSON_WRITER_H

data/src/core/{lib/gpr → util}/linux/log.cc

@@ -47,10 +47,6 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/examine_stack.h"
 
-int gpr_should_log_stacktrace(gpr_log_severity severity);
-
-static long sys_gettid(void) { return syscall(__NR_gettid); }
-
 void gpr_log(const char* file, int line, gpr_log_severity severity,
              const char* format, ...) {
   // Avoid message construction if gpr_log_message won't log
@@ -70,45 +66,4 @@ void gpr_log(const char* file, int line, gpr_log_severity severity,
   free(message);
 }
 
-void gpr_platform_log(gpr_log_func_args* args) {
-  const char* final_slash;
-  const char* display_file;
-  char time_buffer[64];
-  time_t timer;
-  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-  struct tm tm;
-  static thread_local long tid(0);
-  if (tid == 0) tid = sys_gettid();
-
-  timer = static_cast<time_t>(now.tv_sec);
-  final_slash = strrchr(args->file, '/');
-  if (final_slash == nullptr) {
-    display_file = args->file;
-  } else {
-    display_file = final_slash + 1;
-  }
-
-  if (!localtime_r(&timer, &tm)) {
-    strcpy(time_buffer, "error:localtime");
-  } else if (0 ==
-             strftime(time_buffer, sizeof(time_buffer), "%m%d %H:%M:%S", &tm)) {
-    strcpy(time_buffer, "error:strftime");
-  }
-
-  std::string prefix = absl::StrFormat(
-      "%s%s.%09" PRId32 " %7ld %s:%d]", gpr_log_severity_string(args->severity),
-      time_buffer, now.tv_nsec, tid, display_file, args->line);
-
-  absl::optional<std::string> stack_trace =
-      gpr_should_log_stacktrace(args->severity)
-          ? grpc_core::GetCurrentStackTrace()
-          : absl::nullopt;
-  if (stack_trace) {
-    fprintf(stderr, "%-70s %s\n%s\n", prefix.c_str(), args->message,
-            stack_trace->c_str());
-  } else {
-    fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message);
-  }
-}
-
 #endif  // GPR_LINUX_LOG

data/src/core/util/log.cc

@@ -0,0 +1,165 @@
+//
+//
+// 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.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/log/log.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "absl/log/globals.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/config/config_vars.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/string.h"
+
+void gpr_default_log(gpr_log_func_args* args);
+void gpr_platform_log(gpr_log_func_args* args);
+static gpr_atm g_log_func = reinterpret_cast<gpr_atm>(gpr_default_log);
+
+void gpr_unreachable_code(const char* reason, const char* file, int line) {
+  grpc_core::Crash(absl::StrCat("UNREACHABLE CODE: ", reason),
+                   grpc_core::SourceLocation(file, line));
+}
+
+void gpr_assertion_failed(const char* filename, int line, const char* message) {
+  grpc_core::Crash(absl::StrCat("ASSERTION FAILED: ", message),
+                   grpc_core::SourceLocation(filename, line));
+}
+
+const char* gpr_log_severity_string(gpr_log_severity severity) {
+  switch (severity) {
+    case GPR_LOG_SEVERITY_DEBUG:
+      return "D";
+    case GPR_LOG_SEVERITY_INFO:
+      return "I";
+    case GPR_LOG_SEVERITY_ERROR:
+      return "E";
+  }
+  GPR_UNREACHABLE_CODE(return "UNKNOWN");
+}
+
+int gpr_should_log(gpr_log_severity severity) {
+  switch (severity) {
+    case GPR_LOG_SEVERITY_ERROR:
+      return absl::MinLogLevel() <= absl::LogSeverityAtLeast::kError;
+    case GPR_LOG_SEVERITY_INFO:
+      // There is no documentation about how expensive or inexpensive
+      // MinLogLevel is. We could have saved this in a static const variable.
+      // But decided against it just in case anyone programatically sets absl
+      // min log level settings after this has been initialized.
+      // Same holds for VLOG_IS_ON(2).
+      return absl::MinLogLevel() <= absl::LogSeverityAtLeast::kInfo;
+    case GPR_LOG_SEVERITY_DEBUG:
+      return VLOG_IS_ON(2);
+    default:
+      DLOG(ERROR) << "Invalid gpr_log_severity.";
+      return true;
+  }
+}
+
+void gpr_default_log(gpr_log_func_args* args) {
+  switch (args->severity) {
+    case GPR_LOG_SEVERITY_DEBUG:
+      //  Log DEBUG messages as VLOG(2).
+      VLOG(2).AtLocation(args->file, args->line) << args->message;
+      return;
+    case GPR_LOG_SEVERITY_INFO:
+      LOG(INFO).AtLocation(args->file, args->line) << args->message;
+      return;
+    case GPR_LOG_SEVERITY_ERROR:
+      LOG(ERROR).AtLocation(args->file, args->line) << args->message;
+      return;
+    default:
+      LOG(ERROR) << __func__ << ": unknown gpr log severity(" << args->severity
+                 << "), using ERROR";
+      LOG(ERROR).AtLocation(args->file, args->line) << args->message;
+  }
+}
+
+void gpr_log_message(const char* file, int line, gpr_log_severity severity,
+                     const char* message) {
+  if (gpr_should_log(severity) == 0) {
+    return;
+  }
+
+  gpr_log_func_args lfargs;
+  memset(&lfargs, 0, sizeof(lfargs));
+  lfargs.file = file;
+  lfargs.line = line;
+  lfargs.severity = severity;
+  lfargs.message = message;
+  reinterpret_cast<gpr_log_func>(gpr_atm_no_barrier_load(&g_log_func))(&lfargs);
+}
+
+void gpr_set_log_verbosity(
+    [[maybe_unused]] gpr_log_severity deprecated_setting) {
+  LOG(ERROR)
+      << "This will not be set. Please set this via absl log level settings.";
+}
+
+void gpr_log_verbosity_init(void) {
+// This is enabled in Github only.
+// This ifndef is converted to ifdef internally by copybara.
+// Internally grpc verbosity is managed using absl settings.
+// So internally we avoid setting it like this.
+#ifndef GRPC_VERBOSITY_MACRO
+  // SetMinLogLevel sets the value for the entire binary, not just gRPC.
+  // This setting will change things for other libraries/code that is unrelated
+  // to grpc.
+  absl::string_view verbosity = grpc_core::ConfigVars::Get().Verbosity();
+  DVLOG(2) << "Log verbosity: " << verbosity;
+  if (absl::EqualsIgnoreCase(verbosity, "INFO")) {
+    LOG(WARNING) << "Not suitable for production. Prefer WARNING or ERROR. "
+                    "However if you see this message in a debug environmenmt "
+                    "or test environmenmt it is safe to ignore this message.";
+    absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfo);
+  } else if (absl::EqualsIgnoreCase(verbosity, "DEBUG")) {
+    LOG(WARNING) << "Not suitable for production. Prefer WARNING or ERROR. "
+                    "However if you see this message in a debug environmenmt "
+                    "or test environmenmt it is safe to ignore this message.";
+    absl::SetVLogLevel("*grpc*/*", 2);
+    absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfo);
+  } else if (absl::EqualsIgnoreCase(verbosity, "ERROR")) {
+    absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetMinLogLevel(absl::LogSeverityAtLeast::kError);
+  } else if (absl::EqualsIgnoreCase(verbosity, "NONE")) {
+    absl::SetVLogLevel("*grpc*/*", -1);
+    absl::SetMinLogLevel(absl::LogSeverityAtLeast::kInfinity);
+  } else if (verbosity.empty()) {
+    // Do not alter absl settings if GRPC_VERBOSITY flag is not set.
+  } else {
+    LOG(ERROR) << "Unknown log verbosity: " << verbosity;
+  }
+#endif  // GRPC_VERBOSITY_MACRO
+}
+
+void gpr_set_log_function([[maybe_unused]] gpr_log_func deprecated_setting) {
+  LOG(ERROR)
+      << "This function is deprecated. This function will be deleted in the "
+         "next gRPC release. You may create a new absl LogSink with similar "
+         "functionality. gRFC: https://github.com/grpc/proposal/pull/425 ";
+}

data/src/core/{lib/gpr → util}/msys/tmpfile.cc

@@ -29,9 +29,9 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string_windows.h"
-#include "src/core/lib/gpr/tmpfile.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/string_windows.h"
+#include "src/core/util/tmpfile.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
   FILE* result = NULL;

data/src/core/{lib/gpr → util}/posix/cpu.cc

@@ -29,8 +29,8 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/util/useful.h"
 
 static long ncpus = 0;