From c85933cbd07ec3e32fdb27c4c4ef1aeadc609345 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 4 Aug 2018 09:48:50 -0700
Subject: [PATCH] trace_events,async_hooks: use intrinsic trace

Switch to using the intrinsic trace event method for async_hooks.

This is a breaking change because of the switch to a nested data
argument for exec id and trigger id values.

PR-URL: https://github.com/nodejs/node/pull/22127
Reviewed-By: Andreas Madsen <amwebdk@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
---
 lib/internal/trace_events_async_hooks.js      | 20 +++++++++----------
 src/async_wrap.cc                             | 20 ++++++++++++-------
 .../parallel/test-trace-events-async-hooks.js |  4 ++--
 3 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/lib/internal/trace_events_async_hooks.js b/lib/internal/trace_events_async_hooks.js
index 011dc6bbead187..f687f1ced8e155 100644
--- a/lib/internal/trace_events_async_hooks.js
+++ b/lib/internal/trace_events_async_hooks.js
@@ -1,6 +1,7 @@
 'use strict';
 
 exports.setup = function(traceEvents, traceEventCategory) {
+  const { trace } = traceEvents;
   const async_wrap = process.binding('async_wrap');
   const async_hooks = require('async_hooks');
 
@@ -27,34 +28,33 @@ exports.setup = function(traceEvents, traceEventCategory) {
       if (nativeProviders.has(type)) return;
 
       typeMemory.set(asyncId, type);
-      traceEvents.emit(BEFORE_EVENT, traceEventCategory,
-                       type, asyncId,
-                       'triggerAsyncId', triggerAsyncId,
-                       'executionAsyncId', async_hooks.executionAsyncId());
+      trace(BEFORE_EVENT, traceEventCategory,
+            type, asyncId,
+            {
+              triggerAsyncId,
+              executionAsyncId: async_hooks.executionAsyncId()
+            });
     },
 
     before(asyncId) {
       const type = typeMemory.get(asyncId);
       if (type === undefined) return;
 
-      traceEvents.emit(BEFORE_EVENT, traceEventCategory,
-                       type + '_CALLBACK', asyncId);
+      trace(BEFORE_EVENT, traceEventCategory, `${type}_CALLBACK`, asyncId);
     },
 
     after(asyncId) {
       const type = typeMemory.get(asyncId);
       if (type === undefined) return;
 
-      traceEvents.emit(END_EVENT, traceEventCategory,
-                       type + '_CALLBACK', asyncId);
+      trace(END_EVENT, traceEventCategory, `${type}_CALLBACK`, asyncId);
     },
 
     destroy(asyncId) {
       const type = typeMemory.get(asyncId);
       if (type === undefined) return;
 
-      traceEvents.emit(END_EVENT, traceEventCategory,
-                       type, asyncId);
+      trace(END_EVENT, traceEventCategory, type, asyncId);
 
       // cleanup asyncId to type map
       typeMemory.delete(asyncId);
diff --git a/src/async_wrap.cc b/src/async_wrap.cc
index 7f2a0ece2f0055..51072bb8c9c8e9 100644
--- a/src/async_wrap.cc
+++ b/src/async_wrap.cc
@@ -23,6 +23,7 @@
 #include "env-inl.h"
 #include "node_internals.h"
 #include "util-inl.h"
+#include "tracing/traced_value.h"
 
 #include "v8.h"
 #include "v8-profiler.h"
@@ -608,13 +609,18 @@ void AsyncWrap::AsyncReset(double execution_async_id, bool silent) {
   switch (provider_type()) {
 #define V(PROVIDER)                                                           \
     case PROVIDER_ ## PROVIDER:                                               \
-      TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(                                      \
-        TRACING_CATEGORY_NODE1(async_hooks),                                  \
-        #PROVIDER, static_cast<int64_t>(get_async_id()),                      \
-        "executionAsyncId",                                                   \
-        static_cast<int64_t>(env()->execution_async_id()),                    \
-        "triggerAsyncId",                                                     \
-        static_cast<int64_t>(get_trigger_async_id()));                        \
+      if (*TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(                        \
+          TRACING_CATEGORY_NODE1(async_hooks))) {                             \
+        auto data = tracing::TracedValue::Create();                           \
+        data->SetInteger("executionAsyncId",                                  \
+                         static_cast<int64_t>(env()->execution_async_id()));  \
+        data->SetInteger("triggerAsyncId",                                    \
+                         static_cast<int64_t>(get_trigger_async_id()));       \
+        TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(                                    \
+          TRACING_CATEGORY_NODE1(async_hooks),                                \
+          #PROVIDER, static_cast<int64_t>(get_async_id()),                    \
+          "data", std::move(data));                                           \
+        }                                                                     \
       break;
     NODE_ASYNC_PROVIDER_TYPES(V)
 #undef V
diff --git a/test/parallel/test-trace-events-async-hooks.js b/test/parallel/test-trace-events-async-hooks.js
index 13cd523de7ae9c..7c82eb9364a27e 100644
--- a/test/parallel/test-trace-events-async-hooks.js
+++ b/test/parallel/test-trace-events-async-hooks.js
@@ -61,8 +61,8 @@ proc.once('exit', common.mustCall(() => {
       return (trace.ph === 'b' && !trace.name.includes('_CALLBACK'));
     });
     assert.ok(initEvents.every((trace) => {
-      return (trace.args.executionAsyncId > 0 &&
-              trace.args.triggerAsyncId > 0);
+      return (trace.args.data.executionAsyncId > 0 &&
+              trace.args.data.triggerAsyncId > 0);
     }), `Unexpected initEvents format: ${util.inspect(initEvents)}`);
   }));
 }));