src/core/BUILD

@@ -4870,7 +4870,6 @@ grpc_cc_library(
         "absl/container:inlined_vector",
         "absl/functional:function_ref",
         "absl/log:check",
-        "absl/log:globals",
         "absl/log:log",
         "absl/status",
         "absl/status:statusor",

src/core/load_balancing/grpclb/grpclb.cc

@@ -73,8 +73,6 @@
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/function_ref.h"
 #include "absl/log/check.h"
-#include "absl/log/globals.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -1164,12 +1162,13 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
   upb::Arena arena;
   if (!GrpcLbResponseParse(response_slice, arena.ptr(), &response) ||
       (response.type == response.INITIAL && seen_initial_response_)) {
-    if (absl::MinLogLevel() <= absl::LogSeverityAtLeast::kError) {
+    if (gpr_should_log(GPR_LOG_SEVERITY_ERROR)) {
       char* response_slice_str =
           grpc_dump_slice(response_slice, GPR_DUMP_ASCII | GPR_DUMP_HEX);
-      LOG(ERROR) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-                 << ": Invalid LB response received: '" << response_slice_str
-                 << "'. Ignoring.";
+      gpr_log(GPR_ERROR,
+              "[grpclb %p] lb_calld=%p: Invalid LB response received: '%s'. "
+              "Ignoring.",
+              grpclb_policy(), this, response_slice_str);
       gpr_free(response_slice_str);
     }
   } else {

src/cpp/ext/gcp/environment_autodetect.cc

@@ -23,12 +23,12 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpcpp/impl/grpc_library.h>
@@ -64,8 +64,8 @@ std::string GetNamespaceName() {
   auto namespace_name = grpc_core::LoadFile(filename, false);
   if (!namespace_name.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(environment_autodetect)) {
-      VLOG(2) << "Reading file " << filename << " failed: "
-              << grpc_core::StatusToString(namespace_name.status());
+      gpr_log(GPR_DEBUG, "Reading file %s failed: %s", filename,
+              grpc_core::StatusToString(namespace_name.status()).c_str());
     }
     // Fallback on an environment variable
     return grpc_core::GetEnv("NAMESPACE_NAME").value_or("");
@@ -249,12 +249,13 @@ class EnvironmentAutoDetectHelper
           element.first, &pollent_,
           [this](std::string attribute, absl::StatusOr<std::string> result) {
             if (GRPC_TRACE_FLAG_ENABLED(environment_autodetect)) {
-              LOG(INFO) << "Environment AutoDetect: Attribute: \"" << attribute
-                        << "\" Result: \""
-                        << (result.ok()
-                                ? result.value()
-                                : grpc_core::StatusToString(result.status()))
-                        << "\"";
+              gpr_log(
+                  GPR_INFO,
+                  "Environment AutoDetect: Attribute: \"%s\" Result: \"%s\"",
+                  attribute.c_str(),
+                  result.ok()
+                      ? result.value().c_str()
+                      : grpc_core::StatusToString(result.status()).c_str());
             }
             absl::optional<EnvironmentAutoDetect::ResourceType> resource;
             {
@@ -269,8 +270,9 @@ class EnvironmentAutoDetectHelper
                 // assuming a GCE environment, fallback to "global".
                 else if (assuming_gce_) {
                   if (GRPC_TRACE_FLAG_ENABLED(environment_autodetect)) {
-                    LOG(INFO) << "Environment Autodetect: Falling back to "
-                                 "global resource type";
+                    gpr_log(GPR_INFO,
+                            "Environment Autodetect: Falling back to global "
+                            "resource type");
                   }
                   assuming_gce_ = false;
                   resource_.resource_type = "global";
@@ -278,9 +280,10 @@ class EnvironmentAutoDetectHelper
                 attributes_to_fetch_.erase(it);
               } else {
                 // This should not happen
-                LOG(ERROR) << "An unexpected attribute was seen from the "
-                              "MetadataServer: "
-                           << attribute;
+                gpr_log(GPR_ERROR,
+                        "An unexpected attribute was seen from the "
+                        "MetadataServer: %s",
+                        attribute.c_str());
               }
               if (attributes_to_fetch_.empty()) {
                 resource = std::move(resource_);

src/cpp/server/backend_metric_recorder.cc

@@ -24,8 +24,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/log.h"
-
 #include <grpc/support/log.h>
 #include <grpcpp/ext/call_metric_recorder.h>
 #include <grpcpp/ext/server_metric_recorder.h>
@@ -71,36 +69,36 @@ void ServerMetricRecorder::UpdateBackendMetricDataState(
 void ServerMetricRecorder::SetCpuUtilization(double value) {
   if (!IsUtilizationWithSoftLimitsValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] CPU utilization rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] CPU utilization rejected: %f", this, value);
     }
     return;
   }
   UpdateBackendMetricDataState(
       [value](BackendMetricData* data) { data->cpu_utilization = value; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] CPU utilization set: " << value;
+    gpr_log(GPR_INFO, "[%p] CPU utilization set: %f", this, value);
   }
 }
 
 void ServerMetricRecorder::SetMemoryUtilization(double value) {
   if (!IsUtilizationValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] Mem utilization rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] Mem utilization rejected: %f", this, value);
     }
     return;
   }
   UpdateBackendMetricDataState(
       [value](BackendMetricData* data) { data->mem_utilization = value; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Mem utilization set: " << value;
+    gpr_log(GPR_INFO, "[%p] Mem utilization set: %f", this, value);
   }
 }
 
 void ServerMetricRecorder::SetApplicationUtilization(double value) {
   if (!IsUtilizationWithSoftLimitsValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this
-                << "] Application utilization rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] Application utilization rejected: %f", this,
+              value);
     }
     return;
   }
@@ -108,49 +106,49 @@ void ServerMetricRecorder::SetApplicationUtilization(double value) {
     data->application_utilization = value;
   });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Application utilization set: " << value;
+    gpr_log(GPR_INFO, "[%p] Application utilization set: %f", this, value);
   }
 }
 
 void ServerMetricRecorder::SetQps(double value) {
   if (!IsRateValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] QPS rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] QPS rejected: %f", this, value);
     }
     return;
   }
   UpdateBackendMetricDataState(
       [value](BackendMetricData* data) { data->qps = value; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] QPS set: " << value;
+    gpr_log(GPR_INFO, "[%p] QPS set: %f", this, value);
   }
 }
 
 void ServerMetricRecorder::SetEps(double value) {
   if (!IsRateValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] EPS rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] EPS rejected: %f", this, value);
     }
     return;
   }
   UpdateBackendMetricDataState(
       [value](BackendMetricData* data) { data->eps = value; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] EPS set: " << value;
+    gpr_log(GPR_INFO, "[%p] EPS set: %f", this, value);
   }
 }
 
 void ServerMetricRecorder::SetNamedUtilization(string_ref name, double value) {
   if (!IsUtilizationValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] Named utilization rejected: " << value
-                << " name: " << std::string(name.data(), name.size());
+      gpr_log(GPR_INFO, "[%p] Named utilization rejected: %f name: %s", this,
+              value, std::string(name.data(), name.size()).c_str());
     }
     return;
   }
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Named utilization set: " << value
-              << " name: " << std::string(name.data(), name.size());
+    gpr_log(GPR_INFO, "[%p] Named utilization set: %f name: %s", this, value,
+            std::string(name.data(), name.size()).c_str());
   }
   UpdateBackendMetricDataState([name, value](BackendMetricData* data) {
     data->utilization[absl::string_view(name.data(), name.size())] = value;
@@ -160,8 +158,8 @@ void ServerMetricRecorder::SetNamedUtilization(string_ref name, double value) {
 void ServerMetricRecorder::SetAllNamedUtilization(
     std::map<string_ref, double> named_utilization) {
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] All named utilization updated. size: "
-              << named_utilization.size();
+    gpr_log(GPR_INFO, "[%p] All named utilization updated. size: %" PRIuPTR,
+            this, named_utilization.size());
   }
   UpdateBackendMetricDataState(
       [utilization = std::move(named_utilization)](BackendMetricData* data) {
@@ -177,7 +175,7 @@ void ServerMetricRecorder::ClearCpuUtilization() {
   UpdateBackendMetricDataState(
       [](BackendMetricData* data) { data->cpu_utilization = -1; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] CPU utilization cleared.";
+    gpr_log(GPR_INFO, "[%p] CPU utilization cleared.", this);
   }
 }
 
@@ -185,7 +183,7 @@ void ServerMetricRecorder::ClearMemoryUtilization() {
   UpdateBackendMetricDataState(
       [](BackendMetricData* data) { data->mem_utilization = -1; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Mem utilization cleared.";
+    gpr_log(GPR_INFO, "[%p] Mem utilization cleared.", this);
   }
 }
 
@@ -193,28 +191,28 @@ void ServerMetricRecorder::ClearApplicationUtilization() {
   UpdateBackendMetricDataState(
       [](BackendMetricData* data) { data->application_utilization = -1; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Application utilization cleared.";
+    gpr_log(GPR_INFO, "[%p] Application utilization cleared.", this);
   }
 }
 
 void ServerMetricRecorder::ClearQps() {
   UpdateBackendMetricDataState([](BackendMetricData* data) { data->qps = -1; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] QPS utilization cleared.";
+    gpr_log(GPR_INFO, "[%p] QPS utilization cleared.", this);
   }
 }
 
 void ServerMetricRecorder::ClearEps() {
   UpdateBackendMetricDataState([](BackendMetricData* data) { data->eps = -1; });
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] EPS utilization cleared.";
+    gpr_log(GPR_INFO, "[%p] EPS utilization cleared.", this);
   }
 }
 
 void ServerMetricRecorder::ClearNamedUtilization(string_ref name) {
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Named utilization cleared. name: "
-              << std::string(name.data(), name.size());
+    gpr_log(GPR_INFO, "[%p] Named utilization cleared. name: %s", this,
+            std::string(name.data(), name.size()).c_str());
   }
   UpdateBackendMetricDataState([name](BackendMetricData* data) {
     data->utilization.erase(absl::string_view(name.data(), name.size()));
@@ -235,13 +233,12 @@ ServerMetricRecorder::GetMetricsIfChanged() const {
   }
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
     const auto& data = result->data;
-    LOG(INFO) << "[" << this
-              << "] GetMetrics() returned: seq:" << result->sequence_number
-              << " cpu:" << data.cpu_utilization
-              << " mem:" << data.mem_utilization
-              << " app:" << data.application_utilization << " qps:" << data.qps
-              << " eps:" << data.eps
-              << " utilization size: " << data.utilization.size();
+    gpr_log(GPR_INFO,
+            "[%p] GetMetrics() returned: seq:%" PRIu64
+            " cpu:%f mem:%f app:%f qps:%f eps:%f utilization size: %" PRIuPTR,
+            this, result->sequence_number, data.cpu_utilization,
+            data.mem_utilization, data.application_utilization, data.qps,
+            data.eps, data.utilization.size());
   }
   return result;
 }
@@ -252,13 +249,13 @@ experimental::CallMetricRecorder&
 BackendMetricState::RecordCpuUtilizationMetric(double value) {
   if (!IsUtilizationWithSoftLimitsValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] CPU utilization value rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] CPU utilization value rejected: %f", this, value);
     }
     return *this;
   }
   cpu_utilization_.store(value, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] CPU utilization recorded: " << value;
+    gpr_log(GPR_INFO, "[%p] CPU utilization recorded: %f", this, value);
   }
   return *this;
 }
@@ -267,13 +264,13 @@ experimental::CallMetricRecorder&
 BackendMetricState::RecordMemoryUtilizationMetric(double value) {
   if (!IsUtilizationValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] Mem utilization value rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] Mem utilization value rejected: %f", this, value);
     }
     return *this;
   }
   mem_utilization_.store(value, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Mem utilization recorded: " << value;
+    gpr_log(GPR_INFO, "[%p] Mem utilization recorded: %f", this, value);
   }
   return *this;
 }
@@ -282,14 +279,14 @@ experimental::CallMetricRecorder&
 BackendMetricState::RecordApplicationUtilizationMetric(double value) {
   if (!IsUtilizationWithSoftLimitsValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this
-                << "] Application utilization value rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] Application utilization value rejected: %f", this,
+              value);
     }
     return *this;
   }
   application_utilization_.store(value, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Application utilization recorded: " << value;
+    gpr_log(GPR_INFO, "[%p] Application utilization recorded: %f", this, value);
   }
   return *this;
 }
@@ -298,13 +295,13 @@ experimental::CallMetricRecorder& BackendMetricState::RecordQpsMetric(
     double value) {
   if (!IsRateValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] QPS value rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] QPS value rejected: %f", this, value);
     }
     return *this;
   }
   qps_.store(value, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] QPS recorded: " << value;
+    gpr_log(GPR_INFO, "[%p] QPS recorded: %f", this, value);
   }
   return *this;
 }
@@ -313,13 +310,13 @@ experimental::CallMetricRecorder& BackendMetricState::RecordEpsMetric(
     double value) {
   if (!IsRateValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] EPS value rejected: " << value;
+      gpr_log(GPR_INFO, "[%p] EPS value rejected: %f", this, value);
     }
     return *this;
   }
   eps_.store(value, std::memory_order_relaxed);
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] EPS recorded: " << value;
+    gpr_log(GPR_INFO, "[%p] EPS recorded: %f", this, value);
   }
   return *this;
 }
@@ -328,8 +325,8 @@ experimental::CallMetricRecorder& BackendMetricState::RecordUtilizationMetric(
     string_ref name, double value) {
   if (!IsUtilizationValid(value)) {
     if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-      LOG(INFO) << "[" << this << "] Utilization value rejected: "
-                << std::string(name.data(), name.length()) << " " << value;
+      gpr_log(GPR_INFO, "[%p] Utilization value rejected: %s %f", this,
+              std::string(name.data(), name.length()).c_str(), value);
     }
     return *this;
   }
@@ -337,8 +334,8 @@ experimental::CallMetricRecorder& BackendMetricState::RecordUtilizationMetric(
   absl::string_view name_sv(name.data(), name.length());
   utilization_[name_sv] = value;
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Utilization recorded: " << name_sv << " "
-              << value;
+    gpr_log(GPR_INFO, "[%p] Utilization recorded: %s %f", this,
+            std::string(name_sv).c_str(), value);
   }
   return *this;
 }
@@ -349,8 +346,8 @@ experimental::CallMetricRecorder& BackendMetricState::RecordRequestCostMetric(
   absl::string_view name_sv(name.data(), name.length());
   request_cost_[name_sv] = value;
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Request cost recorded: " << name_sv << " "
-              << value;
+    gpr_log(GPR_INFO, "[%p] Request cost recorded: %s %f", this,
+            std::string(name_sv).c_str(), value);
   }
   return *this;
 }
@@ -361,8 +358,8 @@ experimental::CallMetricRecorder& BackendMetricState::RecordNamedMetric(
   absl::string_view name_sv(name.data(), name.length());
   named_metrics_[name_sv] = value;
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this << "] Named metric recorded: " << name_sv << " "
-              << value;
+    gpr_log(GPR_INFO, "[%p] Named metric recorded: %s %f", this,
+            std::string(name_sv).c_str(), value);
   }
   return *this;
 }
@@ -409,13 +406,13 @@ BackendMetricData BackendMetricState::GetBackendMetricData() {
     }
   }
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    LOG(INFO) << "[" << this
-              << "] Backend metric data returned: cpu:" << data.cpu_utilization
-              << " mem:" << data.mem_utilization << " qps:" << data.qps
-              << " eps:" << data.eps
-              << " utilization size:" << data.utilization.size()
-              << " request_cost size:" << data.request_cost.size()
-              << "named_metrics size:" << data.named_metrics.size();
+    gpr_log(GPR_INFO,
+            "[%p] Backend metric data returned: cpu:%f mem:%f qps:%f eps:%f "
+            "utilization size:%" PRIuPTR " request_cost size:%" PRIuPTR
+            "named_metrics size:%" PRIuPTR,
+            this, data.cpu_utilization, data.mem_utilization, data.qps,
+            data.eps, data.utilization.size(), data.request_cost.size(),
+            data.named_metrics.size());
   }
   return data;
 }

tools/run_tests/helper_scripts/build_python.sh

@@ -219,7 +219,7 @@ pip_install_dir "$ROOT/src/python/grpcio_testing"
 # shellcheck disable=SC2261
 pip_install coverage==7.2.0 oauth2client==4.1.0 \
             google-auth>=1.35.0 requests==2.31.0 \
-            rsa==4.0 absl-py==1.4.0 \
+            googleapis-common-protos>=1.5.5 rsa==4.0 absl-py==1.4.0 \
             opentelemetry-sdk==1.21.0
 $VENV_PYTHON "$ROOT/src/python/grpcio_tests/setup.py" preprocess
 $VENV_PYTHON "$ROOT/src/python/grpcio_tests/setup.py" build_package_protos