function

async_hooks.createHook

Registers functions to be called for different lifetime events of each async operation.

The callbacks init()/before()/after()/destroy() are called for the respective asynchronous event during a resource's lifetime.

All callbacks are optional. For example, if only resource cleanup needs to be tracked, then only the destroy callback needs to be passed. The specifics of all functions that can be passed to callbacks is in the Hook Callbacks section.

import { createHook } from 'node:async_hooks';

const asyncHook = createHook({
  init(asyncId, type, triggerAsyncId, resource) { },
  destroy(asyncId) { },
});

The callbacks will be inherited via the prototype chain:

class MyAsyncCallbacks {
  init(asyncId, type, triggerAsyncId, resource) { }
  destroy(asyncId) {}
}

class MyAddedCallbacks extends MyAsyncCallbacks {
  before(asyncId) { }
  after(asyncId) { }
}

const asyncHook = async_hooks.createHook(new MyAddedCallbacks());

Because promises are asynchronous resources whose lifecycle is tracked via the async hooks mechanism, the init(), before(), after(), anddestroy() callbacks must not be async functions that return promises.

@param callbacks

The Hook Callbacks to register

@returns

Instance used for disabling and enabling hooks

Referenced types

interface HookCallbacks

after(
asyncId: number
): void;
Called immediately after the callback specified in before is completed.
If an uncaught exception occurs during execution of the callback, then after will run after the 'uncaughtException' event is emitted or a domain's handler runs.
@param asyncId
the unique identifier assigned to the resource which has executed the callback.
before(
asyncId: number
): void;
When an asynchronous operation is initiated or completes a callback is called to notify the user. The before callback is called just before said callback is executed.
@param asyncId
the unique identifier assigned to the resource about to execute the callback.
destroy(
asyncId: number
): void;
Called after the resource corresponding to asyncId is destroyed
@param asyncId
a unique ID for the async resource
init(
asyncId: number,
type: string,
triggerAsyncId: number,
resource: object
): void;
Called when a class is constructed that has the possibility to emit an asynchronous event.
@param asyncId
A unique ID for the async resource
@param type
The type of the async resource
@param triggerAsyncId
The unique ID of the async resource in whose execution context this async resource was created
@param resource
Reference to the resource representing the async operation, needs to be released during destroy
promiseResolve(
asyncId: number
): void;
Called when a promise has resolve() called. This may not be in the same execution id as the promise itself.
@param asyncId
the unique id for the promise that was resolve()d.

interface AsyncHook

disable(): this;
Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
enable(): this;
Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.