diff --git a/include/grpc/impl/codegen/grpc_types.h b/include/grpc/impl/codegen/grpc_types.h index 22132cc1a4f..b671ad653e3 100644 --- a/include/grpc/impl/codegen/grpc_types.h +++ b/include/grpc/impl/codegen/grpc_types.h @@ -283,7 +283,8 @@ typedef struct { #define GRPC_ARG_SOCKET_FACTORY "grpc.socket_factory" /** The maximum number of trace events to keep in the tracer for each channel or * subchannel. The default is 10. If set to 0, channel tracing is disabled. */ -#define GRPC_ARG_MAX_CHANNEL_TRACE_EVENTS_PER_NODE "grpc.max_channel_trace_events_per_node" +#define GRPC_ARG_MAX_CHANNEL_TRACE_EVENTS_PER_NODE \ + "grpc.max_channel_trace_events_per_node" /** If non-zero, Cronet transport will coalesce packets to fewer frames * when possible. */ #define GRPC_ARG_USE_CRONET_PACKET_COALESCING \ diff --git a/src/core/ext/filters/client_channel/subchannel.cc b/src/core/ext/filters/client_channel/subchannel.cc index 68cd9260ba9..77c0fe2c430 100644 --- a/src/core/ext/filters/client_channel/subchannel.cc +++ b/src/core/ext/filters/client_channel/subchannel.cc @@ -136,7 +136,7 @@ struct grpc_subchannel { /** our alarm */ grpc_timer alarm; - grpc_core::RefCountedPtr tracer; + grpc_core::RefCountedPtr tracer; }; struct grpc_subchannel_call { diff --git a/src/core/lib/channel/channel_tracer.cc b/src/core/lib/channel/channel_tracer.cc index bd1396f04e4..982b86447db 100644 --- a/src/core/lib/channel/channel_tracer.cc +++ b/src/core/lib/channel/channel_tracer.cc @@ -40,7 +40,7 @@ class TraceEvent { public: TraceEvent(grpc_slice data, grpc_error* error, grpc_connectivity_state connectivity_state, - RefCountedPtr referenced_tracer) + RefCountedPtr referenced_tracer) : data_(data), error_(error), connectivity_state_(connectivity_state), @@ -66,34 +66,34 @@ class TraceEvent { } private: - friend class ChannelTracer; - friend class ChannelTracerRenderer; + friend class ChannelTrace; + friend class ChannelTraceRenderer; grpc_slice data_; grpc_error* error_; gpr_timespec time_created_; grpc_connectivity_state connectivity_state_; TraceEvent* next_; - // the tracer object for the (sub)channel that this trace node refers to. - RefCountedPtr referenced_tracer_; + // the tracer object for the (sub)channel that this trace event refers to. + RefCountedPtr referenced_tracer_; }; -ChannelTracer::ChannelTracer(size_t max_nodes) +ChannelTrace::ChannelTrace(size_t max_events) : channel_uuid_(-1), - num_nodes_logged_(0), + num_events_logged_(0), num_children_seen_(0), list_size_(0), - max_list_size_(max_nodes), + max_list_size_(max_events), head_trace_(nullptr), tail_trace_(nullptr) { - if (max_list_size_ == 0) return; // tracing is disabled if max_nodes == 0 + if (max_list_size_ == 0) return; // tracing is disabled if max_events == 0 gpr_mu_init(&tracer_mu_); channel_uuid_ = grpc_object_registry_register_object( this, GRPC_OBJECT_REGISTRY_CHANNEL_TRACER); time_created_ = gpr_now(GPR_CLOCK_REALTIME); } -ChannelTracer::~ChannelTracer() { - if (max_list_size_ == 0) return; // tracing is disabled if max_nodes == 0 +ChannelTrace::~ChannelTrace() { + if (max_list_size_ == 0) return; // tracing is disabled if max_events == 0 TraceEvent* it = head_trace_; while (it != nullptr) { TraceEvent* to_free = it; @@ -103,17 +103,17 @@ ChannelTracer::~ChannelTracer() { gpr_mu_destroy(&tracer_mu_); } -intptr_t ChannelTracer::GetUuid() { return channel_uuid_; } +intptr_t ChannelTrace::GetUuid() { return channel_uuid_; } -void ChannelTracer::AddTraceEventNode(TraceEvent* new_trace_node) { - ++num_nodes_logged_; - // first node case +void ChannelTrace::AddTraceEventHelper(TraceEvent* new_trace_event) { + ++num_events_logged_; + // first event case if (head_trace_ == nullptr) { - head_trace_ = tail_trace_ = new_trace_node; + head_trace_ = tail_trace_ = new_trace_event; } - // regular node add case + // regular event add case else { - tail_trace_->next_ = new_trace_node; + tail_trace_->next_ = new_trace_event; tail_trace_ = tail_trace_->next_; } ++list_size_; @@ -126,19 +126,20 @@ void ChannelTracer::AddTraceEventNode(TraceEvent* new_trace_node) { } } -void ChannelTracer::AddTrace(grpc_slice data, grpc_error* error, - grpc_connectivity_state connectivity_state, - RefCountedPtr referenced_tracer) { - if (max_list_size_ == 0) return; // tracing is disabled if max_nodes == 0 +void ChannelTrace::AddTraceEvent( + grpc_slice data, grpc_error* error, + grpc_connectivity_state connectivity_state, + RefCountedPtr referenced_tracer) { + if (max_list_size_ == 0) return; // tracing is disabled if max_events == 0 ++num_children_seen_; - // create and fill up the new node - AddTraceEventNode( - New(data, error, connectivity_state, std::move(referenced_tracer))); + // create and fill up the new event + AddTraceEventHelper(New(data, error, connectivity_state, + std::move(referenced_tracer))); } -void ChannelTracer::AddTrace(grpc_slice data, grpc_error* error, - grpc_connectivity_state connectivity_state) { - AddTraceEventNode(New(data, error, connectivity_state)); +void ChannelTrace::AddTraceEvent(grpc_slice data, grpc_error* error, + grpc_connectivity_state connectivity_state) { + AddTraceEventHelper(New(data, error, connectivity_state)); } namespace { @@ -153,13 +154,13 @@ char* fmt_time(gpr_timespec tm) { return full_time_str; } -} // anonymous namespace +} // anonymous namespace -class ChannelTracerRenderer { +class ChannelTraceRenderer { public: // If recursive==true, then the entire tree of trace will be rendered. // If not, then only the top level data will be. - ChannelTracerRenderer(ChannelTracer* tracer, bool recursive) + ChannelTraceRenderer(ChannelTrace* tracer, bool recursive) : current_tracer_(tracer), recursive_(recursive), seen_tracers_(nullptr), @@ -180,16 +181,16 @@ class ChannelTracerRenderer { private: // tracks that a tracer has already been rendered to avoid infinite // recursion. - void AddSeenTracer(ChannelTracer* newly_seen) { + void AddSeenTracer(ChannelTrace* newly_seen) { if (size_ >= cap_) { cap_ = GPR_MAX(5 * sizeof(newly_seen), 3 * cap_ / 2); - seen_tracers_ = (ChannelTracer**)gpr_realloc(seen_tracers_, cap_); + seen_tracers_ = (ChannelTrace**)gpr_realloc(seen_tracers_, cap_); } seen_tracers_[size_++] = newly_seen; } // Checks if a tracer has already been seen. - bool TracerAlreadySeen(ChannelTracer* tracer) { + bool TracerAlreadySeen(ChannelTrace* tracer) { for (size_t i = 0; i < size_; ++i) { if (seen_tracers_[i] == tracer) return true; } @@ -211,19 +212,19 @@ class ChannelTracerRenderer { } // Fills up the channelData object. If children is not null, it will - // recursively populate each referenced child as it passes that node. + // recursively populate each referenced child as it passes that event. void PopulateChannelData(grpc_json* channel_data, grpc_json* children) { grpc_json* child = nullptr; char* uuid_str; gpr_asprintf(&uuid_str, "%" PRIdPTR, current_tracer_->channel_uuid_); child = grpc_json_create_child(child, channel_data, "uuid", uuid_str, GRPC_JSON_NUMBER, true); - char* num_nodes_logged_str; - gpr_asprintf(&num_nodes_logged_str, "%" PRId64, - current_tracer_->num_nodes_logged_); + char* num_events_logged_str; + gpr_asprintf(&num_events_logged_str, "%" PRId64, + current_tracer_->num_events_logged_); child = grpc_json_create_child(child, channel_data, "numNodesLogged", - num_nodes_logged_str, GRPC_JSON_NUMBER, true); + num_events_logged_str, GRPC_JSON_NUMBER, true); child = grpc_json_create_child(child, channel_data, "startTime", fmt_time(current_tracer_->time_created_), GRPC_JSON_STRING, true); @@ -278,7 +279,7 @@ class ChannelTracerRenderer { grpc_json* referenced_tracer = grpc_json_create_child( nullptr, children, nullptr, nullptr, GRPC_JSON_OBJECT, false); AddSeenTracer(node->referenced_tracer_.get()); - ChannelTracer* saved = current_tracer_; + ChannelTrace* saved = current_tracer_; current_tracer_ = node->referenced_tracer_.get(); RecursivelyPopulateJson(referenced_tracer); current_tracer_ = saved; @@ -287,30 +288,31 @@ class ChannelTracerRenderer { } // Tracks the current tracer we are rendering as we walk the tree of tracers. - ChannelTracer* current_tracer_; + ChannelTrace* current_tracer_; // If true, we will render the data of all of this tracer's children. bool recursive_; // These members are used to track tracers we have already rendered. This is // a dynamically growing array that is deallocated when the rendering is done. - ChannelTracer** seen_tracers_; + ChannelTrace** seen_tracers_; size_t size_; size_t cap_; }; -char* ChannelTracer::RenderTrace(bool recursive) { - if (!max_list_size_) return nullptr; // tracing is disabled if max_nodes == 0 - ChannelTracerRenderer renderer(this, recursive); +char* ChannelTrace::RenderTrace(bool recursive) { + if (!max_list_size_) + return nullptr; // tracing is disabled if max_events == 0 + ChannelTraceRenderer renderer(this, recursive); return renderer.Run(); } -char* ChannelTracer::GetChannelTraceFromUuid(intptr_t uuid, bool recursive) { +char* ChannelTrace::GetChannelTraceFromUuid(intptr_t uuid, bool recursive) { void* object; grpc_object_registry_type type = grpc_object_registry_get_object(uuid, &object); GPR_ASSERT(type == GRPC_OBJECT_REGISTRY_CHANNEL_TRACER); - return static_cast(object)->RenderTrace(recursive); + return static_cast(object)->RenderTrace(recursive); } } // namespace grpc_core diff --git a/src/core/lib/channel/channel_tracer.h b/src/core/lib/channel/channel_tracer.h index 58e99d340f6..72bdee48f8c 100644 --- a/src/core/lib/channel/channel_tracer.h +++ b/src/core/lib/channel/channel_tracer.h @@ -29,24 +29,24 @@ namespace grpc_core { class TraceEvent; -class ChannelTracer : public RefCounted { +class ChannelTrace : public RefCounted { public: - ChannelTracer(size_t max_nodes); - ~ChannelTracer(); + ChannelTrace(size_t max_events); + ~ChannelTrace(); - /* returns the tracers uuid */ + /* returns the tracer's uuid */ intptr_t GetUuid(); - /* Adds a new trace node to the tracing object */ - void AddTrace(grpc_slice data, grpc_error* error, - grpc_connectivity_state connectivity_state); + /* Adds a new trace event to the tracing object */ + void AddTraceEvent(grpc_slice data, grpc_error* error, + grpc_connectivity_state connectivity_state); - /* Adds a new trace node to the tracing object. This trace node refers to a + /* Adds a new trace event to the tracing object. This trace event refers to a an event on a child of the channel. For example this could log when a particular subchannel becomes connected */ - void AddTrace(grpc_slice data, grpc_error* error, - grpc_connectivity_state connectivity_state, - RefCountedPtr referenced_tracer); + void AddTraceEvent(grpc_slice data, grpc_error* error, + grpc_connectivity_state connectivity_state, + RefCountedPtr referenced_tracer); /* Returns the tracing data rendered as a grpc json string. The string is owned by the caller and must be freed. If recursive @@ -59,14 +59,13 @@ class ChannelTracer : public RefCounted { static char* GetChannelTraceFromUuid(intptr_t uuid, bool recursive); private: + // Internal helper to add and link in a trace event + void AddTraceEventHelper(TraceEvent* new_trace_event); - // Internal helper to add and link in a tracenode - void AddTraceEventNode(TraceEvent* new_trace_node); - - friend class ChannelTracerRenderer; + friend class ChannelTraceRenderer; gpr_mu tracer_mu_; intptr_t channel_uuid_; - uint64_t num_nodes_logged_; + uint64_t num_events_logged_; uint64_t num_children_seen_; size_t list_size_; size_t max_list_size_; diff --git a/src/core/lib/json/json.h b/src/core/lib/json/json.h index c8a87a7b878..f93b43048b9 100644 --- a/src/core/lib/json/json.h +++ b/src/core/lib/json/json.h @@ -19,7 +19,6 @@ #ifndef GRPC_CORE_LIB_JSON_JSON_H #define GRPC_CORE_LIB_JSON_JSON_H - #include #include diff --git a/src/core/lib/surface/channel.cc b/src/core/lib/surface/channel.cc index 76ab9582566..837e78e85f4 100644 --- a/src/core/lib/surface/channel.cc +++ b/src/core/lib/surface/channel.cc @@ -67,7 +67,7 @@ struct grpc_channel { gpr_mu registered_call_mu; registered_call* registered_calls; - grpc_core::RefCountedPtr tracer; + grpc_core::RefCountedPtr tracer; char* target; }; @@ -170,8 +170,8 @@ grpc_channel* grpc_channel_create_with_builder( channel->compression_options.enabled_algorithms_bitset = static_cast(args->args[i].value.integer) | 0x1; /* always support no compression */ - } else if (0 == - strcmp(args->args[i].key, GRPC_ARG_MAX_CHANNEL_TRACE_EVENTS_PER_NODE)) { + } else if (0 == strcmp(args->args[i].key, + GRPC_ARG_MAX_CHANNEL_TRACE_EVENTS_PER_NODE)) { GPR_ASSERT(channel_tracer_max_nodes == 0); // max_nodes defaults to 10, clamped between 0 and 100. const grpc_integer_options options = {10, 0, 100}; @@ -181,10 +181,11 @@ grpc_channel* grpc_channel_create_with_builder( } grpc_channel_args_destroy(args); - channel->tracer = grpc_core::MakeRefCounted( + channel->tracer = grpc_core::MakeRefCounted( channel_tracer_max_nodes); - channel->tracer->AddTrace(grpc_slice_from_static_string("Channel created"), - GRPC_ERROR_NONE, GRPC_CHANNEL_IDLE); + channel->tracer->AddTraceEvent( + grpc_slice_from_static_string("Channel created"), GRPC_ERROR_NONE, + GRPC_CHANNEL_IDLE); return channel; }