Support for projects without go.mod (#153)

* better support for project without go.mod

* fix

* benchmark fix

* Refactor

* Refactor

* comments

* comments

* remove source root from init.go

* Tests for util file

* go fmt

* avoid empty test.code in benchmark tests

Author: tonyredondo

instrumentation/testing/benchmark.go

@@ -2,7 +2,6 @@ package testing
 
 import (
 	"context"
-	"fmt"
 	"math"
 	"regexp"
 	"runtime"
@@ -13,7 +12,6 @@ import (
 
 	"github.com/opentracing/opentracing-go"
 
-	"go.undefinedlabs.com/scopeagent/ast"
 	"go.undefinedlabs.com/scopeagent/instrumentation"
 	"go.undefinedlabs.com/scopeagent/reflection"
 	"go.undefinedlabs.com/scopeagent/runner"
@@ -88,10 +86,10 @@ func startBenchmark(b *testing.B, pc uintptr, benchFunc func(b *testing.B)) {
 	if bChild == nil {
 		return
 	}
-	if getBenchmarkHasSub(bChild) > 0 {
+	if reflection.GetBenchmarkHasSub(bChild) > 0 {
 		return
 	}
-	results, err := extractBenchmarkResult(bChild)
+	results, err := reflection.GetBenchmarkResult(bChild)
 	if err != nil {
 		instrumentation.Logger().Printf("Error while extracting the benchmark result object: %v\n", err)
 		return
@@ -102,7 +100,7 @@ func startBenchmark(b *testing.B, pc uintptr, benchFunc func(b *testing.B)) {
 	fullTestName := runner.GetOriginalTestName(b.Name())
 
 	// We detect if the parent benchmark is instrumented, and if so we remove the "*" SubBenchmark from the previous instrumentation
-	parentBenchmark := getParentBenchmark(b)
+	parentBenchmark := reflection.GetParentBenchmark(b)
 	if parentBenchmark != nil && hasBenchmark(parentBenchmark) {
 		var nameSegments []string
 		for _, match := range benchmarkNameRegex.FindAllStringSubmatch(fullTestName, -1) {
@@ -112,30 +110,27 @@ func startBenchmark(b *testing.B, pc uintptr, benchFunc func(b *testing.B)) {
 		}
 		fullTestName = strings.Join(nameSegments, "/")
 	}
-
-	testNameSlash := strings.IndexByte(fullTestName, '/')
-	funcName := fullTestName
-	if testNameSlash >= 0 {
-		funcName = fullTestName[:testNameSlash]
-	}
-	packageName := getBenchmarkSuiteName(b)
-
-	sourceBounds, _ := ast.GetFuncSourceForName(pc, funcName)
-	var testCode string
-	if sourceBounds != nil {
-		testCode = fmt.Sprintf("%s:%d:%d", sourceBounds.File, sourceBounds.Start.Line, sourceBounds.End.Line)
+	packageName := reflection.GetBenchmarkSuiteName(b)
+	if packageName == "" {
+		packageName = getPackageName(pc, fullTestName)
 	}
 
-	var startOptions []opentracing.StartSpanOption
-	startOptions = append(startOptions, opentracing.Tags{
+	oTags := opentracing.Tags{
 		"span.kind":      "test",
 		"test.name":      fullTestName,
 		"test.suite":     packageName,
-		"test.code":      testCode,
 		"test.framework": "testing",
 		"test.language":  "go",
 		"test.type":      "benchmark",
-	}, opentracing.StartTime(startTime))
+	}
+
+	testCode := getTestCodeBoundaries(pc, fullTestName)
+	if testCode != "" {
+		oTags["test.code"] = testCode
+	}
+
+	var startOptions []opentracing.StartSpanOption
+	startOptions = append(startOptions, oTags, opentracing.StartTime(startTime))
 
 	span, _ := opentracing.StartSpanFromContextWithTracer(context.Background(), instrumentation.Tracer(), fullTestName, startOptions...)
 	span.SetBaggageItem("trace.kind", "test")
@@ -153,33 +148,3 @@ func startBenchmark(b *testing.B, pc uintptr, benchFunc func(b *testing.B)) {
 		FinishTime: startTime.Add(results.T),
 	})
 }
-
-func getParentBenchmark(b *testing.B) *testing.B {
-	if ptr, err := reflection.GetFieldPointerOf(b, "parent"); err == nil {
-		return *(**testing.B)(ptr)
-	}
-	return nil
-}
-
-func getBenchmarkSuiteName(b *testing.B) string {
-	if ptr, err := reflection.GetFieldPointerOf(b, "importPath"); err == nil {
-		return *(*string)(ptr)
-	}
-	return ""
-}
-
-func getBenchmarkHasSub(b *testing.B) int32 {
-	if ptr, err := reflection.GetFieldPointerOf(b, "hasSub"); err == nil {
-		return *(*int32)(ptr)
-	}
-	return 0
-}
-
-//Extract benchmark result from the private result field in testing.B
-func extractBenchmarkResult(b *testing.B) (*testing.BenchmarkResult, error) {
-	if ptr, err := reflection.GetFieldPointerOf(b, "result"); err == nil {
-		return (*testing.BenchmarkResult)(ptr), nil
-	} else {
-		return nil, err
-	}
-}

instrumentation/testing/testing.go

@@ -2,7 +2,6 @@ package testing
 
 import (
 	"context"
-	"fmt"
 	"reflect"
 	"regexp"
 	"runtime"
@@ -14,7 +13,6 @@ import (
 
 	"github.com/opentracing/opentracing-go"
 
-	"go.undefinedlabs.com/scopeagent/ast"
 	"go.undefinedlabs.com/scopeagent/errors"
 	"go.undefinedlabs.com/scopeagent/instrumentation"
 	"go.undefinedlabs.com/scopeagent/instrumentation/logging"
@@ -71,21 +69,10 @@ func StartTestFromCaller(t *testing.T, pc uintptr, opts ...Option) *Test {
 		opt(test)
 	}
 
-	// Extracting the benchmark func name (by removing any possible sub-benchmark suffix `{bench_func}/{sub_benchmark}`)
+	// Extracting the testing func name (by removing any possible sub-test suffix `{test_func}/{sub_test}`)
 	// to search the func source code bounds and to calculate the package name.
 	fullTestName := runner.GetOriginalTestName(t.Name())
-	testNameSlash := strings.IndexByte(fullTestName, '/')
-	funcName := fullTestName
-	if testNameSlash >= 0 {
-		funcName = fullTestName[:testNameSlash]
-	}
-
-	funcFullName := runtime.FuncForPC(pc).Name()
-	funcNameIndex := strings.LastIndex(funcFullName, funcName)
-	if funcNameIndex < 1 {
-		funcNameIndex = len(funcFullName)
-	}
-	packageName := funcFullName[:funcNameIndex-1]
+	packageName := getPackageName(pc, fullTestName)
 
 	testTags := opentracing.Tags{
 		"span.kind":      "test",
@@ -94,12 +81,10 @@ func StartTestFromCaller(t *testing.T, pc uintptr, opts ...Option) *Test {
 		"test.framework": "testing",
 		"test.language":  "go",
 	}
-	sourceBounds, sErr := ast.GetFuncSourceForName(pc, funcName)
-	if sErr != nil {
-		instrumentation.Logger().Printf("error calculating the source boundaries for '%s [%s]': %v", funcName, funcFullName, sErr)
-	}
-	if sourceBounds != nil {
-		testTags["test.code"] = fmt.Sprintf("%s:%d:%d", sourceBounds.File, sourceBounds.Start.Line, sourceBounds.End.Line)
+
+	testCode := getTestCodeBoundaries(pc, fullTestName)
+	if testCode != "" {
+		testTags["test.code"] = testCode
 	}
 
 	if test.ctx == nil {

instrumentation/testing/util.go

@@ -0,0 +1,58 @@
+package testing
+
+import (
+	"fmt"
+	"path"
+	"runtime"
+	"strings"
+
+	"go.undefinedlabs.com/scopeagent/ast"
+	"go.undefinedlabs.com/scopeagent/instrumentation"
+)
+
+// Gets the Test/Benchmark parent func name without sub-benchmark and sub-test segments
+func getFuncName(fullName string) string {
+	testNameSlash := strings.IndexByte(fullName, '/')
+	funcName := fullName
+	if testNameSlash >= 0 {
+		funcName = fullName[:testNameSlash]
+	}
+	return funcName
+}
+
+// Gets the Package name
+func getPackageName(pc uintptr, fullName string) string {
+	// Parent test/benchmark name
+	funcName := getFuncName(fullName)
+	// Full func name (format ex: {packageName}.{test/benchmark name}.{inner function of sub benchmark/test}
+	funcFullName := runtime.FuncForPC(pc).Name()
+
+	// We select the packageName as substring from start to the index of the test/benchmark name minus 1
+	funcNameIndex := strings.LastIndex(funcFullName, funcName)
+	if funcNameIndex < 1 {
+		funcNameIndex = len(funcFullName)
+	}
+	packageName := funcFullName[:funcNameIndex-1]
+
+	// If the package has the format: _/{path...}
+	// We convert the path from absolute to relative to the source root
+	sourceRoot := instrumentation.GetSourceRoot()
+	if len(packageName) > 0 && packageName[0] == '_' && strings.Index(packageName, sourceRoot) != -1 {
+		packageName = strings.Replace(packageName, path.Dir(sourceRoot)+"/", "", -1)[1:]
+	}
+
+	return packageName
+}
+
+// Gets the source code boundaries of a test or benchmark in the format: {file}:{startLine}:{endLine}
+func getTestCodeBoundaries(pc uintptr, fullName string) string {
+	funcName := getFuncName(fullName)
+	sourceBounds, err := ast.GetFuncSourceForName(pc, funcName)
+	if err != nil {
+		instrumentation.Logger().Printf("error calculating the source boundaries for '%s [%s]': %v", funcName, fullName, err)
+	}
+	if sourceBounds != nil {
+		return fmt.Sprintf("%s:%d:%d", sourceBounds.File, sourceBounds.Start.Line, sourceBounds.End.Line)
+	}
+	return ""
+}

instrumentation/testing/util_test.go

@@ -0,0 +1,68 @@
+package testing
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+
+	"go.undefinedlabs.com/scopeagent/ast"
+)
+
+func TestGetFuncName(t *testing.T) {
+	cases := map[string]string{
+		"TestBase":                           "TestBase",
+		"TestBase/Sub01":                     "TestBase",
+		"TestBase/Sub 02":                    "TestBase",
+		"TestBase/Sub/Sub02":                 "TestBase",
+		"TestBase/Sub/Sub02/Sub03":           "TestBase",
+		"TestBase/Sub/Sub02/Sub03/S u b 0 4": "TestBase",
+	}
+
+	for key, expected := range cases {
+		t.Run(key, func(t *testing.T) {
+			value := getFuncName(key)
+			if value != expected {
+				t.Fatalf("value '%s', expected: '%s'", value, expected)
+			}
+		})
+	}
+}
+
+func TestGetPackageName(t *testing.T) {
+	var pc uintptr
+	func() { pc, _, _, _ = runtime.Caller(1) }()
+	testName := t.Name()
+	packName := getPackageName(pc, testName)
+
+	subTestName := ""
+	t.Run("sub-test", func(t *testing.T) {
+		subTestName = t.Name()
+	})
+	packName02 := getPackageName(pc, subTestName)
+
+	if testName != "TestGetPackageName" {
+		t.Fatalf("value '%s' not expected", testName)
+	}
+	if subTestName != "TestGetPackageName/sub-test" {
+		t.Fatalf("value '%s' not expected", testName)
+	}
+	if packName != "go.undefinedlabs.com/scopeagent/instrumentation/testing" {
+		t.Fatalf("value '%s' not expected", packName)
+	}
+	if packName != packName02 {
+		t.Fatalf("value '%s' not expected", packName02)
+	}
+}
+
+func TestGetTestCodeBoundaries(t *testing.T) {
+	var pc uintptr
+	func() { pc, _, _, _ = runtime.Caller(1) }()
+	testName := t.Name()
+
+	actualBoundary := getTestCodeBoundaries(pc, testName)
+	boundaryExpected, _ := ast.GetFuncSourceForName(pc, testName)
+	calcExpected := fmt.Sprintf("%s:%d:%d", boundaryExpected.File, boundaryExpected.Start.Line, boundaryExpected.End.Line)
+	if actualBoundary != calcExpected {
+		t.Fatalf("value '%s' not expected", actualBoundary)
+	}
+}

reflection/reflect.go

@@ -46,3 +46,60 @@ func GetIsParallel(t *testing.T) bool {
 	}
 	return false
 }
+
+func GetBenchmarkMutex(b *testing.B) *sync.RWMutex {
+	if ptr, err := GetFieldPointerOf(b, "mu"); err == nil {
+		return (*sync.RWMutex)(ptr)
+	}
+	return nil
+}
+
+func GetParentBenchmark(b *testing.B) *testing.B {
+	mu := GetBenchmarkMutex(b)
+	if mu != nil {
+		mu.Lock()
+		defer mu.Unlock()
+	}
+	if ptr, err := GetFieldPointerOf(b, "parent"); err == nil {
+		return *(**testing.B)(ptr)
+	}
+	return nil
+}
+
+func GetBenchmarkSuiteName(b *testing.B) string {
+	mu := GetBenchmarkMutex(b)
+	if mu != nil {
+		mu.Lock()
+		defer mu.Unlock()
+	}
+	if ptr, err := GetFieldPointerOf(b, "importPath"); err == nil {
+		return *(*string)(ptr)
+	}
+	return ""
+}
+
+func GetBenchmarkHasSub(b *testing.B) int32 {
+	mu := GetBenchmarkMutex(b)
+	if mu != nil {
+		mu.Lock()
+		defer mu.Unlock()
+	}
+	if ptr, err := GetFieldPointerOf(b, "hasSub"); err == nil {
+		return *(*int32)(ptr)
+	}
+	return 0
+}
+
+//Get benchmark result from the private result field in testing.B
+func GetBenchmarkResult(b *testing.B) (*testing.BenchmarkResult, error) {
+	mu := GetBenchmarkMutex(b)
+	if mu != nil {
+		mu.Lock()
+		defer mu.Unlock()
+	}
+	if ptr, err := GetFieldPointerOf(b, "result"); err == nil {
+		return (*testing.BenchmarkResult)(ptr), nil
+	} else {
+		return nil, err
+	}
+}