Decorator Pattern — Optimize¶

package server

import "net/http"

var serveChain http.Handler

func init() {
    serveChain = Chain(apiHandler, Logging, Recover, Auth, Trace, Metrics)
}

func handle(w http.ResponseWriter, r *http.Request) {
    serveChain.ServeHTTP(w, r)
}

func RegisterRoutes(mux *http.ServeMux) {
    chain := Chain(apiHandler, Logging, Recover, Auth, Trace, Metrics)
    mux.Handle("/api", chain)
}

apiChain   := Chain(apiHandler,   Logging, Recover, Auth)
adminChain := Chain(adminHandler, Logging, Recover, Auth, AdminOnly)
mux.Handle("/api",   apiChain)
mux.Handle("/admin", adminChain)

// Instead of choosing Auth or NoAuth per request, use one Auth that no-ops
// when the route is whitelisted.
func Auth(skipPaths []string) Middleware {
    skipSet := make(map[string]struct{}, len(skipPaths))
    for _, p := range skipPaths { skipSet[p] = struct{}{} }
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if _, skip := skipSet[r.URL.Path]; skip {
                next.ServeHTTP(w, r)
                return
            }
            // ... real auth ...
        })
    }
}

package middleware

import (
    "log"
    "net/http"
    "time"
)

func LoggingLatency(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        // No defer — no closure allocation. log.Printf still allocates its
        // format buffer, but the middleware's contribution drops to zero.
        log.Printf("%s %s took %v", r.Method, r.URL.Path, time.Since(start))
    })
}

import "strconv"

func LoggingLatency(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        elapsed := time.Since(start)
        var buf [128]byte
        b := append(buf[:0], r.Method...)
        b = append(b, ' ')
        b = append(b, r.URL.Path...)
        b = append(b, " took "...)
        b = strconv.AppendInt(b, elapsed.Nanoseconds(), 10)
        b = append(b, "ns\n"...)
        os.Stderr.Write(b)
    })
}

// Capture only `start` (a uint64-sized time.Time on 64-bit platforms,
// which the compiler often keeps on stack).
start := time.Now()
defer logElapsed(start, r.Method, r.URL.Path)  // named function, no closure

if !log.Enabled() { next.ServeHTTP(w, r); return }

type FlatHandler struct {
    tracer    *Tracer
    metrics   *MetricsRecorder
    auth      *Authenticator
    authz     *Authorizer
    rateLimit *RateLimiter
    retry     *RetryConfig
    breaker   *CircuitBreaker
    terminal  http.Handler
}

func (h *FlatHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // Inline what each middleware did, in order. One interface dispatch (terminal).
    span := h.tracer.Start(r.Context(), r.URL.Path)
    defer span.End()

    if err := h.auth.Verify(r); err != nil {
        http.Error(w, "unauthorized", 401)
        return
    }
    if !h.rateLimit.Allow(r) {
        http.Error(w, "rate limited", 429)
        return
    }
    // ... etc ...
    h.terminal.ServeHTTP(w, r)
}

chain = Recovery(Tracing(Metrics(... terminalHandler)))

// Trust http.Server's built-in panic protection.
// http.Server logs the panic and aborts the connection automatically.

func Run(work func()) {
    for {
        runOnce(work)
    }
}

func runOnce(work func()) {
    defer func() {
        if rec := recover(); rec != nil {
            log.Printf("worker panic: %v", rec)
        }
    }()
    work()
}

type CachedRepo struct {
    Inner   Repo
    TTL     time.Duration

    mu      sync.RWMutex
    entries map[int]cacheEntry
}

func (c *CachedRepo) Get(ctx context.Context, id int) (User, error) {
    c.mu.RLock()
    e, ok := c.entries[id]
    c.mu.RUnlock()

    if ok && time.Now().Before(e.expires) {
        return e.user, nil
    }

    u, err := c.Inner.Get(ctx, id)
    if err != nil { return User{}, err }

    c.mu.Lock()
    c.entries[id] = cacheEntry{user: u, expires: time.Now().Add(c.TTL)}
    c.mu.Unlock()

    return u, nil
}

type CachedRepo struct {
    Inner   Repo
    TTL     time.Duration
    entries sync.Map // map[int]*cacheEntry
}

func (c *CachedRepo) Get(ctx context.Context, id int) (User, error) {
    if v, ok := c.entries.Load(id); ok {
        e := v.(*cacheEntry)
        if time.Now().Before(e.expires) {
            return e.user, nil
        }
    }

    u, err := c.Inner.Get(ctx, id)
    if err != nil { return User{}, err }

    c.entries.Store(id, &cacheEntry{user: u, expires: time.Now().Add(c.TTL)})
    return u, nil
}

import "golang.org/x/sync/singleflight"

type CachedRepo struct {
    Inner   Repo
    TTL     time.Duration
    entries sync.Map
    sf      singleflight.Group
}

func (c *CachedRepo) Get(ctx context.Context, id int) (User, error) {
    if v, ok := c.entries.Load(id); ok {
        e := v.(*cacheEntry)
        if time.Now().Before(e.expires) {
            return e.user, nil
        }
    }
    // Only one goroutine calls Inner.Get(id) at a time.
    key := strconv.Itoa(id)
    v, err, _ := c.sf.Do(key, func() (interface{}, error) {
        u, err := c.Inner.Get(ctx, id)
        if err != nil { return nil, err }
        c.entries.Store(id, &cacheEntry{user: u, expires: time.Now().Add(c.TTL)})
        return u, nil
    })
    if err != nil { return User{}, err }
    return v.(User), nil
}

package middleware

import (
    "context"
    "github.com/rs/zerolog"
)

type LoggingCharger struct {
    Inner  Charger
    Logger zerolog.Logger
}

func (l *LoggingCharger) Charge(ctx context.Context, userID int, action string, amount int) error {
    l.Logger.Info().
        Int("user", userID).
        Str("action", action).
        Int("amount", amount).
        Msg("started")

    err := l.Inner.Charge(ctx, userID, action, amount)
    if err != nil {
        l.Logger.Error().
            Int("user", userID).
            Str("action", action).
            Int("amount", amount).
            Err(err).
            Msg("failed")
        return err
    }

    l.Logger.Info().
        Int("user", userID).
        Str("action", action).
        Int("amount", amount).
        Msg("ok")
    return nil
}

import "log/slog"

logger := slog.New(slog.NewJSONHandler(os.Stderr, nil))

logger.Info("started",
    "user", userID,
    "action", action,
    "amount", amount)

reqLog := l.Logger.With().Int("user", userID).Str("action", action).Logger()
reqLog.Info().Msg("started")
// ... later
reqLog.Error().Err(err).Msg("failed")

if rand.Intn(1000) == 0 {
    l.Logger.Info().Int("user", userID).Msg("sampled")
}

package middleware

import (
    "net/http"
    "time"

    "github.com/prometheus/client_golang/prometheus"
)

var requestLatency = prometheus.NewHistogramVec(prometheus.HistogramOpts{
    Name:    "http_request_duration_seconds",
    Buckets: prometheus.DefBuckets,
}, []string{"method", "status"})

// Pre-resolved observers keyed by (method, status). The status is folded into
// buckets to keep the key space small: 2xx, 3xx, 4xx, 5xx.
var observers = map[string]prometheus.Observer{}

func init() {
    methods := []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}
    statusBuckets := []string{"2xx", "3xx", "4xx", "5xx"}
    for _, m := range methods {
        for _, s := range statusBuckets {
            observers[m+s] = requestLatency.WithLabelValues(m, s)
        }
    }
}

func statusBucket(code int) string {
    switch code / 100 {
    case 2: return "2xx"
    case 3: return "3xx"
    case 4: return "4xx"
    case 5: return "5xx"
    }
    return "unknown"
}

func Metrics(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sw := &sizingResponseWriter{ResponseWriter: w, status: 200}
        start := time.Now()
        next.ServeHTTP(sw, r)

        // O(1) map lookup, no string conversion of the status code.
        if obs, ok := observers[r.Method+statusBucket(sw.status)]; ok {
            obs.Observe(time.Since(start).Seconds())
        } else {
            // Cold path — uncommon method or status.
            requestLatency.WithLabelValues(r.Method, statusBucket(sw.status)).Observe(time.Since(start).Seconds())
        }
    })
}

// Lookup keyed by [method][bucket] (two-level map, no string alloc).
var observersByMethod = map[string]map[string]prometheus.Observer{}

func init() {
    methods := []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}
    statusBuckets := []string{"2xx", "3xx", "4xx", "5xx"}
    for _, m := range methods {
        observersByMethod[m] = map[string]prometheus.Observer{}
        for _, s := range statusBuckets {
            observersByMethod[m][s] = requestLatency.WithLabelValues(m, s)
        }
    }
}

func Metrics(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sw := &sizingResponseWriter{ResponseWriter: w, status: 200}
        start := time.Now()
        next.ServeHTTP(sw, r)
        if byStatus, ok := observersByMethod[r.Method]; ok {
            if obs, ok := byStatus[statusBucket(sw.status)]; ok {
                obs.Observe(time.Since(start).Seconds())
                return
            }
        }
        // Cold fallback.
    })
}

var swPool = sync.Pool{
    New: func() any { return &sizingResponseWriter{} },
}

func Metrics(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sw := swPool.Get().(*sizingResponseWriter)
        sw.ResponseWriter = w
        sw.status = 200
        defer swPool.Put(sw)

        start := time.Now()
        next.ServeHTTP(sw, r)
        // ... lookup and observe ...
    })
}

package middleware

import (
    "context"
    "errors"
    "sync/atomic"
    "time"
)

type RateLimit struct {
    Inner    Charger

    tokens   atomic.Int64  // current token count
    capacity int64
    rate     int64         // tokens per nanosecond × 1e9 — store as nano units
    lastNs   atomic.Int64  // last refill time, monotonic nanos
}

func NewRateLimit(inner Charger, capacity int64, ratePerSec int64) *RateLimit {
    r := &RateLimit{
        Inner:    inner,
        capacity: capacity,
        rate:     ratePerSec,
    }
    r.tokens.Store(capacity)
    r.lastNs.Store(time.Now().UnixNano())
    return r
}

func (r *RateLimit) Charge(ctx context.Context, amount int) error {
    nowNs := time.Now().UnixNano()
    lastNs := r.lastNs.Swap(nowNs)
    // Refill: tokens to add = rate * (now - last) / 1e9
    refill := r.rate * (nowNs - lastNs) / 1_000_000_000
    if refill > 0 {
        // Add refill, cap at capacity.
        for {
            cur := r.tokens.Load()
            next := cur + refill
            if next > r.capacity { next = r.capacity }
            if r.tokens.CompareAndSwap(cur, next) { break }
        }
    }
    // Take one token if available.
    for {
        cur := r.tokens.Load()
        if cur <= 0 { return ErrRateLimited }
        if r.tokens.CompareAndSwap(cur, cur-1) { break }
    }
    return r.Inner.Charge(ctx, amount)
}