Separates log functions to separate supporting library.

internal/config/initialize.go

@@ -4,11 +4,14 @@ import (
 	"log"
 	"os"
 	"time"
+
+	l "example.com/golang-base/internal/log"
 )
 
 func Init() Config {
 	cfg := New()
 
+	// parse config structure
 	cfgInfo, err := getStructInfo(&cfg)
 	if err != nil {
 		log.Fatalf("Unable to initialize program: %v", err)
@@ -20,13 +23,13 @@ func Init() Config {
 	}
 
 	// set logging Level
-	setLogLevel(&cfg)
+	l.SetNumericLevel(cfg.LogLevel)
 
 	// set timezone & time format
 	cfg.TZUTC, _ = time.LoadLocation("UTC")
 	cfg.TZLocal, err = time.LoadLocation(cfg.TimeZoneLocal)
 	if err != nil {
-		cfg.Log.Error("Unable to parse timezone string", "error", err)
+		l.L.Error("Unable to parse timezone string", "error", err)
 		os.Exit(1)
 	}
 

internal/config/logging.go

@@ -1,132 +0,0 @@
-package config
-
-import (
-	"context"
-	"log/slog"
-	"reflect"
-	"strconv"
-)
-
-const (
-	LevelTrace = slog.Level(-8)
-	LevelFatal = slog.Level(12)
-)
-
-type Log struct {
-	Ctx       context.Context
-	Log       *slog.Logger
-	SLogLevel *slog.LevelVar
-}
-
-var LevelNames = map[slog.Leveler]string{
-	LevelTrace: "TRACE",
-	LevelFatal: "FATAL",
-}
-
-func setLogLevel(cfg *Config) {
-	switch {
-	// fatal
-	case cfg.LogLevel <= 20:
-		cfg.Log.SLogLevel.Set(LevelFatal)
-		cfg.Log.Info("Log level updated", slog.Any("level", LevelFatal))
-	// error
-	case cfg.LogLevel > 20 && cfg.LogLevel <= 40:
-		cfg.Log.SLogLevel.Set(slog.LevelError)
-		cfg.Log.Info("Log level updated", slog.Any("level", slog.LevelError))
-	// warning
-	case cfg.LogLevel > 40 && cfg.LogLevel <= 60:
-		cfg.Log.SLogLevel.Set(slog.LevelWarn)
-		cfg.Log.Info("Log level updated", slog.Any("level", slog.LevelWarn))
-	// info
-	case cfg.LogLevel > 60 && cfg.LogLevel <= 80:
-		cfg.Log.SLogLevel.Set(slog.LevelInfo)
-		cfg.Log.Info("Log level updated", slog.Any("level", slog.LevelInfo))
-	// debug
-	case cfg.LogLevel > 80 && cfg.LogLevel <= 100:
-		cfg.Log.SLogLevel.Set(slog.LevelDebug)
-		cfg.Log.Info("Log level updated", slog.Any("level", slog.LevelDebug))
-	// trace
-	case cfg.LogLevel > 100:
-		cfg.Log.SLogLevel.Set(LevelTrace)
-		cfg.Log.Info("Log level updated", slog.Any("level", LevelTrace))
-	}
-
-	// set default logger
-	slog.SetDefault(cfg.Log.Log)
-}
-
-func printRunningConfig(cfg *Config, cfgInfo []structInfo) {
-	var logRunningConfiguration string = "Running Configuration"
-
-	for _, info := range cfgInfo {
-		if info.Secret {
-			cfg.Log.Debug(logRunningConfiguration, info.Name, "REDACTED")
-		} else {
-			switch info.Type.String() {
-			case "string":
-				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
-				cfg.Log.Debug(logRunningConfiguration, info.Alt, *p)
-			case "bool":
-				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
-				cfg.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatBool(*p))
-			case "int":
-				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
-				cfg.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatInt(int64(*p), 10))
-			}
-		}
-	}
-}
-
-func (log *Log) Fatal(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		LevelFatal,
-		msg,
-		attrs...,
-	)
-}
-
-func (log Log) Error(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		slog.LevelError,
-		msg,
-		attrs...,
-	)
-}
-
-func (log Log) Warn(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		slog.LevelWarn,
-		msg,
-		attrs...,
-	)
-}
-
-func (log Log) Info(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		slog.LevelInfo,
-		msg,
-		attrs...,
-	)
-}
-
-func (log Log) Debug(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		slog.LevelDebug,
-		msg,
-		attrs...,
-	)
-}
-
-func (log Log) Trace(msg string, attrs ...interface{}) {
-	log.Log.Log(
-		log.Ctx,
-		LevelTrace,
-		msg,
-		attrs...,
-	)
-}

internal/config/struct-config.go

@@ -1,10 +1,11 @@
 package config
 
 import (
-	"context"
+	"reflect"
-	"log/slog"
+	"strconv"
-	"os"
 	"time"
+
+	"example.com/golang-base/internal/log"
 )
 
 type Config struct {
@@ -15,8 +16,7 @@ type Config struct {
 	TZUTC         *time.Location `ignored:"true"`
 
 	// logging
-	LogLevel int  `default:"50"   env:"log_level"`
+	LogLevel int `default:"50" env:"log_level"`
-	Log      *Log `ignored:"true"`
 
 	// webserver
 	WebServerPort         int    `default:"8080"    env:"webserver_port"`
@@ -28,29 +28,27 @@ type Config struct {
 
 // New initializes the config variable for use with a prepared set of defaults.
 func New() Config {
-	cfg := Config{
+	return Config{}
-		Log: &Log{
+}
-			SLogLevel: new(slog.LevelVar),
+
-		},
+func printRunningConfig(cfg *Config, cfgInfo []structInfo) {
-	}
+	var logRunningConfiguration string = "Running Configuration"
-
+
-	// Initialize Logger
+	for _, info := range cfgInfo {
-	cfg.Log.Log = slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		if info.Secret {
-		Level: cfg.Log.SLogLevel,
+			log.L.Debug(logRunningConfiguration, info.Name, "REDACTED")
-		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+		} else {
-			if a.Key == slog.LevelKey {
+			switch info.Type.String() {
-				level := a.Value.Any().(slog.Level)
+			case "string":
-				levelLabel, exists := LevelNames[level]
+				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
-				if !exists {
+				log.L.Debug(logRunningConfiguration, info.Alt, *p)
-					levelLabel = level.String()
+			case "bool":
-				}
+				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
-
+				log.L.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatBool(*p))
-				a.Value = slog.StringValue(levelLabel)
+			case "int":
-			}
+				p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
-			return a
+				log.L.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatInt(int64(*p), 10))
-		},
+			}
-	}))
+		}
-	cfg.Log.Ctx = context.Background()
+	}
-
-	return cfg
 }

internal/config/struct-config_test.go

@@ -6,6 +6,7 @@ import (
 	"reflect"
 	"testing"
 
+	"example.com/golang-base/internal/log"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -15,12 +16,24 @@ func slogToBuffer() (*bytes.Buffer, *slog.Logger) {
 		slog.NewTextHandler(
 			buf,
 			&slog.HandlerOptions{
-				Level: LevelTrace,
+				Level: log.LevelTrace,
 			},
 		),
 	)
 }
 
+func TestPrintRunningConfig(t *testing.T) {
+	buf, l := slogToBuffer()
+	log.L.Log = l
+
+	c := New()
+	cfgInfo, err := getStructInfo(&c)
+	assert.NoError(t, err)
+	printRunningConfig(&c, cfgInfo)
+
+	assert.Contains(t, buf.String(), "Running Configuration")
+}
+
 func TestNew(t *testing.T) {
 	c := New()
 	assert.Equal(t, "config.Config", reflect.TypeOf(c).String())

internal/log/logging.go

@@ -0,0 +1,141 @@
+package log
+
+import (
+	"context"
+	"log/slog"
+	"os"
+)
+
+const (
+	LevelTrace = slog.Level(-8)
+	LevelFatal = slog.Level(12)
+)
+
+type Log struct {
+	Ctx       context.Context
+	Log       *slog.Logger
+	SLogLevel slog.LevelVar
+}
+
+var (
+	// LevelNames set the names associated with custom logging levels.
+	LevelNames = map[slog.Leveler]string{
+		LevelTrace: "TRACE",
+		LevelFatal: "FATAL",
+	}
+	// L is the global interface used for calling the logger subfunctions.
+	L = Log{}
+)
+
+func init() {
+	// Initialize SLog and translate new logging levels
+	L.Log = slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		Level: &L.SLogLevel,
+		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+			if a.Key == slog.LevelKey {
+				level := a.Value.Any().(slog.Level)
+				levelLabel, exists := LevelNames[level]
+				if !exists {
+					levelLabel = level.String()
+				}
+
+				a.Value = slog.StringValue(levelLabel)
+			}
+			return a
+		},
+	}))
+	L.Ctx = context.Background()
+}
+
+// SetNumericLevel will set the log level based on a number from 1-100.
+// The larger the number the more verbose the logs.
+//
+// 1-20 = Fatal, 21-40 = Error, 41-60 = Warn, 61-80 = Info, 81-99 = Debug,
+// and 100 = Trace.
+func SetNumericLevel(level int) {
+	var llu string = "Log Level Updated"
+
+	switch {
+	// fatal
+	case level <= 20:
+		L.SLogLevel.Set(LevelFatal)
+		L.Info(llu, "level", LevelFatal)
+	// error
+	case level > 20 && level <= 40:
+		L.SLogLevel.Set(slog.LevelError)
+		L.Info(llu, "level", slog.LevelError)
+	// warning
+	case level > 40 && level <= 60:
+		L.SLogLevel.Set(slog.LevelWarn)
+		L.Info(llu, "level", slog.LevelWarn)
+	// info
+	case level > 60 && level <= 80:
+		L.SLogLevel.Set(slog.LevelInfo)
+		L.Info(llu, "level", slog.LevelInfo)
+	// debug
+	case level > 80 && level <= 99:
+		L.SLogLevel.Set(slog.LevelDebug)
+		L.Info(llu, "level", slog.LevelDebug)
+	// trace
+	case level > 99:
+		L.SLogLevel.Set(LevelTrace)
+		L.Info(llu, "level", LevelTrace)
+	}
+
+	// set default logger
+	slog.SetDefault(L.Log)
+}
+
+func (log *Log) Fatal(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		LevelFatal,
+		msg,
+		attrs...,
+	)
+}
+
+func (log *Log) Error(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		slog.LevelError,
+		msg,
+		attrs...,
+	)
+}
+
+func (log *Log) Warn(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		slog.LevelWarn,
+		msg,
+		attrs...,
+	)
+}
+
+func (log *Log) Info(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		slog.LevelInfo,
+		msg,
+		attrs...,
+	)
+}
+
+func (log *Log) Debug(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		slog.LevelDebug,
+		msg,
+		attrs...,
+	)
+}
+
+func (log *Log) Trace(msg string, attrs ...interface{}) {
+	log.Log.Log(
+		log.Ctx,
+		LevelTrace,
+		msg,
+		attrs...,
+	)
+}

internal/log/logging_test.go

@@ -1,103 +1,95 @@
-package config
+package log
-
 import (
+	"bytes"
 	"log/slog"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+func slogToBuffer() (*bytes.Buffer, *slog.Logger) {
+	buf := new(bytes.Buffer)
+	return buf, slog.New(
+		slog.NewTextHandler(
+			buf,
+			&slog.HandlerOptions{
+				Level: LevelTrace,
+			},
+		),
+	)
+}
+
 func TestSetLogLevel(t *testing.T) {
-	c := New()
-
 	for _, i := range []int{0, 21, 41, 61, 81, 101} {
-		c.LogLevel = i
+		SetNumericLevel(i)
 
-		setLogLevel(&c)
 		switch i {
 		case 0:
-			assert.Equal(t, LevelFatal, c.Log.SLogLevel.Level())
+			assert.Equal(t, LevelFatal, L.SLogLevel.Level())
 		case 21:
-			assert.Equal(t, slog.LevelError, c.Log.SLogLevel.Level())
+			assert.Equal(t, slog.LevelError, L.SLogLevel.Level())
 		case 41:
-			assert.Equal(t, slog.LevelWarn, c.Log.SLogLevel.Level())
+			assert.Equal(t, slog.LevelWarn, L.SLogLevel.Level())
 		case 61:
-			assert.Equal(t, slog.LevelInfo, c.Log.SLogLevel.Level())
+			assert.Equal(t, slog.LevelInfo, L.SLogLevel.Level())
 		case 81:
-			assert.Equal(t, slog.LevelDebug, c.Log.SLogLevel.Level())
+			assert.Equal(t, slog.LevelDebug, L.SLogLevel.Level())
 		case 101:
-			assert.Equal(t, LevelTrace, c.Log.SLogLevel.Level())
+			assert.Equal(t, LevelTrace, L.SLogLevel.Level())
 		}
 	}
 }
 
-func TestPrintRunningConfig(t *testing.T) {
-	buf, log := slogToBuffer()
-	c := New()
-	c.Log.Log = log
-	cfgInfo, err := getStructInfo(&c)
-	assert.NoError(t, err)
-	printRunningConfig(&c, cfgInfo)
-
-	assert.Contains(t, buf.String(), "Running Configuration")
-}
-
 func TestFatal(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Fatal("TEST Message")
+	L.Fatal("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=ERROR+4")
 }
 
 func TestError(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Error("TEST Message")
+	L.Error("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=ERROR")
 }
 
 func TestWarn(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Warn("TEST Message")
+	L.Warn("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=WARN")
 }
 
 func TestInfo(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Info("TEST Message")
+	L.Info("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=INFO")
 }
 
 func TestDebug(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Debug("TEST Message")
+	L.Debug("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=DEBUG")
 }
 
 func TestTrace(t *testing.T) {
-	c := New()
 	buf, log := slogToBuffer()
-	c.Log.Log = log
+	L.Log = log
 
-	c.Log.Trace("TEST Message")
+	L.Trace("TEST Message")
 	assert.Contains(t, buf.String(), "TEST Message")
 	assert.Contains(t, buf.String(), "level=DEBUG-4")
 }