Code Reviewer

Root Cause of Memory Spikes:

You're loading the full file into memory with image_data = file.read() before passing to Pillow. A 20MB RAW upload decodes to a ~100MB bitmap, allocating ~300MB per worker.

Fix — stream with Pillow's lazy loading:

from PIL import Image
import io

def resize_image(s3_key: str, width: int, height: int):
    obj = s3.get_object(Bucket=BUCKET, Key=s3_key)
    with Image.open(obj['Body']) as img:
        img.thumbnail((width, height), Image.LANCZOS)
        buf = io.BytesIO()
        img.save(buf, format=img.format or 'JPEG', optimize=True)
        buf.seek(0)
        s3.upload_fileobj(buf, BUCKET, f'resized/{s3_key}')

Other issues found:

• No @app.task(bind=True, max_retries=3) — transient S3 errors silently fail
• Missing autospec=True in test mocks — won't catch signature drift
• JPEG quality defaults to 75; make quality a task parameter for flexibility

Expected savings: ~85% memory reduction — Pillow decodes lazily, buffer holds only the resized output.

Data Race — Critical:

Your map[string]*RateLimiter is read and written from concurrent goroutines without synchronization. This is an undefined-behavior data race detectable with go test -race:

// UNSAFE
if rl, ok := limiters[ip]; ok { ... }
limiters[ip] = newLimiter()

Fix — use a sync.RWMutex:

var (
    mu       sync.RWMutex
    limiters = make(map[string]*rate.Limiter)
)

func getLimiter(ip string) *rate.Limiter {
    mu.RLock()
    rl, ok := limiters[ip]
    mu.RUnlock()
    if !ok {
        mu.Lock()
        rl = rate.NewLimiter(rate.Every(time.Minute/100), 100)
        limiters[ip] = rl
        mu.Unlock()
    }
    return rl
}

Memory leak: The limiter map grows unbounded — add a cleanup ticker every 5 minutes evicting entries where time.Since(lastSeen) > 10*time.Minute.

Auth bug: You're not checking err from jwt.ParseWithClaims before using claims — nil dereference panic on a malformed token.

Logging: Log X-Request-ID alongside IP for distributed tracing support.