diff --git a/src/cpp/ext/gcp/environment_autodetect.cc b/src/cpp/ext/gcp/environment_autodetect.cc
index e41435679a2..0f61e24a011 100644
--- a/src/cpp/ext/gcp/environment_autodetect.cc
+++ b/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,
-              grpc_core::StatusToString(namespace_name.status()).c_str());
+      VLOG(2) << "Reading file " << filename << " failed: "
+              << 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(
-                  GPR_INFO,
-                  "Environment AutoDetect: Attribute: \"%s\" Result: \"%s\"",
-                  attribute.c_str(),
-                  result.ok()
-                      ? result.value().c_str()
-                      : grpc_core::StatusToString(result.status()).c_str());
+              LOG(INFO) << "Environment AutoDetect: Attribute: \"" << attribute
+                        << "\" Result: \""
+                        << (result.ok()
+                                ? result.value()
+                                : grpc_core::StatusToString(result.status()))
+                        << "\"";
             }
             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,
-                            "Environment Autodetect: Falling back to global "
-                            "resource type");
+                    LOG(INFO) << "Environment Autodetect: Falling back to "
+                                 "global 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,
-                        "An unexpected attribute was seen from the "
-                        "MetadataServer: %s",
-                        attribute.c_str());
+                LOG(ERROR) << "An unexpected attribute was seen from the "
+                              "MetadataServer: "
+                           << attribute;
               }
               if (attributes_to_fetch_.empty()) {
                 resource = std::move(resource_);
diff --git a/src/cpp/server/backend_metric_recorder.cc b/src/cpp/server/backend_metric_recorder.cc
index e4800849a1c..d92fac3db0a 100644
--- a/src/cpp/server/backend_metric_recorder.cc
+++ b/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,
-              value);
+      LOG(INFO) << "[" << this
+                << "] 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,
-              value, std::string(name.data(), name.size()).c_str());
+      LOG(INFO) << "[" << this << "] Named utilization rejected: " << value
+                << " 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,
-            std::string(name.data(), name.size()).c_str());
+    LOG(INFO) << "[" << this << "] Named utilization set: " << value
+              << " 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,
-            this, named_utilization.size());
+    LOG(INFO) << "[" << this << "] All named utilization updated. 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,
-            std::string(name.data(), name.size()).c_str());
+    LOG(INFO) << "[" << this << "] Named utilization cleared. name: "
+              << 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,
-            "[%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());
+    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();
   }
   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,
-              value);
+      LOG(INFO) << "[" << this
+                << "] 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,
-              std::string(name.data(), name.length()).c_str(), value);
+      LOG(INFO) << "[" << this << "] Utilization value rejected: "
+                << 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,
-            std::string(name_sv).c_str(), value);
+    LOG(INFO) << "[" << this << "] Utilization recorded: " << name_sv << " "
+              << 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,
-            std::string(name_sv).c_str(), value);
+    LOG(INFO) << "[" << this << "] Request cost recorded: " << name_sv << " "
+              << 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,
-            std::string(name_sv).c_str(), value);
+    LOG(INFO) << "[" << this << "] Named metric recorded: " << name_sv << " "
+              << value;
   }
   return *this;
 }
@@ -406,13 +409,13 @@ BackendMetricData BackendMetricState::GetBackendMetricData() {
     }
   }
   if (GRPC_TRACE_FLAG_ENABLED(backend_metric)) {
-    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());
+    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();
   }
   return data;
 }