Allow disabling stack traces, add test.

Makefile

@@ -0,0 +1,6 @@
+lint:
+	golangci-lint run -v
+
+test:
+	@echo Running unit tests...
+	@go test ./...

loggingx/config.go

@@ -23,8 +23,9 @@ import (
 
 // Config handles reading in all the config values available for setting up a logger
 type Config struct {
-	Debug  bool `mapstructure:"debug"`
-	Pretty bool `mapstructure:"pretty"`
+	Debug             bool `mapstructure:"debug"`
+	Pretty            bool `mapstructure:"pretty"`
+	DisableStacktrace bool `mapstructure:"disable_stacktrace"`
 }
 
 // MustViperFlags returns the cobra flags and viper config to prevent code duplication
@@ -34,4 +35,6 @@ func MustViperFlags(v *viper.Viper, flags *pflag.FlagSet) {
 	viperx.MustBindFlag(v, "logging.debug", flags.Lookup("debug"))
 	flags.Bool("pretty", false, "enable pretty (human readable) logging output")
 	viperx.MustBindFlag(v, "logging.pretty", flags.Lookup("pretty"))
+	flags.Bool("disable-stacktrace", false, "logging errorf/fatalf will not include stacktraces")
+	viperx.MustBindFlag(v, "logging.disable_stacktrace", flags.Lookup("disable-stacktrace"))
 }

loggingx/logger.go

@@ -33,6 +33,10 @@ func InitLogger(appName string, cfg Config) *zap.SugaredLogger {
 		lgrCfg.Level = zap.NewAtomicLevelAt(zap.InfoLevel)
 	}
 
+	if cfg.DisableStacktrace {
+		lgrCfg.DisableStacktrace = true
+	}
+
 	l, err := lgrCfg.Build()
 	if err != nil {
 		panic(err)

loggingx/logger_test.go

@@ -0,0 +1,65 @@
+package loggingx_test
+
+import (
+	"testing"
+
+	"go.infratographer.com/x/loggingx"
+
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"go.uber.org/zap/zaptest/observer"
+)
+
+var expectedMsg = "ohno"
+
+func TestInitLogger(t *testing.T) {
+	tests := []struct {
+		name       string
+		cfg        loggingx.Config
+		expectedST bool
+	}{
+		{
+			name:       "With all disabled",
+			cfg:        loggingx.Config{Debug: false, Pretty: false, DisableStacktrace: true},
+			expectedST: false,
+		},
+		{
+			name:       "With stacktrace enabled",
+			cfg:        loggingx.Config{Debug: false, Pretty: false, DisableStacktrace: false},
+			expectedST: true,
+		},
+		{
+			name:       "With all enabled",
+			cfg:        loggingx.Config{Debug: true, Pretty: true, DisableStacktrace: false},
+			expectedST: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := loggingx.InitLogger("test", tt.cfg)
+
+			// Replace the logger's core with the observer core
+			core, recorded := observer.New(zapcore.DebugLevel)
+			logger = logger.Desugar().WithOptions(zap.WrapCore(func(_ zapcore.Core) zapcore.Core {
+				return core
+			})).Sugar()
+
+			// Log an error message
+			logger.Error(expectedMsg)
+
+			// Assert that the message was logged
+			require.Equal(t, 1, recorded.Len(), "Expected one log entry")
+			allLogs := recorded.All()
+			require.Equal(t, expectedMsg, allLogs[0].Message, "Logged message does not match expected")
+
+			// Assert that the stacktrace was logged as expected
+			if tt.expectedST {
+				require.NotEmpty(t, allLogs[0].Stack, "Expected stacktrace to be logged")
+			} else {
+				require.Empty(t, allLogs[0].Stack, "Expected no stacktrace to be logged")
+			}
+		})
+	}
+}