Fix: Logger and main package init fixes

cmd/HellPot/HellPot.go

@@ -8,7 +8,7 @@ import (
 
 func main() {
 	stopChan := make(chan os.Signal, 1)
-	log, _, resolvedConf, realConf, err := setup(stopChan)
+	log, resolvedConf, realConf, err := setup(stopChan)
 
 	if err != nil {
 		println("failed to start: " + err.Error())

cmd/HellPot/HellPot_test.go

@@ -10,14 +10,15 @@ import (
 
 	"github.com/yunginnanet/HellPot/internal/config"
 	"github.com/yunginnanet/HellPot/internal/http"
+	"github.com/yunginnanet/HellPot/internal/logger"
 )
 
-func testMain(t *testing.T) (string, string, chan os.Signal, *config.Parameters, error) {
+func testMain(t *testing.T) (string, chan os.Signal, *logger.Log, *config.Parameters, error) {
 	t.Setenv("HELLPOT_TEST_MODE", "true")
 	t.Helper()
 	stopChan := make(chan os.Signal, 1)
 
-	log, logFile, resolvedConf, realConfig, err := setup(stopChan)
+	log, resolvedConf, realConfig, err := setup(stopChan)
 	if err == nil {
 		printInfo(log, resolvedConf, realConfig)
 		go func() {
@@ -29,7 +30,7 @@ func testMain(t *testing.T) (string, string, chan os.Signal, *config.Parameters,
 		}()
 	}
 	//goland:noinspection GoNilness
-	return resolvedConf, logFile, stopChan, realConfig, err
+	return resolvedConf, stopChan, log, realConfig, err
 }
 
 func TestHellPot(t *testing.T) {
@@ -40,13 +41,24 @@ func TestHellPot(t *testing.T) {
 	}
 	confFile := filepath.Join(tDir, "HellPot_test.toml")
 	t.Setenv("HELLPOT_LOGGER_DIRECTORY", logDir)
-	t.Setenv("HELLPOT_LOGGER_RSYSLOG_ADDRESS", "local")
+	t.Setenv("HELLPOT_LOGGER_RSYSLOG__ADDRESS", "local")
+	t.Setenv("HELLPOT_LOGGER_DEBUG", "true")
 	t.Setenv("HELLPOT_CONFIG", confFile)
 
-	resolvedConf, logFile, stopChan, realConfig, err := testMain(t)
+	resolvedConf, stopChan, log, realConfig, err := testMain(t)
+
 	if err != nil {
 		t.Fatal(err)
 	}
+	if log == nil {
+		t.Fatal("log is nil")
+	}
+	if realConfig == nil {
+		t.Fatal("realConfig is nil")
+	}
+
+	logFile := log.Config.ActiveLogFileName
+
 	if stopChan == nil {
 		t.Fatal("stopChan is nil")
 	}
@@ -79,7 +91,7 @@ func TestHellPot(t *testing.T) {
 	if !strings.Contains(string(logDat), resolvedConf) {
 		t.Errorf("expected log to contain '%s'", resolvedConf)
 	}
-	if !strings.Contains(string(logDat), "PID: "+strconv.Itoa(os.Getpid())) {
+	if !strings.Contains(string(logDat), strconv.Itoa(os.Getpid())+",") {
 		t.Errorf("expected log to contain 'PID: %d', got %s", os.Getpid(), logDat)
 	}
 	t.Log("resolvedConf: ", resolvedConf)

cmd/HellPot/boot.go

@@ -11,8 +11,6 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/rs/zerolog"
-
 	"github.com/yunginnanet/HellPot/internal/config"
 	"github.com/yunginnanet/HellPot/internal/extra"
 	"github.com/yunginnanet/HellPot/internal/logger"
@@ -114,23 +112,64 @@ func readConfig(resolvedConf string) (*config.Parameters, error) {
 	return runningConfig, err
 }
 
+type configDetail struct {
+	runningConfig *config.Parameters
+	usingDefaults bool
+	resolvedConf  string
+}
+
+func loadCLIConfig() (detail configDetail, err error) {
+	conf := config.CLIFlags.Lookup("config")
+	detail = configDetail{}
+	detail.resolvedConf = conf.Value.String()
+	detail.runningConfig, err = readConfig(detail.resolvedConf)
+	detail.usingDefaults = false
+	return
+}
+
+func loadEnvConfig() (detail configDetail, err error) {
+	detail = configDetail{}
+	detail.resolvedConf = os.Getenv("HELLPOT_CONFIG_FILE")
+	detail.runningConfig, err = readConfig(detail.resolvedConf)
+	detail.usingDefaults = false
+	return
+}
+
 func resolveConfig() (runningConfig *config.Parameters, usingDefaults bool, resolvedConf string, err error) {
-	if config.CLIFlags != nil {
-		conf := config.CLIFlags.Lookup("config")
-		if conf != nil && conf.Value.String() != "" {
-			resolvedConf = conf.Value.String()
-			if runningConfig, err = readConfig(resolvedConf); err != nil {
-				return runningConfig, false, resolvedConf, err
-			}
-		}
+	var cliConfigPath string
+	if config.CLIFlags != nil && config.CLIFlags.Lookup("config") != nil {
+		cliConfigPath = config.CLIFlags.Lookup("config").Value.String()
 	}
 
-	if resolvedConf == "" && os.Getenv("HELLPOT_CONFIG_FILE") != "" {
-		resolvedConf = os.Getenv("HELLPOT_CONFIG_FILE")
-	}
+	var detail configDetail
 
-	if resolvedConf == "" {
-		resolvedConf = searchConfig()
+try:
+	switch {
+	case cliConfigPath != "":
+		detail, err = loadCLIConfig()
+		if err == nil {
+			runningConfig = detail.runningConfig
+			usingDefaults = detail.usingDefaults
+			resolvedConf = detail.resolvedConf
+			return
+		}
+		println("failed to load config from CLI path: " + err.Error())
+		cliConfigPath = ""
+		goto try
+	case os.Getenv("HELLPOT_CONFIG_FILE") != "":
+		detail, err = loadEnvConfig()
+		if err == nil {
+			runningConfig = detail.runningConfig
+			usingDefaults = detail.usingDefaults
+			resolvedConf = detail.resolvedConf
+			return
+		}
+		println("failed to load config from env path: " + err.Error())
+		fallthrough
+	default:
+		if resolvedConf = searchConfig(); resolvedConf != "" {
+			usingDefaults = false
+		}
 	}
 
 	if runningConfig, err = readConfig(resolvedConf); err != nil && !errors.Is(err, io.EOF) {
@@ -150,17 +189,15 @@ func resolveConfig() (runningConfig *config.Parameters, usingDefaults bool, reso
 	return runningConfig, false, resolvedConf, nil
 }
 
-func initLogger(runningConfig *config.Parameters) (log zerolog.Logger, logFile string, err error) {
+func initLogger(runningConfig *config.Parameters) (log *logger.Log, err error) {
 	if log, err = logger.New(&runningConfig.Logger); err != nil {
 		return
 	}
 
-	logFile = runningConfig.Logger.ActiveLogFileName
-
 	return
 }
 
-func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string,
+func setup(stopChan chan os.Signal) (log *logger.Log,
 	resolvedConf string, runningConfig *config.Parameters, err error) {
 
 	config.InitCLI()
@@ -172,6 +209,10 @@ func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string,
 			err = errors.New("running configuration is nil, cannot continue")
 			return
 		}
+		if (runningConfig.GetLogger() == nil || runningConfig.GetLogger().Config == nil) && err == nil {
+			err = errors.New("running configuration logger is nil, cannot continue")
+			return
+		}
 		if usingDefaults && os.Getenv("HELLPOT_TEST_MODE") == "" {
 			log.Warn().Msg("using default configuration!")
 			print(red + "continuing with default configuration in ")
@@ -187,7 +228,7 @@ func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string,
 		signal.Notify(stopChan, syscall.SIGINT, syscall.SIGTERM)
 
 		if //goland:noinspection GoNilness
-		!runningConfig.Logger.NoColor {
+		!runningConfig.GetLogger().Config.NoColor {
 			extra.Banner()
 		}
 		if absResolvedConf, err := filepath.Abs(resolvedConf); err == nil {
@@ -200,14 +241,14 @@ func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string,
 		if runningConfig, usingDefaults, resolvedConf, err = resolveConfig(); err != nil {
 			return
 		}
-		log, logFile, err = initLogger(runningConfig)
+		log, err = initLogger(runningConfig)
 	default:
 		println("loading configuration file: " + config.CLIFlags.Lookup("config").Value.String())
 		if runningConfig, err = readConfig(config.CLIFlags.Lookup("config").Value.String()); err != nil {
 			return
 		}
 		resolvedConf = config.CLIFlags.Lookup("config").Value.String()
-		log, logFile, err = initLogger(runningConfig)
+		log, err = initLogger(runningConfig)
 	}
 	return
 }

cmd/HellPot/util.go

@@ -2,34 +2,41 @@ package main
 
 import (
 	"os"
-	"strconv"
 
 	"github.com/rs/zerolog"
 
 	"github.com/yunginnanet/HellPot/internal/config"
+	"github.com/yunginnanet/HellPot/internal/logger"
 	"github.com/yunginnanet/HellPot/internal/version"
 )
 
-func printInfo(log zerolog.Logger, resolvedConf string, realConfig *config.Parameters) {
-	log.Info().Msg("🔥 Starting HellPot 🔥")
+func printInfo(log *logger.Log, resolvedConf string, realConfig *config.Parameters) {
+	log.Info().
+		Str("version", version.Version).
+		Int("pid", os.Getpid()).
+		Str("config_file", resolvedConf).
+		Str("log_file", log.Config.ActiveLogFileName).
+		Msg("🔥 Starting HellPot 🔥")
 	if realConfig.UsingDefaults {
 		log.Warn().Msg("Using default configuration! Please edit the configuration file to suit your needs.")
 	}
-	log.Info().Msg("Version: " + version.Version)
-	log.Info().Msg("PID: " + strconv.Itoa(os.Getpid()))
-	log.Info().Msg("Using config file: " + resolvedConf)
-	if realConfig.Logger.RSyslog != "" {
-		log.Info().Msg("Logging to syslog: " + realConfig.Logger.RSyslog)
+
+	var eventer func() *zerolog.Event
+
+	if realConfig.Logger.Debug && !realConfig.Logger.Trace {
+		eventer = log.Debug
 	}
-	if realConfig.Logger.ActiveLogFileName != "" {
-		log.Info().Msg("Logging to file: " + realConfig.Logger.ActiveLogFileName)
+	if realConfig.Logger.Trace {
+		eventer = log.Trace
 	}
-	if realConfig.Logger.DockerLogging &&
-		realConfig.Logger.File == "" &&
-		realConfig.Logger.Directory == "" &&
-		realConfig.Logger.RSyslog == "" {
-		log.Info().Msg("Only logging to standard output")
+
+	if eventer == nil {
+		return
 	}
-	log.Debug().Msg("Debug logging enabled")
-	log.Trace().Msg("Trace logging enabled")
+
+	eventer().Bool("docker_logging", true).
+		Bool("debug", true).Bool("trace", false).
+		Str("rsyslog", realConfig.Logger.RSyslog).
+		Str("log_file", realConfig.Logger.ActiveLogFileName).
+		Msg("logging engine started")
 }

internal/config/models.go

@@ -4,7 +4,6 @@ import (
 	"sync"
 
 	"github.com/knadh/koanf/v2"
-	"github.com/rs/zerolog"
 
 	"github.com/yunginnanet/HellPot/internal/logger"
 )
@@ -20,13 +19,13 @@ type Parameters struct {
 	IdleHands DevilsPlaythings `koanf:"experimental"`
 
 	source        *koanf.Koanf
-	logger        *zerolog.Logger
+	logger        *logger.Log
 	UsingDefaults bool
 }
 
 var once = &sync.Once{}
 
-func (p *Parameters) GetLogger() *zerolog.Logger {
+func (p *Parameters) GetLogger() *logger.Log {
 	once.Do(func() {
 		p.logger = logger.GetLoggerOnce()
 	})