fix: address review findings for observability PR

1. Security: Replace insecure extractRemoteIP() in audit service with
   middleware.RealIP() which validates trusted proxies before trusting
   X-Real-IP/X-Forwarded-For headers. Export RealIP from middleware.
   Update audit tests to verify anti-spoofing behavior.

2. Audit coverage: Add audit instrumentation to all 9 handlers that
   had dead action constants: HandleEnvVarSave, HandleLabelAdd,
   HandleLabelEdit, HandleLabelDelete, HandleVolumeAdd, HandleVolumeEdit,
   HandleVolumeDelete, HandlePortAdd, HandlePortDelete.

3. README: Fix API path from /api/audit to /api/v1/audit.

4. README: Fix duplicate numbering in DI order section (items 10-11
   were listed twice, now correctly numbered 10-16).

README.md

@@ -11,7 +11,6 @@ A simple self-hosted PaaS that auto-deploys Docker containers from Git repositor
 - Environment variables, labels, and volume mounts per app
 - Docker builds via socket access
 - Notifications via ntfy and Slack-compatible webhooks
-- Backup/restore of app configurations (JSON export/import via UI and API)
 - Simple server-rendered UI with Tailwind CSS
 
 ## Non-Goals
@@ -37,11 +36,13 @@ upaas/
 │   ├── handlers/        # HTTP request handlers
 │   ├── healthcheck/     # Health status service
 │   ├── logger/          # Structured logging (slog)
-│   ├── middleware/      # HTTP middleware (auth, logging, CORS)
+│   ├── metrics/         # Prometheus metrics registration
+│   ├── middleware/      # HTTP middleware (auth, logging, CORS, metrics)
 │   ├── models/          # Active Record style database models
 │   ├── server/          # HTTP server and routes
 │   ├── service/
 │   │   ├── app/         # App management service
+│   │   ├── audit/       # Audit logging service
 │   │   ├── auth/        # Authentication service
 │   │   ├── deploy/      # Deployment orchestration
 │   │   ├── notify/      # Notifications (ntfy, Slack)
@@ -59,16 +60,18 @@ Uses Uber fx for dependency injection. Components are wired in this order:
 2. `logger` - Structured logging
 3. `config` - Configuration loading
 4. `database` - SQLite connection + migrations
-5. `healthcheck` - Health status
-6. `auth` - Authentication service
-7. `app` - App management
-8. `docker` - Docker client
-9. `notify` - Notification service
-10. `deploy` - Deployment service
-11. `webhook` - Webhook processing
-12. `middleware` - HTTP middleware
-13. `handlers` - HTTP handlers
-14. `server` - HTTP server
+5. `metrics` - Prometheus metrics registration
+6. `healthcheck` - Health status
+7. `auth` - Authentication service
+8. `app` - App management
+9. `docker` - Docker client
+10. `notify` - Notification service
+11. `audit` - Audit logging service
+12. `deploy` - Deployment service
+13. `webhook` - Webhook processing
+14. `middleware` - HTTP middleware
+15. `handlers` - HTTP handlers
+16. `server` - HTTP server
 
 ### Request Flow
 
@@ -212,6 +215,48 @@ Example: `HOST_DATA_DIR=/srv/upaas/data docker compose up -d`
 
 Session secrets are automatically generated on first startup and persisted to `$UPAAS_DATA_DIR/session.key`.
 
+## Observability
+
+### Prometheus Metrics
+
+All custom metrics are exposed under the `upaas_` namespace at `/metrics`. The
+endpoint is always available and can be optionally protected with basic auth via
+`METRICS_USERNAME` and `METRICS_PASSWORD`.
+
+| Metric | Type | Labels | Description |
+|--------|------|--------|-------------|
+| `upaas_deployments_total` | Counter | `app`, `status` | Total deployments (success/failed/cancelled) |
+| `upaas_deployments_duration_seconds` | Histogram | `app`, `status` | Deployment duration |
+| `upaas_deployments_in_flight` | Gauge | `app` | Currently running deployments |
+| `upaas_container_healthy` | Gauge | `app` | Container health (1=healthy, 0=unhealthy) |
+| `upaas_webhook_events_total` | Counter | `app`, `event_type`, `matched` | Webhook events received |
+| `upaas_http_requests_total` | Counter | `method`, `status_code` | HTTP requests |
+| `upaas_http_request_duration_seconds` | Histogram | `method` | HTTP request latency |
+| `upaas_http_response_size_bytes` | Histogram | `method` | HTTP response sizes |
+| `upaas_audit_events_total` | Counter | `action` | Audit log events |
+
+### Audit Log
+
+All user-facing actions are recorded in an `audit_log` SQLite table with:
+
+- **Who**: user ID and username
+- **What**: action type and affected resource (app, deployment, session, etc.)
+- **Where**: client IP (via X-Real-IP/X-Forwarded-For/RemoteAddr)
+- **When**: timestamp
+
+Audited actions include login/logout, app CRUD, deployments, container
+start/stop/restart, rollbacks, deployment cancellation, and webhook receipt.
+
+The audit log is available via the API at `GET /api/v1/audit?limit=N` (max 500,
+default 50).
+
+### Structured Logging
+
+All operations use Go's `slog` structured logger. HTTP requests are logged with
+method, URL, status code, response size, latency, user agent, and client IP.
+Deployment events are logged with app name, status, and duration. Audit events
+are also logged to stdout for correlation with external log aggregators.
+
 ## License
 
 WTFPL

cmd/upaasd/main.go

@@ -11,9 +11,11 @@ import (
 	"sneak.berlin/go/upaas/internal/handlers"
 	"sneak.berlin/go/upaas/internal/healthcheck"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/middleware"
 	"sneak.berlin/go/upaas/internal/server"
 	"sneak.berlin/go/upaas/internal/service/app"
+	"sneak.berlin/go/upaas/internal/service/audit"
 	"sneak.berlin/go/upaas/internal/service/auth"
 	"sneak.berlin/go/upaas/internal/service/deploy"
 	"sneak.berlin/go/upaas/internal/service/notify"
@@ -41,6 +43,7 @@ func main() {
 			logger.New,
 			config.New,
 			database.New,
+			metrics.New,
 			healthcheck.New,
 			auth.New,
 			app.New,
@@ -48,6 +51,7 @@ func main() {
 			notify.New,
 			deploy.New,
 			webhook.New,
+			audit.New,
 			middleware.New,
 			handlers.New,
 			server.New,

internal/database/migrations/007_add_audit_log.sql

@@ -0,0 +1,16 @@
+-- Audit log table for tracking user actions.
+CREATE TABLE audit_log (
+    id INTEGER PRIMARY KEY,
+    user_id INTEGER,
+    username TEXT NOT NULL,
+    action TEXT NOT NULL,
+    resource_type TEXT NOT NULL,
+    resource_id TEXT,
+    detail TEXT,
+    remote_ip TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_audit_log_created_at ON audit_log(created_at);
+CREATE INDEX idx_audit_log_action ON audit_log(action);
+CREATE INDEX idx_audit_log_resource ON audit_log(resource_type, resource_id);

internal/handlers/api.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"database/sql"
 	"encoding/json"
 	"net/http"
 	"strconv"
@@ -120,6 +121,9 @@ func (h *Handlers) HandleAPILoginPOST() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionLogin,
+			models.AuditResourceSession, "", "api login")
+
 		h.respondJSON(writer, request, loginResponse{
 			UserID:   user.ID,
 			Username: user.Username,
@@ -243,3 +247,79 @@ func (h *Handlers) HandleAPIWhoAmI() http.HandlerFunc {
 		}, http.StatusOK)
 	}
 }
+
+// auditLogDefaultLimit is the default number of audit entries returned.
+const auditLogDefaultLimit = 50
+
+// auditLogMaxLimit is the maximum number of audit entries returned.
+const auditLogMaxLimit = 500
+
+// HandleAPIAuditLog returns a handler that lists recent audit log entries.
+func (h *Handlers) HandleAPIAuditLog() http.HandlerFunc {
+	type auditEntryResponse struct {
+		ID           int64  `json:"id"`
+		UserID       *int64 `json:"userId,omitempty"`
+		Username     string `json:"username"`
+		Action       string `json:"action"`
+		ResourceType string `json:"resourceType"`
+		ResourceID   string `json:"resourceId,omitempty"`
+		Detail       string `json:"detail,omitempty"`
+		RemoteIP     string `json:"remoteIp,omitempty"`
+		CreatedAt    string `json:"createdAt"`
+	}
+
+	return func(writer http.ResponseWriter, request *http.Request) {
+		limit := auditLogDefaultLimit
+
+		if limitStr := request.URL.Query().Get("limit"); limitStr != "" {
+			parsed, parseErr := strconv.Atoi(limitStr)
+			if parseErr == nil && parsed > 0 && parsed <= auditLogMaxLimit {
+				limit = parsed
+			}
+		}
+
+		entries, err := h.audit.Recent(request.Context(), limit)
+		if err != nil {
+			h.log.Error("failed to fetch audit log", "error", err)
+			h.respondJSON(writer, request,
+				map[string]string{"error": "failed to fetch audit log"},
+				http.StatusInternalServerError)
+
+			return
+		}
+
+		result := make([]auditEntryResponse, 0, len(entries))
+
+		for _, e := range entries {
+			entry := auditEntryResponse{
+				ID:           e.ID,
+				Username:     e.Username,
+				Action:       string(e.Action),
+				ResourceType: string(e.ResourceType),
+				CreatedAt:    e.CreatedAt.UTC().Format("2006-01-02T15:04:05Z"),
+			}
+
+			if e.UserID.Valid {
+				id := e.UserID.Int64
+				entry.UserID = &id
+			}
+
+			entry.ResourceID = nullStringValue(e.ResourceID)
+			entry.Detail = nullStringValue(e.Detail)
+			entry.RemoteIP = nullStringValue(e.RemoteIP)
+
+			result = append(result, entry)
+		}
+
+		h.respondJSON(writer, request, result, http.StatusOK)
+	}
+}
+
+// nullStringValue returns the string value if valid, empty string otherwise.
+func nullStringValue(ns sql.NullString) string {
+	if ns.Valid {
+		return ns.String
+	}
+
+	return ""
+}

internal/handlers/api_test.go

@@ -27,11 +27,6 @@ func apiRouter(tc *testContext) http.Handler {
 			apiR.Get("/apps", tc.handlers.HandleAPIListApps())
 			apiR.Get("/apps/{id}", tc.handlers.HandleAPIGetApp())
 			apiR.Get("/apps/{id}/deployments", tc.handlers.HandleAPIListDeployments())
-
-			// Backup/Restore API
-			apiR.Get("/apps/{id}/export", tc.handlers.HandleAPIExportApp())
-			apiR.Get("/backup/export", tc.handlers.HandleAPIExportAllApps())
-			apiR.Post("/backup/import", tc.handlers.HandleAPIImportApps())
 		})
 	})
 

internal/handlers/app.go

@@ -119,6 +119,9 @@ func (h *Handlers) HandleAppCreate() http.HandlerFunc { //nolint:funlen // valid
 			return
 		}
 
+		h.auditLog(request, models.AuditActionAppCreate,
+			models.AuditResourceApp, createdApp.ID, "created app: "+createdApp.Name)
+
 		http.Redirect(writer, request, "/apps/"+createdApp.ID, http.StatusSeeOther)
 	}
 }
@@ -289,6 +292,9 @@ func (h *Handlers) HandleAppUpdate() http.HandlerFunc { //nolint:funlen // valid
 			return
 		}
 
+		h.auditLog(request, models.AuditActionAppUpdate,
+			models.AuditResourceApp, application.ID, "updated app: "+application.Name)
+
 		redirectURL := "/apps/" + application.ID + "?success=updated"
 		http.Redirect(writer, request, redirectURL, http.StatusSeeOther)
 	}
@@ -344,6 +350,9 @@ func (h *Handlers) HandleAppDelete() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionAppDelete,
+			models.AuditResourceApp, appID, "deleted app: "+application.Name)
+
 		http.Redirect(writer, request, "/", http.StatusSeeOther)
 	}
 }
@@ -360,6 +369,9 @@ func (h *Handlers) HandleAppDeploy() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionAppDeploy,
+			models.AuditResourceApp, application.ID, "manual deploy: "+application.Name)
+
 		// Trigger deployment in background with a detached context
 		// so the deployment continues even if the HTTP request is cancelled
 		deployCtx := context.WithoutCancel(request.Context())
@@ -399,6 +411,8 @@ func (h *Handlers) HandleCancelDeploy() http.HandlerFunc {
 		cancelled := h.deploy.CancelDeploy(application.ID)
 		if cancelled {
 			h.log.Info("deployment cancelled by user", "app", application.Name)
+			h.auditLog(request, models.AuditActionDeployCancel,
+				models.AuditResourceDeployment, application.ID, "cancelled deploy: "+application.Name)
 		}
 
 		http.Redirect(
@@ -430,6 +444,9 @@ func (h *Handlers) HandleAppRollback() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionAppRollback,
+			models.AuditResourceApp, application.ID, "rolled back: "+application.Name)
+
 		http.Redirect(writer, request, "/apps/"+application.ID+"?success=rolledback", http.StatusSeeOther)
 	}
 }
@@ -834,11 +851,29 @@ func (h *Handlers) handleContainerAction(
 	} else {
 		h.log.Info("container action completed",
 			"action", action, "app", application.Name, "container", containerID)
+
+		auditAction := containerActionToAuditAction(action)
+		h.auditLog(request, auditAction,
+			models.AuditResourceApp, appID, string(action)+" container: "+application.Name)
 	}
 
 	http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)
 }
 
+// containerActionToAuditAction maps container actions to audit actions.
+func containerActionToAuditAction(action containerAction) models.AuditAction {
+	switch action {
+	case actionRestart:
+		return models.AuditActionAppRestart
+	case actionStop:
+		return models.AuditActionAppStop
+	case actionStart:
+		return models.AuditActionAppStart
+	default:
+		return models.AuditAction("app." + string(action))
+	}
+}
+
 // HandleAppRestart handles restarting an app's container.
 func (h *Handlers) HandleAppRestart() http.HandlerFunc {
 	return func(writer http.ResponseWriter, request *http.Request) {
@@ -988,6 +1023,10 @@ func (h *Handlers) HandleEnvVarSave() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionEnvVarSave,
+			models.AuditResourceEnvVar, application.ID,
+			fmt.Sprintf("saved %d env vars", len(modelPairs)))
+
 		h.respondJSON(writer, request, map[string]bool{"ok": true}, http.StatusOK)
 	}
 }
@@ -1004,7 +1043,13 @@ func (h *Handlers) HandleLabelAdd() http.HandlerFunc {
 				label.Key = key
 				label.Value = value
 
-				return label.Save(ctx)
+				err := label.Save(ctx)
+				if err == nil {
+					h.auditLog(request, models.AuditActionLabelAdd,
+						models.AuditResourceLabel, application.ID, "added label: "+key)
+				}
+
+				return err
 			},
 		)
 	}
@@ -1033,6 +1078,9 @@ func (h *Handlers) HandleLabelDelete() http.HandlerFunc {
 		deleteErr := label.Delete(request.Context())
 		if deleteErr != nil {
 			h.log.Error("failed to delete label", "error", deleteErr)
+		} else {
+			h.auditLog(request, models.AuditActionLabelDelete,
+				models.AuditResourceLabel, appID, "deleted label: "+label.Key)
 		}
 
 		http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)
@@ -1090,6 +1138,10 @@ func (h *Handlers) HandleVolumeAdd() http.HandlerFunc {
 		saveErr := volume.Save(request.Context())
 		if saveErr != nil {
 			h.log.Error("failed to add volume", "error", saveErr)
+		} else {
+			h.auditLog(request, models.AuditActionVolumeAdd,
+				models.AuditResourceVolume, application.ID,
+				"added volume: "+hostPath+":"+containerPath)
 		}
 
 		http.Redirect(writer, request, "/apps/"+application.ID, http.StatusSeeOther)
@@ -1119,6 +1171,10 @@ func (h *Handlers) HandleVolumeDelete() http.HandlerFunc {
 		deleteErr := volume.Delete(request.Context())
 		if deleteErr != nil {
 			h.log.Error("failed to delete volume", "error", deleteErr)
+		} else {
+			h.auditLog(request, models.AuditActionVolumeDelete,
+				models.AuditResourceVolume, appID,
+				"deleted volume: "+volume.HostPath+":"+volume.ContainerPath)
 		}
 
 		http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)
@@ -1168,6 +1224,10 @@ func (h *Handlers) HandlePortAdd() http.HandlerFunc {
 		saveErr := port.Save(request.Context())
 		if saveErr != nil {
 			h.log.Error("failed to save port", "error", saveErr)
+		} else {
+			h.auditLog(request, models.AuditActionPortAdd,
+				models.AuditResourcePort, application.ID,
+				fmt.Sprintf("added port: %d:%d/%s", hostPort, containerPort, protocol))
 		}
 
 		http.Redirect(writer, request, "/apps/"+application.ID, http.StatusSeeOther)
@@ -1214,6 +1274,10 @@ func (h *Handlers) HandlePortDelete() http.HandlerFunc {
 		deleteErr := port.Delete(request.Context())
 		if deleteErr != nil {
 			h.log.Error("failed to delete port", "error", deleteErr)
+		} else {
+			h.auditLog(request, models.AuditActionPortDelete,
+				models.AuditResourcePort, appID,
+				fmt.Sprintf("deleted port: %d:%d/%s", port.HostPort, port.ContainerPort, port.Protocol))
 		}
 
 		http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)
@@ -1289,6 +1353,9 @@ func (h *Handlers) HandleLabelEdit() http.HandlerFunc {
 		saveErr := label.Save(request.Context())
 		if saveErr != nil {
 			h.log.Error("failed to update label", "error", saveErr)
+		} else {
+			h.auditLog(request, models.AuditActionLabelEdit,
+				models.AuditResourceLabel, appID, "edited label: "+key)
 		}
 
 		http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)
@@ -1347,6 +1414,10 @@ func (h *Handlers) HandleVolumeEdit() http.HandlerFunc {
 		saveErr := volume.Save(request.Context())
 		if saveErr != nil {
 			h.log.Error("failed to update volume", "error", saveErr)
+		} else {
+			h.auditLog(request, models.AuditActionVolumeEdit,
+				models.AuditResourceVolume, appID,
+				"edited volume: "+hostPath+":"+containerPath)
 		}
 
 		http.Redirect(writer, request, "/apps/"+appID, http.StatusSeeOther)

internal/handlers/auth.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"net/http"
 
+	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/templates"
 )
 
@@ -61,6 +62,9 @@ func (h *Handlers) HandleLoginPOST() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionLogin,
+			models.AuditResourceSession, "", "user logged in")
+
 		http.Redirect(writer, request, "/", http.StatusSeeOther)
 	}
 }
@@ -68,6 +72,9 @@ func (h *Handlers) HandleLoginPOST() http.HandlerFunc {
 // HandleLogout handles logout requests.
 func (h *Handlers) HandleLogout() http.HandlerFunc {
 	return func(writer http.ResponseWriter, request *http.Request) {
+		h.auditLog(request, models.AuditActionLogout,
+			models.AuditResourceSession, "", "user logged out")
+
 		destroyErr := h.auth.DestroySession(writer, request)
 		if destroyErr != nil {
 			h.log.Error("failed to destroy session", "error", destroyErr)

internal/handlers/backup.go

@@ -1,282 +0,0 @@
-package handlers
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/go-chi/chi/v5"
-
-	"sneak.berlin/go/upaas/internal/models"
-	"sneak.berlin/go/upaas/internal/service/app"
-	"sneak.berlin/go/upaas/templates"
-)
-
-// importMaxBodyBytes is the maximum allowed request body size for backup import (10 MB).
-const importMaxBodyBytes = 10 << 20
-
-// HandleExportApp exports a single app's configuration as a JSON download.
-func (h *Handlers) HandleExportApp() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		appID := chi.URLParam(request, "id")
-
-		application, findErr := models.FindApp(request.Context(), h.db, appID)
-		if findErr != nil || application == nil {
-			http.NotFound(writer, request)
-
-			return
-		}
-
-		bundle, exportErr := h.appService.ExportApp(request.Context(), application)
-		if exportErr != nil {
-			h.log.Error("failed to export app", "error", exportErr, "app", application.Name)
-			http.Error(writer, "Internal Server Error", http.StatusInternalServerError)
-
-			return
-		}
-
-		filename := fmt.Sprintf("upaas-backup-%s-%s.json",
-			application.Name,
-			time.Now().UTC().Format("20060102-150405"),
-		)
-
-		writer.Header().Set("Content-Type", "application/json")
-		writer.Header().Set("Content-Disposition",
-			`attachment; filename="`+filename+`"`)
-
-		encoder := json.NewEncoder(writer)
-		encoder.SetIndent("", "  ")
-
-		err := encoder.Encode(bundle)
-		if err != nil {
-			h.log.Error("failed to encode backup", "error", err)
-		}
-	}
-}
-
-// HandleExportAllApps exports all app configurations as a JSON download.
-func (h *Handlers) HandleExportAllApps() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		bundle, exportErr := h.appService.ExportAllApps(request.Context())
-		if exportErr != nil {
-			h.log.Error("failed to export all apps", "error", exportErr)
-			http.Error(writer, "Internal Server Error", http.StatusInternalServerError)
-
-			return
-		}
-
-		filename := fmt.Sprintf("upaas-backup-all-%s.json",
-			time.Now().UTC().Format("20060102-150405"),
-		)
-
-		writer.Header().Set("Content-Type", "application/json")
-		writer.Header().Set("Content-Disposition",
-			`attachment; filename="`+filename+`"`)
-
-		encoder := json.NewEncoder(writer)
-		encoder.SetIndent("", "  ")
-
-		err := encoder.Encode(bundle)
-		if err != nil {
-			h.log.Error("failed to encode backup", "error", err)
-		}
-	}
-}
-
-// HandleImportPage renders the import/restore page.
-func (h *Handlers) HandleImportPage() http.HandlerFunc {
-	tmpl := templates.GetParsed()
-
-	return func(writer http.ResponseWriter, request *http.Request) {
-		data := h.addGlobals(map[string]any{
-			"Success": request.URL.Query().Get("success"),
-		}, request)
-
-		h.renderTemplate(writer, tmpl, "backup_import.html", data)
-	}
-}
-
-// HandleImportApps processes an uploaded backup JSON file and imports apps.
-func (h *Handlers) HandleImportApps() http.HandlerFunc {
-	tmpl := templates.GetParsed()
-
-	return func(writer http.ResponseWriter, request *http.Request) {
-		bundle, parseErr := h.parseBackupUpload(request)
-		if parseErr != "" {
-			data := h.addGlobals(map[string]any{"Error": parseErr}, request)
-			h.renderTemplate(writer, tmpl, "backup_import.html", data)
-
-			return
-		}
-
-		imported, skipped, importErr := h.appService.ImportApps(
-			request.Context(), bundle,
-		)
-		if importErr != nil {
-			h.log.Error("failed to import apps", "error", importErr)
-
-			data := h.addGlobals(map[string]any{
-				"Error": "Import failed: " + importErr.Error(),
-			}, request)
-			h.renderTemplate(writer, tmpl, "backup_import.html", data)
-
-			return
-		}
-
-		successMsg := fmt.Sprintf("Imported %d app(s)", len(imported))
-		if len(skipped) > 0 {
-			successMsg += fmt.Sprintf(", skipped %d (name conflict)", len(skipped))
-		}
-
-		http.Redirect(writer, request,
-			"/backup/import?success="+successMsg,
-			http.StatusSeeOther,
-		)
-	}
-}
-
-// parseBackupUpload extracts and validates a BackupBundle from a multipart upload.
-// Returns the bundle and an empty string on success, or nil and an error message.
-func (h *Handlers) parseBackupUpload(
-	request *http.Request,
-) (*app.BackupBundle, string) {
-	request.Body = http.MaxBytesReader(nil, request.Body, importMaxBodyBytes)
-
-	parseErr := request.ParseMultipartForm(importMaxBodyBytes)
-	if parseErr != nil {
-		return nil, "Failed to parse upload: " + parseErr.Error()
-	}
-
-	file, _, openErr := request.FormFile("backup_file")
-	if openErr != nil {
-		return nil, "Please select a backup file to import"
-	}
-
-	defer func() { _ = file.Close() }()
-
-	var bundle app.BackupBundle
-
-	decodeErr := json.NewDecoder(file).Decode(&bundle)
-	if decodeErr != nil {
-		return nil, "Invalid backup file: " + decodeErr.Error()
-	}
-
-	if bundle.Version != 1 {
-		return nil, fmt.Sprintf(
-			"Unsupported backup version: %d (expected 1)", bundle.Version,
-		)
-	}
-
-	if len(bundle.Apps) == 0 {
-		return nil, "Backup file contains no apps"
-	}
-
-	return &bundle, ""
-}
-
-// HandleAPIExportApp exports a single app's configuration as JSON via API.
-func (h *Handlers) HandleAPIExportApp() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		appID := chi.URLParam(request, "id")
-
-		application, err := h.appService.GetApp(request.Context(), appID)
-		if err != nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "internal server error"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		if application == nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "app not found"},
-				http.StatusNotFound)
-
-			return
-		}
-
-		bundle, exportErr := h.appService.ExportApp(request.Context(), application)
-		if exportErr != nil {
-			h.log.Error("failed to export app", "error", exportErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "failed to export app"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		h.respondJSON(writer, request, bundle, http.StatusOK)
-	}
-}
-
-// HandleAPIExportAllApps exports all app configurations as JSON via API.
-func (h *Handlers) HandleAPIExportAllApps() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		bundle, exportErr := h.appService.ExportAllApps(request.Context())
-		if exportErr != nil {
-			h.log.Error("failed to export all apps", "error", exportErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "failed to export apps"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		h.respondJSON(writer, request, bundle, http.StatusOK)
-	}
-}
-
-// HandleAPIImportApps imports app configurations from a JSON request body via API.
-func (h *Handlers) HandleAPIImportApps() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		request.Body = http.MaxBytesReader(writer, request.Body, importMaxBodyBytes)
-
-		var bundle app.BackupBundle
-
-		decodeErr := json.NewDecoder(request.Body).Decode(&bundle)
-		if decodeErr != nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "invalid request body"},
-				http.StatusBadRequest)
-
-			return
-		}
-
-		if bundle.Version != 1 {
-			h.respondJSON(writer, request,
-				map[string]string{"error": fmt.Sprintf(
-					"unsupported backup version: %d", bundle.Version,
-				)},
-				http.StatusBadRequest)
-
-			return
-		}
-
-		if len(bundle.Apps) == 0 {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "backup contains no apps"},
-				http.StatusBadRequest)
-
-			return
-		}
-
-		imported, skipped, importErr := h.appService.ImportApps(
-			request.Context(), &bundle,
-		)
-		if importErr != nil {
-			h.log.Error("api: failed to import apps", "error", importErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "import failed: " + importErr.Error()},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		h.respondJSON(writer, request, map[string]any{
-			"imported": imported,
-			"skipped":  skipped,
-		}, http.StatusOK)
-	}
-}

internal/handlers/backup_test.go

@@ -1,582 +0,0 @@
-package handlers_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"sneak.berlin/go/upaas/internal/models"
-	"sneak.berlin/go/upaas/internal/service/app"
-)
-
-// createTestAppWithConfig creates an app with env vars, labels, volumes, and ports.
-func createTestAppWithConfig(
-	t *testing.T,
-	tc *testContext,
-	name string,
-) *models.App {
-	t.Helper()
-
-	createdApp := createTestApp(t, tc, name)
-
-	// Add env vars
-	ev := models.NewEnvVar(tc.database)
-	ev.AppID = createdApp.ID
-	ev.Key = "DATABASE_URL"
-	ev.Value = "postgres://localhost/mydb"
-	require.NoError(t, ev.Save(context.Background()))
-
-	// Add label
-	label := models.NewLabel(tc.database)
-	label.AppID = createdApp.ID
-	label.Key = "traefik.enable"
-	label.Value = "true"
-	require.NoError(t, label.Save(context.Background()))
-
-	// Add volume
-	volume := models.NewVolume(tc.database)
-	volume.AppID = createdApp.ID
-	volume.HostPath = "/data/app"
-	volume.ContainerPath = "/app/data"
-	volume.ReadOnly = false
-	require.NoError(t, volume.Save(context.Background()))
-
-	// Add port
-	port := models.NewPort(tc.database)
-	port.AppID = createdApp.ID
-	port.HostPort = 8080
-	port.ContainerPort = 80
-	port.Protocol = models.PortProtocolTCP
-	require.NoError(t, port.Save(context.Background()))
-
-	return createdApp
-}
-
-// createTestAppWithConfigPort creates an app with a custom host port.
-func createTestAppWithConfigPort(
-	t *testing.T,
-	tc *testContext,
-	name string,
-	hostPort int,
-) *models.App {
-	t.Helper()
-
-	createdApp := createTestApp(t, tc, name)
-
-	ev := models.NewEnvVar(tc.database)
-	ev.AppID = createdApp.ID
-	ev.Key = "DATABASE_URL"
-	ev.Value = "postgres://localhost/mydb"
-	require.NoError(t, ev.Save(context.Background()))
-
-	port := models.NewPort(tc.database)
-	port.AppID = createdApp.ID
-	port.HostPort = hostPort
-	port.ContainerPort = 80
-	port.Protocol = models.PortProtocolTCP
-	require.NoError(t, port.Save(context.Background()))
-
-	return createdApp
-}
-
-func TestHandleExportApp(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-	createdApp := createTestAppWithConfig(t, testCtx, "export-test-app")
-
-	request := httptest.NewRequest(http.MethodGet, "/apps/"+createdApp.ID+"/export", nil)
-	request = addChiURLParams(request, map[string]string{"id": createdApp.ID})
-
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleExportApp()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Header().Get("Content-Type"), "application/json")
-	assert.Contains(t, recorder.Header().Get("Content-Disposition"), "attachment")
-	assert.Contains(t, recorder.Header().Get("Content-Disposition"), "export-test-app")
-
-	var bundle app.BackupBundle
-	require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &bundle))
-
-	assert.Equal(t, 1, bundle.Version)
-	assert.NotEmpty(t, bundle.ExportedAt)
-	require.Len(t, bundle.Apps, 1)
-
-	appBackup := bundle.Apps[0]
-	assert.Equal(t, "export-test-app", appBackup.Name)
-	assert.Equal(t, "main", appBackup.Branch)
-	assert.Len(t, appBackup.EnvVars, 1)
-	assert.Equal(t, "DATABASE_URL", appBackup.EnvVars[0].Key)
-	assert.Equal(t, "postgres://localhost/mydb", appBackup.EnvVars[0].Value)
-	assert.Len(t, appBackup.Labels, 1)
-	assert.Equal(t, "traefik.enable", appBackup.Labels[0].Key)
-	assert.Len(t, appBackup.Volumes, 1)
-	assert.Equal(t, "/data/app", appBackup.Volumes[0].HostPath)
-	assert.Len(t, appBackup.Ports, 1)
-	assert.Equal(t, 8080, appBackup.Ports[0].HostPort)
-}
-
-func TestHandleExportAppNotFound(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	request := httptest.NewRequest(http.MethodGet, "/apps/nonexistent/export", nil)
-	request = addChiURLParams(request, map[string]string{"id": "nonexistent"})
-
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleExportApp()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusNotFound, recorder.Code)
-}
-
-func TestHandleExportAllApps(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-	createTestAppWithConfig(t, testCtx, "export-all-app1")
-	createTestAppWithConfigPort(t, testCtx, "export-all-app2", 8081)
-
-	request := httptest.NewRequest(http.MethodGet, "/backup/export", nil)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleExportAllApps()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Header().Get("Content-Disposition"), "upaas-backup-all")
-
-	var bundle app.BackupBundle
-	require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &bundle))
-
-	assert.Equal(t, 1, bundle.Version)
-	assert.Len(t, bundle.Apps, 2)
-}
-
-func TestHandleExportAllAppsEmpty(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	request := httptest.NewRequest(http.MethodGet, "/backup/export", nil)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleExportAllApps()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-
-	var bundle app.BackupBundle
-	require.NoError(t, json.Unmarshal(recorder.Body.Bytes(), &bundle))
-
-	assert.Empty(t, bundle.Apps)
-}
-
-// createMultipartBackupRequest builds a multipart form request with backup JSON as a file upload.
-func createMultipartBackupRequest(
-	t *testing.T,
-	backupJSON string,
-) *http.Request {
-	t.Helper()
-
-	var body bytes.Buffer
-
-	writer := multipart.NewWriter(&body)
-
-	part, err := writer.CreateFormFile("backup_file", "backup.json")
-	require.NoError(t, err)
-
-	_, err = io.WriteString(part, backupJSON)
-	require.NoError(t, err)
-
-	require.NoError(t, writer.Close())
-
-	request := httptest.NewRequest(http.MethodPost, "/backup/import", &body)
-	request.Header.Set("Content-Type", writer.FormDataContentType())
-
-	return request
-}
-
-func TestHandleImportApps(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	backupJSON := `{
-		"version": 1,
-		"exportedAt": "2025-01-01T00:00:00Z",
-		"apps": [{
-			"name": "imported-app",
-			"repoUrl": "git@example.com:user/repo.git",
-			"branch": "main",
-			"dockerfilePath": "Dockerfile",
-			"envVars": [{"key": "FOO", "value": "bar"}],
-			"labels": [{"key": "app.name", "value": "test"}],
-			"volumes": [{"hostPath": "/data", "containerPath": "/app/data", "readOnly": true}],
-			"ports": [{"hostPort": 3000, "containerPort": 8080, "protocol": "tcp"}]
-		}]
-	}`
-
-	request := createMultipartBackupRequest(t, backupJSON)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportApps()
-	handler.ServeHTTP(recorder, request)
-
-	// Should redirect on success
-	assert.Equal(t, http.StatusSeeOther, recorder.Code)
-	assert.Contains(t, recorder.Header().Get("Location"), "success=")
-
-	// Verify the app was created
-	apps, err := models.AllApps(context.Background(), testCtx.database)
-	require.NoError(t, err)
-	require.Len(t, apps, 1)
-	assert.Equal(t, "imported-app", apps[0].Name)
-
-	// Verify env vars
-	envVars, _ := apps[0].GetEnvVars(context.Background())
-	require.Len(t, envVars, 1)
-	assert.Equal(t, "FOO", envVars[0].Key)
-	assert.Equal(t, "bar", envVars[0].Value)
-
-	// Verify labels
-	labels, _ := apps[0].GetLabels(context.Background())
-	require.Len(t, labels, 1)
-	assert.Equal(t, "app.name", labels[0].Key)
-
-	// Verify volumes
-	volumes, _ := apps[0].GetVolumes(context.Background())
-	require.Len(t, volumes, 1)
-	assert.Equal(t, "/data", volumes[0].HostPath)
-	assert.True(t, volumes[0].ReadOnly)
-
-	// Verify ports
-	ports, _ := apps[0].GetPorts(context.Background())
-	require.Len(t, ports, 1)
-	assert.Equal(t, 3000, ports[0].HostPort)
-	assert.Equal(t, 8080, ports[0].ContainerPort)
-}
-
-func TestHandleImportAppsSkipsDuplicateNames(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	// Create an existing app with same name
-	createTestApp(t, testCtx, "existing-app")
-
-	backupJSON := `{
-		"version": 1,
-		"exportedAt": "2025-01-01T00:00:00Z",
-		"apps": [
-			{
-				"name": "existing-app",
-				"repoUrl": "git@example.com:user/repo.git",
-				"branch": "main",
-				"dockerfilePath": "Dockerfile",
-				"envVars": [],
-				"labels": [],
-				"volumes": [],
-				"ports": []
-			},
-			{
-				"name": "new-app",
-				"repoUrl": "git@example.com:user/new.git",
-				"branch": "main",
-				"dockerfilePath": "Dockerfile",
-				"envVars": [],
-				"labels": [],
-				"volumes": [],
-				"ports": []
-			}
-		]
-	}`
-
-	request := createMultipartBackupRequest(t, backupJSON)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportApps()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusSeeOther, recorder.Code)
-	assert.Contains(t, recorder.Header().Get("Location"), "skipped")
-
-	// Should have 2 apps total (existing + new)
-	apps, err := models.AllApps(context.Background(), testCtx.database)
-	require.NoError(t, err)
-	assert.Len(t, apps, 2)
-}
-
-func TestHandleImportAppsInvalidJSON(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	request := createMultipartBackupRequest(t, "not valid json")
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportApps()
-	handler.ServeHTTP(recorder, request)
-
-	// Should render the page with error, not redirect
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Body.String(), "Invalid backup file")
-}
-
-func TestHandleImportAppsUnsupportedVersion(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	backupJSON := `{"version": 99, "exportedAt": "2025-01-01T00:00:00Z", "apps": [{"name": "test"}]}`
-
-	request := createMultipartBackupRequest(t, backupJSON)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportApps()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Body.String(), "Unsupported backup version")
-}
-
-func TestHandleImportAppsEmptyBundle(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	backupJSON := `{"version": 1, "exportedAt": "2025-01-01T00:00:00Z", "apps": []}`
-
-	request := createMultipartBackupRequest(t, backupJSON)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportApps()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Body.String(), "contains no apps")
-}
-
-func TestHandleImportPage(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-
-	request := httptest.NewRequest(http.MethodGet, "/backup/import", nil)
-	recorder := httptest.NewRecorder()
-
-	handler := testCtx.handlers.HandleImportPage()
-	handler.ServeHTTP(recorder, request)
-
-	assert.Equal(t, http.StatusOK, recorder.Code)
-	assert.Contains(t, recorder.Body.String(), "Import Backup")
-}
-
-func TestExportImportRoundTrip(t *testing.T) {
-	t.Parallel()
-
-	testCtx := setupTestHandlers(t)
-	createTestAppWithConfig(t, testCtx, "roundtrip-app")
-
-	// Export
-	exportReq := httptest.NewRequest(http.MethodGet, "/backup/export", nil)
-	exportRec := httptest.NewRecorder()
-
-	testCtx.handlers.HandleExportAllApps().ServeHTTP(exportRec, exportReq)
-
-	require.Equal(t, http.StatusOK, exportRec.Code)
-
-	exportedJSON := exportRec.Body.String()
-
-	// Delete the original app
-	apps, _ := models.AllApps(context.Background(), testCtx.database)
-	for _, a := range apps {
-		require.NoError(t, a.Delete(context.Background()))
-	}
-
-	// Import
-	importReq := createMultipartBackupRequest(t, exportedJSON)
-	importRec := httptest.NewRecorder()
-
-	testCtx.handlers.HandleImportApps().ServeHTTP(importRec, importReq)
-
-	assert.Equal(t, http.StatusSeeOther, importRec.Code)
-
-	// Verify the app was recreated with all config
-	restoredApps, _ := models.AllApps(context.Background(), testCtx.database)
-	require.Len(t, restoredApps, 1)
-	assert.Equal(t, "roundtrip-app", restoredApps[0].Name)
-
-	envVars, _ := restoredApps[0].GetEnvVars(context.Background())
-	assert.Len(t, envVars, 1)
-
-	labels, _ := restoredApps[0].GetLabels(context.Background())
-	assert.Len(t, labels, 1)
-
-	volumes, _ := restoredApps[0].GetVolumes(context.Background())
-	assert.Len(t, volumes, 1)
-
-	ports, _ := restoredApps[0].GetPorts(context.Background())
-	assert.Len(t, ports, 1)
-}
-
-// TestAPIExportApp tests the API endpoint for exporting a single app.
-func TestAPIExportApp(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	createdApp, err := tc.appSvc.CreateApp(t.Context(), app.CreateAppInput{
-		Name:    "api-export-app",
-		RepoURL: "git@example.com:user/repo.git",
-	})
-	require.NoError(t, err)
-
-	rr := apiGet(t, tc, cookies, "/api/v1/apps/"+createdApp.ID+"/export")
-	assert.Equal(t, http.StatusOK, rr.Code)
-
-	var bundle app.BackupBundle
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &bundle))
-
-	assert.Equal(t, 1, bundle.Version)
-	require.Len(t, bundle.Apps, 1)
-	assert.Equal(t, "api-export-app", bundle.Apps[0].Name)
-}
-
-// TestAPIExportAppNotFound tests the API endpoint for a nonexistent app.
-func TestAPIExportAppNotFound(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	rr := apiGet(t, tc, cookies, "/api/v1/apps/nonexistent/export")
-	assert.Equal(t, http.StatusNotFound, rr.Code)
-}
-
-// TestAPIExportAllApps tests the API endpoint for exporting all apps.
-func TestAPIExportAllApps(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	_, err := tc.appSvc.CreateApp(t.Context(), app.CreateAppInput{
-		Name:    "api-export-all-1",
-		RepoURL: "git@example.com:user/repo1.git",
-	})
-	require.NoError(t, err)
-
-	_, err = tc.appSvc.CreateApp(t.Context(), app.CreateAppInput{
-		Name:    "api-export-all-2",
-		RepoURL: "git@example.com:user/repo2.git",
-	})
-	require.NoError(t, err)
-
-	rr := apiGet(t, tc, cookies, "/api/v1/backup/export")
-	assert.Equal(t, http.StatusOK, rr.Code)
-
-	var bundle app.BackupBundle
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &bundle))
-
-	assert.Len(t, bundle.Apps, 2)
-}
-
-// TestAPIImportApps tests the API import endpoint.
-func TestAPIImportApps(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	backupJSON := `{
-		"version": 1,
-		"exportedAt": "2025-01-01T00:00:00Z",
-		"apps": [{
-			"name": "api-imported-app",
-			"repoUrl": "git@example.com:user/repo.git",
-			"branch": "main",
-			"dockerfilePath": "Dockerfile",
-			"envVars": [],
-			"labels": [],
-			"volumes": [],
-			"ports": []
-		}]
-	}`
-
-	r := apiRouter(tc)
-
-	req := httptest.NewRequest(http.MethodPost, "/api/v1/backup/import", strings.NewReader(backupJSON))
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusOK, rr.Code)
-
-	var resp map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &resp))
-
-	imported, ok := resp["imported"].([]any)
-	require.True(t, ok)
-	assert.Len(t, imported, 1)
-	assert.Equal(t, "api-imported-app", imported[0])
-}
-
-// TestAPIImportAppsInvalidBody tests that the API rejects bad JSON.
-func TestAPIImportAppsInvalidBody(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	r := apiRouter(tc)
-
-	req := httptest.NewRequest(http.MethodPost, "/api/v1/backup/import", strings.NewReader("not json"))
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusBadRequest, rr.Code)
-}
-
-// TestAPIImportAppsUnsupportedVersion tests that the API rejects bad versions.
-func TestAPIImportAppsUnsupportedVersion(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-
-	r := apiRouter(tc)
-
-	body := `{"version": 42, "apps": [{"name": "x"}]}`
-	req := httptest.NewRequest(http.MethodPost, "/api/v1/backup/import", strings.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusBadRequest, rr.Code)
-}

internal/handlers/handlers.go

@@ -15,7 +15,9 @@ import (
 	"sneak.berlin/go/upaas/internal/globals"
 	"sneak.berlin/go/upaas/internal/healthcheck"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/internal/service/app"
+	"sneak.berlin/go/upaas/internal/service/audit"
 	"sneak.berlin/go/upaas/internal/service/auth"
 	"sneak.berlin/go/upaas/internal/service/deploy"
 	"sneak.berlin/go/upaas/internal/service/webhook"
@@ -35,6 +37,7 @@ type Params struct {
 	Deploy      *deploy.Service
 	Webhook     *webhook.Service
 	Docker      *docker.Client
+	Audit       *audit.Service
 }
 
 // Handlers provides HTTP request handlers.
@@ -48,6 +51,7 @@ type Handlers struct {
 	deploy     *deploy.Service
 	webhook    *webhook.Service
 	docker     *docker.Client
+	audit      *audit.Service
 	globals    *globals.Globals
 }
 
@@ -63,10 +67,48 @@ func New(_ fx.Lifecycle, params Params) (*Handlers, error) {
 		deploy:     params.Deploy,
 		webhook:    params.Webhook,
 		docker:     params.Docker,
+		audit:      params.Audit,
 		globals:    params.Globals,
 	}, nil
 }
 
+// currentUser returns the currently authenticated user, or nil if not authenticated.
+func (h *Handlers) currentUser(request *http.Request) *models.User {
+	user, err := h.auth.GetCurrentUser(request.Context(), request)
+	if err != nil || user == nil {
+		return nil
+	}
+
+	return user
+}
+
+// auditLog records an audit entry for the current request.
+func (h *Handlers) auditLog(
+	request *http.Request,
+	action models.AuditAction,
+	resourceType models.AuditResourceType,
+	resourceID string,
+	detail string,
+) {
+	user := h.currentUser(request)
+
+	entry := audit.LogEntry{
+		Action:       action,
+		ResourceType: resourceType,
+		ResourceID:   resourceID,
+		Detail:       detail,
+	}
+
+	if user != nil {
+		entry.UserID = user.ID
+		entry.Username = user.Username
+	} else {
+		entry.Username = "anonymous"
+	}
+
+	h.audit.LogFromRequest(request.Context(), request, entry)
+}
+
 // addGlobals adds version info and CSRF token to template data map.
 func (h *Handlers) addGlobals(
 	data map[string]any,

internal/handlers/handlers_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/go-chi/chi/v5"
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
@@ -24,8 +25,10 @@ import (
 	"sneak.berlin/go/upaas/internal/handlers"
 	"sneak.berlin/go/upaas/internal/healthcheck"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/middleware"
 	"sneak.berlin/go/upaas/internal/service/app"
+	"sneak.berlin/go/upaas/internal/service/audit"
 	"sneak.berlin/go/upaas/internal/service/auth"
 	"sneak.berlin/go/upaas/internal/service/deploy"
 	"sneak.berlin/go/upaas/internal/service/notify"
@@ -92,7 +95,8 @@ func createAppServices(
 	logInstance *logger.Logger,
 	dbInstance *database.Database,
 	cfg *config.Config,
-) (*auth.Service, *app.Service, *deploy.Service, *webhook.Service, *docker.Client) {
+	metricsInstance *metrics.Metrics,
+) (*auth.Service, *app.Service, *deploy.Service, *webhook.Service, *docker.Client, *audit.Service) {
 	t.Helper()
 
 	authSvc, authErr := auth.New(fx.Lifecycle(nil), auth.ServiceParams{
@@ -125,6 +129,7 @@ func createAppServices(
 		Database: dbInstance,
 		Docker:   dockerClient,
 		Notify:   notifySvc,
+		Metrics:  metricsInstance,
 	})
 	require.NoError(t, deployErr)
 
@@ -132,10 +137,18 @@ func createAppServices(
 		Logger:   logInstance,
 		Database: dbInstance,
 		Deploy:   deploySvc,
+		Metrics:  metricsInstance,
 	})
 	require.NoError(t, webhookErr)
 
-	return authSvc, appSvc, deploySvc, webhookSvc, dockerClient
+	auditSvc, auditErr := audit.New(fx.Lifecycle(nil), audit.ServiceParams{
+		Logger:   logInstance,
+		Database: dbInstance,
+		Metrics:  metricsInstance,
+	})
+	require.NoError(t, auditErr)
+
+	return authSvc, appSvc, deploySvc, webhookSvc, dockerClient, auditSvc
 }
 
 func setupTestHandlers(t *testing.T) *testContext {
@@ -145,11 +158,14 @@ func setupTestHandlers(t *testing.T) *testContext {
 
 	globalInstance, logInstance, dbInstance, hcInstance := createCoreServices(t, cfg)
 
-	authSvc, appSvc, deploySvc, webhookSvc, dockerClient := createAppServices(
+	metricsInstance := metrics.NewForTest(prometheus.NewRegistry())
+
+	authSvc, appSvc, deploySvc, webhookSvc, dockerClient, auditSvc := createAppServices(
 		t,
 		logInstance,
 		dbInstance,
 		cfg,
+		metricsInstance,
 	)
 
 	handlersInstance, handlerErr := handlers.New(
@@ -164,6 +180,7 @@ func setupTestHandlers(t *testing.T) *testContext {
 			Deploy:      deploySvc,
 			Webhook:     webhookSvc,
 			Docker:      dockerClient,
+			Audit:       auditSvc,
 		},
 	)
 	require.NoError(t, handlerErr)
@@ -173,6 +190,7 @@ func setupTestHandlers(t *testing.T) *testContext {
 		Globals: globalInstance,
 		Config:  cfg,
 		Auth:    authSvc,
+		Metrics: metricsInstance,
 	})
 	require.NoError(t, mwErr)
 

internal/handlers/setup.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"net/http"
 
+	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/templates"
 )
 
@@ -111,6 +112,9 @@ func (h *Handlers) HandleSetupPOST() http.HandlerFunc {
 			return
 		}
 
+		h.auditLog(request, models.AuditActionSetup,
+			models.AuditResourceUser, "", "initial setup completed")
+
 		http.Redirect(writer, request, "/", http.StatusSeeOther)
 	}
 }

internal/handlers/webhook.go

@@ -7,13 +7,14 @@ import (
 	"github.com/go-chi/chi/v5"
 
 	"sneak.berlin/go/upaas/internal/models"
+	"sneak.berlin/go/upaas/internal/service/audit"
 )
 
 // maxWebhookBodySize is the maximum allowed size of a webhook request body (1MB).
 const maxWebhookBodySize = 1 << 20
 
 // HandleWebhook handles incoming Gitea webhooks.
-func (h *Handlers) HandleWebhook() http.HandlerFunc {
+func (h *Handlers) HandleWebhook() http.HandlerFunc { //nolint:funlen // audit logging adds necessary length
 	return func(writer http.ResponseWriter, request *http.Request) {
 		secret := chi.URLParam(request, "secret")
 		if secret == "" {
@@ -56,6 +57,15 @@ func (h *Handlers) HandleWebhook() http.HandlerFunc {
 			eventType = "push"
 		}
 
+		// Log webhook receipt
+		h.audit.LogFromRequest(request.Context(), request, audit.LogEntry{
+			Username:     "webhook",
+			Action:       models.AuditActionWebhookReceive,
+			ResourceType: models.AuditResourceWebhook,
+			ResourceID:   application.ID,
+			Detail:       "webhook from app: " + application.Name + ", event: " + eventType,
+		})
+
 		// Process webhook
 		webhookErr := h.webhook.HandleWebhook(
 			request.Context(),

internal/metrics/metrics.go

@@ -0,0 +1,148 @@
+// Package metrics provides Prometheus metrics for upaas.
+//
+//nolint:revive // "metrics" matches the domain; runtime/metrics is rarely imported directly
+package metrics
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"go.uber.org/fx"
+)
+
+// Params contains dependencies for Metrics.
+type Params struct {
+	fx.In
+}
+
+// Metrics holds all Prometheus metrics for the application.
+type Metrics struct {
+	// Deployment metrics.
+	DeploymentsTotal    *prometheus.CounterVec
+	DeploymentDuration  *prometheus.HistogramVec
+	DeploymentsInFlight *prometheus.GaugeVec
+
+	// Container health metrics.
+	ContainerHealthy *prometheus.GaugeVec
+
+	// Webhook metrics.
+	WebhookEventsTotal *prometheus.CounterVec
+
+	// HTTP request metrics.
+	HTTPRequestsTotal     *prometheus.CounterVec
+	HTTPRequestDuration   *prometheus.HistogramVec
+	HTTPResponseSizeBytes *prometheus.HistogramVec
+
+	// Audit log metrics.
+	AuditEventsTotal *prometheus.CounterVec
+}
+
+// New creates a new Metrics instance with all Prometheus metrics registered
+// in the default Prometheus registry.
+func New(_ fx.Lifecycle, _ Params) (*Metrics, error) {
+	return newMetrics(promauto.With(prometheus.DefaultRegisterer)), nil
+}
+
+// NewForTest creates a Metrics instance with a custom registry for test isolation.
+func NewForTest(reg prometheus.Registerer) *Metrics {
+	return newMetrics(promauto.With(reg))
+}
+
+// newMetrics creates a Metrics instance using the given factory.
+func newMetrics(factory promauto.Factory) *Metrics {
+	return &Metrics{
+		DeploymentsTotal:      newDeploymentsTotal(factory),
+		DeploymentDuration:    newDeploymentDuration(factory),
+		DeploymentsInFlight:   newDeploymentsInFlight(factory),
+		ContainerHealthy:      newContainerHealthy(factory),
+		WebhookEventsTotal:    newWebhookEventsTotal(factory),
+		HTTPRequestsTotal:     newHTTPRequestsTotal(factory),
+		HTTPRequestDuration:   newHTTPRequestDuration(factory),
+		HTTPResponseSizeBytes: newHTTPResponseSizeBytes(factory),
+		AuditEventsTotal:      newAuditEventsTotal(factory),
+	}
+}
+
+func newDeploymentsTotal(f promauto.Factory) *prometheus.CounterVec {
+	return f.NewCounterVec(prometheus.CounterOpts{
+		Namespace: "upaas",
+		Subsystem: "deployments",
+		Name:      "total",
+		Help:      "Total number of deployments by app and status.",
+	}, []string{"app", "status"})
+}
+
+func newDeploymentDuration(f promauto.Factory) *prometheus.HistogramVec {
+	return f.NewHistogramVec(prometheus.HistogramOpts{
+		Namespace: "upaas",
+		Subsystem: "deployments",
+		Name:      "duration_seconds",
+		Help:      "Duration of deployments in seconds by app and status.",
+		Buckets:   []float64{10, 30, 60, 120, 300, 600, 1800},
+	}, []string{"app", "status"})
+}
+
+func newDeploymentsInFlight(f promauto.Factory) *prometheus.GaugeVec {
+	return f.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: "upaas",
+		Subsystem: "deployments",
+		Name:      "in_flight",
+		Help:      "Number of deployments currently in progress by app.",
+	}, []string{"app"})
+}
+
+func newContainerHealthy(f promauto.Factory) *prometheus.GaugeVec {
+	return f.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: "upaas",
+		Subsystem: "container",
+		Name:      "healthy",
+		Help:      "Whether the app container is healthy (1) or unhealthy (0).",
+	}, []string{"app"})
+}
+
+func newWebhookEventsTotal(f promauto.Factory) *prometheus.CounterVec {
+	return f.NewCounterVec(prometheus.CounterOpts{
+		Namespace: "upaas",
+		Subsystem: "webhook",
+		Name:      "events_total",
+		Help:      "Total number of webhook events by app, event type, and matched status.",
+	}, []string{"app", "event_type", "matched"})
+}
+
+func newHTTPRequestsTotal(f promauto.Factory) *prometheus.CounterVec {
+	return f.NewCounterVec(prometheus.CounterOpts{
+		Namespace: "upaas",
+		Subsystem: "http",
+		Name:      "requests_total",
+		Help:      "Total number of HTTP requests by method and status code.",
+	}, []string{"method", "status_code"})
+}
+
+func newHTTPRequestDuration(f promauto.Factory) *prometheus.HistogramVec {
+	return f.NewHistogramVec(prometheus.HistogramOpts{
+		Namespace: "upaas",
+		Subsystem: "http",
+		Name:      "request_duration_seconds",
+		Help:      "Duration of HTTP requests in seconds by method.",
+		Buckets:   prometheus.DefBuckets,
+	}, []string{"method"})
+}
+
+//nolint:mnd // bucket boundaries are domain-specific constants
+func newHTTPResponseSizeBytes(f promauto.Factory) *prometheus.HistogramVec {
+	return f.NewHistogramVec(prometheus.HistogramOpts{
+		Namespace: "upaas",
+		Subsystem: "http",
+		Name:      "response_size_bytes",
+		Help:      "Size of HTTP responses in bytes by method.",
+		Buckets:   prometheus.ExponentialBuckets(100, 10, 7),
+	}, []string{"method"})
+}
+
+func newAuditEventsTotal(f promauto.Factory) *prometheus.CounterVec {
+	return f.NewCounterVec(prometheus.CounterOpts{
+		Namespace: "upaas",
+		Subsystem: "audit",
+		Name:      "events_total",
+		Help:      "Total number of audit log events by action.",
+	}, []string{"action"})
+}

internal/metrics/metrics_test.go

@@ -0,0 +1,158 @@
+package metrics_test
+
+import (
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/fx"
+
+	"sneak.berlin/go/upaas/internal/metrics"
+)
+
+func TestNewForTest(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	require.NotNil(t, m)
+	assert.NotNil(t, m.DeploymentsTotal)
+	assert.NotNil(t, m.DeploymentDuration)
+	assert.NotNil(t, m.DeploymentsInFlight)
+	assert.NotNil(t, m.ContainerHealthy)
+	assert.NotNil(t, m.WebhookEventsTotal)
+	assert.NotNil(t, m.HTTPRequestsTotal)
+	assert.NotNil(t, m.HTTPRequestDuration)
+	assert.NotNil(t, m.HTTPResponseSizeBytes)
+	assert.NotNil(t, m.AuditEventsTotal)
+}
+
+func TestNew(t *testing.T) {
+	t.Parallel()
+
+	m, err := metrics.New(fx.Lifecycle(nil), metrics.Params{})
+	require.NoError(t, err)
+	require.NotNil(t, m)
+}
+
+func TestDeploymentMetrics(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	m.DeploymentsTotal.WithLabelValues("test-app", "success").Inc()
+	m.DeploymentDuration.WithLabelValues("test-app", "success").Observe(42.5)
+	m.DeploymentsInFlight.WithLabelValues("test-app").Set(1)
+
+	families, err := reg.Gather()
+	require.NoError(t, err)
+
+	names := make(map[string]bool)
+
+	for _, f := range families {
+		names[f.GetName()] = true
+	}
+
+	assert.True(t, names["upaas_deployments_total"])
+	assert.True(t, names["upaas_deployments_duration_seconds"])
+	assert.True(t, names["upaas_deployments_in_flight"])
+}
+
+func TestContainerHealthMetrics(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	m.ContainerHealthy.WithLabelValues("my-app").Set(1)
+
+	families, err := reg.Gather()
+	require.NoError(t, err)
+
+	found := false
+
+	for _, f := range families {
+		if f.GetName() == "upaas_container_healthy" {
+			found = true
+
+			break
+		}
+	}
+
+	assert.True(t, found)
+}
+
+func TestWebhookMetrics(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	m.WebhookEventsTotal.WithLabelValues("test-app", "push", "true").Inc()
+
+	families, err := reg.Gather()
+	require.NoError(t, err)
+
+	found := false
+
+	for _, f := range families {
+		if f.GetName() == "upaas_webhook_events_total" {
+			found = true
+
+			break
+		}
+	}
+
+	assert.True(t, found)
+}
+
+func TestHTTPMetrics(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	m.HTTPRequestsTotal.WithLabelValues("GET", "200").Inc()
+	m.HTTPRequestDuration.WithLabelValues("GET").Observe(0.05)
+	m.HTTPResponseSizeBytes.WithLabelValues("GET").Observe(1024)
+
+	families, err := reg.Gather()
+	require.NoError(t, err)
+
+	names := make(map[string]bool)
+
+	for _, f := range families {
+		names[f.GetName()] = true
+	}
+
+	assert.True(t, names["upaas_http_requests_total"])
+	assert.True(t, names["upaas_http_request_duration_seconds"])
+	assert.True(t, names["upaas_http_response_size_bytes"])
+}
+
+func TestAuditMetrics(t *testing.T) {
+	t.Parallel()
+
+	reg := prometheus.NewRegistry()
+	m := metrics.NewForTest(reg)
+
+	m.AuditEventsTotal.WithLabelValues("login").Inc()
+
+	families, err := reg.Gather()
+	require.NoError(t, err)
+
+	found := false
+
+	for _, f := range families {
+		if f.GetName() == "upaas_audit_events_total" {
+			found = true
+
+			break
+		}
+	}
+
+	assert.True(t, found)
+}

internal/middleware/middleware.go

@@ -21,6 +21,7 @@ import (
 	"sneak.berlin/go/upaas/internal/config"
 	"sneak.berlin/go/upaas/internal/globals"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/service/auth"
 )
 
@@ -35,33 +36,37 @@ type Params struct {
 	Globals *globals.Globals
 	Config  *config.Config
 	Auth    *auth.Service
+	Metrics *metrics.Metrics
 }
 
 // Middleware provides HTTP middleware.
 type Middleware struct {
-	log    *slog.Logger
-	params *Params
+	log     *slog.Logger
+	metrics *metrics.Metrics
+	params  *Params
 }
 
 // New creates a new Middleware instance.
 func New(_ fx.Lifecycle, params Params) (*Middleware, error) {
 	return &Middleware{
-		log:    params.Logger.Get(),
-		params: &params,
+		log:     params.Logger.Get(),
+		metrics: params.Metrics,
+		params:  &params,
 	}, nil
 }
 
-// loggingResponseWriter wraps http.ResponseWriter to capture status code.
+// loggingResponseWriter wraps http.ResponseWriter to capture status code and bytes written.
 type loggingResponseWriter struct {
 	http.ResponseWriter
 
-	statusCode int
+	statusCode   int
+	bytesWritten int
 }
 
 func newLoggingResponseWriter(
 	writer http.ResponseWriter,
 ) *loggingResponseWriter {
-	return &loggingResponseWriter{writer, http.StatusOK}
+	return &loggingResponseWriter{ResponseWriter: writer, statusCode: http.StatusOK}
 }
 
 func (lrw *loggingResponseWriter) WriteHeader(code int) {
@@ -69,7 +74,14 @@ func (lrw *loggingResponseWriter) WriteHeader(code int) {
 	lrw.ResponseWriter.WriteHeader(code)
 }
 
-// Logging returns a request logging middleware.
+func (lrw *loggingResponseWriter) Write(b []byte) (int, error) {
+	n, err := lrw.ResponseWriter.Write(b)
+	lrw.bytesWritten += n
+
+	return n, err
+}
+
+// Logging returns a request logging middleware that also records HTTP metrics.
 func (m *Middleware) Logging() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(
@@ -83,6 +95,8 @@ func (m *Middleware) Logging() func(http.Handler) http.Handler {
 			defer func() {
 				latency := time.Since(start)
 				reqID := middleware.GetReqID(ctx)
+				statusStr := strconv.Itoa(lrw.statusCode)
+
 				m.log.InfoContext(ctx, "request",
 					"request_start", start,
 					"method", request.Method,
@@ -91,10 +105,21 @@ func (m *Middleware) Logging() func(http.Handler) http.Handler {
 					"request_id", reqID,
 					"referer", request.Referer(),
 					"proto", request.Proto,
-					"remoteIP", realIP(request),
+					"remoteIP", RealIP(request),
 					"status", lrw.statusCode,
+					"bytes", lrw.bytesWritten,
 					"latency_ms", latency.Milliseconds(),
 				)
+
+				m.metrics.HTTPRequestsTotal.WithLabelValues(
+					request.Method, statusStr,
+				).Inc()
+				m.metrics.HTTPRequestDuration.WithLabelValues(
+					request.Method,
+				).Observe(latency.Seconds())
+				m.metrics.HTTPResponseSizeBytes.WithLabelValues(
+					request.Method,
+				).Observe(float64(lrw.bytesWritten))
 			}()
 
 			next.ServeHTTP(lrw, request)
@@ -145,11 +170,11 @@ func isTrustedProxy(ip net.IP) bool {
 	return false
 }
 
-// realIP extracts the client's real IP address from the request.
+// RealIP extracts the client's real IP address from the request.
 // Proxy headers (X-Real-IP, X-Forwarded-For) are only trusted when the
 // direct connection originates from an RFC1918/loopback address.
 // Otherwise, headers are ignored and RemoteAddr is used (fail closed).
-func realIP(r *http.Request) string {
+func RealIP(r *http.Request) string {
 	addr := ipFromHostPort(r.RemoteAddr)
 	remoteIP := net.ParseIP(addr)
 
@@ -340,7 +365,7 @@ func (m *Middleware) LoginRateLimit() func(http.Handler) http.Handler {
 			writer http.ResponseWriter,
 			request *http.Request,
 		) {
-			ip := realIP(request)
+			ip := RealIP(request)
 			limiter := loginLimiter.getLimiter(ip)
 
 			if !limiter.Allow() {

internal/middleware/realip_test.go

@@ -1,4 +1,4 @@
-package middleware //nolint:testpackage // tests unexported realIP function
+package middleware //nolint:testpackage // tests RealIP via internal package access
 
 import (
 	"context"
@@ -126,9 +126,9 @@ func TestRealIP(t *testing.T) { //nolint:funlen // table-driven test
 				req.Header.Set("X-Forwarded-For", tt.xff)
 			}
 
-			got := realIP(req)
+			got := RealIP(req)
 			if got != tt.want {
-				t.Errorf("realIP() = %q, want %q", got, tt.want)
+				t.Errorf("RealIP() = %q, want %q", got, tt.want)
 			}
 		})
 	}

internal/models/audit_log.go

@@ -0,0 +1,193 @@
+package models
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"sneak.berlin/go/upaas/internal/database"
+)
+
+// AuditAction represents the type of audited user action.
+type AuditAction string
+
+// Audit action constants.
+const (
+	AuditActionLogin          AuditAction = "login"
+	AuditActionLogout         AuditAction = "logout"
+	AuditActionAppCreate      AuditAction = "app.create"
+	AuditActionAppUpdate      AuditAction = "app.update"
+	AuditActionAppDelete      AuditAction = "app.delete"
+	AuditActionAppDeploy      AuditAction = "app.deploy"
+	AuditActionAppRollback    AuditAction = "app.rollback"
+	AuditActionAppRestart     AuditAction = "app.restart"
+	AuditActionAppStop        AuditAction = "app.stop"
+	AuditActionAppStart       AuditAction = "app.start"
+	AuditActionDeployCancel   AuditAction = "deploy.cancel"
+	AuditActionEnvVarSave     AuditAction = "env_var.save"
+	AuditActionLabelAdd       AuditAction = "label.add"
+	AuditActionLabelEdit      AuditAction = "label.edit"
+	AuditActionLabelDelete    AuditAction = "label.delete"
+	AuditActionVolumeAdd      AuditAction = "volume.add"
+	AuditActionVolumeEdit     AuditAction = "volume.edit"
+	AuditActionVolumeDelete   AuditAction = "volume.delete"
+	AuditActionPortAdd        AuditAction = "port.add"
+	AuditActionPortDelete     AuditAction = "port.delete"
+	AuditActionSetup          AuditAction = "setup"
+	AuditActionWebhookReceive AuditAction = "webhook.receive"
+)
+
+// AuditResourceType represents the type of resource being acted on.
+type AuditResourceType string
+
+// Audit resource type constants.
+const (
+	AuditResourceApp        AuditResourceType = "app"
+	AuditResourceUser       AuditResourceType = "user"
+	AuditResourceSession    AuditResourceType = "session"
+	AuditResourceEnvVar     AuditResourceType = "env_var"
+	AuditResourceLabel      AuditResourceType = "label"
+	AuditResourceVolume     AuditResourceType = "volume"
+	AuditResourcePort       AuditResourceType = "port"
+	AuditResourceDeployment AuditResourceType = "deployment"
+	AuditResourceWebhook    AuditResourceType = "webhook"
+)
+
+// AuditEntry represents a single audit log entry.
+type AuditEntry struct {
+	db *database.Database
+
+	ID           int64
+	UserID       sql.NullInt64
+	Username     string
+	Action       AuditAction
+	ResourceType AuditResourceType
+	ResourceID   sql.NullString
+	Detail       sql.NullString
+	RemoteIP     sql.NullString
+	CreatedAt    time.Time
+}
+
+// NewAuditEntry creates a new AuditEntry with a database reference.
+func NewAuditEntry(db *database.Database) *AuditEntry {
+	return &AuditEntry{db: db}
+}
+
+// Save inserts the audit entry into the database.
+func (a *AuditEntry) Save(ctx context.Context) error {
+	query := `
+		INSERT INTO audit_log (
+			user_id, username, action, resource_type, resource_id,
+			detail, remote_ip
+		) VALUES (?, ?, ?, ?, ?, ?, ?)`
+
+	result, err := a.db.Exec(ctx, query,
+		a.UserID, a.Username, a.Action, a.ResourceType,
+		a.ResourceID, a.Detail, a.RemoteIP,
+	)
+	if err != nil {
+		return fmt.Errorf("inserting audit entry: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return fmt.Errorf("getting audit entry id: %w", err)
+	}
+
+	a.ID = id
+
+	return nil
+}
+
+// FindAuditEntries returns recent audit log entries, newest first.
+func FindAuditEntries(
+	ctx context.Context,
+	db *database.Database,
+	limit int,
+) ([]*AuditEntry, error) {
+	query := `
+		SELECT id, user_id, username, action, resource_type, resource_id,
+			detail, remote_ip, created_at
+		FROM audit_log
+		ORDER BY created_at DESC
+		LIMIT ?`
+
+	rows, err := db.Query(ctx, query, limit)
+	if err != nil {
+		return nil, fmt.Errorf("querying audit entries: %w", err)
+	}
+
+	defer func() { _ = rows.Close() }()
+
+	return scanAuditRows(rows)
+}
+
+// FindAuditEntriesByResource returns audit log entries for a specific resource.
+func FindAuditEntriesByResource(
+	ctx context.Context,
+	db *database.Database,
+	resourceType AuditResourceType,
+	resourceID string,
+	limit int,
+) ([]*AuditEntry, error) {
+	query := `
+		SELECT id, user_id, username, action, resource_type, resource_id,
+			detail, remote_ip, created_at
+		FROM audit_log
+		WHERE resource_type = ? AND resource_id = ?
+		ORDER BY created_at DESC
+		LIMIT ?`
+
+	rows, err := db.Query(ctx, query, resourceType, resourceID, limit)
+	if err != nil {
+		return nil, fmt.Errorf("querying audit entries by resource: %w", err)
+	}
+
+	defer func() { _ = rows.Close() }()
+
+	return scanAuditRows(rows)
+}
+
+// CountAuditEntries returns the total number of audit log entries.
+func CountAuditEntries(
+	ctx context.Context,
+	db *database.Database,
+) (int, error) {
+	var count int
+
+	row := db.QueryRow(ctx, "SELECT COUNT(*) FROM audit_log")
+
+	err := row.Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("counting audit entries: %w", err)
+	}
+
+	return count, nil
+}
+
+func scanAuditRows(rows *sql.Rows) ([]*AuditEntry, error) {
+	var entries []*AuditEntry
+
+	for rows.Next() {
+		entry := &AuditEntry{}
+
+		scanErr := rows.Scan(
+			&entry.ID, &entry.UserID, &entry.Username, &entry.Action,
+			&entry.ResourceType, &entry.ResourceID, &entry.Detail,
+			&entry.RemoteIP, &entry.CreatedAt,
+		)
+		if scanErr != nil {
+			return nil, fmt.Errorf("scanning audit entry: %w", scanErr)
+		}
+
+		entries = append(entries, entry)
+	}
+
+	rowsErr := rows.Err()
+	if rowsErr != nil {
+		return nil, fmt.Errorf("iterating audit entries: %w", rowsErr)
+	}
+
+	return entries, nil
+}

internal/models/models_test.go

@@ -23,6 +23,7 @@ const (
 	testBranch    = "main"
 	testValue     = "value"
 	testEventType = "push"
+	testAdmin     = "admin"
 )
 
 func setupTestDB(t *testing.T) (*database.Database, func()) {
@@ -183,7 +184,7 @@ func TestUserExists(t *testing.T) {
 		defer cleanup()
 
 		user := models.NewUser(testDB)
-		user.Username = "admin"
+		user.Username = testAdmin
 		user.PasswordHash = testHash
 
 		err := user.Save(context.Background())
@@ -781,6 +782,179 @@ func TestCascadeDelete(t *testing.T) {
 	})
 }
 
+// AuditEntry Tests.
+
+func TestAuditEntryCreateAndFind(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	entry := models.NewAuditEntry(testDB)
+	entry.Username = testAdmin
+	entry.Action = models.AuditActionLogin
+	entry.ResourceType = models.AuditResourceSession
+
+	err := entry.Save(context.Background())
+	require.NoError(t, err)
+	assert.NotZero(t, entry.ID)
+
+	entries, err := models.FindAuditEntries(context.Background(), testDB, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, testAdmin, entries[0].Username)
+	assert.Equal(t, models.AuditActionLogin, entries[0].Action)
+	assert.Equal(t, models.AuditResourceSession, entries[0].ResourceType)
+}
+
+func TestAuditEntryWithAllFields(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	entry := models.NewAuditEntry(testDB)
+	entry.UserID = sql.NullInt64{Int64: 1, Valid: true}
+	entry.Username = testAdmin
+	entry.Action = models.AuditActionAppCreate
+	entry.ResourceType = models.AuditResourceApp
+	entry.ResourceID = sql.NullString{String: "app-123", Valid: true}
+	entry.Detail = sql.NullString{String: "created new app", Valid: true}
+	entry.RemoteIP = sql.NullString{String: "192.168.1.1", Valid: true}
+
+	err := entry.Save(context.Background())
+	require.NoError(t, err)
+
+	entries, err := models.FindAuditEntries(context.Background(), testDB, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, int64(1), entries[0].UserID.Int64)
+	assert.Equal(t, "app-123", entries[0].ResourceID.String)
+	assert.Equal(t, "created new app", entries[0].Detail.String)
+	assert.Equal(t, "192.168.1.1", entries[0].RemoteIP.String)
+}
+
+func TestAuditEntryFindByResource(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	// Create entries for different resources.
+	for _, action := range []models.AuditAction{
+		models.AuditActionAppCreate,
+		models.AuditActionAppUpdate,
+		models.AuditActionAppDeploy,
+	} {
+		entry := models.NewAuditEntry(testDB)
+		entry.Username = testAdmin
+		entry.Action = action
+		entry.ResourceType = models.AuditResourceApp
+		entry.ResourceID = sql.NullString{String: "app-1", Valid: true}
+
+		err := entry.Save(context.Background())
+		require.NoError(t, err)
+	}
+
+	// Create entry for a different resource.
+	entry := models.NewAuditEntry(testDB)
+	entry.Username = testAdmin
+	entry.Action = models.AuditActionLogin
+	entry.ResourceType = models.AuditResourceSession
+
+	err := entry.Save(context.Background())
+	require.NoError(t, err)
+
+	// Find by resource.
+	appEntries, err := models.FindAuditEntriesByResource(
+		context.Background(), testDB,
+		models.AuditResourceApp, "app-1", 10,
+	)
+	require.NoError(t, err)
+	assert.Len(t, appEntries, 3)
+
+	// All entries.
+	allEntries, err := models.FindAuditEntries(context.Background(), testDB, 10)
+	require.NoError(t, err)
+	assert.Len(t, allEntries, 4)
+}
+
+func TestAuditEntryCount(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	count, err := models.CountAuditEntries(context.Background(), testDB)
+	require.NoError(t, err)
+	assert.Equal(t, 0, count)
+
+	entry := models.NewAuditEntry(testDB)
+	entry.Username = testAdmin
+	entry.Action = models.AuditActionLogin
+	entry.ResourceType = models.AuditResourceSession
+
+	err = entry.Save(context.Background())
+	require.NoError(t, err)
+
+	count, err = models.CountAuditEntries(context.Background(), testDB)
+	require.NoError(t, err)
+	assert.Equal(t, 1, count)
+}
+
+func TestAuditEntryFindLimit(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	for range 5 {
+		entry := models.NewAuditEntry(testDB)
+		entry.Username = testAdmin
+		entry.Action = models.AuditActionLogin
+		entry.ResourceType = models.AuditResourceSession
+
+		err := entry.Save(context.Background())
+		require.NoError(t, err)
+	}
+
+	entries, err := models.FindAuditEntries(context.Background(), testDB, 3)
+	require.NoError(t, err)
+	assert.Len(t, entries, 3)
+}
+
+func TestAuditEntryOrderByCreatedAtDesc(t *testing.T) {
+	t.Parallel()
+
+	testDB, cleanup := setupTestDB(t)
+	defer cleanup()
+
+	actions := []models.AuditAction{
+		models.AuditActionLogin,
+		models.AuditActionAppCreate,
+		models.AuditActionLogout,
+	}
+
+	for _, action := range actions {
+		entry := models.NewAuditEntry(testDB)
+		entry.Username = testAdmin
+		entry.Action = action
+		entry.ResourceType = models.AuditResourceSession
+
+		err := entry.Save(context.Background())
+		require.NoError(t, err)
+	}
+
+	entries, err := models.FindAuditEntries(context.Background(), testDB, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 3)
+
+	// Newest first (logout was last inserted).
+	assert.Equal(t, models.AuditActionLogout, entries[0].Action)
+	assert.Equal(t, models.AuditActionAppCreate, entries[1].Action)
+	assert.Equal(t, models.AuditActionLogin, entries[2].Action)
+}
+
 // Helper function to create a test app.
 func createTestApp(t *testing.T, testDB *database.Database) *models.App {
 	t.Helper()

internal/server/routes.go

@@ -98,12 +98,6 @@ func (s *Server) SetupRoutes() {
 			// Ports
 			r.Post("/apps/{id}/ports", s.handlers.HandlePortAdd())
 			r.Post("/apps/{id}/ports/{portID}/delete", s.handlers.HandlePortDelete())
-
-			// Backup/Restore
-			r.Get("/apps/{id}/export", s.handlers.HandleExportApp())
-			r.Get("/backup/export", s.handlers.HandleExportAllApps())
-			r.Get("/backup/import", s.handlers.HandleImportPage())
-			r.Post("/backup/import", s.handlers.HandleImportApps())
 		})
 	})
 
@@ -121,19 +115,13 @@ func (s *Server) SetupRoutes() {
 			r.Get("/apps", s.handlers.HandleAPIListApps())
 			r.Get("/apps/{id}", s.handlers.HandleAPIGetApp())
 			r.Get("/apps/{id}/deployments", s.handlers.HandleAPIListDeployments())
-
-			// Backup/Restore API
-			r.Get("/apps/{id}/export", s.handlers.HandleAPIExportApp())
-			r.Get("/backup/export", s.handlers.HandleAPIExportAllApps())
-			r.Post("/backup/import", s.handlers.HandleAPIImportApps())
+			r.Get("/audit", s.handlers.HandleAPIAuditLog())
 		})
 	})
 
-	// Metrics endpoint (optional, with basic auth)
-	if s.params.Config.MetricsUsername != "" {
-		s.router.Group(func(r chi.Router) {
-			r.Use(s.mw.MetricsAuth())
-			r.Get("/metrics", promhttp.Handler().ServeHTTP)
-		})
-	}
+	// Metrics endpoint (always available, optionally protected with basic auth)
+	s.router.Group(func(r chi.Router) {
+		r.Use(s.mw.MetricsAuth())
+		r.Get("/metrics", promhttp.Handler().ServeHTTP)
+	})
 }

internal/service/app/backup.go

@@ -1,391 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"sneak.berlin/go/upaas/internal/models"
-)
-
-// BackupEnvVar represents an environment variable in a backup.
-type BackupEnvVar struct {
-	Key   string `json:"key"`
-	Value string `json:"value"`
-}
-
-// BackupLabel represents a Docker label in a backup.
-type BackupLabel struct {
-	Key   string `json:"key"`
-	Value string `json:"value"`
-}
-
-// BackupVolume represents a volume mount in a backup.
-type BackupVolume struct {
-	HostPath      string `json:"hostPath"`
-	ContainerPath string `json:"containerPath"`
-	ReadOnly      bool   `json:"readOnly"`
-}
-
-// BackupPort represents a port mapping in a backup.
-type BackupPort struct {
-	HostPort      int    `json:"hostPort"`
-	ContainerPort int    `json:"containerPort"`
-	Protocol      string `json:"protocol"`
-}
-
-// Backup represents the exported configuration of a single app.
-type Backup struct {
-	Name           string         `json:"name"`
-	RepoURL        string         `json:"repoUrl"`
-	Branch         string         `json:"branch"`
-	DockerfilePath string         `json:"dockerfilePath"`
-	DockerNetwork  string         `json:"dockerNetwork,omitempty"`
-	NtfyTopic      string         `json:"ntfyTopic,omitempty"`
-	SlackWebhook   string         `json:"slackWebhook,omitempty"`
-	EnvVars        []BackupEnvVar `json:"envVars"`
-	Labels         []BackupLabel  `json:"labels"`
-	Volumes        []BackupVolume `json:"volumes"`
-	Ports          []BackupPort   `json:"ports"`
-}
-
-// BackupBundle represents a complete backup of one or more apps.
-type BackupBundle struct {
-	Version    int      `json:"version"`
-	ExportedAt string   `json:"exportedAt"`
-	Apps       []Backup `json:"apps"`
-}
-
-// backupVersion is the current backup format version.
-const backupVersion = 1
-
-// ExportApp exports a single app's configuration as a BackupBundle.
-func (svc *Service) ExportApp(
-	ctx context.Context,
-	application *models.App,
-) (*BackupBundle, error) {
-	appBackup, err := svc.buildAppBackup(ctx, application)
-	if err != nil {
-		return nil, err
-	}
-
-	return &BackupBundle{
-		Version:    backupVersion,
-		ExportedAt: time.Now().UTC().Format(time.RFC3339),
-		Apps:       []Backup{appBackup},
-	}, nil
-}
-
-// ExportAllApps exports all app configurations as a BackupBundle.
-func (svc *Service) ExportAllApps(ctx context.Context) (*BackupBundle, error) {
-	apps, err := models.AllApps(ctx, svc.db)
-	if err != nil {
-		return nil, fmt.Errorf("listing apps for export: %w", err)
-	}
-
-	backups := make([]Backup, 0, len(apps))
-
-	for _, application := range apps {
-		appBackup, buildErr := svc.buildAppBackup(ctx, application)
-		if buildErr != nil {
-			return nil, buildErr
-		}
-
-		backups = append(backups, appBackup)
-	}
-
-	return &BackupBundle{
-		Version:    backupVersion,
-		ExportedAt: time.Now().UTC().Format(time.RFC3339),
-		Apps:       backups,
-	}, nil
-}
-
-// ImportApps imports app configurations from a BackupBundle.
-// It creates new apps (with fresh IDs, SSH keys, and webhook secrets)
-// and populates their env vars, labels, volumes, and ports.
-// Apps whose names conflict with existing apps are skipped and reported.
-func (svc *Service) ImportApps(
-	ctx context.Context,
-	bundle *BackupBundle,
-) ([]string, []string, error) {
-	// Build a set of existing app names for conflict detection
-	existingApps, listErr := models.AllApps(ctx, svc.db)
-	if listErr != nil {
-		return nil, nil, fmt.Errorf("listing existing apps: %w", listErr)
-	}
-
-	existingNames := make(map[string]bool, len(existingApps))
-	for _, a := range existingApps {
-		existingNames[a.Name] = true
-	}
-
-	var imported, skipped []string
-
-	for _, ab := range bundle.Apps {
-		if existingNames[ab.Name] {
-			skipped = append(skipped, ab.Name)
-
-			continue
-		}
-
-		importErr := svc.importSingleApp(ctx, ab)
-		if importErr != nil {
-			return imported, skipped, fmt.Errorf(
-				"importing app %q: %w", ab.Name, importErr,
-			)
-		}
-
-		imported = append(imported, ab.Name)
-	}
-
-	return imported, skipped, nil
-}
-
-// importSingleApp creates a single app from backup data.
-func (svc *Service) importSingleApp(
-	ctx context.Context,
-	ab Backup,
-) error {
-	createdApp, createErr := svc.CreateApp(ctx, CreateAppInput{
-		Name:           ab.Name,
-		RepoURL:        ab.RepoURL,
-		Branch:         ab.Branch,
-		DockerfilePath: ab.DockerfilePath,
-		DockerNetwork:  ab.DockerNetwork,
-		NtfyTopic:      ab.NtfyTopic,
-		SlackWebhook:   ab.SlackWebhook,
-	})
-	if createErr != nil {
-		return fmt.Errorf("creating app: %w", createErr)
-	}
-
-	envErr := svc.importEnvVars(ctx, createdApp.ID, ab.EnvVars)
-	if envErr != nil {
-		return envErr
-	}
-
-	labelErr := svc.importLabels(ctx, createdApp.ID, ab.Labels)
-	if labelErr != nil {
-		return labelErr
-	}
-
-	volErr := svc.importVolumes(ctx, createdApp.ID, ab.Volumes)
-	if volErr != nil {
-		return volErr
-	}
-
-	portErr := svc.importPorts(ctx, createdApp.ID, ab.Ports)
-	if portErr != nil {
-		return portErr
-	}
-
-	svc.log.Info("app imported from backup",
-		"id", createdApp.ID, "name", createdApp.Name)
-
-	return nil
-}
-
-// importEnvVars adds env vars from backup to an app.
-func (svc *Service) importEnvVars(
-	ctx context.Context,
-	appID string,
-	envVars []BackupEnvVar,
-) error {
-	for _, ev := range envVars {
-		addErr := svc.AddEnvVar(ctx, appID, ev.Key, ev.Value)
-		if addErr != nil {
-			return fmt.Errorf("adding env var %q: %w", ev.Key, addErr)
-		}
-	}
-
-	return nil
-}
-
-// importLabels adds labels from backup to an app.
-func (svc *Service) importLabels(
-	ctx context.Context,
-	appID string,
-	labels []BackupLabel,
-) error {
-	for _, l := range labels {
-		addErr := svc.AddLabel(ctx, appID, l.Key, l.Value)
-		if addErr != nil {
-			return fmt.Errorf("adding label %q: %w", l.Key, addErr)
-		}
-	}
-
-	return nil
-}
-
-// importVolumes adds volumes from backup to an app.
-func (svc *Service) importVolumes(
-	ctx context.Context,
-	appID string,
-	volumes []BackupVolume,
-) error {
-	for _, v := range volumes {
-		addErr := svc.AddVolume(ctx, appID, v.HostPath, v.ContainerPath, v.ReadOnly)
-		if addErr != nil {
-			return fmt.Errorf("adding volume %q: %w", v.ContainerPath, addErr)
-		}
-	}
-
-	return nil
-}
-
-// importPorts adds ports from backup to an app.
-func (svc *Service) importPorts(
-	ctx context.Context,
-	appID string,
-	ports []BackupPort,
-) error {
-	for _, p := range ports {
-		port := models.NewPort(svc.db)
-		port.AppID = appID
-		port.HostPort = p.HostPort
-		port.ContainerPort = p.ContainerPort
-		port.Protocol = models.PortProtocol(p.Protocol)
-
-		if port.Protocol == "" {
-			port.Protocol = models.PortProtocolTCP
-		}
-
-		saveErr := port.Save(ctx)
-		if saveErr != nil {
-			return fmt.Errorf("adding port %d: %w", p.HostPort, saveErr)
-		}
-	}
-
-	return nil
-}
-
-// buildAppBackup collects all configuration for a single app into a Backup.
-func (svc *Service) buildAppBackup(
-	ctx context.Context,
-	application *models.App,
-) (Backup, error) {
-	envVars, labels, volumes, ports, err := svc.fetchAppResources(ctx, application)
-	if err != nil {
-		return Backup{}, err
-	}
-
-	backup := Backup{
-		Name:           application.Name,
-		RepoURL:        application.RepoURL,
-		Branch:         application.Branch,
-		DockerfilePath: application.DockerfilePath,
-		EnvVars:        convertEnvVars(envVars),
-		Labels:         convertLabels(labels),
-		Volumes:        convertVolumes(volumes),
-		Ports:          convertPorts(ports),
-	}
-
-	if application.DockerNetwork.Valid {
-		backup.DockerNetwork = application.DockerNetwork.String
-	}
-
-	if application.NtfyTopic.Valid {
-		backup.NtfyTopic = application.NtfyTopic.String
-	}
-
-	if application.SlackWebhook.Valid {
-		backup.SlackWebhook = application.SlackWebhook.String
-	}
-
-	return backup, nil
-}
-
-// fetchAppResources retrieves all sub-resources for an app.
-func (svc *Service) fetchAppResources(
-	ctx context.Context,
-	application *models.App,
-) ([]*models.EnvVar, []*models.Label, []*models.Volume, []*models.Port, error) {
-	envVars, err := application.GetEnvVars(ctx)
-	if err != nil {
-		return nil, nil, nil, nil, fmt.Errorf(
-			"getting env vars for %q: %w", application.Name, err,
-		)
-	}
-
-	labels, err := application.GetLabels(ctx)
-	if err != nil {
-		return nil, nil, nil, nil, fmt.Errorf(
-			"getting labels for %q: %w", application.Name, err,
-		)
-	}
-
-	volumes, err := application.GetVolumes(ctx)
-	if err != nil {
-		return nil, nil, nil, nil, fmt.Errorf(
-			"getting volumes for %q: %w", application.Name, err,
-		)
-	}
-
-	ports, err := application.GetPorts(ctx)
-	if err != nil {
-		return nil, nil, nil, nil, fmt.Errorf(
-			"getting ports for %q: %w", application.Name, err,
-		)
-	}
-
-	return envVars, labels, volumes, ports, nil
-}
-
-// convertEnvVars converts model env vars to backup format.
-func convertEnvVars(envVars []*models.EnvVar) []BackupEnvVar {
-	result := make([]BackupEnvVar, 0, len(envVars))
-
-	for _, ev := range envVars {
-		result = append(result, BackupEnvVar{
-			Key:   ev.Key,
-			Value: ev.Value,
-		})
-	}
-
-	return result
-}
-
-// convertLabels converts model labels to backup format.
-func convertLabels(labels []*models.Label) []BackupLabel {
-	result := make([]BackupLabel, 0, len(labels))
-
-	for _, l := range labels {
-		result = append(result, BackupLabel{
-			Key:   l.Key,
-			Value: l.Value,
-		})
-	}
-
-	return result
-}
-
-// convertVolumes converts model volumes to backup format.
-func convertVolumes(volumes []*models.Volume) []BackupVolume {
-	result := make([]BackupVolume, 0, len(volumes))
-
-	for _, v := range volumes {
-		result = append(result, BackupVolume{
-			HostPath:      v.HostPath,
-			ContainerPath: v.ContainerPath,
-			ReadOnly:      v.ReadOnly,
-		})
-	}
-
-	return result
-}
-
-// convertPorts converts model ports to backup format.
-func convertPorts(ports []*models.Port) []BackupPort {
-	result := make([]BackupPort, 0, len(ports))
-
-	for _, p := range ports {
-		result = append(result, BackupPort{
-			HostPort:      p.HostPort,
-			ContainerPort: p.ContainerPort,
-			Protocol:      string(p.Protocol),
-		})
-	}
-
-	return result
-}

internal/service/app/backup_test.go

@@ -1,379 +0,0 @@
-package app_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/fx"
-
-	"sneak.berlin/go/upaas/internal/config"
-	"sneak.berlin/go/upaas/internal/database"
-	"sneak.berlin/go/upaas/internal/globals"
-	"sneak.berlin/go/upaas/internal/logger"
-	"sneak.berlin/go/upaas/internal/models"
-	"sneak.berlin/go/upaas/internal/service/app"
-)
-
-// backupTestContext bundles test dependencies for backup tests.
-type backupTestContext struct {
-	svc *app.Service
-	db  *database.Database
-}
-
-func setupBackupTest(t *testing.T) *backupTestContext {
-	t.Helper()
-
-	tmpDir := t.TempDir()
-
-	globals.SetAppname("upaas-test")
-	globals.SetVersion("test")
-
-	globalsInst, err := globals.New(fx.Lifecycle(nil))
-	require.NoError(t, err)
-
-	loggerInst, err := logger.New(
-		fx.Lifecycle(nil),
-		logger.Params{Globals: globalsInst},
-	)
-	require.NoError(t, err)
-
-	cfg := &config.Config{
-		Port:          8080,
-		DataDir:       tmpDir,
-		SessionSecret: "test-secret-key-at-least-32-chars",
-	}
-
-	dbInst, err := database.New(fx.Lifecycle(nil), database.Params{
-		Logger: loggerInst,
-		Config: cfg,
-	})
-	require.NoError(t, err)
-
-	svc, err := app.New(fx.Lifecycle(nil), app.ServiceParams{
-		Logger:   loggerInst,
-		Database: dbInst,
-	})
-	require.NoError(t, err)
-
-	return &backupTestContext{svc: svc, db: dbInst}
-}
-
-// createAppWithFullConfig creates an app with env vars, labels, volumes, and ports.
-func createAppWithFullConfig(
-	t *testing.T,
-	btc *backupTestContext,
-	name string,
-) *models.App {
-	t.Helper()
-
-	createdApp, err := btc.svc.CreateApp(context.Background(), app.CreateAppInput{
-		Name:          name,
-		RepoURL:       "git@example.com:user/" + name + ".git",
-		Branch:        "develop",
-		NtfyTopic:     "https://ntfy.sh/" + name,
-		DockerNetwork: "test-network",
-	})
-	require.NoError(t, err)
-
-	require.NoError(t, btc.svc.AddEnvVar(
-		context.Background(), createdApp.ID, "DB_HOST", "localhost",
-	))
-	require.NoError(t, btc.svc.AddEnvVar(
-		context.Background(), createdApp.ID, "DB_PORT", "5432",
-	))
-	require.NoError(t, btc.svc.AddLabel(
-		context.Background(), createdApp.ID, "traefik.enable", "true",
-	))
-	require.NoError(t, btc.svc.AddVolume(
-		context.Background(), createdApp.ID, "/data", "/app/data", false,
-	))
-
-	port := models.NewPort(btc.db)
-	port.AppID = createdApp.ID
-	port.HostPort = 9090
-	port.ContainerPort = 8080
-	port.Protocol = models.PortProtocolTCP
-	require.NoError(t, port.Save(context.Background()))
-
-	return createdApp
-}
-
-// createAppWithConfigPort creates an app like createAppWithFullConfig but with
-// a custom host port to avoid UNIQUE constraint collisions.
-func createAppWithConfigPort(
-	t *testing.T,
-	btc *backupTestContext,
-	name string,
-	hostPort int,
-) *models.App {
-	t.Helper()
-
-	createdApp, err := btc.svc.CreateApp(context.Background(), app.CreateAppInput{
-		Name:          name,
-		RepoURL:       "git@example.com:user/" + name + ".git",
-		Branch:        "develop",
-		NtfyTopic:     "https://ntfy.sh/" + name,
-		DockerNetwork: "test-network",
-	})
-	require.NoError(t, err)
-
-	require.NoError(t, btc.svc.AddEnvVar(
-		context.Background(), createdApp.ID, "DB_HOST", "localhost",
-	))
-	require.NoError(t, btc.svc.AddLabel(
-		context.Background(), createdApp.ID, "traefik.enable", "true",
-	))
-	require.NoError(t, btc.svc.AddVolume(
-		context.Background(), createdApp.ID, "/data2", "/app/data2", false,
-	))
-
-	port := models.NewPort(btc.db)
-	port.AppID = createdApp.ID
-	port.HostPort = hostPort
-	port.ContainerPort = 8080
-	port.Protocol = models.PortProtocolTCP
-	require.NoError(t, port.Save(context.Background()))
-
-	return createdApp
-}
-
-func TestExportApp(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-	createdApp := createAppWithFullConfig(t, btc, "export-svc-test")
-
-	bundle, err := btc.svc.ExportApp(context.Background(), createdApp)
-	require.NoError(t, err)
-
-	assert.Equal(t, 1, bundle.Version)
-	assert.NotEmpty(t, bundle.ExportedAt)
-	require.Len(t, bundle.Apps, 1)
-
-	ab := bundle.Apps[0]
-	assert.Equal(t, "export-svc-test", ab.Name)
-	assert.Equal(t, "develop", ab.Branch)
-	assert.Equal(t, "test-network", ab.DockerNetwork)
-	assert.Equal(t, "https://ntfy.sh/export-svc-test", ab.NtfyTopic)
-	assert.Len(t, ab.EnvVars, 2)
-	assert.Len(t, ab.Labels, 1)
-	assert.Len(t, ab.Volumes, 1)
-	assert.Len(t, ab.Ports, 1)
-	assert.Equal(t, 9090, ab.Ports[0].HostPort)
-	assert.Equal(t, 8080, ab.Ports[0].ContainerPort)
-	assert.Equal(t, "tcp", ab.Ports[0].Protocol)
-}
-
-func TestExportAllApps(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-	createAppWithFullConfig(t, btc, "export-all-1")
-	createAppWithConfigPort(t, btc, "export-all-2", 9091)
-
-	bundle, err := btc.svc.ExportAllApps(context.Background())
-	require.NoError(t, err)
-
-	assert.Equal(t, 1, bundle.Version)
-	assert.Len(t, bundle.Apps, 2)
-}
-
-func TestExportAllAppsEmpty(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-
-	bundle, err := btc.svc.ExportAllApps(context.Background())
-	require.NoError(t, err)
-
-	assert.Empty(t, bundle.Apps)
-}
-
-func TestImportApps(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-
-	bundle := &app.BackupBundle{
-		Version:    1,
-		ExportedAt: "2025-01-01T00:00:00Z",
-		Apps: []app.Backup{
-			{
-				Name:           "imported-test",
-				RepoURL:        "git@example.com:user/imported.git",
-				Branch:         "main",
-				DockerfilePath: "Dockerfile",
-				DockerNetwork:  "my-network",
-				EnvVars: []app.BackupEnvVar{
-					{Key: "FOO", Value: "bar"},
-				},
-				Labels: []app.BackupLabel{
-					{Key: "app", Value: "test"},
-				},
-				Volumes: []app.BackupVolume{
-					{HostPath: "/host", ContainerPath: "/container", ReadOnly: true},
-				},
-				Ports: []app.BackupPort{
-					{HostPort: 3000, ContainerPort: 8080, Protocol: "tcp"},
-				},
-			},
-		},
-	}
-
-	imported, skipped, err := btc.svc.ImportApps(context.Background(), bundle)
-	require.NoError(t, err)
-
-	assert.Equal(t, []string{"imported-test"}, imported)
-	assert.Empty(t, skipped)
-
-	// Verify the app was created
-	apps, _ := btc.svc.ListApps(context.Background())
-	require.Len(t, apps, 1)
-	assert.Equal(t, "imported-test", apps[0].Name)
-	assert.True(t, apps[0].DockerNetwork.Valid)
-	assert.Equal(t, "my-network", apps[0].DockerNetwork.String)
-
-	// Has fresh secrets
-	assert.NotEmpty(t, apps[0].WebhookSecret)
-	assert.NotEmpty(t, apps[0].SSHPublicKey)
-
-	// Verify sub-resources
-	envVars, _ := apps[0].GetEnvVars(context.Background())
-	assert.Len(t, envVars, 1)
-
-	labels, _ := apps[0].GetLabels(context.Background())
-	assert.Len(t, labels, 1)
-
-	volumes, _ := apps[0].GetVolumes(context.Background())
-	assert.Len(t, volumes, 1)
-	assert.True(t, volumes[0].ReadOnly)
-
-	ports, _ := apps[0].GetPorts(context.Background())
-	assert.Len(t, ports, 1)
-	assert.Equal(t, 3000, ports[0].HostPort)
-}
-
-func TestImportAppsSkipsDuplicates(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-
-	// Create existing app
-	_, err := btc.svc.CreateApp(context.Background(), app.CreateAppInput{
-		Name:    "existing",
-		RepoURL: "git@example.com:user/existing.git",
-	})
-	require.NoError(t, err)
-
-	bundle := &app.BackupBundle{
-		Version:    1,
-		ExportedAt: "2025-01-01T00:00:00Z",
-		Apps: []app.Backup{
-			{
-				Name:           "existing",
-				RepoURL:        "git@example.com:user/existing.git",
-				Branch:         "main",
-				DockerfilePath: "Dockerfile",
-				EnvVars:        []app.BackupEnvVar{},
-				Labels:         []app.BackupLabel{},
-				Volumes:        []app.BackupVolume{},
-				Ports:          []app.BackupPort{},
-			},
-			{
-				Name:           "brand-new",
-				RepoURL:        "git@example.com:user/new.git",
-				Branch:         "main",
-				DockerfilePath: "Dockerfile",
-				EnvVars:        []app.BackupEnvVar{},
-				Labels:         []app.BackupLabel{},
-				Volumes:        []app.BackupVolume{},
-				Ports:          []app.BackupPort{},
-			},
-		},
-	}
-
-	imported, skipped, err := btc.svc.ImportApps(context.Background(), bundle)
-	require.NoError(t, err)
-
-	assert.Equal(t, []string{"brand-new"}, imported)
-	assert.Equal(t, []string{"existing"}, skipped)
-}
-
-func TestImportAppsPortDefaultProtocol(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-
-	bundle := &app.BackupBundle{
-		Version:    1,
-		ExportedAt: "2025-01-01T00:00:00Z",
-		Apps: []app.Backup{
-			{
-				Name:           "port-default-test",
-				RepoURL:        "git@example.com:user/repo.git",
-				Branch:         "main",
-				DockerfilePath: "Dockerfile",
-				EnvVars:        []app.BackupEnvVar{},
-				Labels:         []app.BackupLabel{},
-				Volumes:        []app.BackupVolume{},
-				Ports: []app.BackupPort{
-					{HostPort: 80, ContainerPort: 80, Protocol: ""},
-				},
-			},
-		},
-	}
-
-	imported, _, err := btc.svc.ImportApps(context.Background(), bundle)
-	require.NoError(t, err)
-	assert.Len(t, imported, 1)
-
-	apps, _ := btc.svc.ListApps(context.Background())
-	ports, _ := apps[0].GetPorts(context.Background())
-	require.Len(t, ports, 1)
-	assert.Equal(t, models.PortProtocolTCP, ports[0].Protocol)
-}
-
-func TestExportImportRoundTripService(t *testing.T) {
-	t.Parallel()
-
-	btc := setupBackupTest(t)
-	createAppWithFullConfig(t, btc, "roundtrip-svc")
-
-	// Export
-	bundle, err := btc.svc.ExportAllApps(context.Background())
-	require.NoError(t, err)
-	require.Len(t, bundle.Apps, 1)
-
-	// Delete original
-	apps, _ := btc.svc.ListApps(context.Background())
-	for _, a := range apps {
-		require.NoError(t, btc.svc.DeleteApp(context.Background(), a))
-	}
-
-	// Import
-	imported, skipped, err := btc.svc.ImportApps(context.Background(), bundle)
-	require.NoError(t, err)
-	assert.Len(t, imported, 1)
-	assert.Empty(t, skipped)
-
-	// Verify round-trip fidelity
-	restored, _ := btc.svc.ListApps(context.Background())
-	require.Len(t, restored, 1)
-	assert.Equal(t, "roundtrip-svc", restored[0].Name)
-	assert.Equal(t, "develop", restored[0].Branch)
-	assert.Equal(t, "test-network", restored[0].DockerNetwork.String)
-
-	envVars, _ := restored[0].GetEnvVars(context.Background())
-	assert.Len(t, envVars, 2)
-
-	labels, _ := restored[0].GetLabels(context.Background())
-	assert.Len(t, labels, 1)
-
-	volumes, _ := restored[0].GetVolumes(context.Background())
-	assert.Len(t, volumes, 1)
-
-	ports, _ := restored[0].GetPorts(context.Background())
-	assert.Len(t, ports, 1)
-}

internal/service/audit/audit.go

@@ -0,0 +1,126 @@
+// Package audit provides audit logging for user actions.
+package audit
+
+import (
+	"context"
+	"database/sql"
+	"log/slog"
+	"net/http"
+
+	"go.uber.org/fx"
+
+	"sneak.berlin/go/upaas/internal/database"
+	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
+	"sneak.berlin/go/upaas/internal/middleware"
+	"sneak.berlin/go/upaas/internal/models"
+)
+
+// ServiceParams contains dependencies for Service.
+type ServiceParams struct {
+	fx.In
+
+	Logger   *logger.Logger
+	Database *database.Database
+	Metrics  *metrics.Metrics
+}
+
+// Service provides audit logging functionality.
+type Service struct {
+	log     *slog.Logger
+	db      *database.Database
+	metrics *metrics.Metrics
+}
+
+// New creates a new audit Service.
+func New(_ fx.Lifecycle, params ServiceParams) (*Service, error) {
+	return &Service{
+		log:     params.Logger.Get(),
+		db:      params.Database,
+		metrics: params.Metrics,
+	}, nil
+}
+
+// LogEntry records an audit event.
+type LogEntry struct {
+	UserID       int64
+	Username     string
+	Action       models.AuditAction
+	ResourceType models.AuditResourceType
+	ResourceID   string
+	Detail       string
+	RemoteIP     string
+}
+
+// Log records an audit log entry and increments the audit metrics counter.
+func (svc *Service) Log(ctx context.Context, entry LogEntry) {
+	auditEntry := models.NewAuditEntry(svc.db)
+	auditEntry.Username = entry.Username
+	auditEntry.Action = entry.Action
+	auditEntry.ResourceType = entry.ResourceType
+
+	if entry.UserID != 0 {
+		auditEntry.UserID = sql.NullInt64{Int64: entry.UserID, Valid: true}
+	}
+
+	if entry.ResourceID != "" {
+		auditEntry.ResourceID = sql.NullString{String: entry.ResourceID, Valid: true}
+	}
+
+	if entry.Detail != "" {
+		auditEntry.Detail = sql.NullString{String: entry.Detail, Valid: true}
+	}
+
+	if entry.RemoteIP != "" {
+		auditEntry.RemoteIP = sql.NullString{String: entry.RemoteIP, Valid: true}
+	}
+
+	err := auditEntry.Save(ctx)
+	if err != nil {
+		svc.log.Error("failed to save audit entry",
+			"error", err,
+			"action", entry.Action,
+			"username", entry.Username,
+		)
+
+		return
+	}
+
+	svc.metrics.AuditEventsTotal.WithLabelValues(string(entry.Action)).Inc()
+
+	svc.log.Info("audit",
+		"action", entry.Action,
+		"username", entry.Username,
+		"resource_type", entry.ResourceType,
+		"resource_id", entry.ResourceID,
+	)
+}
+
+// LogFromRequest records an audit log entry, extracting the remote IP from
+// the HTTP request using the middleware's trusted-proxy-aware IP resolution.
+func (svc *Service) LogFromRequest(
+	ctx context.Context,
+	request *http.Request,
+	entry LogEntry,
+) {
+	entry.RemoteIP = middleware.RealIP(request)
+	svc.Log(ctx, entry)
+}
+
+// Recent returns the most recent audit log entries.
+func (svc *Service) Recent(
+	ctx context.Context,
+	limit int,
+) ([]*models.AuditEntry, error) {
+	return models.FindAuditEntries(ctx, svc.db, limit)
+}
+
+// ForResource returns audit log entries for a specific resource.
+func (svc *Service) ForResource(
+	ctx context.Context,
+	resourceType models.AuditResourceType,
+	resourceID string,
+	limit int,
+) ([]*models.AuditEntry, error) {
+	return models.FindAuditEntriesByResource(ctx, svc.db, resourceType, resourceID, limit)
+}

internal/service/audit/audit_test.go

@@ -0,0 +1,221 @@
+package audit_test
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/fx"
+
+	"sneak.berlin/go/upaas/internal/config"
+	"sneak.berlin/go/upaas/internal/database"
+	"sneak.berlin/go/upaas/internal/globals"
+	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
+	"sneak.berlin/go/upaas/internal/models"
+	"sneak.berlin/go/upaas/internal/service/audit"
+)
+
+func setupTestAuditService(t *testing.T) (*audit.Service, *database.Database) {
+	t.Helper()
+
+	globals.SetAppname("upaas-test")
+	globals.SetVersion("test")
+
+	tmpDir := t.TempDir()
+
+	cfg := &config.Config{
+		DataDir: tmpDir,
+	}
+
+	log := slog.New(slog.NewTextHandler(os.Stderr, nil))
+	logWrapper := logger.NewForTest(log)
+
+	db, err := database.New(fx.Lifecycle(nil), database.Params{
+		Logger: logWrapper,
+		Config: cfg,
+	})
+	require.NoError(t, err)
+
+	reg := prometheus.NewRegistry()
+	metricsInstance := metrics.NewForTest(reg)
+
+	svc, err := audit.New(fx.Lifecycle(nil), audit.ServiceParams{
+		Logger:   logWrapper,
+		Database: db,
+		Metrics:  metricsInstance,
+	})
+	require.NoError(t, err)
+
+	return svc, db
+}
+
+func TestAuditServiceLog(t *testing.T) {
+	t.Parallel()
+
+	svc, db := setupTestAuditService(t)
+	ctx := context.Background()
+
+	svc.Log(ctx, audit.LogEntry{
+		UserID:       1,
+		Username:     "admin",
+		Action:       models.AuditActionLogin,
+		ResourceType: models.AuditResourceSession,
+		Detail:       "user logged in",
+		RemoteIP:     "127.0.0.1",
+	})
+
+	entries, err := models.FindAuditEntries(ctx, db, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "admin", entries[0].Username)
+	assert.Equal(t, models.AuditActionLogin, entries[0].Action)
+	assert.Equal(t, "127.0.0.1", entries[0].RemoteIP.String)
+}
+
+func TestAuditServiceLogFromRequest(t *testing.T) {
+	t.Parallel()
+
+	svc, db := setupTestAuditService(t)
+	ctx := context.Background()
+
+	request := httptest.NewRequest(http.MethodPost, "/apps", nil)
+	request.RemoteAddr = "10.0.0.1:12345"
+
+	svc.LogFromRequest(ctx, request, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppCreate,
+		ResourceType: models.AuditResourceApp,
+		ResourceID:   "app-1",
+		Detail:       "created app",
+	})
+
+	entries, err := models.FindAuditEntries(ctx, db, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "10.0.0.1", entries[0].RemoteIP.String)
+	assert.Equal(t, "app-1", entries[0].ResourceID.String)
+}
+
+func TestAuditServiceLogFromRequestWithXRealIPTrustedProxy(t *testing.T) {
+	t.Parallel()
+
+	svc, db := setupTestAuditService(t)
+	ctx := context.Background()
+
+	// When the request comes from a trusted proxy (RFC1918), X-Real-IP is honoured.
+	request := httptest.NewRequest(http.MethodPost, "/apps", nil)
+	request.RemoteAddr = "10.0.0.1:1234"
+	request.Header.Set("X-Real-IP", "203.0.113.50")
+
+	svc.LogFromRequest(ctx, request, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppCreate,
+		ResourceType: models.AuditResourceApp,
+	})
+
+	entries, err := models.FindAuditEntries(ctx, db, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "203.0.113.50", entries[0].RemoteIP.String)
+}
+
+func TestAuditServiceLogFromRequestWithXRealIPUntrustedProxy(t *testing.T) {
+	t.Parallel()
+
+	svc, db := setupTestAuditService(t)
+	ctx := context.Background()
+
+	// When the request comes from a public IP, X-Real-IP is ignored (anti-spoof).
+	request := httptest.NewRequest(http.MethodPost, "/apps", nil)
+	request.RemoteAddr = "203.0.113.99:1234"
+	request.Header.Set("X-Real-IP", "10.0.0.1")
+
+	svc.LogFromRequest(ctx, request, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppCreate,
+		ResourceType: models.AuditResourceApp,
+	})
+
+	entries, err := models.FindAuditEntries(ctx, db, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.Equal(t, "203.0.113.99", entries[0].RemoteIP.String)
+}
+
+func TestAuditServiceRecent(t *testing.T) {
+	t.Parallel()
+
+	svc, _ := setupTestAuditService(t)
+	ctx := context.Background()
+
+	for range 5 {
+		svc.Log(ctx, audit.LogEntry{
+			Username:     "admin",
+			Action:       models.AuditActionLogin,
+			ResourceType: models.AuditResourceSession,
+		})
+	}
+
+	entries, err := svc.Recent(ctx, 3)
+	require.NoError(t, err)
+	assert.Len(t, entries, 3)
+}
+
+func TestAuditServiceForResource(t *testing.T) {
+	t.Parallel()
+
+	svc, _ := setupTestAuditService(t)
+	ctx := context.Background()
+
+	// Log entries for different resources.
+	svc.Log(ctx, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppCreate,
+		ResourceType: models.AuditResourceApp,
+		ResourceID:   "app-1",
+	})
+	svc.Log(ctx, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppDeploy,
+		ResourceType: models.AuditResourceApp,
+		ResourceID:   "app-1",
+	})
+	svc.Log(ctx, audit.LogEntry{
+		Username:     "admin",
+		Action:       models.AuditActionAppCreate,
+		ResourceType: models.AuditResourceApp,
+		ResourceID:   "app-2",
+	})
+
+	entries, err := svc.ForResource(ctx, models.AuditResourceApp, "app-1", 10)
+	require.NoError(t, err)
+	assert.Len(t, entries, 2)
+}
+
+func TestAuditServiceLogWithNoOptionalFields(t *testing.T) {
+	t.Parallel()
+
+	svc, db := setupTestAuditService(t)
+	ctx := context.Background()
+
+	svc.Log(ctx, audit.LogEntry{
+		Username:     "system",
+		Action:       models.AuditActionWebhookReceive,
+		ResourceType: models.AuditResourceWebhook,
+	})
+
+	entries, err := models.FindAuditEntries(ctx, db, 10)
+	require.NoError(t, err)
+	require.Len(t, entries, 1)
+	assert.False(t, entries[0].UserID.Valid)
+	assert.False(t, entries[0].ResourceID.Valid)
+	assert.False(t, entries[0].Detail.Valid)
+	assert.False(t, entries[0].RemoteIP.Valid)
+}

internal/service/deploy/deploy.go

@@ -21,6 +21,7 @@ import (
 	"sneak.berlin/go/upaas/internal/database"
 	"sneak.berlin/go/upaas/internal/docker"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/internal/service/notify"
 )
@@ -208,6 +209,7 @@ type ServiceParams struct {
 	Database *database.Database
 	Docker   *docker.Client
 	Notify   *notify.Service
+	Metrics  *metrics.Metrics
 }
 
 // activeDeploy tracks a running deployment so it can be cancelled.
@@ -222,6 +224,7 @@ type Service struct {
 	db            *database.Database
 	docker        *docker.Client
 	notify        *notify.Service
+	metrics       *metrics.Metrics
 	config        *config.Config
 	params        *ServiceParams
 	activeDeploys sync.Map // map[string]*activeDeploy - per-app active deployment tracking
@@ -231,12 +234,13 @@ type Service struct {
 // New creates a new deploy Service.
 func New(lc fx.Lifecycle, params ServiceParams) (*Service, error) {
 	svc := &Service{
-		log:    params.Logger.Get(),
-		db:     params.Database,
-		docker: params.Docker,
-		notify: params.Notify,
-		config: params.Config,
-		params: &params,
+		log:     params.Logger.Get(),
+		db:      params.Database,
+		docker:  params.Docker,
+		notify:  params.Notify,
+		metrics: params.Metrics,
+		config:  params.Config,
+		params:  &params,
 	}
 
 	if lc != nil {
@@ -327,6 +331,11 @@ func (svc *Service) Deploy(
 	}
 	defer svc.unlockApp(app.ID)
 
+	// Track in-flight deployments
+	svc.metrics.DeploymentsInFlight.WithLabelValues(app.Name).Inc()
+
+	deployStart := time.Now()
+
 	// Set up cancellable context and register as active deploy
 	deployCtx, cancel := context.WithCancel(ctx)
 	done := make(chan struct{})
@@ -334,6 +343,7 @@ func (svc *Service) Deploy(
 	svc.activeDeploys.Store(app.ID, ad)
 
 	defer func() {
+		svc.metrics.DeploymentsInFlight.WithLabelValues(app.Name).Dec()
 		cancel()
 		close(done)
 		svc.activeDeploys.Delete(app.ID)
@@ -359,7 +369,7 @@ func (svc *Service) Deploy(
 
 	svc.notify.NotifyBuildStart(bgCtx, app, deployment)
 
-	return svc.runBuildAndDeploy(deployCtx, bgCtx, app, deployment)
+	return svc.runBuildAndDeploy(deployCtx, bgCtx, app, deployment, deployStart)
 }
 
 // Rollback rolls back an app to its previous image.
@@ -467,15 +477,20 @@ func (svc *Service) runBuildAndDeploy(
 	bgCtx context.Context,
 	app *models.App,
 	deployment *models.Deployment,
+	deployStart time.Time,
 ) error {
 	// Build phase with timeout
 	imageID, err := svc.buildImageWithTimeout(deployCtx, app, deployment)
 	if err != nil {
 		cancelErr := svc.checkCancelled(deployCtx, bgCtx, app, deployment, "")
 		if cancelErr != nil {
+			svc.recordDeployMetrics(app.Name, "cancelled", deployStart)
+
 			return cancelErr
 		}
 
+		svc.recordDeployMetrics(app.Name, "failed", deployStart)
+
 		return err
 	}
 
@@ -486,9 +501,13 @@ func (svc *Service) runBuildAndDeploy(
 	if err != nil {
 		cancelErr := svc.checkCancelled(deployCtx, bgCtx, app, deployment, imageID)
 		if cancelErr != nil {
+			svc.recordDeployMetrics(app.Name, "cancelled", deployStart)
+
 			return cancelErr
 		}
 
+		svc.recordDeployMetrics(app.Name, "failed", deployStart)
+
 		return err
 	}
 
@@ -504,11 +523,19 @@ func (svc *Service) runBuildAndDeploy(
 
 	// Use context.WithoutCancel to ensure health check completes even if
 	// the parent context is cancelled (e.g., HTTP request ends).
-	go svc.checkHealthAfterDelay(bgCtx, app, deployment)
+	go svc.checkHealthAfterDelay(bgCtx, app, deployment, deployStart)
 
 	return nil
 }
 
+// recordDeployMetrics records deployment completion metrics.
+func (svc *Service) recordDeployMetrics(appName, status string, start time.Time) {
+	duration := time.Since(start).Seconds()
+
+	svc.metrics.DeploymentsTotal.WithLabelValues(appName, status).Inc()
+	svc.metrics.DeploymentDuration.WithLabelValues(appName, status).Observe(duration)
+}
+
 // buildImageWithTimeout runs the build phase with a timeout.
 func (svc *Service) buildImageWithTimeout(
 	ctx context.Context,
@@ -1163,6 +1190,7 @@ func (svc *Service) checkHealthAfterDelay(
 	ctx context.Context,
 	app *models.App,
 	deployment *models.Deployment,
+	deployStart time.Time,
 ) {
 	svc.log.Info(
 		"waiting 60 seconds to check container health",
@@ -1189,6 +1217,8 @@ func (svc *Service) checkHealthAfterDelay(
 		svc.notify.NotifyDeployFailed(ctx, reloadedApp, deployment, err)
 		_ = deployment.MarkFinished(ctx, models.DeploymentStatusFailed)
 		svc.writeLogsToFile(reloadedApp, deployment)
+		svc.recordDeployMetrics(reloadedApp.Name, "failed", deployStart)
+		svc.metrics.ContainerHealthy.WithLabelValues(reloadedApp.Name).Set(0)
 		reloadedApp.Status = models.AppStatusError
 		_ = reloadedApp.Save(ctx)
 
@@ -1200,6 +1230,8 @@ func (svc *Service) checkHealthAfterDelay(
 		svc.notify.NotifyDeploySuccess(ctx, reloadedApp, deployment)
 		_ = deployment.MarkFinished(ctx, models.DeploymentStatusSuccess)
 		svc.writeLogsToFile(reloadedApp, deployment)
+		svc.recordDeployMetrics(reloadedApp.Name, "success", deployStart)
+		svc.metrics.ContainerHealthy.WithLabelValues(reloadedApp.Name).Set(1)
 	} else {
 		svc.log.Warn(
 			"container unhealthy after 60 seconds",
@@ -1208,6 +1240,8 @@ func (svc *Service) checkHealthAfterDelay(
 		svc.notify.NotifyDeployFailed(ctx, reloadedApp, deployment, ErrContainerUnhealthy)
 		_ = deployment.MarkFinished(ctx, models.DeploymentStatusFailed)
 		svc.writeLogsToFile(reloadedApp, deployment)
+		svc.recordDeployMetrics(reloadedApp.Name, "failed", deployStart)
+		svc.metrics.ContainerHealthy.WithLabelValues(reloadedApp.Name).Set(0)
 		reloadedApp.Status = models.AppStatusError
 		_ = reloadedApp.Save(ctx)
 	}

internal/service/webhook/webhook.go

@@ -7,12 +7,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
+	"strconv"
 
 	"go.uber.org/fx"
 
 	"sneak.berlin/go/upaas/internal/database"
 
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/internal/service/deploy"
 )
@@ -24,23 +26,26 @@ type ServiceParams struct {
 	Logger   *logger.Logger
 	Database *database.Database
 	Deploy   *deploy.Service
+	Metrics  *metrics.Metrics
 }
 
 // Service provides webhook handling functionality.
 type Service struct {
-	log    *slog.Logger
-	db     *database.Database
-	deploy *deploy.Service
-	params *ServiceParams
+	log     *slog.Logger
+	db      *database.Database
+	deploy  *deploy.Service
+	metrics *metrics.Metrics
+	params  *ServiceParams
 }
 
 // New creates a new webhook Service.
 func New(_ fx.Lifecycle, params ServiceParams) (*Service, error) {
 	return &Service{
-		log:    params.Logger.Get(),
-		db:     params.Database,
-		deploy: params.Deploy,
-		params: &params,
+		log:     params.Logger.Get(),
+		db:      params.Database,
+		deploy:  params.Deploy,
+		metrics: params.Metrics,
+		params:  &params,
 	}, nil
 }
 
@@ -122,6 +127,10 @@ func (svc *Service) HandleWebhook(
 		"commit", commitSHA,
 	)
 
+	svc.metrics.WebhookEventsTotal.WithLabelValues(
+		app.Name, eventType, strconv.FormatBool(matched),
+	).Inc()
+
 	// If branch matches, trigger deployment
 	if matched {
 		svc.triggerDeployment(ctx, app, event)

internal/service/webhook/webhook_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/fx"
@@ -17,6 +18,7 @@ import (
 	"sneak.berlin/go/upaas/internal/docker"
 	"sneak.berlin/go/upaas/internal/globals"
 	"sneak.berlin/go/upaas/internal/logger"
+	"sneak.berlin/go/upaas/internal/metrics"
 	"sneak.berlin/go/upaas/internal/models"
 	"sneak.berlin/go/upaas/internal/service/deploy"
 	"sneak.berlin/go/upaas/internal/service/notify"
@@ -63,13 +65,17 @@ func setupTestService(t *testing.T) (*webhook.Service, *database.Database, func(
 	notifySvc, err := notify.New(fx.Lifecycle(nil), notify.ServiceParams{Logger: deps.logger})
 	require.NoError(t, err)
 
+	metricsInstance := metrics.NewForTest(prometheus.NewRegistry())
+
 	deploySvc, err := deploy.New(fx.Lifecycle(nil), deploy.ServiceParams{
 		Logger: deps.logger, Config: deps.config, Database: deps.db, Docker: dockerClient, Notify: notifySvc,
+		Metrics: metricsInstance,
 	})
 	require.NoError(t, err)
 
 	svc, err := webhook.New(fx.Lifecycle(nil), webhook.ServiceParams{
 		Logger: deps.logger, Database: deps.db, Deploy: deploySvc,
+		Metrics: metricsInstance,
 	})
 	require.NoError(t, err)
 

templates/app_detail.html

@@ -432,18 +432,6 @@
         </div>
     </div>
 
-    <!-- Backup -->
-    <div class="card p-6 mb-6">
-        <h2 class="section-title mb-4">Backup</h2>
-        <p class="text-sm text-gray-500 mb-3">Export this app's configuration (settings, env vars, labels, volumes, ports) as a JSON file for backup or migration.</p>
-        <a href="/apps/{{.App.ID}}/export" class="btn-secondary">
-            <svg class="w-4 h-4 mr-1 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4"/>
-            </svg>
-            Export Config
-        </a>
-    </div>
-
     <!-- Danger Zone -->
     <div class="card border-2 border-error-500/20 bg-error-50/50 p-6">
         <h2 class="text-lg font-medium text-error-700 mb-4">Danger Zone</h2>

templates/backup_import.html

@@ -1,62 +0,0 @@
-{{template "base" .}}
-
-{{define "title"}}Import Backup - µPaaS{{end}}
-
-{{define "content"}}
-{{template "nav" .}}
-
-<main class="max-w-4xl mx-auto px-4 py-8">
-    <div class="mb-6">
-        <a href="/" class="text-primary-600 hover:text-primary-800 inline-flex items-center">
-            <svg class="w-4 h-4 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"/>
-            </svg>
-            Back to Dashboard
-        </a>
-    </div>
-
-    {{template "alert-success" .}}
-    {{template "alert-error" .}}
-
-    <h1 class="text-2xl font-medium text-gray-900 mb-6">Import Backup</h1>
-
-    <div class="card p-6 mb-6">
-        <h2 class="section-title mb-4">Restore from Backup File</h2>
-        <p class="text-sm text-gray-500 mb-4">
-            Upload a previously exported µPaaS backup file (JSON) to restore app configurations.
-            New apps will be created with fresh SSH keys and webhook secrets.
-            Apps whose names already exist will be skipped.
-        </p>
-        <form method="POST" action="/backup/import" enctype="multipart/form-data">
-            {{ .CSRFField }}
-            <div class="mb-4">
-                <label for="backup_file" class="form-label">Backup File</label>
-                <input type="file" id="backup_file" name="backup_file" accept=".json,application/json"
-                    class="block w-full text-sm text-gray-500
-                    file:mr-4 file:py-2 file:px-4
-                    file:rounded file:border-0
-                    file:text-sm file:font-medium
-                    file:bg-primary-50 file:text-primary-700
-                    hover:file:bg-primary-100
-                    cursor-pointer">
-            </div>
-            <button type="submit" class="btn-primary">Import</button>
-        </form>
-    </div>
-
-    <div class="card p-6">
-        <h2 class="section-title mb-4">Export All Apps</h2>
-        <p class="text-sm text-gray-500 mb-4">
-            Download a backup of all app configurations. This includes app settings,
-            environment variables, labels, volumes, and port mappings.
-            Secrets (SSH keys, webhook tokens) are not included — they are regenerated on import.
-        </p>
-        <a href="/backup/export" class="btn-secondary">
-            <svg class="w-4 h-4 mr-1 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4"/>
-            </svg>
-            Export All Apps
-        </a>
-    </div>
-</main>
-{{end}}

templates/dashboard.html

@@ -11,20 +11,12 @@
 
     <div class="section-header">
         <h1 class="text-2xl font-medium text-gray-900">Applications</h1>
-        <div class="flex gap-3">
-            <a href="/backup/import" class="btn-secondary">
-                <svg class="w-4 h-4 mr-1 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-8l-4-4m0 0L8 8m4-4v12"/>
-                </svg>
-                Backup / Restore
-            </a>
-            <a href="/apps/new" class="btn-primary">
-                <svg class="w-5 h-5 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/>
-                </svg>
-                New App
-            </a>
-        </div>
+        <a href="/apps/new" class="btn-primary">
+            <svg class="w-5 h-5 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/>
+            </svg>
+            New App
+        </a>
     </div>
 
     {{if .AppStats}}

templates/templates.go

@@ -45,7 +45,6 @@ func initTemplates() {
 		"app_edit.html",
 		"deployments.html",
 		"webhook_events.html",
-		"backup_import.html",
 	}
 
 	pageTemplates = make(map[string]*template.Template)