Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FEATURE (audit logs): Add retention for audit logs within 1 year

Rostislav Dugin9d30406d833b
diff --git a/backend/cmd/main.go b/backend/cmd/main.go
index fb381c7b..a00e4d51 100644
--- a/backend/cmd/main.go
+++ b/backend/cmd/main.go
@@ -238,6 +238,10 @@ func runBackgroundTasks(log *slog.Logger) {
go runWithPanicLogging(log, "healthcheck attempt background service", func() {
healthcheck_attempt.GetHealthcheckAttemptBackgroundService().Run()
})
+
+ go runWithPanicLogging(log, "audit log cleanup background service", func() {
+ audit_logs.GetAuditLogBackgroundService().Run()
+ })
}
func runWithPanicLogging(log *slog.Logger, serviceName string, fn func()) {
diff --git a/backend/internal/features/audit_logs/background_service.go b/backend/internal/features/audit_logs/background_service.go
new file mode 100644
index 00000000..fd18d096
--- /dev/null
+++ b/backend/internal/features/audit_logs/background_service.go
@@ -0,0 +1,36 @@
+package audit_logs
+
+import (
+ "databasus-backend/internal/config"
+ "log/slog"
+ "time"
+)
+
+type AuditLogBackgroundService struct {
+ auditLogService *AuditLogService
+ logger *slog.Logger
+}
+
+func (s *AuditLogBackgroundService) Run() {
+ s.logger.Info("Starting audit log cleanup background service")
+
+ if config.IsShouldShutdown() {
+ return
+ }
+
+ for {
+ if config.IsShouldShutdown() {
+ return
+ }
+
+ if err := s.cleanOldAuditLogs(); err != nil {
+ s.logger.Error("Failed to clean old audit logs", "error", err)
+ }
+
+ time.Sleep(1 * time.Hour)
+ }
+}
+
+func (s *AuditLogBackgroundService) cleanOldAuditLogs() error {
+ return s.auditLogService.CleanOldAuditLogs()
+}
diff --git a/backend/internal/features/audit_logs/background_service_test.go b/backend/internal/features/audit_logs/background_service_test.go
new file mode 100644
index 00000000..8ed1af3f
--- /dev/null
+++ b/backend/internal/features/audit_logs/background_service_test.go
@@ -0,0 +1,141 @@
+package audit_logs
+
+import (
+ "databasus-backend/internal/storage"
+ "fmt"
+ "testing"
+ "time"
+
+ user_enums "databasus-backend/internal/features/users/enums"
+ users_testing "databasus-backend/internal/features/users/testing"
+
+ "github.com/google/uuid"
+ "github.com/stretchr/testify/assert"
+ "gorm.io/gorm"
+)
+
+func Test_CleanOldAuditLogs_DeletesLogsOlderThanOneYear(t *testing.T) {
+ service := GetAuditLogService()
+ user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ db := storage.GetDb()
+ baseTime := time.Now().UTC()
+
+ // Create old logs (more than 1 year old)
+ createTimedAuditLog(db, &user.UserID, "Old log 1", baseTime.Add(-400*24*time.Hour))
+ createTimedAuditLog(db, &user.UserID, "Old log 2", baseTime.Add(-370*24*time.Hour))
+
+ // Create recent logs (less than 1 year old)
+ createAuditLog(service, "Recent log 1", &user.UserID, nil)
+ createAuditLog(service, "Recent log 2", &user.UserID, nil)
+
+ // Run cleanup
+ err := service.CleanOldAuditLogs()
+ assert.NoError(t, err)
+
+ // Verify old logs were deleted
+ oneYearAgo := baseTime.Add(-365 * 24 * time.Hour)
+ var oldLogs []*AuditLog
+ db.Where("created_at < ?", oneYearAgo).Find(&oldLogs)
+ assert.Equal(t, 0, len(oldLogs), "All logs older than 1 year should be deleted")
+
+ // Verify recent logs still exist
+ var recentLogs []*AuditLog
+ db.Where("created_at >= ?", oneYearAgo).Find(&recentLogs)
+ assert.GreaterOrEqual(t, len(recentLogs), 2, "Recent logs should not be deleted")
+}
+
+func Test_CleanOldAuditLogs_PreservesLogsNewerThanOneYear(t *testing.T) {
+ service := GetAuditLogService()
+ user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ db := storage.GetDb()
+ baseTime := time.Now().UTC()
+
+ // Create logs exactly at boundary (1 year old)
+ boundaryTime := baseTime.Add(-365 * 24 * time.Hour)
+ createTimedAuditLog(db, &user.UserID, "Boundary log", boundaryTime)
+
+ // Create recent logs
+ createTimedAuditLog(db, &user.UserID, "Recent log 1", baseTime.Add(-364*24*time.Hour))
+ createTimedAuditLog(db, &user.UserID, "Recent log 2", baseTime.Add(-100*24*time.Hour))
+ createAuditLog(service, "Current log", &user.UserID, nil)
+
+ // Get count before cleanup
+ var countBefore int64
+ db.Model(&AuditLog{}).Count(&countBefore)
+
+ // Run cleanup
+ err := service.CleanOldAuditLogs()
+ assert.NoError(t, err)
+
+ // Get count after cleanup
+ var countAfter int64
+ db.Model(&AuditLog{}).Count(&countAfter)
+
+ // Verify logs newer than 1 year are preserved
+ oneYearAgo := baseTime.Add(-365 * 24 * time.Hour)
+ var recentLogs []*AuditLog
+ db.Where("created_at >= ?", oneYearAgo).Find(&recentLogs)
+
+ messages := make([]string, len(recentLogs))
+ for i, log := range recentLogs {
+ messages[i] = log.Message
+ }
+
+ assert.Contains(t, messages, "Recent log 1")
+ assert.Contains(t, messages, "Recent log 2")
+ assert.Contains(t, messages, "Current log")
+}
+
+func Test_CleanOldAuditLogs_HandlesEmptyDatabase(t *testing.T) {
+ service := GetAuditLogService()
+
+ // Run cleanup on database that may have no old logs
+ err := service.CleanOldAuditLogs()
+ assert.NoError(t, err)
+}
+
+func Test_CleanOldAuditLogs_DeletesMultipleOldLogs(t *testing.T) {
+ service := GetAuditLogService()
+ user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ db := storage.GetDb()
+ baseTime := time.Now().UTC()
+
+ // Create many old logs with specific UUIDs to track them
+ testLogIDs := make([]uuid.UUID, 5)
+ for i := 0; i < 5; i++ {
+ testLogIDs[i] = uuid.New()
+ daysAgo := 400 + (i * 10)
+ log := &AuditLog{
+ ID: testLogIDs[i],
+ UserID: &user.UserID,
+ Message: fmt.Sprintf("Test old log %d", i),
+ CreatedAt: baseTime.Add(-time.Duration(daysAgo) * 24 * time.Hour),
+ }
+ result := db.Create(log)
+ assert.NoError(t, result.Error)
+ }
+
+ // Verify logs exist before cleanup
+ var logsBeforeCleanup []*AuditLog
+ db.Where("id IN ?", testLogIDs).Find(&logsBeforeCleanup)
+ assert.Equal(t, 5, len(logsBeforeCleanup), "All test logs should exist before cleanup")
+
+ // Run cleanup
+ err := service.CleanOldAuditLogs()
+ assert.NoError(t, err)
+
+ // Verify test logs were deleted
+ var logsAfterCleanup []*AuditLog
+ db.Where("id IN ?", testLogIDs).Find(&logsAfterCleanup)
+ assert.Equal(t, 0, len(logsAfterCleanup), "All old test logs should be deleted")
+}
+
+func createTimedAuditLog(db *gorm.DB, userID *uuid.UUID, message string, createdAt time.Time) {
+ log := &AuditLog{
+ ID: uuid.New(),
+ UserID: userID,
+ Message: message,
+ CreatedAt: createdAt,
+ }
+ db.Create(log)
+}
diff --git a/backend/internal/features/audit_logs/di.go b/backend/internal/features/audit_logs/di.go
index 7932bd47..2f0ae83d 100644
--- a/backend/internal/features/audit_logs/di.go
+++ b/backend/internal/features/audit_logs/di.go
@@ -7,11 +7,15 @@ import (
var auditLogRepository = &AuditLogRepository{}
var auditLogService = &AuditLogService{
- auditLogRepository: auditLogRepository,
- logger: logger.GetLogger(),
+ auditLogRepository,
+ logger.GetLogger(),
}
var auditLogController = &AuditLogController{
- auditLogService: auditLogService,
+ auditLogService,
+}
+var auditLogBackgroundService = &AuditLogBackgroundService{
+ auditLogService,
+ logger.GetLogger(),
}
func GetAuditLogService() *AuditLogService {
@@ -22,6 +26,10 @@ func GetAuditLogController() *AuditLogController {
return auditLogController
}
+func GetAuditLogBackgroundService() *AuditLogBackgroundService {
+ return auditLogBackgroundService
+}
+
func SetupDependencies() {
users_services.GetUserService().SetAuditLogWriter(auditLogService)
users_services.GetSettingsService().SetAuditLogWriter(auditLogService)
diff --git a/backend/internal/features/audit_logs/repository.go b/backend/internal/features/audit_logs/repository.go
index 33540ed8..9823519a 100644
--- a/backend/internal/features/audit_logs/repository.go
+++ b/backend/internal/features/audit_logs/repository.go
@@ -137,3 +137,15 @@ func (r *AuditLogRepository) CountGlobal(beforeDate *time.Time) (int64, error) {
err := query.Count(&count).Error
return count, err
}
+
+func (r *AuditLogRepository) DeleteOlderThan(beforeDate time.Time) (int64, error) {
+ result := storage.GetDb().
+ Where("created_at < ?", beforeDate).
+ Delete(&AuditLog{})
+
+ if result.Error != nil {
+ return 0, result.Error
+ }
+
+ return result.RowsAffected, nil
+}
diff --git a/backend/internal/features/audit_logs/service.go b/backend/internal/features/audit_logs/service.go
index 4b99621e..a29490cb 100644
--- a/backend/internal/features/audit_logs/service.go
+++ b/backend/internal/features/audit_logs/service.go
@@ -135,3 +135,19 @@ func (s *AuditLogService) GetWorkspaceAuditLogs(
Offset: offset,
}, nil
}
+
+func (s *AuditLogService) CleanOldAuditLogs() error {
+ oneYearAgo := time.Now().UTC().Add(-365 * 24 * time.Hour)
+
+ deletedCount, err := s.auditLogRepository.DeleteOlderThan(oneYearAgo)
+ if err != nil {
+ s.logger.Error("Failed to delete old audit logs", "error", err)
+ return err
+ }
+
+ if deletedCount > 0 {
+ s.logger.Info("Deleted old audit logs", "count", deletedCount, "olderThan", oneYearAgo)
+ }
+
+ return nil
+}