Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

[Gpr_To_Absl_Logging] Using GRPC_TRACE_LOG instead of GRPC_TRACE_FLAG_ENABLED (#37350)

Browse Source 
[Gpr_To_Absl_Logging] Using GRPC_TRACE_LOG instead of GRPC_TRACE_FLAG_ENABLED

Used find and replace for this PR

Find String :

```
if \(GRPC_TRACE_FLAG_ENABLED\((.*)\)\) {
(.*)LOG\(INFO\)(.*)
(.*);
(.*)}(.*)
```

Replace String

`GRPC_TRACE_LOG($1, INFO) $3 $4;`

Closes #37350

COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/37350 from tanvi-jagtap:GRPC_TRACE_FLAG_ENABLED_02 94a14ae3c5
PiperOrigin-RevId: 659040558
pull/37396/head
Tanvi Jagtap 7 months ago committed by Copybara-Service
parent 523b22d219
commit c2f1f929c6
15 changed files with 121 additions and 180 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 93
      src/core/lib/channel/promise_based_filter.cc
  2. 21
      src/core/lib/gprpp/work_serializer.cc
  3. 6
      src/core/lib/iomgr/ev_epoll1_linux.cc
  4. 7
      src/core/lib/iomgr/event_engine_shims/endpoint.cc
  5. 20
      src/core/lib/iomgr/tcp_client_posix.cc
  6. 31
      src/core/lib/iomgr/tcp_posix.cc
  7. 13
      src/core/lib/iomgr/tcp_server_posix.cc
  8. 7
      src/core/lib/resource_quota/memory_quota.cc
  9. 6
      src/core/lib/resource_quota/memory_quota.h
  10. 13
      src/core/lib/security/authorization/grpc_server_authz_filter.cc
  11. 28
      src/core/lib/security/credentials/plugin/plugin_credentials.cc
  12. 14
      src/core/lib/slice/slice_refcount.h
  13. 7
      src/core/lib/transport/bdp_estimator.cc
  14. 14
      src/core/lib/transport/bdp_estimator.h
  15. 21
      src/core/lib/transport/connectivity_state.cc

93
src/core/lib/channel/promise_based_filter.cc
Unescape View File

@ -207,10 +207,8 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
uintptr_t& refcnt = *RefCountField(batch);
if (refcnt == 0) {
// refcnt==0 ==> cancelled
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << releaser->call()->DebugTag()
<< "RESUME BATCH REQUEST CANCELLED";
}
GRPC_TRACE_LOG(channel, INFO)
<< releaser->call()->DebugTag() << "RESUME BATCH REQUEST CANCELLED";
return;
}
if (--refcnt == 0) {
@ -266,10 +264,9 @@ BaseCallData::Flusher::~Flusher() {
auto* batch = static_cast<grpc_transport_stream_op_batch*>(p);
BaseCallData* call =
static_cast<BaseCallData*>(batch->handler_private.extra_arg);
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << "FLUSHER:forward batch via closure: "
<< grpc_transport_stream_op_batch_string(batch, false);
}
GRPC_TRACE_LOG(channel, INFO)
<< "FLUSHER:forward batch via closure: "
<< grpc_transport_stream_op_batch_string(batch, false);
grpc_call_next_op(call->elem(), batch);
GRPC_CALL_STACK_UNREF(call->call_stack(), "flusher_batch");
};
@ -278,10 +275,9 @@ BaseCallData::Flusher::~Flusher() {
if (call_->call() != nullptr && call_->call()->traced()) {
batch->is_traced = true;
}
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << "FLUSHER:queue batch to forward in closure: "
<< grpc_transport_stream_op_batch_string(release_[i], false);
}
GRPC_TRACE_LOG(channel, INFO)
<< "FLUSHER:queue batch to forward in closure: "
<< grpc_transport_stream_op_batch_string(release_[i], false);
batch->handler_private.extra_arg = call_;
GRPC_CLOSURE_INIT(&batch->handler_private.closure, call_next_op, batch,
nullptr);
@ -290,10 +286,9 @@ BaseCallData::Flusher::~Flusher() {
"flusher_batch");
}
call_closures_.RunClosuresWithoutYielding(call_->call_combiner());
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << "FLUSHER:forward batch: "
<< grpc_transport_stream_op_batch_string(release_[0], false);
}
GRPC_TRACE_LOG(channel, INFO)
<< "FLUSHER:forward batch: "
<< grpc_transport_stream_op_batch_string(release_[0], false);
if (call_->call() != nullptr && call_->call()->traced()) {
release_[0]->is_traced = true;
}
@ -331,10 +326,8 @@ const char* BaseCallData::SendMessage::StateString(State state) {
}
void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << base_->LogTag()
<< " SendMessage.StartOp st=" << StateString(state_);
}
GRPC_TRACE_LOG(channel, INFO)
<< base_->LogTag() << " SendMessage.StartOp st=" << StateString(state_);
switch (state_) {
case State::kInitial:
state_ = State::kGotBatchNoPipe;
@ -359,10 +352,8 @@ void BaseCallData::SendMessage::StartOp(CapturedBatch batch) {
template <typename T>
void BaseCallData::SendMessage::GotPipe(T* pipe_end) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << base_->LogTag()
<< " SendMessage.GotPipe st=" << StateString(state_);
}
GRPC_TRACE_LOG(channel, INFO)
<< base_->LogTag() << " SendMessage.GotPipe st=" << StateString(state_);
CHECK_NE(pipe_end, nullptr);
switch (state_) {
case State::kInitial:
@ -615,10 +606,9 @@ const char* BaseCallData::ReceiveMessage::StateString(State state) {
}
void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << base_->LogTag()
<< " ReceiveMessage.StartOp st=" << StateString(state_);
}
GRPC_TRACE_LOG(channel, INFO)
<< base_->LogTag()
<< " ReceiveMessage.StartOp st=" << StateString(state_);
switch (state_) {
case State::kInitial:
state_ = State::kForwardedBatchNoPipe;
@ -656,10 +646,9 @@ void BaseCallData::ReceiveMessage::StartOp(CapturedBatch& batch) {
template <typename T>
void BaseCallData::ReceiveMessage::GotPipe(T* pipe_end) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << base_->LogTag()
<< " ReceiveMessage.GotPipe st=" << StateString(state_);
}
GRPC_TRACE_LOG(channel, INFO)
<< base_->LogTag()
<< " ReceiveMessage.GotPipe st=" << StateString(state_);
switch (state_) {
case State::kInitial:
state_ = State::kIdle;
@ -901,10 +890,9 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
case State::kPulledFromPipe: {
CHECK(push_.has_value());
if ((*push_)().ready()) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << base_->LogTag()
<< " ReceiveMessage.WakeInsideCombiner push complete";
}
GRPC_TRACE_LOG(channel, INFO)
<< base_->LogTag()
<< " ReceiveMessage.WakeInsideCombiner push complete";
if (state_ == State::kCompletedWhilePulledFromPipe) {
interceptor()->Push()->Close();
state_ = State::kCancelled;
@ -1016,10 +1004,9 @@ class ClientCallData::PollContext {
void Run() {
DCHECK(HasContext<Arena>());
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << self_->LogTag() << " ClientCallData.PollContext.Run "
<< self_->DebugString();
}
GRPC_TRACE_LOG(channel, INFO)
<< self_->LogTag() << " ClientCallData.PollContext.Run "
<< self_->DebugString();
CHECK(have_scoped_activity_);
repoll_ = false;
if (self_->send_message() != nullptr) {
@ -1664,10 +1651,8 @@ void ClientCallData::HookRecvTrailingMetadata(CapturedBatch batch) {
// - return a wrapper around PollTrailingMetadata as the promise.
ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
CallArgs call_args) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << LogTag() << " ClientCallData.MakeNextPromise "
<< DebugString();
}
GRPC_TRACE_LOG(channel, INFO)
<< LogTag() << " ClientCallData.MakeNextPromise " << DebugString();
CHECK_NE(poll_ctx_, nullptr);
CHECK(send_initial_state_ == SendInitialState::kQueued);
send_initial_metadata_batch_->payload->send_initial_metadata
@ -1727,10 +1712,8 @@ ArenaPromise<ServerMetadataHandle> ClientCallData::MakeNextPromise(
// All polls: await receiving the trailing metadata, then return it to the
// application.
Poll<ServerMetadataHandle> ClientCallData::PollTrailingMetadata() {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << LogTag() << " ClientCallData.PollTrailingMetadata "
<< DebugString();
}
GRPC_TRACE_LOG(channel, INFO)
<< LogTag() << " ClientCallData.PollTrailingMetadata " << DebugString();
CHECK_NE(poll_ctx_, nullptr);
if (send_initial_state_ == SendInitialState::kQueued) {
// First poll: pass the send_initial_metadata op down the stack.
@ -2275,10 +2258,9 @@ ArenaPromise<ServerMetadataHandle> ServerCallData::MakeNextPromise(
// All polls: await sending the trailing metadata, then foward it down the
// stack.
Poll<ServerMetadataHandle> ServerCallData::PollTrailingMetadata() {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << LogTag()
<< " PollTrailingMetadata: " << StateString(send_trailing_state_);
}
GRPC_TRACE_LOG(channel, INFO)
<< LogTag()
<< " PollTrailingMetadata: " << StateString(send_trailing_state_);
switch (send_trailing_state_) {
case SendTrailingState::kInitial:
case SendTrailingState::kQueuedBehindSendMessage:
@ -2306,10 +2288,9 @@ void ServerCallData::RecvTrailingMetadataReadyCallback(
}
void ServerCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
if (GRPC_TRACE_FLAG_ENABLED(channel)) {
LOG(INFO) << LogTag() << ": RecvTrailingMetadataReady error=" << error
<< " md=" << recv_trailing_metadata_->DebugString();
}
GRPC_TRACE_LOG(channel, INFO)
<< LogTag() << ": RecvTrailingMetadataReady error=" << error
<< " md=" << recv_trailing_metadata_->DebugString();
Flusher flusher(this);
PollContext poll_ctx(this, &flusher);
Completed(error, recv_trailing_metadata_->get(GrpcTarPit()).has_value(),

21
src/core/lib/gprpp/work_serializer.cc
Unescape View File

@ -136,10 +136,9 @@ class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
const DebugLocation& location) {
if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
LOG(INFO) << "WorkSerializer::Run() " << this << " Scheduling callback ["
<< location.file() << ":" << location.line() << "]";
}
GRPC_TRACE_LOG(work_serializer, INFO)
<< "WorkSerializer::Run() " << this << " Scheduling callback ["
<< location.file() << ":" << location.line() << "]";
// Increment queue size for the new callback and owner count to attempt to
// take ownership of the WorkSerializer.
const uint64_t prev_ref_pair =
@ -405,10 +404,9 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
// Implementation of WorkSerializerImpl::Run
void WorkSerializer::DispatchingWorkSerializer::Run(
std::function<void()> callback, const DebugLocation& location) {
if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
LOG(INFO) << "WorkSerializer[" << this << "] Scheduling callback ["
<< location.file() << ":" << location.line() << "]";
}
GRPC_TRACE_LOG(work_serializer, INFO)
<< "WorkSerializer[" << this << "] Scheduling callback ["
<< location.file() << ":" << location.line() << "]";
global_stats().IncrementWorkSerializerItemsEnqueued();
MutexLock lock(&mu_);
if (!running_) {
@ -438,10 +436,9 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
// Grab the last element of processing_ - which is the next item in our
// queue since processing_ is stored in reverse order.
auto& cb = processing_.back();
if (GRPC_TRACE_FLAG_ENABLED(work_serializer)) {
LOG(INFO) << "WorkSerializer[" << this << "] Executing callback ["
<< cb.location.file() << ":" << cb.location.line() << "]";
}
GRPC_TRACE_LOG(work_serializer, INFO)
<< "WorkSerializer[" << this << "] Executing callback ["
<< cb.location.file() << ":" << cb.location.line() << "]";
// Run the work item.
const auto start = std::chrono::steady_clock::now();
SetCurrentThread();

6
src/core/lib/iomgr/ev_epoll1_linux.cc
Unescape View File

@ -1125,10 +1125,8 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
}
goto done;
} else {
if (GRPC_TRACE_FLAG_ENABLED(polling)) {
LOG(INFO) << " .. non-root poller " << next_worker
<< " (root=" << root_worker << ")";
}
GRPC_TRACE_LOG(polling, INFO) << " .. non-root poller " << next_worker
<< " (root=" << root_worker << ")";
SET_KICK_STATE(next_worker, KICKED);
ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
goto done;

7
src/core/lib/iomgr/event_engine_shims/endpoint.cc
Unescape View File

@ -173,10 +173,9 @@ class EventEngineEndpointWrapper {
void FinishPendingWrite(absl::Status status) {
auto* write_buffer = reinterpret_cast<SliceBuffer*>(&eeep_->write_buffer);
write_buffer->~SliceBuffer();
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "TCP: " << this << " WRITE (peer=" << PeerAddress()
<< ") error=" << status;
}
GRPC_TRACE_LOG(tcp, INFO)
<< "TCP: " << this << " WRITE (peer=" << PeerAddress()
<< ") error=" << status;
grpc_closure* cb = pending_write_cb_;
pending_write_cb_ = nullptr;
if (grpc_core::ExecCtx::Get() == nullptr) {

20
src/core/lib/iomgr/tcp_client_posix.cc
Unescape View File

@ -141,10 +141,9 @@ done:
static void tc_on_alarm(void* acp, grpc_error_handle error) {
int done;
async_connect* ac = static_cast<async_connect*>(acp);
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
<< ": on_alarm: error=" << grpc_core::StatusToString(error);
}
GRPC_TRACE_LOG(tcp, INFO)
<< "CLIENT_CONNECT: " << ac->addr_str
<< ": on_alarm: error=" << grpc_core::StatusToString(error);
gpr_mu_lock(&ac->mu);
if (ac->fd != nullptr) {
grpc_fd_shutdown(ac->fd, GRPC_ERROR_CREATE("connect() timed out"));
@ -180,10 +179,9 @@ static void on_writable(void* acp, grpc_error_handle error) {
std::string addr_str = ac->addr_str;
grpc_fd* fd;
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
<< ": on_writable: error=" << grpc_core::StatusToString(error);
}
GRPC_TRACE_LOG(tcp, INFO)
<< "CLIENT_CONNECT: " << ac->addr_str
<< ": on_writable: error=" << grpc_core::StatusToString(error);
gpr_mu_lock(&ac->mu);
CHECK(ac->fd);
@ -381,10 +379,8 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
grpc_schedule_on_exec_ctx);
ac->options = options;
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "CLIENT_CONNECT: " << ac->addr_str
<< ": asynchronously connecting fd " << fdobj;
}
GRPC_TRACE_LOG(tcp, INFO) << "CLIENT_CONNECT: " << ac->addr_str
<< ": asynchronously connecting fd " << fdobj;
int shard_number = connection_id % (*g_connection_shards).size();
struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];

31
src/core/lib/iomgr/tcp_posix.cc
Unescape View File

@ -669,10 +669,8 @@ static void drop_uncovered(grpc_tcp* /*tcp*/) {
old_count = g_uncovered_notifications_pending--;
g_backup_poller_mu->Unlock();
CHECK_GT(old_count, 1);
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "BACKUP_POLLER:" << p << " uncover cnt " << old_count << "->"
<< old_count - 1;
}
GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " uncover cnt "
<< old_count << "->" << old_count - 1;
}
// gRPC API considers a Write operation to be done the moment it clears ‘flow
@ -705,10 +703,8 @@ static void cover_self(grpc_tcp* tcp) {
p = g_backup_poller;
g_backup_poller_mu->Unlock();
}
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "BACKUP_POLLER:" << p << " add " << tcp << " cnt "
<< old_count - 1 << "->" << old_count;
}
GRPC_TRACE_LOG(tcp, INFO) << "BACKUP_POLLER:" << p << " add " << tcp
<< " cnt " << old_count - 1 << "->" << old_count;
grpc_pollset_add_fd(BACKUP_POLLER_POLLSET(p), tcp->em_fd);
}
@ -731,10 +727,8 @@ static void notify_on_write(grpc_tcp* tcp) {
static void tcp_drop_uncovered_then_handle_write(void* arg,
grpc_error_handle error) {
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "TCP:" << arg
<< " got_write: " << grpc_core::StatusToString(error);
}
GRPC_TRACE_LOG(tcp, INFO)
<< "TCP:" << arg << " got_write: " << grpc_core::StatusToString(error);
drop_uncovered(static_cast<grpc_tcp*>(arg));
tcp_handle_write(arg, error);
}
@ -1129,10 +1123,8 @@ static void maybe_make_read_slices(grpc_tcp* tcp)
static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
grpc_tcp* tcp = static_cast<grpc_tcp*>(arg);
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "TCP:" << tcp
<< " got_read: " << grpc_core::StatusToString(error);
}
GRPC_TRACE_LOG(tcp, INFO)
<< "TCP:" << tcp << " got_read: " << grpc_core::StatusToString(error);
tcp->read_mu.Lock();
grpc_error_handle tcp_read_error;
if (GPR_LIKELY(error.ok()) && tcp->memory_owner.is_valid()) {
@ -1472,10 +1464,9 @@ static bool process_errors(grpc_tcp* tcp) {
} else {
// Got a control message that is not a timestamp or zerocopy. Don't know
// how to handle this.
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "unknown control message cmsg_level:" << cmsg->cmsg_level
<< " cmsg_type:" << cmsg->cmsg_type;
}
GRPC_TRACE_LOG(tcp, INFO)
<< "unknown control message cmsg_level:" << cmsg->cmsg_level
<< " cmsg_type:" << cmsg->cmsg_type;
return processed_err;
}
}

13
src/core/lib/iomgr/tcp_server_posix.cc
Unescape View File

@ -177,10 +177,9 @@ static grpc_error_handle CreateEventEngineListener(
<< addr_uri.status().ToString();
return;
}
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "SERVER_CONNECT: incoming external connection: "
<< addr_uri->c_str();
}
GRPC_TRACE_LOG(tcp, INFO) << "SERVER_CONNECT: incoming external "
"connection: "
<< addr_uri->c_str();
}
read_notifier_pollset =
(*(s->pollsets))[static_cast<size_t>(
@ -916,10 +915,8 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
LOG(ERROR) << "Invalid address: " << addr_uri.status();
return;
}
if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
LOG(INFO) << "SERVER_CONNECT: incoming external connection: "
<< *addr_uri;
}
GRPC_TRACE_LOG(tcp, INFO)
<< "SERVER_CONNECT: incoming external connection: " << *addr_uri;
std::string name = absl::StrCat("tcp-server-connection:", addr_uri.value());
grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
read_notifier_pollset =

7
src/core/lib/resource_quota/memory_quota.cc
Unescape View File

@ -766,10 +766,9 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
} else {
report = controller_.Update(current_estimate - kSetPoint);
}
if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
LOG(INFO) << "RQ: pressure:" << current_estimate << " report:" << report
<< " controller:" << controller_.DebugString();
}
GRPC_TRACE_LOG(resource_quota, INFO)
<< "RQ: pressure:" << current_estimate << " report:" << report
<< " controller:" << controller_.DebugString();
report_.store(report, std::memory_order_relaxed);
});
return report_.load(std::memory_order_relaxed);

6
src/core/lib/resource_quota/memory_quota.h
Unescape View File

@ -425,10 +425,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
void ReturnFree() {
size_t ret = free_bytes_.exchange(0, std::memory_order_acq_rel);
if (ret == 0) return;
if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
LOG(INFO) << "Allocator " << this << " returning " << ret
<< " bytes to quota";
}
GRPC_TRACE_LOG(resource_quota, INFO)
<< "Allocator " << this << " returning " << ret << " bytes to quota";
taken_bytes_.fetch_sub(ret, std::memory_order_relaxed);
memory_quota_->Return(ret);
memory_quota_->MaybeMoveAllocator(this, /*old_free_bytes=*/ret,

13
src/core/lib/security/authorization/grpc_server_authz_filter.cc
Unescape View File

@ -77,10 +77,9 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
AuthorizationEngine::Decision decision =
engines.deny_engine->Evaluate(args);
if (decision.type == AuthorizationEngine::Decision::Type::kDeny) {
if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
LOG(INFO) << "chand=" << this << ": request denied by policy "
<< decision.matching_policy_name;
}
GRPC_TRACE_LOG(grpc_authz_api, INFO)
<< "chand=" << this << ": request denied by policy "
<< decision.matching_policy_name;
return false;
}
}
@ -95,10 +94,8 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
return true;
}
}
if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
LOG(INFO) << "chand=" << this
<< ": request denied, no matching policy found.";
}
GRPC_TRACE_LOG(grpc_authz_api, INFO)
<< "chand=" << this << ": request denied, no matching policy found.";
return false;
}

28
src/core/lib/security/credentials/plugin/plugin_credentials.cc
Unescape View File

@ -121,10 +121,9 @@ void grpc_plugin_credentials::PendingRequest::RequestMetadataReady(
GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP);
grpc_core::RefCountedPtr<grpc_plugin_credentials::PendingRequest> r(
static_cast<grpc_plugin_credentials::PendingRequest*>(request));
if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
LOG(INFO) << "plugin_credentials[" << r->creds() << "]: request " << r.get()
<< ": plugin returned asynchronously";
}
GRPC_TRACE_LOG(plugin_credentials, INFO)
<< "plugin_credentials[" << r->creds() << "]: request " << r.get()
<< ": plugin returned asynchronously";
for (size_t i = 0; i < num_md; ++i) {
grpc_metadata p;
p.key = grpc_core::CSliceRef(md[i].key);
@ -150,10 +149,9 @@ grpc_plugin_credentials::GetRequestMetadata(
RefAsSubclass<grpc_plugin_credentials>(), std::move(initial_metadata),
args);
// Invoke the plugin. The callback holds a ref to us.
if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
LOG(INFO) << "plugin_credentials[" << this << "]: request " << request.get()
<< ": invoking plugin";
}
GRPC_TRACE_LOG(plugin_credentials, INFO)
<< "plugin_credentials[" << this << "]: request " << request.get()
<< ": invoking plugin";
grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX];
size_t num_creds_md = 0;
grpc_status_code status = GRPC_STATUS_OK;
@ -168,17 +166,15 @@ grpc_plugin_credentials::GetRequestMetadata(
child_request.get(), creds_md, &num_creds_md,
&status, &error_details)) {
child_request.release();
if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
LOG(INFO) << "plugin_credentials[" << this << "]: request "
<< request.get() << ": plugin will return asynchronously";
}
GRPC_TRACE_LOG(plugin_credentials, INFO)
<< "plugin_credentials[" << this << "]: request " << request.get()
<< ": plugin will return asynchronously";
return [request] { return request->PollAsyncResult(); };
}
// Synchronous return.
if (GRPC_TRACE_FLAG_ENABLED(plugin_credentials)) {
LOG(INFO) << "plugin_credentials[" << this << "]: request " << request.get()
<< ": plugin returned synchronously";
}
GRPC_TRACE_LOG(plugin_credentials, INFO)
<< "plugin_credentials[" << this << "]: request " << request.get()
<< ": plugin returned synchronously";
auto result = request->ProcessPluginResult(creds_md, num_creds_md, status,
error_details);
// Clean up.

14
src/core/lib/slice/slice_refcount.h
Unescape View File

@ -46,17 +46,15 @@ struct grpc_slice_refcount {
void Ref(grpc_core::DebugLocation location) {
auto prev_refs = ref_.fetch_add(1, std::memory_order_relaxed);
if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
LOG(INFO).AtLocation(location.file(), location.line())
<< "REF " << this << " " << prev_refs << "->" << prev_refs + 1;
}
GRPC_TRACE_LOG(slice_refcount, INFO)
.AtLocation(location.file(), location.line())
<< "REF " << this << " " << prev_refs << "->" << prev_refs + 1;
}
void Unref(grpc_core::DebugLocation location) {
auto prev_refs = ref_.fetch_sub(1, std::memory_order_acq_rel);
if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
LOG(INFO).AtLocation(location.file(), location.line())
<< "UNREF " << this << " " << prev_refs << "->" << prev_refs - 1;
}
GRPC_TRACE_LOG(slice_refcount, INFO)
.AtLocation(location.file(), location.line())
<< "UNREF " << this << " " << prev_refs << "->" << prev_refs - 1;
if (prev_refs == 1) {
destroyer_fn_(this);
}

7
src/core/lib/transport/bdp_estimator.cc
Unescape View File

@ -71,10 +71,9 @@ Timestamp BdpEstimator::CompletePing() {
}
if (start_inter_ping_delay != inter_ping_delay_) {
stable_estimate_count_ = 0;
if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
LOG(INFO) << "bdp[" << name_ << "]:update_inter_time to "
<< inter_ping_delay_.millis() << "ms";
}
GRPC_TRACE_LOG(bdp_estimator, INFO)
<< "bdp[" << name_ << "]:update_inter_time to "
<< inter_ping_delay_.millis() << "ms";
}
ping_state_ = PingState::UNSCHEDULED;
accumulator_ = 0;

14
src/core/lib/transport/bdp_estimator.h
Unescape View File

@ -49,10 +49,9 @@ class BdpEstimator {
// grpc_bdp_estimator_add_incoming_bytes once a ping has been scheduled by a
// transport (but not necessarily started)
void SchedulePing() {
if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
LOG(INFO) << "bdp[" << name_ << "]:sched acc=" << accumulator_
<< " est=" << estimate_;
}
GRPC_TRACE_LOG(bdp_estimator, INFO)
<< "bdp[" << name_ << "]:sched acc=" << accumulator_
<< " est=" << estimate_;
CHECK(ping_state_ == PingState::UNSCHEDULED);
ping_state_ = PingState::SCHEDULED;
accumulator_ = 0;
@ -62,10 +61,9 @@ class BdpEstimator {
// once
// the ping is on the wire
void StartPing() {
if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
LOG(INFO) << "bdp[" << name_ << "]:start acc=" << accumulator_
<< " est=" << estimate_;
}
GRPC_TRACE_LOG(bdp_estimator, INFO)
<< "bdp[" << name_ << "]:start acc=" << accumulator_
<< " est=" << estimate_;
CHECK(ping_state_ == PingState::SCHEDULED);
ping_state_ = PingState::STARTED;
ping_start_time_ = gpr_now(GPR_CLOCK_MONOTONIC);

21
src/core/lib/transport/connectivity_state.cc
Unescape View File

@ -117,10 +117,9 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
void ConnectivityStateTracker::AddWatcher(
grpc_connectivity_state initial_state,
OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
<< "]: add watcher " << watcher.get();
}
GRPC_TRACE_LOG(connectivity_state, INFO)
<< "ConnectivityStateTracker " << name_ << "[" << this
<< "]: add watcher " << watcher.get();
grpc_connectivity_state current_state =
state_.load(std::memory_order_relaxed);
if (initial_state != current_state) {
@ -141,10 +140,9 @@ void ConnectivityStateTracker::AddWatcher(
void ConnectivityStateTracker::RemoveWatcher(
ConnectivityStateWatcherInterface* watcher) {
if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
<< "]: remove watcher " << watcher;
}
GRPC_TRACE_LOG(connectivity_state, INFO)
<< "ConnectivityStateTracker " << name_ << "[" << this
<< "]: remove watcher " << watcher;
watchers_.erase(watcher);
}
@ -178,10 +176,9 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
grpc_connectivity_state ConnectivityStateTracker::state() const {
grpc_connectivity_state state = state_.load(std::memory_order_relaxed);
if (GRPC_TRACE_FLAG_ENABLED(connectivity_state)) {
LOG(INFO) << "ConnectivityStateTracker " << name_ << "[" << this
<< "]: get current state: " << ConnectivityStateName(state);
}
GRPC_TRACE_LOG(connectivity_state, INFO)
<< "ConnectivityStateTracker " << name_ << "[" << this
<< "]: get current state: " << ConnectivityStateName(state);
return state;
}

Write Preview
Loading…
Cancel
Save