Gocheck benchmark support (#242)

* gocheck benchmark support

* go check benchmark fix in workflow

* fixes

* remove comments

* reduce nesting

Author: tonyredondo

.github/workflows/go.yml

@@ -35,6 +35,14 @@ jobs:
           SCOPE_TESTING_FAIL_RETRIES: 3
           SCOPE_TESTING_PANIC_AS_FAIL: true
 
+      - name: Go check benchmark
+        run: go test ./instrumentation/gocheck -gocheck.b -v
+        if: matrix.os == 'ubuntu-latest'
+        env:
+          SCOPE_DSN: ${{ secrets.SCOPE_DSN }}
+          SCOPE_LOGGER_ROOT: /home/runner/.scope-results
+          SCOPE_DEBUG: true
+
       - name: Upload Scope logs
         if: always()
         uses: actions/upload-artifact@v1

instrumentation/gocheck/gocheck_test.go

@@ -73,3 +73,8 @@ func (s *MySuite) TestError(c *C) {
 		c.Error("This is an error")
 	}
 }
+func (s *MySuite) BenchmarkLogic(c *C) {
+	for i := 0; i < c.N; i++ {
+		c.Assert("asd", Equals, "asd")
+	}
+}

instrumentation/gocheck/instrumentation.go

@@ -2,6 +2,7 @@ package gocheck
 
 import (
 	"context"
+	"math"
 	"reflect"
 	"testing"
 	"time"
@@ -162,3 +163,93 @@ func (test *Test) end(c *chk.C) {
 
 	test.span.FinishWithOptions(finishOptions)
 }
+
+// write the benchmark result
+func writeBenchmarkResult(method *methodType, c *chk.C, tm timer) {
+	_, _, testCode := instrumentation.GetPackageAndNameAndBoundaries(method.Info.Func.Pointer())
+
+	t := method.Info.Type.In(0)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	pName := t.Name()
+
+	testTags := opentracing.Tags{
+		"span.kind":      "test",
+		"test.name":      method.Info.Name,
+		"test.suite":     pName,
+		"test.framework": "gopkg.in/check.v1",
+		"test.language":  "go",
+		"test.type":      "benchmark",
+	}
+	opts := []opentracing.StartSpanOption{
+		testTags,
+		opentracing.StartTime(tm.start),
+	}
+
+	if testCode != "" {
+		testTags["test.code"] = testCode
+	}
+
+	span, _ := opentracing.StartSpanFromContextWithTracer(context.Background(), instrumentation.Tracer(), method.Info.Name, opts...)
+	span.SetBaggageItem("trace.kind", "test")
+	avg := math.Round((float64(tm.duration.Nanoseconds())/float64(c.N))*100) / 100
+	meanAllocsPerOp := math.Round((float64(tm.netAllocs)/float64(c.N))*100) / 100
+	meanAllocedBytesPerOp := math.Round((float64(tm.netBytes)/float64(c.N))*100) / 100
+
+	span.SetTag("benchmark.runs", c.N)
+	span.SetTag("benchmark.duration.mean", avg)
+	span.SetTag("benchmark.memory.mean_allocations", meanAllocsPerOp)
+	span.SetTag("benchmark.memory.mean_bytes_allocations", meanAllocedBytesPerOp)
+
+	reason := getTestReason(c)
+	status := getTestStatus(c)
+	switch status {
+	case testSucceeded:
+		if !getTestMustFail(c) {
+			span.SetTag("test.status", tags.TestStatus_PASS)
+			reason = ""
+		} else {
+			span.SetTag("test.status", tags.TestStatus_FAIL)
+			span.SetTag("error", true)
+		}
+	case testFailed:
+		if getTestMustFail(c) {
+			span.SetTag("test.status", tags.TestStatus_PASS)
+			reason = ""
+		} else {
+			span.SetTag("test.status", tags.TestStatus_FAIL)
+			span.SetTag("error", true)
+			if reason == "" {
+				reason = "Test failed"
+			}
+		}
+	case testSkipped:
+		span.SetTag("test.status", tags.TestStatus_SKIP)
+	case testPanicked, testFixturePanicked:
+		span.SetTag("test.status", tags.TestStatus_FAIL)
+		span.SetTag("error", true)
+	case testMissed:
+		span.SetTag("test.status", tags.TestStatus_SKIP)
+	default:
+		span.SetTag("test.status", status)
+		span.SetTag("error", true)
+	}
+
+	if reason != "" {
+		eventType := tags.EventTestFailure
+		if status == testSkipped {
+			eventType = tags.EventTestSkip
+		}
+		span.LogFields(
+			log.String(tags.EventType, eventType),
+			log.String(tags.EventMessage, reason),
+			log.String("log.internal_level", "Fatal"),
+			log.String("log.logger", "testing"),
+		)
+	}
+
+	span.FinishWithOptions(opentracing.FinishOptions{
+		FinishTime: tm.start.Add(tm.duration),
+	})
+}

instrumentation/gocheck/types.go

@@ -70,6 +70,21 @@ type (
 		benchMem                  bool
 	}
 
+	timer struct {
+		start     time.Time // Time test or benchmark started
+		duration  time.Duration
+		N         int
+		bytes     int64
+		timerOn   bool
+		benchTime time.Duration
+		// The initial states of memStats.Mallocs and memStats.TotalAlloc.
+		startAllocs uint64
+		startBytes  uint64
+		// The net total of this test after being run.
+		netAllocs uint64
+		netBytes  uint64
+	}
+
 	testStatus uint32
 
 	testData struct {
@@ -109,6 +124,9 @@ func lTestingT(testingT *testing.T)
 //go:linkname writeLog gopkg.in/check%2ev1.(*C).writeLog
 func writeLog(c *chk.C, buf []byte)
 
+//go:linkname lreportCallDone gopkg.in/check%2ev1.(*suiteRunner).reportCallDone
+func lreportCallDone(runner *suiteRunner, c *chk.C)
+
 func Init() {
 	var nSRunnerPatch *mpatch.Patch
 	var err error
@@ -122,8 +140,12 @@ func Init() {
 		r := nSRunner(suite, runConf)
 		for idx := range r.tests {
 			item := r.tests[idx]
-			tData := &testData{options: runnerOptions, writer: tWriter}
 
+			if strings.HasPrefix(item.Info.Name, "Benchmark") {
+				continue
+			}
+
+			tData := &testData{options: runnerOptions, writer: tWriter}
 			instTest := func(c *chk.C) {
 				if isTestCached(c) {
 					writeCachedResult(item)
@@ -173,6 +195,26 @@ func Init() {
 		lTestingT(testingT)
 	})
 	logOnError(err)
+
+	var lreportCallDonePatch *mpatch.Patch
+	lreportCallDonePatch, err = mpatch.PatchMethod(lreportCallDone, func(runner *suiteRunner, c *chk.C) {
+		lreportCallDonePatch.Unpatch()
+		defer lreportCallDonePatch.Patch()
+
+		if ptrMethod, err := reflection.GetFieldPointerOf(c, "method"); err == nil {
+			method := *(**methodType)(ptrMethod)
+
+			if strings.HasPrefix(method.Info.Name, "Benchmark") {
+				if ptr, err := reflection.GetFieldPointerOf(c, "timer"); err == nil {
+					tm := *(*timer)(ptr)
+					writeBenchmarkResult(method, c, tm)
+				}
+			}
+		}
+
+		lreportCallDone(runner, c)
+	})
+	logOnError(err)
 }
 
 func logOnError(err error) {