forked from mtusi2026/mtusi2026lab6
105 lines
3.0 KiB
Go
105 lines
3.0 KiB
Go
package fiber
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/google/uuid"
|
|
"go.uber.org/zap"
|
|
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab6/internal/admission"
|
|
)
|
|
|
|
// request assigns a request identifier, handles errors and logs the completed request.
|
|
func (ctrl *Controller) request(ctx *fiber.Ctx) error {
|
|
ctx.Set(headerRequestID, uuid.NewString())
|
|
ctx.Set("X-Instance-Id", ctrl.instanceID)
|
|
started := time.Now()
|
|
var finish func(error)
|
|
if ctrl.observer != nil {
|
|
parent := ctrl.observer.Extract(ctx.UserContext(), ctx.Get("traceparent"), ctx.Get("tracestate"))
|
|
observed, end := ctrl.observer.Start(parent, "http.request", "server")
|
|
ctx.SetUserContext(observed)
|
|
finish = end
|
|
}
|
|
ctrl.metrics.active.Inc()
|
|
defer ctrl.metrics.active.Dec()
|
|
err := ctx.Next()
|
|
if err != nil {
|
|
err = ctrl.handleErr(ctx, err)
|
|
}
|
|
ctrl.logRequest(ctx, time.Since(started))
|
|
if ctrl.observer != nil {
|
|
route := "unmatched"
|
|
if ctx.Route() != nil {
|
|
route = ctx.Route().Path
|
|
}
|
|
ctrl.observer.HTTP(ctx.UserContext(), ctx.Method(), route, ctx.Response().StatusCode(), time.Since(started), ctx.GetRespHeader(headerRequestID))
|
|
finish(err)
|
|
} else if ctx.Path() != "/metrics" {
|
|
ctrl.metrics.observe(ctx, time.Since(started))
|
|
}
|
|
return err
|
|
}
|
|
|
|
// logRequest logs request metadata without including message contents.
|
|
func (ctrl *Controller) logRequest(ctx *fiber.Ctx, elapsed time.Duration) {
|
|
route := "unmatched"
|
|
if ctx.Route() != nil {
|
|
route = ctx.Route().Path
|
|
}
|
|
ctrl.log.Info("http request",
|
|
zap.String("method", ctx.Method()),
|
|
zap.String("route", route),
|
|
zap.Int("status", ctx.Response().StatusCode()),
|
|
zap.String("request_id", ctx.GetRespHeader(headerRequestID)),
|
|
zap.Duration("duration", elapsed),
|
|
)
|
|
}
|
|
|
|
// admit reserves global budgets and bounds downstream request work.
|
|
func (ctrl *Controller) admit(ctx *fiber.Ctx) error {
|
|
if ctrl.stopping.Load() {
|
|
return errBusy
|
|
}
|
|
requestCtx, cancel := context.WithTimeout(ctx.UserContext(), ctrl.cfg.Timeout())
|
|
ctx.SetUserContext(requestCtx)
|
|
release, err := ctrl.admission.Enter(requestCtx, requestGroup(ctx), "")
|
|
if err != nil {
|
|
cancel()
|
|
return admissionError(ctx, err)
|
|
}
|
|
defer finishRequest(ctx, func() {
|
|
release()
|
|
cancel()
|
|
})
|
|
return ctx.Next()
|
|
}
|
|
|
|
// requireIdentity resolves the session before reserving per-user budgets.
|
|
func (ctrl *Controller) requireIdentity(ctx *fiber.Ctx) error {
|
|
user, err := ctrl.auth.Authenticate(ctx.UserContext(), bearer(ctx))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ctx.Locals(identityKey, user)
|
|
release, err := ctrl.admission.Enter(ctx.UserContext(), requestGroup(ctx), user)
|
|
if err != nil {
|
|
return admissionError(ctx, err)
|
|
}
|
|
defer finishRequest(ctx, release)
|
|
return ctx.Next()
|
|
}
|
|
|
|
// admissionError maps policy rejection and backend failure into HTTP-owned errors.
|
|
func admissionError(ctx *fiber.Ctx, err error) error {
|
|
ctx.Set(fiber.HeaderRetryAfter, strconv.Itoa(retryAfterSeconds))
|
|
if errors.Is(err, admission.ErrRate) {
|
|
return errRateLimited
|
|
}
|
|
return errBusy
|
|
}
|