বড় JSON পড়া Node.js-এ: stream-json স্ট্রিমিং পার্সিং ও ব্যাকপ্রেশার বাস্তবে
সংক্ষেপে: readFileSync ও JSON.parse দিয়ে 186MB JSON অ্যারে পড়লে মেমরির পিক হয় 612MB; stream-json-এর streamArray-এ বদলালে তা 104MB-এ সমতল থাকে। এই নিবন্ধে চারটি পড়ার কৌশলের পরিমাপভিত্তিক তুলনা দেওয়া হলো, ব্যাখ্যা করা হলো for await কেন স্বাভাবিকভাবেই ব্যাকপ্রেশার দেয়, data ইভেন্ট কীভাবে তা হারায়, এবং লেখার পাশে highWaterMark ও drain কীভাবে সাজাবেন।

186MB JSON ফাইল ইম্পোর্ট করতেই প্রসেসের মেমরি 600MB-এ পৌঁছালে দোষ ফাইলের আকারের নয় — JSON.parse পুরো টেক্সটকে এক নিমেষে পুরো অবজেক্ট গ্রাফের সঙ্গে বদলে ফেলেছে। পড়ার কৌশল বদলালে মেমরির কার্ভ সমতল হয়ে যায়।
একটি লক্ষণ: 186MB ফাইলের 612MB পিক
সার্ভার-সাইড ইম্পোর্ট জব-এ এই সমস্যা সবচেয়ে বেশি দেখা যায়: নির্ধারিত অর্ডার সিঙ্ক, লগ পরিষ্কার, বাল্ক হিস্ট্রি লোড। সাধারণ বাস্তবায়ন দেখতে এমন:
const fs = require('fs');
const raw = fs.readFileSync('./orders.json', 'utf8');
const orders = JSON.parse(raw);
for (const order of orders) await saveToDb(order);
আমরা Node 22.13-এ এই প্যাটার্ন পরিমাপ করেছি। নমুনা: 480,000 অর্ডার রেকর্ডের অবজেক্ট অ্যারে, ফাইল 186MB, ফিল্ডে স্ট্রিং, নেস্টেড অবজেক্ট ও অ্যারে সহ বাস্তব ব্যবসায়িক গঠনের অনুকরণে। /usr/bin/time -v দিয়ে মাপা পিক Maximum resident set size: ফাইল 1.3 সেকেন্ডে পড়া হয়, কিন্তু RSS-এর পিক 612MB — ফাইলের 3.3 গুণ। V8-এর ডিফল্ট ওল্ড-স্পেস লিমিট 1.4–2GB হওয়ায় এমন কয়েকটি জব সমান্তরালে চালালেই কন্টেইনার OOM Kill-এর শিকার হয়।
গণিত অতিশয় জটিল নয়: কাঁচা টেক্সট মেমরিতে এক কপি জায়গা নেয় (প্রায় 186MB), parse-এর ফলে গঠিত অবজেক্ট গ্রাফ আরেক কপি নেয় (প্রতিটি স্ট্রিং কী, নেস্টেড অবজেক্ট হেডার ও অ্যারের অতিরিক্ত খরচ আছে), এবং পার্সিং প্রক্রিয়া নিজেই সাময়িক এলোকেশন করে। পিক 600MB-এ পৌঁছানো স্বাভাবিক।
দ্বিতীয় কারণ: JSON.parse পুরো টেক্সট বদলে পুরো গ্রাফ দেয়
JSON.parse-এর চুক্তি হলো «আমাকে সম্পূর্ণ টেক্সট দাও, তুমি সম্পূর্ণ অবজেক্ট গ্রাফ পাবে»। এটি শুরুর আগেই পুরো টেক্সট তৈরি থাকার দাবি করে এবং শেষ হলে ফল একবারে বুঝিয়ে দেয়। «প্রথমে ১,০০০ রেকর্ড নাও» জাতীয় কোনো সুযোগ নেই।
অবজেক্ট গ্রাফের খরচ JSON-এর মেমরি হিসাব নিবন্ধে আইটেম ধরে মাপা হয়েছে: প্রতিটি স্ট্রিং বাস্তব জায়গা নেয়, অবজেক্টের প্রতিটি কী একটি স্লট নেয়, আর অ্যারের প্রস্থ উপাদানের ধরনের ওপর নির্ভর করে। কয়েক ডজন MB JSON পার্স করার পর নিয়মিতভাবে তিন-পাঁচ গুণ বড় হয়, পিক তার ওপরে যোগ হয়।
অথচ বেশিরভাগ ইম্পোর্ট জবের পুরো গ্রাফ কখনোই দরকার হয় না: সারি ধরে ইনসার্ট, সারি ধরে ফিল্টার, সারি ধরে ট্রান্সফর্ম — প্রতিটি রেকর্ড হাতলে হাতলে গারবেজ কলেক্ট হতে পারে। জবের প্রয়োজন «একটি রেকর্ড পার্স করলে একটি রেকর্ড দাও»। এটাই স্ট্রিমিং পার্সিংয়ের সংজ্ঞা।
সমাধান: streamArray একটি একটি রেকর্ড সরবরাহ করে, আর for await ব্যাকপ্রেশার ফ্রি দেয়
stream-json পার্সারকে Transform স্ট্রিম হিসেবে বাস্তবায়ন করে, টোকেন ধরে পার্স করে, কখনো পুরো ফাইলের জন্য অপেক্ষা করে না। উপরের স্তর অ্যারে হলে streamArray() প্রতিটি উপাদানের পার্সিং শেষ হওয়ামাত্র {key, value} ইমিট করে:
const fs = require('fs');
const { chain } = require('stream-chain');
const { parser } = require('stream-json');
const { streamArray } = require('stream-json/streamers/StreamArray');
async function importOrders(filePath) {
const pipeline = chain([
fs.createReadStream(filePath, { highWaterMark: 64 * 1024 }),
parser(),
streamArray(),
]);
for await (const { key, value } of pipeline) {
await saveToDb(value);
}
}
একই 186MB ফাইলে, একই 480,000 রেকর্ডে এই সংস্করণের পিক RSS 104MB, পুরো রান জুড়ে সমতল। মেমরিতে যেকোনো মুহূর্তে থাকে শুধু «বর্তমান উপাদান + পার্সার স্টেট»; শেষ হওয়া রেকর্ড সঙ্গে সঙ্গে মুক্ত হয়।
একটি সহজে ভুলোয যায় এমন বিষয়: for await পরের রেকর্ড পার্সার থেকে টানে না যতক্ষণ না saveToDb শেষ হয়, ফলে পার্সার ফাইল পড়া থামিয়ে দেয়। ডেটাবেস ধীর হলে পড়াও ধীর — এটাই ব্যাকপ্রেশার, স্বাভাবিকভাবে গঠিত, এক লাইন অতিরিক্ত কোড ছাড়া। dev.to-তে 4GB পৌরসভা ট্রানজিট ফিড ইনজেস্টের রিপোর্টেও একই চেইন ব্যবহৃত হয়েছে, pick({filter:'data'}) সহ, মেমরি কার্ভ তেমনি সমতল।
যখন লেখার পাশ ব্যর্থ হয়: না-থামানো data ইভেন্ট মেমরি আবার বাড়ায়
স্ট্রিমিং পার্সিং শুধু পড়ার পাশ শাসন করে। লেখার পাশ ব্যাকপ্রেশার না নিলে মেমরি আবার বাড়ে। ধ্রুপদী ব্যর্থতা: data হ্যান্ডলারে অ্যাসিঙ্ক লেখা, কিন্তু writable-এর বাফারে নজর নেই:
// ভুল: data ইভেন্ট + অ্যাসিঙ্ক লেখা, ব্যাকপ্রেশার সম্পূর্ণ হারায়
readable.on('data', async (chunk) => {
await slowWrite(chunk); // স্ট্রিম অপেক্ষা করে না; বাফার বাড়তে থাকে
});
data মোডে স্ট্রিম চলতেই থাকে, slowWrite যত ধীরই হোক, সবকিছু writable-এর অভ্যন্তরীণ বাফারে জমে। একই 186MB নমুনায় আমরা রেকর্ডগুলো একটি ধীর Writable-এ পাঠিয়েছি যা প্রতি শততম চাঙ্কে 1ms দেরি করে। ব্যাকপ্রেশার উপেক্ষা করলে RSS-এর পিক 407MB; write() false দিলে await once(sink, 'drain') দিয়ে থামালে 161MB। 246MB-এর পার্থক্যটা আক্ষরিক অর্থেই লেখার বাফারে বসে থাকা ডেটা।
// সঠিক: write() false দিলে থামো, drain-এ চালু করো
for await (const { value } of pipeline) {
if (!sink.write(value)) {
await once(sink, 'drain');
}
}
আরও দুটি কাজের পরামর্শ: নিজে স্ট্রিম চেইন জোড়া দিলে প্রতিটি স্ট্রিমে highWaterMark স্পষ্টভাবে সেট করুন — objectMode-এর ডিফল্ট 16 বড় অবজেক্টের জন্য অতিরিক্ত; এবং pipe()-এর বদলে stream/promises-এর pipeline() বেছে নিন, যা ত্রুটি প্রসারণ ও পরিষ্কার করার ভার নেয়।
পরিমাপ: চার কৌশলের মেমরির পিক
| কৌশল | নমুনা | পিক RSS | সময় | ব্যবহার |
|---|---|---|---|---|
| readFileSync + JSON.parse | 186MB / 480k | 612MB | 1.3s | ছোট ফাইল, এলোমেলো অ্যাক্সেস |
| streamArray + for await + ধীর DB লেখা (প্রতি 0.5ms) | একই | 104MB (সমতল) | DB-র গতি অনুযায়ী | রেকর্ড ধরে ইনজেস্ট, ট্রান্সফর্ম |
| streamArray + data ইভেন্ট লেখা, ব্যাকপ্রেশার ছাড়া | একই | 407MB | ~10s | যা করা উচিত নয় |
| streamArray + write()/drain | একই | 161MB | ~10s | ডিস্কে লেখা বা পাঠানো |
পরিবেশ: Node 22.13, /usr/bin/time -v দিয়ে Maximum resident set size, ব্যবসায়িক গঠনের সিন্থেটিক নমুনা, গড়হীন একক রান, setTimeout দিয়ে ধীর লেখার অনুকরণ। এই সংখ্যাগুলো এই নমুনার মাত্রার উপসংহার, সার্বজনীন ধ্রুবক নয় — নিজের ডেটায় মাপুন।
দুটি পাঠ মনোযোগ দাবি করে। প্রথম ও দ্বিতীয় কৌশলের মেমরির পার্থক্য ছয় গুণ, বিনিময়ে «1.3 সেকেন্ড» বদলে «DB-র গতি»। তৃতীয় ও চতুর্থের পার্থক্য 2.5 গুণ: পড়া স্ট্রিমিং হলেও লেখায় ব্যাকপ্রেশার না থাকলে অর্ধেক সমস্যাই সমাধান হয়।
ডায়াগনোসিস: ব্যাকপ্রেশার সত্যিই কাজ করছে কি নিশ্চিত করা
প্রোডাকশনের মেমরি সমস্যা অনুমানে সমাধান হয় না। Tencent Cloud-এর ব্যাকপ্রেশার ট্রাবলশুটিং লেখাটি বাস্তবসম্মত পদ্ধতি দেয়:
- গুরুত্বপূর্ণ স্ট্রিমে সাময়িকভাবে
'pause'ও'resume'লগ লাগান। বড় ভলিউমের পাইপলাইনে যদি কখনো pause না আসে, কোথাও ডেটা মেমরিতে জমছে; writable.writableLengthদেখুন — ধারাবাহিক বৃদ্ধি মানে বাফার কখনো খালি হয় না;process.memoryUsage()দিয়ে ব্যবধানে RSS স্যাম্পল করে কার্ভ আঁকুন, «র্যাম্প বৃদ্ধি» (জমা) আর «দাঁতাল স্থিতি» (সুস্থ মুক্তি) আলাদা করুন।
for await-এ pause ও resume ইভেন্ট পর্যায়ক্রমে আসতেই হবে; আসে না হলে বাড়তি data লিসেনার বা ভুলে যাওয়া await খুঁজুন।
কখন স্ট্রিমিং উত্তর নয়
স্ট্রিমিং ডিফল্ট সমাধান নয়। কয়েক ডজন MB ফাইলে কী দিয়ে এলোমেলো অ্যাক্সেস দরকার হলে একটি JSON.parse কলই সহজ ও সস্তা। ব্রাউজারে বড় ফাইল খোলা অন্য সমস্যা-ক্ষেত্র — বড় JSON ফাইল কীভাবে খুলবেন দেখুন। স্ট্রিমিং পার্সিংয়ের সীমা স্পষ্ট:
- উপরের স্তর অ্যারে (বা ডেটা JSONL হিসেবে ভাগ করা যায়), ব্যবহার ক্রমিক, পেছন তাকানোর দরকার নেই;
- ফাইলের আকার অনিয়ন্ত্রিত বা হিপ-মার্জিন ছাড়িয়ে গেছে, আর এক ইম্পোর্টে প্রসেসের মেমরি দ্বিগুণ করা যাবে না;
- গ্রাহকের সঙ্গে স্বাভাবিক গতির ব্যবধান আছে (DB লেখা, ডাউনস্ট্রিম API কল), তাই দরকার ব্যাকপ্রেশার, পুরোগতির পাইপ নয়।
উপরের গঠন অনিয়মিত হলে আগে JSON পার্সার ও ফরম্যাটার টুলে কাঠামো দেখুন; কমান্ড-লাইন সমতুল্য jq দিয়ে বড় JSON নিবন্ধে — jq --stream ও streamArray একই ভাবনার দুই রানটাইমে বাস্তবায়ন।
FAQ
stream-json JSON.parse-এর চেয়ে কত ধীর?
শুধু পার্সিংয়ে JSON.parse জেতে: 186MB নমুনায় 1.3 সেকেন্ড, বিপরীতে লেখার বিলম্ব ছাড়া streamArray প্রায় 7 সেকেন্ড (টোকেন পার্সিং প্লাস রেকর্ড ধরে অবজেক্ট গঠন)। স্ট্রিমিংয়ের লাভ সম্পূর্ণ মেমরির পাশে: পিক 612MB থেকে 104MB-এ নামে। ইম্পোর্ট যেহেতু তবু DB লেখায় সীমাবদ্ধ, কয়েক সেকেন্ড বাড়তি পার্সিংয়ের বিনিময়ে ছয় গুণ মেমরির মার্জিন সাধারণত লাভজনক; মিলিসেকেন্ড API রেসপন্সের ভেতরে নয়।
for await-এর ব্যাকপ্রেশার কি ম্যানুয়াল pause/resume-এর মতোই?
অর্থগতভাবে হ্যাঁ: for await লুপ বডি ঝুলে থাকলে পড়ার স্ট্রিম স্বয়ংক্রিয়ভাবে থামায়, যা write() false দিলে pause() ডাকা আর drain-এ resume() ডাকার সমতুল্য। পার্থক্য হলো ভাষার কাঠামো হিসাব নিজেই বহন করে এবং কিছু ভুলে যায় না; ম্যানুয়াল সংযোগ এক জায়গা মিস করলেই পুরো চেইনের ব্যাকপ্রেশার নষ্ট হয়।
উপরের স্তর যদি অ্যারে না হয়ে একটি বিশাল অবজেক্ট হয়?
stream-json দেয় streamObject() (কী ধরে ইমিট) ও Pick ফিল্টার (নির্বাচিত সাবট্রি-ই পার্স করে)। কয়েকটি ফিল্ড দরকার হলে Pick ও JSONPath দিয়ে পুরো গ্রাফ সরিয়ে প্রয়োজনীয় সাবগ্রাফে নামানো যায়। মাল্টি-ডকুমেন্ট ইনপুট (JSON Lines, JSON সিকোয়েন্স) লাইন ধরে ভেঙে স্বাধীন ডকুমেন্ট হিসেবে চালানো ভালো।
ফল কীভাবে JSONL হিসেবে লিখবো বা ডাউনস্ট্রিমে পাঠাবো?
লেখার পাশও একই ব্যাকপ্রেশার প্রশ্ন: fs.createWriteStream ও http.request দুটোতেই write()-এর রিটার্ন ভ্যালু দেখতে হবে আর false হলে once(stream, 'drain') অপেক্ষা করতে হবে — নয়তো writable-কে pipeline()-এ জুড়ে দিন। যাচাই সহজ: রানের পরে RSS কার্ভ স্থিতিশীল হতে হবে আর writableLength ধারাবাহিকভাবে বাড়া চলবে না।
ইম্পোর্ট জবের জন্য দ্রুততম মেমরি মনিটর কী?
সর্বনিম্ন সংস্করণ: একটি টাইমার প্রতি 100ms-এ process.memoryUsage().rss অ্যারেতে স্যাম্পল করে শেষে সর্বোচ্চ মান ছাপে। বেশি সঠিক: /usr/bin/time -v node task.js সরাসরি Maximum resident set size দেয়। কন্টেইনারে অ্যালার্ট লাইন রাখুন মেমরি লিমিটের 70%-এ, GC-র জন্য জায়গা রেখে।