backport from v3

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

logger/options.go

@@ -39,8 +39,10 @@ type Options struct {
 	SourceKey string
 	// StacktraceKey is the key used for the stacktrace
 	StacktraceKey string
-	// Stacktrace controls writing of stacktaces on error
-	Stacktrace bool
+	// AddStacktrace controls writing of stacktaces on error
+	AddStacktrace bool
+	// AddSource enabled writing source file and position in log
+	AddSource bool
 }
 
 // NewOptions creates new options struct
@@ -52,6 +54,7 @@ func NewOptions(opts ...options.Option) Options {
 		CallerSkipCount:  DefaultCallerSkipCount,
 		Context:          context.Background(),
 		ContextAttrFuncs: DefaultContextAttrFuncs,
+		AddSource:        true,
 	}
 
 	_ = WithMicroKeys()(&options)
@@ -207,9 +210,16 @@ func WithMicroKeys() options.Option {
 	}
 }
 
-// WithStacktrace controls writing stacktrace on error
-func WithStacktrace(v bool) options.Option {
+// WithAddStacktrace controls writing stacktrace on error
+func WithAddStacktrace(v bool) options.Option {
 	return func(src interface{}) error {
-		return options.Set(src, v, ".Stacktrace")
+		return options.Set(src, v, ".AddStacktrace")
+	}
+}
+
+// WitAddSource controls writing source file and pos in log
+func WithAddSource(v bool) options.Option {
+	return func(src interface{}) error {
+		return options.Set(src, v, ".AddSource")
 	}
 }

logger/slog/slog.go

@@ -80,18 +80,11 @@ func (s *slogLogger) Clone(opts ...options.Option) logger.Logger {
 		opts: options,
 	}
 
-	/*
-		if slog, ok := s.opts.Context.Value(loggerKey{}).(*slog.Logger); ok {
-			l.slog = slog
-			return nil
-		}
-	*/
-
 	l.leveler = new(slog.LevelVar)
 	handleOpt := &slog.HandlerOptions{
-		ReplaceAttr: s.renameAttr,
+		ReplaceAttr: l.renameAttr,
 		Level:       l.leveler,
-		AddSource:   true,
+		AddSource:   l.opts.AddSource,
 	}
 	l.leveler.Set(loggerToSlogLevel(l.opts.Level))
 	handler := slog.NewJSONHandler(options.Out, handleOpt)
@@ -116,50 +109,47 @@ func (s *slogLogger) Options() logger.Options {
 
 func (s *slogLogger) Attrs(attrs ...interface{}) logger.Logger {
 	s.mu.RLock()
-	nl := &slogLogger{opts: s.opts}
-	nl.leveler = new(slog.LevelVar)
-	nl.leveler.Set(s.leveler.Level())
+	l := &slogLogger{opts: s.opts}
+	l.leveler = new(slog.LevelVar)
+	l.leveler.Set(s.leveler.Level())
 
 	handleOpt := &slog.HandlerOptions{
-		ReplaceAttr: nl.renameAttr,
-		Level:       nl.leveler,
-		AddSource:   true,
+		ReplaceAttr: l.renameAttr,
+		Level:       l.leveler,
+		AddSource:   l.opts.AddSource,
 	}
 
 	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
-	nl.slog = slog.New(handler).With(attrs...)
+	l.slog = slog.New(handler).With(attrs...)
 
 	s.mu.RUnlock()
 
-	return nl
+	return l
 }
 
 func (s *slogLogger) Init(opts ...options.Option) error {
+	s.mu.Lock()
+
 	if len(s.opts.ContextAttrFuncs) == 0 {
 		s.opts.ContextAttrFuncs = logger.DefaultContextAttrFuncs
 	}
+
 	for _, o := range opts {
 		if err := o(&s.opts); err != nil {
 			return err
 		}
 	}
 
-	/*
-		if slog, ok := s.opts.Context.Value(loggerKey{}).(*slog.Logger); ok {
-			s.slog = slog
-			return nil
-		}
-	*/
-
 	s.leveler = new(slog.LevelVar)
 	handleOpt := &slog.HandlerOptions{
 		ReplaceAttr: s.renameAttr,
 		Level:       s.leveler,
-		AddSource:   true,
+		AddSource:   s.opts.AddSource,
 	}
 	s.leveler.Set(loggerToSlogLevel(s.opts.Level))
 	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
 	s.slog = slog.New(handler).With(s.opts.Attrs...)
+	s.mu.Unlock()
 
 	return nil
 }
@@ -180,7 +170,7 @@ func (s *slogLogger) Log(ctx context.Context, lvl logger.Level, msg string, attr
 			break
 		}
 	}
-	if s.opts.Stacktrace && lvl == logger.ErrorLevel {
+	if s.opts.AddStacktrace && lvl == logger.ErrorLevel {
 		stackInfo := make([]byte, 1024*1024)
 		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
 			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
@@ -260,7 +250,7 @@ func (s *slogLogger) Error(ctx context.Context, msg string, attrs ...interface{}
 			break
 		}
 	}
-	if s.opts.Stacktrace {
+	if s.opts.AddStacktrace {
 		stackInfo := make([]byte, 1024*1024)
 		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
 			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)

logger/slog/slog_test.go

@@ -13,7 +13,7 @@ import (
 func TestError(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithStacktrace(true))
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithAddStacktrace(true))
 	if err := l.Init(); err != nil {
 		t.Fatal(err)
 	}