jq dan fail JSON besar: mengapa -s meletupkan memori dan cara memproses secara streaming
Inti pati: Pengagregatan ratusan MB log JSON dengan jq -s berakhir dengan OOM, manakala reduce inputs menghasilkan statistik yang sama hanya dengan beberapa MB RAM. Diukur pada sampel 220 MB dan 2 juta baris: slurp memuncak pada 2,08 GB berbanding 3,5 MB untuk pengagregat streaming. Artikel ini menerangkan mekanisme penggunaan memori, pemprosesan JSONL baris demi baris, peristiwa laluan --stream dan tiga perangkap sebenar, termasuk output kosong senyap -n --stream.

jq menghurai dengan pantas, tetapi hampir setiap kematian di hadapan fail beberapa ratus MB bermuara ke flag yang sama:
-smemuatkan seluruh input ke dalam satu tatasusunan gergasi, dan RSS puncak dengan mudah mencapai beberapa kali saiz fail.
Satu fail, dua pertanyaan: memori 580 kali lebih kurang
Mari mulakan dengan pengukuran. Sampel ialah log JSONL 220 MB dengan 2,000,000 baris (satu rekod permintaan setiap baris: timestamp, level, path, status, duration_ms, uid). Persekitaran: jq 1.7 di Linux x86_64, RSS puncak direkodkan melalui /usr/bin/time -v:
| Pertanyaan | Tugasan | Tempoh | RSS puncak |
|---|---|---|---|
jq -s 'group_by(.level) | ...' |
pengiraan mengikut level | 10,1s | 2,08 GB (~9,5x saiz fail) |
jq -n 'reduce inputs ...' |
pengiraan yang sama | 4,7s | 3,5 MB |
jq -r 'select(...) | .path' |
penapis baris demi baris | 2,6s | 3,6 MB |
Statistik yang sama, memori 580 kali lebih kurang, malah lebih pantas. Ini bukan pepijat jq — -s menurut takrif bermaksud «baca semuanya ke dalam tatasusunan»; kebanyakan orang sekadar tidak menaksir kos lalai ini. Sumber pihak ketiga bersetuju: laporan pengalaman 2,3 GB JSONL daripada komuniti Huawei Cloud menceritakan kisah yang sama persis — OOM dengan slurp, kemudian pengagregat streaming siap dalam 47 saat dengan RSS sedikit melebihi 30 MB. Dratini.tech mengukur pada input 2,5 GB sebuah jq -s yang dibunuh oleh OOM killer malah pada mesin 16 GB+, sementara pipeline biasa siap dalam 48,2s pada 84 MB.
Kesimpulan dahulu: jika fail melebihi separuh memori yang tersedia, -s bukan calon langsung. Ukur tiga perkara sebelum menulis apa-apa: ls -lh untuk saiz, free -m untuk baki memori, wc -l untuk bilangan baris.
Ke mana memori sebenarnya pergi
jq -s (slurp) didokumenkan sebagai «baca semua input ke dalam tatasusunan». Kos sebenar jauh melampaui teks: selepas penghuraian, jq memegang pokok struktur C, dan setiap objek, tatasusunan, rentetan serta nombor membawa nodnya sendiri lengkap dengan metadata. 220 MB teks kami menjadi sedikit melebihi 2 GB struktur — kembung sekitar 9,5x. group_by tambah pula mengisih dan mengelompokkan dalam memori, membesarkan puncak.
Satu dokumen JSON besar berkelakuan sama. Membungkus log yang sama ke dalam tatasusunan akar 300 MB dan mengekstrak dengan penapis biasa:
| Pertanyaan | Tempoh | RSS puncak |
|---|---|---|
jq '.[] | select(.level=="ERROR") | .uid' (seluruh dokumen) |
4,7s | 1,85 GB |
jq --stream 'select(...)' (peristiwa laluan) |
13,4s | 3,4 MB |
Penghuraian penuh masih memuncak sekitar 1,8 GB — jq membina seluruh pokok sebelum penapis dilaksanakan. --stream menukar kira-kira 3x masa pelaksanaan dengan memori 540 kali lebih kecil. Model terperinci kembung ini dibangunkan dalam Dari mana memori datang.
Log JSONL: bacaan baris demi baris sudah pun streaming
Jika «fail besar» anda sebenarnya JSONL — satu objek setiap baris —, tingkah laku lalai jq sudah pun aliran: setiap baris dihurai dan dipancarkan secara berasingan, dan -s bukan sahaja tidak perlu, malah merugikan:
# pengiraan mengikut level: baris demi baris, agregasi dalam shell
jq -r '.level' app.jsonl | sort | uniq -c | sort -rn | head
# penapis + ekstraksi: select dahulu, baris yang tidak sepadan dibuang seketika
jq -r 'select(.level=="ERROR") | .path' app.jsonl | sort | uniq -c | sort -rn | head -5
Dua tabiat yang patut dipaksa:
selectpaling hujung hadapan pipeline. jq menapis begitu sahaja satu baris dihurai; menapis selepas transformasi membazirkan pengiraan.-runtuk rentetan mentah. Tanpanya, output ialah rentetan JSON bertanda petik, danuniq -cakan mengira"ERROR"danERRORsebagai dua nilai berbeza.
Untuk baris rosak gunakan fromjson?: jq -r 'fromjson? | .level' melangkau baris yang tidak boleh dihurai secara senyap, dan serpihan yang terpotong tidak membunuh seluruh pipeline. Format itu sendiri dibincangkan dalam Buku panduan praktikal JSONL; artikel ini mengenai arahan yang memprosesnya.
Pengagregatan global: reduce inputs mengekalkan keadaan terhad
Penapisan baris demi baris adalah tugas shell, tetapi apabila pengagregatan mesti berlaku dalam jq itu sendiri — pengira mengikut level, tempoh purata mengikut path —, kuncinya ialah reduce dengan inputs, untuk keadaan yang terhad:
# pengiraan mengikut level: memori mengikut saiz hasil, bukan fail
jq -n 'reduce inputs as $x ({}; .[$x.level] = ((.[$x.level] // 0) + 1))' app.jsonl
# tempoh purata mengikut path: keadaannya pasangan tetap {count, total}
jq -n 'reduce inputs as $x ({}; .[$x.path].count += 1 | .[$x.path].total += $x.duration_ms)
| map_values(.total / .count)' app.jsonl
Dua butiran:
-nbermakna jq tidak boleh mengambil input pertama sebagai nilai awal;inputssendiri memancarkan setiap rekod. Lupa-ndan rekod pertama ditelan sebagai keadaan awal.- Keadaan pengagregat mesti berbentuk tetap — hanya pengira dan pengumpul. Sebaik sahaja anda menolak baris sepadan ke dalam tatasusunan dalam pengagregat, memori kembali membesar mengikut volum data dan streaming tidak berharga lagi.
Itulah asal 3,5 MB dalam jadual: dua gigabyte telah mengalir, tinggal hanya jadual hash.
Satu dokumen gergasi: peristiwa laluan --stream
Apabila input ialah satu dokumen akar gergasi (eksport beberapa ratus MB tanpa sempadan baris), gunakan --stream. Sebagai ganti nilai penuh, ia memancarkan urutan peristiwa «laluan + nilai daun»:
# satu peristiwa kelihatan seperti: tatasusunan laluan + skalar
$ echo '{"rows":[{"id":"a"},{"id":"b"}],"meta":{"id":"top"}}' | jq -c --stream .
["rows",0,"id"]
"a"
["rows",1,"id"]
"b"
["meta","id"]
"top"
Mengekstrak daripada strim peristiwa menuntut pemadanan bentuk penuh laluan — kedalaman, nama ahli, kedudukan indeks —, kerana memeriksa komponen terakhir sahaja akan menangkap juga kunci serupa nama dalam objek bersarang:
# hanya rows[i].id, mengabaikan meta.id dan sepupu senama yang lebih dalam
jq --stream 'select(length == 2 and .[0][0] == "rows" and .[0][-1] == "id") | .[1]' huge.json
Pengagregatan kekal sebagai reduce inputs berbentuk tetap (dengan -n --stream, peristiwa mesti digunakan melalui inputs — lihat perangkap). Untuk pembinaan semula — mengubah strim peristiwa kembali kepada objek penuh — gabungkan truncate_stream dan fromstream. Gambaran pemilihan alat mengikut saiz ada dalam Fail JSON terlalu besar?.
Tiga perangkap sebenar
Perangkap satu: -n --stream tanpa inputs tidak mengeluarkan apa-apa, dalam senyap. Dibuktikan pada mesin ini: jq -n --stream 'select(...)' file.json berakhir dengan kod 0, tanpa output mahupun ralat — dalam mod -n, jq tidak membaca input, dan select penapis tidak menerima sebarang peristiwa. Betul: buang -n dan gunakan --stream kosong, atau padankan -n --stream dengan reduce inputs. Kelas kegagalan «berjaya tetapi kosong» ini paling sukar didebug; sahkan pada sampel kecil sebelum mendawai sesebuah pipeline.
Perangkap dua: --stream hanya memancarkan daun skalar; objek dan tatasusunan kosong tiada peristiwa nilai. {"a":{}} hanya menghasilkan peristiwa penutupan laluan (jenis length == 1), dan penapis pada length == 2 akan menelan bekas kosong dalam senyap — putuskan secara jelas sama ada mereka dikira dalam statistik anda.
Perangkap tiga: hasil separa selepas ralat penghuraian di tengah fail. Pipeline streaming mungkin telah memancarkan separuh output sebelum tersadai JSON rosak hampir penghujung. jq 1.7 secara lalai gagal dengan bising — [1,] menghasilkan parse error: Expected another array element at line 1, column 4 dengan kod 5 dalam ujian kami — tetapi jika shell anda mengalihkan stdout ke fail sasaran, hasil terpotong sudah berada di cakera. Perisai kejuruteraan: staging tambah rename — tulis ke fail sementara dan mv menimpa sasaran hanya selepas jq berjaya. Untuk kawalan lebih halus, --stream-errors mengubah ralat penghuraian menjadi peristiwa yang boleh anda kendalikan dan hentikan secara jelas melalui error.
Bilakah tidak menggunakan jq: Miller dan pipeline hibrid
jq ialah bahasa berfungsi bagi transformasi pokok, kuat dalam penstrukturan semula yang mendalam. Namun begitu tugas merosot menjadi «tapis dan kira gigabyte log rata», wujud alat yang lebih bersesuaian. Benchmark dratini.tech pada 2,5 GB JSONL (penapis + pemilihan lajur):
| Alat | Tempoh | RSS puncak |
|---|---|---|
| pipeline jq biasa | 48,2s | 84 MB |
| jq -s | OOM (dibunuh walaupun dengan 16 GB+) | — |
| Miller (mlr --json) | 11,4s | 18 MB |
| ripgrep + jq hibrid | 8,1s | 32 MB |
Peraturannya: sarang mendalam, penstrukturan semula, kehadiran di mana-mana dalam CI — jq. Statistik rata berbilang gigabyte, persentil p95, JSONL ke TSV — satu mlr --json stats1 menggantikan skrip jq dengan memori malar. Dan jika ripgrep mampu menyisihkan 90 % baris sia-sia sebelum jq, laluan hibrid paling pantas.
FAQ
Mulakan saiz berapa jq -s menjadi berbahaya?
Ambang praktikal: sebaik sahaja fail melebihi separuh memori yang tersedia, bersiap curiga. Memori selepas penghuraian biasanya 3 hingga 10 kali teks (9,5x pada 220 MB kami; laporan pihak ketiga menunjukkan fail 4 GB membunuh mesin 16 GB). Bandingkan dahulu ls -lh dengan free -m, dan hampir sempadan gantikan -s dengan reduce inputs.
Mengapa -n di hadapan reduce inputs?
-n menyuruh jq supaya tidak mengambil input pertama sebagai nilai awal program, agar inputs sendiri memancarkan setiap rekod. Tanpa -n, rekod pertama menjadi keadaan awal reduce dan lenyap secara senyap daripada hasil — kehilangan data tanpa sebarang ralat.
Bagaimana memilih antara --stream dan mod biasa?
Lihat bentuk fail dahulu. JSONL sudah pun strim baris demi baris; --stream tidak berguna. Bagi satu dokumen besar yang anda hanya mahu beberapa nilai daun, --stream menukar kira-kira 3x masa dengan memori ratusan kali lebih kecil. Jika fail muat dalam memori, jq biasa memang lebih pantas.
Apa perlu dilakukan terhadap baris rosak semasa streaming?
Dalam JSONL, fromjson? melangkau baris yang tidak boleh dihurai supaya satu baris kotor tidak membunuh pipeline. Bagi satu dokumen besar, ralat penghuraian di tengah fail menjatuhkan keseluruhan larian — terbitkan secara atomik melalui fail staging dan rename, atau gunakan --stream-errors untuk kawalan jelas.