fix(authn): correctly handle session-limited cookies

See CNOUS/mse#4347

Dockerfile

@@ -1,4 +1,4 @@
-FROM reg.cadoles.com/proxy_cache/library/golang:1.22 AS BUILD
+FROM reg.cadoles.com/proxy_cache/library/golang:1.23 AS BUILD
 
 RUN apt-get update \
     && apt-get install -y make

Makefile

@@ -17,8 +17,8 @@ GOTEST_ARGS ?= -short
 OPENWRT_DEVICE ?= 192.168.1.1
 
 SIEGE_URLS_FILE ?= misc/siege/urls.txt
-SIEGE_CONCURRENCY ?= 50
-SIEGE_DURATION ?= 1M
+SIEGE_CONCURRENCY ?= 200
+SIEGE_DURATION ?= 5M
 
 data/bootstrap.d/dummy.yml:
 	mkdir -p data/bootstrap.d

doc/fr/references/layers/rewriter.md

@@ -38,6 +38,33 @@ Supprimer un ou plusieurs entêtes HTTP dont le nom correspond au patron `patter
 
 Le patron est défini par une chaîne comprenant un ou plusieurs caractères `*`, signifiant un ou plusieurs caractères arbitraires.
 
+##### `get_cookie(ctx, name string) Cookie`
+
+Récupère un cookie depuis la requête/réponse (en fonction du contexte d'utilisation).
+Retourne `nil` si le cookie n'existe pas.
+
+**Cookie**
+
+```js
+// Plus d'informations sur https://pkg.go.dev/net/http#Cookie
+{
+  name: "string", // Nom du cookie
+  value: "string", // Valeur associée au cookie
+  path: "string", // Chemin associé au cookie (présent uniquement dans un contexte de réponse)
+  domain: "string", // Domaine associé au cookie (présent uniquement dans un contexte de réponse)
+  expires: "string", // Date d'expiration du cookie (présent uniquement dans un contexte de réponse)
+  max_age: "string", // Age maximum du cookie (présent uniquement dans un contexte de réponse)
+  secure: "boolean", // Le cookie doit-il être présent uniquement en HTTPS ? (présent uniquement dans un contexte de réponse)
+  http_only: "boolean", // Le cookie est il accessible en Javascript ? (présent uniquement dans un contexte de réponse)
+  same_site: "int" // Voir https://pkg.go.dev/net/http#SameSite (présent uniquement dans un contexte de réponse)
+}
+```
+
+##### `add_cookie(ctx, cookie Cookie)`
+
+Définit un cookie sur la requête/réponse (en fonction du contexte d'utilisation).
+Voir la méthode `get_cookie()` pour voir les attributs potentiels.
+
 #### Requête
 
 ##### `set_host(ctx, host string)`
@@ -48,6 +75,12 @@ Modifier la valeur de l'entête `Host` de la requête.
 
 Modifier l'URL du serveur cible.
 
+##### `redirect(ctx, statusCode int, url string)`
+
+Interrompt la requête et retourne une redirection HTTP au client.
+
+Le code HTTP utilisé doit être supérieur ou égale à `300` et inférieur à `400` (non inclus).
+
 #### Réponse
 
 _Pas de fonctions spécifiques._
@@ -72,7 +105,7 @@ L'URL originale, avant réécriture du `Host` par Bouncer.
     },
     host: "string", // Nom d'hôte (<domaine>:<port>) de l'URL
     path: "string", // Chemin de l'URL (format assaini)
-    rawPath: "string", // Chemin de l'URL (format brut)
+    raw_path: "string", // Chemin de l'URL (format brut)
     raw_query: "string", // Variables d'URL (format brut)
     fragment : "string", // Fragment d'URL (format assaini)
     raw_fragment : "string" // Fragment d'URL (format brut)
@@ -96,7 +129,7 @@ La requête en cours de traitement.
         },
         host: "string", // Nom d'hôte (<domaine>:<port>) de l'URL
         path: "string", // Chemin de l'URL (format assaini)
-        rawPath: "string", // Chemin de l'URL (format brut)
+        raw_path: "string", // Chemin de l'URL (format brut)
         raw_query: "string", // Variables d'URL (format brut)
         fragment : "string", // Fragment d'URL (format assaini)
         raw_fragment : "string" // Fragment d'URL (format brut)

go.mod

@@ -1,8 +1,8 @@
 module forge.cadoles.com/cadoles/bouncer
 
-go 1.22
+go 1.23
 
-toolchain go1.22.0
+toolchain go1.23.0
 
 require (
 	forge.cadoles.com/Cadoles/go-proxy v0.0.0-20240626132607-e1db6466a926

internal/admin/authz.go

@@ -70,7 +70,7 @@ func assertRequestUser(w http.ResponseWriter, r *http.Request) (auth.User, bool)
 	ctx := r.Context()
 	user, err := auth.CtxUser(ctx)
 	if err != nil {
-		logger.Error(ctx, "could not retrieve user", logger.E(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve user", logger.CapturedE(errors.WithStack(err)))
 
 		forbidden(w, r)
 

internal/admin/error.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/schema"
-	"github.com/getsentry/sentry-go"
 	"gitlab.com/wpetit/goweb/api"
 	"gitlab.com/wpetit/goweb/logger"
 )
@@ -29,11 +28,8 @@ func invalidDataErrorResponse(w http.ResponseWriter, r *http.Request, err *schem
 	}{
 		Message: message,
 	})
-
-	return
 }
 
 func logAndCaptureError(ctx context.Context, message string, err error) {
-	sentry.CaptureException(err)
-	logger.Error(ctx, message, logger.E(err))
+	logger.Error(ctx, message, logger.CapturedE(err))
 }

internal/admin/server.go

@@ -2,6 +2,7 @@ package admin
 
 import (
 	"context"
+	"expvar"
 	"fmt"
 	"log"
 	"net"
@@ -115,7 +116,9 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 		router.Use(middleware.RealIP)
 	}
 
+	router.Use(middleware.RequestID)
 	router.Use(middleware.RequestLogger(bouncerChi.NewLogFormatter()))
+	router.Use(middleware.Recoverer)
 
 	if s.serverConfig.Sentry.DSN != "" {
 		logger.Info(ctx, "enabling sentry http middleware")
@@ -162,7 +165,7 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 
 		router.Group(func(r chi.Router) {
 			if profiling.BasicAuth != nil {
-				logger.Info(ctx, "enabling authentication on metrics endpoint")
+				logger.Info(ctx, "enabling authentication on profiling endpoint")
 
 				r.Use(middleware.BasicAuth(
 					"profiling",
@@ -176,6 +179,7 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 				r.HandleFunc("/profile", pprof.Profile)
 				r.HandleFunc("/symbol", pprof.Symbol)
 				r.HandleFunc("/trace", pprof.Trace)
+				r.Handle("/vars", expvar.Handler())
 				r.HandleFunc("/{name}", func(w http.ResponseWriter, r *http.Request) {
 					name := chi.URLParam(r, "name")
 					pprof.Handler(name).ServeHTTP(w, r)

internal/auth/middleware.go

@@ -52,7 +52,7 @@ func Middleware(authenticators ...Authenticator) func(http.Handler) http.Handler
 			for _, auth := range authenticators {
 				user, err = auth.Authenticate(ctx, r)
 				if err != nil {
-					logger.Debug(ctx, "could not authenticate request", logger.E(errors.WithStack(err)))
+					logger.Debug(ctx, "could not authenticate request", logger.CapturedE(errors.WithStack(err)))
 
 					continue
 				}

internal/chi/log_formatter.go

@@ -2,7 +2,6 @@ package chi
 
 import (
 	"context"
-	"fmt"
 	"net/http"
 	"time"
 
@@ -37,12 +36,19 @@ type LogEntry struct {
 
 // Panic implements middleware.LogEntry
 func (e *LogEntry) Panic(v interface{}, stack []byte) {
-	logger.Error(e.ctx, fmt.Sprintf("%s %s", e.method, e.path), logger.F("stack", string(stack)))
+	logger.Error(
+		e.ctx, "http panic",
+		logger.F("stack", string(stack)),
+		logger.F("host", e.host),
+		logger.F("method", e.method),
+		logger.F("path", e.path),
+	)
 }
 
 // Write implements middleware.LogEntry
 func (e *LogEntry) Write(status int, bytes int, header http.Header, elapsed time.Duration, extra interface{}) {
-	logger.Info(e.ctx, fmt.Sprintf("%s %s - %d", e.method, e.path, status),
+	logger.Info(
+		e.ctx, "http request",
 		logger.F("host", e.host),
 		logger.F("status", status),
 		logger.F("bytes", bytes),

internal/command/server/dummy/run.go

@@ -53,7 +53,7 @@ func RunCommand() *cli.Command {
 				}
 
 				if err := tmpl.Execute(w, data); err != nil {
-					logger.Error(ctx.Context, "could not execute template", logger.E(errors.WithStack(err)))
+					logger.Error(ctx.Context, "could not execute template", logger.CapturedE(errors.WithStack(err)))
 				}
 			})
 

internal/config/redis.go

@@ -15,8 +15,16 @@ type RedisConfig struct {
 	WriteTimeout          InterpolatedDuration    `yaml:"writeTimeout"`
 	DialTimeout           InterpolatedDuration    `yaml:"dialTimeout"`
 	LockMaxRetries        InterpolatedInt         `yaml:"lockMaxRetries"`
+	RouteByLatency        InterpolatedBool        `yaml:"routeByLatency"`
+	ContextTimeoutEnabled InterpolatedBool        `yaml:"contextTimeoutEnabled"`
 	MaxRetries            InterpolatedInt         `yaml:"maxRetries"`
 	PingInterval          InterpolatedDuration    `yaml:"pingInterval"`
+	PoolSize              InterpolatedInt         `yaml:"poolSize"`
+	PoolTimeout           InterpolatedDuration    `yaml:"poolTimeout"`
+	MinIdleConns          InterpolatedInt         `yaml:"minIdleConns"`
+	MaxIdleConns          InterpolatedInt         `yaml:"maxIdleConns"`
+	ConnMaxIdleTime       InterpolatedDuration    `yaml:"connMaxIdleTime"`
+	ConnMaxLifetime       InterpolatedDuration    `yaml:"connMaxLifeTime"`
 }
 
 func NewDefaultRedisConfig() RedisConfig {
@@ -29,5 +37,7 @@ func NewDefaultRedisConfig() RedisConfig {
 		LockMaxRetries:        10,
 		MaxRetries:            3,
 		PingInterval:          InterpolatedDuration(30 * time.Second),
+		ContextTimeoutEnabled: true,
+		RouteByLatency:        true,
 	}
 }

internal/config/sentry.go

@@ -28,11 +28,11 @@ func NewDefaultSentryConfig() SentryConfig {
 		Debug:              false,
 		FlushTimeout:       NewInterpolatedDuration(2 * time.Second),
 		AttachStacktrace:   true,
-		SampleRate:         0.2,
-		EnableTracing:      true,
-		TracesSampleRate:   0.2,
-		ProfilesSampleRate: 0.2,
-		IgnoreErrors:       []string{},
+		SampleRate:         1,
+		EnableTracing:      false,
+		TracesSampleRate:   0.1,
+		ProfilesSampleRate: 0.1,
+		IgnoreErrors:       []string{"context canceled", "net/http: abort"},
 		SendDefaultPII:     false,
 		ServerName:         "",
 		Environment:        "",

internal/lock/redis/locker.go

@@ -38,7 +38,7 @@ func (l *Locker) WithLock(ctx context.Context, key string, timeout time.Duration
 
 		defer func() {
 			if err := lock.Release(ctx); err != nil {
-				logger.Error(ctx, "could not release lock", logger.E(errors.WithStack(err)))
+				logger.Error(ctx, "could not release lock", logger.CapturedE(errors.WithStack(err)))
 			}
 
 			logger.Debug(ctx, "lock released")

internal/lock/redis/retry.go

@@ -30,7 +30,7 @@ func retryWithBackoff(ctx context.Context, attempts int, fn func(ctx context.Con
 			return errors.Wrapf(err, "execution failed after %d attempts", attempts)
 		}
 
-		logger.Error(ctx, "error while executing func, retrying with backoff", logger.E(err), logger.F("backoffDelay", backoffDelay), logger.F("remainingAttempts", attempts-count))
+		logger.Error(ctx, "error while executing func, retrying with backoff", logger.CapturedE(err), logger.F("backoffDelay", backoffDelay), logger.F("remainingAttempts", attempts-count))
 
 		time.Sleep(backoffDelay)
 

internal/proxy/director/context.go

@@ -2,10 +2,12 @@ package director
 
 import (
 	"context"
+	"net/http"
 	"net/url"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
 	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
 )
 
 type contextKey string
@@ -14,6 +16,7 @@ const (
 	contextKeyProxy       contextKey = "proxy"
 	contextKeyLayers      contextKey = "layers"
 	contextKeyOriginalURL contextKey = "originalURL"
+	contextKeyHandleError contextKey = "handleError"
 )
 
 var (
@@ -60,3 +63,22 @@ func ctxValue[T any](ctx context.Context, key contextKey) (T, error) {
 
 	return value, nil
 }
+
+type HandleErrorFunc func(w http.ResponseWriter, r *http.Request, status int, err error)
+
+func withHandleError(ctx context.Context, fn HandleErrorFunc) context.Context {
+	return context.WithValue(ctx, contextKeyHandleError, fn)
+}
+
+func HandleError(ctx context.Context, w http.ResponseWriter, r *http.Request, status int, err error) {
+	err = errors.WithStack(err)
+
+	fn, ok := ctx.Value(contextKeyHandleError).(HandleErrorFunc)
+	if !ok {
+		logger.Error(ctx, err.Error(), logger.CapturedE(err))
+		http.Error(w, http.StatusText(status), status)
+		return
+	}
+
+	fn(w, r, status, err)
+}

internal/proxy/director/director.go

@@ -21,6 +21,8 @@ type Director struct {
 
 	proxyCache cache.Cache[string, []*store.Proxy]
 	layerCache cache.Cache[string, []*store.Layer]
+
+	handleError HandleErrorFunc
 }
 
 func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
@@ -32,7 +34,6 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 	}
 
 	url := getRequestURL(r)
-
 	ctx = withOriginalURL(ctx, url)
 	ctx = logger.With(ctx, logger.F("url", url.String()))
 
@@ -40,21 +41,11 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 
 	for _, p := range proxies {
 		for _, from := range p.From {
-			logger.Debug(
-				ctx, "matching request with proxy's from",
-				logger.F("from", from),
-			)
-
 			if matches := wildcard.Match(url.String(), from); !matches {
 				continue
 			}
 
-			logger.Debug(
-				ctx, "proxy's from matched",
-				logger.F("from", from),
-			)
-
-			ctx = logger.With(ctx,
+			proxyCtx := logger.With(ctx,
 				logger.F("proxy", p.Name),
 				logger.F("host", r.Host),
 				logger.F("remoteAddr", r.RemoteAddr),
@@ -62,7 +53,7 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 
 			metricProxyRequestsTotal.With(prometheus.Labels{metricLabelProxy: string(p.Name)}).Add(1)
 
-			proxyLayers, err := d.getLayers(ctx, p.Name)
+			proxyLayers, err := d.getLayers(proxyCtx, p.Name)
 			if err != nil {
 				return r, errors.WithStack(err)
 			}
@@ -82,8 +73,8 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 			r.URL.Scheme = toURL.Scheme
 			r.URL.Path = toURL.JoinPath(r.URL.Path).Path
 
-			ctx = withLayers(ctx, layers)
-			r = r.WithContext(ctx)
+			proxyCtx = withLayers(proxyCtx, layers)
+			r = r.WithContext(proxyCtx)
 
 			return r, nil
 		}
@@ -168,13 +159,14 @@ func (d *Director) getLayers(ctx context.Context, proxyName store.ProxyName) ([]
 func (d *Director) RequestTransformer() proxy.RequestTransformer {
 	return func(r *http.Request) {
 		ctx := r.Context()
+
 		layers, err := ctxLayers(ctx)
 		if err != nil {
 			if errors.Is(err, errContextKeyNotFound) {
 				return
 			}
 
-			logger.Error(ctx, "could not retrieve layers from context", logger.E(errors.WithStack(err)))
+			logger.Error(ctx, "could not retrieve layers from context", logger.CapturedE(errors.WithStack(err)))
 
 			return
 		}
@@ -224,15 +216,16 @@ func (d *Director) ResponseTransformer() proxy.ResponseTransformer {
 func (d *Director) Middleware() proxy.Middleware {
 	return func(next http.Handler) http.Handler {
 		fn := func(w http.ResponseWriter, r *http.Request) {
+			ctx := withHandleError(r.Context(), d.handleError)
+			r = r.WithContext(ctx)
+
 			r, err := d.rewriteRequest(r)
 			if err != nil {
-				logger.Error(r.Context(), "could not rewrite request", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not rewrite request"))
 				return
 			}
 
-			ctx := r.Context()
+			ctx = r.Context()
 
 			layers, err := ctxLayers(ctx)
 			if err != nil {
@@ -240,9 +233,7 @@ func (d *Director) Middleware() proxy.Middleware {
 					return
 				}
 
-				logger.Error(ctx, "could not retrieve proxy and layers from context", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not retrieve proxy and layers from context"))
 				return
 			}
 
@@ -276,5 +267,6 @@ func New(proxyRepository store.ProxyRepository, layerRepository store.LayerRepos
 		layerRegistry:   registry,
 		proxyCache:      opts.ProxyCache,
 		layerCache:      opts.LayerCache,
+		handleError:     opts.HandleError,
 	}
 }

internal/proxy/director/layer/authn/layer.go

@@ -1,13 +1,18 @@
 package authn
 
 import (
+	"bytes"
 	"html/template"
+	"io"
 	"net/http"
 	"path/filepath"
 
 	"forge.cadoles.com/Cadoles/go-proxy"
 	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
 	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
+	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director/layer/util"
+	"forge.cadoles.com/cadoles/bouncer/internal/rule"
+	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
 	"github.com/Masterminds/sprig/v3"
 	"github.com/pkg/errors"
@@ -19,6 +24,8 @@ type Layer struct {
 	auth      Authenticator
 	debug     bool
 
+	ruleEngineCache *util.RuleEngineCache[*Vars, *LayerOptions]
+
 	templateDir string
 }
 
@@ -29,9 +36,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options)
 			if err != nil {
-				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
 				return
 			}
 
@@ -42,7 +47,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 					}
 
 					err = errors.WithStack(err)
-					logger.Error(ctx, "could not execute pre-auth hook", logger.E(err))
+					logger.Error(ctx, "could not execute pre-auth hook", logger.CapturedE(err))
 					l.renderErrorPage(w, r, layer, options, err)
 
 					return
@@ -68,20 +73,20 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 				}
 
 				err = errors.WithStack(err)
-				logger.Error(ctx, "could not authenticate user", logger.E(err))
+				logger.Error(ctx, "could not authenticate user", logger.CapturedE(err))
 				l.renderErrorPage(w, r, layer, options, err)
 
 				return
 			}
 
-			if err := l.applyRules(ctx, r, options, user); err != nil {
+			if err := l.applyRules(ctx, r, layer, options, user); err != nil {
 				if errors.Is(err, ErrForbidden) {
 					l.renderForbiddenPage(w, r, layer, options, user)
 					return
 				}
 
 				err = errors.WithStack(err)
-				logger.Error(ctx, "could not apply rules", logger.E(err))
+				logger.Error(ctx, "could not apply rules", logger.CapturedE(err))
 				l.renderErrorPage(w, r, layer, options, err)
 
 				return
@@ -99,7 +104,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 					}
 
 					err = errors.WithStack(err)
-					logger.Error(ctx, "could not execute post-auth hook", logger.E(err))
+					logger.Error(ctx, "could not execute post-auth hook", logger.CapturedE(err))
 					l.renderErrorPage(w, r, layer, options, err)
 
 					return
@@ -162,20 +167,22 @@ func (l *Layer) renderPage(w http.ResponseWriter, r *http.Request, page string,
 
 	tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseGlob(pattern)
 	if err != nil {
-		logger.Error(ctx, "could not load authn templates", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not load authn templates"))
 		return
 	}
 
 	w.Header().Add("Cache-Control", "no-cache")
 
-	if err := tmpl.ExecuteTemplate(w, block, templateData); err != nil {
-		logger.Error(ctx, "could not render authn page", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+	var buf bytes.Buffer
 
+	if err := tmpl.ExecuteTemplate(w, block, templateData); err != nil {
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not render authn page"))
 		return
 	}
+
+	if _, err := io.Copy(w, &buf); err != nil {
+		logger.Error(ctx, "could not write authn page", logger.CapturedE(errors.WithStack(err)))
+	}
 }
 
 // LayerType implements director.MiddlewareLayer
@@ -187,6 +194,18 @@ func NewLayer(layerType store.LayerType, auth Authenticator, funcs ...OptionFunc
 	opts := NewOptions(funcs...)
 
 	return &Layer{
+		ruleEngineCache: util.NewInMemoryRuleEngineCache[*Vars, *LayerOptions](func(options *LayerOptions) (*rule.Engine[*Vars], error) {
+			engine, err := rule.NewEngine[*Vars](
+				rule.WithRules(options.Rules...),
+				rule.WithExpr(getAuthnAPI()...),
+				ruleHTTP.WithRequestFuncs(),
+			)
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			return engine, nil
+		}),
 		layerType:   layerType,
 		auth:        auth,
 		templateDir: opts.TemplateDir,

internal/proxy/director/layer/authn/layer_options.go

@@ -28,12 +28,13 @@ func DefaultLayerOptions() LayerOptions {
 	return LayerOptions{
 		MatchURLs: []string{"*"},
 		Rules: []string{
-			"del_headers('Remote-*')",
-			"set_header('Remote-User', user.subject)",
+			"del_headers(ctx, 'Remote-*')",
+			"set_header(ctx,'Remote-User', vars.user.subject)",
 			`map(
-				toPairs(user.attrs), {
+				toPairs(vars.user.attrs), {
 					let name = replace(lower(string(get(#, 0))), '_', '-');
 					set_header(
+						ctx,
 						'Remote-User-Attr-' + name, 
 						get(#, 1)
 					) 

internal/proxy/director/layer/authn/network/authenticator_test.go

@@ -39,6 +39,23 @@ func TestMatchAuthorizedCIDRs(t *testing.T) {
 			},
 			ExpectedResult: false,
 		},
+		{
+			RemoteHostPort: "192.168.1.15:43349",
+			AuthorizedCIDRs: []string{
+				"192.168.1.5/32",
+				"192.168.1.0/24",
+			},
+			ExpectedResult: true,
+		},
+		{
+			RemoteHostPort: "192.168.1.15:43349",
+			AuthorizedCIDRs: []string{
+				"192.168.1.5/32",
+				"192.168.1.6/32",
+				"192.168.1.7/32",
+			},
+			ExpectedResult: false,
+		},
 	}
 
 	auth := Authenticator{}

internal/proxy/director/layer/authn/oidc/authenticator.go

@@ -44,7 +44,7 @@ func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request
 
 	sess, err := a.store.Get(r, a.getCookieName(options.Cookie.Name, layer.Proxy, layer.Name))
 	if err != nil {
-		logger.Error(ctx, "could not retrieve session", logger.E(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve session", logger.CapturedE(errors.WithStack(err)))
 	}
 
 	loginCallbackURL, err := a.getLoginCallbackURL(originalURL, layer.Proxy, layer.Name, options)
@@ -86,7 +86,7 @@ func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request
 		if postLogoutRedirectURL != "" {
 			isAuthorized := slices.Contains(options.OIDC.PostLogoutRedirectURLs, postLogoutRedirectURL)
 			if !isAuthorized {
-				http.Error(w, "unauthorized post-logout redirect", http.StatusBadRequest)
+				director.HandleError(ctx, w, r, http.StatusBadRequest, errors.New("unauthorized post-logout redirect"))
 				return errors.WithStack(authn.ErrSkipRequest)
 			}
 		}
@@ -128,7 +128,7 @@ func (a *Authenticator) Authenticate(w http.ResponseWriter, r *http.Request, lay
 
 	defer func() {
 		if err := sess.Save(r, w); err != nil {
-			logger.Error(ctx, "could not save session", logger.E(errors.WithStack(err)))
+			logger.Error(ctx, "could not save session", logger.CapturedE(errors.WithStack(err)))
 		}
 	}()
 

internal/proxy/director/layer/authn/oidc/client.go

@@ -6,6 +6,7 @@ import (
 	"net/url"
 	"strings"
 
+	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
 	"github.com/coreos/go-oidc/v3/oidc"
 	"github.com/dchest/uniuri"
 	"github.com/gorilla/sessions"
@@ -68,8 +69,7 @@ func (c *Client) login(w http.ResponseWriter, r *http.Request, sess *sessions.Se
 	sess.Values[sessionKeyPostLoginRedirectURL] = postLoginRedirectURL
 
 	if err := sess.Save(r, w); err != nil {
-		logger.Error(ctx, "could not save session", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not save session"))
 
 		return
 	}
@@ -127,7 +127,7 @@ func (c *Client) HandleLogout(w http.ResponseWriter, r *http.Request, sess *sess
 
 	rawIDToken, err := c.getRawIDToken(sess)
 	if err != nil {
-		logger.Error(ctx, "could not retrieve raw id token", logger.E(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve raw id token", logger.CapturedE(errors.WithStack(err)))
 	}
 
 	sess.Values[sessionKeyIDToken] = nil

internal/proxy/director/layer/authn/rules.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"net/http"
 
-	"forge.cadoles.com/cadoles/bouncer/internal/rule"
 	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
+	"forge.cadoles.com/cadoles/bouncer/internal/store"
 	"github.com/expr-lang/expr"
 	"github.com/pkg/errors"
 )
@@ -14,17 +14,11 @@ type Vars struct {
 	User *User `expr:"user"`
 }
 
-func (l *Layer) applyRules(ctx context.Context, r *http.Request, options *LayerOptions, user *User) error {
-	rules := options.Rules
-	if len(rules) == 0 {
-		return nil
-	}
+func (l *Layer) applyRules(ctx context.Context, r *http.Request, layer *store.Layer, options *LayerOptions, user *User) error {
+	key := string(layer.Proxy) + "-" + string(layer.Name)
+	revisionedEngine := l.ruleEngineCache.Get(key)
 
-	engine, err := rule.NewEngine[*Vars](
-		rule.WithRules(options.Rules...),
-		rule.WithExpr(getAuthnAPI()...),
-		ruleHTTP.WithRequestFuncs(),
-	)
+	engine, err := revisionedEngine.Get(ctx, layer.Revision, options)
 	if err != nil {
 		return errors.WithStack(err)
 	}

internal/proxy/director/layer/queue/queue.go

@@ -1,9 +1,11 @@
 package queue
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"html/template"
+	"io"
 	"math/rand"
 	"net/http"
 	"path/filepath"
@@ -52,9 +54,7 @@ func (q *Queue) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options, q.defaultKeepAlive)
 			if err != nil {
-				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
 				return
 			}
 
@@ -71,7 +71,7 @@ func (q *Queue) Middleware(layer *store.Layer) proxy.Middleware {
 
 			cookie, err := r.Cookie(cookieName)
 			if err != nil && !errors.Is(err, http.ErrNoCookie) {
-				logger.Error(ctx, "could not retrieve cookie", logger.E(errors.WithStack(err)))
+				logger.Error(ctx, "could not retrieve cookie", logger.CapturedE(errors.WithStack(err)))
 			}
 
 			if cookie == nil {
@@ -89,9 +89,7 @@ func (q *Queue) Middleware(layer *store.Layer) proxy.Middleware {
 
 			rank, err := q.adapter.Touch(ctx, queueName, sessionID)
 			if err != nil {
-				logger.Error(ctx, "could not retrieve session rank", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not update queue session rank"))
 				return
 			}
 
@@ -126,7 +124,7 @@ func (q *Queue) updateSessionsMetric(ctx context.Context, proxyName store.ProxyN
 
 	status, err := q.adapter.Status(ctx, queueName)
 	if err != nil {
-		logger.Error(ctx, "could not retrieve queue status", logger.E(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve queue status", logger.CapturedE(errors.WithStack(err)))
 
 		return
 	}
@@ -144,9 +142,7 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 
 	status, err := q.adapter.Status(ctx, queueName)
 	if err != nil {
-		logger.Error(ctx, "could not retrieve queue status", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not retrieve queue status"))
 		return
 	}
 
@@ -157,7 +153,7 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 
 		tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseGlob(pattern)
 		if err != nil {
-			logger.Error(ctx, "could not load queue templates", logger.E(errors.WithStack(err)))
+			logger.Error(ctx, "could not load queue templates", logger.CapturedE(errors.WithStack(err)))
 
 			return
 		}
@@ -166,9 +162,7 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 	})
 
 	if q.tmpl == nil {
-		logger.Error(ctx, "queue page templates not loaded", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.New("queue page templates not loaded"))
 		return
 	}
 
@@ -194,12 +188,16 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 	w.Header().Add("Retry-After", strconv.FormatInt(int64(refreshRate.Seconds()), 10))
 	w.WriteHeader(http.StatusServiceUnavailable)
 
-	if err := q.tmpl.ExecuteTemplate(w, "queue", templateData); err != nil {
-		logger.Error(ctx, "could not render queue page", logger.E(errors.WithStack(err)))
-		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+	var buf bytes.Buffer
 
+	if err := q.tmpl.ExecuteTemplate(&buf, "queue", templateData); err != nil {
+		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not render queue page"))
 		return
 	}
+
+	if _, err := io.Copy(w, &buf); err != nil {
+		logger.Error(ctx, "could not write queue page", logger.CapturedE(errors.WithStack(err)))
+	}
 }
 
 func (q *Queue) refreshQueue(ctx context.Context, layerName store.LayerName, keepAlive time.Duration) {
@@ -211,7 +209,7 @@ func (q *Queue) refreshQueue(ctx context.Context, layerName store.LayerName, kee
 
 	if err := q.adapter.Refresh(ctx, string(layerName), keepAlive); err != nil {
 		logger.Error(ctx, "could not refresh queue",
-			logger.E(errors.WithStack(err)),
+			logger.CapturedE(errors.WithStack(err)),
 			logger.F("queue", layerName),
 		)
 	}

internal/proxy/director/layer/rewriter/api.go

@@ -0,0 +1,79 @@
+package rewriter
+
+import (
+	"context"
+	"fmt"
+
+	"forge.cadoles.com/cadoles/bouncer/internal/rule"
+	"github.com/expr-lang/expr"
+	"github.com/pkg/errors"
+)
+
+type errRedirect struct {
+	statusCode int
+	url        string
+}
+
+func (e *errRedirect) StatusCode() int {
+	return e.statusCode
+}
+
+func (e *errRedirect) URL() string {
+	return e.url
+}
+
+func (e *errRedirect) Error() string {
+	return fmt.Sprintf("redirect %d %s", e.statusCode, e.url)
+}
+
+func newErrRedirect(statusCode int, url string) *errRedirect {
+	return &errRedirect{
+		url:        url,
+		statusCode: statusCode,
+	}
+}
+
+var _ error = &errRedirect{}
+
+func redirectFunc() expr.Option {
+	return expr.Function(
+		"redirect",
+		func(params ...any) (any, error) {
+			_, err := rule.Assert[context.Context](params[0])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			statusCode, err := rule.Assert[int](params[1])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			if statusCode < 300 || statusCode >= 400 {
+				return nil, errors.Errorf("unexpected redirect status code '%d'", statusCode)
+			}
+
+			url, err := rule.Assert[string](params[2])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			return nil, newErrRedirect(statusCode, url)
+		},
+		new(func(context.Context, int, string) bool),
+	)
+}
+
+func WithRewriterFuncs() rule.OptionFunc {
+	return func(opts *rule.Options) {
+		funcs := []expr.Option{
+			redirectFunc(),
+		}
+
+		if len(opts.Expr) == 0 {
+			opts.Expr = make([]expr.Option, 0)
+		}
+
+		opts.Expr = append(opts.Expr, funcs...)
+	}
+}

internal/proxy/director/layer/rewriter/layer.go

@@ -11,14 +11,13 @@ import (
 	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
 	"github.com/pkg/errors"
-	"gitlab.com/wpetit/goweb/logger"
 )
 
 const LayerType store.LayerType = "rewriter"
 
 type Layer struct {
-	requestRuleEngine  *util.RevisionedRuleEngine[*RequestVars, *LayerOptions]
-	responseRuleEngine *util.RevisionedRuleEngine[*ResponseVars, *LayerOptions]
+	requestRuleEngineCache  *util.RuleEngineCache[*RequestVars, *LayerOptions]
+	responseRuleEngineCache *util.RuleEngineCache[*ResponseVars, *LayerOptions]
 }
 
 func (l *Layer) LayerType() store.LayerType {
@@ -32,9 +31,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options)
 			if err != nil {
-				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-
+				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
 				return
 			}
 
@@ -45,9 +42,14 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 				return
 			}
 
-			if err := l.applyRequestRules(ctx, r, layer.Revision, options); err != nil {
-				logger.Error(ctx, "could not apply request rules", logger.E(errors.WithStack(err)))
-				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			if err := l.applyRequestRules(ctx, r, layer, options); err != nil {
+				var redirect *errRedirect
+				if errors.As(err, &redirect) {
+					http.Redirect(w, r, redirect.URL(), redirect.StatusCode())
+					return
+				}
+
+				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not apply request rules"))
 
 				return
 			}
@@ -74,7 +76,7 @@ func (l *Layer) ResponseTransformer(layer *store.Layer) proxy.ResponseTransforme
 
 		ctx := r.Request.Context()
 
-		if err := l.applyResponseRules(ctx, r, layer.Revision, options); err != nil {
+		if err := l.applyResponseRules(ctx, r, layer, options); err != nil {
 			return errors.WithStack(err)
 		}
 
@@ -84,10 +86,11 @@ func (l *Layer) ResponseTransformer(layer *store.Layer) proxy.ResponseTransforme
 
 func New(funcs ...OptionFunc) *Layer {
 	return &Layer{
-		requestRuleEngine: util.NewRevisionedRuleEngine(func(options *LayerOptions) (*rule.Engine[*RequestVars], error) {
+		requestRuleEngineCache: util.NewInMemoryRuleEngineCache(func(options *LayerOptions) (*rule.Engine[*RequestVars], error) {
 			engine, err := rule.NewEngine[*RequestVars](
 				rule.WithRules(options.Rules.Request...),
 				ruleHTTP.WithRequestFuncs(),
+				WithRewriterFuncs(),
 			)
 			if err != nil {
 				return nil, errors.WithStack(err)
@@ -95,7 +98,7 @@ func New(funcs ...OptionFunc) *Layer {
 
 			return engine, nil
 		}),
-		responseRuleEngine: util.NewRevisionedRuleEngine(func(options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
+		responseRuleEngineCache: util.NewInMemoryRuleEngineCache(func(options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
 			engine, err := rule.NewEngine[*ResponseVars](
 				rule.WithRules(options.Rules.Response...),
 				ruleHTTP.WithResponseFuncs(),

internal/proxy/director/layer/rewriter/rules.go

@@ -3,10 +3,12 @@ package rewriter
 import (
 	"context"
 	"net/http"
+	"net/url"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
 	"forge.cadoles.com/cadoles/bouncer/internal/rule"
 	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
+	"forge.cadoles.com/cadoles/bouncer/internal/store"
 	"github.com/pkg/errors"
 )
 
@@ -27,6 +29,26 @@ type URLVar struct {
 	RawFragment string  `expr:"raw_fragment"`
 }
 
+func fromURL(url *url.URL) URLVar {
+	return URLVar{
+		Scheme: url.Scheme,
+		Opaque: url.Opaque,
+		User: UserVar{
+			Username: url.User.Username(),
+			Password: func() string {
+				passwd, _ := url.User.Password()
+				return passwd
+			}(),
+		},
+		Host:        url.Host,
+		Path:        url.Path,
+		RawPath:     url.RawPath,
+		RawQuery:    url.RawQuery,
+		Fragment:    url.Fragment,
+		RawFragment: url.RawFragment,
+	}
+}
+
 type UserVar struct {
 	Username string `expr:"username"`
 	Password string `expr:"password"`
@@ -48,59 +70,10 @@ type RequestVar struct {
 	RequestURI       string              `expr:"request_uri"`
 }
 
-func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layerRevision int, options *LayerOptions) error {
-	rules := options.Rules.Request
-	if len(rules) == 0 {
-		return nil
-	}
-
-	engine, err := l.getRequestRuleEngine(ctx, layerRevision, options)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-
-	originalURL, err := director.OriginalURL(ctx)
-	if err != nil {
-		return errors.WithStack(err)
-	}
-
-	vars := &RequestVars{
-		OriginalURL: URLVar{
-			Scheme: originalURL.Scheme,
-			Opaque: originalURL.Opaque,
-			User: UserVar{
-				Username: originalURL.User.Username(),
-				Password: func() string {
-					passwd, _ := originalURL.User.Password()
-					return passwd
-				}(),
-			},
-			Host:        originalURL.Host,
-			Path:        originalURL.Path,
-			RawPath:     originalURL.RawPath,
-			RawQuery:    originalURL.RawQuery,
-			Fragment:    originalURL.Fragment,
-			RawFragment: originalURL.RawFragment,
-		},
-		Request: RequestVar{
+func fromRequest(r *http.Request) RequestVar {
+	return RequestVar{
 		Method:           r.Method,
-			URL: URLVar{
-				Scheme: r.URL.Scheme,
-				Opaque: r.URL.Opaque,
-				User: UserVar{
-					Username: r.URL.User.Username(),
-					Password: func() string {
-						passwd, _ := r.URL.User.Password()
-						return passwd
-					}(),
-				},
-				Host:        r.URL.Host,
-				Path:        r.URL.Path,
-				RawPath:     r.URL.RawPath,
-				RawQuery:    r.URL.RawQuery,
-				Fragment:    r.URL.Fragment,
-				RawFragment: r.URL.RawFragment,
-			},
+		URL:              fromURL(r.URL),
 		RawURL:           r.URL.String(),
 		Proto:            r.Proto,
 		ProtoMajor:       r.ProtoMajor,
@@ -112,7 +85,28 @@ func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layerRev
 		Trailer:          r.Trailer,
 		RemoteAddr:       r.RemoteAddr,
 		RequestURI:       r.RequestURI,
-		},
+	}
+}
+
+func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layer *store.Layer, options *LayerOptions) error {
+	rules := options.Rules.Request
+	if len(rules) == 0 {
+		return nil
+	}
+
+	engine, err := l.getRequestRuleEngine(ctx, layer, options)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	originalURL, err := director.OriginalURL(ctx)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	vars := &RequestVars{
+		OriginalURL: fromURL(originalURL),
+		Request:     fromRequest(r),
 	}
 
 	ctx = ruleHTTP.WithRequest(ctx, r)
@@ -124,8 +118,11 @@ func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layerRev
 	return nil
 }
 
-func (l *Layer) getRequestRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*RequestVars], error) {
-	engine, err := l.requestRuleEngine.Get(ctx, layerRevision, options)
+func (l *Layer) getRequestRuleEngine(ctx context.Context, layer *store.Layer, options *LayerOptions) (*rule.Engine[*RequestVars], error) {
+	key := string(layer.Proxy) + "-" + string(layer.Name)
+	revisionedEngine := l.requestRuleEngineCache.Get(key)
+
+	engine, err := revisionedEngine.Get(ctx, layer.Revision, options)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -152,13 +149,13 @@ type ResponseVar struct {
 	Trailer          map[string][]string `expr:"trailer"`
 }
 
-func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerRevision int, options *LayerOptions) error {
+func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layer *store.Layer, options *LayerOptions) error {
 	rules := options.Rules.Response
 	if len(rules) == 0 {
 		return nil
 	}
 
-	engine, err := l.getResponseRuleEngine(ctx, layerRevision, options)
+	engine, err := l.getResponseRuleEngine(ctx, layer, options)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -169,54 +166,8 @@ func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerR
 	}
 
 	vars := &ResponseVars{
-		OriginalURL: URLVar{
-			Scheme: originalURL.Scheme,
-			Opaque: originalURL.Opaque,
-			User: UserVar{
-				Username: originalURL.User.Username(),
-				Password: func() string {
-					passwd, _ := originalURL.User.Password()
-					return passwd
-				}(),
-			},
-			Host:        originalURL.Host,
-			Path:        originalURL.Path,
-			RawPath:     originalURL.RawPath,
-			RawQuery:    originalURL.RawQuery,
-			Fragment:    originalURL.Fragment,
-			RawFragment: originalURL.RawFragment,
-		},
-		Request: RequestVar{
-			Method: r.Request.Method,
-			URL: URLVar{
-				Scheme: r.Request.URL.Scheme,
-				Opaque: r.Request.URL.Opaque,
-				User: UserVar{
-					Username: r.Request.URL.User.Username(),
-					Password: func() string {
-						passwd, _ := r.Request.URL.User.Password()
-						return passwd
-					}(),
-				},
-				Host:        r.Request.URL.Host,
-				Path:        r.Request.URL.Path,
-				RawPath:     r.Request.URL.RawPath,
-				RawQuery:    r.Request.URL.RawQuery,
-				Fragment:    r.Request.URL.Fragment,
-				RawFragment: r.Request.URL.RawFragment,
-			},
-			RawURL:           r.Request.URL.String(),
-			Proto:            r.Request.Proto,
-			ProtoMajor:       r.Request.ProtoMajor,
-			ProtoMinor:       r.Request.ProtoMinor,
-			Header:           r.Request.Header,
-			ContentLength:    r.Request.ContentLength,
-			TransferEncoding: r.Request.TransferEncoding,
-			Host:             r.Request.Host,
-			Trailer:          r.Request.Trailer,
-			RemoteAddr:       r.Request.RemoteAddr,
-			RequestURI:       r.Request.RequestURI,
-		},
+		OriginalURL: fromURL(originalURL),
+		Request:     fromRequest(r.Request),
 		Response: ResponseVar{
 			Proto:            r.Proto,
 			ProtoMajor:       r.ProtoMajor,
@@ -231,6 +182,7 @@ func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerR
 	}
 
 	ctx = ruleHTTP.WithResponse(ctx, r)
+	ctx = ruleHTTP.WithRequest(ctx, r.Request)
 
 	if _, err := engine.Apply(ctx, vars); err != nil {
 		return errors.WithStack(err)
@@ -239,8 +191,11 @@ func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerR
 	return nil
 }
 
-func (l *Layer) getResponseRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
-	engine, err := l.responseRuleEngine.Get(ctx, layerRevision, options)
+func (l *Layer) getResponseRuleEngine(ctx context.Context, layer *store.Layer, options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
+	key := string(layer.Proxy) + "-" + string(layer.Name)
+	revisionedEngine := l.responseRuleEngineCache.Get(key)
+
+	engine, err := revisionedEngine.Get(ctx, layer.Revision, options)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}

internal/proxy/director/layer/util/rule_engine_cache.go

@@ -0,0 +1,28 @@
+package util
+
+import (
+	"forge.cadoles.com/cadoles/bouncer/internal/cache"
+	"forge.cadoles.com/cadoles/bouncer/internal/cache/memory"
+)
+
+type RuleEngineCache[V any, O any] struct {
+	cache   cache.Cache[string, *RevisionedRuleEngine[V, O]]
+	factory RuleEngineFactoryFunc[V, O]
+}
+
+func (c *RuleEngineCache[V, O]) Get(key string) *RevisionedRuleEngine[V, O] {
+	revisionedRuleEngine, exists := c.cache.Get(key)
+	if !exists {
+		revisionedRuleEngine = NewRevisionedRuleEngine(c.factory)
+		c.cache.Set(key, revisionedRuleEngine)
+	}
+
+	return revisionedRuleEngine
+}
+
+func NewInMemoryRuleEngineCache[V any, O any](factory RuleEngineFactoryFunc[V, O]) *RuleEngineCache[V, O] {
+	return &RuleEngineCache[V, O]{
+		factory: factory,
+		cache:   memory.NewCache[string, *RevisionedRuleEngine[V, O]](),
+	}
+}

internal/proxy/director/options.go

@@ -1,18 +1,21 @@
 package director
 
 import (
+	"net/http"
 	"time"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/cache"
 	"forge.cadoles.com/cadoles/bouncer/internal/cache/memory"
 	"forge.cadoles.com/cadoles/bouncer/internal/cache/ttl"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
+	"gitlab.com/wpetit/goweb/logger"
 )
 
 type Options struct {
 	Layers      []Layer
 	ProxyCache  cache.Cache[string, []*store.Proxy]
 	LayerCache  cache.Cache[string, []*store.Layer]
+	HandleError HandleErrorFunc
 }
 
 type OptionFunc func(opts *Options)
@@ -30,6 +33,10 @@ func NewOptions(funcs ...OptionFunc) *Options {
 			memory.NewCache[string, time.Time](),
 			30*time.Second,
 		),
+		HandleError: func(w http.ResponseWriter, r *http.Request, status int, err error) {
+			logger.Error(r.Context(), err.Error(), logger.CapturedE(err))
+			http.Error(w, http.StatusText(status), status)
+		},
 	}
 
 	for _, fn := range funcs {
@@ -56,3 +63,9 @@ func WithLayerCache(cache cache.Cache[string, []*store.Layer]) OptionFunc {
 		opts.LayerCache = cache
 	}
 }
+
+func WithHandleErrorFunc(fn HandleErrorFunc) OptionFunc {
+	return func(opts *Options) {
+		opts.HandleError = fn
+	}
+}

internal/proxy/server.go

@@ -1,9 +1,12 @@
 package proxy
 
 import (
+	"bytes"
 	"context"
+	"expvar"
 	"fmt"
 	"html/template"
+	"io"
 	"log"
 	"net"
 	"net/http"
@@ -23,7 +26,6 @@ import (
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
 
 	"github.com/Masterminds/sprig/v3"
-	"github.com/getsentry/sentry-go"
 	sentryhttp "github.com/getsentry/sentry-go/http"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
@@ -110,13 +112,16 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 				s.directorCacheTTL,
 			),
 		),
+		director.WithHandleErrorFunc(s.handleError),
 	)
 
 	if s.serverConfig.HTTP.UseRealIP {
 		router.Use(middleware.RealIP)
 	}
 
+	router.Use(middleware.RequestID)
 	router.Use(middleware.RequestLogger(bouncerChi.NewLogFormatter()))
+	router.Use(middleware.Recoverer)
 
 	if s.serverConfig.Sentry.DSN != "" {
 		logger.Info(ctx, "enabling sentry http middleware")
@@ -153,7 +158,7 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 
 		router.Group(func(r chi.Router) {
 			if profiling.BasicAuth != nil {
-				logger.Info(ctx, "enabling authentication on metrics endpoint")
+				logger.Info(ctx, "enabling authentication on profiling endpoint")
 
 				r.Use(middleware.BasicAuth(
 					"profiling",
@@ -167,6 +172,7 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 				r.HandleFunc("/profile", pprof.Profile)
 				r.HandleFunc("/symbol", pprof.Symbol)
 				r.HandleFunc("/trace", pprof.Trace)
+				r.Handle("/vars", expvar.Handler())
 				r.HandleFunc("/{name}", func(w http.ResponseWriter, r *http.Request) {
 					name := chi.URLParam(r, "name")
 					pprof.Handler(name).ServeHTTP(w, r)
@@ -215,27 +221,29 @@ func (s *Server) createReverseProxy(ctx context.Context, target *url.URL) *httpu
 	httpTransport.DialContext = dialer.DialContext
 
 	reverseProxy.Transport = httpTransport
-	reverseProxy.ErrorHandler = s.handleError
+	reverseProxy.ErrorHandler = s.handleProxyError
 
 	return reverseProxy
 }
 
 func (s *Server) handleDefault(w http.ResponseWriter, r *http.Request) {
-	err := errors.Errorf("no proxy target found")
-
-	logger.Error(r.Context(), "proxy error", logger.E(err))
-	sentry.CaptureException(err)
-
-	s.renderErrorPage(w, r, err, http.StatusBadGateway, http.StatusText(http.StatusBadGateway))
+	s.handleError(w, r, http.StatusBadGateway, errors.Errorf("no proxy target found"))
 }
 
-func (s *Server) handleError(w http.ResponseWriter, r *http.Request, err error) {
+func (s *Server) handleError(w http.ResponseWriter, r *http.Request, status int, err error) {
 	err = errors.WithStack(err)
 
-	logger.Error(r.Context(), "proxy error", logger.E(err))
-	sentry.CaptureException(err)
+	if errors.Is(err, context.Canceled) {
+		logger.Warn(r.Context(), err.Error(), logger.E(err))
+	} else {
+		logger.Error(r.Context(), err.Error(), logger.CapturedE(err))
+	}
 
-	s.renderErrorPage(w, r, err, http.StatusBadGateway, http.StatusText(http.StatusBadGateway))
+	s.renderErrorPage(w, r, err, status, http.StatusText(status))
+}
+
+func (s *Server) handleProxyError(w http.ResponseWriter, r *http.Request, err error) {
+	s.handleError(w, r, http.StatusBadGateway, err)
 }
 
 func (s *Server) renderErrorPage(w http.ResponseWriter, r *http.Request, err error, statusCode int, status string) {
@@ -266,7 +274,7 @@ func (s *Server) renderPage(w http.ResponseWriter, r *http.Request, page string,
 
 	tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseGlob(pattern)
 	if err != nil {
-		logger.Error(ctx, "could not load proxy templates", logger.E(errors.WithStack(err)))
+		logger.Error(ctx, "could not load proxy templates", logger.CapturedE(errors.WithStack(err)))
 		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
 		return
@@ -286,12 +294,18 @@ func (s *Server) renderPage(w http.ResponseWriter, r *http.Request, page string,
 		return
 	}
 
-	if err := blockTmpl.Execute(w, templateData); err != nil {
-		logger.Error(ctx, "could not render proxy page", logger.E(errors.WithStack(err)))
+	var buf bytes.Buffer
+
+	if err := blockTmpl.Execute(&buf, templateData); err != nil {
+		logger.Error(ctx, "could not render proxy page", logger.CapturedE(errors.WithStack(err)))
 		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
 		return
 	}
+
+	if _, err := io.Copy(w, &buf); err != nil {
+		logger.Error(ctx, "could not write page", logger.CapturedE(errors.WithStack(err)))
+	}
 }
 
 func NewServer(funcs ...OptionFunc) *Server {

internal/rule/http/context.go

@@ -22,10 +22,10 @@ func WithResponse(ctx context.Context, r *http.Response) context.Context {
 	return context.WithValue(ctx, contextKeyResponse, r)
 }
 
-func ctxRequest(ctx context.Context) (*http.Request, bool) {
+func CtxRequest(ctx context.Context) (*http.Request, bool) {
 	return rule.Context[*http.Request](ctx, contextKeyRequest)
 }
 
-func ctxResponse(ctx context.Context) (*http.Response, bool) {
+func CtxResponse(ctx context.Context) (*http.Response, bool) {
 	return rule.Context[*http.Response](ctx, contextKeyResponse)
 }

internal/rule/http/option.go

@@ -13,6 +13,8 @@ func WithRequestFuncs() rule.OptionFunc {
 			addRequestHeaderFunc(),
 			delRequestHeadersFunc(),
 			setRequestHostFunc(),
+			getRequestCookieFunc(),
+			addRequestCookieFunc(),
 		}
 
 		if len(opts.Expr) == 0 {
@@ -29,6 +31,8 @@ func WithResponseFuncs() rule.OptionFunc {
 			setResponseHeaderFunc(),
 			addResponseHeaderFunc(),
 			delResponseHeadersFunc(),
+			addResponseCookieFunc(),
+			getResponseCookieFunc(),
 		}
 
 		if len(opts.Expr) == 0 {

internal/rule/http/request.go

@@ -3,6 +3,7 @@ package http
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"net/url"
 	"strconv"
 	"strings"
@@ -28,7 +29,7 @@ func setRequestHostFunc() expr.Option {
 				return nil, errors.WithStack(err)
 			}
 
-			r, ok := ctxRequest(ctx)
+			r, ok := CtxRequest(ctx)
 			if !ok {
 				return nil, errors.New("could not find http request in context")
 			}
@@ -60,7 +61,7 @@ func setRequestURLFunc() expr.Option {
 				return false, errors.WithStack(err)
 			}
 
-			r, ok := ctxRequest(ctx)
+			r, ok := CtxRequest(ctx)
 			if !ok {
 				return nil, errors.New("could not find http request in context")
 			}
@@ -89,7 +90,7 @@ func addRequestHeaderFunc() expr.Option {
 
 			value := formatValue(params[2])
 
-			r, ok := ctxRequest(ctx)
+			r, ok := CtxRequest(ctx)
 			if !ok {
 				return nil, errors.New("could not find http request in context")
 			}
@@ -118,7 +119,7 @@ func setRequestHeaderFunc() expr.Option {
 
 			value := formatValue(params[2])
 
-			r, ok := ctxRequest(ctx)
+			r, ok := CtxRequest(ctx)
 			if !ok {
 				return nil, errors.New("could not find http request in context")
 			}
@@ -145,7 +146,7 @@ func delRequestHeadersFunc() expr.Option {
 				return nil, errors.WithStack(err)
 			}
 
-			r, ok := ctxRequest(ctx)
+			r, ok := CtxRequest(ctx)
 			if !ok {
 				return nil, errors.New("could not find http request in context")
 			}
@@ -167,6 +168,145 @@ func delRequestHeadersFunc() expr.Option {
 	)
 }
 
+type CookieVar struct {
+	Name     string        `expr:"name"`
+	Value    string        `expr:"value"`
+	Path     string        `expr:"path"`
+	Domain   string        `expr:"domain"`
+	Expires  time.Time     `expr:"expires"`
+	MaxAge   int           `expr:"max_age"`
+	Secure   bool          `expr:"secure"`
+	HttpOnly bool          `expr:"http_only"`
+	SameSite http.SameSite `expr:"same_site"`
+}
+
+func getRequestCookieFunc() expr.Option {
+	return expr.Function(
+		"get_cookie",
+		func(params ...any) (any, error) {
+			ctx, err := rule.Assert[context.Context](params[0])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			name, err := rule.Assert[string](params[1])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			r, ok := CtxRequest(ctx)
+			if !ok {
+				return nil, errors.New("could not find http request in context")
+			}
+
+			cookie, err := r.Cookie(name)
+			if err != nil && !errors.Is(err, http.ErrNoCookie) {
+				return nil, errors.WithStack(err)
+			}
+
+			if cookie == nil {
+				return nil, nil
+			}
+
+			return CookieVar{
+				Name:     cookie.Name,
+				Value:    cookie.Value,
+				Path:     cookie.Path,
+				Domain:   cookie.Domain,
+				Expires:  cookie.Expires,
+				MaxAge:   cookie.MaxAge,
+				Secure:   cookie.Secure,
+				HttpOnly: cookie.HttpOnly,
+				SameSite: cookie.SameSite,
+			}, nil
+		},
+		new(func(context.Context, string) CookieVar),
+	)
+}
+
+func addRequestCookieFunc() expr.Option {
+	return expr.Function(
+		"add_cookie",
+		func(params ...any) (any, error) {
+			ctx, err := rule.Assert[context.Context](params[0])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			values, err := rule.Assert[map[string]any](params[1])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			cookie, err := cookieFrom(values)
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			r, ok := CtxRequest(ctx)
+			if !ok {
+				return nil, errors.New("could not find http request in context")
+			}
+
+			r.AddCookie(cookie)
+
+			return true, nil
+		},
+		new(func(context.Context, map[string]any) bool),
+	)
+}
+
+func cookieFrom(values map[string]any) (*http.Cookie, error) {
+	cookie := &http.Cookie{}
+
+	if name, ok := values["name"].(string); ok {
+		cookie.Name = name
+	}
+
+	if value, ok := values["value"].(string); ok {
+		cookie.Value = value
+	}
+
+	if domain, ok := values["domain"].(string); ok {
+		cookie.Domain = domain
+	}
+
+	if path, ok := values["path"].(string); ok {
+		cookie.Path = path
+	}
+
+	if httpOnly, ok := values["http_only"].(bool); ok {
+		cookie.HttpOnly = httpOnly
+	}
+
+	if maxAge, ok := values["max_age"].(int); ok {
+		cookie.MaxAge = maxAge
+	}
+
+	if secure, ok := values["secure"].(bool); ok {
+		cookie.Secure = secure
+	}
+
+	if sameSite, ok := values["same_site"].(http.SameSite); ok {
+		cookie.SameSite = sameSite
+	} else if sameSite, ok := values["same_site"].(int); ok {
+		cookie.SameSite = http.SameSite(sameSite)
+	}
+
+	if expires, ok := values["expires"].(time.Time); ok {
+		cookie.Expires = expires
+	} else if rawExpires, ok := values["expires"].(string); ok {
+		expires, err := time.Parse(http.TimeFormat, rawExpires)
+		if err != nil {
+			return nil, errors.WithStack(err)
+		}
+
+		cookie.Expires = expires
+	}
+
+	return cookie, nil
+}
+
 func formatValue(v any) string {
 	var value string
 	switch v := v.(type) {

internal/rule/http/request_test.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"testing"
 
@@ -185,6 +186,134 @@ func TestDelRequestHeaders(t *testing.T) {
 	}
 }
 
+func TestAddRequestCookie(t *testing.T) {
+	type TestCase struct {
+		Cookie     map[string]any
+		Check      func(t *testing.T, tc TestCase, req *http.Request)
+		ShouldFail bool
+	}
+
+	testCases := []TestCase{
+		{
+			Cookie: map[string]any{
+				"name": "test",
+			},
+			Check: func(t *testing.T, tc TestCase, req *http.Request) {
+				cookie, err := req.Cookie(tc.Cookie["name"].(string))
+				if err != nil {
+					t.Errorf("%+v", errors.WithStack(err))
+					return
+				}
+
+				if e, g := tc.Cookie["name"], cookie.Name; e != g {
+					t.Errorf("cookie.Name: expected '%v', got '%v'", e, g)
+				}
+			},
+		},
+		{
+			Cookie: map[string]any{
+				"name":  "foo",
+				"value": "test",
+			},
+			Check: func(t *testing.T, tc TestCase, req *http.Request) {
+				cookie, err := req.Cookie(tc.Cookie["name"].(string))
+				if err != nil {
+					t.Errorf("%+v", errors.WithStack(err))
+					return
+				}
+
+				if e, g := tc.Cookie["name"], cookie.Name; e != g {
+					t.Errorf("cookie.Name: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["value"], cookie.Value; e != g {
+					t.Errorf("cookie.Value: expected '%v', got '%v'", e, g)
+				}
+			},
+		},
+	}
+
+	for idx, tc := range testCases {
+		t.Run(fmt.Sprintf("Case_%d", idx), func(t *testing.T) {
+			type Vars struct {
+				NewCookie map[string]any `expr:"new_cookie"`
+			}
+
+			engine := createRuleEngine[Vars](t,
+				rule.WithExpr(addRequestCookieFunc()),
+				rule.WithRules(
+					`add_cookie(ctx, vars.new_cookie)`,
+				),
+			)
+
+			req, err := http.NewRequest("GET", "http://example.net", nil)
+			if err != nil {
+				t.Fatalf("%+v", errors.WithStack(err))
+			}
+
+			vars := Vars{
+				NewCookie: tc.Cookie,
+			}
+
+			ctx := context.Background()
+			ctx = WithRequest(ctx, req)
+
+			if _, err := engine.Apply(ctx, vars); err != nil {
+				t.Fatalf("%+v", errors.WithStack(err))
+			}
+
+			if tc.ShouldFail {
+				t.Error("engine.Apply() should have failed")
+			}
+
+			if tc.Check != nil {
+				tc.Check(t, tc, req)
+			}
+		})
+	}
+}
+
+func TestGetRequestCookie(t *testing.T) {
+	type Vars struct {
+		CookieName string `expr:"cookieName"`
+	}
+
+	engine := createRuleEngine[Vars](t,
+		rule.WithExpr(getRequestCookieFunc()),
+		rule.WithRules(
+			"let cookie = get_cookie(ctx, vars.cookieName); cookie.value",
+		),
+	)
+
+	req, err := http.NewRequest("GET", "http://example.net", nil)
+	if err != nil {
+		t.Fatalf("%+v", errors.WithStack(err))
+	}
+
+	vars := Vars{
+		CookieName: "foo",
+	}
+
+	cookie := &http.Cookie{
+		Name:  vars.CookieName,
+		Value: "bar",
+	}
+
+	req.AddCookie(cookie)
+
+	ctx := context.Background()
+	ctx = WithRequest(ctx, req)
+
+	results, err := engine.Apply(ctx, vars)
+	if err != nil {
+		t.Fatalf("%+v", errors.WithStack(err))
+	}
+
+	if e, g := cookie.Value, results[0]; e != g {
+		t.Errorf("result[0]: expected '%v', got '%v'", e, g)
+	}
+}
+
 func createRuleEngine[V any](t *testing.T, funcs ...rule.OptionFunc) *rule.Engine[V] {
 	engine, err := rule.NewEngine[V](funcs...)
 	if err != nil {

internal/rule/http/response.go

@@ -3,6 +3,7 @@ package http
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"strconv"
 	"strings"
 	"time"
@@ -41,7 +42,7 @@ func addResponseHeaderFunc() expr.Option {
 				value = fmt.Sprintf("%v", rawValue)
 			}
 
-			r, ok := ctxResponse(ctx)
+			r, ok := CtxResponse(ctx)
 			if !ok {
 				return nil, errors.New("could not find http response in context")
 			}
@@ -82,7 +83,7 @@ func setResponseHeaderFunc() expr.Option {
 				value = fmt.Sprintf("%v", rawValue)
 			}
 
-			r, ok := ctxResponse(ctx)
+			r, ok := CtxResponse(ctx)
 			if !ok {
 				return nil, errors.New("could not find http response in context")
 			}
@@ -109,7 +110,7 @@ func delResponseHeadersFunc() expr.Option {
 				return nil, errors.WithStack(err)
 			}
 
-			r, ok := ctxResponse(ctx)
+			r, ok := CtxResponse(ctx)
 			if !ok {
 				return nil, errors.New("could not find http response in context")
 			}
@@ -130,3 +131,84 @@ func delResponseHeadersFunc() expr.Option {
 		new(func(context.Context, string) bool),
 	)
 }
+
+func addResponseCookieFunc() expr.Option {
+	return expr.Function(
+		"add_cookie",
+		func(params ...any) (any, error) {
+			ctx, err := rule.Assert[context.Context](params[0])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			values, err := rule.Assert[map[string]any](params[1])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			cookie, err := cookieFrom(values)
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			r, ok := CtxResponse(ctx)
+			if !ok {
+				return nil, errors.New("could not find http request in context")
+			}
+
+			r.Header.Add("Set-Cookie", cookie.String())
+
+			return true, nil
+		},
+		new(func(context.Context, map[string]any) bool),
+	)
+}
+
+func getResponseCookieFunc() expr.Option {
+	return expr.Function(
+		"get_cookie",
+		func(params ...any) (any, error) {
+			ctx, err := rule.Assert[context.Context](params[0])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			name, err := rule.Assert[string](params[1])
+			if err != nil {
+				return nil, errors.WithStack(err)
+			}
+
+			res, ok := CtxResponse(ctx)
+			if !ok {
+				return nil, errors.New("could not find http response in context")
+			}
+
+			var cookie *http.Cookie
+			for _, c := range res.Cookies() {
+				if c.Name != name {
+					continue
+				}
+
+				cookie = c
+				break
+			}
+
+			if cookie == nil {
+				return nil, nil
+			}
+
+			return CookieVar{
+				Name:     cookie.Name,
+				Value:    cookie.Value,
+				Path:     cookie.Path,
+				Domain:   cookie.Domain,
+				Expires:  cookie.Expires,
+				MaxAge:   cookie.MaxAge,
+				Secure:   cookie.Secure,
+				HttpOnly: cookie.HttpOnly,
+				SameSite: cookie.SameSite,
+			}, nil
+		},
+		new(func(context.Context, string) CookieVar),
+	)
+}

internal/rule/http/response_test.go

@@ -2,9 +2,11 @@ package http
 
 import (
 	"context"
+	"fmt"
 	"io"
 	"net/http"
 	"testing"
+	"time"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/rule"
 	"github.com/pkg/errors"
@@ -124,6 +126,182 @@ func TestResponseDelHeaders(t *testing.T) {
 	}
 }
 
+func TestAddResponseCookie(t *testing.T) {
+	type TestCase struct {
+		Cookie     map[string]any
+		Check      func(t *testing.T, tc TestCase, res *http.Response)
+		ShouldFail bool
+	}
+
+	testCases := []TestCase{
+		{
+			Cookie: map[string]any{
+				"name":      "foo",
+				"value":     "test",
+				"domain":    "example.net",
+				"path":      "/custom",
+				"same_site": http.SameSiteStrictMode,
+				"http_only": true,
+				"secure":    false,
+				"expires":   time.Now().UTC().Truncate(time.Second),
+			},
+			Check: func(t *testing.T, tc TestCase, res *http.Response) {
+				var cookie *http.Cookie
+				for _, c := range res.Cookies() {
+					if c.Name == tc.Cookie["name"] {
+						cookie = c
+						break
+					}
+				}
+				if cookie == nil {
+					t.Errorf("could not find cookie '%s'", tc.Cookie["name"])
+					return
+				}
+
+				if e, g := tc.Cookie["name"], cookie.Name; e != g {
+					t.Errorf("cookie.Name: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["value"], cookie.Value; e != g {
+					t.Errorf("cookie.Value: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["domain"], cookie.Domain; e != g {
+					t.Errorf("cookie.Domain: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["path"], cookie.Path; e != g {
+					t.Errorf("cookie.Path: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["secure"], cookie.Secure; e != g {
+					t.Errorf("cookie.Secure: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["http_only"], cookie.HttpOnly; e != g {
+					t.Errorf("cookie.HttpOnly: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["same_site"], cookie.SameSite; e != g {
+					t.Errorf("cookie.SameSite: expected '%v', got '%v'", e, g)
+				}
+
+				if e, g := tc.Cookie["expires"], cookie.Expires; e != g {
+					t.Errorf("cookie.Expires: expected '%v', got '%v'", e, g)
+				}
+			},
+		},
+		{
+			Cookie: map[string]any{
+				"name":    "foo",
+				"expires": time.Now().UTC().Format(http.TimeFormat),
+			},
+			Check: func(t *testing.T, tc TestCase, res *http.Response) {
+				var cookie *http.Cookie
+				for _, c := range res.Cookies() {
+					if c.Name == tc.Cookie["name"] {
+						cookie = c
+						break
+					}
+				}
+				if cookie == nil {
+					t.Errorf("could not find cookie '%s'", tc.Cookie["name"])
+					return
+				}
+
+				if e, g := tc.Cookie["expires"], cookie.Expires.Format(http.TimeFormat); e != g {
+					t.Errorf("cookie.Expires: expected '%v', got '%v'", e, g)
+				}
+			},
+		},
+	}
+
+	for idx, tc := range testCases {
+		t.Run(fmt.Sprintf("Case_%d", idx), func(t *testing.T) {
+			type Vars struct {
+				NewCookie map[string]any `expr:"new_cookie"`
+			}
+
+			engine := createRuleEngine[Vars](t,
+				rule.WithExpr(addResponseCookieFunc()),
+				rule.WithRules(
+					`add_cookie(ctx, vars.new_cookie)`,
+				),
+			)
+
+			req, err := http.NewRequest("GET", "http://example.net", nil)
+			if err != nil {
+				t.Fatalf("%+v", errors.WithStack(err))
+			}
+
+			resp := createResponse(req, http.StatusOK, nil)
+
+			vars := Vars{
+				NewCookie: tc.Cookie,
+			}
+
+			ctx := context.Background()
+			ctx = WithRequest(ctx, req)
+			ctx = WithResponse(ctx, resp)
+
+			if _, err := engine.Apply(ctx, vars); err != nil {
+				t.Fatalf("%+v", errors.WithStack(err))
+			}
+
+			if tc.ShouldFail {
+				t.Error("engine.Apply() should have failed")
+			}
+
+			if tc.Check != nil {
+				tc.Check(t, tc, resp)
+			}
+		})
+	}
+}
+
+func TestGetResponseCookie(t *testing.T) {
+	type Vars struct {
+		CookieName string `expr:"cookieName"`
+	}
+
+	engine := createRuleEngine[Vars](t,
+		rule.WithExpr(getResponseCookieFunc()),
+		rule.WithRules(
+			"let cookie = get_cookie(ctx, vars.cookieName); cookie.value",
+		),
+	)
+
+	req, err := http.NewRequest("GET", "http://example.net", nil)
+	if err != nil {
+		t.Fatalf("%+v", errors.WithStack(err))
+	}
+
+	resp := createResponse(req, http.StatusOK, nil)
+
+	vars := Vars{
+		CookieName: "foo",
+	}
+
+	cookie := &http.Cookie{
+		Name:  vars.CookieName,
+		Value: "bar",
+	}
+
+	resp.Header.Add("Set-Cookie", cookie.String())
+
+	ctx := context.Background()
+	ctx = WithResponse(ctx, resp)
+
+	results, err := engine.Apply(ctx, vars)
+	if err != nil {
+		t.Fatalf("%+v", errors.WithStack(err))
+	}
+
+	if e, g := cookie.Value, results[0]; e != g {
+		t.Errorf("result[0]: expected '%v', got '%v'", e, g)
+	}
+}
+
 func createResponse(req *http.Request, statusCode int, body io.Reader) *http.Response {
 	return &http.Response{
 		Status:        http.StatusText(statusCode),

internal/session/store.go

@@ -75,7 +75,7 @@ func (s *Store) New(r *http.Request, name string) (*sessions.Session, error) {
 }
 
 func (s *Store) Save(r *http.Request, w http.ResponseWriter, session *sessions.Session) error {
-	if session.Options.MaxAge <= 0 {
+	if session.Options.MaxAge < 0 {
 		if err := s.delete(r.Context(), session); err != nil {
 			return errors.WithStack(err)
 		}

internal/setup/redis.go

@@ -38,9 +38,15 @@ func newRedisClient(conf config.RedisConfig) redis.UniversalClient {
 		ReadTimeout:           time.Duration(conf.ReadTimeout),
 		WriteTimeout:          time.Duration(conf.WriteTimeout),
 		DialTimeout:           time.Duration(conf.DialTimeout),
-		RouteByLatency:        true,
-		ContextTimeoutEnabled: true,
+		RouteByLatency:        bool(conf.RouteByLatency),
+		ContextTimeoutEnabled: bool(conf.ContextTimeoutEnabled),
 		MaxRetries:            int(conf.MaxRetries),
+		PoolSize:              int(conf.PoolSize),
+		PoolTimeout:           time.Duration(conf.PoolTimeout),
+		MinIdleConns:          int(conf.MinIdleConns),
+		MaxIdleConns:          int(conf.MaxIdleConns),
+		ConnMaxIdleTime:       time.Duration(conf.ConnMaxIdleTime),
+		ConnMaxLifetime:       time.Duration(conf.ConnMaxLifetime),
 	})
 
 	go func() {
@@ -56,7 +62,7 @@ func newRedisClient(conf config.RedisConfig) redis.UniversalClient {
 
 		for range timer.C {
 			if _, err := client.Ping(ctx).Result(); err != nil {
-				logger.Error(ctx, "redis disconnected", logger.E(errors.WithStack(err)))
+				logger.Error(ctx, "redis disconnected", logger.CapturedE(errors.WithStack(err)))
 				connected = false
 				continue
 			}

internal/setup/sentry.go

@@ -34,6 +34,10 @@ func SetupSentry(ctx context.Context, conf config.SentryConfig, release string)
 		return nil, errors.WithStack(err)
 	}
 
+	logger.SetCaptureFunc(func(err error) {
+		sentry.CaptureException(err)
+	})
+
 	flush := func() {
 		sentry.Flush(time.Duration(*conf.FlushTimeout))
 	}

internal/store/redis/helper.go

@@ -81,7 +81,7 @@ func WithRetry(ctx context.Context, client redis.UniversalClient, key string, fn
 	for attempt := 0; attempt < maxAttempts; attempt++ {
 		if err = WithTx(ctx, client, key, fn); err != nil {
 			err = errors.WithStack(err)
-			logger.Debug(ctx, "redis transaction failed", logger.E(err))
+			logger.Debug(ctx, "redis transaction failed", logger.CapturedE(err))
 
 			if errors.Is(err, redis.TxFailedErr) {
 				logger.Debug(ctx, "retrying redis transaction", logger.F("attempts", attempt), logger.F("delay", delay))
@@ -97,7 +97,7 @@ func WithRetry(ctx context.Context, client redis.UniversalClient, key string, fn
 		return nil
 	}
 
-	logger.Error(ctx, "redis error", logger.E(errors.WithStack(err)))
+	logger.Error(ctx, "redis error", logger.CapturedE(errors.WithStack(err)))
 
 	return errors.WithStack(redis.TxFailedErr)
 }

layers/authn/templates/error.gohtml

@@ -55,6 +55,8 @@
         border-radius: 5px;
         box-shadow: 2px 2px #cccccc1c;
         color: #810000 !important;
+        max-width: 80%;
+        overflow-x: hidden;
       }
 
       .title {
@@ -81,7 +83,7 @@
       <div id="card">
         <h2 class="title">Une erreur est survenue !</h2>
         {{ if .Debug }}
-        <pre>{{ .Err }}</pre>
+        <pre style="overflow-x: auto">{{ .Err }}</pre>
         {{ end }}
         {{/* if a public base url is provided, show navigation link */}}
         {{ $oidc := ( index .Layer.Options "oidc" ) }}

templates/error.gohtml

@@ -76,14 +76,26 @@
         margin-top: 2em;
         text-align: right;
       }
+
+      .stacktrace {
+        max-height: 250px;
+        overflow-y: auto;
+        background-color: #dca0a0;
+        padding: 0 10px;
+        border-radius: 5px;
+        margin-top: 10px;
+      }
     </style>
   </head>
   <body>
     <div id="container">
       <div id="card">
-        <h2 class="title">{{ $title }}</h2>
+        <h2 class="title">⚠ {{ $title }}</h2>
         {{ if .Debug }}
-        <pre>{{ .Err }}</pre>
+        <h3>Stack Trace</h3>
+        <div class="stacktrace">
+          <pre>{{ printf "%+v" .Err }}</pre>
+        </div>
         {{ end }}
         <p class="footer">
           Propulsé par