Node.js request starvation during large IO - json

Question

I have a node application that utilizes streams to read and process data from a DB.
I have a reader stream that makes a request via ZeroMQ and as it receives the data it pushes the data out to the next stream in the pipe.
The second stream will write the JSON data to a file and then pass the data on.
The final stream will convert the JSON data to a CSV and then write out a CSV file.
What I'm noticing is that when I'm receiving a "large" amount of data from the DB (over 10k rows and about 2MB of uncompressed raw data) that this process takes a considerable amount of time (~20 seconds). And during that 20 seconds, other requests are starved and can not complete.
Does this sound right? Is the there a way to relinquish the thread to allow it to do other work while the stream of data is being read/written? Or is there a better approach to handling this file I/O?
EDIT FOR CODE
function FirstStream(msg) {
stream.Readable.call(this, { objectMode: true });
this.request = msg;
this._read = function() {
var self = this;
DBRequest.send(self.request).then(function(json) {
json.Body.messages.forEach(function(item) {
self.push(JSON.stringify(item));
});
self.push(null);
});
};
}
util.inherits(FirstStream, stream.Readable);
function SecondStream(filename, maxFileSize) {
stream.Transform.call(this, { objectMode: true });
this.filename = filename;
this.jsonArray = [];
this.buf = '';
this.bufferTooBig = false;
this.id = 0;
this.maxFileSize = maxFileSize || MB;
// Buffers JSON data, if the Buffer gets too large, then don't bother writing the JSON file
this._write = function(chunk, encoding, done) {
// If our buffer is too large, don't worry about caching more data
if(!this.bufferTooBig) {
var json = JSON.parse(chunk);
this.jsonArray.push(json);
this.buf = new Buffer(JSON.stringify(this.jsonArray));
// If the filesize is going to be over our Max filesize, then forget about it
if(this.buf.length > this.maxFileSize) {
fs.unlink(filename, function(err) { });
this.jsonArray = [];
this.buf = '';
this.bufferTooBig = true;
}
}
// Pass the data on to the next stream
this.push(chunk);
done();
};
this._flush = function(done) {
// If the filesize is within reason, then write out the file
if(!this.bufferTooBig) {
fs.writeFile(filename, this.buf.toString(), function(err) {
if(err) {
throw err;
}
done();
});
} else {
done();
}
};
}
util.inherits(SecondStream, stream.Transform);
function ThirdStream(filename) {
stream.Transform.call(this, { objectMode: true });
this.fileStream = fs.createWriteStream(filename);
this._write = function(chunk, encoding, done) {
this.fileStream.write(csvMessage);
this.push(csvMessage);
done();
};
this._flush = function(done) {
this.fileStream.end();
done();
};
}
util.inherits(ThirdStream, stream.Transform);
// USE CASE
var backendStream = new FirstStream(request)
.pipe(new SecondStream(jsonFileName))
.pipe(new ThirdStream(csvFileName))
.on('finish', function() { /* write response back to client */ });