async hooks promise not destroyed

[wengeezhang]

• Version: node -v 8.2.1
• Platform: window 7 64-bit
• Subsystem:

my code is like follows:

const async_hooks = require('async_hooks');

function init(id, type, triggerId, handle) {
    process._rawDebug(`id: ${id}, type: ${type}, triggerId: ${triggerId}, 
                                        handle.promise: ${handle.promise}, 
                                        handle.parentid: ${handle.parentId}`);
}


function before(id) { 
    process._rawDebug('before', id, async_hooks.executionAsyncId());
 }
function after(id) { 
    process._rawDebug('after', id, async_hooks.executionAsyncId());
 }
function destroy(id) {
    process._rawDebug('destroy', id);
}

async_hooks.createHook({init, before, after, destroy}).enable();
debugger;

const parent_promise = new Promise((resolve, reject) => {resolve(5);}); 
const promise = parent_promise.then((val) => {return val;});

the output is:

id: 2, type: PROMISE, triggerId: 1
id: 3, type: PROMISE, triggerId: 2
before 3 3
after 3 3

why the Promise async resources' destroy callback not triggered?

[AndreasMadsen]

Promises are only destroyed by the V8 garbage collector. If you give the process some time it should eventually destroy them.

[Fishrock123]

Yes, exactly what @AndreasMadsen said.

(Generally avoid holding onto any resource of handle for an indeterminate amount of time.)

[wengeezhang]

const async_hooks = require('async_hooks');
let map = new Map();

function init(asyncId, type, triggerId, resource) {
    let emptyObj = {};
    Error.captureStackTrace(emptyObj, init);
    map.set(asyncId,emptyObj.stack)
}


function before(asyncId) { 
    global.longStack = map.get(asyncId);
 }
function after(asyncId) { 

 }
function destroy(asyncId) {
  map.delete(asyncId);
}

async_hooks.createHook({init, before, after, destroy}).enable();
debugger;

const parent_promise = new Promise((resolve, reject) => {resolve(5);}); 
const promise = parent_promise.then((val) => {return val;});

i want to implement a 'long stack trace' using async hooks like this:

• store stack in a map when async resource's initiated

• restore the stack in 'before' callback.

how can i delete the stack in the map?

(not using weakmap,because

Note: In some cases the resource object is reused for performance reasons, it is thus not safe to use it as a key in a WeakMap or add properties to it.

in nodejs api doc)

@Fishrock123

[AndreasMadsen]

In terms of destroy your implementation is fine. You are right that the promises aren't immediately destroyed and thus the stack traces are also not immediately destroyed. However, this is fine, what is important is that they are eventually destroyed, otherwise you have a memory leak.

PS: You should be aware that before and after can be called multiple times in the same tick. (e.g. before(1), before(2), after(2), after(1)), thus global.longStack should be a stack and not a single value.

You can look at my long stack trace (https://github.com/AndreasMadsen/trace/blob/master/trace.js) for more inspiration.

[wengeezhang]

@AndreasMadsen Thanks for your info:

PS: You should be aware that before and after can be called multiple times in the same tick. (e.g. before(1), before(2), after(2), after(1)), thus global.longStack should be a stack and not a single value.

i've inspected your implementation and gained much.
However,when i use your implementation to test

const parent_promise = new Promise((resolve, reject) => {resolve(5);}); 
const promise = parent_promise.then((val) => {return val;});

i got the same result:
after half an hour,the traces map in your implementation still has 'the Promise' stack. If the site is busy(more and more requests come),then the 'traces' will eat more and more memeroy

[wengeezhang]

my worries in this issue do not exist!!!

thanks @AndreasMadsen
i've confirmed that promise is eventually destroyed.
If it's not destroyed(maybe a long time,several hours,or several days),it's really ok.

The reason is:

• promises not to many,GC think it's not time to trigger a collection(expensive)
• when there're to many,GC will trigger collection(you can make new more promises to verify this)