refactor: refactor logging system for improved stack trace handling

- Remove unused imports `path/filepath` and `runtime` from `logger.go`
- Remove `Infof` method from `defaultLogger` and re-add it at the end of the file
- Replace `runtime.Caller` and `filepath.Base` with `stack` function for logging stack traces
- Simplify `Errorf` and `Error` methods to use `Printf` and `Println` directly
- Remove calls to `os.Exit(1)` in `Fatalf` and `Fatal` methods
- Add a new file `recovery.go` with utility functions for stack trace handling and a buffer pool for performance optimization

Signed-off-by: Bo-Yi Wu <[email protected]>

Author: appleboy

logger.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"path/filepath"
-	"runtime"
 )
 
 // Logger interface is used throughout gorush
@@ -33,50 +31,38 @@ type defaultLogger struct {
 	fatalLogger *log.Logger
 }
 
-func (l defaultLogger) Infof(format string, args ...interface{}) {
-	l.infoLogger.Printf(format, args...)
-}
-
 func (l defaultLogger) logWithCallerf(logger *log.Logger, format string, args ...interface{}) {
-	_, file, line, ok := runtime.Caller(2)
-	if ok {
-		shortFile := filepath.Base(file)
-		logger.Printf("%s:%d: %s", shortFile, line, fmt.Sprintf(format, args...))
-		return
-	}
-	logger.Printf(format, args...)
+	stack := stack(3)
+	logger.Printf("%s\n%s", stack, fmt.Sprintf(format, args...))
 }
 
 func (l defaultLogger) logWithCaller(logger *log.Logger, args ...interface{}) {
-	_, file, line, ok := runtime.Caller(2)
-	if ok {
-		shortFile := filepath.Base(file)
-		logger.Printf("%s:%d: %s", shortFile, line, fmt.Sprint(args...))
-		return
-	}
-	logger.Println(fmt.Sprint(args...))
+	stack := stack(3)
+	logger.Println(stack, fmt.Sprint(args...))
+}
+
+func (l defaultLogger) Infof(format string, args ...interface{}) {
+	l.infoLogger.Printf(format, args...)
 }
 
 func (l defaultLogger) Errorf(format string, args ...interface{}) {
-	l.logWithCallerf(l.errorLogger, format, args...)
+	l.errorLogger.Printf(format, args...)
 }
 
 func (l defaultLogger) Fatalf(format string, args ...interface{}) {
 	l.logWithCallerf(l.fatalLogger, format, args...)
-	os.Exit(1)
 }
 
 func (l defaultLogger) Info(args ...interface{}) {
 	l.infoLogger.Println(fmt.Sprint(args...))
 }
 
 func (l defaultLogger) Error(args ...interface{}) {
-	l.logWithCaller(l.errorLogger, args...)
+	l.errorLogger.Println(fmt.Sprint(args...))
 }
 
 func (l defaultLogger) Fatal(args ...interface{}) {
 	l.logWithCaller(l.fatalLogger, args...)
-	os.Exit(1)
 }
 
 // NewEmptyLogger for simple logger.

recovery.go

@@ -0,0 +1,104 @@
+package queue
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+)
+
+const (
+	dunno     = "???"
+	centerDot = "·"
+	dot       = "."
+	slash     = "/"
+)
+
+// bufferPool is a pool of byte buffers that can be reused to reduce the number
+// of allocations and improve performance. It uses sync.Pool to manage a pool
+// of reusable *bytes.Buffer objects. When a buffer is requested from the pool,
+// if one is available, it is returned; otherwise, a new buffer is created.
+// When a buffer is no longer needed, it should be put back into the pool to be
+// reused.
+var bufferPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
+}
+
+// stack captures and returns the current stack trace, skipping the specified number of frames.
+// It retrieves the stack trace information, including the file name, line number, and function name,
+// and formats it into a byte slice. The function uses a buffer pool to manage memory efficiently.
+//
+// Parameters:
+//   - skip: The number of stack frames to skip before recording the trace.
+//
+// Returns:
+//   - A byte slice containing the formatted stack trace.
+func stack(skip int) []byte {
+	buf := bufferPool.Get().(*bytes.Buffer)
+	defer bufferPool.Put(buf)
+	buf.Reset()
+
+	var lines [][]byte
+	var lastFile string
+	for i := skip; ; i++ {
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
+		if file != lastFile {
+			data, err := os.ReadFile(file)
+			if err != nil {
+				continue
+			}
+			lines = bytes.Split(data, []byte{'\n'})
+			lastFile = file
+		}
+		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
+	}
+	return buf.Bytes()
+}
+
+// source retrieves the n-th line from the provided slice of byte slices,
+// trims any leading and trailing whitespace, and returns it as a byte slice.
+// If n is out of range, it returns a default "dunno" byte slice.
+//
+// Parameters:
+//
+//	lines - a slice of byte slices representing lines of text
+//	n - the 1-based index of the line to retrieve
+//
+// Returns:
+//
+//	A byte slice containing the trimmed n-th line, or a default "dunno" byte slice if n is out of range.
+func source(lines [][]byte, n int) []byte {
+	n--
+	if n < 0 || n >= len(lines) {
+		return []byte(dunno)
+	}
+	return bytes.TrimSpace(lines[n])
+}
+
+// function takes a program counter (pc) value and returns the name of the function
+// corresponding to that program counter as a byte slice. It uses runtime.FuncForPC
+// to retrieve the function information and processes the function name to remove
+// any path and package information, returning only the base function name.
+func function(pc uintptr) []byte {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return []byte(dunno)
+	}
+	name := fn.Name()
+	if lastSlash := strings.LastIndex(name, slash); lastSlash >= 0 {
+		name = name[lastSlash+1:]
+	}
+	if period := strings.Index(name, dot); period >= 0 {
+		name = name[period+1:]
+	}
+	name = strings.ReplaceAll(name, centerDot, dot)
+	return []byte(name)
+}