package middleware import ( "context" "crypto/rand" "encoding/base64" "fmt" "net/http" "os" "strings" "sync/atomic" ) // Key to use when setting the request ID. type ctxKeyRequestID int // RequestIDKey is the key that holds the unique request ID in a request context. const RequestIDKey ctxKeyRequestID = 0 var prefix string var reqid uint64 // A quick note on the statistics here: we're trying to calculate the chance that // two randomly generated base62 prefixes will collide. We use the formula from // http://en.wikipedia.org/wiki/Birthday_problem // // P[m, n] \approx 1 - e^{-m^2/2n} // // We ballpark an upper bound for $m$ by imagining (for whatever reason) a server // that restarts every second over 10 years, for $m = 86400 * 365 * 10 = 315360000$ // // For a $k$ character base-62 identifier, we have $n(k) = 62^k$ // // Plugging this in, we find $P[m, n(10)] \approx 5.75%$, which is good enough for // our purposes, and is surely more than anyone would ever need in practice -- a // process that is rebooted a handful of times a day for a hundred years has less // than a millionth of a percent chance of generating two colliding IDs. func init() { hostname, err := os.Hostname() if hostname == "" || err != nil { hostname = "localhost" } var buf [12]byte var b64 string for len(b64) < 10 { rand.Read(buf[:]) b64 = base64.StdEncoding.EncodeToString(buf[:]) b64 = strings.NewReplacer("+", "", "/", "").Replace(b64) } prefix = fmt.Sprintf("%s/%s", hostname, b64[0:10]) } // RequestID is a middleware that injects a request ID into the context of each // request. A request ID is a string of the form "host.example.com/random-0001", // where "random" is a base62 random string that uniquely identifies this go // process, and where the last number is an atomically incremented request // counter. func RequestID(next http.Handler) http.Handler { fn := func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() requestID := r.Header.Get("X-Request-Id") if requestID == "" { myid := atomic.AddUint64(&reqid, 1) requestID = fmt.Sprintf("%s-%06d", prefix, myid) } ctx = context.WithValue(ctx, RequestIDKey, requestID) next.ServeHTTP(w, r.WithContext(ctx)) } return http.HandlerFunc(fn) } // GetReqID returns a request ID from the given context if one is present. // Returns the empty string if a request ID cannot be found. func GetReqID(ctx context.Context) string { if ctx == nil { return "" } if reqID, ok := ctx.Value(RequestIDKey).(string); ok { return reqID } return "" } // NextRequestID generates the next request ID in the sequence. func NextRequestID() uint64 { return atomic.AddUint64(&reqid, 1) }