nhyatt/golang-base
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Separates log functions to separate supporting library.

Browse Source
This commit is contained in:
Hyatt 2025-02-14 14:58:40 -06:00
parent a42e1f3e7a
commit a0676c0f54
Signed by: nhyatt
GPG Key ID: C50D0BBB5BC40BEA
6 changed files with 221 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
internal/config/initialize.go
View File

@ -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)
}

132
internal/config/logging.go
View File

@ -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...,
)
}

58
internal/config/struct-config.go
View File

@ -1,10 +1,11 @@
package config
import (
"context"
"log/slog"
"os"
"reflect"
"strconv"
"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"`
Log *Log `ignored:"true"`
LogLevel int `default:"50" env:"log_level"`
// 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{
Log: &Log{
SLogLevel: new(slog.LevelVar),
},
}
// Initialize Logger
cfg.Log.Log = slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
Level: cfg.Log.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
},
}))
cfg.Log.Ctx = context.Background()
return cfg
return Config{}
}
func printRunningConfig(cfg *Config, cfgInfo []structInfo) {
var logRunningConfiguration string = "Running Configuration"
for _, info := range cfgInfo {
if info.Secret {
log.L.Debug(logRunningConfiguration, info.Name, "REDACTED")
} else {
switch info.Type.String() {
case "string":
p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
log.L.Debug(logRunningConfiguration, info.Alt, *p)
case "bool":
p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
log.L.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatBool(*p))
case "int":
p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
log.L.Log.Debug(logRunningConfiguration, info.Alt, strconv.FormatInt(int64(*p), 10))
}
}
}
}

15
internal/config/struct-config_test.go
View File

@ -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())

141
internal/log/logging.go Normal file
View File

@ -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...,
)
}

74
internal/config/logging_test.go → internal/log/logging_test.go
View File

@ -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")
}