Skip to content

Modern Docker Management, Designed for Everyone

refactor: cleanup auth middleware, refactor logging

Kyle Mendell09431a3140ff
diff --git a/backend/go.mod b/backend/go.mod
index 26e1c7741..e05fe8885 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -17,6 +17,7 @@ require (
github.com/jinzhu/copier v0.4.0
github.com/joho/godotenv v1.5.1
github.com/lmittmann/tint v1.1.2
+ github.com/orandin/slog-gorm v1.4.0
github.com/samber/slog-gin v1.17.1
github.com/shirou/gopsutil/v3 v3.24.5
golang.org/x/crypto v0.38.0
diff --git a/backend/go.sum b/backend/go.sum
index 7aae1d8af..b15239c26 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -156,6 +156,8 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
github.com/opencontainers/image-spec v1.1.1 h1:y0fUlFfIZhPF1W537XOLg0/fcx6zcHCJwooC2xJA040=
github.com/opencontainers/image-spec v1.1.1/go.mod h1:qpqAh3Dmcf36wStyyWU+kCeDgrGnAve2nCC8+7h8Q0M=
+github.com/orandin/slog-gorm v1.4.0 h1:FgA8hJufF9/jeNSYoEXmHPPBwET2gwlF3B85JdpsTUU=
+github.com/orandin/slog-gorm v1.4.0/go.mod h1:MoZ51+b7xE9lwGNPYEhxcUtRNrYzjdcKvA8QXQQGEPA=
github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
diff --git a/backend/internal/bootstrap/logger_bootstrap.go b/backend/internal/bootstrap/logger_bootstrap.go
index 2fb586ee0..08a2ac686 100644
--- a/backend/internal/bootstrap/logger_bootstrap.go
+++ b/backend/internal/bootstrap/logger_bootstrap.go
@@ -1,18 +1,16 @@
package bootstrap
import (
- "context"
- "errors"
"log/slog"
"os"
"strings"
"time"
"github.com/lmittmann/tint"
+ slogGorm "github.com/orandin/slog-gorm"
"github.com/ofkm/arcane-backend/internal/config"
"github.com/ofkm/arcane-backend/internal/database"
- "gorm.io/gorm"
"gorm.io/gorm/logger"
)
@@ -46,116 +44,36 @@ func SetupLogger(cfg *config.Config) {
}
func BuildGormLogger(cfg *config.Config) logger.Interface {
- switch strings.ToLower(cfg.LogLevel) {
+ lvl := strings.ToLower(cfg.LogLevel)
+
+ opts := []slogGorm.Option{
+ slogGorm.WithHandler(slog.Default().Handler()),
+ slogGorm.WithSlowThreshold(200 * time.Millisecond),
+ }
+
+ var defaultTypeLevel slog.Level
+ switch lvl {
case "debug":
- return newGormSlogLogger(logger.Info, 200*time.Millisecond, true)
- case "info":
- return newGormSlogLogger(logger.Warn, 200*time.Millisecond, true)
+ defaultTypeLevel = slog.LevelDebug
+ // Trace all SQL messages only in debug
+ opts = append(opts, slogGorm.WithTraceAll())
case "warn", "warning":
- return newGormSlogLogger(logger.Error, 200*time.Millisecond, true)
+ defaultTypeLevel = slog.LevelWarn
case "error":
- return newGormSlogLogger(logger.Error, 200*time.Millisecond, true)
+ defaultTypeLevel = slog.LevelError
default:
- return newGormSlogLogger(logger.Warn, 200*time.Millisecond, true)
- }
-}
-
-func ConfigureGormLogger(cfg *config.Config) {
- database.SetGormLogger(BuildGormLogger(cfg))
-}
-
-type gormSlogLogger struct {
- level logger.LogLevel
- slowThreshold time.Duration
- ignoreRecordNotFoundError bool
-}
-
-func newGormSlogLogger(level logger.LogLevel, slow time.Duration, ignoreNotFound bool) logger.Interface {
- return &gormSlogLogger{
- level: level,
- slowThreshold: slow,
- ignoreRecordNotFoundError: ignoreNotFound,
+ defaultTypeLevel = slog.LevelInfo
}
-}
-func (l *gormSlogLogger) LogMode(level logger.LogLevel) logger.Interface {
- nl := *l
- nl.level = level
- return &nl
-}
+ opts = append(opts,
+ slogGorm.SetLogLevel(slogGorm.DefaultLogType, defaultTypeLevel),
+ slogGorm.SetLogLevel(slogGorm.ErrorLogType, slog.LevelError),
+ slogGorm.SetLogLevel(slogGorm.SlowQueryLogType, slog.LevelWarn),
+ )
-func (l *gormSlogLogger) Info(ctx context.Context, msg string, data ...interface{}) {
- if l.level > logger.Info {
- return
- }
- slog.InfoContext(ctx, msg, slog.Any("data", data))
-}
-
-func (l *gormSlogLogger) Warn(ctx context.Context, msg string, data ...interface{}) {
- if l.level > logger.Warn {
- return
- }
- slog.WarnContext(ctx, msg, slog.Any("data", data))
-}
-
-func (l *gormSlogLogger) Error(ctx context.Context, msg string, data ...interface{}) {
- if l.level > logger.Error {
- return
- }
- slog.ErrorContext(ctx, msg, slog.Any("data", data))
+ return slogGorm.New(opts...)
}
-const maxSQLLen = 500
-
-func sanitizeSQL(s string) string {
- if s == "" {
- return s
- }
- oneLine := strings.Join(strings.Fields(s), " ")
- if len(oneLine) > maxSQLLen {
- return oneLine[:maxSQLLen] + "…"
- }
- return oneLine
-}
-
-func (l *gormSlogLogger) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
- if l.level == logger.Silent {
- return
- }
-
- elapsed := time.Since(begin)
- sql, rows := fc()
- sql = sanitizeSQL(sql)
-
- attrs := []slog.Attr{
- slog.Int64("elapsed_ms", elapsed.Milliseconds()),
- }
- if rows >= 0 {
- attrs = append(attrs, slog.Int64("rows", rows))
- }
- if sql != "" {
- attrs = append(attrs, slog.String("sql", sql))
- }
-
- anyAttrs := make([]any, 0, len(attrs)+1)
- for _, a := range attrs {
- anyAttrs = append(anyAttrs, a)
- }
-
- if err != nil && l.level <= logger.Error {
- if !l.ignoreRecordNotFoundError || !errors.Is(err, gorm.ErrRecordNotFound) {
- anyAttrs = append(anyAttrs, slog.String("error", err.Error()))
- slog.ErrorContext(ctx, "gorm.error", anyAttrs...)
- }
- return
- }
-
- if l.slowThreshold > 0 && elapsed > l.slowThreshold && l.level <= logger.Warn {
- slog.WarnContext(ctx, "gorm.slow_query", anyAttrs...)
- return
- }
-
- if l.level <= logger.Info {
- slog.InfoContext(ctx, "gorm.query", anyAttrs...)
- }
+func ConfigureGormLogger(cfg *config.Config) {
+ database.SetGormLogger(BuildGormLogger(cfg))
}
diff --git a/backend/internal/job/image_polling_job.go b/backend/internal/job/image_polling_job.go
index 3656b0ff5..70609d00c 100644
--- a/backend/internal/job/image_polling_job.go
+++ b/backend/internal/job/image_polling_job.go
@@ -45,7 +45,7 @@ func RegisterImagePollingJob(ctx context.Context, scheduler *Scheduler, imageUpd
return scheduler.RegisterJob(
ctx,
- "ArcaneImagePolling",
+ "image-polling",
jobDefinition,
job.Execute,
false,
diff --git a/backend/internal/job/job.go b/backend/internal/job/job.go
index be45a6180..948330d34 100644
--- a/backend/internal/job/job.go
+++ b/backend/internal/job/job.go
@@ -50,33 +50,20 @@ func (s *Scheduler) RegisterJob(
gocron.WithContext(ctx),
gocron.WithEventListeners(
gocron.BeforeJobRuns(func(jobID uuid.UUID, jobName string) {
- slog.InfoContext(ctx, "Job starting",
- slog.String("name", name),
- slog.String("id", jobID.String()),
- )
+ slog.InfoContext(ctx, "Job starting", slog.String("name", name), slog.String("id", jobID.String()))
}),
gocron.AfterJobRuns(func(jobID uuid.UUID, jobName string) {
- slog.InfoContext(ctx, "Job finished successfully",
- slog.String("name", name),
- slog.String("id", jobID.String()),
- )
+ slog.InfoContext(ctx, "Job finished successfully", slog.String("name", name), slog.String("id", jobID.String()))
}),
gocron.AfterJobRunsWithError(func(jobID uuid.UUID, jobName string, err error) {
- slog.ErrorContext(ctx, "Job failed",
- slog.String("name", name),
- slog.String("id", jobID.String()),
- slog.Any("error", err),
- )
+ slog.ErrorContext(ctx, "Job failed", slog.String("name", name), slog.String("id", jobID.String()), slog.Any("error", err))
}),
),
}
task := gocron.NewTask(func() {
if err := taskFunc(ctx); err != nil {
- slog.ErrorContext(ctx, "Error executing task function",
- slog.String("name", name),
- slog.Any("error", err),
- )
+ slog.ErrorContext(ctx, "Error executing task function", slog.String("name", name), slog.Any("error", err))
}
})
diff --git a/backend/internal/middleware/auth_middleware.go b/backend/internal/middleware/auth_middleware.go
index 563769f5c..31059a58c 100644
--- a/backend/internal/middleware/auth_middleware.go
+++ b/backend/internal/middleware/auth_middleware.go
@@ -12,6 +12,12 @@ import (
"github.com/ofkm/arcane-backend/internal/utils/cookie"
)
+const (
+ headerAgentBootstrap = "X-Arcane-Agent-Bootstrap"
+ headerAgentToken = "X-Arcane-Agent-Token"
+ agentPairingPrefix = "/api/environments/0/agent/pair"
+)
+
type AuthOptions struct {
AdminRequired bool
SuccessOptional bool
@@ -50,85 +56,92 @@ func (m *AuthMiddleware) WithSuccessOptional() *AuthMiddleware {
func (m *AuthMiddleware) Add() gin.HandlerFunc {
return func(c *gin.Context) {
if m.cfg != nil && m.cfg.AgentMode {
- // Allow OPTIONS preflight to pass through in agent mode
- if c.Request.Method == http.MethodOptions {
- c.Next()
- return
- }
-
- // Allow pairing with bootstrap token
- if strings.HasPrefix(c.Request.URL.Path, "/api/environments/0/agent/pair") &&
- m.cfg.AgentBootstrapToken != "" &&
- c.GetHeader("X-Arcane-Agent-Bootstrap") == m.cfg.AgentBootstrapToken {
- slog.Info("Agent auth: bootstrap pairing accepted", "path", c.Request.URL.Path, "method", c.Request.Method)
- agentSudo(c)
- return
- }
-
- if tok := c.GetHeader("X-Arcane-Agent-Token"); tok != "" && m.cfg.AgentToken != "" && tok == m.cfg.AgentToken {
- slog.Info("Agent auth: agent token accepted", "path", c.Request.URL.Path, "method", c.Request.Method)
- agentSudo(c)
- return
- }
-
- slog.Warn("Agent auth forbidden",
- "path", c.Request.URL.Path,
- "method", c.Request.Method,
- "has_agent_token_hdr", c.GetHeader("X-Arcane-Agent-Token") != "",
- "agent_token_config_set", m.cfg.AgentToken != "",
- "has_bearer", c.GetHeader("Authorization") != "")
-
- c.JSON(http.StatusForbidden, models.APIError{
- Code: "FORBIDDEN",
- Message: "Invalid or missing agent token",
- })
- c.Abort()
+ m.agentAuth(c)
return
}
+ m.managerAuth(c)
+ }
+}
- // Manager (normal) JWT mode
- token := extractBearerOrCookieToken(c)
- if token == "" {
- if m.options.SuccessOptional {
- c.Next()
- return
- }
- c.JSON(http.StatusUnauthorized, models.APIError{
- Code: models.APIErrorCodeUnauthorized,
- Message: "Authentication required",
- })
- c.Abort()
- return
- }
+func (m *AuthMiddleware) agentAuth(c *gin.Context) {
+ if isPreflight(c) {
+ c.Next()
+ return
+ }
- user, err := m.authService.VerifyToken(c.Request.Context(), token)
- if err != nil {
- if m.options.SuccessOptional {
- c.Next()
- return
- }
- c.JSON(http.StatusUnauthorized, models.APIError{
- Code: models.APIErrorCodeUnauthorized,
- Message: "Invalid or expired token",
- })
- c.Abort()
+ if strings.HasPrefix(c.Request.URL.Path, agentPairingPrefix) &&
+ m.cfg.AgentBootstrapToken != "" &&
+ c.GetHeader(headerAgentBootstrap) == m.cfg.AgentBootstrapToken {
+ slog.Info("Agent auth: bootstrap pairing accepted", "path", c.Request.URL.Path, "method", c.Request.Method)
+ agentSudo(c)
+ return
+ }
+
+ if tok := c.GetHeader(headerAgentToken); tok != "" && m.cfg.AgentToken != "" && tok == m.cfg.AgentToken {
+ agentSudo(c)
+ return
+ }
+
+ slog.Warn("Agent auth forbidden",
+ "path", c.Request.URL.Path,
+ "method", c.Request.Method,
+ "has_agent_token_hdr", c.GetHeader(headerAgentToken) != "",
+ "agent_token_config_set", m.cfg.AgentToken != "",
+ )
+ c.JSON(http.StatusForbidden, models.APIError{
+ Code: "FORBIDDEN",
+ Message: "Invalid or missing agent token",
+ })
+ c.Abort()
+}
+
+func (m *AuthMiddleware) managerAuth(c *gin.Context) {
+ token := extractBearerOrCookieToken(c)
+ if token == "" {
+ if m.options.SuccessOptional {
+ c.Next()
return
}
+ c.JSON(http.StatusUnauthorized, models.APIError{
+ Code: models.APIErrorCodeUnauthorized,
+ Message: "Authentication required",
+ })
+ c.Abort()
+ return
+ }
- isAdmin := userHasRole(user, "admin")
- if m.options.AdminRequired && !isAdmin {
- c.JSON(http.StatusForbidden, models.APIError{
- Code: "FORBIDDEN",
- Message: "You don't have permission to access this resource",
- })
- c.Abort()
+ user, err := m.authService.VerifyToken(c.Request.Context(), token)
+ if err != nil {
+ if m.options.SuccessOptional {
+ c.Next()
return
}
- c.Set("userID", user.ID)
- c.Set("currentUser", user)
- c.Set("userIsAdmin", isAdmin)
- c.Next()
+ c.JSON(http.StatusUnauthorized, models.APIError{
+ Code: models.APIErrorCodeUnauthorized,
+ Message: "Invalid or expired token",
+ })
+ c.Abort()
+ return
}
+
+ isAdmin := userHasRole(user, "admin")
+ if m.options.AdminRequired && !isAdmin {
+ c.JSON(http.StatusForbidden, models.APIError{
+ Code: "FORBIDDEN",
+ Message: "You don't have permission to access this resource",
+ })
+ c.Abort()
+ return
+ }
+
+ c.Set("userID", user.ID)
+ c.Set("currentUser", user)
+ c.Set("userIsAdmin", isAdmin)
+ c.Next()
+}
+
+func isPreflight(c *gin.Context) bool {
+ return c.Request.Method == http.MethodOptions
}
func agentSudo(c *gin.Context) {