Add tracer option to query service (jaegertracing#124)

cmd/query/app/handler.go

@@ -85,6 +85,7 @@ type APIHandler struct {
 	logger            *zap.Logger
 	queryParser       queryParser
 	httpPrefix        string
+	tracer            opentracing.Tracer
 }
 
 // NewAPIHandler returns an APIHandler
@@ -113,6 +114,9 @@ func NewAPIHandler(spanReader spanstore.Reader, dependencyReader dependencystore
 	if aH.logger == nil {
 		aH.logger = zap.NewNop()
 	}
+	if aH.tracer == nil {
+		aH.tracer = opentracing.NoopTracer{}
+	}
 	return aH
 }
 
@@ -138,7 +142,7 @@ func (aH *APIHandler) handleFunc(
 ) *mux.Route {
 	route = aH.route(route, args...)
 	traceMiddleware := nethttp.Middleware(
-		opentracing.GlobalTracer(),
+		aH.tracer,
 		http.HandlerFunc(f),
 		nethttp.OperationNameFunc(func(r *http.Request) string {
 			return route

cmd/query/app/handler_options.go

@@ -23,9 +23,11 @@ package app
 import (
 	"time"
 
+	"github.com/opentracing/opentracing-go"
+	"go.uber.org/zap"
+
 	"github.com/uber/jaeger/model/adjuster"
 	"github.com/uber/jaeger/storage/spanstore"
-	"go.uber.org/zap"
 )
 
 // HandlerOption is a function that sets some option on the APIHandler
@@ -78,3 +80,10 @@ func (handlerOptions) ArchiveSpanWriter(writer spanstore.Writer) HandlerOption {
 		apiHandler.archiveSpanWriter = writer
 	}
 }
+
+// Tracer creates a HandlerOption that initializes OpenTracing tracer
+func (handlerOptions) Tracer(tracer opentracing.Tracer) HandlerOption {
+	return func(apiHandler *APIHandler) {
+		apiHandler.tracer = tracer
+	}
+}

cmd/query/app/handler_test.go

@@ -33,9 +33,9 @@ import (
 	"time"
 
 	"github.com/gorilla/mux"
-	"github.com/opentracing/opentracing-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"go.uber.org/zap"
 
 	jaeger "github.com/uber/jaeger-client-go"
 	"github.com/uber/jaeger/model"
@@ -44,7 +44,6 @@ import (
 	depsmocks "github.com/uber/jaeger/storage/dependencystore/mocks"
 	"github.com/uber/jaeger/storage/spanstore"
 	spanstoremocks "github.com/uber/jaeger/storage/spanstore/mocks"
-	"go.uber.org/zap"
 )
 
 const millisToNanosMultiplier = int64(time.Millisecond / time.Nanosecond)
@@ -86,11 +85,16 @@ type structuredTraceResponse struct {
 	Errors []structuredError `json:"errors"`
 }
 
-func initializeTestServerWitHandler() (*httptest.Server, *spanstoremocks.Reader, *depsmocks.Reader, *APIHandler) {
+func initializeTestServerWithHandler(options ...HandlerOption) (*httptest.Server, *spanstoremocks.Reader, *depsmocks.Reader, *APIHandler) {
 	return initializeTestServerWithOptions(
-		HandlerOptions.Logger(zap.NewNop()),
-		HandlerOptions.Prefix(defaultHTTPPrefix),
-		HandlerOptions.QueryLookbackDuration(defaultTraceQueryLookbackDuration),
+		append(
+			[]HandlerOption{
+				HandlerOptions.Logger(zap.NewNop()),
+				HandlerOptions.Prefix(defaultHTTPPrefix),
+				HandlerOptions.QueryLookbackDuration(defaultTraceQueryLookbackDuration),
+			},
+			options...,
+		)...,
 	)
 }
 
@@ -103,8 +107,8 @@ func initializeTestServerWithOptions(options ...HandlerOption) (*httptest.Server
 	return httptest.NewServer(r), readStorage, dependencyStorage, handler
 }
 
-func initializeTestServer() (*httptest.Server, *spanstoremocks.Reader, *depsmocks.Reader) {
-	https, sr, dr, _ := initializeTestServerWitHandler()
+func initializeTestServer(options ...HandlerOption) (*httptest.Server, *spanstoremocks.Reader, *depsmocks.Reader) {
+	https, sr, dr, _ := initializeTestServerWithHandler(options...)
 	return https, sr, dr
 }
 
@@ -140,15 +144,11 @@ func TestGetTraceSuccess(t *testing.T) {
 }
 
 func TestTracing(t *testing.T) {
-	globalTracer := opentracing.GlobalTracer()
-	defer opentracing.InitGlobalTracer(globalTracer)
-
 	reporter := jaeger.NewInMemoryReporter()
 	jaegerTracer, jaegerCloser := jaeger.NewTracer("test", jaeger.NewConstSampler(true), reporter)
 	defer jaegerCloser.Close()
-	opentracing.InitGlobalTracer(jaegerTracer)
 
-	server, readMock, _ := initializeTestServer()
+	server, readMock, _ := initializeTestServer(HandlerOptions.Tracer(jaegerTracer))
 	defer server.Close()
 	readMock.On("GetTrace", mock.AnythingOfType("model.TraceID")).
 		Return(mockTrace, nil).Once()
@@ -185,7 +185,7 @@ func TestGetTraceNotFound(t *testing.T) {
 }
 
 func TestGetTraceAdjustmentFailure(t *testing.T) {
-	server, readMock, _, handler := initializeTestServerWitHandler()
+	server, readMock, _, handler := initializeTestServerWithHandler()
 	handler.adjuster = adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
 		return trace, errAdjustment
 	})

cmd/standalone/main.go

@@ -29,13 +29,14 @@ import (
 	"strconv"
 
 	"github.com/gorilla/mux"
+	"github.com/uber/jaeger-lib/metrics"
+	"github.com/uber/jaeger-lib/metrics/go-kit"
+	"github.com/uber/jaeger-lib/metrics/go-kit/expvar"
 	"github.com/uber/tchannel-go"
 	"github.com/uber/tchannel-go/thrift"
 	"go.uber.org/zap"
 
-	"github.com/uber/jaeger-lib/metrics"
-	"github.com/uber/jaeger-lib/metrics/go-kit"
-	"github.com/uber/jaeger-lib/metrics/go-kit/expvar"
+	jaegerClientConfig "github.com/uber/jaeger-client-go/config"
 	agentApp "github.com/uber/jaeger/cmd/agent/app"
 	basic "github.com/uber/jaeger/cmd/builder"
 	collector "github.com/uber/jaeger/cmd/collector/app/builder"
@@ -134,11 +135,23 @@ func startQuery(logger *zap.Logger, baseFactory metrics.Factory, memoryStore *me
 	if err != nil {
 		logger.Fatal("Failed to get dependency reader", zap.Error(err))
 	}
+	tracer, closer, err := jaegerClientConfig.Configuration{
+		Sampler: &jaegerClientConfig.SamplerConfig{
+			Type:  "probabilistic",
+			Param: 0.001,
+		},
+		RPCMetrics: true,
+	}.New("jaeger-query", jaegerClientConfig.Metrics(baseFactory))
+	if err != nil {
+		logger.Fatal("Failed to initialize tracer", zap.Error(err))
+	}
+	defer closer.Close()
 	rHandler := queryApp.NewAPIHandler(
 		spanReader,
 		dependencyReader,
 		queryApp.HandlerOptions.Prefix(*query.QueryPrefix),
-		queryApp.HandlerOptions.Logger(logger))
+		queryApp.HandlerOptions.Logger(logger),
+		queryApp.HandlerOptions.Tracer(tracer))
 	sHandler := queryApp.NewStaticAssetsHandler(*query.QueryStaticAssets)
 	r := mux.NewRouter()
 	rHandler.RegisterRoutes(r)