All files / lib/internal trace_events_async_hooks.js

93.94% Statements 93/99
94.44% Branches 17/18
85.71% Functions 6/7
93.94% Lines 93/99

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 10010x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 10x 9x 9x 9x 9x 9x 9x 9x 31x 25x 25x 25x 25x 25x 25x 25x 25x 9x 9x 9x 23x 23x 16x 16x 9x 9x 9x 23x 23x 16x 16x 9x 9x 9x 20x 20x 16x 16x 16x 16x 16x 20x 9x 9x 9x 9x 9x 9x 9x 9x 9x 9x 9x             9x 9x 10x 10x  
'use strict';
 
const {
  ObjectKeys,
  SafeMap,
  SafeSet,
  Symbol,
} = primordials;
 
const { trace } = internalBinding('trace_events');
const async_wrap = internalBinding('async_wrap');
const async_hooks = require('async_hooks');
const {
  CHAR_LOWERCASE_B,
  CHAR_LOWERCASE_E,
} = require('internal/constants');
 
// 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.
const kBeforeEvent = CHAR_LOWERCASE_B;
const kEndEvent = CHAR_LOWERCASE_E;
const kTraceEventCategory = 'node,node.async_hooks';
 
const kEnabled = Symbol('enabled');
 
// 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.
const nativeProviders = new SafeSet(ObjectKeys(async_wrap.Providers));
const typeMemory = new SafeMap();
 
// Promises are not AsyncWrap resources so they should emit trace_events here.
nativeProviders.delete('PROMISE');
 
function createHook() {
  // 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.
 
  const hook = async_hooks.createHook({
    init(asyncId, type, triggerAsyncId, resource) {
      if (nativeProviders.has(type)) return;
 
      typeMemory.set(asyncId, type);
      trace(kBeforeEvent, kTraceEventCategory,
            type, asyncId,
            {
              triggerAsyncId,
              executionAsyncId: async_hooks.executionAsyncId()
            });
    },
 
    before(asyncId) {
      const type = typeMemory.get(asyncId);
      if (type === undefined) return;
 
      trace(kBeforeEvent, kTraceEventCategory, `${type}_CALLBACK`, asyncId);
    },
 
    after(asyncId) {
      const type = typeMemory.get(asyncId);
      if (type === undefined) return;
 
      trace(kEndEvent, kTraceEventCategory, `${type}_CALLBACK`, asyncId);
    },
 
    destroy(asyncId) {
      const type = typeMemory.get(asyncId);
      if (type === undefined) return;
 
      trace(kEndEvent, kTraceEventCategory, type, asyncId);
 
      // Cleanup asyncId to type map
      typeMemory.delete(asyncId);
    }
  });
 
  return {
    enable() {
      if (this[kEnabled])
        return;
      this[kEnabled] = true;
      hook.enable();
    },
 
    disable() {
      if (!this[kEnabled])
        return;
      this[kEnabled] = false;
      hook.disable();
      typeMemory.clear();
    }
  };
}
 
exports.createHook = createHook;