bebe/bamort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Logging auf console eingebaut

Browse Source
This commit is contained in:
Frank
2025-08-10 20:19:30 +02:00
parent 61c89fc964
commit 1880051165
11 changed files with 1026 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/.env.example
+51
View File
@@ -0,0 +1,51 @@
# Bamort Server Konfiguration
# ======================
# Server Einstellungen
# ======================
PORT=8180
SERVER_PORT=8180
# ======================
# Umgebung
# ======================
# Optionen: development, production, test
ENVIRONMENT=development
# Alternative:
# GO_ENV=development
# ======================
# Logging Konfiguration
# ======================
# Debug-Modus (true/false oder 1/0)
DEBUG=true
# Log-Level (DEBUG, INFO, WARN, ERROR)
LOG_LEVEL=DEBUG
# ======================
# Datenbank Konfiguration
# ======================
# DATABASE_URL=postgresql://user:password@localhost:5432/bamort_db
# ======================
# Beispiel-Konfigurationen
# ======================
# Development:
# ENVIRONMENT=development
# DEBUG=true
# LOG_LEVEL=DEBUG
# PORT=8180
# Production:
# ENVIRONMENT=production
# DEBUG=false
# LOG_LEVEL=INFO
# PORT=8180
# Testing:
# ENVIRONMENT=test
# DEBUG=true
# LOG_LEVEL=WARN
# PORT=8181
backend/.env.production
+26
View File
@@ -0,0 +1,26 @@
# Bamort Server Konfiguration - Produktionsumgebung
# Diese Datei sollte für die Produktionsumgebung verwendet werden
# ======================
# Server Einstellungen
# ======================
PORT=8180
# ======================
# Umgebung
# ======================
ENVIRONMENT=production
# ======================
# Logging Konfiguration
# ======================
# Debug-Modus (deaktiviert für Produktion)
DEBUG=false
# Log-Level (nur wichtige Nachrichten in Produktion)
LOG_LEVEL=INFO
# ======================
# Datenbank Konfiguration
# ======================
# DATABASE_URL=postgresql://user:password@prod-host:5432/bamort_prod_db
backend/.gitignore
+10
View File
@@ -28,3 +28,13 @@ coverage
*.sw? *.sw?
*.tsbuildinfo *.tsbuildinfo
# Environment variables
.env.local
.env.production.local
.env.test.local
# Binaries
main
bamort
*.exe
backend/LOGGING.md
+190
View File
@@ -0,0 +1,190 @@
# Bamort Logging System
## Überblick
Das Bamort Logging System bietet konfigurierbare Debug- und Standard-Logs, die über Umgebungsvariablen oder .env-Dateien gesteuert werden können.
## Konfiguration
### .env-Dateien
Das System lädt automatisch `.env` und `.env.local` Dateien aus dem Projektverzeichnis, falls vorhanden.
**Priorität der Konfigurationsquellen:**
1. Bereits gesetzte Umgebungsvariablen (höchste Priorität)
2. .env.local Datei
3. .env Datei
4. Standard-Werte (niedrigste Priorität)
**Beispiel .env-Datei:**
```bash
# Bamort Server Konfiguration
ENVIRONMENT=development
DEBUG=true
LOG_LEVEL=DEBUG
PORT=8180
DATABASE_URL=postgresql://user:pass@localhost:5432/bamort
```
### Umgebungsvariablen
### Debug-Modus
```bash
# Debug-Modus aktivieren
DEBUG=true
# oder
DEBUG=1
```
### Log-Level
```bash
# Verfügbare Log-Level: DEBUG, INFO, WARN, ERROR
LOG_LEVEL=DEBUG
LOG_LEVEL=INFO
LOG_LEVEL=WARN
LOG_LEVEL=ERROR
```
### Environment
```bash
# Umgebung definieren
ENVIRONMENT=development # Aktiviert automatisch Debug-Modus
ENVIRONMENT=production # Deaktiviert Debug-Modus standardmäßig
# oder
GO_ENV=development
GO_ENV=production
```
### Server-Port
```bash
# Server-Port konfigurieren
PORT=8180
# oder
SERVER_PORT=8180
```
## Verwendung im Code
### Import
```go
import "bamort/logger"
```
### Logging-Funktionen
```go
// Debug-Messages (nur sichtbar wenn Debug-Modus aktiviert)
logger.Debug("Debug-Information: %s", variable)
logger.Debugf("Debug mit Printf-Syntax: %d", number)
// Info-Messages
logger.Info("Server gestartet auf Port %s", port)
logger.Infof("Benutzer %s angemeldet", username)
// Warning-Messages
logger.Warn("Warnung: %s", warningMessage)
logger.Warnf("Performance-Warnung: %dms", duration)
// Error-Messages
logger.Error("Fehler beim Laden der Datenbank: %s", err.Error())
logger.Errorf("HTTP-Fehler %d: %s", statusCode, message)
```
### Programmgesteuerte Konfiguration
```go
import (
"bamort/logger"
"bamort/config"
)
// Konfiguration laden
cfg := config.LoadConfig()
// Debug-Modus setzen
logger.SetDebugMode(true)
// Minimales Log-Level setzen
logger.SetMinLogLevel(logger.DEBUG)
// Debug-Status prüfen
if logger.IsDebugEnabled() {
// Nur ausführen wenn Debug aktiv
}
```
## Beispiel-Konfigurationen
### Development
```bash
export ENVIRONMENT=development
export DEBUG=true
export LOG_LEVEL=DEBUG
export PORT=8180
```
### Production
```bash
export ENVIRONMENT=production
export DEBUG=false
export LOG_LEVEL=INFO
export PORT=8180
```
### Testing
```bash
export ENVIRONMENT=test
export DEBUG=true
export LOG_LEVEL=WARN
export PORT=8181
```
## Log-Format
```
[2025-08-10 15:04:05] DEBUG: Debug-Nachricht hier
[2025-08-10 15:04:05] INFO: Info-Nachricht hier
[2025-08-10 15:04:05] WARN: Warning-Nachricht hier
[2025-08-10 15:04:05] ERROR: Error-Nachricht hier
```
## Docker-Konfiguration
### Dockerfile
```dockerfile
# Für Development
ENV ENVIRONMENT=development
ENV DEBUG=true
ENV LOG_LEVEL=DEBUG
# Für Production
ENV ENVIRONMENT=production
ENV DEBUG=false
ENV LOG_LEVEL=INFO
```
### docker-compose.yml
```yaml
version: '3.8'
services:
bamort-api:
environment:
- ENVIRONMENT=development
- DEBUG=true
- LOG_LEVEL=DEBUG
- PORT=8180
```
## Best Practices
1. **Debug-Messages**: Verwenden Sie Debug-Messages für detaillierte Informationen, die nur während der Entwicklung relevant sind.
2. **Info-Messages**: Verwenden Sie Info-Messages für wichtige Ereignisse wie Server-Start, Benutzeraktionen, etc.
3. **Warning-Messages**: Verwenden Sie Warn-Messages für potentielle Probleme, die nicht zum Absturz führen.
4. **Error-Messages**: Verwenden Sie Error-Messages für tatsächliche Fehler und Exceptions.
5. **Performance**: Debug-Messages werden automatisch gefiltert, wenn der Debug-Modus deaktiviert ist, daher keine Performance-Einbußen in der Produktion.
6. **Sensitive Daten**: Niemals Passwörter, Token oder andere sensitive Daten loggen, besonders nicht in höheren Log-Levels.
backend/character/handlers.go
+12
View File
@@ -3,6 +3,7 @@ package character
import ( import (
"bamort/database" "bamort/database"
"bamort/gsmaster" "bamort/gsmaster"
"bamort/logger"
"bamort/models" "bamort/models"
"strconv" "strconv"
"strings" "strings"
@@ -23,16 +24,25 @@ type LearnRequestStruct struct {
} }
func respondWithError(c *gin.Context, status int, message string) { func respondWithError(c *gin.Context, status int, message string) {
logger.Warn("HTTP Fehler %d: %s", status, message)
c.JSON(status, gin.H{"error": message}) c.JSON(status, gin.H{"error": message})
} }
func ListCharacters(c *gin.Context) { func ListCharacters(c *gin.Context) {
logger.Debug("ListCharacters aufgerufen")
var characters []models.Char var characters []models.Char
var listOfChars []models.CharList var listOfChars []models.CharList
logger.Debug("Lade Charaktere aus der Datenbank...")
if err := database.DB.Find(&characters).Error; err != nil { if err := database.DB.Find(&characters).Error; err != nil {
logger.Error("Fehler beim Laden der Charaktere: %s", err.Error())
respondWithError(c, http.StatusInternalServerError, "Failed to retrieve characters") respondWithError(c, http.StatusInternalServerError, "Failed to retrieve characters")
return return
} }
logger.Debug("Gefundene Charaktere: %d", len(characters))
for i := range characters { for i := range characters {
listOfChars = append(listOfChars, models.CharList{ listOfChars = append(listOfChars, models.CharList{
BamortBase: models.BamortBase{ BamortBase: models.BamortBase{
@@ -45,6 +55,8 @@ func ListCharacters(c *gin.Context) {
Owner: "test", Owner: "test",
}) })
} }
logger.Info("Charakterliste erfolgreich geladen: %d Charaktere", len(listOfChars))
c.JSON(http.StatusOK, listOfChars) c.JSON(http.StatusOK, listOfChars)
} }
backend/cmd/main.go
+47 -3
View File
@@ -2,9 +2,11 @@ package main
import ( import (
"bamort/character" "bamort/character"
"bamort/config"
"bamort/database" "bamort/database"
"bamort/gsmaster" "bamort/gsmaster"
"bamort/importer" "bamort/importer"
"bamort/logger"
"bamort/maintenance" "bamort/maintenance"
"bamort/router" "bamort/router"
@@ -18,24 +20,66 @@ import (
// @BasePath / // @BasePath /
// @schemes http // @schemes http
func main() { func main() {
// Konfiguration laden
cfg := config.LoadConfig()
// Logger konfigurieren
logger.SetDebugMode(cfg.DebugMode)
if cfg.LogLevel == "DEBUG" {
logger.SetMinLogLevel(logger.DEBUG)
} else if cfg.LogLevel == "WARN" {
logger.SetMinLogLevel(logger.WARN)
} else if cfg.LogLevel == "ERROR" {
logger.SetMinLogLevel(logger.ERROR)
} else {
logger.SetMinLogLevel(logger.INFO)
}
logger.Info("Bamort Server wird gestartet...")
logger.Debug("Debug-Modus ist aktiviert")
logger.Info("Environment: %s", cfg.Environment)
logger.Info("Server Port: %s", cfg.ServerPort)
// Gin-Modus basierend auf Environment setzen
if cfg.IsProduction() {
gin.SetMode(gin.ReleaseMode)
logger.Info("Gin läuft im Release-Modus")
} else {
gin.SetMode(gin.DebugMode)
logger.Debug("Gin läuft im Debug-Modus")
}
// Datenbank verbinden
logger.Debug("Verbinde mit Datenbank...")
database.ConnectDatabase() database.ConnectDatabase()
//database.DB.AutoMigrate(&models.User{}, &models.Character{}) // Add other models here logger.Info("Datenbankverbindung erfolgreich")
// Migrate Audit-Log table // Migrate Audit-Log table
logger.Debug("Führe Audit-Log Migration durch...")
if err := character.MigrateAuditLog(); err != nil { if err := character.MigrateAuditLog(); err != nil {
logger.Error("Fehler bei Audit-Log Migration: %s", err.Error())
panic("Failed to migrate audit log table: " + err.Error()) panic("Failed to migrate audit log table: " + err.Error())
} }
logger.Debug("Audit-Log Migration erfolgreich")
r := gin.Default() r := gin.Default()
router.SetupGin(r) router.SetupGin(r)
// Routes // Routes registrieren
logger.Debug("Registriere API-Routen...")
protected := router.BaseRouterGrp(r) protected := router.BaseRouterGrp(r)
// Register your module routes // Register your module routes
gsmaster.RegisterRoutes(protected) gsmaster.RegisterRoutes(protected)
character.RegisterRoutes(protected) character.RegisterRoutes(protected)
maintenance.RegisterRoutes(protected) maintenance.RegisterRoutes(protected)
importer.RegisterRoutes(protected) importer.RegisterRoutes(protected)
logger.Info("API-Routen erfolgreich registriert")
r.Run(":8180") // Start server on port 8080 // Server starten
serverAddress := cfg.GetServerAddress()
logger.Info("Server startet auf Adresse: %s", serverAddress)
if err := r.Run(serverAddress); err != nil {
logger.Error("Fehler beim Starten des Servers: %s", err.Error())
panic(err)
}
} }
backend/config/config.go
+167
View File
@@ -0,0 +1,167 @@
package config
import (
"bufio"
"os"
"strconv"
"strings"
)
// Config enthält alle Anwendungskonfigurationen
type Config struct {
// Server Konfiguration
ServerPort string
// Database Konfiguration
DatabaseURL string
// Logging Konfiguration
DebugMode bool
LogLevel string
// Environment
Environment string
}
// defaultConfig gibt die Standard-Konfiguration zurück
func defaultConfig() *Config {
return &Config{
ServerPort: "8180",
DatabaseURL: "",
DebugMode: false,
LogLevel: "INFO",
Environment: "production",
}
}
// LoadConfig lädt die Konfiguration aus Umgebungsvariablen
func LoadConfig() *Config {
// Lade .env-Datei falls vorhanden
loadEnvFile()
config := defaultConfig()
// Server Port
if port := os.Getenv("PORT"); port != "" {
config.ServerPort = port
}
if port := os.Getenv("SERVER_PORT"); port != "" {
config.ServerPort = port
}
// Database
if dbURL := os.Getenv("DATABASE_URL"); dbURL != "" {
config.DatabaseURL = dbURL
}
// Debug Mode
if debug := os.Getenv("DEBUG"); debug != "" {
config.DebugMode = strings.ToLower(debug) == "true" || debug == "1"
}
// Log Level
if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "" {
config.LogLevel = strings.ToUpper(logLevel)
}
// Environment
if env := os.Getenv("ENVIRONMENT"); env != "" {
config.Environment = strings.ToLower(env)
}
if env := os.Getenv("GO_ENV"); env != "" {
config.Environment = strings.ToLower(env)
}
// Automatisch Debug-Modus für Development-Environment aktivieren
if config.Environment == "development" || config.Environment == "dev" {
config.DebugMode = true
if config.LogLevel == "INFO" {
config.LogLevel = "DEBUG"
}
}
return config
}
// loadEnvFile lädt eine .env-Datei falls vorhanden
func loadEnvFile() {
envFiles := []string{".env", ".env.local"}
for _, envFile := range envFiles {
if _, err := os.Stat(envFile); err == nil {
loadEnvFileContent(envFile)
}
}
}
// loadEnvFileContent lädt den Inhalt einer .env-Datei
func loadEnvFileContent(filename string) {
file, err := os.Open(filename)
if err != nil {
return
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
// Überspringe leere Zeilen und Kommentare
if line == "" || strings.HasPrefix(line, "#") {
continue
}
// Teile die Zeile in Key=Value auf
parts := strings.SplitN(line, "=", 2)
if len(parts) != 2 {
continue
}
key := strings.TrimSpace(parts[0])
value := strings.TrimSpace(parts[1])
// Entferne Anführungszeichen falls vorhanden
value = strings.Trim(value, `"'`)
// Setze die Umgebungsvariable nur, wenn sie noch nicht gesetzt ist
if os.Getenv(key) == "" {
os.Setenv(key, value)
}
}
}
// IsDevelopment prüft, ob die Anwendung im Development-Modus läuft
func (c *Config) IsDevelopment() bool {
return c.Environment == "development" || c.Environment == "dev"
}
// IsProduction prüft, ob die Anwendung im Production-Modus läuft
func (c *Config) IsProduction() bool {
return c.Environment == "production" || c.Environment == "prod"
}
// GetServerAddress gibt die vollständige Server-Adresse zurück
func (c *Config) GetServerAddress() string {
return ":" + c.ServerPort
}
// GetBoolEnv ist eine Hilfsfunktion zum Laden von Boolean-Umgebungsvariablen
func GetBoolEnv(key string, defaultValue bool) bool {
if value := os.Getenv(key); value != "" {
if parsed, err := strconv.ParseBool(value); err == nil {
return parsed
}
return strings.ToLower(value) == "true" || value == "1"
}
return defaultValue
}
// GetIntEnv ist eine Hilfsfunktion zum Laden von Integer-Umgebungsvariablen
func GetIntEnv(key string, defaultValue int) int {
if value := os.Getenv(key); value != "" {
if parsed, err := strconv.Atoi(value); err == nil {
return parsed
}
}
return defaultValue
}
backend/config/config_test.go
+192
View File
@@ -0,0 +1,192 @@
package config
import (
"os"
"testing"
)
func TestLoadEnvFile(t *testing.T) {
// Test-Datei erstellen
envContent := `# Test .env file
DEBUG=true
LOG_LEVEL=DEBUG
PORT=9999
# Comment line should be ignored
ENVIRONMENT=test
DATABASE_URL="postgresql://test:test@localhost:5432/test"
QUOTED_VALUE='single quotes'
`
// Temporäre .env-Datei erstellen
err := os.WriteFile(".env.test", []byte(envContent), 0644)
if err != nil {
t.Fatalf("Fehler beim Erstellen der Test-.env-Datei: %v", err)
}
defer os.Remove(".env.test")
// Ursprüngliche Umgebungsvariablen sichern
originalDebug := os.Getenv("DEBUG")
originalLogLevel := os.Getenv("LOG_LEVEL")
originalPort := os.Getenv("PORT")
originalEnv := os.Getenv("ENVIRONMENT")
originalDB := os.Getenv("DATABASE_URL")
originalQuoted := os.Getenv("QUOTED_VALUE")
// Umgebungsvariablen zurücksetzen
os.Unsetenv("DEBUG")
os.Unsetenv("LOG_LEVEL")
os.Unsetenv("PORT")
os.Unsetenv("ENVIRONMENT")
os.Unsetenv("DATABASE_URL")
os.Unsetenv("QUOTED_VALUE")
// Test-Datei laden
loadEnvFileContent(".env.test")
// Tests
tests := []struct {
key string
expected string
}{
{"DEBUG", "true"},
{"LOG_LEVEL", "DEBUG"},
{"PORT", "9999"},
{"ENVIRONMENT", "test"},
{"DATABASE_URL", "postgresql://test:test@localhost:5432/test"},
{"QUOTED_VALUE", "single quotes"},
}
for _, test := range tests {
if value := os.Getenv(test.key); value != test.expected {
t.Errorf("Für %s: erwartet '%s', erhalten '%s'", test.key, test.expected, value)
}
}
// Ursprüngliche Werte wiederherstellen
if originalDebug != "" {
os.Setenv("DEBUG", originalDebug)
} else {
os.Unsetenv("DEBUG")
}
if originalLogLevel != "" {
os.Setenv("LOG_LEVEL", originalLogLevel)
} else {
os.Unsetenv("LOG_LEVEL")
}
if originalPort != "" {
os.Setenv("PORT", originalPort)
} else {
os.Unsetenv("PORT")
}
if originalEnv != "" {
os.Setenv("ENVIRONMENT", originalEnv)
} else {
os.Unsetenv("ENVIRONMENT")
}
if originalDB != "" {
os.Setenv("DATABASE_URL", originalDB)
} else {
os.Unsetenv("DATABASE_URL")
}
if originalQuoted != "" {
os.Setenv("QUOTED_VALUE", originalQuoted)
} else {
os.Unsetenv("QUOTED_VALUE")
}
}
func TestEnvVariablesPrecedence(t *testing.T) {
// Test, dass bereits gesetzte Umgebungsvariablen Vorrang haben
envContent := `DEBUG=false
LOG_LEVEL=ERROR`
// Temporäre .env-Datei erstellen
err := os.WriteFile(".env.precedence", []byte(envContent), 0644)
if err != nil {
t.Fatalf("Fehler beim Erstellen der Test-.env-Datei: %v", err)
}
defer os.Remove(".env.precedence")
// Umgebungsvariable vorher setzen
os.Setenv("DEBUG", "true")
os.Setenv("LOG_LEVEL", "INFO")
// .env-Datei laden
loadEnvFileContent(".env.precedence")
// Tests - bereits gesetzte Werte sollten nicht überschrieben werden
if debug := os.Getenv("DEBUG"); debug != "true" {
t.Errorf("DEBUG sollte 'true' bleiben, aber ist '%s'", debug)
}
if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "INFO" {
t.Errorf("LOG_LEVEL sollte 'INFO' bleiben, aber ist '%s'", logLevel)
}
// Cleanup
os.Unsetenv("DEBUG")
os.Unsetenv("LOG_LEVEL")
}
func TestLoadConfigWithEnvFile(t *testing.T) {
// Test-Konfiguration mit .env-Datei
envContent := `ENVIRONMENT=development
DEBUG=true
LOG_LEVEL=DEBUG
PORT=7777
DATABASE_URL=test://localhost/testdb`
// Temporäre .env-Datei erstellen
err := os.WriteFile(".env", []byte(envContent), 0644)
if err != nil {
t.Fatalf("Fehler beim Erstellen der .env-Datei: %v", err)
}
defer os.Remove(".env")
// Alle relevanten Umgebungsvariablen zurücksetzen
originalVars := map[string]string{
"ENVIRONMENT": os.Getenv("ENVIRONMENT"),
"DEBUG": os.Getenv("DEBUG"),
"LOG_LEVEL": os.Getenv("LOG_LEVEL"),
"PORT": os.Getenv("PORT"),
"DATABASE_URL": os.Getenv("DATABASE_URL"),
}
for key := range originalVars {
os.Unsetenv(key)
}
// Konfiguration laden
config := LoadConfig()
// Tests
if config.Environment != "development" {
t.Errorf("Environment: erwartet 'development', erhalten '%s'", config.Environment)
}
if !config.DebugMode {
t.Error("DebugMode sollte true sein")
}
if config.LogLevel != "DEBUG" {
t.Errorf("LogLevel: erwartet 'DEBUG', erhalten '%s'", config.LogLevel)
}
if config.ServerPort != "7777" {
t.Errorf("ServerPort: erwartet '7777', erhalten '%s'", config.ServerPort)
}
if config.DatabaseURL != "test://localhost/testdb" {
t.Errorf("DatabaseURL: erwartet 'test://localhost/testdb', erhalten '%s'", config.DatabaseURL)
}
// Ursprüngliche Werte wiederherstellen
for key, value := range originalVars {
if value != "" {
os.Setenv(key, value)
} else {
os.Unsetenv(key)
}
}
}
backend/demo_env.sh
Executable
+52
View File
@@ -0,0 +1,52 @@
#!/bin/bash
echo "=== Bamort .env Konfiguration Demo ==="
echo ""
# Erstelle verschiedene .env-Dateien für Demo
echo "# Development .env" > .env.dev.demo
echo "ENVIRONMENT=development" >> .env.dev.demo
echo "DEBUG=true" >> .env.dev.demo
echo "LOG_LEVEL=DEBUG" >> .env.dev.demo
echo "PORT=8180" >> .env.dev.demo
echo "" >> .env.dev.demo
echo "# Production .env" > .env.prod.demo
echo "ENVIRONMENT=production" >> .env.prod.demo
echo "DEBUG=false" >> .env.prod.demo
echo "LOG_LEVEL=INFO" >> .env.prod.demo
echo "PORT=8080" >> .env.prod.demo
echo "" >> .env.prod.demo
echo "1. Development-Konfiguration (.env.dev.demo):"
cat .env.dev.demo
echo ""
echo "2. Production-Konfiguration (.env.prod.demo):"
cat .env.prod.demo
echo ""
echo "3. Test mit Development-Konfiguration:"
cp .env.dev.demo .env
echo "Building and testing with development config..."
go run cmd/logging_demo.go 2>/dev/null | head -10
echo ""
echo "4. Test mit Production-Konfiguration:"
cp .env.prod.demo .env
echo "Building and testing with production config..."
go run cmd/logging_demo.go 2>/dev/null | head -10
echo ""
echo "5. Test mit Umgebungsvariablen-Override:"
echo "Setze DEBUG=false als Umgebungsvariable (sollte .env überschreiben)"
DEBUG=false go run cmd/logging_demo.go 2>/dev/null | head -10
echo ""
# Cleanup
rm -f .env.dev.demo .env.prod.demo
echo "=== Demo beendet ==="
echo ""
echo "Tipp: Kopiere .env.example nach .env und passe sie an deine Bedürfnisse an:"
echo "cp .env.example .env"
backend/logger/logger.go
+156
View File
@@ -0,0 +1,156 @@
package logger
import (
"fmt"
"log"
"os"
"strings"
"time"
)
// LogLevel definiert die verschiedenen Log-Level
type LogLevel int
const (
DEBUG LogLevel = iota
INFO
WARN
ERROR
)
// String gibt eine String-Repräsentation des Log-Levels zurück
func (l LogLevel) String() string {
switch l {
case DEBUG:
return "DEBUG"
case INFO:
return "INFO"
case WARN:
return "WARN"
case ERROR:
return "ERROR"
default:
return "UNKNOWN"
}
}
// Logger struct enthält die Konfiguration
type Logger struct {
debugEnabled bool
minLevel LogLevel
logger *log.Logger
}
// Globaler Logger
var defaultLogger *Logger
// init initialisiert den Standard-Logger
func init() {
defaultLogger = &Logger{
debugEnabled: getDebugModeFromEnv(),
minLevel: getMinLogLevelFromEnv(),
logger: log.New(os.Stdout, "", 0), // Kein Standard-Prefix, wir verwenden unseren eigenen
}
}
// getDebugModeFromEnv liest den Debug-Modus aus Umgebungsvariablen
func getDebugModeFromEnv() bool {
debugMode := os.Getenv("DEBUG")
return strings.ToLower(debugMode) == "true" || debugMode == "1"
}
// getMinLogLevelFromEnv liest das minimale Log-Level aus Umgebungsvariablen
func getMinLogLevelFromEnv() LogLevel {
levelStr := strings.ToUpper(os.Getenv("LOG_LEVEL"))
switch levelStr {
case "DEBUG":
return DEBUG
case "INFO":
return INFO
case "WARN":
return WARN
case "ERROR":
return ERROR
default:
if getDebugModeFromEnv() {
return DEBUG
}
return INFO
}
}
// SetDebugMode aktiviert oder deaktiviert den Debug-Modus
func SetDebugMode(enabled bool) {
defaultLogger.debugEnabled = enabled
if enabled && defaultLogger.minLevel > DEBUG {
defaultLogger.minLevel = DEBUG
}
}
// SetMinLogLevel setzt das minimale Log-Level
func SetMinLogLevel(level LogLevel) {
defaultLogger.minLevel = level
}
// IsDebugEnabled gibt zurück, ob der Debug-Modus aktiviert ist
func IsDebugEnabled() bool {
return defaultLogger.debugEnabled && defaultLogger.minLevel <= DEBUG
}
// logMessage ist die interne Funktion zum Loggen von Nachrichten
func logMessage(level LogLevel, format string, args ...interface{}) {
if level < defaultLogger.minLevel {
return
}
// Für Debug-Messages zusätzlich prüfen, ob Debug-Modus aktiviert ist
if level == DEBUG && !defaultLogger.debugEnabled {
return
}
timestamp := time.Now().Format("2006-01-02 15:04:05")
message := fmt.Sprintf(format, args...)
logLine := fmt.Sprintf("[%s] %s: %s", timestamp, level.String(), message)
defaultLogger.logger.Println(logLine)
}
// Debug loggt Debug-Nachrichten (nur wenn Debug-Modus aktiviert)
func Debug(format string, args ...interface{}) {
logMessage(DEBUG, format, args...)
}
// Info loggt Info-Nachrichten
func Info(format string, args ...interface{}) {
logMessage(INFO, format, args...)
}
// Warn loggt Warn-Nachrichten
func Warn(format string, args ...interface{}) {
logMessage(WARN, format, args...)
}
// Error loggt Error-Nachrichten
func Error(format string, args ...interface{}) {
logMessage(ERROR, format, args...)
}
// Debugf ist ein Alias für Debug (für Kompatibilität)
func Debugf(format string, args ...interface{}) {
Debug(format, args...)
}
// Infof ist ein Alias für Info (für Kompatibilität)
func Infof(format string, args ...interface{}) {
Info(format, args...)
}
// Warnf ist ein Alias für Warn (für Kompatibilität)
func Warnf(format string, args ...interface{}) {
Warn(format, args...)
}
// Errorf ist ein Alias für Error (für Kompatibilität)
func Errorf(format string, args ...interface{}) {
Error(format, args...)
}
backend/logger/logger_test.go
+123
View File
@@ -0,0 +1,123 @@
package logger
import (
"os"
"testing"
)
func TestLogLevels(t *testing.T) {
// Test String-Representation der Log-Levels
tests := []struct {
level LogLevel
expected string
}{
{DEBUG, "DEBUG"},
{INFO, "INFO"},
{WARN, "WARN"},
{ERROR, "ERROR"},
}
for _, test := range tests {
if test.level.String() != test.expected {
t.Errorf("Expected %s, got %s", test.expected, test.level.String())
}
}
}
func TestDebugModeFromEnv(t *testing.T) {
// Test verschiedene Umgebungsvariablen-Werte
tests := []struct {
envValue string
expected bool
}{
{"true", true},
{"TRUE", true},
{"True", true},
{"1", true},
{"false", false},
{"FALSE", false},
{"False", false},
{"0", false},
{"", false},
{"invalid", false},
}
for _, test := range tests {
os.Setenv("DEBUG", test.envValue)
result := getDebugModeFromEnv()
if result != test.expected {
t.Errorf("For DEBUG=%s, expected %v, got %v", test.envValue, test.expected, result)
}
}
// Cleanup
os.Unsetenv("DEBUG")
}
func TestMinLogLevelFromEnv(t *testing.T) {
// Test verschiedene LOG_LEVEL Werte
tests := []struct {
envValue string
expected LogLevel
}{
{"DEBUG", DEBUG},
{"debug", DEBUG},
{"INFO", INFO},
{"info", INFO},
{"WARN", WARN},
{"warn", WARN},
{"ERROR", ERROR},
{"error", ERROR},
{"invalid", INFO}, // Default zu INFO
{"", INFO}, // Default zu INFO
}
// DEBUG-Modus deaktivieren für diese Tests
os.Setenv("DEBUG", "false")
for _, test := range tests {
os.Setenv("LOG_LEVEL", test.envValue)
result := getMinLogLevelFromEnv()
if result != test.expected {
t.Errorf("For LOG_LEVEL=%s, expected %v, got %v", test.envValue, test.expected, result)
}
}
// Test: Wenn DEBUG=true und kein LOG_LEVEL gesetzt, sollte DEBUG returned werden
os.Setenv("DEBUG", "true")
os.Unsetenv("LOG_LEVEL")
result := getMinLogLevelFromEnv()
if result != DEBUG {
t.Errorf("When DEBUG=true and no LOG_LEVEL set, expected DEBUG, got %v", result)
}
// Cleanup
os.Unsetenv("DEBUG")
os.Unsetenv("LOG_LEVEL")
}
func TestSetDebugMode(t *testing.T) {
// Test Debug-Modus aktivieren
SetDebugMode(true)
if !IsDebugEnabled() {
t.Error("Debug mode should be enabled")
}
// Test Debug-Modus deaktivieren
SetDebugMode(false)
if IsDebugEnabled() {
t.Error("Debug mode should be disabled")
}
}
func TestSetMinLogLevel(t *testing.T) {
// Test verschiedene Log-Level setzen
levels := []LogLevel{DEBUG, INFO, WARN, ERROR}
for _, level := range levels {
SetMinLogLevel(level)
if defaultLogger.minLevel != level {
t.Errorf("Expected min log level %v, got %v", level, defaultLogger.minLevel)
}
}
}