Fix caller coverage issue.

internal/caller.go

@@ -25,8 +25,8 @@ const KnownCallerDepth = 5
 
 // NewCallerReporter returns a CallerReporter instance.
 func NewCallerReporter(skip int) *CallerReporter {
-	if skip == 0 {
-		return DefaultCallerReporter
+	if skip >= 0 && skip < 15 {
+		return DefaultCallerReporter[skip]
 	}
 	return &CallerReporter{skip: skip}
 }
@@ -41,10 +41,15 @@ func (o *CallerReporter) Equal(skip int) bool {
 	return o.skip == skip
 }
 
+// Skip gets the current skipped call stack depth.
+func (o *CallerReporter) Skip() int {
+	return o.skip
+}
+
 // GetCaller reports file and line number information about function invocations on
 // the calling goroutine's stack.
-func (o *CallerReporter) GetCaller() string {
-	if _, file, line, ok := runtime.Caller(o.skip + KnownCallerDepth); ok {
+func GetCaller(skipped int) string {
+	if _, file, line, ok := runtime.Caller(skipped + KnownCallerDepth); ok {
 		return filepath.Base(file) + ":" + strconv.Itoa(line)
 	}
 	return "???:0"

internal/caller_caller_test.go

@@ -18,20 +18,19 @@ import (
 	"testing"
 )
 
-func TestCallerReporter_GetCaller(t *testing.T) {
-	r := NewCallerReporter(1)
-	f1 := func() string { return r.GetCaller() }
+func TestGetCaller(t *testing.T) {
+	f1 := func() string { return GetCaller(1) }
 	f2 := func() string { return f1() }
 	f3 := func() string { return f2() }
 	f4 := func() string { return f3() }
 	f5 := func() string { return f4() }
 
-	got := f5() // Line 29
-	if want := "caller_caller_test.go:29"; got != want {
+	got := f5() // Line 28
+	if want := "caller_caller_test.go:28"; got != want {
 		t.Fatalf("CallerReporter.GetCaller(): got %q, want %q", got, want)
 	}
 
-	got = r.GetCaller()
+	got = GetCaller(0)
 	if want := "???:0"; got != want {
 		t.Fatalf("CallerReporter.GetCaller(): got %q, want %q", got, want)
 	}

internal/default.go

@@ -41,7 +41,12 @@ var (
 	DefaultTimeFormat = time.RFC3339
 
 	// DefaultCallerReporter is the default caller for all logger instances.
-	DefaultCallerReporter = new(CallerReporter)
+	// Creating these 15 instances in advance can already cover most cases.
+	DefaultCallerReporter = [15]*CallerReporter{
+		{skip: 0}, {skip: 1}, {skip: 2}, {skip: 3}, {skip: 4},
+		{skip: 5}, {skip: 6}, {skip: 7}, {skip: 8}, {skip: 9},
+		{skip: 10}, {skip: 11}, {skip: 12}, {skip: 13}, {skip: 14},
+	}
 
 	// ErrorWriter is used to output logger internal error messages.
 	ErrorWriter io.Writer = os.Stderr

log.go

@@ -407,16 +407,22 @@ func (o *log) write(entity *logEntity) (err error) {
 // Get the caller report. If caller reporting is not enabled in the current
 // log, an empty string is always returned.
 func (o *log) getCaller(level Level) string {
-	if o.caller != nil {
-		return o.caller.GetCaller()
+	if o.caller == nil {
+		if caller, found := o.core.levelCaller[level]; found {
+			return internal.GetCaller(caller.Skip())
+		}
+		if o.core.caller != nil {
+			return internal.GetCaller(o.core.caller.Skip())
+		}
+		return ""
 	}
 	if caller, found := o.core.levelCaller[level]; found {
-		return caller.GetCaller()
+		return internal.GetCaller(caller.Skip() + o.caller.Skip())
 	}
 	if o.core.caller != nil {
-		return o.core.caller.GetCaller()
+		return internal.GetCaller(o.core.caller.Skip() + o.caller.Skip())
 	}
-	return ""
+	return internal.GetCaller(o.caller.Skip())
 }
 
 // Log uses the given parameters to record a log of the specified level.

logger_caller_test.go

@@ -112,3 +112,21 @@ func TestLogger_InvalidCaller(t *testing.T) {
 		t.Fatalf("Logger caller: %s", got)
 	}
 }
+
+func TestLogger_WithCaller_Skip(t *testing.T) {
+	w := new(bytes.Buffer)
+	o := New("test")
+	o.SetOutput(w)
+	o.SetLevel(TraceLevel)
+	o.EnableCaller(1)
+
+	f1 := func() { o.WithCaller(2).Info("test") }
+	f2 := func() { f1() }
+	f3 := func() { f2() }
+	f3() // LINE 126
+
+	got := w.String()
+	if !strings.Contains(got, "logger_caller_test.go:126") {
+		t.Fatalf("Logger caller: %s", got)
+	}
+}