Add tracer sampler (#73)

README.md

@@ -32,6 +32,14 @@ if err != nil {
 }
 defer r.Close()
 tracer, err := go2sky.NewTracer("example", go2sky.WithReporter(r))
+// create with sampler
+// tracer, err := go2sky.NewTracer("example", go2sky.WithReporter(r), go2sky.WithSampler(0.5))
+```
+
+You can also create tracer with sampling rate.
+```go
+....
+tracer, err := go2sky.NewTracer("example", go2sky.WithReporter(r), go2sky.WithSampler(0.5))
 ```
 
 ## Create span

sampler.go

@@ -0,0 +1,68 @@
+// Licensed to SkyAPM org under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. SkyAPM org 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 go2sky
+
+import (
+	"math/rand"
+	"time"
+)
+
+type Sampler interface {
+	IsSampled(operation string) (sampled bool)
+}
+
+type ConstSampler struct {
+	decision bool
+}
+
+// NewConstSampler creates a ConstSampler.
+func NewConstSampler(sample bool) *ConstSampler {
+	s := &ConstSampler{
+		decision: sample,
+	}
+	return s
+}
+
+// IsSampled implements IsSampled() of Sampler.
+func (s *ConstSampler) IsSampled(operation string) bool {
+	return s.decision
+}
+
+type RandomSampler struct {
+	samplingRate float64
+	rand         *rand.Rand
+	threshold    int
+}
+
+// IsSampled implements IsSampled() of Sampler.
+func (s *RandomSampler) IsSampled(operation string) bool {
+	return s.threshold >= s.rand.Intn(100)
+}
+
+func (s *RandomSampler) init() {
+	s.rand = rand.New(rand.NewSource(time.Now().Unix()))
+	s.threshold = int(s.samplingRate * 100)
+}
+
+func NewRandomSampler(samplingRate float64) *RandomSampler {
+	s := &RandomSampler{
+		samplingRate: samplingRate,
+	}
+	s.init()
+	return s
+}

sampler_test.go

@@ -0,0 +1,47 @@
+// Licensed to SkyAPM org under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. SkyAPM org 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 go2sky
+
+import (
+	"testing"
+)
+
+func TestConstSampler_IsSampled(t *testing.T) {
+	sampler := NewConstSampler(true)
+	operationName := "op"
+	sampled := sampler.IsSampled(operationName)
+	if sampled != true {
+		t.Errorf("const sampler should be sampled")
+	}
+	samplerNegative := NewConstSampler(false)
+	sampledNegative := samplerNegative.IsSampled(operationName)
+	if sampledNegative != false {
+		t.Errorf("const sampler should not be sampled")
+	}
+}
+
+func TestRandomSampler_IsSampled(t *testing.T) {
+	randomSampler := NewRandomSampler(0.5)
+	//just for test case
+	randomSampler.threshold = 100
+	operationName := "op"
+	sampled := randomSampler.IsSampled(operationName)
+	if sampled != true {
+		t.Errorf("const sampler should be sampled")
+	}
+}

span_opts.go

@@ -35,3 +35,10 @@ func WithSpanType(spanType SpanType) SpanOption {
 		s.SpanType = spanType
 	}
 }
+
+// WithOperationName setup span OperationName of a span
+func WithOperationName(operationName string) SpanOption {
+	return func(s *defaultSpan) {
+		s.OperationName = operationName
+	}
+}

trace.go

@@ -40,6 +40,7 @@ type Tracer struct {
 	reporter Reporter
 	// 0 not init 1 init
 	initFlag int32
+	sampler  Sampler
 }
 
 // TracerOption allows for functional options to adjust behaviour
@@ -70,6 +71,10 @@ func NewTracer(service string, opts ...TracerOption) (tracer *Tracer, err error)
 		t.reporter.Boot(t.service, t.instance)
 		t.initFlag = 1
 	}
+
+	if t.sampler == nil {
+		t.sampler = NewConstSampler(true)
+	}
 	return t, nil
 }
 
@@ -93,11 +98,10 @@ func (t *Tracer) CreateEntrySpan(ctx context.Context, operationName string, extr
 			return
 		}
 	}
-	s, nCtx, err = t.CreateLocalSpan(ctx, WithContext(refSc), WithSpanType(SpanTypeEntry))
+	s, nCtx, err = t.CreateLocalSpan(ctx, WithContext(refSc), WithSpanType(SpanTypeEntry), WithOperationName(operationName))
 	if err != nil {
 		return
 	}
-	s.SetOperationName(operationName)
 	return
 }
 
@@ -117,6 +121,17 @@ func (t *Tracer) CreateLocalSpan(ctx context.Context, opts ...SpanOption) (s Spa
 	if !ok {
 		parentSpan = nil
 	}
+	isForceSample := len(ds.Refs) > 0
+	// Try to sample when it is not force sample
+	if parentSpan == nil && !isForceSample {
+		// Force sample
+		sampled := t.sampler.IsSampled(ds.OperationName)
+		if !sampled {
+			// Filter by sample just return noop span
+			s = &NoopSpan{}
+			return s, context.WithValue(ctx, ctxKeyInstance, s), nil
+		}
+	}
 	s, err = newSegmentSpan(ds, parentSpan)
 	if err != nil {
 		return nil, nil, err
@@ -132,11 +147,15 @@ func (t *Tracer) CreateExitSpan(ctx context.Context, operationName string, peer
 	if s, _ := t.createNoop(ctx); s != nil {
 		return s, nil
 	}
-	s, _, err := t.CreateLocalSpan(ctx, WithSpanType(SpanTypeExit))
+	s, _, err := t.CreateLocalSpan(ctx, WithSpanType(SpanTypeExit), WithOperationName(operationName))
 	if err != nil {
 		return nil, err
 	}
-	s.SetOperationName(operationName)
+	noopSpan, ok := interface{}(s).(NoopSpan)
+	if ok {
+		// Ignored, there is no need to inject SW8 in the request header
+		return &noopSpan, nil
+	}
 	s.SetPeer(peer)
 	spanContext := &propagation.SpanContext{}
 	span, ok := s.(ReportedSpan)

trace_opts.go

@@ -30,3 +30,19 @@ func WithInstance(instance string) TracerOption {
 		t.instance = instance
 	}
 }
+
+// WithSampler setup sampler
+func WithSampler(samplingRate float64) TracerOption {
+	return func(t *Tracer) {
+		var sampler Sampler
+		//check const sampler
+		if samplingRate <= 0 {
+			sampler = NewConstSampler(false)
+		} else if samplingRate >= 1.0 {
+			sampler = NewConstSampler(true)
+		} else {
+			sampler = NewRandomSampler(samplingRate)
+		}
+		t.sampler = sampler
+	}
+}

trace_test.go

@@ -181,7 +181,7 @@ func TestNewTracer(t *testing.T) {
 				service string
 				opts    []TracerOption
 			}{service: "test", opts: nil},
-			&Tracer{service: "test"},
+			&Tracer{service: "test", sampler: NewConstSampler(true)},
 			false,
 		},
 	}