Files, streams and the io interfaces

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
    "slices"
    "strconv"
    "strings"
    "sync"
)

// A line looks like:
// 192.168.1.1 GET /api/users 200 134ms
type stats struct {
    requests int
    byStatus map[int]int
    byPath   map[string]int
    totalMS  int
    slowest  string
    sloweste int
}

func newStats() *stats {
    return &stats{byStatus: map[int]int{}, byPath: map[string]int{}}
}

// analyse takes an io.Reader, not a filename, so it is testable with a
// strings.Reader and works on stdin, a file or a network stream alike.
func analyse(r io.Reader) (*stats, error) {
    s := newStats()
    sc := bufio.NewScanner(r)
    sc.Buffer(make([]byte, 0, 256*1024), 256*1024)

    for sc.Scan() {
        f := strings.Fields(sc.Text())
        if len(f) < 5 {
            // skip malformed lines rather than failing
            continue
        }
        status, err := strconv.Atoi(f[3])
        if err != nil {
            continue
        }
        ms, err := strconv.Atoi(strings.TrimSuffix(f[4], "ms"))
        if err != nil {
            continue
        }

        s.requests++
        s.byStatus[status]++
        s.byPath[f[2]]++
        s.totalMS += ms
        if ms > s.sloweste {
            s.sloweste, s.slowest = ms, f[2]
        }
    }
    // The check that is always skipped and always matters.
    if err := sc.Err(); err != nil {
        return nil, fmt.Errorf("scanning: %w", err)
    }
    return s, nil
}

func (s *stats) merge(o *stats) {
    s.requests += o.requests
    s.totalMS += o.totalMS
    for k, v := range o.byStatus {
        s.byStatus[k] += v
    }
    for k, v := range o.byPath {
        s.byPath[k] += v
    }
    if o.sloweste > s.sloweste {
        s.sloweste, s.slowest = o.sloweste, o.slowest
    }
}

func main() {
    top := flag.Int("top", 5, "how many paths to show")
    flag.Parse()

    paths := flag.Args()
    if len(paths) == 0 {
        // No files given: read standard input, so the tool pipes.
        s, err := analyse(os.Stdin)
        if err != nil {
            fail(err)
        }
        report(s, *top)
        return
    }

    // One goroutine per file, each with its own stats to avoid any
    // shared
    // state, merged at the end under a mutex.
    total := newStats()
    var mu sync.Mutex
    var wg sync.WaitGroup
    var failed int

    for _, p := range paths {
        wg.Go(func() {
            f, err := os.Open(p)
            if err != nil {
                mu.Lock()
                failed++
                mu.Unlock()
                fmt.Fprintf(os.Stderr, "skipping %s: %v\n", p, err)
                return
            }
            defer f.Close()

            s, err := analyse(f)
            if err != nil {
                fmt.Fprintf(os.Stderr, "reading %s: %v\n", p, err)
                return
            }
            mu.Lock()
            total.merge(s)
            mu.Unlock()
        })
    }
    wg.Wait()

    report(total, *top)
    if failed > 0 {
        os.Exit(1)
    }
}

func report(s *stats, top int) {
    if s.requests == 0 {
        fmt.Println("no requests found")
        return
    }
    fmt.Printf("requests   %d\n", s.requests)
    fmt.Printf("average    %dms\n", s.totalMS/s.requests)
    fmt.Printf("slowest    %s (%dms)\n\n", s.slowest, s.sloweste)

    codes := make([]int, 0, len(s.byStatus))
    for c := range s.byStatus {
        codes = append(codes, c)
    }
    slices.Sort(codes)
    for _, c := range codes {
        fmt.Printf("  %d  %d\n", c, s.byStatus[c])
    }

    type pair struct {
        path string
        n    int
    }
    paths := make([]pair, 0, len(s.byPath))
    for p, n := range s.byPath {
        paths = append(paths, pair{p, n})
    }
    slices.SortFunc(paths, func(a, b pair) int { return b.n - a.n })

    fmt.Println()
    for _, p := range paths[:min(top, len(paths))] {
        fmt.Printf("  %-30s %d\n", p.path, p.n)
    }
}

func fail(err error) {
    fmt.Fprintln(os.Stderr, "loganalyse:", err)
    os.Exit(1)
}

cat > access.log <<'EOF'
1.1.1.1 GET /api/users 200 134ms
1.1.1.2 GET /api/users 200 89ms
1.1.1.3 POST /api/login 401 12ms
1.1.1.4 GET /api/reports 200 2400ms
EOF
go run . access.log
cat access.log | go run .