Add WithCaller and WithCallerAt for overriding the caller detection

entry.go

@@ -83,7 +83,7 @@ func (entry *Entry) Dup() *Entry {
 	for k, v := range entry.Data {
 		data[k] = v
 	}
-	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, Context: entry.Context, err: entry.err}
+	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, Context: entry.Context, Caller: entry.Caller, err: entry.err}
 }
 
 // Returns the bytes representation of this entry from the formatter.
@@ -113,7 +113,7 @@ func (entry *Entry) WithContext(ctx context.Context) *Entry {
 	for k, v := range entry.Data {
 		dataCopy[k] = v
 	}
-	return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: ctx}
+	return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: ctx, Caller: entry.Caller}
 }
 
 // Add a single field to the Entry.
@@ -147,7 +147,7 @@ func (entry *Entry) WithFields(fields Fields) *Entry {
 			data[k] = v
 		}
 	}
-	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context}
+	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context, Caller: entry.Caller}
 }
 
 // Overrides the time of the Entry.
@@ -156,7 +156,46 @@ func (entry *Entry) WithTime(t time.Time) *Entry {
 	for k, v := range entry.Data {
 		dataCopy[k] = v
 	}
-	return &Entry{Logger: entry.Logger, Data: dataCopy, Time: t, err: entry.err, Context: entry.Context}
+	return &Entry{Logger: entry.Logger, Data: dataCopy, Time: t, err: entry.err, Context: entry.Context, Caller: entry.Caller}
+}
+
+// Overrides the caller frame of the Entry.
+//
+// This method works regardless of whether ReportCaller is enabled or not.
+func (entry *Entry) WithCaller(frame *runtime.Frame) *Entry {
+	dataCopy := make(Fields, len(entry.Data))
+	for k, v := range entry.Data {
+		dataCopy[k] = v
+	}
+	return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: entry.Context, Caller: frame}
+}
+
+// Overrides the caller frame of the Entry,
+// finding the frame at the given calldepth.
+// A calldepth of 0 asks to fetch the frame
+// that calls WithCallerAt.
+//
+// If ReportCaller is disabled on this entry's logger,
+// returns an exact copy of entry.
+func (entry *Entry) WithCallerAt(calldepth int) *Entry {
+	entry.Logger.mu.Lock()
+	if !entry.Logger.ReportCaller {
+		entry.Logger.mu.Unlock()
+
+		dataCopy := make(Fields, len(entry.Data))
+		for k, v := range entry.Data {
+			dataCopy[k] = v
+		}
+		return &Entry{Logger: entry.Logger, Data: dataCopy, Time: entry.Time, err: entry.err, Context: entry.Context, Caller: entry.Caller}
+	}
+
+	defer entry.Logger.mu.Unlock()
+
+	pcs := []uintptr{0}
+	depth := runtime.Callers(calldepth+2, pcs)
+	frames := runtime.CallersFrames(pcs[:depth])
+	frame, _ := frames.Next()
+	return entry.WithCaller(&frame)
 }
 
 // getPackageName reduces a fully qualified function name to the package name
@@ -230,12 +269,14 @@ func (entry *Entry) log(level Level, msg string) {
 	newEntry.Level = level
 	newEntry.Message = msg
 
-	newEntry.Logger.mu.Lock()
-	reportCaller := newEntry.Logger.ReportCaller
-	newEntry.Logger.mu.Unlock()
+	if newEntry.Caller == nil {
+		newEntry.Logger.mu.Lock()
+		reportCaller := newEntry.Logger.ReportCaller
+		newEntry.Logger.mu.Unlock()
 
-	if reportCaller {
-		newEntry.Caller = getCaller()
+		if reportCaller {
+			newEntry.Caller = getCaller()
+		}
 	}
 
 	newEntry.fireHooks()

entry_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"strings"
 	"testing"
 	"time"
 
@@ -123,6 +124,27 @@ func TestEntryWithTimeCopiesData(t *testing.T) {
 	assert.Empty(val)
 }
 
+func TestEntryWithCallerAt(t *testing.T) {
+	assert := assert.New(t)
+
+	logger := New()
+	logger.Out = &bytes.Buffer{}
+
+	entry := func() *Entry {
+		return logger.WithCallerAt(0)
+	}()
+	assert.Equal(logger, entry.Logger)
+	assert.Nil(entry.Caller, "WithCallerAt shouldn't look when ReportCaller == false")
+
+	logger.SetReportCaller(true)
+	entry = func() *Entry {
+		return logger.WithCallerAt(1)
+	}()
+	assert.Equal(logger, entry.Logger)
+	assert.NotNil(entry.Caller)
+	assert.True(strings.HasSuffix(entry.Caller.Function, ".TestEntryWithCallerAt"))
+}
+
 func TestEntryPanicln(t *testing.T) {
 	errBoom := fmt.Errorf("boom time")
 

logger.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"io"
 	"os"
+	"runtime"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -145,6 +146,28 @@ func (logger *Logger) WithTime(t time.Time) *Entry {
 	return entry.WithTime(t)
 }
 
+// Overrides the caller frame of the log entry.
+//
+// This method works regardless of whether ReportCaller is enabled or not.
+func (logger *Logger) WithCaller(frame *runtime.Frame) *Entry {
+	entry := logger.newEntry()
+	defer logger.releaseEntry(entry)
+	return entry.WithCaller(frame)
+}
+
+// Overrides the caller frame of the log entry,
+// finding the frame at the given calldepth.
+// A calldepth of 0 asks to fetch the frame
+// that calls WithCallerAt.
+//
+// If ReportCaller is disabled, this simply returns a blank entry
+// (roughly like calling `NewEntry(logger)`).
+func (logger *Logger) WithCallerAt(calldepth int) *Entry {
+	entry := logger.newEntry()
+	defer logger.releaseEntry(entry)
+	return entry.WithCallerAt(calldepth + 1)
+}
+
 func (logger *Logger) Logf(level Level, format string, args ...interface{}) {
 	if logger.IsLevelEnabled(level) {
 		entry := logger.newEntry()