python · level 3 check

a shipped log analyser.

Time to ship a real tool. `logcheck` reads a server log and reports on it. The first line you type is its command line, like `--level warning --top 2`. Every line after that is a log line, until a line that says `END`.

Each log line has a time, a level and a message, like `09:15 ERROR disk full`. Lines that do not fit are skipped and counted, never crashed on. The levels are DEBUG, INFO, WARNING and ERROR, and `--level` hides anything less serious.

The report counts each level, ranks the most common messages and says how many lines were skipped. A bad option gets one polite sentence and exit code 2, not a traceback. Fill in each `____`, run it, then feed it a log of your own.

Your program

import argparse
import sys
from collections import Counter
from dataclasses import dataclass

LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR"]

@dataclass(frozen=____)
class Entry:
    time: str
    level: str
    message: str

class BadLine(ValueError):
    pass

class OptionError(ValueError):
    pass

class Parser(argparse.ArgumentParser):
    def error(self, message):
        raise ____(message)

def parse_line(line: str) -> Entry:
    parts = line.strip().split(" ", ____)
    if len(parts) != 3:
        raise BadLine("expected a time, a level and a message")
    time, level, message = parts
    level = level.upper()
    if level not in LEVELS:
        raise BadLine(f"unknown level {level}")
    return Entry(time, level, message.strip())

def read_lines():
    while True:
        try:
            line = input()
        except EOFError:
            return
        if line.strip() == "END":
            return
        ____ line

def analyse(lines, minimum: str) -> tuple[Counter, Counter, int]:
    counts = Counter()
    messages = Counter()
    skipped = 0
    for line in lines:
        if line.strip() == "":
            continue
        try:
            entry = parse_line(line)
        except ____:
            skipped = skipped + 1
            continue
        if LEVELS.index(entry.level) >= LEVELS.index(minimum):
            counts[entry.level] = counts[entry.level] + 1
            messages[entry.message] = messages[entry.message] + 1
    return counts, messages, skipped

def main(argv: list[str]) -> int:
    parser = Parser(prog="logcheck")
    parser.add_argument("--level", type=str.upper, choices=LEVELS, default="INFO")
    parser.add_argument("--top", type=int, default=3)
    try:
        args = parser.parse_args(argv)
        if args.top < 1:
            raise OptionError("--top must be at least 1")
    except OptionError as problem:
        print(f"logcheck: {problem}", file=____)
        return 2
    counts, messages, skipped = analyse(read_lines(), args.level)
    total = sum(counts.values())
    if total == 0:
        print(f"No entries at {args.level} or above.")
    else:
        print(f"Entries at {args.level} or above: {total}")
        for level in LEVELS:
            if counts[level] > 0:
                print(f"  {level}: {counts[level]}")
        print("Most common:")
        for message, times in messages.most_common(____):
            print(f"  {times} x {message}")
    print(f"Bad lines skipped: {skipped}")
    return 0

if __name__ == ____:
    status = main(input().split())
    print(f"exit code {status}")

Fill in every ____ then run the checks.

1 It counts each leveluses: Counter
2 It hides less serious levels with --leveluses: argparse
3 It ranks the most common messages with --topuses: Counter
4 It skips bad lines without crashinguses: validating input
5 It rejects a bad option politelyuses: failing politely
6 It copes with an empty loguses: edge cases

Take as long as you like and try as many times as you want.

a shipped log analyser.

level up.

playground