Merge pull request #801 from n2h9/logger-caller-hook-use-function-name-to-filter-out

[logger] use function in caller hook to filter out meshkit/logger and  logrus package

Author: n2h9

logger/caller_hook.go

@@ -15,11 +15,11 @@ type CallerHook struct {
 	skippedPaths []string
 }
 
-// defaultCallerSkippedPaths contains the default path patterns to skip when finding the real caller
+// defaultCallerSkippedPaths contains the default function name patterns to skip when finding the real caller
 var (
 	defaultCallerSkippedPaths = []string{
-		"meshkit/logger",
-		"sirupsen/logrus",
+		"github.com/meshery/meshkit/logger",
+		"github.com/sirupsen/logrus",
 	}
 	defaultCallerSkippedPathsMu sync.RWMutex
 )
@@ -36,10 +36,16 @@ func (hook *CallerHook) Levels() []logrus.Level {
 	return logrus.AllLevels
 }
 
-// shouldSkipFrame checks if a file path should be skipped
-func (hook *CallerHook) shouldSkipFrame(file string) bool {
+// shouldSkipFrame checks if a function should be skipped based on function name
+func (hook *CallerHook) shouldSkipFrame(pc uintptr) bool {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return false
+	}
+	
+	funcName := fn.Name()
 	for _, path := range hook.skippedPaths {
-		if strings.Contains(file, path) {
+		if strings.Contains(funcName, path) {
 			return true
 		}
 	}
@@ -55,7 +61,7 @@ func (hook *CallerHook) Fire(entry *logrus.Entry) error {
 			break
 		}
 
-		if !hook.shouldSkipFrame(file) {
+		if !hook.shouldSkipFrame(pc) {
 			fn := runtime.FuncForPC(pc)
 			funcName := "unknown"
 			if fn != nil {

logger/caller_hook_test.go

@@ -3,18 +3,18 @@ package logger
 import (
 	"bytes"
 	"encoding/json"
+	"runtime"
 	"strings"
 	"testing"
 
 	"github.com/sirupsen/logrus"
 )
 
-// testSkippedPaths contains the paths we want to skip during tests
-// (including caller_hook.go but excluding the logger.go and test files)
+// testSkippedPaths contains the function name patterns we want to skip during tests
 var testSkippedPaths = []string{
-	"meshkit/logger/caller_hook.go",
-	"meshkit/logger/logger.go",
-	"sirupsen/logrus",
+	"github.com/meshery/meshkit/logger.(*CallerHook).Fire",
+	"github.com/meshery/meshkit/logger.(*Logger)",
+	"github.com/sirupsen/logrus",
 }
 
 func TestCallerHook_WithMeshkitLogger(t *testing.T) {
@@ -245,30 +245,25 @@ func TestCallerHook_DifferentLogLevels(t *testing.T) {
 }
 
 func TestShouldSkipFrame(t *testing.T) {
-	hook := &CallerHook{skippedPaths: []string{"meshkit/logger", "sirupsen/logrus"}}
-
-	testCases := []struct {
-		name     string
-		filepath string
-		expected bool
-	}{
-		{"should skip meshkit/logger path", "/some/path/meshkit/logger/logger.go", true},
-		{"should skip meshkit/logger path", "/some/path/meshkit/logger/caller_hook.go", true},
-		{"should skip sirupsen/logrus path", "/some/path/sirupsen/logrus/entry.go", true},
-		{"should skip meshkit/logger test files", "/some/path/meshkit/logger/caller_hook_test.go", true}, // This will be skipped with default paths
-		{"should not skip regular application path", "/some/path/myapp/main.go", false},
-		{"should not skip empty path", "", false},
-		{"should not skip partial match", "/some/path/logger-test/file.go", false},
+	// Use the test-specific skipped paths
+	hook := &CallerHook{skippedPaths: testSkippedPaths}
+
+	// Test with the current function (this test function should not be skipped)
+	pc, _, _, _ := runtime.Caller(0)
+	result := hook.shouldSkipFrame(pc)
+
+	// This test function should NOT be skipped since it doesn't match our specific patterns
+	if result {
+		currentFunc := runtime.FuncForPC(pc)
+		funcName := "unknown"
+		if currentFunc != nil {
+			funcName = currentFunc.Name()
+		}
+		t.Errorf("Test function %s should not be skipped, but shouldSkipFrame returned true", funcName)
 	}
 
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := hook.shouldSkipFrame(tc.filepath)
-			if result != tc.expected {
-				t.Errorf("shouldSkipFrame(%q) = %v, expected %v", tc.filepath, result, tc.expected)
-			}
-		})
-	}
+	// Test that the method works correctly
+	t.Logf("shouldSkipFrame works correctly for test functions")
 }
 
 func TestCallerHook_Levels(t *testing.T) {