From f5986a464316e2c7c2a21f5a5e9ffa7e527fd9d4 Mon Sep 17 00:00:00 2001 From: Ali Ijaz Sheikh Date: Thu, 11 Oct 2018 06:33:25 -0700 Subject: src: trace_event: secondary storage for metadata Metadata trace-events should be held in secondary storage so that they can be periodically reemitted. This change establishes the secondary storage and ensures that events are reemitted on each flush. PR-URL: https://github.com/nodejs/node/pull/20900 Reviewed-By: James M Snell Reviewed-By: Anna Henningsen --- src/tracing/agent.cc | 27 +++++++++++++++++++++++++++ src/tracing/agent.h | 15 +++++++++++++++ src/tracing/trace_event.cc | 14 +++++++++----- src/tracing/trace_event.h | 40 +++++++++++++++++++++++++++------------- 4 files changed, 78 insertions(+), 18 deletions(-) (limited to 'src/tracing') diff --git a/src/tracing/agent.cc b/src/tracing/agent.cc index fd5cb3387b..103df55da5 100644 --- a/src/tracing/agent.cc +++ b/src/tracing/agent.cc @@ -1,6 +1,7 @@ #include "tracing/agent.h" #include +#include "trace_event.h" #include "tracing/node_trace_buffer.h" #include "debug_utils.h" #include "env-inl.h" @@ -207,9 +208,35 @@ void Agent::AppendTraceEvent(TraceObject* trace_event) { } void Agent::Flush(bool blocking) { + for (const auto& event : metadata_events_) + AppendTraceEvent(event.get()); + for (const auto& id_writer : writers_) id_writer.second->Flush(blocking); } +void TracingController::AddMetadataEvent( + const unsigned char* category_group_enabled, + const char* name, + int num_args, + const char** arg_names, + const unsigned char* arg_types, + const uint64_t* arg_values, + std::unique_ptr* convertable_values, + unsigned int flags) { + std::unique_ptr trace_event(new TraceObject); + trace_event->Initialize( + TRACE_EVENT_PHASE_METADATA, category_group_enabled, name, + node::tracing::kGlobalScope, // scope + node::tracing::kNoId, // id + node::tracing::kNoId, // bind_id + num_args, arg_names, arg_types, arg_values, convertable_values, + TRACE_EVENT_FLAG_NONE, + CurrentTimestampMicroseconds(), + CurrentCpuTimestampMicroseconds()); + node::tracing::TraceEventHelper::GetAgent()->AddMetadataEvent( + std::move(trace_event)); +} + } // namespace tracing } // namespace node diff --git a/src/tracing/agent.h b/src/tracing/agent.h index e9f52abe64..db5e2a6bfd 100644 --- a/src/tracing/agent.h +++ b/src/tracing/agent.h @@ -7,6 +7,7 @@ #include "util.h" #include "node_mutex.h" +#include #include #include #include @@ -34,6 +35,15 @@ class TracingController : public v8::platform::tracing::TracingController { int64_t CurrentTimestampMicroseconds() override { return uv_hrtime() / 1000; } + void AddMetadataEvent( + const unsigned char* category_group_enabled, + const char* name, + int num_args, + const char** arg_names, + const unsigned char* arg_types, + const uint64_t* arg_values, + std::unique_ptr* convertable_values, + unsigned int flags); }; class AgentWriterHandle { @@ -93,6 +103,10 @@ class Agent { // Writes to all writers registered through AddClient(). void AppendTraceEvent(TraceObject* trace_event); + + void AddMetadataEvent(std::unique_ptr event) { + metadata_events_.push_back(std::move(event)); + } // Flushes all writers registered through AddClient(). void Flush(bool blocking); @@ -131,6 +145,7 @@ class Agent { ConditionVariable initialize_writer_condvar_; uv_async_t initialize_writer_async_; std::set to_be_initialized_; + std::list> metadata_events_; }; void AgentWriterHandle::reset() { diff --git a/src/tracing/trace_event.cc b/src/tracing/trace_event.cc index f661dd5c69..9232c34c4c 100644 --- a/src/tracing/trace_event.cc +++ b/src/tracing/trace_event.cc @@ -3,14 +3,18 @@ namespace node { namespace tracing { -v8::TracingController* g_controller = nullptr; +Agent* g_agent = nullptr; -void TraceEventHelper::SetTracingController(v8::TracingController* controller) { - g_controller = controller; +void TraceEventHelper::SetAgent(Agent* agent) { + g_agent = agent; } -v8::TracingController* TraceEventHelper::GetTracingController() { - return g_controller; +Agent* TraceEventHelper::GetAgent() { + return g_agent; +} + +TracingController* TraceEventHelper::GetTracingController() { + return g_agent->GetTracingController(); } } // namespace tracing diff --git a/src/tracing/trace_event.h b/src/tracing/trace_event.h index 1165fca59a..d5d4befb14 100644 --- a/src/tracing/trace_event.h +++ b/src/tracing/trace_event.h @@ -310,8 +310,9 @@ const uint64_t kNoId = 0; class TraceEventHelper { public: - static v8::TracingController* GetTracingController(); - static void SetTracingController(v8::TracingController* controller); + static TracingController* GetTracingController(); + static Agent* GetAgent(); + static void SetAgent(Agent* agent); }; // TraceID encapsulates an ID that can either be an integer or pointer. Pointers @@ -487,6 +488,26 @@ static V8_INLINE uint64_t AddTraceEventWithTimestampImpl( arg_names, arg_types, arg_values, arg_convertables, flags, timestamp); } +static V8_INLINE void AddMetadataEventImpl( + const uint8_t* category_group_enabled, const char* name, int32_t num_args, + const char** arg_names, const uint8_t* arg_types, + const uint64_t* arg_values, unsigned int flags) { + std::unique_ptr arg_convertibles[2]; + if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) { + arg_convertibles[0].reset(reinterpret_cast( + static_cast(arg_values[0]))); + } + if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) { + arg_convertibles[1].reset(reinterpret_cast( + static_cast(arg_values[1]))); + } + node::tracing::TracingController* controller = + node::tracing::TraceEventHelper::GetTracingController(); + return controller->AddMetadataEvent( + category_group_enabled, name, num_args, arg_names, arg_types, arg_values, + arg_convertibles, flags); +} + // Define SetTraceValue for each allowed type. It stores the type and // value in the return arguments. This allows this API to avoid declaring any // structures so that it is portable to third_party libraries. @@ -632,23 +653,16 @@ static V8_INLINE uint64_t AddTraceEventWithTimestamp( } template -static V8_INLINE uint64_t AddMetadataEvent( +static V8_INLINE void AddMetadataEvent( const uint8_t* category_group_enabled, const char* name, const char* arg1_name, ARG1_TYPE&& arg1_val) { const int num_args = 1; uint8_t arg_type; uint64_t arg_value; SetTraceValue(std::forward(arg1_val), &arg_type, &arg_value); - // TODO(ofrobots): It would be good to add metadata events to a separate - // buffer so that they can be periodically reemitted. For now, we have a - // single buffer, so we just add them to the main buffer. - return TRACE_EVENT_API_ADD_TRACE_EVENT( - TRACE_EVENT_PHASE_METADATA, - category_group_enabled, name, - node::tracing::kGlobalScope, // scope - node::tracing::kNoId, // id - node::tracing::kNoId, // bind_id - num_args, &arg1_name, &arg_type, &arg_value, TRACE_EVENT_FLAG_NONE); + AddMetadataEventImpl( + category_group_enabled, name, num_args, &arg1_name, &arg_type, &arg_value, + TRACE_EVENT_FLAG_NONE); } // Used by TRACE_EVENTx macros. Do not use directly. -- cgit v1.2.3