- Startseite
- Anleitung
- JSONL-Streaming: Daten in Echtzeit verarbeiten
JSONL-Streaming: Daten in Echtzeit verarbeiten
Eine ausführliche Anleitung zum Streaming von JSONL-Daten in Echtzeit. Erfahren Sie, wie Sie Streaming-Pipelines mit readline in Node.js, Python-Generatoren, Server-Sent Events und WebSockets aufbauen und bewährte Verfahren für das Log-Streaming im Produktivbetrieb einsetzen.
Warum sich JSONL ideal für Streaming eignet
JSONL (JSON Lines) speichert pro Zeile ein vollständiges JSON-Objekt. Die einzelnen Objekte sind durch Zeilenumbrüche getrennt. Diese zeilenbasierte Struktur eignet sich ideal für Streaming, denn jede Zeile ist eine in sich geschlossene Einheit, die sich separat parsen lässt. Anders als bei einem großen JSON-Array müssen Sie nicht erst den gesamten Datenbestand in den Arbeitsspeicher laden, bevor Sie die ersten Datensätze verarbeiten können. Ein Consumer kann eine Zeile lesen, parsen und verarbeiten und dann zur nächsten übergehen. Der Speicherverbrauch bleibt dabei konstant, unabhängig davon, wie groß die Datenquelle wird.
Deshalb ist JSONL in Systemen zur Log-Aggregation, Pipelines für Echtzeitanalysen, Datenfeeds für Machine Learning und Streaming-Antworten von APIs so verbreitet. Die OpenAI-API, AWS CloudWatch und Apache Kafka verwenden JSON mit Zeilenumbrüchen als Trennzeichen, weil es die universelle Lesbarkeit von JSON mit der Streaming-Effizienz zeilenorientierter Protokolle verbindet. In dieser Anleitung erfahren Sie, wie Sie JSONL-Streaming in Node.js und Python umsetzen, Echtzeitdaten per Server-Sent Events an Browser senden, JSONL über WebSockets austauschen und ein Log-Streaming-System für den Produktivbetrieb implementieren.
JSONL-Streaming in Node.js
Node.js basiert auf einem ereignisgesteuerten I/O-Modell mit nicht blockierenden Ein- und Ausgaben und eignet sich damit besonders gut für Streaming. Die integrierten Module readline und stream bieten alles, was Sie brauchen, um JSONL-Dateien und Netzwerkstreams zeilenweise zu verarbeiten, ohne die gesamten Nutzdaten in den Arbeitsspeicher zu laden.
Das Modul readline in Kombination mit fs.createReadStream ist der übliche Weg, JSONL-Dateien in Node.js einzulesen. Die Datei wird blockweise gelesen und in vollständigen Zeilen ausgegeben. So bleibt der Speicherverbrauch selbst bei Dateien mit mehreren Gigabyte konstant.
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';
async function streamJsonl(filePath, onRecord) {
const rl = createInterface({
input: createReadStream(filePath, 'utf-8'),
crlfDelay: Infinity,
});
let count = 0;
for await (const line of rl) {
const trimmed = line.trim();
if (!trimmed) continue;
try {
const record = JSON.parse(trimmed);
await onRecord(record);
count++;
} catch (err) {
console.error(`Skipping invalid line: ${err.message}`);
}
}
return count;
}
// Usage: process each record as it arrives
const total = await streamJsonl('events.jsonl', async (record) => {
console.log(`Event: ${record.type} at ${record.timestamp}`);
});
console.log(`Processed ${total} records`);Mit den Transform-Streams von Node.js lassen sich Datenpipelines aus einzelnen Verarbeitungsschritten zusammensetzen: Sie lesen JSONL ein, filtern oder ergänzen die Datensätze und schreiben die Ergebnisse wieder heraus. Backpressure wird dabei automatisch berücksichtigt: Kann das Ziel die Daten nicht schnell genug verarbeiten, wird die Quelle pausiert.
import { createReadStream, createWriteStream } from 'node:fs';
import { Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
// Split incoming chunks into individual lines
class LineSplitter extends Transform {
constructor() {
super({ readableObjectMode: true });
this.buffer = '';
}
_transform(chunk, encoding, cb) {
this.buffer += chunk.toString();
const lines = this.buffer.split('\n');
this.buffer = lines.pop();
for (const line of lines) {
if (line.trim()) this.push(line.trim());
}
cb();
}
_flush(cb) {
if (this.buffer.trim()) this.push(this.buffer.trim());
cb();
}
}
// Parse, transform, and re-serialize each record
class JsonlTransform extends Transform {
constructor(transformFn) {
super({ objectMode: true });
this.transformFn = transformFn;
}
_transform(line, encoding, cb) {
try {
const record = JSON.parse(line);
const result = this.transformFn(record);
if (result) cb(null, JSON.stringify(result) + '\n');
else cb(); // Filter out null results
} catch (err) {
cb(); // Skip invalid lines
}
}
}
// Build the pipeline: read -> split -> transform -> write
await pipeline(
createReadStream('input.jsonl', 'utf-8'),
new LineSplitter(),
new JsonlTransform((record) => {
if (record.level === 'error') {
return { ...record, flagged: true, reviewedAt: new Date().toISOString() };
}
return null; // Filter out non-error records
}),
createWriteStream('errors.jsonl', 'utf-8')
);
console.log('Pipeline complete');JSONL-Streaming in Python
Mit Python-Generatoren lassen sich JSONL-Daten auf elegante Weise streamen. Ein Generator liefert jeweils nur einen Datensatz und setzt die Verarbeitung erst fort, wenn der Consumer den nächsten Wert anfordert. Dadurch bleibt der Speicherverbrauch minimal. Zusammen mit dem integrierten json-Modul können Sie so mit wenigen Zeilen Code leistungsfähige Streaming-Pipelines aufbauen.
Eine Python-Generatorfunktion liest die Datei mit einer gewöhnlichen for-Schleife zeilenweise ein. Jeder Aufruf von next() liest genau eine Zeile, parst sie und liefert das Ergebnis. Das Datei-Handle bleibt geöffnet, und die Leseposition verschiebt sich erst, wenn der Consumer weitere Datensätze abruft.
import json
from typing import Generator, Any
def stream_jsonl(file_path: str) -> Generator[dict[str, Any], None, None]:
"""Stream JSONL records one at a time using a generator."""
with open(file_path, 'r', encoding='utf-8') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
yield json.loads(line)
except json.JSONDecodeError as e:
print(f"Skipping line {line_num}: {e}")
# Usage: process records lazily
for record in stream_jsonl('events.jsonl'):
if record.get('level') == 'error':
print(f"ERROR: {record['message']}")
# Or collect a subset with itertools
import itertools
first_100 = list(itertools.islice(stream_jsonl('large.jsonl'), 100))
print(f"Loaded first {len(first_100)} records")Mit dem Python-Modul itertools lassen sich Streaming-Operationen wie Filtern, Batching und Slicing kombinieren, ohne Zwischenergebnisse vollständig im Speicher abzulegen. Jeder Schritt in der Verarbeitungskette verarbeitet jeweils einen Datensatz. Dadurch können Sie auch Dateien verarbeiten, die größer sind als der verfügbare Arbeitsspeicher.
import json
import itertools
from typing import Generator, Iterable
def stream_jsonl(path: str) -> Generator[dict, None, None]:
with open(path, 'r') as f:
for line in f:
if line.strip():
yield json.loads(line)
def filter_records(records: Iterable[dict], key: str, value) -> Generator[dict, None, None]:
"""Filter records where key equals value."""
for record in records:
if record.get(key) == value:
yield record
def batch(iterable: Iterable, size: int) -> Generator[list, None, None]:
"""Yield successive batches of the given size."""
it = iter(iterable)
while True:
chunk = list(itertools.islice(it, size))
if not chunk:
break
yield chunk
# Compose a streaming pipeline
records = stream_jsonl('access_logs.jsonl')
errors = filter_records(records, 'status', 500)
for i, error_batch in enumerate(batch(errors, 50)):
print(f"Batch {i + 1}: {len(error_batch)} errors")
# Send batch to alerting system, database, etc.
for record in error_batch:
print(f" {record['timestamp']} - {record['path']}")Server-Sent Events mit JSONL
Server-Sent Events (SSE) bieten ein einfaches HTTP-basiertes Protokoll, mit dem ein Server Echtzeit-Updates an einen Client senden kann. Jedes SSE-Event enthält ein data-Feld. JSONL eignet sich dafür als Datenformat, weil jede Zeile ein vollständiges JSON-Objekt enthält, das der Client sofort parsen kann. Anders als WebSockets nutzt SSE gewöhnliches HTTP, benötigt keine besondere Proxy-Konfiguration und stellt die Verbindung nach einem Ausfall automatisch wieder her.
Der Server setzt den Content-Type auf text/event-stream und schreibt jeden JSONL-Datensatz in das data-Feld eines SSE-Events. Die Verbindung bleibt geöffnet, und der Server sendet neue Events, sobald sie vorliegen.
import express from 'express';
const app = express();
// Simulate a real-time data source
function* generateMetrics() {
let id = 0;
while (true) {
yield {
id: ++id,
cpu: Math.random() * 100,
memory: Math.random() * 16384,
timestamp: new Date().toISOString(),
};
}
}
app.get('/api/stream/metrics', (req, res) => {
// SSE headers
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
res.setHeader('Access-Control-Allow-Origin', '*');
res.flushHeaders();
const metrics = generateMetrics();
const interval = setInterval(() => {
const record = metrics.next().value;
// Each SSE event contains one JSONL record
res.write(`data: ${JSON.stringify(record)}\n\n`);
}, 1000);
req.on('close', () => {
clearInterval(interval);
res.end();
});
});
app.listen(3000, () => console.log('SSE server on :3000'));Der Browser verbindet sich über die EventSource-API mit dem SSE-Endpunkt. Jedes eingehende Event enthält einen JSONL-Datensatz, der in Echtzeit geparst und dargestellt wird. Bricht die Verbindung ab, stellt EventSource sie automatisch wieder her.
// Connect to the SSE endpoint
const source = new EventSource('/api/stream/metrics');
// Parse each JSONL record as it arrives
source.onmessage = (event) => {
const record = JSON.parse(event.data);
console.log(`[${record.timestamp}] CPU: ${record.cpu.toFixed(1)}%`);
// Update your UI in real time
updateDashboard(record);
};
source.onerror = (err) => {
console.error('SSE connection error:', err);
// EventSource automatically reconnects
};
// For Fetch-based SSE (more control over the stream)
async function fetchSSE(url, onRecord) {
const response = await fetch(url);
const reader = response.body
.pipeThrough(new TextDecoderStream())
.getReader();
let buffer = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += value;
const events = buffer.split('\n\n');
buffer = events.pop();
for (const event of events) {
const dataLine = event.split('\n').find(l => l.startsWith('data: '));
if (dataLine) {
const record = JSON.parse(dataLine.slice(6));
onRecord(record);
}
}
}
}
await fetchSSE('/api/stream/metrics', (record) => {
console.log('Metric:', record);
});JSONL-Streaming über WebSockets
SSE überträgt Daten vom Server zum Client. WebSockets ermöglichen dagegen Vollduplex-Kommunikation: Beide Seiten können jederzeit JSONL-Datensätze senden. Das eignet sich ideal für interaktive Anwendungen wie gemeinsames Bearbeiten von Inhalten, Echtzeit-Dashboards mit Benutzerbefehlen und bidirektionale Datensynchronisation. Jede WebSocket-Nachricht enthält genau einen JSONL-Datensatz und lässt sich deshalb auf beiden Seiten einfach parsen.
import { WebSocketServer } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (ws) => {
console.log('Client connected');
// Send JSONL records to the client
const interval = setInterval(() => {
const record = {
type: 'metric',
value: Math.random() * 100,
timestamp: new Date().toISOString(),
};
ws.send(JSON.stringify(record));
}, 500);
// Receive JSONL records from the client
ws.on('message', (data) => {
try {
const record = JSON.parse(data.toString());
console.log(`Received: ${record.type}`, record);
// Echo back an acknowledgment
ws.send(JSON.stringify({
type: 'ack',
originalId: record.id,
processedAt: new Date().toISOString(),
}));
} catch (err) {
ws.send(JSON.stringify({ type: 'error', message: 'Invalid JSON' }));
}
});
ws.on('close', () => {
clearInterval(interval);
console.log('Client disconnected');
});
});
// Client-side usage:
// const ws = new WebSocket('ws://localhost:8080');
// ws.onmessage = (e) => {
// const record = JSON.parse(e.data);
// console.log(record);
// };
// ws.send(JSON.stringify({ type: 'subscribe', channel: 'metrics' }));Jede WebSocket-Nachricht besteht aus einem einzelnen JSON-Objekt und folgt damit dem JSONL-Prinzip: ein Datensatz pro Nachricht. Der Server streamt im 500-ms-Intervall Metriken an den Client und nimmt gleichzeitig dessen Befehle entgegen. In beiden Richtungen wird dieselbe JSON-Serialisierung verwendet. Dadurch ist das Protokoll symmetrisch und lässt sich leicht debuggen.
Log-Streaming in der Praxis
Die zentrale Erfassung von Logs gehört zu den häufigsten Anwendungsfällen für JSONL-Streaming. Anwendungen schreiben strukturierte Log-Einträge als JSONL-Zeilen nach stdout oder in eine Datei. Ein Collector-Agent liest die Ausgabe in Echtzeit mit und leitet die Datensätze an ein zentrales System weiter. Docker, Kubernetes und die meisten Cloud-Logging-Dienste nutzen dieses Verfahren.
import { createReadStream, watchFile } from 'node:fs';
import { createInterface } from 'node:readline';
import { stat } from 'node:fs/promises';
class JsonlLogCollector {
constructor(filePath, handlers = {}) {
this.filePath = filePath;
this.handlers = handlers;
this.position = 0;
this.running = false;
}
async start() {
this.running = true;
// Read existing content first
await this.readFrom(0);
// Watch for new appends
this.watch();
}
async readFrom(startPos) {
const rl = createInterface({
input: createReadStream(this.filePath, {
encoding: 'utf-8',
start: startPos,
}),
crlfDelay: Infinity,
});
for await (const line of rl) {
if (!line.trim()) continue;
try {
const record = JSON.parse(line);
await this.dispatch(record);
} catch (err) {
this.handlers.onError?.(err, line);
}
}
const info = await stat(this.filePath);
this.position = info.size;
}
watch() {
watchFile(this.filePath, { interval: 500 }, async (curr, prev) => {
if (!this.running) return;
if (curr.size > this.position) {
await this.readFrom(this.position);
}
});
}
async dispatch(record) {
const level = record.level || 'info';
this.handlers[level]?.(record);
this.handlers.onRecord?.(record);
}
stop() {
this.running = false;
}
}
// Usage
const collector = new JsonlLogCollector('app.log.jsonl', {
error: (r) => console.error(`[ERROR] ${r.message}`),
warn: (r) => console.warn(`[WARN] ${r.message}`),
onRecord: (r) => forwardToElasticsearch(r),
onError: (err, line) => console.error('Bad line:', line),
});
await collector.start();Dieser Collector liest eine JSONL-Logdatei in Echtzeit mit und übergibt die Datensätze je nach Log-Level an die passenden Handler. Er merkt sich die Leseposition und liest nach dem ersten Durchlauf, der den vorhandenen Inhalt erfasst, nur noch neu hinzugekommene Daten. Für den Produktivbetrieb würden Sie noch die Erkennung von Logrotation, ein geordnetes Herunterfahren und die gebündelte Weiterleitung von Datensätzen ergänzen, um die Zahl der Netzwerkanfragen an Ihr zentrales Logging-System zu reduzieren.
Probieren Sie unsere kostenlosen JSONL-Tools aus
Sie möchten JSONL-Daten prüfen oder konvertieren, bevor Sie Ihre Streaming-Pipeline aufbauen? Mit unseren kostenlosen Online-Tools können Sie JSONL-Dateien direkt im Browser anzeigen, konvertieren und formatieren. Die gesamte Verarbeitung erfolgt lokal, sodass Ihre Daten privat bleiben.
Strategien für JSONL-Daten im Gigabyte-Bereich: Lesen per Streaming, Speicherverwaltung, Aufteilen von Dateien, Komprimierung und Online-Tools.
Lernen Sie strukturiertes Logging im JSONL-Format und die Integration mit dem ELK Stack, Fluentd, CloudWatch, GCP Logging und Azure Monitor. Mit produktionsreifen Beispielen für Python, Node.js und Go.
Bewährte Vorgehensweisen für JSONL: Formatierung, einheitliche Schemas, Fehlerbehandlung, Performance-Optimierung und Dateiorganisation. Praktische Beispiele helfen Ihnen, typische Fallstricke zu vermeiden.
Validieren Sie JSONL-Dateien Zeile für Zeile und erkennen Sie Syntaxfehler, Probleme mit der Zeichenkodierung und Formatfehler sofort.
Erfahren Sie, wie Sie das JSONL-Format in JavaScript und Node.js verwenden.