1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

package database

import (
	"errors"
	"log"
	"os"
	"time"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

var DB *gorm.DB = nil

type ConfigEntry struct {
	Key   string `gorm:"primaryKey;size:100"`
	Value string `gorm:"type:text"`
}

func ConnectDB() error {
	db, err := gorm.Open(postgres.Open(os.Getenv("DATABASE")), &gorm.Config{})
	if err != nil {
		log.Println("database connection error:", err)
		return errors.New("can't connect to database")
	}
	if err := db.AutoMigrate(&Logtable{}, &ConfigEntry{}); err != nil {
		return err
	}
	DB = db
	return nil
}

func LoadConfigEntry(key string) (string, error) {
	if DB == nil {
		return "", errors.New("database not initialized")
	}
	var entry ConfigEntry
	if err := DB.First(&entry, "key = ?", key).Error; err != nil {
		return "", err
	}
	return entry.Value, nil
}

func SaveConfigEntry(key, value string) error {
	if DB == nil {
		return errors.New("database not initialized")
	}
	entry := ConfigEntry{Key: key, Value: value}
	return DB.Save(&entry).Error
}

// CleanupOldLogs deletes oldest entries when count exceeds maxEntries
func CleanupOldLogs(maxEntries int) error {
	if DB == nil {
		return errors.New("database not initialized")
	}

	var count int64
	if err := DB.Model(&Logtable{}).Count(&count).Error; err != nil {
		return err
	}

	if count > int64(maxEntries) {
		deleteCount := count - int64(maxEntries)
		subQuery := DB.Model(&Logtable{}).Select("id").Order("created ASC").Limit(int(deleteCount))
		if err := DB.Where("id IN (?)", subQuery).Delete(&Logtable{}).Error; err != nil {
			return err
		}
		log.Printf("Cleaned up %d old log entries", deleteCount)
	}
	return nil
}

// DeleteLogsOlderThan deletes all log entries older than the given retention duration.
func DeleteLogsOlderThan(retention time.Duration) error {
	if DB == nil {
		return errors.New("database not initialized")
	}
	cutoff := time.Now().Add(-retention)
	result := DB.Where("created < ?", cutoff).Delete(&Logtable{})
	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected > 0 {
		log.Printf("Retention cleanup: deleted %d log entries older than %v", result.RowsAffected, retention)
	}
	return nil
}

// StartCleanupRoutine starts a background goroutine that periodically cleans up old logs.
// maxEntries: hard cap on total row count (0 = disabled)
// retention: delete entries older than this duration (0 = disabled)
func StartCleanupRoutine(maxEntries int, retention time.Duration, interval time.Duration) {
	go func() {
		ticker := time.NewTicker(interval)
		defer ticker.Stop()
		for range ticker.C {
			if retention > 0 {
				if err := DeleteLogsOlderThan(retention); err != nil {
					log.Printf("Retention cleanup failed: %v", err)
				}
			}
			if maxEntries > 0 {
				if err := CleanupOldLogs(maxEntries); err != nil {
					log.Printf("Log cleanup failed: %v", err)
				}
			}
		}
	}()
	log.Printf("Started log cleanup routine (max %d entries, retention %v, every %v)", maxEntries, retention, interval)
}

type Logtable struct {
	ID            uint   `gorm:"primaryKey"`
	GUID          string `gorm:"size:100"`
	IP            string `gorm:"size:100"`
	Path          string `gorm:"size:255"`
	Service       string `gorm:"size:100"`
	ServiceExists bool
	HeaderRouting bool
	Routed        bool
	EndPoint      string `gorm:"size:255"`
	Method        string `gorm:"size:100"`
	RequestSize   int
	Host          string `gorm:"size:100"`
	HeadersCount  int
	ResponseTime  float32
	StatusCode    int
	Created       time.Time `gorm:"autoCreateTime"`
	Message       string
	TimePre       float32
	TimePost      float32
	TimeFull      float32
}