jq এবং বড় JSON ফাইল: কেন -s মেমরি বিস্ফোরিত করে এবং কীভাবে স্ট্রিমিংয়ে প্রক্রিয়া করবেন
সংক্ষেপে: শত শত মেগাবাইট JSON লগ jq -s দিয়ে একত্রিত করতে গেলে OOM হয়, অথচ reduce inputs মাত্র কয়েক মেগাবাইট RAM-এ একই পরিসংখ্যান দেয়। ২২০ মেগাবাইট ও ২০ লক্ষ লাইনের নমুনায় পরিমাপ: slurp এ ২,০৮ গিগাবাইট পিক, বিপরীতে স্ট্রিমিং রিডিউসারে মাত্র ৩,৫ মেগাবাইট। এই নিবন্ধে মেমরি খরচের প্রক্রিয়া, JSONL লাইন-বাই-লাইন প্রক্রিয়াকরণ, --stream এর পাথ ইভেন্ট এবং তিনটি বাস্তব ফাঁদ — এর মধ্যে -n --stream এর নীরব খালি আউটপুট — ব্যাখ্যা করা হয়েছে।

jq দ্রুত পার্স করে, কিন্তু কয়েকশো মেগাবাইটের ফাইলে প্রায় প্রতিটি মৃত্যু একই ফ্ল্যাগে ফিরে যায়:
-sপুরো ইনপুট একটি বিশাল অ্যারেতে লোড করে, আর পিক RSS সহজেই ফাইলের আকারের কয়েকগুণ ছুঁয়ে ফেলে।
এক ফাইল, দুটি কোয়েরি: ৫৮০ গুণ কম মেমরি
পরিমাপ দিয়ে শুরু করি। নমুনাটি ২২০ মেগাবাইট ও ২০,০০,০০০ লাইনের JSONL লগ (প্রতি লাইনে একটি request রেকর্ড: timestamp, level, path, status, duration_ms, uid)। পরিবেশ: Linux x86_64-এ jq 1.7, পিক RSS /usr/bin/time -v দিয়ে রেকর্ড করা:
| কোয়েরি | কাজ | সময় | পিক RSS |
|---|---|---|---|
jq -s 'group_by(.level) | ...' |
level অনুযায়ী গণনা | 10,1s | 2,08 GB (~ফাইলের 9,5 গুণ) |
jq -n 'reduce inputs ...' |
একই গণনা | 4,7s | 3,5 MB |
jq -r 'select(...) | .path' |
লাইন-বাই-লাইন ফিল্টার | 2,6s | 3,6 MB |
একই পরিসংখ্যান, ৫৮০ গুণ কম মেমরি, তাও আবার দ্রুততর। এটা jq-এর বাগ নয় — -s সংজ্ঞা অনুসারেই «সব অ্যারেতে পড়ো» মানে; বেশিরভাগ মানুষ এই ডিফল্ট খরচটাই হিসাব করে না। তৃতীয় পক্ষের সূত্রও একমত: Huawei Cloud কমিউনিটির 2,3 গিগাবাইট JSONL নিয়ে অভিজ্ঞতা ঠিক একই গল্প বলে — slurp-এ OOM, তারপর স্ট্রিমিং রিডিউসার ৪৭ সেকেন্ডে শেষ করে RSS মাত্র ৩০ মেগাবাইট একটু বেশি। Dratini.tech 2,5 গিগাবাইট ইনপুটে দেখেছে jq -s 16 GB+ মেশিনেও OOM killer-এর হাতে মারা যায়, অথচ সাধারণ পাইপলাইন 48,2s-এ 84 MB দিয়ে শেষ হয়।
আগেই সিদ্ধান্ত: ফাইল উপলব্ধ মেমরির অর্ধেক ছাড়িয়ে গেলে -s আদৌ প্রার্থীই নয়। কিছু লেখার আগে তিনটি জিনিস মাপুন: আকারের জন্য ls -lh, মেমরির জায়গার জন্য free -m, লাইন সংখ্যার জন্য wc -l।
মেমরি আসলে কোথায় যায়
jq -s (slurp) ডকুমেন্টেড অর্থ «সব ইনপুট অ্যারেতে পড়া»। বাস্তব খরচ টেক্সটকে অনেক পেছনে ফেলে দেয়: পার্সিংয়ের পর jq একটি C-স্ট্রাকচার ট্রি ধরে রাখে, আর প্রতিটি object, array, string ও number তার নিজস্ব নোড মেটাডেটাসহ বহন করে। আমাদের ২২০ মেগাবাইট টেক্সট হয়ে যায় সামান্যের বেশি ২ গিগাবাইট স্ট্রাকচার — প্রায় 9,5 গুণ ফোলা। group_by আবার মেমরিতেই সর্ট ও গ্রুপ করে, পিককে আরও বাড়িয়ে দেয়।
একটি বড় JSON ডকুমেন্টও একই আচরণ করে। একই লগ ৩০০ মেগাবাইটের রুট অ্যারেতে মুড়ে সাধারণ ফিল্টার দিয়ে বের করলে:
| কোয়েরি | সময় | পিক RSS |
|---|---|---|
jq '.[] | select(.level=="ERROR") | .uid' (সম্পূর্ণ ডকুমেন্ট) |
4,7s | 1,85 GB |
jq --stream 'select(...)' (পাথ ইভেন্ট) |
13,4s | 3,4 MB |
সম্পূর্ণ পার্সিং এখনও 1,8 গিগাবাইটের কাছে পিক করে — ফিল্টার চলার আগেই jq পুরো ট্রি বানিয়ে ফেলে। --stream প্রায় ৩ গুণ রানটাইম বদলে ৫৪০ গুণ ছোট মেমরি নেয়। এই ফোলার বিস্তারিত মডেল মেমরি কোথা থেকে আসে-এ বর্ণিত।
JSONL লগ: লাইন-বাই-লাইন পড়া ইতিমধ্যেই স্ট্রিম
আপনার «বড় ফাইল» যদি প্রকৃতপক্ষে JSONL হয় — প্রতি লাইনে একটি object — তাহলে jq-এর ডিফল্ট আচরণই স্ট্রিম: প্রতিটি লাইন স্বাধীনভাবে পার্স ও এমিট হয়, আর -s শুধু অপ্রয়োজনীয় নয়, ক্ষতিকর:
# level অনুযায়ী গণনা: লাইন-বাই-লাইন, শেলে একত্রীকরণ
jq -r '.level' app.jsonl | sort | uniq -c | sort -rn | head
# ফিল্টার + এক্সট্র্যাকশন: select আগে, ম্যাচ না হওয়া লাইন সঙ্গে সঙ্গে ফেলে দেওয়া
jq -r 'select(.level=="ERROR") | .path' app.jsonl | sort | uniq -c | sort -rn | head -5
দুটি অভ্যাস তৈরি করুন:
- পাইপলাইনের একদম শুরুতে
select। একটি লাইন পার্স হওয়া মাত্র jq ফিল্টার করে; ট্রান্সফরমেশনের পরে ফিল্টার করা মানে কম্পিউটেশন নষ্ট। - কাঁচা স্ট্রিংয়ের জন্য
-r। এটা ছাড়া আউটপুট কোট করা JSON স্ট্রিং, আরuniq -cগুনবে"ERROR"ওERROR-কে দুটি আলাদা মান হিসেবে।
ভাঙা লাইনের জন্য fromjson? ব্যবহার করুন: jq -r 'fromjson? | .level' যেসব লাইন পার্স হয় না সেগুলো নীরবে স্কিপ করে, আর কাটা যাওয়া টুকরো পুরো পাইপলাইন মারে না। ফরম্যাটটি নিজে আছে JSONL ব্যবহারিক হ্যান্ডবুক-এ; এই নিবন্ধটি যে কমান্ডগুলো এটি প্রক্রিয়া করে সে নিয়ে।
বৈশ্বিক একত্রীকরণ: reduce inputs অবস্থাকে সীমাবদ্ধ রাখে
লাইন-বাই-লাইন ফিল্টারিং শেলের কাজ, কিন্তু যখন একত্রীকরণ jq-এর ভেতরেই হতে হবে — level অনুযায়ী কাউন্টার, path অনুযায়ী গড় সময় — তখন চাবিকাঠি হলো reduce সঙ্গে inputs, সীমাবদ্ধ অবস্থার জন্য:
# level অনুযায়ী গণনা: মেমরি ফলের আকার অনুসরণ করে, ফাইলের নয়
jq -n 'reduce inputs as $x ({}; .[$x.level] = ((.[$x.level] // 0) + 1))' app.jsonl
# path অনুযায়ী গড় সময়: অবস্থা স্থির জোড়া {count, total}
jq -n 'reduce inputs as $x ({}; .[$x.path].count += 1 | .[$x.path].total += $x.duration_ms)
| map_values(.total / .count)' app.jsonl
দুটি বিস্তারিত:
-nমানে jq প্রথম ইনপুটকে আদি মান হিসেবে গ্রহণ করবে না;inputsনিজেই প্রতিটি রেকর্ড এমিট করে।-nভুলে গেলে প্রথম রেকর্ড আদি অবস্থা হিসেবে গিলে যায়।- রিডিউসারের অবস্থার আকৃতি স্থির হতে হবে — শুধু কাউন্টার ও অ্যাকুমুলেটর। ম্যাচ করা লাইনগুলো রিডিউসারের ভেতরের অ্যারেতে ঠেললেই মেমরি আবার ডেটা ভলিউমের সঙ্গে বাড়তে শুরু করে এবং স্ট্রিমিং আর দামি কিছুই থাকে না।
সেজন্যই টেবিলে 3,5 মেগাবাইট: দুই গিগাবাইট পার হয়ে গেছে, রয়ে গেছে কেবল একটি হ্যাশ টেবিল।
একটিই বিশাল ডকুমেন্ট: --stream এর পাথ ইভেন্ট
ইনপুট যখন একটিই বিশাল রুট ডকুমেন্ট (কয়েকশো মেগাবাইটের এক্সপোর্ট, লাইনের সীমানা নেই), তখন --stream ব্যবহার করুন। সম্পূর্ণ মানের বদলে এটি এমিট করে «পাথ + লিফ ভ্যালু» ইভেন্টের ক্রম:
# একটি ইভেন্ট দেখতে এমন: পাথ অ্যারে + স্কেলার
$ echo '{"rows":[{"id":"a"},{"id":"b"}],"meta":{"id":"top"}}' | jq -c --stream .
["rows",0,"id"]
"a"
["rows",1,"id"]
"b"
["meta","id"]
"top"
ইভেন্ট স্ট্রিম থেকে বের করতে পাথের সম্পূর্ণ আকৃতি মেলাতে হয় — গভীরতা, মেম্বারের নাম, ইনডেক্সের অবস্থান — কারণ শুধু শেষ উপাদান দেখলে নেস্টেড অবজেক্টের সমনাম কীগুলোও ধরা পড়বে:
# শুধু rows[i].id, meta.id ও গভীরের সমনামগুলো উপেক্ষা করে
jq --stream 'select(length == 2 and .[0][0] == "rows" and .[0][-1] == "id") | .[1]' huge.json
একত্রীকরণ থাকবে স্থির আকৃতির reduce inputs-এ (-n --stream-এ ইভেন্ট inputs দিয়ে গ্রহণ করতে হবে — ফাঁদ দেখুন)। পুনর্গঠনের জন্য — ইভেন্ট স্ট্রিমকে আবার পূর্ণ object-এ বদলাতে — truncate_stream ও fromstream একসঙ্গে ব্যবহার করুন। আকার অনুযায়ী টুল নির্বাচনের সারসংক্ষেপ আছে JSON ফাইল অনেক বড়?-এ।
তিনটি বাস্তব ফাঁদ
ফাঁদ এক: inputs ছাড়া -n --stream নীরবে কিছুই আউটপুট দেয় না। এই মেশিনেই প্রমাণিত: jq -n --stream 'select(...)' file.json কোড 0 দিয়ে শেষ, কোনো আউটপুট বা ত্রুটি ছাড়া — -n মোডে jq ইনপুট পড়ে না, আর ফিল্টারের select একটি ইভেন্টও পায় না। সঠিক: -n বাদ দিয়ে খালি --stream ব্যবহার করুন, বা -n --stream-কে reduce inputs-এর সঙ্গে জোড়া লাগান। «সফল কিন্তু খালি» শ্রেণির এই ব্যর্থতা ডিবাগ করা সবচেয়ে কঠিন; পাইপলাইন গেঁথে দেওয়ার আগে ছোট নমুনায় যাচাই করুন।
ফাঁদ দুই: --stream শুধু স্কেলার লিফ এমিট করে; খালি object ও array-র কোনো ভ্যালু ইভেন্ট নেই। {"a":{}} কেবল পাথ-বন্ধ ইভেন্ট দেয় (length == 1 ধরনের), আর length == 2-তে ফিল্টার খালি কনটেইনার নীরবে গিলে ফেলবে — এগুলো আপনার পরিসংখ্যানে গোনা হবে কি না স্পষ্টভাবে ঠিক করুন।
ফাঁদ তিন: ফাইলের মাঝে পার্স এররের পরে আংশিক ফলাফল। স্ট্রিমিং পাইপলাইন শেষের দিকে ভাঙা JSON-এ আটকানোর আগেই অর্ধেক আউটপুট এমিট করে ফেলতে পারে। jq 1.7 ডিফল্টে জোরে ব্যর্থ হয় — আমাদের টেস্টে [1,] দিয়েছে parse error: Expected another array element at line 1, column 4, কোড 5 — কিন্তু আপনার শেল stdout টার্গেট ফাইলে redirect করলে কাটা ফলাফল ডিস্কেই বসে গেছে। ইঞ্জিনিয়ারিং ঢাল: staging যোগ rename — অস্থায়ী ফাইলে লিখুন এবং jq সফল হওয়ার পরেই mv দিয়ে টার্গেটের ওপর বসান। আরও সূক্ষ্ম নিয়ন্ত্রণের জন্য --stream-errors পার্স এররগুলোকে ইভেন্টে বদলে দেয়, যা আপনি প্রক্রিয়া করে error দিয়ে স্পষ্টভাবে থামাতে পারেন।
কখন jq ব্যবহার করবেন না: Miller ও হাইব্রিড পাইপলাইন
jq হলো ট্রি ট্রান্সফরমেশনের ফাংশনাল ভাষা, গভীর পুনর্গঠনে শক্তিশালী। কিন্তু কাজটা যখন «ফ্ল্যাট লগের গিগাবাইট ফিল্টার ও গণনা»-য় অবনমিত হয়, তখন বেশি মানানসই টুল আছে। dratini.tech-এর বেঞ্চমার্ক, 2,5 গিগাবাইট JSONL-এ (ফিল্টার + কলাম নির্বাচন):
| টুল | সময় | পিক RSS |
|---|---|---|
| সাধারণ jq পাইপলাইন | 48,2s | 84 MB |
| jq -s | OOM (16 GB+ দিয়েও মারা যায়) | — |
| Miller (mlr --json) | 11,4s | 18 MB |
| ripgrep + jq হাইব্রিড | 8,1s | 32 MB |
নিয়ম: গভীর নেস্টিং, পুনর্গঠন, CI-তে সর্বত্র ব্যবহার — jq। বহু-গিগাবাইট ফ্ল্যাট পরিসংখ্যান, p95 পার্সেন্টাইল, JSONL থেকে TSV — একটিই mlr --json stats1 স্থির মেমরিতে jq স্ক্রিপ্ট প্রতিস্থাপন করে। আর ripgrep jq-এর আগে 90 % অপ্রয়োজনীয় লাইন বাদ দিতে পারলে হাইব্রিডই দ্রুততম।
FAQ
কত বড় ফাইল থেকে jq -s বিপজ্জনক হয়?
ব্যবহারিক সীমা: ফাইল উপলব্ধ মেমরির অর্ধেক ছাড়ামাত্র সন্দেহ করুন। পার্সিংয়ের পর মেমরি সাধারণত টেক্সটের ৩–১০ গুণ (আমাদের ২২০ মেগাবাইটে 9,5 গুণ; তৃতীয় পক্ষের রিপোর্টে ৪ গিগাবাইট ফাইল ১৬ গিগাবাইটের মেশিন মারে)। আগে ls -lh ও free -m মিলিয়ে দেখুন, সীমার কাছে থাকলে -s বদলে reduce inputs নিন।
reduce inputs-এর আগে -n কেন?
-n বলে jq প্রথম ইনপুটকে প্রোগ্রামের আদি মান হিসেবে নেবে না, যাতে inputs নিজেই প্রতিটি রেকর্ড এমিট করে। -n ছাড়া প্রথম রেকর্ড reduce-এর আদি অবস্থা হয়ে যায় এবং ফল থেকে নীরবে হারিয়ে যায় — কোনো ত্রুটি ছাড়াই ডেটা হারানো।
--stream আর সাধারণ মোডের মধ্যে কীভাবে বাছবেন?
আগে ফাইলের আকৃতি দেখুন। JSONL ইতিমধ্যেই লাইন-বাই-লাইন স্ট্রিম; --stream কিছু দেয় না। একটিই বড় ডকুমেন্ট থেকে মাত্র কয়েকটি লিফ ভ্যালু দরকার হলে --stream প্রায় ৩ গুণ সময় বদলে শতগুণ কম মেমরি নেয়। ফাইল মেমরিতে ধরলে সাধারণ jq-ই বরং দ্রুত।
স্ট্রিমিংয়ে ভাঙা লাইন হলে কী করবেন?
JSONL-এ fromjson? পার্স-অযোগ্য লাইন স্কিপ করে, যাতে একটিমাত্র নোংরা লাইন পাইপলাইন না মারে। একটিই বড় ডকুমেন্টে মাঝপথের পার্স এরর পুরো রান ভাঙে — staging ফাইল ও rename দিয়ে অ্যাটমিকভাবে প্রকাশ করুন, বা স্পষ্ট নিয়ন্ত্রণের জন্য --stream-errors ব্যবহার করুন।