Problem Solving and Analytical Thinking Questions

#!/bin/bash
ENDPOINT=${1:-https://staging.api.local/cron-handler}
for f in payloads/*.json; do
  curl -s -H "X-Cron-Replay: true" -H "Trace-Id: replay-$(date +%s%N)" \
    -X POST -d @"$f" "$ENDPOINT"
  sleep 0.5
done

package ratelimit

import (
	"sync"
	"time"
)

type userWindow struct {
	mu      sync.Mutex
	buckets []int
	times   []int64 // bucket epoch seconds
	size    int
	cap     int // max requests per window
	window  int64 // window seconds (e.g., 60)
}

type RateLimiter struct {
	users sync.Map // map[string]*userWindow
	bucketSize int // e.g., 60
}

func NewRateLimiter(perMinute int) *RateLimiter {
	return &RateLimiter{bucketSize: 60, users: sync.Map{},}
}

// Allow returns true if request permitted for userID.
func (r *RateLimiter) Allow(userID string) bool {
	now := time.Now().Unix()
	v, _ := r.users.LoadOrStore(userID, &userWindow{
		buckets: make([]int, r.bucketSize),
		times:   make([]int64, r.bucketSize),
		size:    r.bucketSize,
		cap:     100, // configurable per user in real impl
		window:  int64(r.bucketSize),
	})
	u := v.(*userWindow)

	slot := int(now % int64(u.size))

	u.mu.Lock()
	defer u.mu.Unlock()

	// reset bucket if stale
	if u.times[slot] != now {
		u.buckets[slot] = 0
		u.times[slot] = now
	}
	// compute sum across window
	total := 0
	threshold := now - u.window + 1
	for i := 0; i < u.size; i++ {
		if u.times[i] >= threshold {
			total += u.buckets[i]
		}
	}
	if total >= u.cap {
		return false
	}
	u.buckets[slot]++
	return true
}