Support go-micro framework with v4 version (#46)

.github/workflows/plugin-tests.yaml

@@ -62,6 +62,7 @@ jobs:
           - go-restfulv3
           - gorm
           - kratosv2
+          - microv4
           - plugin_exclusion
     steps:
       - uses: actions/checkout@v2

agent/core/compile.go

@@ -34,6 +34,7 @@ import (
 	_ "sync"
 	_ "sync/atomic"
 	_ "time"
+	_ "unsafe"
 
 	//go:nolint
 	_ "github.com/apache/skywalking-go/agent/core/operator"

docs/en/agent/support-plugins.md

@@ -9,6 +9,7 @@
 * RPC Frameworks
   * `dubbo`: [Dubbo](https://github.com/apache/dubbo-go)
   * `kratosv2`: [Kratos](github.com/go-kratos/kratos)
+  * `microv4`: [Go-Micro](https://github.com/go-micro/go-micro)
 * Database Client
   * `gorm`: [GORM](https://github.com/go-gorm/gorm)
     * [MySQL Driver](https://github.com/go-gorm/mysql)

docs/en/development-and-contribution/development-guide.md

@@ -387,6 +387,26 @@ Following the previous API define, you should following these steps to use the a
 4. Once the above steps are all set, call `span.AsyncFinish()` in any goroutine.
 5. When the `span.AsyncFinish()` is complete for all spans, the all spans would be finished and report to the backend.
 
+#### Tracing Context Operation
+
+In the Go Agent, Trace Context would continue cross goroutines automatically by default.
+However, in some cases, goroutine would be context sharing due to be scheduled by the pool mechanism. Consider these advanced APIs to manipulate context and switch the current context.
+
+```go
+// CaptureContext capture current tracing context in the current goroutine.
+func CaptureContext() ContextSnapshot
+
+// ContinueContext continue the tracing context in the current goroutine.
+func ContinueContext(ctx ContextSnapshot)
+
+// CleanContext clean the tracing context in the current goroutine.
+func CleanContext()
+```
+
+Typically, use APIs as following to control or switch the context:
+1. Use `tracing.CaptureContext()` to get the ContextSnapshot object.
+2. Propagate the snapshot context to any other goroutine in your plugin.
+3. Use `tracing.ContinueContext(snapshot)` to continue the snapshot context in the target goroutine.
 
 ## Import Plugin
 

go.work

@@ -11,6 +11,7 @@ use (
 	./plugins/go-restfulv3
 	./plugins/gorm
 	./plugins/kratosv2
+	./plugins/microv4
 
 	./test/benchmark-codebase/consumer
 	./test/benchmark-codebase/provider
@@ -24,6 +25,7 @@ use (
 	./test/plugins/scenarios/go-restfulv3
 	./test/plugins/scenarios/gorm
 	./test/plugins/scenarios/kratosv2
+	./test/plugins/scenarios/microv4
 
 	./test/plugins/scenarios/plugin_exclusion
 

plugins/core/go.mod

@@ -16,7 +16,7 @@ require (
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/kr/pretty v0.3.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rogpeppe/go-internal v1.9.0 // indirect
+	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	golang.org/x/mod v0.9.0 // indirect
 	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/sys v0.8.0 // indirect

plugins/core/go.sum

@@ -68,7 +68,7 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

plugins/core/operator/common.go

@@ -22,6 +22,7 @@ var GetOperator = func() Operator { return nil }
 type Operator interface {
 	Tracing() interface{} // to TracingOperator
 	Logger() interface{}  // to LogOperator
+	Tools() interface{}   // to ToolsOperator
 	DebugStack() []byte   // Getting the stack of the current goroutine, for getting details when plugin broken.
 	Entity() interface{}  // Get the entity of the service
 }

plugins/core/operator/tools.go

@@ -0,0 +1,22 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package operator
+
+type ToolsOperator interface {
+	ReflectGetValue(instance interface{}, filters []interface{}) interface{}
+}

plugins/core/operator/tracing.go

@@ -25,4 +25,8 @@ type TracingOperator interface {
 
 	GetRuntimeContextValue(key string) interface{}
 	SetRuntimeContextValue(key string, value interface{})
+
+	CaptureContext() interface{}
+	ContinueContext(interface{})
+	CleanContext()
 }

plugins/core/span_default.go

@@ -190,5 +190,4 @@ func (ds *DefaultSpan) AsyncFinish() {
 		panic("already finished async")
 	}
 	ds.AsyncModeFinished = true
-	ds.AsyncOpLocker = nil
 }

plugins/core/span_tracing.go

@@ -101,7 +101,9 @@ func (s *SegmentSpanImpl) End() {
 		return
 	}
 	s.DefaultSpan.End(true)
-	s.end0()
+	if !s.DefaultSpan.InAsyncMode {
+		s.end0()
+	}
 }
 
 func (s *SegmentSpanImpl) AsyncFinish() {
@@ -111,11 +113,9 @@ func (s *SegmentSpanImpl) AsyncFinish() {
 }
 
 func (s *SegmentSpanImpl) end0() {
-	if !s.DefaultSpan.InAsyncMode || s.DefaultSpan.AsyncModeFinished {
-		go func() {
-			s.SegmentContext.collect <- s
-		}()
-	}
+	go func() {
+		s.SegmentContext.collect <- s
+	}()
 }
 func (s *SegmentSpanImpl) GetDefaultSpan() *DefaultSpan {
 	return &s.DefaultSpan
@@ -232,7 +232,9 @@ func (rs *RootSegmentSpan) End() {
 		return
 	}
 	rs.DefaultSpan.End(true)
-	rs.end0()
+	if !rs.InAsyncMode {
+		rs.end0()
+	}
 }
 
 func (rs *RootSegmentSpan) AsyncFinish() {
@@ -242,11 +244,9 @@ func (rs *RootSegmentSpan) AsyncFinish() {
 }
 
 func (rs *RootSegmentSpan) end0() {
-	if !rs.InAsyncMode || rs.AsyncModeFinished {
-		go func() {
-			rs.doneCh <- atomic.SwapInt32(rs.SegmentContext.refNum, -1)
-		}()
-	}
+	go func() {
+		rs.doneCh <- atomic.SwapInt32(rs.SegmentContext.refNum, -1)
+	}()
 }
 
 func (rs *RootSegmentSpan) createRootSegmentContext(ctx *TracingContext, _ SegmentSpan) (err error) {

plugins/core/tools/reflect.go

@@ -0,0 +1,58 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package tools
+
+import "github.com/apache/skywalking-go/plugins/core/operator"
+
+type ReflectFieldFilter interface {
+	Apply(interface{})
+}
+
+// GetInstanceValueByType using reflect to get the first value of instance by type
+func GetInstanceValueByType(instance interface{}, filters ...ReflectFieldFilter) interface{} {
+	if instance == nil || len(filters) == 0 {
+		return nil
+	}
+	op := operator.GetOperator()
+	if op == nil {
+		return nil
+	}
+	fs := make([]interface{}, len(filters))
+	for i, f := range filters {
+		fs[i] = f
+	}
+	return op.Tools().(operator.ToolsOperator).ReflectGetValue(instance, fs)
+}
+
+func WithFieldName(name string) ReflectFieldFilter {
+	return buildFieldFilterOption(func(s ReflectFieldFilterSetter) {
+		s.SetName(name)
+	})
+}
+
+func WithInterfaceType(typeVal interface{}) ReflectFieldFilter {
+	return buildFieldFilterOption(func(s ReflectFieldFilterSetter) {
+		s.SetInterfaceType(typeVal)
+	})
+}
+
+func WithType(typeVal interface{}) ReflectFieldFilter {
+	return buildFieldFilterOption(func(s ReflectFieldFilterSetter) {
+		s.SetType(typeVal)
+	})
+}

plugins/core/tools/reflect_bridge.go

@@ -0,0 +1,38 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package tools
+
+type ReflectFieldFilterSetter interface {
+	SetName(string)
+	SetInterfaceType(interface{})
+	SetType(interface{})
+}
+
+type fieldFilterImpl struct {
+	exe func(s ReflectFieldFilterSetter)
+}
+
+func (s *fieldFilterImpl) Apply(span interface{}) {
+	if setter, ok := span.(ReflectFieldFilterSetter); ok {
+		s.exe(setter)
+	}
+}
+
+func buildFieldFilterOption(e func(s ReflectFieldFilterSetter)) ReflectFieldFilter {
+	return &fieldFilterImpl{exe: e}
+}

plugins/core/tracer.go

@@ -44,6 +44,8 @@ type Tracer struct {
 	Log      *LogWrapper
 	// correlation *CorrelationConfig	// temporarily disable, because haven't been implemented yet
 	cdsWatchers []reporter.AgentConfigChangeWatcher
+	// for plugin tools
+	tools *TracerTools
 }
 
 func (t *Tracer) Init(entity *reporter.Entity, rep reporter.Reporter, samp Sampler, logger operator.LogOperator) error {
@@ -62,6 +64,10 @@ func (t *Tracer) Entity() interface{} {
 	return t.ServiceEntity
 }
 
+func (t *Tracer) Tools() interface{} {
+	return t.tools
+}
+
 func NewEntity(service, instanceEnvName string) *reporter.Entity {
 	instanceName := os.Getenv(instanceEnvName)
 	if instanceName == "" {
@@ -88,6 +94,7 @@ func newTracer() *Tracer {
 		Sampler:     NewConstSampler(false),
 		Log:         &LogWrapper{newDefaultLogger()},
 		cdsWatchers: make([]reporter.AgentConfigChangeWatcher, 0),
+		tools:       NewTracerTools(),
 	}
 }