Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 2: Structs, Methoden, Interfaces – logsum

Ziel: Ein Paket logs mit eigenen Typen, Methoden und einem Interface bauen und daraus logsum machen, das Zugriffslogs in zwei Formaten auswertet · Dauer: ca. 120 min · Voraussetzung: Tag 1

Briefing

  • Ein Struct bündelt Felder zu einem Typ; es gibt keine Klassen und keine Vererbung.
  • Methoden hängen an einem Typ über einen Receiver: func (s *Summary) Add(e Entry). Pointer-Receiver dürfen den Wert ändern.
  • Ein Interface beschreibt Verhalten (Parse(line string) (Entry, error)). Ein Typ erfüllt es implizit, sobald er die Methoden hat – kein implements.
  • Ein Paket ist ein Ordner. Großgeschrieben = exportiert, kleingeschrieben = privat. internal/ darf nur das eigene Modul importieren.
  • Faustregel: Funktionen nehmen Interfaces (io.Reader, io.Writer) und geben konkrete Typen zurück.
 cmd/logsum/main.go                    internal/logs
 ┌──────────────────┐                  ┌────────────────────────────────┐
 │ -format json     │ ── Parser ─────► │ Combined{} / JSON{}  .Parse()  │
 │ -top 3           │ ── io.Reader ──► │ Read() ──► *Summary            │
 │ Datei oder stdin │                  │   .Add() .TopPaths() .ErrorRate│
 │ os.Stdout        │ ◄─ io.Writer ─── │   .Report(w, top)              │
 └──────────────────┘                  └────────────────────────────────┘

Drill 1: Modul und Testdaten

mkdir -p ~/go-lab/tag02-logsum && cd ~/go-lab/tag02-logsum
go mod init example.com/logsum
mkdir -p cmd/logsum internal/logs testdata
cat > testdata/access.log <<'EOF'
10.0.0.1 - - [10/Oct/2026:08:00:01 +0200] "GET / HTTP/1.1" 200 512 "-" "curl/8.7"
10.0.0.2 - - [10/Oct/2026:08:00:03 +0200] "GET /api/orders HTTP/1.1" 200 2048 "-" "k6"
10.0.0.2 - - [10/Oct/2026:08:00:04 +0200] "POST /api/orders HTTP/1.1" 201 64 "-" "k6"
10.0.0.3 - - [10/Oct/2026:08:01:10 +0200] "GET /api/orders HTTP/1.1" 200 2048 "-" "k6"
10.0.0.1 - - [10/Oct/2026:08:01:12 +0200] "GET /favicon.ico HTTP/1.1" 404 0 "-" "Safari"
10.0.0.4 - - [10/Oct/2026:08:02:00 +0200] "GET /old HTTP/1.1" 301 - "-" "curl/8.7"
das ist keine Logzeile
10.0.0.3 - - [10/Oct/2026:08:02:30 +0200] "GET /api/users HTTP/1.1" 500 128 "-" "k6"
10.0.0.2 - - [10/Oct/2026:08:03:45 +0200] "GET /api/orders HTTP/1.1" 200 2048 "-" "k6"
10.0.0.5 - - [10/Oct/2026:08:04:13 +0200] "GET /admin HTTP/1.1" 403 256 "-" "nmap"
10.0.0.3 - - [10/Oct/2026:08:04:20 +0200] "GET /api/users HTTP/1.1" 502 0 "-" "k6"
EOF
cat > testdata/access.jsonl <<'EOF'
{"ts":"2026-10-10T07:00:00Z","ip":"10.0.0.7","path":"/healthz","status":200,"bytes":2}
{"ts":"2026-10-10T07:00:05Z","ip":"10.0.0.7","path":"/healthz","status":200,"bytes":2}
{"ts":"2026-10-10T07:00:09Z","ip":"10.0.0.8","path":"/api/orders","status":503}
{"ts":"kaputt"}
EOF
wc -l testdata/*

Erwartet:

go: creating new go.mod: module example.com/logsum
       4 testdata/access.jsonl
      11 testdata/access.log
      15 total

Zwei Formate, je eine kaputte Zeile – ein gutes Tool muss damit umgehen. testdata/ ist ein Sonderordner: go build ignoriert ihn, Tests (Tag 4) finden darin ihre Eingaben.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein Typ und ein Interface

cat > internal/logs/entry.go <<'EOF'
// Package logs liest Zugriffslogs und fasst sie zusammen.
package logs

import "time"

// Entry ist eine geparste Logzeile.
type Entry struct {
    IP     string
    Time   time.Time
    Method string
    Path   string
    Status int
    Bytes  int64
}

// Parser macht aus einer Zeile einen Entry. Jedes Logformat implementiert ihn.
type Parser interface {
    Parse(line string) (Entry, error)
}
EOF
go doc ./internal/logs

Erwartet:

package logs // import "example.com/logsum/internal/logs"

Package logs liest Zugriffslogs und fasst sie zusammen.

type Entry struct{ ... }
type Parser interface{ ... }

Warum? Der Kommentar direkt über package und über jedem exportierten Namen ist die Doku – go doc, gopls und pkg.go.dev zeigen ihn an. Das Interface ist absichtlich klein: eine Methode. Kleine Interfaces lassen sich leicht implementieren und leicht in Tests ersetzen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Zwei Implementierungen

Erst das klassische Combined Log Format von nginx und Apache:

cat > internal/logs/combined.go <<'EOF'
package logs

import (
    "fmt"
    "regexp"
    "strconv"
    "time"
)

// combinedRe ist klein geschrieben, also nur in Paket logs sichtbar.
var combinedRe = regexp.MustCompile(
    `^(\S+) \S+ \S+ \[([^\]]+)\] "(\S+) (\S+)[^"]*" (\d{3}) (\d+|-)`)

const combinedTime = "02/Jan/2006:15:04:05 -0700"

// Combined liest das Combined Log Format von nginx und Apache.
type Combined struct{}

// Compiler prüft: Combined erfüllt Parser.
var _ Parser = Combined{}

// Parse implementiert Parser.
func (Combined) Parse(line string) (Entry, error) {
    m := combinedRe.FindStringSubmatch(line)
    if m == nil {
        return Entry{}, fmt.Errorf("kein Combined-Format: %q", line)
    }
    t, err := time.Parse(combinedTime, m[2])
    if err != nil {
        return Entry{}, err
    }
    status, _ := strconv.Atoi(m[5]) // Regex garantiert drei Ziffern
    var size int64
    if m[6] != "-" {
        size, _ = strconv.ParseInt(m[6], 10, 64)
    }
    return Entry{
        IP: m[1], Time: t, Method: m[3], Path: m[4],
        Status: status, Bytes: size,
    }, nil
}
EOF

Dann JSON-Logs, eine Zeile pro Request:

cat > internal/logs/json.go <<'EOF'
package logs

import (
    "encoding/json"
    "fmt"
    "time"
)

// JSON liest ein JSON-Objekt pro Zeile (z. B. nginx mit escape=json).
type JSON struct{}

var _ Parser = JSON{}

// jsonLine beschreibt das Format; die Tags ordnen JSON-Keys den Feldern zu.
type jsonLine struct {
    Time   time.Time `json:"ts"`
    IP     string    `json:"ip"`
    Method string    `json:"method"`
    Path   string    `json:"path"`
    Status int       `json:"status"`
    Bytes  int64     `json:"bytes"`
}

// Parse implementiert Parser.
func (JSON) Parse(line string) (Entry, error) {
    var j jsonLine
    if err := json.Unmarshal([]byte(line), &j); err != nil {
        return Entry{}, err
    }
    if j.Path == "" || j.Status == 0 {
        return Entry{}, fmt.Errorf("path oder status fehlt: %q", line)
    }
    return Entry{
        IP: j.IP, Time: j.Time, Method: j.Method, Path: j.Path,
        Status: j.Status, Bytes: j.Bytes,
    }, nil
}
EOF
go vet ./... && go doc ./internal/logs Combined

Erwartet:

package logs // import "example.com/logsum/internal/logs"

type Combined struct{}
    Combined liest das Combined Log Format von nginx und Apache.

func (Combined) Parse(line string) (Entry, error)

Warum? Combined und JSON sind leere Structs – sie brauchen keinen Zustand, nur die Methode. var _ Parser = Combined{} kostet nichts zur Laufzeit, lässt aber den Compiler sofort meckern, wenn die Signatur nicht passt. Struct-Tags wie `json:"ts"` sagen encoding/json, welcher Key in welches Feld gehört (mehr an Tag 6). Das Zeitformat 02/Jan/2006:15:04:05 -0700 ist kein Tippfehler: Go beschreibt Layouts mit dem Referenzdatum 2. Januar 2006, 15:04:05.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Summary mit Methoden

cat > internal/logs/summary.go <<'EOF'
package logs

import (
    "bufio"
    "cmp"
    "fmt"
    "io"
    "slices"
    "strings"
    "time"
)

// Summary sammelt Kennzahlen über viele Entries.
type Summary struct {
    Lines    int // gelesene Zeilen
    Bad      int // nicht lesbare Zeilen
    Bytes    int64
    First    time.Time
    Last     time.Time
    ByStatus map[int]int    // 200 -> 17
    ByPath   map[string]int // "/api" -> 4
}

// PathCount ist ein Eintrag der Top-Liste.
type PathCount struct {
    Path string
    N    int
}

// NewSummary liefert einen Summary mit initialisierten Maps.
func NewSummary() *Summary {
    return &Summary{ByStatus: map[int]int{}, ByPath: map[string]int{}}
}

// Read parst jede Zeile aus r mit p und zählt sie in einen neuen Summary.
func Read(r io.Reader, p Parser) (*Summary, error) {
    s := NewSummary()
    sc := bufio.NewScanner(r)
    for sc.Scan() {
        s.Lines++
        e, err := p.Parse(sc.Text())
        if err != nil {
            s.Bad++
            continue
        }
        s.Add(e)
    }
    return s, sc.Err()
}

// Add zählt e. Pointer-Receiver, weil Add den Summary verändert.
func (s *Summary) Add(e Entry) {
    s.Bytes += e.Bytes
    s.ByStatus[e.Status]++
    s.ByPath[e.Path]++
    if s.First.IsZero() || e.Time.Before(s.First) {
        s.First = e.Time
    }
    if e.Time.After(s.Last) {
        s.Last = e.Time
    }
}

// Requests ist die Zahl der lesbaren Zeilen.
func (s *Summary) Requests() int { return s.Lines - s.Bad }

// ErrorRate liefert den Anteil der 5xx-Antworten in Prozent.
func (s *Summary) ErrorRate() float64 {
    if s.Requests() == 0 {
        return 0
    }
    n := 0
    for code, k := range s.ByStatus {
        if code >= 500 {
            n += k
        }
    }
    return 100 * float64(n) / float64(s.Requests())
}

// TopPaths liefert die n häufigsten Pfade.
func (s *Summary) TopPaths(n int) []PathCount {
    list := make([]PathCount, 0, len(s.ByPath))
    for p, k := range s.ByPath {
        list = append(list, PathCount{p, k})
    }
    slices.SortFunc(list, func(a, b PathCount) int {
        return cmp.Or(cmp.Compare(b.N, a.N), cmp.Compare(a.Path, b.Path))
    })
    return list[:min(n, len(list))]
}

// Report schreibt eine Übersicht nach w – Terminal, Datei oder Puffer.
func (s *Summary) Report(w io.Writer, top int) error {
    var b strings.Builder // sammeln, dann einmal schreiben
    fmt.Fprintf(&b, "Requests:   %d (%d Zeilen unlesbar)\n", s.Requests(), s.Bad)
    if s.Requests() > 0 {
        const layout = "2006-01-02 15:04:05"
        fmt.Fprintf(&b, "Zeitraum:   %s bis %s\n",
            s.First.Format(layout), s.Last.Format(layout))
        fmt.Fprintf(&b, "Bytes:      %d\n", s.Bytes)
        b.WriteString("Status:    ")
        for _, class := range []int{1, 2, 3, 4, 5} {
            n := 0
            for code, k := range s.ByStatus {
                if code/100 == class {
                    n += k
                }
            }
            if n > 0 {
                fmt.Fprintf(&b, " %dxx=%d", class, n)
            }
        }
        fmt.Fprintf(&b, "\n5xx-Quote:  %.1f %%\n", s.ErrorRate())
        fmt.Fprintf(&b, "Top %d Pfade:\n", top)
        for _, pc := range s.TopPaths(top) {
            fmt.Fprintf(&b, "%8d  %s\n", pc.N, pc.Path)
        }
    }
    _, err := io.WriteString(w, b.String())
    return err
}
EOF
go vet ./...

Erwartet: keine Ausgabe.

Warum so?

Element Was es zeigt
NewSummary() Konstruktor-Konvention: Maps müssen mit make oder {} angelegt werden
func (s *Summary) Add Pointer-Receiver: ändert den Summary des Aufrufers
Read(r io.Reader, p Parser) nimmt zwei Interfaces – Datei, stdin, Test-String, jedes Format
Report(w io.Writer, …) error schreibt überallhin; Fehler beim Schreiben kommen zurück

cmp.Or nimmt den ersten Wert ungleich 0: erst nach Häufigkeit, bei Gleichstand nach Pfad. min ist seit Go 1.21 eingebaut.

Fortschritt speichern? Kostenlos registrieren

Drill 5: main – das Interface im Einsatz

cat > cmd/logsum/main.go <<'EOF'
// logsum fasst ein Zugriffslog zusammen: Status, Fehlerquote, Top-Pfade.
// Tag 2 aus "Go zum Anfassen".
package main

import (
    "flag"
    "fmt"
    "io"
    "os"

    "example.com/logsum/internal/logs"
)

func main() {
    format := flag.String("format", "combined", "Logformat: combined oder json")
    top := flag.Int("top", 3, "Anzahl der Top-Pfade")
    flag.Parse()

    // Das Interface macht die Formate austauschbar.
    parsers := map[string]logs.Parser{
        "combined": logs.Combined{},
        "json":     logs.JSON{},
    }
    p, ok := parsers[*format]
    if !ok {
        fmt.Fprintf(os.Stderr, "logsum: unbekanntes Format %q\n", *format)
        os.Exit(2)
    }

    var in io.Reader = os.Stdin
    if flag.NArg() > 0 {
        f, err := os.Open(flag.Arg(0))
        if err != nil {
            fmt.Fprintln(os.Stderr, "logsum:", err)
            os.Exit(1)
        }
        defer f.Close() //nolint:errcheck // nur gelesen
        in = f
    }

    s, err := logs.Read(in, p)
    if err != nil {
        fmt.Fprintln(os.Stderr, "logsum:", err)
        os.Exit(1)
    }
    if err := s.Report(os.Stdout, *top); err != nil {
        fmt.Fprintln(os.Stderr, "logsum:", err)
        os.Exit(1)
    }
}
EOF
go build -o bin/logsum ./cmd/logsum
./bin/logsum testdata/access.log

Erwartet:

Requests:   10 (1 Zeilen unlesbar)
Zeitraum:   2026-10-10 08:00:01 bis 2026-10-10 08:04:20
Bytes:      7104
Status:     2xx=5 3xx=1 4xx=2 5xx=2
5xx-Quote:  20.0 %
Top 3 Pfade:
       4  /api/orders
       2  /api/users
       1  /

Warum? main kennt nur logs.Parser – welcher konkrete Typ dahintersteckt, entscheidet die Map zur Laufzeit. var in io.Reader = os.Stdin wird bei Bedarf durch eine *os.File ersetzt; beide erfüllen io.Reader. Die kaputte Zeile landet in Bad statt das Tool abzubrechen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zweites Format, gleicher Code

./bin/logsum -format json -top 2 testdata/access.jsonl
cat testdata/access.log | ./bin/logsum -top 1 | tail -2
./bin/logsum -format xml; echo "exit=$?"

Erwartet:

Requests:   3 (1 Zeilen unlesbar)
Zeitraum:   2026-10-10 07:00:00 bis 2026-10-10 07:00:09
Bytes:      4
Status:     2xx=2 5xx=1
5xx-Quote:  33.3 %
Top 2 Pfade:
       2  /healthz
       1  /api/orders
Top 1 Pfade:
       4  /api/orders
logsum: unbekanntes Format "xml"
exit=2

Warum? Read, Summary und Report haben sich nicht geändert – nur der Parser. Genau dafür sind Interfaces da: Ein drittes Format (Traefik, CloudFront, Envoy) ist eine neue Datei mit einer Parse-Methode.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Sichtbarkeit testen

Was „exportiert” heißt, zeigt dir der Compiler am schnellsten. Ein Wegwerf-Programm im selben Modul:

mkdir -p cmd/probe
cat > cmd/probe/main.go <<'EOF'
package main

import (
    "fmt"

    "example.com/logsum/internal/logs"
)

func main() {
    var p logs.Parser = logs.JSON{}
    fmt.Printf("%T\n", p)
    fmt.Println(logs.combinedRe)
}
EOF
go build ./cmd/probe
perl -ni -e 'print unless /combinedRe/' cmd/probe/main.go
go run ./cmd/probe
rm -r cmd/probe

Erwartet:

# example.com/logsum/cmd/probe
cmd/probe/main.go:12:19: undefined: logs.combinedRe
logs.JSON

Warum? combinedRe ist kleingeschrieben und damit außerhalb von logs unsichtbar – so kann niemand die Regex von außen austauschen. %T zeigt den dynamischen Typ hinter einer Interface-Variable. Ein fremdes Modul könnte example.com/logsum/internal/logs gar nicht importieren: internal/ sperrt alles außerhalb von example.com/logsum aus.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

cd ~/go-lab/tag02-logsum
gofmt -l . && go vet ./... && ~/go-lab/bin/lint run ./...
go build -o bin/logsum ./cmd/logsum
./bin/logsum -h
./bin/logsum -top 2 testdata/access.log | grep -A2 Top

Erwartet:

0 issues.
Usage of ./bin/logsum:
  -format string
        Logformat: combined oder json (default "combined")
  -top int
        Anzahl der Top-Pfade (default 3)
Top 2 Pfade:
       4  /api/orders
       2  /api/users

Dein Modul:

tag02-logsum/
├── cmd/logsum/main.go        Flags, Datei/stdin, Parser wählen
├── internal/logs/
│   ├── entry.go              Entry, Parser
│   ├── combined.go           Parser für nginx/Apache
│   ├── json.go               Parser für JSON-Zeilen
│   └── summary.go            Summary, Read, Report
├── testdata/access.log, access.jsonl
└── go.mod

Tipp: logsum ist mit Regex und time.Parse bewusst einfach gehalten. An Tag 13 machst du es mit Benchmarks und pprof zehnmal schneller.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/go-lab/tag02-logsum
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Combined: 10 Requests" \
  "./bin/logsum testdata/access.log | grep -q '^Requests:   10 '"
check "JSON: 5xx-Quote 33.3 %" \
  "./bin/logsum -format json testdata/access.jsonl | grep -q '33.3 %'"
check "Exit 2 bei falschem Format" "./bin/logsum -format xml; test \$? -eq 2"
check "Paket dokumentiert" "go doc ./internal/logs | grep -q 'Package logs'"

Erwartet:

✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Combined: 10 Requests
✔ JSON: 5xx-Quote 33.3 %
✔ Exit 2 bei falschem Format
✔ Paket dokumentiert

Challenge

Ein Kollege „vereinfacht” Add auf einen Value-Receiver: func (s Summary) Add(e Entry). Der Code kompiliert, go vet schweigt. Sag voraus, welche Zeilen im Report falsch werden – und warum nicht alle.

Hinweis: Ein Value-Receiver bekommt eine Kopie des Structs. Was wird bei einer Map eigentlich kopiert?

Lösung

perl -pi -e 's/func \(s \*Summary\) Add/func (s Summary) Add/' internal/logs/summary.go
go vet ./... && go run ./cmd/logsum testdata/access.log | head -4
~/go-lab/bin/lint run ./... 2>&1 | grep -o 'SA4005: .*'
perl -pi -e 's/func \(s Summary\) Add/func (s *Summary) Add/' internal/logs/summary.go

Erwartet:

Requests:   10 (1 Zeilen unlesbar)
Zeitraum:   0001-01-01 00:00:00 bis 0001-01-01 00:00:00
Bytes:      0
Status:     2xx=5 3xx=1 4xx=2 5xx=2
SA4005: ineffective assignment to field Summary.Bytes (staticcheck)
SA4005: ineffective assignment to field Summary.First (staticcheck)
SA4005: ineffective assignment to field Summary.Last (staticcheck)

Bytes, First und Last landen in der Kopie und verschwinden mit ihr – deshalb Nullwerte (0001-01-01 ist der Nullwert von time.Time). Die Statuscodes stimmen trotzdem: Die Kopie enthält dieselbe Map-Referenz, also schreibt Add in dieselbe Map. Genau diese halbe Wirkung macht den Fehler so tückisch. go vet findet ihn nicht, staticcheck im Linter schon. Regel: Ändert eine Methode den Wert, bekommt sie einen Pointer-Receiver – und dann alle Methoden des Typs, damit es einheitlich bleibt.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • bufio.Scanner bricht bei Zeilen über 64 KB mit token too long ab – bei JSON-Logs mit Stacktraces realistisch. Abhilfe: sc.Buffer(make([]byte, 0, 1<<20), 10<<20).
  • Logs enthalten personenbezogene Daten (IP-Adressen, User-IDs). Auswertungen nur auf freigegebenen Daten, Ergebnisse ohne Roh-IPs weitergeben (DSGVO).
  • Paketschnitt: Ein Paket pro Verantwortung (logs, nicht utils oder common). internal/ schützt dich davor, dass andere Teams sich an halbfertige APIs koppeln.
  • Für echte Logpipelines gibt es Loki, Vector oder Fluent Bit – ein eigenes Tool lohnt sich für schnelle Analysen, Ad-hoc-Incidents und CI-Checks.