Merge pull request src-d#166 from erizocosmico/feature/remove-tracer-impl

server: remove specific tracer implementation

Author: ajnavarro

.travis.yml

@@ -15,8 +15,6 @@ matrix:
 sudo: required
 
 install:
-  - go get -v github.com/golang/dep/...
-  - dep ensure
   - make dependencies
 
 script:

Gopkg.lock

@@ -11,8 +11,9 @@ import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 	"gopkg.in/src-d/go-mysql-server.v0/sql/parse"
 
+	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go/log"
 	"github.com/stretchr/testify/require"
-	jaeger "github.com/uber/jaeger-client-go"
 )
 
 const driverName = "engine_tests"
@@ -414,11 +415,7 @@ func TestTracing(t *testing.T) {
 	require := require.New(t)
 	e := newEngine(t)
 
-	reporter := jaeger.NewInMemoryReporter()
-	tracer, closer := jaeger.NewTracer("go-mysql-server", jaeger.NewConstSampler(true), reporter)
-	defer func() {
-		require.NoError(closer.Close())
-	}()
+	tracer := new(memTracer)
 
 	ctx := sql.NewContext(context.TODO(), sql.WithTracer(tracer))
 
@@ -433,30 +430,67 @@ func TestTracing(t *testing.T) {
 	require.Len(rows, 1)
 	require.NoError(err)
 
-	spans := reporter.GetSpans()
+	spans := tracer.spans
 
 	var expectedSpans = []string{
-		"expression.Equals",
-		"expression.Equals",
-		"expression.Equals",
-		"plan.Filter",
 		"plan.Limit",
 		"plan.Distinct",
 		"plan.Project",
 		"plan.Sort",
+		"plan.Filter",
+		"expression.Equals",
+		"expression.Equals",
+		"expression.Equals",
 	}
 
 	var spanOperations []string
 	for _, s := range spans {
-		name := s.(*jaeger.Span).OperationName()
 		// only check the ones inside the execution tree
-		if strings.HasPrefix(name, "plan.") ||
-			strings.HasPrefix(name, "expression.") ||
-			strings.HasPrefix(name, "function.") ||
-			strings.HasPrefix(name, "aggregation.") {
-			spanOperations = append(spanOperations, name)
+		if strings.HasPrefix(s, "plan.") ||
+			strings.HasPrefix(s, "expression.") ||
+			strings.HasPrefix(s, "function.") ||
+			strings.HasPrefix(s, "aggregation.") {
+			spanOperations = append(spanOperations, s)
 		}
 	}
 
 	require.Equal(expectedSpans, spanOperations)
 }
+
+type memTracer struct {
+	spans []string
+}
+
+type memSpan struct {
+	opName string
+}
+
+func (t *memTracer) StartSpan(operationName string, opts ...opentracing.StartSpanOption) opentracing.Span {
+	t.spans = append(t.spans, operationName)
+	return &memSpan{operationName}
+}
+
+func (t *memTracer) Inject(sm opentracing.SpanContext, format interface{}, carrier interface{}) error {
+	panic("not implemented")
+}
+
+func (t *memTracer) Extract(format interface{}, carrier interface{}) (opentracing.SpanContext, error) {
+	panic("not implemented")
+}
+
+func (m memSpan) Context() opentracing.SpanContext                      { return m }
+func (m memSpan) SetBaggageItem(key, val string) opentracing.Span       { return m }
+func (m memSpan) BaggageItem(key string) string                         { return "" }
+func (m memSpan) SetTag(key string, value interface{}) opentracing.Span { return m }
+func (m memSpan) LogFields(fields ...log.Field)                         {}
+func (m memSpan) LogKV(keyVals ...interface{})                          {}
+func (m memSpan) Finish()                                               {}
+func (m memSpan) FinishWithOptions(opts opentracing.FinishOptions)      {}
+func (m memSpan) SetOperationName(operationName string) opentracing.Span {
+	return &memSpan{operationName}
+}
+func (m memSpan) Tracer() opentracing.Tracer                            { return &memTracer{} }
+func (m memSpan) LogEvent(event string)                                 {}
+func (m memSpan) LogEventWithPayload(event string, payload interface{}) {}
+func (m memSpan) Log(data opentracing.LogData)                          {}
+func (m memSpan) ForeachBaggageItem(handler func(k, v string) bool)     {}