JSONL in Rust: serde_json, BufReader en zero-cost abstractions
Een complete handleiding voor het werken met JSONL-bestanden (JSON Lines) in Rust. Leer JSONL-data lezen, schrijven, parsen en streamen met serde_json, BufReader, rayon voor parallelle verwerking en tokio voor async I/O.
Waarom Rust voor JSONL?
Rust is een uitstekende keuze voor JSONL-verwerking als snelheid, geheugenveiligheid en correcte werking belangrijk zijn. Het ownership-model sluit data races al tijdens het compileren uit. Dankzij zero-cost abstractions kun je op hoog niveau ketens van iterators schrijven die de compiler omzet in efficiënte lussen. Bovendien is serde_json een van de snelste JSON-parsers, ongeacht de programmeertaal. Bouw je een datapipeline die miljoenen JSONL-records per seconde moet verwerken, dan geeft Rust je de controle die je daarvoor nodig hebt, zonder in te leveren op veiligheid.
JSONL (JSON Lines) slaat één JSON-object per regel op. Dat maakt het formaat ideaal voor streaming, append-only logging en het verwerken van grote datasets. Met BufReader in Rust lees je bestanden regel voor regel, zonder het hele bestand in het geheugen te laden. Het iteratormodel sluit bovendien perfect aan op de regelgeoriënteerde opbouw van JSONL. In deze handleiding leer je JSONL lezen en schrijven met BufReader, records met serde parsen naar sterk getypeerde structs, records parallel verwerken met rayon, async I/O afhandelen met tokio en robuuste foutafhandeling opzetten met Result en de ?-operator.
JSONL-bestanden lezen met BufReader
De standaardbibliotheek van Rust biedt BufReader om bestanden efficiënt en gebufferd te lezen. In combinatie met de lines()-iterator lees je JSONL-bestanden regel voor regel, met minimale geheugenoverhead. Elke regel wordt afzonderlijk geparset, waardoor deze aanpak geschikt is voor bestanden van elke grootte.
De eenvoudigste aanpak is om een File aan een BufReader door te geven, met lines() over de regels te itereren en elke regel met serde_json te parsen. Zo staat er steeds maar één regel tegelijk in het geheugen, ongeacht de bestandsgrootte.
use std::fs::File;
use std::io::{BufRead, BufReader};
use serde_json::Value;
fn read_jsonl(path: &str) -> std::io::Result<Vec<Value>> {
let file = File::open(path)?;
let reader = BufReader::new(file);
let mut records = Vec::new();
for (line_num, line) in reader.lines().enumerate() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue; // Sla lege regels over
}
match serde_json::from_str::<Value>(trimmed) {
Ok(value) => records.push(value),
Err(e) => {
eprintln!("Ongeldige JSON overgeslagen op regel {}: {}", line_num + 1, e);
}
}
}
Ok(records)
}
fn main() -> std::io::Result<()> {
let records = read_jsonl("data.jsonl")?;
println!("{} records geladen", records.len());
if let Some(first) = records.first() {
println!("Eerste record: {}", first);
}
Ok(())
}Voeg serde en serde_json toe aan je Cargo.toml. Met de feature derive schakel je de derive-macro's Serialize en Deserialize in om getypeerde structs te definiëren.
[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"
# Optioneel: voor parallelle verwerking
rayon = "1.10"
# Optioneel: voor async I/O
tokio = { version = "1", features = ["full"] }Typeveilig parsen met serde_json
Een groot voordeel van Rust bij JSONL-verwerking zijn de derive-macro's van serde. Daarmee deserialiseer je elke JSON-regel rechtstreeks naar een sterk getypeerde struct. De compiler controleert of je code de data correct verwerkt en spoort niet-overeenkomende types, ontbrekende velden en fouten in de structuur al tijdens het compileren op, in plaats van tijdens het uitvoeren.
Definieer een struct met Deserialize en gebruik serde_json::from_str om elke JSONL-regel naar die struct te parsen. Ontbrekende of onjuist gevormde velden leveren bij het parsen duidelijke foutmeldingen op, in plaats van later in je programma panics te veroorzaken.
use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
#[derive(Debug, Deserialize)]
struct LogEntry {
timestamp: String,
level: String,
message: String,
#[serde(default)]
metadata: Option<serde_json::Value>,
}
fn read_typed_jsonl(path: &str) -> anyhow::Result<Vec<LogEntry>> {
let file = File::open(path)?;
let reader = BufReader::new(file);
let mut entries = Vec::new();
for line in reader.lines() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let entry: LogEntry = serde_json::from_str(trimmed)?;
entries.push(entry);
}
Ok(entries)
}
fn main() -> anyhow::Result<()> {
let entries = read_typed_jsonl("logs.jsonl")?;
for entry in &entries {
println!("[{}] {}: {}", entry.level, entry.timestamp, entry.message);
}
Ok(())
}Gebruik serde_json::Value om flexibel met JSONL-records met uiteenlopende schema's te werken. Je kunt waarden benaderen met vierkante haken of de methoden as_str() en as_i64() gebruiken voor veilige typeconversie.
use serde_json::Value;
use std::fs::File;
use std::io::{BufRead, BufReader};
fn process_dynamic_jsonl(path: &str) -> anyhow::Result<()> {
let file = File::open(path)?;
let reader = BufReader::new(file);
for line in reader.lines() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let value: Value = serde_json::from_str(trimmed)?;
// Velden dynamisch benaderen
if let Some(name) = value.get("name").and_then(Value::as_str) {
println!("Naam: {}", name);
}
if let Some(age) = value.get("age").and_then(Value::as_i64) {
println!("Leeftijd: {}", age);
}
// Controleer of een veld bestaat
if value.get("email").is_some() {
println!("Heeft e-mailveld");
}
}
Ok(())
}JSONL-bestanden schrijven in Rust
JSONL schrijven werkt precies andersom dan lezen: serialiseer elk record naar een JSON-string, voeg een regeleinde toe en schrijf het geheel naar een bestand. Met BufWriter en serde_json::to_string schrijf je de data correct en efficiënt weg.
Serialiseer elke struct met serde_json::to_string() en schrijf het resultaat weg, gevolgd door een regeleinde. De derive-macro Serialize zet je Rust-types automatisch om naar JSON.
use serde::Serialize;
use std::fs::File;
use std::io::Write;
#[derive(Serialize)]
struct Record {
id: u64,
name: String,
score: f64,
}
fn write_jsonl(path: &str, records: &[Record]) -> std::io::Result<()> {
let mut file = File::create(path)?;
for record in records {
let json = serde_json::to_string(record)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
writeln!(file, "{}", json)?;
}
Ok(())
}
fn main() -> std::io::Result<()> {
let records = vec![
Record { id: 1, name: "Alice".into(), score: 95.5 },
Record { id: 2, name: "Bob".into(), score: 87.3 },
Record { id: 3, name: "Charlie".into(), score: 92.1 },
];
write_jsonl("output.jsonl", &records)?;
println!("{} records geschreven", records.len());
Ok(())
}Geef bij het schrijven van grote JSONL-bestanden de File door aan een BufWriter om het aantal systeemaanroepen te beperken. De buffer verzamelt kleine schrijfbewerkingen en schrijft ze in grotere blokken weg. Dat verhoogt de doorvoersnelheid aanzienlijk.
use serde::Serialize;
use std::fs::File;
use std::io::{BufWriter, Write};
#[derive(Serialize)]
struct Event {
timestamp: u64,
event_type: String,
payload: serde_json::Value,
}
fn write_buffered_jsonl(path: &str, events: &[Event]) -> std::io::Result<()> {
let file = File::create(path)?;
let mut writer = BufWriter::new(file);
for event in events {
serde_json::to_writer(&mut writer, event)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
writer.write_all(b"\n")?;
}
writer.flush()?;
Ok(())
}Parallelle verwerking met rayon
Met de Rust-crate rayon kun je data parallel verwerken met minimale aanpassingen aan je code. Roep je par_iter() aan in plaats van iter(), dan verdeelt rayon het werk automatisch over alle CPU-cores via een threadpool met work stealing. Dit is vooral effectief voor CPU-intensieve JSONL-transformaties waarbij het parsen en verwerken meer tijd kost dan de I/O.
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Write};
#[derive(Debug, Deserialize, Serialize)]
struct Record {
id: u64,
text: String,
#[serde(default)]
word_count: Option<usize>,
}
fn parallel_process_jsonl(
input_path: &str,
output_path: &str,
) -> anyhow::Result<usize> {
// Stap 1: Lees alle regels in het geheugen
let file = File::open(input_path)?;
let reader = BufReader::new(file);
let lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;
// Stap 2: Parseer en transformeer parallel
let processed: Vec<Record> = lines
.par_iter()
.filter(|line| !line.trim().is_empty())
.filter_map(|line| {
serde_json::from_str::<Record>(line.trim()).ok()
})
.map(|mut record| {
record.word_count = Some(record.text.split_whitespace().count());
record
})
.collect();
// Stap 3: Schrijf resultaten
let file = File::create(output_path)?;
let mut writer = BufWriter::new(file);
let count = processed.len();
for record in &processed {
serde_json::to_writer(&mut writer, record)?;
writer.write_all(b"\n")?;
}
writer.flush()?;
Ok(count)
}
fn main() -> anyhow::Result<()> {
let count = parallel_process_jsonl("input.jsonl", "output.jsonl")?;
println!("{} records parallel verwerkt", count);
Ok(())
}Deze aanpak leest alle regels in, verwerkt ze parallel met par_iter() van rayon en schrijft de resultaten vervolgens sequentieel weg. Tijdens de parallelle stap worden de regels over alle beschikbare CPU-cores verdeeld om ze te parsen en te transformeren. Bij bestanden die in het geheugen passen, kan de snelheidswinst vrijwel lineair meegroeien met het aantal cores. Overweeg bij zeer grote bestanden om de invoer in blokken te verdelen, zodat geheugengebruik en parallelle verwerking in balans blijven.
Async I/O met tokio
Gebruik je bij de verwerking van JSONL ook netwerk-I/O, bijvoorbeeld om HTTP-endpoints uit te lezen of naar externe opslag te schrijven? Met de async runtime van tokio kun je berekeningen uitvoeren terwijl je op I/O wacht. De trait tokio::io::AsyncBufReadExt biedt een asynchrone lines()-methode die overeenkomt met de synchrone API van BufReader.
use tokio::fs::File;
use tokio::io::{AsyncBufReadExt, BufReader};
use serde::Deserialize;
#[derive(Debug, Deserialize)]
struct ApiRecord {
id: u64,
url: String,
status: String,
}
async fn read_jsonl_async(path: &str) -> anyhow::Result<Vec<ApiRecord>> {
let file = File::open(path).await?;
let reader = BufReader::new(file);
let mut lines = reader.lines();
let mut records = Vec::new();
while let Some(line) = lines.next_line().await? {
let trimmed = line.trim().to_string();
if trimmed.is_empty() {
continue;
}
let record: ApiRecord = serde_json::from_str(&trimmed)?;
records.push(record);
}
Ok(records)
}
async fn write_jsonl_async(
path: &str,
records: &[ApiRecord],
) -> anyhow::Result<()> {
use tokio::io::AsyncWriteExt;
let mut file = File::create(path).await?;
for record in records {
let json = serde_json::to_string(record)?;
file.write_all(json.as_bytes()).await?;
file.write_all(b"\n").await?;
}
file.flush().await?;
Ok(())
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let records = read_jsonl_async("api_logs.jsonl").await?;
println!("{} async records gelezen", records.len());
write_jsonl_async("output.jsonl", &records).await?;
Ok(())
}De asynchrone aanpak levert vooral voordeel op in combinatie met netwerkbewerkingen. Voor uitsluitend bestands-I/O op lokale schijven is de synchrone BufReader vaak sneller, omdat async extra overhead met zich meebrengt voor het inplannen van taken. Gebruik tokio als je JSONL leest uit HTTP-streams, S3-buckets of andere netwerkbronnen waarbij de I/O-latentie de meeste tijd kost.
Foutafhandeling: Result en de ?-operator
Het Result-type van Rust en de ?-operator bieden een overzichtelijke aanpak voor foutafhandeling bij JSONL-verwerking, die je gemakkelijk kunt combineren. In plaats van try-catch-blokken te gebruiken, geeft elke bewerking die kan mislukken een Result terug. Met ? geef je een fout door; met match handel je die ter plekke af. Zo zijn de foutpaden expliciet en kun je ze niet per ongeluk negeren.
use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
use thiserror::Error;
#[derive(Error, Debug)]
enum JsonlError {
#[error("I/O-fout: {0}")]
Io(#[from] std::io::Error),
#[error("JSON-parseerfout op regel {line}: {source}")]
Parse {
line: usize,
source: serde_json::Error,
},
#[error("Validatiefout op regel {line}: {message}")]
Validation {
line: usize,
message: String,
},
}
#[derive(Debug, Deserialize)]
struct Record {
id: u64,
name: String,
value: f64,
}
fn validate_record(record: &Record, line: usize) -> Result<(), JsonlError> {
if record.name.is_empty() {
return Err(JsonlError::Validation {
line,
message: "naam mag niet leeg zijn".into(),
});
}
if record.value < 0.0 {
return Err(JsonlError::Validation {
line,
message: format!("waarde moet niet-negatief zijn, kreeg {}", record.value),
});
}
Ok(())
}
fn process_jsonl_with_errors(
path: &str,
) -> Result<Vec<Record>, JsonlError> {
let file = File::open(path)?; // I/O-fout automatisch geconverteerd via #[from]
let reader = BufReader::new(file);
let mut records = Vec::new();
for (idx, line) in reader.lines().enumerate() {
let line_num = idx + 1;
let line = line?; // Propageer I/O-fouten
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let record: Record = serde_json::from_str(trimmed)
.map_err(|e| JsonlError::Parse { line: line_num, source: e })?;
validate_record(&record, line_num)?;
records.push(record);
}
Ok(records)
}
fn main() {
match process_jsonl_with_errors("data.jsonl") {
Ok(records) => println!("{} records succesvol verwerkt", records.len()),
Err(JsonlError::Io(e)) => eprintln!("Bestandsfout: {}", e),
Err(JsonlError::Parse { line, source }) => {
eprintln!("JSON-fout op regel {}: {}", line, source);
}
Err(JsonlError::Validation { line, message }) => {
eprintln!("Validatiefout op regel {}: {}", line, message);
}
}
}Deze aanpak gebruikt thiserror om een eigen enum voor fouten te definiëren die alle mogelijke foutgevallen afdekt: I/O-fouten, JSON-parsefouten met regelnummers en domeinspecifieke validatiefouten. Het attribuut #[from] maakt automatische conversie vanuit std::io::Error mogelijk, en de ?-operator geeft fouten door naar boven in de call stack. Elke foutvariant bevat voldoende context voor een duidelijke foutmelding, zodat je eenvoudig kunt achterhalen welke regel het probleem heeft veroorzaakt.
Rust-crates voor JSON-verwerking
Het Rust-ecosysteem biedt meerdere crates om JSON te parsen, elk met hun eigen prestatiekenmerken. serde_json is de standaardkeuze. simd-json en sonic-rs halen met SIMD-instructies nog meer snelheid uit het parsen.
serde_json
StandaardDe de facto standaard voor JSON in Rust. Dankzij de naadloze integratie met de derive-macro's van serde kun je serialiseren zonder boilerplate te schrijven. Met sterke typeveiligheid, uitgebreide foutmeldingen en brede ondersteuning in het ecosysteem is dit een uitstekende keuze voor de meeste JSONL-workloads.
simd-json
SnelstEen Rust-port van simdjson die met SIMD-instructies meerdere gigabytes JSON per seconde kan parsen. Deze crate vereist invoerbuffers die gewijzigd kunnen worden en heeft een andere API dan serde_json, maar kan bij workloads waarin vooral veel wordt geparset 2-4x sneller zijn. Vooral geschikt voor pipelines die een hoge doorvoersnelheid nodig hebben.
sonic-rs
SIMD + serdeEen JSON-library die SIMD gebruikt voor extra snelheid en een API biedt die compatibel is met serde. Het doel is om de snelheid van simd-json te combineren met het gebruiksgemak van serde_json. De library ondersteunt zowel lazy als eager parsing en is daarmee een goede keuze als je snelheid nodig hebt zonder je code te herschrijven.
Probeer onze gratis JSONL-tools
Wil je geen code schrijven? Met onze gratis online tools kun je JSONL-bestanden rechtstreeks in je browser bekijken, valideren en converteren.
Strategieën om gigabytes aan JSONL-data te verwerken. Met aandacht voor lezen via streaming, geheugenbeheer, het splitsen van bestanden, compressie en online tools.
Leer hoe je JSONL als uitwisselingsformaat in ETL-pipelines gebruikt. Met uitleg over streaming met Apache Kafka, Airflow-DAG’s, het laden van data in Snowflake en BigQuery en het ontwerpen van fouttolerante pipelines.
Leer de best practices voor JSONL toepassen: opmaak, consistente schema’s, foutafhandeling, prestatieoptimalisatie en het organiseren van bestanden. Vermijd veelvoorkomende valkuilen aan de hand van praktische voorbeelden.
Valideer JSONL-bestanden regel voor regel. Spoor syntaxfouten, tekencoderingsproblemen en fouten in het formaat direct op.
Een complete handleiding om met JSONL-bestanden in Go te werken. Leer werken met bufio.Scanner en json.Decoder, ontdek concurrencypatronen met goroutines en lees hoe je fouten afhandelt en snelle datapipelines bouwt.