著者: Jerry Fan

Rust で JSONL を扱う:serde_json、BufReader、ゼロコスト抽象化

Rust で JSONL(JSON Lines)ファイルを扱うための完全ガイドです。serde_json と BufReader を使った JSONL データの読み書き、パース、ストリーミング処理から、rayon による並列処理、tokio による非同期 I/O まで解説します。

JSONL の処理に Rust を選ぶ理由

パフォーマンス、メモリ安全性、処理の正確性が求められる JSONL 処理には、Rust が適しています。所有権モデルによってコンパイル時にデータ競合を排除でき、ゼロコスト抽象化によって、高レベルなイテレータのチェーンも無駄のないループにコンパイルされます。さらに、serde_json は、言語を問わず最速クラスの JSON パーサーです。毎秒数百万件の JSONL レコードを処理するデータパイプラインを構築する場合も、Rust なら安全性を犠牲にせず、必要な性能を引き出すための細かな制御ができます。

JSONL(JSON Lines)は1行に1つの JSON オブジェクトを格納する形式で、ストリーミング処理、追記専用のログ、大規模なデータセットの処理に適しています。Rust の BufReader はファイル全体をメモリに読み込まずに行単位で読み取ることができ、イテレータの仕組みも JSONL の行単位の構造とよく合います。このガイドでは、BufReader を使った JSONL の読み書き、serde による厳密な型を持つ構造体へのパース、rayon によるレコードの並列処理、tokio による非同期 I/O、Result と ? 演算子を使った堅牢なエラーハンドリングを解説します。

BufReader で JSONL ファイルを読み込む

Rust の標準ライブラリには、バッファを使ってファイルを効率よく読み込むための BufReader が用意されています。lines() イテレータと組み合わせると、メモリの追加使用量を最小限に抑えながら JSONL ファイルを1行ずつ読み込めます。各行を個別にパースするため、ファイルのサイズを問わず使える方法です。

最も簡単な方法は、File を BufReader でラップし、lines() で各行を取り出して serde_json でパースすることです。ファイルのサイズにかかわらず、一度にメモリに保持するのは1行分だけです。

BufReader を使った JSONL 読み込みの基本
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; // Skip empty lines
        }
        match serde_json::from_str::<Value>(trimmed) {
            Ok(value) => records.push(value),
            Err(e) => {
                eprintln!("Skipping invalid JSON at line {}: {}", line_num + 1, e);
            }
        }
    }


    Ok(records)
}


fn main() -> std::io::Result<()> {
    let records = read_jsonl("data.jsonl")?;
    println!("Loaded {} records", records.len());
    if let Some(first) = records.first() {
        println!("First record: {}", first);
    }
    Ok(())
}

Cargo.toml に serde と serde_json を追加します。derive フィーチャーを有効にすると、型付きの構造体を定義する際に Serialize と Deserialize の derive マクロを使えるようになります。

Cargo.toml に依存関係を追加する
[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"


# Optional: for parallel processing
rayon = "1.10"


# Optional: for async I/O
tokio = { version = "1", features = ["full"] }

serde_json で型安全にパースする

JSONL 処理における Rust の大きな強みの一つが、serde の derive マクロです。各行の JSON を、厳密な型を持つ構造体に直接デシリアライズできます。コンパイラがコード内でのデータの扱いを検証するため、型の不一致、フィールドの欠落、構造上の誤りを、実行時ではなくコンパイル時に検出できます。

Deserialize を導出する構造体を定義し、serde_json::from_str で JSONL の各行をその構造体にパースします。フィールドが欠けていたり、形式が不正だったりすると、後続の処理でパニックが発生するのではなく、パース時点で明確なエラーメッセージが返されます。

型付きの構造体にデシリアライズする
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(())
}

レコードごとにスキーマが異なる JSONL では、serde_json::Value を使うと柔軟にデータにアクセスできます。角括弧によるインデックスアクセスのほか、as_str() や as_i64() メソッドによる安全な型変換も利用できます。

serde_json::Value で動的にパースする
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)?;


        // Access fields dynamically
        if let Some(name) = value.get("name").and_then(Value::as_str) {
            println!("Name: {}", name);
        }
        if let Some(age) = value.get("age").and_then(Value::as_i64) {
            println!("Age: {}", age);
        }


        // Check if a field exists
        if value.get("email").is_some() {
            println!("Has email field");
        }
    }


    Ok(())
}

Rust で JSONL ファイルを書き出す

JSONL の書き込みは、読み込みと逆の手順で行います。各レコードを JSON 文字列にシリアライズし、末尾に改行を付けてファイルに書き込みます。BufWriter と serde_json::to_string を使えば、正確性とパフォーマンスを両立できます。

serde_json::to_string() で各構造体をシリアライズし、末尾に改行を付けて書き込みます。Serialize の derive マクロが、Rust の型から JSON への変換を自動で処理します。

JSONL 書き込みの基本
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!("Wrote {} records", records.len());
    Ok(())
}

大きな JSONL ファイルを書き出すときは、File を BufWriter でラップするとシステムコールの回数を減らせます。小さな書き込みをバッファにためてまとめて出力することで、スループットが大幅に向上します。

大量のデータをバッファ経由で書き込む
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(())
}

rayon で並列処理する

Rust の rayon クレートを使うと、わずかなコード変更でデータを並列処理できます。iter() の代わりに par_iter() を呼び出すだけで、rayon のワークスティーリング方式のスレッドプールが、すべての CPU コアに処理を自動で振り分けます。I/O よりもパースやデータ処理に時間がかかる、CPU バウンドな JSONL 変換に特に効果的です。

rayon で並列処理する
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> {
    // Step 1: Read all lines into memory
    let file = File::open(input_path)?;
    let reader = BufReader::new(file);
    let lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;


    // Step 2: Parse and transform in 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();


    // Step 3: Write results
    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!("Processed {} records in parallel", count);
    Ok(())
}

このパターンでは、すべての行を読み込み、rayon の par_iter() で並列処理した後、結果を順次書き込みます。パースと変換は、利用可能なすべての CPU コアを使って並列に実行します。ファイルがメモリに収まる場合は、コア数にほぼ比例した高速化が期待できます。非常に大きなファイルでは、メモリ使用量と並列性のバランスを取るため、入力をチャンクに分けて処理することを検討してください。

tokio で非同期 I/O を扱う

HTTP エンドポイントからの読み込みやリモートストレージへの書き込みなど、JSONL の処理にネットワーク I/O が含まれる場合は、tokio の非同期ランタイムを使うと I/O の待ち時間に計算処理を進められます。tokio::io::AsyncBufReadExt トレイトには、同期版の BufReader API に対応する非同期の lines() メソッドが用意されています。

tokio で非同期 I/O を扱う
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!("Read {} async records", records.len());
    write_jsonl_async("output.jsonl", &records).await?;
    Ok(())
}

非同期処理が最も効果を発揮するのは、ネットワーク通信と組み合わせる場合です。ローカルディスク上のファイル I/O だけであれば、タスクのスケジューリングに伴うオーバーヘッドがない分、同期版の BufReader の方が速いことがよくあります。HTTP ストリームや S3 バケットなど、I/O の待ち時間が処理時間の大部分を占めるネットワーク上のデータソースから JSONL を読み込む場合に、tokio を使ってください。

Result と ? 演算子によるエラーハンドリング

Rust の Result 型と ? 演算子を使うと、JSONL 処理のエラーハンドリングをすっきりと記述でき、複数の処理も組み合わせやすくなります。try-catch ブロックを使う代わりに、失敗する可能性のある操作がそれぞれ Result を返します。エラーは ? で呼び出し元に伝播させることも、その場で match を使って処理することもできます。これにより、エラー時の処理経路が明示され、うっかりエラーを無視してしまうことを防げます。

Result と ? 演算子によるエラーハンドリング
use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
use thiserror::Error;


#[derive(Error, Debug)]
enum JsonlError {
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
    #[error("JSON parse error at line {line}: {source}")]
    Parse {
        line: usize,
        source: serde_json::Error,
    },
    #[error("Validation error at line {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: "name cannot be empty".into(),
        });
    }
    if record.value < 0.0 {
        return Err(JsonlError::Validation {
            line,
            message: format!("value must be non-negative, got {}", record.value),
        });
    }
    Ok(())
}


fn process_jsonl_with_errors(
    path: &str,
) -> Result<Vec<Record>, JsonlError> {
    let file = File::open(path)?; // Io error auto-converted 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?; // Propagate I/O errors
        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!("Successfully processed {} records", records.len()),
        Err(JsonlError::Io(e)) => eprintln!("File error: {}", e),
        Err(JsonlError::Parse { line, source }) => {
            eprintln!("JSON error at line {}: {}", line, source);
        }
        Err(JsonlError::Validation { line, message }) => {
            eprintln!("Validation error at line {}: {}", line, message);
        }
    }
}

このパターンでは、thiserror を使って独自のエラー列挙型を定義し、I/O エラー、行番号付きの JSON パースエラー、ドメイン固有の検証エラーという、すべての失敗パターンに対応します。#[from] 属性によって std::io::Error から自動変換でき、? 演算子で呼び出し元へエラーを伝播できます。各エラーバリアントには、原因を明確に伝えるメッセージを生成するための情報が含まれているため、問題が起きた行を正確に特定できます。

JSON 処理に使える Rust クレート

Rust のエコシステムには、性能面でそれぞれ特徴のある JSON パース用クレートがそろっています。標準的な選択肢は serde_json で、simd-json と sonic-rs は SIMD 命令を使ってさらなる高速化を図っています。

serde_json

標準

Rust で JSON を扱う際のデファクトスタンダードです。serde の derive マクロと自然に連携し、定型コードを書かずにシリアライズできます。強い型安全性、充実したエラーメッセージ、幅広いエコシステムでのサポートを備えており、ほとんどの JSONL 処理に適しています。

simd-json

最速

simdjson の Rust 移植版です。SIMD 命令を使い、毎秒数ギガバイトの速度で JSON をパースします。変更可能な入力バッファが必要で、API も serde_json とは異なりますが、パースの負荷が大きい処理では 2〜4 倍の速度が得られる可能性があります。高いスループットが求められるパイプラインに最適です。

sonic-rs

SIMD + serde

serde 互換の API を備えた、SIMD による高速化を図った JSON ライブラリです。simd-json の速さと serde_json の使いやすさの両立を目指しています。遅延パースと即時パースの両方に対応しており、コードを書き換えずに性能を向上させたい場合に適しています。

無料の JSONL ツールを試す

コードを書かずに操作したい場合は、無料のオンラインツールをご利用ください。ブラウザ上で直接 JSONL ファイルを表示、検証、変換できます。

JSONL ファイルをオンラインで操作する

最大 1GB の JSONL ファイルを、ブラウザ上で直接表示、検証、変換できます。アップロードは不要で、プライバシーは 100% 保たれます。

よくある質問

参考資料