[Gpr_To_Absl_Logging] Replace gpr_should_log with absl::MinLogLevel() (#36870)

[Gpr_To_Absl_Logging] Replace gpr_should_log with absl::MinLogLevel()

Closes #36870

COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/36870 from tanvi-jagtap:fix_tcp_windows_gpr_should_log_01 a04c0106b7
PiperOrigin-RevId: 642443074

src/core/BUILD

@@ -4870,6 +4870,7 @@ 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,6 +73,8 @@
 #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"
@@ -1162,13 +1164,12 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
   upb::Arena arena;
   if (!GrpcLbResponseParse(response_slice, arena.ptr(), &response) ||
       (response.type == response.INITIAL && seen_initial_response_)) {
-    if (gpr_should_log(GPR_LOG_SEVERITY_ERROR)) {
+    if (absl::MinLogLevel() <= absl::LogSeverityAtLeast::kError) {
       char* response_slice_str =
           grpc_dump_slice(response_slice, GPR_DUMP_ASCII | GPR_DUMP_HEX);
-      gpr_log(GPR_ERROR,
+      LOG(ERROR) << "[grpclb " << grpclb_policy() << "] lb_calld=" << this
-              "[grpclb %p] lb_calld=%p: Invalid LB response received: '%s'. "
+                 << ": Invalid LB response received: '" << response_slice_str
-              "Ignoring.",
+                 << "'. 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)) {
-      gpr_log(GPR_DEBUG, "Reading file %s failed: %s", filename,
+      VLOG(2) << "Reading file " << filename << " failed: "
-              grpc_core::StatusToString(namespace_name.status()).c_str());
+              << grpc_core::StatusToString(namespace_name.status());
     }
     // Fallback on an environment variable
     return grpc_core::GetEnv("NAMESPACE_NAME").value_or("");
@@ -249,13 +249,12 @@ class EnvironmentAutoDetectHelper
           element.first, &pollent_,
           [this](std::string attribute, absl::StatusOr<std::string> result) {
             if (GRPC_TRACE_FLAG_ENABLED(environment_autodetect)) {
-              gpr_log(
+              LOG(INFO) << "Environment AutoDetect: Attribute: \"" << attribute
-                  GPR_INFO,
+                        << "\" Result: \""
-                  "Environment AutoDetect: Attribute: \"%s\" Result: \"%s\"",
+                        << (result.ok()
-                  attribute.c_str(),
+                                ? result.value()
-                  result.ok()
+                                : grpc_core::StatusToString(result.status()))
-                      ? result.value().c_str()
+                        << "\"";
-                      : grpc_core::StatusToString(result.status()).c_str());
             }
             absl::optional<EnvironmentAutoDetect::ResourceType> resource;
             {
@@ -270,9 +269,8 @@ class EnvironmentAutoDetectHelper
                 // assuming a GCE environment, fallback to "global".
                 else if (assuming_gce_) {
                   if (GRPC_TRACE_FLAG_ENABLED(environment_autodetect)) {
-                    gpr_log(GPR_INFO,
+                    LOG(INFO) << "Environment Autodetect: Falling back to "
-                            "Environment Autodetect: Falling back to global "
+                                 "global resource type";
-                            "resource type");
                   }
                   assuming_gce_ = false;
                   resource_.resource_type = "global";
@@ -280,10 +278,9 @@ class EnvironmentAutoDetectHelper
                 attributes_to_fetch_.erase(it);
               } else {
                 // This should not happen
-                gpr_log(GPR_ERROR,
+                LOG(ERROR) << "An unexpected attribute was seen from the "
-                        "An unexpected attribute was seen from the "
+                              "MetadataServer: "
-                        "MetadataServer: %s",
+                           << attribute;
-                        attribute.c_str());
               }
               if (attributes_to_fetch_.empty()) {
                 resource = std::move(resource_);

src/cpp/server/backend_metric_recorder.cc

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