Added Level type - A custom int type with constants DEBUG, INFO, WARNING, ERROR in increasing severity order.

Added `minLevel` field to Logger struct to track the minimum level threshold.
Added `SetLevel()` and `GetLevel()` methods for dynamically changing/reading the log level at runtime.

core.go

@@ -293,7 +293,6 @@ func (app *App) makeHTTPRouterHandlerFunc(h Controller, ms []Hook) httprouter.Ha
 		for _, header := range ctx.Response.headers {
 			w.Header().Add(header.key, header.val)
 		}
-		logger.CloseLogsFile()
 		var ct string
 		if ctx.Response.overrideContentType != "" {
 			ct = ctx.Response.overrideContentType
@@ -334,7 +333,7 @@ func (n notFoundHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusNotFound)
 	res := "{\"message\": \"Not Found\"}"
 	loggr.Error("Not Found")
-	loggr.Error(debug.Stack())
+	//loggr.Error(debug.Stack())
 	w.Header().Add(CONTENT_TYPE, CONTENT_TYPE_JSON)
 	w.Write([]byte(res))
 }
@@ -344,7 +343,7 @@ func (n methodNotAllowed) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusMethodNotAllowed)
 	res := "{\"message\": \"Method not allowed\"}"
 	loggr.Error("Method not allowed")
-	loggr.Error(debug.Stack())
+	//loggr.Error(debug.Stack())
 	w.Header().Add(CONTENT_TYPE, CONTENT_TYPE_JSON)
 	w.Write([]byte(res))
 }
@@ -372,7 +371,7 @@ var panicHandler = func(w http.ResponseWriter, r *http.Request, e interface{}) {
 	shrtMsg := fmt.Sprintf("%v", e)
 	loggr.Error(shrtMsg)
 	fmt.Println(shrtMsg)
-	loggr.Error(string(debug.Stack()))
+	//loggr.Error(string(debug.Stack()))
 	var res string
 	if env.GetVarOtherwiseDefault("APP_ENV", "local") == PRODUCTION {
 		res = "{\"message\": \"internal error\"}"

logger/logger.go

@@ -1,4 +1,4 @@
-// Copyright 2021 Harran Ali <harran.m@gmail.com>. All rights reserved.
+// Copyright (c) 2026 Zeni Kim <zenik@smarteching.com>
 // Use of this source code is governed by MIT-style
 // license that can be found in the LICENSE file.
 
@@ -8,16 +8,68 @@ import (
 	"io"
 	"log"
 	"os"
+	"strings"
 )
 
 // logs file
 var logsFile *os.File
 
+// ANSI color codes for terminal output
+const (
+	colorReset  = "\033[0m"
+	colorRed    = "\033[31m"
+	colorYellow = "\033[33m"
+	colorBlue   = "\033[34m"
+	colorCyan   = "\033[36m"
+)
+
+// Level represents a log severity level.
+type Level int
+
+const (
+	DEBUG Level = iota
+	INFO
+	WARNING
+	ERROR
+)
+
+// String returns the string representation of a log level.
+func (l Level) String() string {
+	switch l {
+	case DEBUG:
+		return "debug"
+	case INFO:
+		return "info"
+	case WARNING:
+		return "warning"
+	case ERROR:
+		return "error"
+	default:
+		return "unknown"
+	}
+}
+
+// coloredWriter wraps an io.Writer and replaces plain log prefixes with ANSI-colored ones
+// in the output stream. The original bytes pass through unmodified to any additional writers.
+type coloredWriter struct {
+	writer  io.Writer
+	plain   string
+	colored string
+}
+
+func (w *coloredWriter) Write(p []byte) (n int, err error) {
+	// Replace the plain prefix with the colored version in the output
+	colored := strings.Replace(string(p), w.plain, w.colored, 1)
+	return w.writer.Write([]byte(colored))
+}
+
 type Logger struct {
+	minLevel      Level
 	infoLogger    *log.Logger
 	warningLogger *log.Logger
 	errorLogger   *log.Logger
 	debugLogger   *log.Logger
+	file          *os.File
 }
 
 var l *Logger
@@ -40,9 +92,36 @@ func (f LogFileDriver) GetTarget() interface{} {
 	return f.FilePath
 }
 
+// levelPrefixes returns the plain and colored (with ANSI escapes) prefix strings for a given level.
+func levelPrefixes(level Level) (plain, colored string) {
+	switch level {
+	case INFO:
+		return "info: ", colorBlue + "INFO" + colorReset + ": "
+	case DEBUG:
+		return "debug: ", colorCyan + "DEBUG" + colorReset + ": "
+	case WARNING:
+		return "warning: ", colorYellow + "WARNING" + colorReset + ": "
+	case ERROR:
+		return "error: ", colorRed + "ERROR" + colorReset + ": "
+	default:
+		return "info: ", "INFO: "
+	}
+}
+
+// NewLogger creates a new Logger with the given driver and a minimum level of DEBUG (all levels logged).
 func NewLogger(driver LogsDriver) *Logger {
+	stdoutEnabled := os.Getenv("LOG_STDOUT_ENABLE") == "true"
+	return NewLoggerWithStdout(driver, DEBUG, stdoutEnabled)
+}
+
+// NewLoggerWithStdout creates a new Logger with the given driver, minimum log level,
+// and optionally writes to stdout in addition to the target file.
+// When stdoutEnabled is true, log messages are written to both the target and stdout.
+// ANSI color codes are applied to log prefixes in terminal output only.
+func NewLoggerWithStdout(driver LogsDriver, minLevel Level, stdoutEnabled bool) *Logger {
 	if driver.GetTarget() == nil {
 		l = &Logger{
+			minLevel:      minLevel,
 			infoLogger:    log.New(io.Discard, "info: ", log.LstdFlags),
 			warningLogger: log.New(io.Discard, "warning: ", log.LstdFlags),
 			errorLogger:   log.New(io.Discard, "error: ", log.LstdFlags),
@@ -54,41 +133,103 @@ func NewLogger(driver LogsDriver) *Logger {
 	if !ok {
 		panic("something wrong with the file path")
 	}
-	logsFile, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0644)
+	var err error
+	logsFile, err = os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0644)
 	if err != nil {
 		panic(err)
 	}
+
+	if stdoutEnabled {
+		// Build each logger with a MultiWriter: the file gets the original plain output,
+		// stdout gets the output with ANSI-colored prefixes.
+		infoPlain, infoColored := levelPrefixes(INFO)
+		debugPlain, debugColored := levelPrefixes(DEBUG)
+		warnPlain, warnColored := levelPrefixes(WARNING)
+		errPlain, errColored := levelPrefixes(ERROR)
+
 		l = &Logger{
+			minLevel: minLevel,
+			infoLogger: log.New(
+				io.MultiWriter(logsFile, &coloredWriter{writer: os.Stdout, plain: infoPlain, colored: infoColored}),
+				infoPlain, log.LstdFlags,
+			),
+			warningLogger: log.New(
+				io.MultiWriter(logsFile, &coloredWriter{writer: os.Stdout, plain: warnPlain, colored: warnColored}),
+				warnPlain, log.LstdFlags,
+			),
+			errorLogger: log.New(
+				io.MultiWriter(logsFile, &coloredWriter{writer: os.Stdout, plain: errPlain, colored: errColored}),
+				errPlain, log.LstdFlags,
+			),
+			debugLogger: log.New(
+				io.MultiWriter(logsFile, &coloredWriter{writer: os.Stdout, plain: debugPlain, colored: debugColored}),
+				debugPlain, log.LstdFlags,
+			),
+			file: logsFile,
+		}
+	} else {
+		// No stdout: all output goes to file with plain prefixes
+		l = &Logger{
+			minLevel:      minLevel,
 			infoLogger:    log.New(logsFile, "info: ", log.LstdFlags),
 			warningLogger: log.New(logsFile, "warning: ", log.LstdFlags),
 			errorLogger:   log.New(logsFile, "error: ", log.LstdFlags),
 			debugLogger:   log.New(logsFile, "debug: ", log.LstdFlags),
+			file:          logsFile,
+		}
 	}
 	return l
 }
 
+// NewLoggerWithLevel creates a new Logger with the given driver and minimum log level.
+// Messages below the minimum level will be discarded. Stdout output is disabled by default.
+func NewLoggerWithLevel(driver LogsDriver, minLevel Level) *Logger {
+	stdoutEnabled := os.Getenv("LOG_STDOUT_ENABLE") == "true"
+	return NewLoggerWithStdout(driver, minLevel, stdoutEnabled)
+}
+
+// SetLevel sets the minimum log level for the logger.
+// Messages below this level will be discarded.
+func (l *Logger) SetLevel(level Level) {
+	l.minLevel = level
+}
+
+// GetLevel returns the current minimum log level.
+func (l *Logger) GetLevel() Level {
+	return l.minLevel
+}
+
 func ResolveLogger() *Logger {
 	return l
 }
 
 func (l *Logger) Info(msg interface{}) {
+	if l.minLevel <= INFO {
 		l.infoLogger.Println(msg)
 	}
+}
 
 func (l *Logger) Debug(msg interface{}) {
+	if l.minLevel <= DEBUG {
 		l.debugLogger.Println(msg)
 	}
+}
 
 func (l *Logger) Warning(msg interface{}) {
+	if l.minLevel <= WARNING {
 		l.warningLogger.Println(msg)
 	}
+}
 
 func (l *Logger) Error(msg interface{}) {
+	if l.minLevel <= ERROR {
 		l.errorLogger.Println(msg)
 	}
+}
 
-func CloseLogsFile() {
+func (l *Logger) Close() error {
-	if logsFile != nil {
+	if l.file != nil {
-		defer logsFile.Close()
+		return l.file.Close()
 	}
+	return nil
 }

logger/logger_test.go

@@ -61,7 +61,7 @@ func TestInfo(t *testing.T) {
 		t.Error("error testing info")
 	}
 	t.Cleanup(func() {
-		CloseLogsFile()
+		l.Close()
 	})
 }
 
@@ -84,7 +84,7 @@ func TestWarning(t *testing.T) {
 		t.Error("failed testing warning")
 	}
 	t.Cleanup(func() {
-		CloseLogsFile()
+		l.Close()
 	})
 }
 
@@ -106,7 +106,7 @@ func TestDebug(t *testing.T) {
 		t.Error("error testing debug")
 	}
 	t.Cleanup(func() {
-		CloseLogsFile()
+		l.Close()
 	})
 }
 
@@ -128,6 +128,173 @@ func TestError(t *testing.T) {
 		t.Error("failed testing error")
 	}
 	t.Cleanup(func() {
-		CloseLogsFile()
+		l.Close()
 	})
 }
+
+func TestLevelFiltering(t *testing.T) {
+	t.Run("NewLoggerWithLevel_DEBUG", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), uuid.NewString())
+		l := NewLoggerWithLevel(&LogFileDriver{FilePath: path}, DEBUG)
+		l.Debug("debug-msg")
+		l.Info("info-msg")
+		l.Warning("warn-msg")
+		l.Error("err-msg")
+		l.Close()
+
+		b, _ := os.ReadFile(path)
+		content := string(b)
+		if !strings.Contains(content, "debug-msg") {
+			t.Error("expected debug-msg to be logged at DEBUG level")
+		}
+		if !strings.Contains(content, "info-msg") {
+			t.Error("expected info-msg to be logged at DEBUG level")
+		}
+		if !strings.Contains(content, "warn-msg") {
+			t.Error("expected warn-msg to be logged at DEBUG level")
+		}
+		if !strings.Contains(content, "err-msg") {
+			t.Error("expected err-msg to be logged at DEBUG level")
+		}
+	})
+
+	t.Run("NewLoggerWithLevel_INFO", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), uuid.NewString())
+		l := NewLoggerWithLevel(&LogFileDriver{FilePath: path}, INFO)
+		l.Debug("debug-msg")
+		l.Info("info-msg")
+		l.Warning("warn-msg")
+		l.Error("err-msg")
+		l.Close()
+
+		b, _ := os.ReadFile(path)
+		content := string(b)
+		if strings.Contains(content, "debug-msg") {
+			t.Error("debug-msg should NOT be logged at INFO minimum level")
+		}
+		if !strings.Contains(content, "info-msg") {
+			t.Error("expected info-msg to be logged at INFO level")
+		}
+		if !strings.Contains(content, "warn-msg") {
+			t.Error("expected warn-msg to be logged at INFO level")
+		}
+		if !strings.Contains(content, "err-msg") {
+			t.Error("expected err-msg to be logged at INFO level")
+		}
+	})
+
+	t.Run("NewLoggerWithLevel_WARNING", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), uuid.NewString())
+		l := NewLoggerWithLevel(&LogFileDriver{FilePath: path}, WARNING)
+		l.Debug("debug-msg")
+		l.Info("info-msg")
+		l.Warning("warn-msg")
+		l.Error("err-msg")
+		l.Close()
+
+		b, _ := os.ReadFile(path)
+		content := string(b)
+		if strings.Contains(content, "debug-msg") {
+			t.Error("debug-msg should NOT be logged at WARNING minimum level")
+		}
+		if strings.Contains(content, "info-msg") {
+			t.Error("info-msg should NOT be logged at WARNING minimum level")
+		}
+		if !strings.Contains(content, "warn-msg") {
+			t.Error("expected warn-msg to be logged at WARNING level")
+		}
+		if !strings.Contains(content, "err-msg") {
+			t.Error("expected err-msg to be logged at WARNING level")
+		}
+	})
+
+	t.Run("NewLoggerWithLevel_ERROR", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), uuid.NewString())
+		l := NewLoggerWithLevel(&LogFileDriver{FilePath: path}, ERROR)
+		l.Debug("debug-msg")
+		l.Info("info-msg")
+		l.Warning("warn-msg")
+		l.Error("err-msg")
+		l.Close()
+
+		b, _ := os.ReadFile(path)
+		content := string(b)
+		if strings.Contains(content, "debug-msg") {
+			t.Error("debug-msg should NOT be logged at ERROR minimum level")
+		}
+		if strings.Contains(content, "info-msg") {
+			t.Error("info-msg should NOT be logged at ERROR minimum level")
+		}
+		if strings.Contains(content, "warn-msg") {
+			t.Error("warn-msg should NOT be logged at ERROR minimum level")
+		}
+		if !strings.Contains(content, "err-msg") {
+			t.Error("expected err-msg to be logged at ERROR level")
+		}
+	})
+
+	t.Run("SetLevel_dynamically", func(t *testing.T) {
+		path := filepath.Join(t.TempDir(), uuid.NewString())
+		l := NewLogger(&LogFileDriver{FilePath: path})
+
+		// Default is DEBUG, so debug messages are logged
+		l.Debug("debug-msg-before")
+		l.SetLevel(WARNING)
+		l.Debug("debug-msg-after")
+		l.Info("info-msg-after")
+		l.Warning("warn-msg-after")
+		l.Error("err-msg-after")
+		l.Close()
+
+		b, _ := os.ReadFile(path)
+		content := string(b)
+		if !strings.Contains(content, "debug-msg-before") {
+			t.Error("expected debug-msg-before to be logged before level change")
+		}
+		if strings.Contains(content, "debug-msg-after") {
+			t.Error("debug-msg-after should NOT be logged after setting level to WARNING")
+		}
+		if strings.Contains(content, "info-msg-after") {
+			t.Error("info-msg-after should NOT be logged after setting level to WARNING")
+		}
+		if !strings.Contains(content, "warn-msg-after") {
+			t.Error("expected warn-msg-after to be logged at WARNING level")
+		}
+		if !strings.Contains(content, "err-msg-after") {
+			t.Error("expected err-msg-after to be logged at WARNING level")
+		}
+	})
+}
+
+func TestLevelString(t *testing.T) {
+	tests := []struct {
+		level Level
+		want  string
+	}{
+		{DEBUG, "debug"},
+		{INFO, "info"},
+		{WARNING, "warning"},
+		{ERROR, "error"},
+		{Level(99), "unknown"},
+	}
+	for _, tt := range tests {
+		if got := tt.level.String(); got != tt.want {
+			t.Errorf("Level(%d).String() = %q, want %q", tt.level, got, tt.want)
+		}
+	}
+}
+
+func TestGetLevel(t *testing.T) {
+	path := filepath.Join(t.TempDir(), uuid.NewString())
+	l := NewLoggerWithLevel(&LogFileDriver{FilePath: path}, WARNING)
+	defer l.Close()
+
+	if l.GetLevel() != WARNING {
+		t.Errorf("GetLevel() = %d, want %d", l.GetLevel(), WARNING)
+	}
+
+	l.SetLevel(INFO)
+	if l.GetLevel() != INFO {
+		t.Errorf("GetLevel() after SetLevel(INFO) = %d, want %d", l.GetLevel(), INFO)
+	}
+}