Slow response to resolved promise node.js - node.js

Question

I'm brand new to node.js and and I feel I am doing something incorrectly, but I'm having a harder time googling good answers then I have for other languages for some reason. Basically I'm using a node wrapped c++ addon to do some work and then I want to send it over a websocket after I've done some some additional parsing on it. When the additional parsing is done synchronously it is sent immediately (as expected). When I do the work in a promise (which is what a thirdparty module is doing for me) after the resolve is called it takes an excessively long time for the fulfilled callback to be called. Like upwards of 5-10 seconds. Here's the code:
var addon = require('...'); // Node wrapped C++ module
...
var server = http.createServer(){...};
var ios = io.listen(server);
function someFunction(args) {
console.log("Preparing to call some function");
someOtherFunction(args).then(funtction(val) {
console.log("Sending val over websocket....");
ios.sockets.emit('thing', val);
}
}
function someOtherFunction(args) {
return new Promise(function(resolve, reject) {
//logic
resolve(someVal);
console.log("Done with someOtherFunc");
}
}
ios.sockets.on('connection', function(socket){
console.log("Conneced");
// This does some work on a different thread. Eventually reposts to event loop and calls callback
addon.doThing("someVal", someFunc);
socket.on('disconnect', function() {
console.log("Disconnected");
});
});
Output:
Connected
Preparing to call some function...
Done with someOtherFunc;
<variable delay sometimes up to 5-10 seconds>
Sending val over websocket.
Multiple callbacks to someFunction may happen before the first call to someOtherFunction is done. These are all posted events to the the main Event loop, so I don't believe anything is blocking there.
Output:
Connected
Preparing to call some function...
Done with someOtherFunc;
<1 second delay>
Preparing to call some function...
Done with someOtherFunc;
<1 second delay>
Preparing to call some function...
Done with someOtherFunc;
<1 second delay>
<variable delay sometimes up to 5-10 seconds>
Sending val over websocket.
Sending val over websocket.
Sending val over websocket.
So my question original thought was that when resolve was called then the callback was called immediately. But that doesn't look like it's happening. Something is triggering the callback to eventually trigger but I have no idea what and it seems random when it actually does. Any help would be appreciated!
C++ Addon code:
class NodeWrapper {
public:
static NodeWrapper& GetInstance() {
static NodeWrapper mInstance;
return mInstance;
}
~NodeWrapper() {
uv_close((uv_handle_t*) &mNodeAsyncEventLoop, NULL);
};
static void SendToNode(uv_async_t *handle) {
GetInstance().SendToNode();
}
void SendToNode() {
uv_mutex_lock(&mMutex);
swap(pushQueue, popQueue);
uv_mutex_unlock(&mMutex);
while(!popQueue.empty()) {
Data* pData = popQueue.front();
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
const unsigned argc = 1;
Local<Value> argv = { node::Buffer::New(isolate, pData->mData, pData->mLen, DataDeleter, NULL).ToLocalChecked() };
Local<Function> cb = Local<Function>::New(isolate, mNodeCB);
cb->Call(isolate->GetCurrentContext()->Global(), argc, &argv);
popQueue.pop();
}
log << "Done with Callback!" << std::endl;
}
void SendOnData(const void* pData, DWORD dwLen) {
log << "Callback received!" << std::endl;
if(dwLen > 0) {
uv_mutex_lock(&mMutex);
pushQueue.push(new Data(pData, dwLen));
uv_mutex_unlock(&mMutex);
uv_async_send(&GetInstance().mNodeAsyncEventLoop);
}
};
static NodeWrapper mInstance;
UniquePersistent<Function> mNodeCB;
private:
NodeWrapper() {
uv_async_init(uv_default_loop(), &mNodeAsyncEventLoop, &NodeWrapper::SendToNode);
uv_mutex_init(&mMutex);
};
DATA_QUEUE pushQueue;
DATA_QUEUE popQueue;
uv_mutex_t mMutex;
uv_async_t mNodeAsyncEventLoop;
};
void doThing(const FunctionCallbackInfo<Value>& args) {
Isolate* isolate = Isolate::GetCurrent();
HandleScope scope(isolate);
auto f = std::bind(&NodeWrapper::SendOnData, &NodeWrapper::GetInstance());
DoThingAnotherThreadAndCallCallback(f);
NodeWrapper::GetInstance().mNodeCB = UniquePersistent<Function>(isolate, Local<Function>::Cast(args[1]));
}
Output update:
22:01:57.831645 - Callback received
Preparing to call some function....
Done with someOtherFunc
22:01:57.839711 - Done with Callback!
22:01:57.918472 - Callback received
Preparing to call some function....
Done with someOtherFunc
22:01:57.927344 - Done with Callback!
Sending val over websocket....
Sending val over websocket....

Answer 1

Promise .then() callbacks are never called immediately upon resolve(). Instead, they are always called asynchronously. This provides uniform async behavior whether the resolve is called synchronously or asynchronously, thus making life a lot easier for the caller.
Promises wait until other code in the current thread of execution has finished executing and the stack frame has cleared back to only "platform code" as the spec says. Then, the .then() callback is called. If you are doing a lot of other stuff in that thread of execution, then there can be a delay before the .then() handler is called.

Answer 2

I solved it by switching from native v8 Promises to bluebird Promises. Native v8 Promises are handled by a Microtask queue, I'm not sure how c++ addons are handled (I could never get a good stack trace to see) but it looks like the microtask queue was getting starved until it eventually ran after some event must of flushed it (still not sure about it). bluebird uses SetImmediate which and it is processed immediately which solved the issue for me.
Further reading read here: https://github.com/nodejs/node-v0.x-archive/issues/7714
This was "fixed" in v0.12, I'm using actually io.js v3.2.0. I'm not 100% sure if this is the same issue or different. Either way I'll stick with bluebird for now