I am currently developing an application in Node.js that requires numerous configuration and database calls to process user data. The problem I am facing is that after reaching 11,800+ function calls, Node throws a RangeError and exits the process.
The error message reads: "RangeError: Maximum call stack size exceeded"
Has anyone else encountered this issue and how did you resolve it? I have started breaking up my code into multiple worker files, but each time I process a data node, it involves interactions with two databases (up to 25 calls to update various tables) and perform several sanitization checks.
I am open to acknowledging any non-optimal practices on my end and would appreciate guidance if there is a better approach.
Below is a snippet of the code I am running for processing data:
app.post('/initspeaker', function(req, res) {
// Check if Admin ID is present
if(req.body.xyzid != config.adminid) {
res.send({});
return;
}
var gcnt = 0, dbsize = 0, goutput = [], goutputdata = [], xyzuserdataCallers = [];
xyz.loadbatchfile(xyz.getbatchurl("speakers", "csv"), function(data) {
var parsed = csv.parse(data);
console.log("lexicon", parsed[0]);
for(var i = 1; i < parsed.length; i++) {
if(typeof parsed[i][0] != 'undefined' && parsed[i][0] != 'name') {
var xyzevent = require('./lib/model/xyz_speaker').create(parsed[i], parsed[0]);
xyzevent.isPresenter = true;
goutput.push(xyzevent);
}
}
dbsize = goutput.length;
xyzuserdataCallers = [new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata(),
new xyzuserdata()
];
xyzuserdataCallers[0].sendSpeakerData(goutput[0]);
for(var i = 1; i < xyzuserdataCallers; i++) {
xyzuserdataCallers[i].sendSpeakerData(8008);
}
});
var callback = function(data, func) {
if(data && data != 8008) {
if(gcnt >= dbsize) {
res.send("done");
} else {
gcnt++;
func.sendSpeakerData(goutput[gcnt]);
}
} else {
gcnt++;
func.sendSpeakerData(goutput[gcnt]);
}
};
var xyzuserdata = function() {};
xyzuserdata.prototype.sendSpeakerData = function(data) {
var thisfunc = this;
if(data && data != 8008) {
var userdata = require('./lib/model/user').create(data.toObject());
var speakerdata = userdata.toObject();
speakerdata.uid = uuid.v1();
speakerdata.isPresenter = true;
couchdb.insert(speakerdata, config.couch.db.user, function($data) {
if($data == false) {
console.log("*** trying user data again ***");
speakerdata.uid = uuid.v1();
arguments.callee(speakerdata);
} else {
callback($data, thisfunc);
}
});
} else {
gcnt++;
arguments.callee(goutput[gcnt]);
}
};
});
Some classes and elements are defined here that may need clarification:
- I am using Express.js with hosted CouchDB to respond to POST requests
- There is a CSV parser class that loads event lists for fetching speaker data
- Each event can have varying numbers of users (currently around 8K users for all events)
- I follow a pattern of loading all data/users before processing any of them
- Each loaded user from an external source is converted into an object and sanitized accordingly
- Each user is then inserted into CouchDB
The code runs fine initially, but eventually crashes after making over 11,800+ calls. The error does not provide a stack trace like a typical coding error; rather, it exits due to the sheer number of calls being made.
Any help, feedback, or suggestions would be greatly appreciated.