Projekt: ein Logdatei-Analysator

// One log line -> { time: Date, level, message }, or null if it does not match.
export function parseLine(line) {
  const [time, level, message] = line.split(" ");
  return { time: new Date(time), level, message };
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {parseLine} from './main.js';

test('Der ganze Rest der Zeile ist die Meldung', () => {
  const entry = parseLine('2026-10-05T09:47:13Z ERROR database timeout after 5000 ms');
  assert.equal(entry?.level, 'ERROR', `das Level ist ${entry?.level}`);
  assert.equal(entry?.message, 'database timeout after 5000 ms', `die Meldung ist ${entry?.message}`);
});

test('Die Zeit ist ein Date zu diesem UTC-Moment', () => {
  const entry = parseLine('2026-10-05T08:15:02Z INFO server started');
  assert.ok(entry?.time instanceof Date, 'time sollte ein Date sein');
  assert.equal(entry.time.toISOString(), '2026-10-05T08:15:02.000Z', `die Zeit ist ${entry.time.toISOString()}`);
});

test('Eine kaputte Zeile ergibt null', () => {
  assert.equal(parseLine('this line is broken'), null, 'parseLine sollte für eine kaputte Zeile null zurückgeben');
});

test('Ein unbekanntes Level ergibt null', () => {
  assert.equal(parseLine('2026-10-05T08:16:00Z DEBUG cache warm'), null, 'DEBUG ist keines der drei Level');
});

{
  "type": "module"
}

// Counts entries by the key that keyOf returns, in first-seen order.
export function countBy(entries, keyOf) {
  const counts = new Map();
  for (const entry of entries) {
    const key = keyOf(entry);
    counts.set(key, counts.get(key) + 1);
  }
  return counts;
}

export const countByLevel = (entries) => countBy(entries, (entry) => entry.level);
// TODO: count by the hour of entry.time, in UTC.
export const countByHour = (entries) => countBy(entries, (entry) => entry.time);

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {countByLevel, countByHour} from './main.js';

const at = (iso, level) => ({time: new Date(iso), level, message: 'x'});
const entries = [
  at('2026-10-05T08:15:02Z', 'INFO'),
  at('2026-10-05T08:40:00Z', 'ERROR'),
  at('2026-10-05T09:02:44Z', 'INFO'),
  at('2026-10-05T23:59:59Z', 'INFO')
];

test('Level werden in der Reihenfolge des ersten Auftretens gezählt', () => {
  const counts = countByLevel(entries);
  assert.deepEqual([...counts], [['INFO', 3], ['ERROR', 1]], `die Zähler sind ${JSON.stringify([...counts])}`);
});

test('Stunden sind UTC-Stunden als Zahlen', () => {
  const counts = countByHour(entries);
  assert.deepEqual([...counts], [[8, 2], [9, 1], [23, 1]], `die Zähler sind ${JSON.stringify([...counts])}`);
});

test('Keine Einträge ergeben eine leere Map', () => {
  assert.equal(countByLevel([]).size, 0, 'countByLevel([]) sollte leer sein');
});

{
  "type": "module"
}

// counts: Map of level -> count. Returns the summary lines for a locale.
export function formatSummary(counts, locale) {
  const total = [...counts.values()].reduce((sum, n) => sum + n, 0);
  const lines = [];
  for (const [level, count] of counts) {
    lines.push(`${level}: ${count} (${Math.round((count / total) * 1000) / 10}%)`);
  }
  lines.push(`levels: ${[...counts.keys()].join(", ")}`);
  return lines;
}

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {formatSummary} from './main.js';

const counts = new Map([['INFO', 3], ['WARN', 1], ['ERROR', 2]]);

test('Deutsche Anteile haben ein Komma und ein geschütztes Leerzeichen vor %', () => {
  const lines = formatSummary(counts, 'de-DE');
  assert.equal(lines[1], 'WARN: 1 (16,7\u00a0%)', `die WARN-Zeile ist ${JSON.stringify(lines[1])}`);
});

test('Englische Anteile haben einen Punkt und kein Leerzeichen', () => {
  const lines = formatSummary(counts, 'en-US');
  assert.equal(lines[2], 'ERROR: 2 (33.3%)', `die ERROR-Zeile ist ${JSON.stringify(lines[2])}`);
});

test('Die Level sind eine Liste in der Sprache des Locales', () => {
  const german = formatSummary(counts, 'de-DE').at(-1);
  const english = formatSummary(counts, 'en-US').at(-1);
  assert.equal(german, 'levels: INFO, WARN und ERROR', `die deutsche Listenzeile ist ${german}`);
  assert.equal(english, 'levels: INFO, WARN, and ERROR', `die englische Listenzeile ist ${english}`);
});

{
  "type": "module"
}