All files / lib/internal trace_events_async_hooks.js

93.75% Statements 90/96
94.12% Branches 16/17
85.71% Functions 6/7
93.75% Lines 90/96

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 9710x 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 30x 15x 15x 15x 15x 15x 15x 15x 15x 9x 9x 9x 22x 22x 15x 15x 9x 9x 9x 22x 22x 15x 15x 9x 9x 9x 19x 19x 15x 15x 15x 15x 15x 19x 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();
 
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;