refactor(gs): supports multiple log file formats

Author: lvan100

conf/bind.go

@@ -27,8 +27,8 @@ import (
 )
 
 var (
-	ErrNotExist      = errors.New("not exist")
-	ErrInvalidSyntax = errors.New("invalid syntax")
+	ErrNotExist      = util.FormatError(nil, "not exist")
+	ErrInvalidSyntax = util.FormatError(nil, "invalid syntax")
 )
 
 // ParsedTag represents a parsed configuration tag that encodes

gs/app.go

@@ -65,7 +65,7 @@ func (s *AppStarter) stopApp() {
 
 // Run starts the application, optionally runs a user-defined callback,
 // and waits for termination signals (e.g., SIGTERM, Ctrl+C) to trigger graceful shutdown.
-func (s *AppStarter) Run(fn ...func(ctx context.Context) error) {
+func (s *AppStarter) Run(fn ...func() error) {
 
 	// Start application
 	if err := s.startApp(); err != nil {
@@ -76,7 +76,7 @@ func (s *AppStarter) Run(fn ...func(ctx context.Context) error) {
 
 	// Execute user-provided callback after app starts
 	if len(fn) > 0 && fn[0] != nil {
-		if err := fn[0](app.Ctx); err != nil {
+		if err := fn[0](); err != nil {
 			err = util.WrapError(err, "start app failed")
 			log.Errorf(context.Background(), log.TagAppDef, "%s", err)
 			return

gs/gs.go

@@ -280,7 +280,7 @@ func Web(enable bool) *AppStarter {
 }
 
 // Run starts the application with a custom run function.
-func Run(fn ...func(ctx context.Context) error) {
+func Run(fn ...func() error) {
 	new(AppStarter).Run(fn...)
 }
 

gs/internal/gs_app/app.go

@@ -39,7 +39,7 @@ type App struct {
 	P *gs_conf.AppConfig // Application configuration
 
 	exiting atomic.Bool        // Indicates whether the application is shutting down
-	Ctx     context.Context    // Root context for managing cancellation
+	ctx     context.Context    // Root context for managing cancellation
 	cancel  context.CancelFunc // Function to cancel the root context
 	wg      sync.WaitGroup     // WaitGroup to track running jobs and servers
 
@@ -57,7 +57,7 @@ func NewApp() *App {
 	return &App{
 		C:      gs_core.New(),
 		P:      gs_conf.NewAppConfig(),
-		Ctx:    ctx,
+		ctx:    ctx,
 		cancel: cancel,
 	}
 }
@@ -98,7 +98,7 @@ func (app *App) Start() error {
 	if app.EnableJobs {
 		for _, job := range app.Jobs {
 			app.wg.Add(1)
-			goutil.GoFunc(func() {
+			goutil.Go(app.ctx, func(ctx context.Context) {
 				defer app.wg.Done()
 				defer func() {
 					// Handle unexpected panics by shutting down the app
@@ -107,8 +107,8 @@ func (app *App) Start() error {
 						panic(r)
 					}
 				}()
-				if err := job.Run(app.Ctx); err != nil {
-					log.Errorf(context.Background(), log.TagAppDef, "job run error: %v", err)
+				if err := job.Run(ctx); err != nil {
+					log.Errorf(ctx, log.TagAppDef, "job run error: %v", err)
 					app.ShutDown()
 				}
 			})
@@ -121,7 +121,7 @@ func (app *App) Start() error {
 		for _, svr := range app.Servers {
 			sig.Add()
 			app.wg.Add(1)
-			goutil.GoFunc(func() {
+			goutil.Go(app.ctx, func(ctx context.Context) {
 				defer app.wg.Done()
 				defer func() {
 					// Handle server panics by intercepting readiness and shutting down
@@ -133,22 +133,22 @@ func (app *App) Start() error {
 				}()
 				err := svr.ListenAndServe(sig)
 				if err != nil && !errors.Is(err, http.ErrServerClosed) {
-					log.Errorf(context.Background(), log.TagAppDef, "server serve error: %v", err)
+					log.Errorf(ctx, log.TagAppDef, "server serve error: %v", err)
 					sig.Intercept()
 					app.ShutDown()
 				} else {
-					log.Infof(context.Background(), log.TagAppDef, "server closed")
+					log.Infof(ctx, log.TagAppDef, "server closed")
 				}
 			})
 		}
 
 		// Wait for all servers to be ready
 		sig.Wait()
 		if sig.Intercepted() {
-			log.Infof(context.Background(), log.TagAppDef, "server intercepted")
+			log.Infof(app.ctx, log.TagAppDef, "server intercepted")
 			return util.FormatError(nil, "server intercepted")
 		}
-		log.Infof(context.Background(), log.TagAppDef, "ready to serve requests")
+		log.Infof(app.ctx, log.TagAppDef, "ready to serve requests")
 		sig.Close()
 	}
 	return nil
@@ -158,19 +158,19 @@ func (app *App) Start() error {
 // and then gracefully stops all servers and jobs.
 func (app *App) WaitForShutdown() {
 	// Wait until the application context is cancelled (triggered by ShutDown)
-	<-app.Ctx.Done()
+	<-app.ctx.Done()
 
 	// Gracefully shut down all running servers
 	for _, svr := range app.Servers {
-		goutil.GoFunc(func() {
-			if err := svr.Shutdown(app.Ctx); err != nil {
-				log.Errorf(context.Background(), log.TagAppDef, "shutdown server failed: %v", err)
+		goutil.Go(app.ctx, func(ctx context.Context) {
+			if err := svr.Shutdown(context.Background()); err != nil {
+				log.Errorf(ctx, log.TagAppDef, "shutdown server failed: %v", err)
 			}
 		})
 	}
 	app.wg.Wait()
 	app.C.Close()
-	log.Infof(context.Background(), log.TagAppDef, "shutdown complete")
+	log.Infof(app.ctx, log.TagAppDef, "shutdown complete")
 }
 
 // Exiting returns whether the application is currently in the process of shutting down.
@@ -182,7 +182,7 @@ func (app *App) Exiting() bool {
 // setting the exiting flag and cancelling the root context.
 func (app *App) ShutDown() {
 	if app.exiting.CompareAndSwap(false, true) {
-		log.Infof(context.Background(), log.TagAppDef, "shutting down")
+		log.Infof(app.ctx, log.TagAppDef, "shutting down")
 		app.cancel()
 	}
 }

gs/internal/gs_app/app_test.go

@@ -22,7 +22,6 @@ import (
 	"errors"
 	"net/http"
 	"os"
-	"runtime/debug"
 	"testing"
 	"time"
 
@@ -38,8 +37,8 @@ import (
 var logBuf = &bytes.Buffer{}
 
 func init() {
-	goutil.OnPanic = func(ctx context.Context, r any) {
-		log.Panicf(ctx, log.TagAppDef, "panic: %v\n%s\n", r, debug.Stack())
+	goutil.OnPanic = func(ctx context.Context, r any, stack []byte) {
+		log.Panicf(ctx, log.TagAppDef, "panic: %v\n%s\n", r, stack)
 	}
 }
 

gs/log.go

@@ -28,54 +28,62 @@ import (
 // initLog initializes the application's logging system.
 func initLog() error {
 
-	// Refresh the global system configuration.
+	// Step 1: Refresh the global system configuration.
 	p, err := new(gs_conf.SysConfig).Refresh()
 	if err != nil {
 		return util.FormatError(err, "refresh error in source sys")
 	}
 
+	// Step 2: Load logging-related configuration parameters.
 	var c struct {
 		// LocalDir is the directory that contains configuration files.
 		// Defaults to "./conf" if not provided.
 		LocalDir string `value:"${spring.app.config-local.dir:=./conf}"`
 
 		// Profiles specifies the active application profile(s),
-		// such as "dev" or "prod".
+		// such as "dev", "prod", etc.
+		// Multiple profiles can be provided as a comma-separated list.
 		Profiles string `value:"${spring.profiles.active:=}"`
 	}
 	if err = p.Bind(&c); err != nil {
 		return util.FormatError(err, "bind error in source sys")
 	}
 
-	var (
-		logFileDefault = filepath.Join(c.LocalDir, "log.xml")
-		logFileProfile string
-	)
+	extensions := []string{".properties", ".yaml", ".yml", ".xml", ".json"}
 
-	// If one or more profiles are set, use the first profile to look
-	// for a profile-specific log configuration file.
-	if c.Profiles != "" {
-		profile := strings.Split(c.Profiles, ",")[0]
-		logFileProfile = filepath.Join(c.LocalDir, "log-"+profile+".xml")
+	// Step 3: Build a list of candidate configuration files.
+	var files []string
+	if profiles := strings.TrimSpace(c.Profiles); profiles != "" {
+		for s := range strings.SplitSeq(profiles, ",") { // NOTE: range returns index
+			if s = strings.TrimSpace(s); s != "" {
+				for _, ext := range extensions {
+					files = append(files, filepath.Join(c.LocalDir, "log-"+s+ext))
+				}
+			}
+		}
+	}
+	for _, ext := range extensions {
+		files = append(files, filepath.Join(c.LocalDir, "log"+ext))
 	}
 
-	// Determine which log configuration file to use.
-	var logFile string
-	for _, s := range []string{logFileProfile, logFileDefault} {
+	// Step 4: Detect existing configuration files.
+	var logFiles []string
+	for _, s := range files {
 		if ok, err := util.PathExists(s); err != nil {
 			return err
-		} else if !ok {
-			continue
+		} else if ok {
+			logFiles = append(logFiles, s)
 		}
-		logFile = s
-		break
 	}
 
-	// If no configuration file exists, leave the logger as default.
-	if logFile == "" {
+	// Step 5: Apply logging configuration or fall back to defaults.
+	switch n := len(logFiles); {
+	case n == 0:
+		log.Infof(nil, log.TagAppDef, "no log configuration file found, using default logger")
 		return nil
+	case n > 1:
+		return util.FormatError(nil, "multiple log files found: %s", logFiles)
+	default:
+		return log.RefreshFile(logFiles[0])
 	}
-
-	// Refresh the logger configuration from the selected file.
-	return log.RefreshFile(logFile)
 }