lib: lazy loaded

This makes sure the async hooks and more is only loaded in case it
is actually necessary.
PR-URL: #20567
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>

Author: BridgeAR

lib/internal/bootstrap/node.js

@@ -63,7 +63,17 @@
 if(global.__coverage__)
 NativeModule.require('internal/process/write-coverage').setup();
 
-NativeModule.require('internal/trace_events_async_hooks').setup();
+
+{
+consttraceEvents=process.binding('trace_events');
+consttraceEventCategory='node,node.async_hooks';
+
+if(traceEvents.categoryGroupEnabled(traceEventCategory)){
+NativeModule.require('internal/trace_events_async_hooks')
+.setup(traceEvents,traceEventCategory);
+}
+}
+
 
 if(process.config.variables.v8_enable_inspector){
 NativeModule.require('internal/inspector_async_hook').setup();

lib/internal/trace_events_async_hooks.js

@@ -1,71 +1,63 @@
 'use strict';
 
-consttrace_events=process.binding('trace_events');
-constasync_wrap=process.binding('async_wrap');
-constasync_hooks=require('async_hooks');
-
-// Use small letters such that chrome://tracing groups by the name.
-// The behavior is not only useful but the same as the events emitted using
-// the specific C++ macros.
-constBEFORE_EVENT='b'.charCodeAt(0);
-constEND_EVENT='e'.charCodeAt(0);
-
-// In trace_events it is not only the id but also the name that needs to be
-// repeated. Since async_hooks doesn't expose the provider type in the
-// non-init events, use a map to manually map the asyncId to the type name.
-consttypeMemory=newMap();
-
-consttrace_event_category='node,node.async_hooks';
-
-// It is faster to emit trace_events directly from C++. Thus, this happens in
-// async_wrap.cc. However, events emitted from the JavaScript API or the
-// Embedder C++ API can't be emitted from async_wrap.cc. Thus they are
-// emitted using the JavaScript API. To prevent emitting the same event
-// twice the async_wrap.Providers list is used to filter the events.
-constnativeProviders=newSet(Object.keys(async_wrap.Providers));
-
-consthook=async_hooks.createHook({
-init(asyncId,type,triggerAsyncId,resource){
-if(nativeProviders.has(type))return;
-
-typeMemory.set(asyncId,type);
-trace_events.emit(BEFORE_EVENT,trace_event_category,
-type,asyncId,
-'triggerAsyncId',triggerAsyncId,
-'executionAsyncId',async_hooks.executionAsyncId());
-},
-
-before(asyncId){
-consttype=typeMemory.get(asyncId);
-if(type===undefined)return;
-
-trace_events.emit(BEFORE_EVENT,trace_event_category,
-type+'_CALLBACK',asyncId);
-},
-
-after(asyncId){
-consttype=typeMemory.get(asyncId);
-if(type===undefined)return;
-
-trace_events.emit(END_EVENT,trace_event_category,
-type+'_CALLBACK',asyncId);
-},
-
-destroy(asyncId){
-consttype=typeMemory.get(asyncId);
-if(type===undefined)return;
-
-trace_events.emit(END_EVENT,trace_event_category,
-type,asyncId);
-
-// cleanup asyncId to type map
-typeMemory.delete(asyncId);
-}
-});
-
-
-exports.setup=function(){
-if(trace_events.categoryGroupEnabled(trace_event_category)){
-hook.enable();
-}
+exports.setup=function(traceEvents,traceEventCategory){
+constasync_wrap=process.binding('async_wrap');
+constasync_hooks=require('async_hooks');
+
+// Use small letters such that chrome://tracing groups by the name.
+// The behavior is not only useful but the same as the events emitted using
+// the specific C++ macros.
+constBEFORE_EVENT='b'.charCodeAt(0);
+constEND_EVENT='e'.charCodeAt(0);
+
+// In traceEvents it is not only the id but also the name that needs to be
+// repeated. Since async_hooks doesn't expose the provider type in the
+// non-init events, use a map to manually map the asyncId to the type name.
+consttypeMemory=newMap();
+
+// It is faster to emit traceEvents directly from C++. Thus, this happens
+// in async_wrap.cc. However, events emitted from the JavaScript API or the
+// Embedder C++ API can't be emitted from async_wrap.cc. Thus they are
+// emitted using the JavaScript API. To prevent emitting the same event
+// twice the async_wrap.Providers list is used to filter the events.
+constnativeProviders=newSet(Object.keys(async_wrap.Providers));
+
+async_hooks.createHook({
+init(asyncId,type,triggerAsyncId,resource){
+if(nativeProviders.has(type))return;
+
+typeMemory.set(asyncId,type);
+traceEvents.emit(BEFORE_EVENT,traceEventCategory,
+type,asyncId,
+'triggerAsyncId',triggerAsyncId,
+'executionAsyncId',async_hooks.executionAsyncId());
+},
+
+before(asyncId){
+consttype=typeMemory.get(asyncId);
+if(type===undefined)return;
+
+traceEvents.emit(BEFORE_EVENT,traceEventCategory,
+type+'_CALLBACK',asyncId);
+},
+
+after(asyncId){
+consttype=typeMemory.get(asyncId);
+if(type===undefined)return;
+
+traceEvents.emit(END_EVENT,traceEventCategory,
+type+'_CALLBACK',asyncId);
+},
+
+destroy(asyncId){
+consttype=typeMemory.get(asyncId);
+if(type===undefined)return;
+
+traceEvents.emit(END_EVENT,traceEventCategory,
+type,asyncId);
+
+// cleanup asyncId to type map
+typeMemory.delete(asyncId);
+}
+}).enable();
 };