Dockerfile

@@ -1,4 +1,4 @@
-FROM reg.cadoles.com/proxy_cache/library/golang:1.24.2 AS build
+FROM reg.cadoles.com/proxy_cache/library/golang:1.22 AS BUILD
 
 RUN apt-get update \
     && apt-get install -y make
@@ -33,7 +33,7 @@ RUN /src/dist/bouncer_linux_amd64_v1/bouncer -c '' config dump > /src/dist/bounc
     && yq -i '.bootstrap.lockTimeout = "30s"' /src/dist/bouncer_linux_amd64_v1/config.yml \
     && yq -i '.integrations.kubernetes.lockTimeout = "30s"' /src/dist/bouncer_linux_amd64_v1/config.yml
 
-FROM reg.cadoles.com/proxy_cache/library/alpine:3.21 AS runtime
+FROM reg.cadoles.com/proxy_cache/library/alpine:3.20 AS RUNTIME
 
 RUN apk add --no-cache ca-certificates dumb-init
 
@@ -41,10 +41,10 @@ ENTRYPOINT ["/usr/bin/dumb-init", "--"]
 
 RUN mkdir -p /usr/local/bin /usr/share/bouncer/bin /etc/bouncer
 
-COPY --from=build /src/dist/bouncer_linux_amd64_v1/bouncer /usr/share/bouncer/bin/bouncer
+COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/bouncer /usr/share/bouncer/bin/bouncer
-COPY --from=build /src/layers /usr/share/bouncer/layers
+COPY --from=BUILD /src/layers /usr/share/bouncer/layers
-COPY --from=build /src/templates /usr/share/bouncer/templates
+COPY --from=BUILD /src/templates /usr/share/bouncer/templates
-COPY --from=build /src/dist/bouncer_linux_amd64_v1/config.yml /etc/bouncer/config.yml
+COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/config.yml /etc/bouncer/config.yml
 
 RUN ln -s /usr/share/bouncer/bin/bouncer /usr/local/bin/bouncer
 

Makefile

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

doc/fr/references/layers/rewriter.md

@@ -60,7 +60,7 @@ Retourne `nil` si le cookie n'existe pas.
 }
 ```
 
-##### `add_cookie(ctx, cookie Cookie)`
+##### `set_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.

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.CapturedE(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve user", logger.E(errors.WithStack(err)))
 
 		forbidden(w, r)
 

internal/admin/error.go

@@ -6,6 +6,7 @@ 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"
 )
@@ -28,8 +29,11 @@ func invalidDataErrorResponse(w http.ResponseWriter, r *http.Request, err *schem
 	}{
 		Message: message,
 	})
+
+	return
 }
 
 func logAndCaptureError(ctx context.Context, message string, err error) {
-	logger.Error(ctx, message, logger.CapturedE(err))
+	sentry.CaptureException(err)
+	logger.Error(ctx, message, logger.E(err))
 }

internal/admin/server.go

@@ -2,7 +2,6 @@ package admin
 
 import (
 	"context"
-	"expvar"
 	"fmt"
 	"log"
 	"net"
@@ -116,9 +115,7 @@ 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")
@@ -165,7 +162,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 profiling endpoint")
+				logger.Info(ctx, "enabling authentication on metrics endpoint")
 
 				r.Use(middleware.BasicAuth(
 					"profiling",
@@ -179,7 +176,6 @@ 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.CapturedE(errors.WithStack(err)))
+					logger.Debug(ctx, "could not authenticate request", logger.E(errors.WithStack(err)))
 
 					continue
 				}

internal/cache/cache.go

@@ -3,5 +3,4 @@ package cache
 type Cache[K comparable, V any] interface {
 	Get(key K) (V, bool)
 	Set(key K, value V)
-	Clear()
 }

internal/cache/memory/cache.go

@@ -25,10 +25,6 @@ func (c *Cache[K, V]) Set(key K, value V) {
 	c.store.Store(key, value)
 }
 
-func (c *Cache[K, V]) Clear() {
-	c.store.Clear()
-}
-
 func NewCache[K comparable, V any]() *Cache[K, V] {
 	return &Cache[K, V]{
 		store: new(sync.Map),

internal/cache/ttl/cache.go

@@ -28,11 +28,6 @@ func (c *Cache[K, V]) Set(key K, value V) {
 	c.values.Set(key, value)
 }
 
-func (c *Cache[K, V]) Clear() {
-	c.timestamps.Clear()
-	c.values.Clear()
-}
-
 func NewCache[K comparable, V any](values cache.Cache[K, V], timestamps cache.Cache[K, time.Time], ttl time.Duration) *Cache[K, V] {
 	return &Cache[K, V]{
 		values:     values,

internal/chi/log_formatter.go

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

internal/command/server/admin/run.go

@@ -12,8 +12,14 @@ import (
 	"gitlab.com/wpetit/goweb/logger"
 )
 
+const (
+	flagPrintDefaultToken = "print-default-token"
+)
+
 func RunCommand() *cli.Command {
-	flags := common.Flags()
+	flags := append(
+		common.Flags(),
+	)
 
 	return &cli.Command{
 		Name:  "run",
@@ -28,8 +34,6 @@ func RunCommand() *cli.Command {
 			logger.SetFormat(logger.Format(conf.Logger.Format))
 			logger.SetLevel(logger.Level(conf.Logger.Level))
 
-			logger.Debug(ctx.Context, "using config", logger.F("config", conf))
-
 			projectVersion := ctx.String("projectVersion")
 
 			if conf.Proxy.Sentry.DSN != "" {

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.CapturedE(errors.WithStack(err)))
+					logger.Error(ctx.Context, "could not execute template", logger.E(errors.WithStack(err)))
 				}
 			})
 

internal/command/server/proxy/run.go

@@ -29,8 +29,6 @@ func RunCommand() *cli.Command {
 			logger.SetFormat(logger.Format(conf.Logger.Format))
 			logger.SetLevel(logger.Level(conf.Logger.Level))
 
-			logger.Debug(ctx.Context, "using config", logger.F("config", conf))
-
 			projectVersion := ctx.String("projectVersion")
 
 			if conf.Proxy.Sentry.DSN != "" {
@@ -51,7 +49,7 @@ func RunCommand() *cli.Command {
 				proxy.WithServerConfig(conf.Proxy),
 				proxy.WithRedisConfig(conf.Redis),
 				proxy.WithDirectorLayers(layers...),
-				proxy.WithDirectorCacheTTL(time.Duration(*conf.Proxy.Cache.TTL)),
+				proxy.WithDirectorCacheTTL(time.Duration(conf.Proxy.Cache.TTL)),
 			)
 
 			addrs, srvErrs := srv.Start(ctx.Context)

internal/config/environment.go

@@ -19,7 +19,7 @@ func (is *InterpolatedString) UnmarshalYAML(value *yaml.Node) error {
 		return errors.WithStack(err)
 	}
 
-	str, err := envsubst.Eval(str, getEnv)
+	str, err := envsubst.EvalEnv(str)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -38,7 +38,7 @@ func (ii *InterpolatedInt) UnmarshalYAML(value *yaml.Node) error {
 		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
 	}
 
-	str, err := envsubst.Eval(str, getEnv)
+	str, err := envsubst.EvalEnv(str)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -62,7 +62,7 @@ func (ifl *InterpolatedFloat) UnmarshalYAML(value *yaml.Node) error {
 		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
 	}
 
-	str, err := envsubst.Eval(str, getEnv)
+	str, err := envsubst.EvalEnv(str)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -86,7 +86,7 @@ func (ib *InterpolatedBool) UnmarshalYAML(value *yaml.Node) error {
 		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
 	}
 
-	str, err := envsubst.Eval(str, getEnv)
+	str, err := envsubst.EvalEnv(str)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -101,10 +101,9 @@ func (ib *InterpolatedBool) UnmarshalYAML(value *yaml.Node) error {
 	return nil
 }
 
-var getEnv = os.Getenv
-
 type InterpolatedMap struct {
-	Data map[string]any
+	Data   map[string]any
+	getEnv func(string) string
 }
 
 func (im *InterpolatedMap) UnmarshalYAML(value *yaml.Node) error {
@@ -114,6 +113,10 @@ func (im *InterpolatedMap) UnmarshalYAML(value *yaml.Node) error {
 		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into map", value.Value, value.Line)
 	}
 
+	if im.getEnv == nil {
+		im.getEnv = os.Getenv
+	}
+
 	interpolated, err := im.interpolateRecursive(data)
 	if err != nil {
 		return errors.WithStack(err)
@@ -137,7 +140,7 @@ func (im InterpolatedMap) interpolateRecursive(data any) (any, error) {
 		}
 
 	case string:
-		value, err := envsubst.Eval(typ, getEnv)
+		value, err := envsubst.Eval(typ, im.getEnv)
 		if err != nil {
 			return nil, errors.WithStack(err)
 		}
@@ -168,7 +171,7 @@ func (iss *InterpolatedStringSlice) UnmarshalYAML(value *yaml.Node) error {
 	}
 
 	for index, value := range data {
-		value, err := envsubst.Eval(value, getEnv)
+		value, err := envsubst.EvalEnv(value)
 		if err != nil {
 			return errors.WithStack(err)
 		}
@@ -190,7 +193,7 @@ func (id *InterpolatedDuration) UnmarshalYAML(value *yaml.Node) error {
 		return errors.Wrapf(err, "could not decode value '%v' (line '%d') into string", value.Value, value.Line)
 	}
 
-	str, err := envsubst.Eval(str, getEnv)
+	str, err := envsubst.EvalEnv(str)
 	if err != nil {
 		return errors.WithStack(err)
 	}

internal/config/environment_test.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"testing"
-	"time"
 
 	"github.com/pkg/errors"
 	"gopkg.in/yaml.v3"
@@ -66,7 +65,7 @@ func TestInterpolatedMap(t *testing.T) {
 			var interpolatedMap InterpolatedMap
 
 			if tc.Env != nil {
-				getEnv = func(key string) string {
+				interpolatedMap.getEnv = func(key string) string {
 					return tc.Env[key]
 				}
 			}
@@ -81,54 +80,3 @@ func TestInterpolatedMap(t *testing.T) {
 		})
 	}
 }
-
-func TestInterpolatedDuration(t *testing.T) {
-	type testCase struct {
-		Path   string
-		Env    map[string]string
-		Assert func(t *testing.T, parsed *InterpolatedDuration)
-	}
-
-	testCases := []testCase{
-		{
-			Path: "testdata/environment/interpolated-duration.yml",
-			Env: map[string]string{
-				"MY_DURATION": "30s",
-			},
-			Assert: func(t *testing.T, parsed *InterpolatedDuration) {
-				if e, g := 30*time.Second, parsed; e != time.Duration(*g) {
-					t.Errorf("parsed: expected '%v', got '%v'", e, g)
-				}
-			},
-		},
-	}
-
-	for idx, tc := range testCases {
-		t.Run(fmt.Sprintf("Case #%d", idx), func(t *testing.T) {
-			data, err := os.ReadFile(tc.Path)
-			if err != nil {
-				t.Fatalf("%+v", errors.WithStack(err))
-			}
-
-			if tc.Env != nil {
-				getEnv = func(key string) string {
-					return tc.Env[key]
-				}
-			}
-
-			config := struct {
-				Duration *InterpolatedDuration `yaml:"duration"`
-			}{
-				Duration: NewInterpolatedDuration(-1),
-			}
-
-			if err := yaml.Unmarshal(data, &config); err != nil {
-				t.Fatalf("%+v", errors.WithStack(err))
-			}
-
-			if tc.Assert != nil {
-				tc.Assert(t, config.Duration)
-			}
-		})
-	}
-}

internal/config/layers.go

@@ -20,10 +20,6 @@ func NewDefaultLayersConfig() LayersConfig {
 					TransportConfig: NewDefaultTransportConfig(),
 					Timeout:         NewInterpolatedDuration(10 * time.Second),
 				},
-				ProviderCacheTimeout: NewInterpolatedDuration(time.Hour),
-			},
-			Sessions: AuthnLayerSessionConfig{
-				TTL: NewInterpolatedDuration(time.Hour),
 			},
 		},
 	}
@@ -35,19 +31,13 @@ type QueueLayerConfig struct {
 }
 
 type AuthnLayerConfig struct {
-	Debug       InterpolatedBool        `yaml:"debug"`
+	Debug       InterpolatedBool     `yaml:"debug"`
-	TemplateDir InterpolatedString      `yaml:"templateDir"`
+	TemplateDir InterpolatedString   `yaml:"templateDir"`
-	OIDC        AuthnOIDCLayerConfig    `yaml:"oidc"`
+	OIDC        AuthnOIDCLayerConfig `yaml:"oidc"`
-	Sessions    AuthnLayerSessionConfig `yaml:"sessions"`
-}
-
-type AuthnLayerSessionConfig struct {
-	TTL *InterpolatedDuration `yaml:"ttl"`
 }
 
 type AuthnOIDCLayerConfig struct {
-	HTTPClient           AuthnOIDCHTTPClientConfig `yaml:"httpClient"`
+	HTTPClient AuthnOIDCHTTPClientConfig `yaml:"httpClient"`
-	ProviderCacheTimeout *InterpolatedDuration     `yaml:"providerCacheTimeout"`
 }
 
 type AuthnOIDCHTTPClientConfig struct {

internal/config/proxy_server.go

@@ -113,12 +113,12 @@ func NewDefaultDialConfig() DialConfig {
 }
 
 type CacheConfig struct {
-	TTL *InterpolatedDuration `yaml:"ttl"`
+	TTL InterpolatedDuration `yaml:"ttl"`
 }
 
 func NewDefaultCacheConfig() CacheConfig {
 	return CacheConfig{
-		TTL: NewInterpolatedDuration(time.Second * 30),
+		TTL: *NewInterpolatedDuration(time.Second * 30),
 	}
 }
 

internal/config/redis.go

@@ -9,35 +9,25 @@ const (
 )
 
 type RedisConfig struct {
-	Adresses              InterpolatedStringSlice `yaml:"addresses"`
+	Adresses       InterpolatedStringSlice `yaml:"addresses"`
-	Master                InterpolatedString      `yaml:"master"`
+	Master         InterpolatedString      `yaml:"master"`
-	ReadTimeout           InterpolatedDuration    `yaml:"readTimeout"`
+	ReadTimeout    InterpolatedDuration    `yaml:"readTimeout"`
-	WriteTimeout          InterpolatedDuration    `yaml:"writeTimeout"`
+	WriteTimeout   InterpolatedDuration    `yaml:"writeTimeout"`
-	DialTimeout           InterpolatedDuration    `yaml:"dialTimeout"`
+	DialTimeout    InterpolatedDuration    `yaml:"dialTimeout"`
-	LockMaxRetries        InterpolatedInt         `yaml:"lockMaxRetries"`
+	LockMaxRetries InterpolatedInt         `yaml:"lockMaxRetries"`
-	RouteByLatency        InterpolatedBool        `yaml:"routeByLatency"`
+	MaxRetries     InterpolatedInt         `yaml:"maxRetries"`
-	ContextTimeoutEnabled InterpolatedBool        `yaml:"contextTimeoutEnabled"`
+	PingInterval   InterpolatedDuration    `yaml:"pingInterval"`
-	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 {
 	return RedisConfig{
-		Adresses:              InterpolatedStringSlice{"localhost:6379"},
+		Adresses:       InterpolatedStringSlice{"localhost:6379"},
-		Master:                "",
+		Master:         "",
-		ReadTimeout:           InterpolatedDuration(30 * time.Second),
+		ReadTimeout:    InterpolatedDuration(30 * time.Second),
-		WriteTimeout:          InterpolatedDuration(30 * time.Second),
+		WriteTimeout:   InterpolatedDuration(30 * time.Second),
-		DialTimeout:           InterpolatedDuration(30 * time.Second),
+		DialTimeout:    InterpolatedDuration(30 * time.Second),
-		LockMaxRetries:        10,
+		LockMaxRetries: 10,
-		MaxRetries:            3,
+		MaxRetries:     3,
-		PingInterval:          InterpolatedDuration(30 * time.Second),
+		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:         1,
+		SampleRate:         0.2,
-		EnableTracing:      false,
+		EnableTracing:      true,
-		TracesSampleRate:   0.1,
+		TracesSampleRate:   0.2,
-		ProfilesSampleRate: 0.1,
+		ProfilesSampleRate: 0.2,
-		IgnoreErrors:       []string{"context canceled", "net/http: abort"},
+		IgnoreErrors:       []string{},
 		SendDefaultPII:     false,
 		ServerName:         "",
 		Environment:        "",

internal/config/testdata/environment/interpolated-duration.yml

@@ -1 +0,0 @@
-duration: ${MY_DURATION}

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.CapturedE(errors.WithStack(err)))
+				logger.Error(ctx, "could not release lock", logger.E(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.CapturedE(err), logger.F("backoffDelay", backoffDelay), logger.F("remainingAttempts", attempts-count))
+		logger.Error(ctx, "error while executing func, retrying with backoff", logger.E(err), logger.F("backoffDelay", backoffDelay), logger.F("remainingAttempts", attempts-count))
 
 		time.Sleep(backoffDelay)
 

internal/proxy/director/context.go

@@ -2,13 +2,10 @@ package director
 
 import (
 	"context"
-	"net/http"
 	"net/url"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
-	"github.com/getsentry/sentry-go"
 	"github.com/pkg/errors"
-	"gitlab.com/wpetit/goweb/logger"
 )
 
 type contextKey string
@@ -17,8 +14,6 @@ const (
 	contextKeyProxy       contextKey = "proxy"
 	contextKeyLayers      contextKey = "layers"
 	contextKeyOriginalURL contextKey = "originalURL"
-	contextKeyHandleError contextKey = "handleError"
-	contextKeySentryScope contextKey = "sentryScope"
 )
 
 var (
@@ -65,35 +60,3 @@ 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)
-}
-
-func withSentryScope(ctx context.Context, scope *sentry.Scope) context.Context {
-	return context.WithValue(ctx, contextKeySentryScope, scope)
-}
-
-func SentryScope(ctx context.Context) (*sentry.Scope, error) {
-	scope, err := ctxValue[*sentry.Scope](ctx, contextKeySentryScope)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	return scope, nil
-}

internal/proxy/director/director.go

@@ -7,9 +7,8 @@ import (
 
 	"forge.cadoles.com/Cadoles/go-proxy"
 	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
+	"forge.cadoles.com/cadoles/bouncer/internal/cache"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
-	"forge.cadoles.com/cadoles/bouncer/internal/syncx"
-	"github.com/getsentry/sentry-go"
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"gitlab.com/wpetit/goweb/logger"
@@ -20,23 +19,20 @@ type Director struct {
 	layerRepository store.LayerRepository
 	layerRegistry   *LayerRegistry
 
-	cachedProxies *syncx.CachedResource[string, []*store.Proxy]
+	proxyCache cache.Cache[string, []*store.Proxy]
-	cachedLayers  *syncx.CachedResource[string, []*store.Layer]
+	layerCache cache.Cache[string, []*store.Layer]
-
-	handleError HandleErrorFunc
 }
 
-const proxiesCacheKey = "proxies"
-
 func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 	ctx := r.Context()
 
-	proxies, _, err := d.cachedProxies.Get(ctx, proxiesCacheKey)
+	proxies, err := d.getProxies(ctx)
 	if err != nil {
 		return r, errors.WithStack(err)
 	}
 
 	url := getRequestURL(r)
+
 	ctx = withOriginalURL(ctx, url)
 	ctx = logger.With(ctx, logger.F("url", url.String()))
 
@@ -44,11 +40,21 @@ 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
 			}
 
-			proxyCtx := logger.With(ctx,
+			logger.Debug(
+				ctx, "proxy's from matched",
+				logger.F("from", from),
+			)
+
+			ctx = logger.With(ctx,
 				logger.F("proxy", p.Name),
 				logger.F("host", r.Host),
 				logger.F("remoteAddr", r.RemoteAddr),
@@ -56,7 +62,7 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 
 			metricProxyRequestsTotal.With(prometheus.Labels{metricLabelProxy: string(p.Name)}).Add(1)
 
-			proxyLayers, _, err := d.cachedLayers.Get(proxyCtx, string(p.Name))
+			proxyLayers, err := d.getLayers(ctx, p.Name)
 			if err != nil {
 				return r, errors.WithStack(err)
 			}
@@ -76,16 +82,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
 
-			proxyCtx = withLayers(proxyCtx, layers)
+			ctx = withLayers(ctx, layers)
-			r = r.WithContext(proxyCtx)
+			r = r.WithContext(ctx)
-
-			if sentryScope, _ := SentryScope(ctx); sentryScope != nil {
-				sentryScope.SetTags(map[string]string{
-					"bouncer.proxy.name":        string(p.Name),
-					"bouncer.proxy.target.url":  r.URL.String(),
-					"bouncer.proxy.target.host": r.URL.Host,
-				})
-			}
 
 			return r, nil
 		}
@@ -97,8 +95,13 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 	return r, nil
 }
 
-func (d *Director) getProxies(ctx context.Context, key string) ([]*store.Proxy, error) {
+const proxiesCacheKey = "proxies"
-	logger.Debug(ctx, "querying fresh proxies")
+
+func (d *Director) getProxies(ctx context.Context) ([]*store.Proxy, error) {
+	proxies, exists := d.proxyCache.Get(proxiesCacheKey)
+	if exists {
+		return proxies, nil
+	}
 
 	headers, err := d.proxyRepository.QueryProxy(ctx, store.WithProxyQueryEnabled(true))
 	if err != nil {
@@ -107,7 +110,7 @@ func (d *Director) getProxies(ctx context.Context, key string) ([]*store.Proxy,
 
 	sort.Sort(store.ByProxyWeight(headers))
 
-	proxies := make([]*store.Proxy, 0, len(headers))
+	proxies = make([]*store.Proxy, 0, len(headers))
 
 	for _, h := range headers {
 		if !h.Enabled {
@@ -122,13 +125,18 @@ func (d *Director) getProxies(ctx context.Context, key string) ([]*store.Proxy,
 		proxies = append(proxies, proxy)
 	}
 
+	d.proxyCache.Set(proxiesCacheKey, proxies)
+
 	return proxies, nil
 }
 
-func (d *Director) getLayers(ctx context.Context, rawProxyName string) ([]*store.Layer, error) {
+func (d *Director) getLayers(ctx context.Context, proxyName store.ProxyName) ([]*store.Layer, error) {
-	proxyName := store.ProxyName(rawProxyName)
+	cacheKey := "layers-" + string(proxyName)
 
-	logger.Debug(ctx, "querying fresh layers")
+	layers, exists := d.layerCache.Get(cacheKey)
+	if exists {
+		return layers, nil
+	}
 
 	headers, err := d.layerRepository.QueryLayers(ctx, proxyName, store.WithLayerQueryEnabled(true))
 	if err != nil {
@@ -137,7 +145,7 @@ func (d *Director) getLayers(ctx context.Context, rawProxyName string) ([]*store
 
 	sort.Sort(store.ByLayerWeight(headers))
 
-	layers := make([]*store.Layer, 0, len(headers))
+	layers = make([]*store.Layer, 0, len(headers))
 
 	for _, h := range headers {
 		if !h.Enabled {
@@ -152,20 +160,21 @@ func (d *Director) getLayers(ctx context.Context, rawProxyName string) ([]*store
 		layers = append(layers, layer)
 	}
 
+	d.layerCache.Set(cacheKey, layers)
+
 	return layers, nil
 }
 
 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.CapturedE(errors.WithStack(err)))
+			logger.Error(ctx, "could not retrieve layers from context", logger.E(errors.WithStack(err)))
 
 			return
 		}
@@ -215,43 +224,41 @@ 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) {
-			sentry.ConfigureScope(func(scope *sentry.Scope) {
+			r, err := d.rewriteRequest(r)
-				ctx := withHandleError(r.Context(), d.handleError)
+			if err != nil {
-				ctx = withSentryScope(ctx, scope)
+				logger.Error(r.Context(), "could not rewrite request", logger.E(errors.WithStack(err)))
-				r = r.WithContext(ctx)
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
-				r, err := d.rewriteRequest(r)
+				return
-				if err != nil {
+			}
-					HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not rewrite request"))
+
+			ctx := r.Context()
+
+			layers, err := ctxLayers(ctx)
+			if err != nil {
+				if errors.Is(err, errContextKeyNotFound) {
 					return
 				}
 
-				ctx = r.Context()
+				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)
 
-				layers, err := ctxLayers(ctx)
+				return
-				if err != nil {
+			}
-					if errors.Is(err, errContextKeyNotFound) {
-						return
-					}
 
-					HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not retrieve proxy and layers from context"))
+			httpMiddlewares := make([]proxy.Middleware, 0)
-					return
+			for _, layer := range layers {
+				middleware, ok := d.layerRegistry.GetMiddleware(layer.Type)
+				if !ok {
+					continue
 				}
 
-				httpMiddlewares := make([]proxy.Middleware, 0)
+				httpMiddlewares = append(httpMiddlewares, middleware.Middleware(layer))
-				for _, layer := range layers {
+			}
-					middleware, ok := d.layerRegistry.GetMiddleware(layer.Type)
-					if !ok {
-						continue
-					}
 
-					httpMiddlewares = append(httpMiddlewares, middleware.Middleware(layer))
+			handler := createMiddlewareChain(next, httpMiddlewares)
-				}
 
-				handler := createMiddlewareChain(next, httpMiddlewares)
+			handler.ServeHTTP(w, r)
-
-				handler.ServeHTTP(w, r)
-			})
 		}
 
 		return http.HandlerFunc(fn)
@@ -263,15 +270,11 @@ func New(proxyRepository store.ProxyRepository, layerRepository store.LayerRepos
 
 	registry := NewLayerRegistry(opts.Layers...)
 
-	director := &Director{
+	return &Director{
 		proxyRepository: proxyRepository,
 		layerRepository: layerRepository,
 		layerRegistry:   registry,
-		handleError:     opts.HandleError,
+		proxyCache:      opts.ProxyCache,
+		layerCache:      opts.LayerCache,
 	}
-
-	director.cachedProxies = syncx.NewCachedResource(opts.ProxyCache, director.getProxies)
-	director.cachedLayers = syncx.NewCachedResource(opts.LayerCache, director.getLayers)
-
-	return director
 }

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

@@ -1,18 +1,13 @@
 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"
@@ -24,8 +19,6 @@ type Layer struct {
 	auth      Authenticator
 	debug     bool
 
-	ruleEngineCache *util.RuleEngineCache[*Vars, *LayerOptions]
-
 	templateDir string
 }
 
@@ -36,7 +29,9 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options)
 			if err != nil {
-				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
+				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 				return
 			}
 
@@ -47,7 +42,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 					}
 
 					err = errors.WithStack(err)
-					logger.Error(ctx, "could not execute pre-auth hook", logger.CapturedE(err))
+					logger.Error(ctx, "could not execute pre-auth hook", logger.E(err))
 					l.renderErrorPage(w, r, layer, options, err)
 
 					return
@@ -73,20 +68,20 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 				}
 
 				err = errors.WithStack(err)
-				logger.Error(ctx, "could not authenticate user", logger.CapturedE(err))
+				logger.Error(ctx, "could not authenticate user", logger.E(err))
 				l.renderErrorPage(w, r, layer, options, err)
 
 				return
 			}
 
-			if err := l.applyRules(ctx, r, layer, options, user); err != nil {
+			if err := l.applyRules(ctx, r, 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.CapturedE(err))
+				logger.Error(ctx, "could not apply rules", logger.E(err))
 				l.renderErrorPage(w, r, layer, options, err)
 
 				return
@@ -104,7 +99,7 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 					}
 
 					err = errors.WithStack(err)
-					logger.Error(ctx, "could not execute post-auth hook", logger.CapturedE(err))
+					logger.Error(ctx, "could not execute post-auth hook", logger.E(err))
 					l.renderErrorPage(w, r, layer, options, err)
 
 					return
@@ -167,21 +162,19 @@ func (l *Layer) renderPage(w http.ResponseWriter, r *http.Request, page string,
 
 	tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseGlob(pattern)
 	if err != nil {
-		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not load authn templates"))
+		logger.Error(ctx, "could not load authn templates", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 		return
 	}
 
 	w.Header().Add("Cache-Control", "no-cache")
 
-	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"))
+		logger.Error(ctx, "could not render authn page", logger.E(errors.WithStack(err)))
-		return
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
-	}
 
-	if _, err := io.Copy(w, &buf); err != nil {
+		return
-		logger.Error(ctx, "could not write authn page", logger.CapturedE(errors.WithStack(err)))
 	}
 }
 
@@ -194,18 +187,6 @@ 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,13 +28,12 @@ func DefaultLayerOptions() LayerOptions {
 	return LayerOptions{
 		MatchURLs: []string{"*"},
 		Rules: []string{
-			"del_headers(ctx, 'Remote-*')",
+			"del_headers('Remote-*')",
-			"set_header(ctx,'Remote-User', vars.user.subject)",
+			"set_header('Remote-User', user.subject)",
 			`map(
-				toPairs(vars.user.attrs), {
+				toPairs(user.attrs), {
 					let name = replace(lower(string(get(#, 0))), '_', '-');
 					set_header(
-						ctx,
 						'Remote-User-Attr-' + name, 
 						get(#, 1)
 					) 

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

@@ -13,12 +13,9 @@ import (
 	"time"
 
 	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
-	"forge.cadoles.com/cadoles/bouncer/internal/cache/memory"
-	"forge.cadoles.com/cadoles/bouncer/internal/cache/ttl"
 	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
 	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director/layer/authn"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
-	"forge.cadoles.com/cadoles/bouncer/internal/syncx"
 	"github.com/coreos/go-oidc/v3/oidc"
 	"github.com/gorilla/sessions"
 	"github.com/pkg/errors"
@@ -27,10 +24,9 @@ import (
 )
 
 type Authenticator struct {
-	store              sessions.Store
+	store             sessions.Store
-	httpTransport      *http.Transport
+	httpTransport     *http.Transport
-	httpClientTimeout  time.Duration
+	httpClientTimeout time.Duration
-	cachedOIDCProvider *syncx.CachedResource[string, *oidc.Provider]
 }
 
 func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request, layer *store.Layer) error {
@@ -48,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.CapturedE(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve session", logger.E(errors.WithStack(err)))
 	}
 
 	loginCallbackURL, err := a.getLoginCallbackURL(originalURL, layer.Proxy, layer.Name, options)
@@ -56,7 +52,7 @@ func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request
 		return errors.WithStack(err)
 	}
 
-	client, err := a.getClient(ctx, options, loginCallbackURL.String())
+	client, err := a.getClient(options, loginCallbackURL.String())
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -90,7 +86,7 @@ func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request
 		if postLogoutRedirectURL != "" {
 			isAuthorized := slices.Contains(options.OIDC.PostLogoutRedirectURLs, postLogoutRedirectURL)
 			if !isAuthorized {
-				director.HandleError(ctx, w, r, http.StatusBadRequest, errors.New("unauthorized post-logout redirect"))
+				http.Error(w, "unauthorized post-logout redirect", http.StatusBadRequest)
 				return errors.WithStack(authn.ErrSkipRequest)
 			}
 		}
@@ -132,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.CapturedE(errors.WithStack(err)))
+			logger.Error(ctx, "could not save session", logger.E(errors.WithStack(err)))
 		}
 	}()
 
@@ -162,7 +158,7 @@ func (a *Authenticator) Authenticate(w http.ResponseWriter, r *http.Request, lay
 		return nil, errors.WithStack(err)
 	}
 
-	client, err := a.getClient(ctx, options, loginCallbackURL.String())
+	client, err := a.getClient(options, loginCallbackURL.String())
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -364,7 +360,9 @@ func (a *Authenticator) templatize(rawTemplate string, proxyName store.ProxyName
 	return raw.String(), nil
 }
 
-func (a *Authenticator) getClient(ctx context.Context, options *LayerOptions, redirectURL string) (*Client, error) {
+func (a *Authenticator) getClient(options *LayerOptions, redirectURL string) (*Client, error) {
+	ctx := context.Background()
+
 	transport := a.httpTransport.Clone()
 
 	if options.OIDC.TLSInsecureSkipVerify {
@@ -375,10 +373,6 @@ func (a *Authenticator) getClient(ctx context.Context, options *LayerOptions, re
 		transport.TLSClientConfig.InsecureSkipVerify = true
 	}
 
-	if options.OIDC.SkipIssuerVerification {
-		ctx = oidc.InsecureIssuerURLContext(ctx, options.OIDC.IssuerURL)
-	}
-
 	httpClient := &http.Client{
 		Timeout:   a.httpClientTimeout,
 		Transport: transport,
@@ -390,9 +384,9 @@ func (a *Authenticator) getClient(ctx context.Context, options *LayerOptions, re
 		ctx = oidc.InsecureIssuerURLContext(ctx, options.OIDC.IssuerURL)
 	}
 
-	provider, _, err := a.cachedOIDCProvider.Get(ctx, options.OIDC.IssuerURL)
+	provider, err := oidc.NewProvider(ctx, options.OIDC.IssuerURL)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not retrieve oidc provider")
+		return nil, errors.Wrap(err, "could not create oidc provider")
 	}
 
 	client := NewClient(
@@ -407,17 +401,6 @@ func (a *Authenticator) getClient(ctx context.Context, options *LayerOptions, re
 	return client, nil
 }
 
-func (a *Authenticator) getOIDCProvider(ctx context.Context, issuerURL string) (*oidc.Provider, error) {
-	logger.Debug(ctx, "refreshing oidc provider", logger.F("issuerURL", issuerURL))
-
-	provider, err := oidc.NewProvider(ctx, issuerURL)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not create oidc provider")
-	}
-
-	return provider, nil
-}
-
 const defaultCookieNamePrefix = "_bouncer_authn_oidc"
 
 func (a *Authenticator) getCookieName(cookieName string, proxyName store.ProxyName, layerName store.LayerName) string {
@@ -428,25 +411,6 @@ func (a *Authenticator) getCookieName(cookieName string, proxyName store.ProxyNa
 	return strings.ToLower(fmt.Sprintf("%s_%s_%s", defaultCookieNamePrefix, proxyName, layerName))
 }
 
-func NewAuthenticator(httpTransport *http.Transport, clientTimeout time.Duration, store sessions.Store, oidcProviderCacheTimeout time.Duration) *Authenticator {
-	authenticator := &Authenticator{
-		httpTransport:     httpTransport,
-		httpClientTimeout: clientTimeout,
-		store:             store,
-	}
-
-	authenticator.cachedOIDCProvider = syncx.NewCachedResource(
-		ttl.NewCache(
-			memory.NewCache[string, *oidc.Provider](),
-			memory.NewCache[string, time.Time](),
-			oidcProviderCacheTimeout,
-		),
-		authenticator.getOIDCProvider,
-	)
-
-	return authenticator
-}
-
 var (
 	_ authn.PreAuthentication = &Authenticator{}
 	_ authn.Authenticator     = &Authenticator{}

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

@@ -6,7 +6,6 @@ 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"
@@ -69,7 +68,8 @@ 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 {
-		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not save session"))
+		logger.Error(ctx, "could not save session", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
 		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.CapturedE(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve raw id token", logger.E(errors.WithStack(err)))
 	}
 
 	sess.Values[sessionKeyIDToken] = nil

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

@@ -10,11 +10,9 @@ const LayerType store.LayerType = "authn-oidc"
 
 func NewLayer(store sessions.Store, funcs ...OptionFunc) *authn.Layer {
 	opts := NewOptions(funcs...)
-	authenticator := NewAuthenticator(
+	return authn.NewLayer(LayerType, &Authenticator{
-		opts.HTTPTransport,
+		httpTransport:     opts.HTTPTransport,
-		opts.HTTPClientTimeout,
+		httpClientTimeout: opts.HTTPClientTimeout,
-		store,
+		store:             store,
-		opts.OIDCProviderCacheTimeout,
+	}, opts.AuthnOptions...)
-	)
-	return authn.NewLayer(LayerType, authenticator, opts.AuthnOptions...)
 }

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

@@ -8,10 +8,9 @@ import (
 )
 
 type Options struct {
-	HTTPTransport            *http.Transport
+	HTTPTransport     *http.Transport
-	HTTPClientTimeout        time.Duration
+	HTTPClientTimeout time.Duration
-	AuthnOptions             []authn.OptionFunc
+	AuthnOptions      []authn.OptionFunc
-	OIDCProviderCacheTimeout time.Duration
 }
 
 type OptionFunc func(opts *Options)
@@ -34,18 +33,11 @@ func WithAuthnOptions(funcs ...authn.OptionFunc) OptionFunc {
 	}
 }
 
-func WithOIDCProviderCacheTimeout(timeout time.Duration) OptionFunc {
-	return func(opts *Options) {
-		opts.OIDCProviderCacheTimeout = timeout
-	}
-}
-
 func NewOptions(funcs ...OptionFunc) *Options {
 	opts := &Options{
-		HTTPTransport:            http.DefaultTransport.(*http.Transport),
+		HTTPTransport:     http.DefaultTransport.(*http.Transport),
-		HTTPClientTimeout:        30 * time.Second,
+		HTTPClientTimeout: 30 * time.Second,
-		AuthnOptions:             make([]authn.OptionFunc, 0),
+		AuthnOptions:      make([]authn.OptionFunc, 0),
-		OIDCProviderCacheTimeout: time.Hour,
 	}
 
 	for _, fn := range funcs {

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,11 +14,17 @@ type Vars struct {
 	User *User `expr:"user"`
 }
 
-func (l *Layer) applyRules(ctx context.Context, r *http.Request, layer *store.Layer, options *LayerOptions, user *User) error {
+func (l *Layer) applyRules(ctx context.Context, r *http.Request, options *LayerOptions, user *User) error {
-	key := string(layer.Proxy) + "-" + string(layer.Name)
+	rules := options.Rules
-	revisionedEngine := l.ruleEngineCache.Get(key)
+	if len(rules) == 0 {
+		return nil
+	}
 
-	engine, err := revisionedEngine.Get(ctx, layer.Revision, options)
+	engine, err := rule.NewEngine[*Vars](
+		rule.WithRules(options.Rules...),
+		rule.WithExpr(getAuthnAPI()...),
+		ruleHTTP.WithRequestFuncs(),
+	)
 	if err != nil {
 		return errors.WithStack(err)
 	}

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

@@ -1,11 +1,9 @@
 package queue
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"html/template"
-	"io"
 	"math/rand"
 	"net/http"
 	"path/filepath"
@@ -54,7 +52,9 @@ func (q *Queue) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options, q.defaultKeepAlive)
 			if err != nil {
-				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
+				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 				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.CapturedE(errors.WithStack(err)))
+				logger.Error(ctx, "could not retrieve cookie", logger.E(errors.WithStack(err)))
 			}
 
 			if cookie == nil {
@@ -89,7 +89,9 @@ func (q *Queue) Middleware(layer *store.Layer) proxy.Middleware {
 
 			rank, err := q.adapter.Touch(ctx, queueName, sessionID)
 			if err != nil {
-				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not update queue session rank"))
+				logger.Error(ctx, "could not retrieve session rank", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 				return
 			}
 
@@ -124,7 +126,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.CapturedE(errors.WithStack(err)))
+		logger.Error(ctx, "could not retrieve queue status", logger.E(errors.WithStack(err)))
 
 		return
 	}
@@ -142,7 +144,9 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 
 	status, err := q.adapter.Status(ctx, queueName)
 	if err != nil {
-		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not retrieve queue status"))
+		logger.Error(ctx, "could not retrieve queue status", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 		return
 	}
 
@@ -153,7 +157,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.CapturedE(errors.WithStack(err)))
+			logger.Error(ctx, "could not load queue templates", logger.E(errors.WithStack(err)))
 
 			return
 		}
@@ -162,7 +166,9 @@ func (q *Queue) renderQueuePage(w http.ResponseWriter, r *http.Request, queueNam
 	})
 
 	if q.tmpl == nil {
-		director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.New("queue page templates not loaded"))
+		logger.Error(ctx, "queue page templates not loaded", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 		return
 	}
 
@@ -188,16 +194,12 @@ 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)
 
-	var buf bytes.Buffer
+	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)
 
-	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) {
@@ -209,7 +211,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.CapturedE(errors.WithStack(err)),
+			logger.E(errors.WithStack(err)),
 			logger.F("queue", layerName),
 		)
 	}

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

@@ -11,13 +11,14 @@ 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 {
-	requestRuleEngineCache  *util.RuleEngineCache[*RequestVars, *LayerOptions]
+	requestRuleEngine  *util.RevisionedRuleEngine[*RequestVars, *LayerOptions]
-	responseRuleEngineCache *util.RuleEngineCache[*ResponseVars, *LayerOptions]
+	responseRuleEngine *util.RevisionedRuleEngine[*ResponseVars, *LayerOptions]
 }
 
 func (l *Layer) LayerType() store.LayerType {
@@ -31,7 +32,9 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 
 			options, err := fromStoreOptions(layer.Options)
 			if err != nil {
-				director.HandleError(ctx, w, r, http.StatusInternalServerError, errors.Wrap(err, "could not parse layer options"))
+				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
 				return
 			}
 
@@ -42,14 +45,15 @@ func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
 				return
 			}
 
-			if err := l.applyRequestRules(ctx, r, layer, options); err != nil {
+			if err := l.applyRequestRules(ctx, r, layer.Revision, 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"))
+				logger.Error(ctx, "could not apply request rules", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
 				return
 			}
@@ -76,7 +80,7 @@ func (l *Layer) ResponseTransformer(layer *store.Layer) proxy.ResponseTransforme
 
 		ctx := r.Request.Context()
 
-		if err := l.applyResponseRules(ctx, r, layer, options); err != nil {
+		if err := l.applyResponseRules(ctx, r, layer.Revision, options); err != nil {
 			return errors.WithStack(err)
 		}
 
@@ -86,7 +90,7 @@ func (l *Layer) ResponseTransformer(layer *store.Layer) proxy.ResponseTransforme
 
 func New(funcs ...OptionFunc) *Layer {
 	return &Layer{
-		requestRuleEngineCache: util.NewInMemoryRuleEngineCache(func(options *LayerOptions) (*rule.Engine[*RequestVars], error) {
+		requestRuleEngine: util.NewRevisionedRuleEngine(func(options *LayerOptions) (*rule.Engine[*RequestVars], error) {
 			engine, err := rule.NewEngine[*RequestVars](
 				rule.WithRules(options.Rules.Request...),
 				ruleHTTP.WithRequestFuncs(),
@@ -98,7 +102,7 @@ func New(funcs ...OptionFunc) *Layer {
 
 			return engine, nil
 		}),
-		responseRuleEngineCache: util.NewInMemoryRuleEngineCache(func(options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
+		responseRuleEngine: util.NewRevisionedRuleEngine(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

@@ -8,7 +8,6 @@ import (
 	"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"
 )
 
@@ -88,13 +87,13 @@ func fromRequest(r *http.Request) RequestVar {
 	}
 }
 
-func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layer *store.Layer, options *LayerOptions) error {
+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, layer, options)
+	engine, err := l.getRequestRuleEngine(ctx, layerRevision, options)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -118,11 +117,8 @@ func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layer *s
 	return nil
 }
 
-func (l *Layer) getRequestRuleEngine(ctx context.Context, layer *store.Layer, options *LayerOptions) (*rule.Engine[*RequestVars], error) {
+func (l *Layer) getRequestRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*RequestVars], error) {
-	key := string(layer.Proxy) + "-" + string(layer.Name)
+	engine, err := l.requestRuleEngine.Get(ctx, layerRevision, options)
-	revisionedEngine := l.requestRuleEngineCache.Get(key)
-
-	engine, err := revisionedEngine.Get(ctx, layer.Revision, options)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -149,13 +145,13 @@ type ResponseVar struct {
 	Trailer          map[string][]string `expr:"trailer"`
 }
 
-func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layer *store.Layer, options *LayerOptions) error {
+func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerRevision int, options *LayerOptions) error {
 	rules := options.Rules.Response
 	if len(rules) == 0 {
 		return nil
 	}
 
-	engine, err := l.getResponseRuleEngine(ctx, layer, options)
+	engine, err := l.getResponseRuleEngine(ctx, layerRevision, options)
 	if err != nil {
 		return errors.WithStack(err)
 	}
@@ -191,11 +187,8 @@ func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layer
 	return nil
 }
 
-func (l *Layer) getResponseRuleEngine(ctx context.Context, layer *store.Layer, options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
+func (l *Layer) getResponseRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
-	key := string(layer.Proxy) + "-" + string(layer.Name)
+	engine, err := l.responseRuleEngine.Get(ctx, layerRevision, options)
-	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

@@ -1,28 +0,0 @@
-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,21 +1,18 @@
 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
+	Layers     []Layer
-	ProxyCache  cache.Cache[string, []*store.Proxy]
+	ProxyCache cache.Cache[string, []*store.Proxy]
-	LayerCache  cache.Cache[string, []*store.Layer]
+	LayerCache cache.Cache[string, []*store.Layer]
-	HandleError HandleErrorFunc
 }
 
 type OptionFunc func(opts *Options)
@@ -33,10 +30,6 @@ 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 {
@@ -63,9 +56,3 @@ 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,23 +1,17 @@
 package proxy
 
 import (
-	"bytes"
 	"context"
-	"expvar"
 	"fmt"
 	"html/template"
-	"io"
 	"log"
 	"net"
 	"net/http"
 	"net/http/httputil"
 	"net/http/pprof"
 	"net/url"
-	"os"
-	"os/signal"
 	"path/filepath"
 	"strconv"
-	"syscall"
 	"time"
 
 	"forge.cadoles.com/Cadoles/go-proxy"
@@ -29,6 +23,7 @@ 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"
@@ -97,25 +92,31 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 
 	logger.Info(ctx, "http server listening")
 
-	layerCache, proxyCache, cancel := s.createDirectorCaches(ctx)
-	defer cancel()
-
 	director := director.New(
 		s.proxyRepository,
 		s.layerRepository,
 		director.WithLayers(s.directorLayers...),
-		director.WithLayerCache(layerCache),
+		director.WithLayerCache(
-		director.WithProxyCache(proxyCache),
+			ttl.NewCache(
-		director.WithHandleErrorFunc(s.handleError),
+				memory.NewCache[string, []*store.Layer](),
+				memory.NewCache[string, time.Time](),
+				s.directorCacheTTL,
+			),
+		),
+		director.WithProxyCache(
+			ttl.NewCache(
+				memory.NewCache[string, []*store.Proxy](),
+				memory.NewCache[string, time.Time](),
+				s.directorCacheTTL,
+			),
+		),
 	)
 
 	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")
@@ -152,7 +153,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 profiling endpoint")
+				logger.Info(ctx, "enabling authentication on metrics endpoint")
 
 				r.Use(middleware.BasicAuth(
 					"profiling",
@@ -166,7 +167,6 @@ 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)
@@ -199,44 +199,6 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 	logger.Info(ctx, "http server exiting")
 }
 
-func (s *Server) createDirectorCaches(ctx context.Context) (*ttl.Cache[string, []*store.Layer], *ttl.Cache[string, []*store.Proxy], func()) {
-	layerCache := ttl.NewCache(
-		memory.NewCache[string, []*store.Layer](),
-		memory.NewCache[string, time.Time](),
-		s.directorCacheTTL,
-	)
-
-	proxyCache := ttl.NewCache(
-		memory.NewCache[string, []*store.Proxy](),
-		memory.NewCache[string, time.Time](),
-		s.directorCacheTTL,
-	)
-
-	sig := make(chan os.Signal, 1)
-
-	signal.Notify(sig, syscall.SIGUSR2)
-
-	go func() {
-		for {
-			_, ok := <-sig
-			if !ok {
-				return
-			}
-
-			logger.Info(ctx, "received sigusr2 signal, clearing proxies and layers cache")
-
-			layerCache.Clear()
-			proxyCache.Clear()
-		}
-	}()
-
-	cancel := func() {
-		close(sig)
-	}
-
-	return layerCache, proxyCache, cancel
-}
-
 func (s *Server) createReverseProxy(ctx context.Context, target *url.URL) *httputil.ReverseProxy {
 	reverseProxy := httputil.NewSingleHostReverseProxy(target)
 
@@ -253,27 +215,27 @@ func (s *Server) createReverseProxy(ctx context.Context, target *url.URL) *httpu
 	httpTransport.DialContext = dialer.DialContext
 
 	reverseProxy.Transport = httpTransport
-	reverseProxy.ErrorHandler = s.handleProxyError
+	reverseProxy.ErrorHandler = s.handleError
 
 	return reverseProxy
 }
 
 func (s *Server) handleDefault(w http.ResponseWriter, r *http.Request) {
-	s.handleError(w, r, http.StatusBadGateway, errors.Errorf("no proxy target found"))
+	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))
 }
 
-func (s *Server) handleError(w http.ResponseWriter, r *http.Request, status int, err error) {
+func (s *Server) handleError(w http.ResponseWriter, r *http.Request, err error) {
 	err = errors.WithStack(err)
 
-	if !errors.Is(err, context.Canceled) {
+	logger.Error(r.Context(), "proxy error", logger.E(err))
-		logger.Error(r.Context(), err.Error(), logger.CapturedE(err))
+	sentry.CaptureException(err)
-	}
 
-	s.renderErrorPage(w, r, err, status, http.StatusText(status))
+	s.renderErrorPage(w, r, err, http.StatusBadGateway, http.StatusText(http.StatusBadGateway))
-}
-
-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) {
@@ -304,7 +266,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.CapturedE(errors.WithStack(err)))
+		logger.Error(ctx, "could not load proxy templates", logger.E(errors.WithStack(err)))
 		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 
 		return
@@ -324,18 +286,12 @@ func (s *Server) renderPage(w http.ResponseWriter, r *http.Request, page string,
 		return
 	}
 
-	var buf bytes.Buffer
+	if err := blockTmpl.Execute(w, templateData); err != nil {
-
+		logger.Error(ctx, "could not render proxy page", logger.E(errors.WithStack(err)))
-	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/session/options.go

@@ -10,7 +10,6 @@ import (
 type Options struct {
 	Session   sessions.Options
 	KeyPrefix string
-	TTL       time.Duration
 }
 
 type OptionFunc func(opts *Options)
@@ -26,7 +25,6 @@ func NewOptions(funcs ...OptionFunc) *Options {
 			SameSite: http.SameSiteDefaultMode,
 		},
 		KeyPrefix: "session:",
-		TTL:       time.Hour,
 	}
 
 	for _, fn := range funcs {
@@ -47,9 +45,3 @@ func WithKeyPrefix(prefix string) OptionFunc {
 		opts.KeyPrefix = prefix
 	}
 }
-
-func WithTTL(ttl time.Duration) OptionFunc {
-	return func(opts *Options) {
-		opts.TTL = ttl
-	}
-}

internal/session/store.go

@@ -31,7 +31,6 @@ type Store struct {
 	keyPrefix  string
 	keyGen     KeyGenFunc
 	serializer SessionSerializer
-	ttl        time.Duration
 }
 
 type KeyGenFunc func() (string, error)
@@ -44,7 +43,6 @@ func NewStore(adapter StoreAdapter, funcs ...OptionFunc) *Store {
 		keyPrefix:  opts.KeyPrefix,
 		keyGen:     generateRandomKey,
 		serializer: GobSerializer{},
-		ttl:        opts.TTL,
 	}
 
 	return rs
@@ -64,21 +62,20 @@ func (s *Store) New(r *http.Request, name string) (*sessions.Session, error) {
 	if err != nil {
 		return session, nil
 	}
-
 	session.ID = c.Value
 
 	err = s.load(r.Context(), session)
 	if err == nil {
 		session.IsNew = false
 	} else if !errors.Is(err, ErrNotFound) {
-		return session, errors.WithStack(err)
+		return nil, errors.WithStack(err)
 	}
 
 	return session, nil
 }
 
 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)
 		}
@@ -123,12 +120,7 @@ func (s *Store) save(ctx context.Context, session *sessions.Session) error {
 		return errors.WithStack(err)
 	}
 
-	ttl := time.Duration(session.Options.MaxAge) * time.Second
+	if err := s.adapter.Set(ctx, s.keyPrefix+session.ID, b, time.Duration(session.Options.MaxAge)*time.Second); err != nil {
-	if s.ttl < ttl || ttl == 0 {
-		ttl = s.ttl
-	}
-
-	if err := s.adapter.Set(ctx, s.keyPrefix+session.ID, b, ttl); err != nil {
 		return errors.WithStack(err)
 	}
 

internal/setup/authn_oidc_layer.go

@@ -37,6 +37,5 @@ func setupAuthnOIDCLayer(conf *config.Config) (director.Layer, error) {
 			authn.WithTemplateDir(string(conf.Layers.Authn.TemplateDir)),
 			authn.WithDebug(bool(conf.Layers.Authn.Debug)),
 		),
-		oidc.WithOIDCProviderCacheTimeout(time.Duration(*conf.Layers.Authn.OIDC.ProviderCacheTimeout)),
 	), nil
 }

internal/setup/redis.go

@@ -38,15 +38,9 @@ func newRedisClient(conf config.RedisConfig) redis.UniversalClient {
 		ReadTimeout:           time.Duration(conf.ReadTimeout),
 		WriteTimeout:          time.Duration(conf.WriteTimeout),
 		DialTimeout:           time.Duration(conf.DialTimeout),
-		RouteByLatency:        bool(conf.RouteByLatency),
+		RouteByLatency:        true,
-		ContextTimeoutEnabled: bool(conf.ContextTimeoutEnabled),
+		ContextTimeoutEnabled: true,
 		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() {
@@ -62,7 +56,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.CapturedE(errors.WithStack(err)))
+				logger.Error(ctx, "redis disconnected", logger.E(errors.WithStack(err)))
 				connected = false
 				continue
 			}

internal/setup/sentry.go

@@ -34,10 +34,6 @@ 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.CapturedE(err))
+			logger.Debug(ctx, "redis transaction failed", logger.E(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.CapturedE(errors.WithStack(err)))
+	logger.Error(ctx, "redis error", logger.E(errors.WithStack(err)))
 
 	return errors.WithStack(redis.TxFailedErr)
 }

internal/syncx/cached_resource.go

@@ -1,63 +0,0 @@
-package syncx
-
-import (
-	"context"
-	"sync"
-
-	"forge.cadoles.com/cadoles/bouncer/internal/cache"
-	"github.com/pkg/errors"
-)
-
-type RefreshFunc[K comparable, V any] func(ctx context.Context, key K) (V, error)
-
-type CachedResource[K comparable, V any] struct {
-	cache   cache.Cache[K, V]
-	lock    sync.RWMutex
-	refresh RefreshFunc[K, V]
-}
-
-func (r *CachedResource[K, V]) Clear() {
-	r.cache.Clear()
-}
-
-func (r *CachedResource[K, V]) Get(ctx context.Context, key K) (V, bool, error) {
-	value, exists := r.cache.Get(key)
-	if exists {
-		return value, false, nil
-	}
-
-	locked := r.lock.TryLock()
-	if !locked {
-		r.lock.RLock()
-
-		value, exists := r.cache.Get(key)
-		if exists {
-			r.lock.RUnlock()
-			return value, false, nil
-		}
-
-		r.lock.RUnlock()
-	}
-
-	if !locked {
-		r.lock.Lock()
-	}
-
-	defer r.lock.Unlock()
-
-	value, err := r.refresh(ctx, key)
-	if err != nil {
-		return *new(V), false, errors.WithStack(err)
-	}
-
-	r.cache.Set(key, value)
-
-	return value, true, nil
-}
-
-func NewCachedResource[K comparable, V any](cache cache.Cache[K, V], refresh RefreshFunc[K, V]) *CachedResource[K, V] {
-	return &CachedResource[K, V]{
-		cache:   cache,
-		refresh: refresh,
-	}
-}

internal/syncx/cached_resource_test.go

@@ -1,66 +0,0 @@
-package syncx
-
-import (
-	"context"
-	"math"
-	"sync"
-	"testing"
-	"time"
-
-	"forge.cadoles.com/cadoles/bouncer/internal/cache/memory"
-	"forge.cadoles.com/cadoles/bouncer/internal/cache/ttl"
-	"github.com/pkg/errors"
-)
-
-func TestCachedResource(t *testing.T) {
-	refreshCalls := 0
-	cacheTTL := 1*time.Second + 500*time.Millisecond
-	duration := 2 * time.Second
-
-	expectedCalls := math.Ceil(float64(duration) / float64(cacheTTL))
-
-	resource := NewCachedResource(
-		ttl.NewCache(
-			memory.NewCache[string, string](),
-			memory.NewCache[string, time.Time](),
-			cacheTTL,
-		),
-		func(ctx context.Context, key string) (string, error) {
-			refreshCalls++
-			return "bar", nil
-		},
-	)
-
-	concurrents := 50
-	key := "foo"
-
-	var wg sync.WaitGroup
-
-	wg.Add(concurrents)
-
-	for i := range concurrents {
-		go func(i int) {
-			done := time.After(duration)
-
-			defer wg.Done()
-			for {
-				select {
-				case <-done:
-					return
-				default:
-					value, fresh, err := resource.Get(context.Background(), key)
-					if err != nil {
-						t.Errorf("%+v", errors.WithStack(err))
-					}
-					t.Logf("resource retrieved for goroutine #%d: (%s, %s, %v)", i, key, value, fresh)
-				}
-			}
-		}(i)
-	}
-
-	wg.Wait()
-
-	if e, g := int(expectedCalls), refreshCalls; e != g {
-		t.Errorf("refreshCalls: expected '%d', got '%d'", e, g)
-	}
-}

layers/authn/templates/error.gohtml

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

misc/packaging/common/config.yml

@@ -131,12 +131,6 @@ proxy:
     # Les proxys/layers sont mis en cache local pour une durée de 30s
     # par défaut. Si les modifications sont rares, vous pouvez augmenter
     # cette valeur pour réduire la "pression" sur le serveur Redis.
-    # Il est possible de forcer la réinitialisation du cache en envoyant
-    # le signal SIGUSR2 au processus Bouncer.
-    #
-    # Exemple
-    #
-    # kill -s USR2 $(pgrep bouncer)
     ttl: 30s
 
   # Configuration du transport HTTP(S)
@@ -224,11 +218,6 @@ layers:
   authn:
     # Répertoire contenant les templates
     templateDir: "/etc/bouncer/layers/authn/templates"
-    # Configuration des sessions
-    sessions:
-      # Temps de persistence sans actualisation des sessions dans le store
-      # (prévalent sur le MaxAge de la session)
-      ttl: "1h"
 
 # Configuration d'une série de proxy/layers
 # à créer par défaut par le serveur d'administration

templates/error.gohtml

@@ -76,26 +76,14 @@
         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 }}
-        <h3>Stack Trace</h3>
+        <pre>{{ .Err }}</pre>
-        <div class="stacktrace">
-          <pre>{{ printf "%+v" .Err }}</pre>
-        </div>
         {{ end }}
         <p class="footer">
           Propulsé par