diff --git a/Makefile b/Makefile
index 7eb51691281..470433c990d 100644
--- a/Makefile
+++ b/Makefile
@@ -60,7 +60,7 @@ SWAGGER_IMAGE=quay.io/goswagger/swagger:v$(SWAGGER_VER)
 SWAGGER=docker run --rm -it -u ${shell id -u} -v "${PWD}:/go/src/" -w /go/src/ $(SWAGGER_IMAGE)
 SWAGGER_GEN_DIR=swagger-gen
 
-JAEGER_DOCKER_PROTOBUF=jaegertracing/protobuf:0.3.0
+JAEGER_DOCKER_PROTOBUF=jaegertracing/protobuf:arm64
 
 COLOR_PASS=$(shell printf "\033[32mPASS\033[0m")
 COLOR_FAIL=$(shell printf "\033[31mFAIL\033[0m")
diff --git a/cmd/query/app/apiv3/grpc_gateway_test.go b/cmd/query/app/apiv3/grpc_gateway_test.go
index eb11a885ca9..5d1bdc4148b 100644
--- a/cmd/query/app/apiv3/grpc_gateway_test.go
+++ b/cmd/query/app/apiv3/grpc_gateway_test.go
@@ -114,7 +114,7 @@ func testGRPCGatewayWithTenancy(t *testing.T, basePath string, serverTLS tlscfg.
 	defer httpServer.Shutdown(context.Background())
 
 	traceID := model.NewTraceID(150, 160)
-	reader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).Return(
+	reader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("spanstore.TraceIDQueryParameters")).Return(
 		&model.Trace{
 			Spans: []*model.Span{
 				{
@@ -197,7 +197,7 @@ func TestTenancyGRPCRejection(t *testing.T) {
 	defer httpServer.Shutdown(context.Background())
 
 	traceID := model.NewTraceID(150, 160)
-	reader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).Return(
+	reader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("spanstore.TraceIDQueryParameters")).Return(
 		&model.Trace{
 			Spans: []*model.Span{
 				{
diff --git a/cmd/query/app/apiv3/grpc_handler.go b/cmd/query/app/apiv3/grpc_handler.go
index a9659f1e84d..efc34f69ef1 100644
--- a/cmd/query/app/apiv3/grpc_handler.go
+++ b/cmd/query/app/apiv3/grpc_handler.go
@@ -42,7 +42,21 @@ func (h *Handler) GetTrace(request *api_v3.GetTraceRequest, stream api_v3.QueryS
 		return err
 	}
 
-	trace, err := h.QueryService.GetTrace(stream.Context(), traceID)
+	start, err := types.TimestampFromProto(request.GetStart())
+	if err != nil {
+		return err
+	}
+
+	end, err := types.TimestampFromProto(request.GetStart())
+	if err != nil {
+		return err
+	}
+
+	trace, err := h.QueryService.GetTrace(stream.Context(), &spanstore.TraceIDQueryParameters{
+		ID:    traceID,
+		Start: start,
+		End:   end,
+	})
 	if err != nil {
 		return err
 	}
diff --git a/cmd/query/app/apiv3/grpc_handler_test.go b/cmd/query/app/apiv3/grpc_handler_test.go
index d22f3f89c18..37a85fce780 100644
--- a/cmd/query/app/apiv3/grpc_handler_test.go
+++ b/cmd/query/app/apiv3/grpc_handler_test.go
@@ -51,7 +51,7 @@ func newGrpcServer(t *testing.T, handler *Handler) (*grpc.Server, net.Addr) {
 
 func TestGetTrace(t *testing.T) {
 	r := &spanstoremocks.Reader{}
-	r.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).Return(
+	r.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).Return(
 		&model.Trace{
 			Spans: []*model.Span{
 				{
@@ -83,7 +83,7 @@ func TestGetTrace(t *testing.T) {
 
 func TestGetTrace_storage_error(t *testing.T) {
 	r := &spanstoremocks.Reader{}
-	r.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).Return(
+	r.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("spanstore.TraceIDQueryParameters")).Return(
 		nil, fmt.Errorf("storage_error")).Once()
 
 	q := querysvc.NewQueryService(r, &dependencyStoreMocks.Reader{}, querysvc.QueryServiceOptions{})
diff --git a/cmd/query/app/grpc_handler.go b/cmd/query/app/grpc_handler.go
index 441d1b4d3c3..345f8b57c5e 100644
--- a/cmd/query/app/grpc_handler.go
+++ b/cmd/query/app/grpc_handler.go
@@ -67,7 +67,9 @@ func (g *GRPCHandler) GetTrace(r *api_v2.GetTraceRequest, stream api_v2.QuerySer
 	if r.TraceID == (model.TraceID{}) {
 		return errUninitializedTraceID
 	}
-	trace, err := g.queryService.GetTrace(stream.Context(), r.TraceID)
+	trace, err := g.queryService.GetTrace(stream.Context(), &spanstore.TraceIDQueryParameters{
+		ID: r.TraceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		g.logger.Error(msgTraceNotFound, zap.Error(err))
 		return status.Errorf(codes.NotFound, "%s: %v", msgTraceNotFound, err)
@@ -87,7 +89,9 @@ func (g *GRPCHandler) ArchiveTrace(ctx context.Context, r *api_v2.ArchiveTraceRe
 	if r.TraceID == (model.TraceID{}) {
 		return nil, errUninitializedTraceID
 	}
-	err := g.queryService.ArchiveTrace(ctx, r.TraceID)
+	err := g.queryService.ArchiveTrace(ctx, &spanstore.TraceIDQueryParameters{
+		ID: r.TraceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		g.logger.Error("trace not found", zap.Error(err))
 		return nil, status.Errorf(codes.NotFound, "%s: %v", msgTraceNotFound, err)
diff --git a/cmd/query/app/grpc_handler_test.go b/cmd/query/app/grpc_handler_test.go
index 8384bafb40b..6f08030dd49 100644
--- a/cmd/query/app/grpc_handler_test.go
+++ b/cmd/query/app/grpc_handler_test.go
@@ -213,7 +213,7 @@ func withServerAndClient(t *testing.T, actualTest func(server *grpcServer, clien
 
 func TestGetTraceSuccessGRPC(t *testing.T) {
 	withServerAndClient(t, func(server *grpcServer, client *grpcClient) {
-		server.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+		server.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 			Return(mockTrace, nil).Once()
 
 		res, err := client.GetTrace(context.Background(), &api_v2.GetTraceRequest{
diff --git a/cmd/query/app/http_handler.go b/cmd/query/app/http_handler.go
index 3e09895d37b..54a04584315 100644
--- a/cmd/query/app/http_handler.go
+++ b/cmd/query/app/http_handler.go
@@ -265,7 +265,9 @@ func (aH *APIHandler) tracesByIDs(ctx context.Context, traceIDs []model.TraceID)
 	var errors []structuredError
 	retMe := make([]*model.Trace, 0, len(traceIDs))
 	for _, traceID := range traceIDs {
-		if trace, err := aH.queryService.GetTrace(ctx, traceID); err != nil {
+		if trace, err := aH.queryService.GetTrace(ctx, &spanstore.TraceIDQueryParameters{
+			ID: traceID,
+		}); err != nil {
 			if err != spanstore.ErrTraceNotFound {
 				return nil, nil, err
 			}
@@ -428,7 +430,9 @@ func (aH *APIHandler) getTrace(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
-	trace, err := aH.queryService.GetTrace(r.Context(), traceID)
+	trace, err := aH.queryService.GetTrace(r.Context(), &spanstore.TraceIDQueryParameters{
+		ID: traceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		aH.handleError(w, err, http.StatusNotFound)
 		return
@@ -467,7 +471,9 @@ func (aH *APIHandler) archiveTrace(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// QueryService.ArchiveTrace can now archive this traceID.
-	err := aH.queryService.ArchiveTrace(r.Context(), traceID)
+	err := aH.queryService.ArchiveTrace(r.Context(), &spanstore.TraceIDQueryParameters{
+		ID: traceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		aH.handleError(w, err, http.StatusNotFound)
 		return
diff --git a/cmd/query/app/querysvc/query_service.go b/cmd/query/app/querysvc/query_service.go
index 7dde2813cae..de4eb95c8ee 100644
--- a/cmd/query/app/querysvc/query_service.go
+++ b/cmd/query/app/querysvc/query_service.go
@@ -63,13 +63,13 @@ func NewQueryService(spanReader spanstore.Reader, dependencyReader dependencysto
 }
 
 // GetTrace is the queryService implementation of spanstore.Reader.GetTrace
-func (qs QueryService) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
-	trace, err := qs.spanReader.GetTrace(ctx, traceID)
+func (qs QueryService) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
+	trace, err := qs.spanReader.GetTrace(ctx, query)
 	if err == spanstore.ErrTraceNotFound {
 		if qs.options.ArchiveSpanReader == nil {
 			return nil, err
 		}
-		trace, err = qs.options.ArchiveSpanReader.GetTrace(ctx, traceID)
+		trace, err = qs.options.ArchiveSpanReader.GetTrace(ctx, query)
 	}
 	return trace, err
 }
@@ -93,11 +93,11 @@ func (qs QueryService) FindTraces(ctx context.Context, query *spanstore.TraceQue
 }
 
 // ArchiveTrace is the queryService utility to archive traces.
-func (qs QueryService) ArchiveTrace(ctx context.Context, traceID model.TraceID) error {
+func (qs QueryService) ArchiveTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) error {
 	if qs.options.ArchiveSpanWriter == nil {
 		return errNoArchiveSpanStorage
 	}
-	trace, err := qs.GetTrace(ctx, traceID)
+	trace, err := qs.GetTrace(ctx, query)
 	if err != nil {
 		return err
 	}
diff --git a/cmd/query/app/querysvc/query_service_test.go b/cmd/query/app/querysvc/query_service_test.go
index ee214c33ea2..73d7aeef9a0 100644
--- a/cmd/query/app/querysvc/query_service_test.go
+++ b/cmd/query/app/querysvc/query_service_test.go
@@ -116,12 +116,14 @@ func initializeTestService(optionAppliers ...testOption) *testQueryService {
 // Test QueryService.GetTrace()
 func TestGetTraceSuccess(t *testing.T) {
 	tqs := initializeTestService()
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(mockTrace, nil).Once()
 
 	type contextKey string
 	ctx := context.Background()
-	res, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	res, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.NoError(t, err)
 	assert.Equal(t, res, mockTrace)
 }
@@ -129,26 +131,30 @@ func TestGetTraceSuccess(t *testing.T) {
 // Test QueryService.GetTrace() without ArchiveSpanReader
 func TestGetTraceNotFound(t *testing.T) {
 	tqs := initializeTestService()
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(nil, spanstore.ErrTraceNotFound).Once()
 
 	type contextKey string
 	ctx := context.Background()
-	_, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	_, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.Equal(t, err, spanstore.ErrTraceNotFound)
 }
 
 // Test QueryService.GetTrace() with ArchiveSpanReader
 func TestGetTraceFromArchiveStorage(t *testing.T) {
 	tqs := initializeTestService(withArchiveSpanReader())
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(nil, spanstore.ErrTraceNotFound).Once()
-	tqs.archiveSpanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.archiveSpanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(mockTrace, nil).Once()
 
 	type contextKey string
 	ctx := context.Background()
-	res, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	res, err := tqs.queryService.GetTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.NoError(t, err)
 	assert.Equal(t, res, mockTrace)
 }
@@ -211,35 +217,41 @@ func TestArchiveTraceNoOptions(t *testing.T) {
 
 	type contextKey string
 	ctx := context.Background()
-	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.Equal(t, errNoArchiveSpanStorage, err)
 }
 
 // Test QueryService.ArchiveTrace() with ArchiveSpanWriter but invalid traceID.
 func TestArchiveTraceWithInvalidTraceID(t *testing.T) {
 	tqs := initializeTestService(withArchiveSpanReader(), withArchiveSpanWriter())
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(nil, spanstore.ErrTraceNotFound).Once()
-	tqs.archiveSpanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.archiveSpanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(nil, spanstore.ErrTraceNotFound).Once()
 
 	type contextKey string
 	ctx := context.Background()
-	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.Equal(t, spanstore.ErrTraceNotFound, err)
 }
 
 // Test QueryService.ArchiveTrace(), save error with ArchiveSpanWriter.
 func TestArchiveTraceWithArchiveWriterError(t *testing.T) {
 	tqs := initializeTestService(withArchiveSpanWriter())
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(mockTrace, nil).Once()
 	tqs.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")).
 		Return(errors.New("cannot save")).Times(2)
 
 	type contextKey string
 	ctx := context.Background()
-	joinErr := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	joinErr := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	// There are two spans in the mockTrace, ArchiveTrace should return a wrapped error.
 	assert.EqualError(t, joinErr, "cannot save\ncannot save")
 }
@@ -247,14 +259,16 @@ func TestArchiveTraceWithArchiveWriterError(t *testing.T) {
 // Test QueryService.ArchiveTrace() with correctly configured ArchiveSpanWriter.
 func TestArchiveTraceSuccess(t *testing.T) {
 	tqs := initializeTestService(withArchiveSpanWriter())
-	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("model.TraceID")).
+	tqs.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceIDQueryParameters")).
 		Return(mockTrace, nil).Once()
 	tqs.archiveSpanWriter.On("WriteSpan", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*model.Span")).
 		Return(nil).Times(2)
 
 	type contextKey string
 	ctx := context.Background()
-	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), mockTraceID)
+	err := tqs.queryService.ArchiveTrace(context.WithValue(ctx, contextKey("foo"), "bar"), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.NoError(t, err)
 }
 
diff --git a/plugin/storage/badger/spanstore/read_write_test.go b/plugin/storage/badger/spanstore/read_write_test.go
index 064419dd761..dac7431bbe7 100644
--- a/plugin/storage/badger/spanstore/read_write_test.go
+++ b/plugin/storage/badger/spanstore/read_write_test.go
@@ -79,9 +79,11 @@ func TestWriteReadBack(t *testing.T) {
 		}
 
 		for i := 0; i < traces; i++ {
-			tr, err := sr.GetTrace(context.Background(), model.TraceID{
-				Low:  uint64(i),
-				High: 1,
+			tr, err := sr.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+				ID: model.TraceID{
+					Low:  uint64(i),
+					High: 1,
+				},
 			})
 			assert.NoError(t, err)
 
@@ -302,7 +304,9 @@ func TestFindNothing(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Len(t, trs, 0)
 
-		tr, err := sr.GetTrace(context.Background(), model.TraceID{High: 0, Low: 0})
+		tr, err := sr.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{High: 0, Low: 0},
+		})
 		assert.Equal(t, spanstore.ErrTraceNotFound, err)
 		assert.Nil(t, tr)
 	})
@@ -431,9 +435,11 @@ func TestPersist(t *testing.T) {
 	})
 
 	p(t, dir, func(t *testing.T, sw spanstore.Writer, sr spanstore.Reader) {
-		trace, err := sr.GetTrace(context.Background(), model.TraceID{
-			Low:  uint64(1),
-			High: 1,
+		trace, err := sr.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{
+				Low:  uint64(1),
+				High: 1,
+			},
 		})
 		assert.NoError(t, err)
 		assert.Equal(t, "operation-p", trace.Spans[0].OperationName)
diff --git a/plugin/storage/badger/spanstore/reader.go b/plugin/storage/badger/spanstore/reader.go
index 2a22ff41193..1e8f70d436b 100644
--- a/plugin/storage/badger/spanstore/reader.go
+++ b/plugin/storage/badger/spanstore/reader.go
@@ -157,8 +157,8 @@ func (r *TraceReader) getTraces(traceIDs []model.TraceID) ([]*model.Trace, error
 }
 
 // GetTrace takes a traceID and returns a Trace associated with that traceID
-func (r *TraceReader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
-	traces, err := r.getTraces([]model.TraceID{traceID})
+func (r *TraceReader) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
+	traces, err := r.getTraces([]model.TraceID{query.ID})
 	if err != nil {
 		return nil, err
 	}
diff --git a/plugin/storage/badger/spanstore/rw_internal_test.go b/plugin/storage/badger/spanstore/rw_internal_test.go
index f706f97c653..9378b70cde6 100644
--- a/plugin/storage/badger/spanstore/rw_internal_test.go
+++ b/plugin/storage/badger/spanstore/rw_internal_test.go
@@ -40,7 +40,9 @@ func TestEncodingTypes(t *testing.T) {
 		err := sw.WriteSpan(context.Background(), &testSpan)
 		assert.NoError(t, err)
 
-		tr, err := rw.GetTrace(context.Background(), model.TraceID{Low: 0, High: 1})
+		tr, err := rw.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{Low: 0, High: 1},
+		})
 		assert.NoError(t, err)
 		assert.Equal(t, 1, len(tr.Spans))
 	})
@@ -83,7 +85,9 @@ func TestEncodingTypes(t *testing.T) {
 			return nil
 		})
 
-		_, err = rw.GetTrace(context.Background(), model.TraceID{Low: 0, High: 1})
+		_, err = rw.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{Low: 0, High: 1},
+		})
 		assert.EqualError(t, err, "unknown encoding type: 0x04")
 	})
 }
diff --git a/plugin/storage/cassandra/savetracetest/main.go b/plugin/storage/cassandra/savetracetest/main.go
index 8b28858b3e4..3569221596e 100644
--- a/plugin/storage/cassandra/savetracetest/main.go
+++ b/plugin/storage/cassandra/savetracetest/main.go
@@ -53,7 +53,9 @@ func main() {
 		logger.Info("Saved span", zap.String("spanID", getSomeSpan().SpanID.String()))
 	}
 	s := getSomeSpan()
-	trace, err := spanReader.GetTrace(ctx, s.TraceID)
+	trace, err := spanReader.GetTrace(ctx, &spanstore.TraceIDQueryParameters{
+		ID: s.TraceID,
+	})
 	if err != nil {
 		logger.Fatal("Failed to read", zap.Error(err))
 	} else {
diff --git a/plugin/storage/cassandra/spanstore/reader.go b/plugin/storage/cassandra/spanstore/reader.go
index 621e327a41c..ba5d0c1fa4a 100644
--- a/plugin/storage/cassandra/spanstore/reader.go
+++ b/plugin/storage/cassandra/spanstore/reader.go
@@ -208,8 +208,8 @@ func (s *SpanReader) readTraceInSpan(ctx context.Context, traceID dbmodel.TraceI
 }
 
 // GetTrace takes a traceID and returns a Trace associated with that traceID
-func (s *SpanReader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
-	return s.readTrace(ctx, dbmodel.TraceIDFromDomain(traceID))
+func (s *SpanReader) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
+	return s.readTrace(ctx, dbmodel.TraceIDFromDomain(query.ID))
 }
 
 func validateQuery(p *spanstore.TraceQueryParameters) error {
@@ -242,7 +242,9 @@ func (s *SpanReader) FindTraces(ctx context.Context, traceQuery *spanstore.Trace
 	}
 	var retMe []*model.Trace
 	for _, traceID := range uniqueTraceIDs {
-		jTrace, err := s.GetTrace(ctx, traceID)
+		jTrace, err := s.GetTrace(ctx, &spanstore.TraceIDQueryParameters{
+			ID: traceID,
+		})
 		if err != nil {
 			s.logger.Error("Failure to read trace", zap.String("trace_id", traceID.String()), zap.Error(err))
 			continue
diff --git a/plugin/storage/cassandra/spanstore/reader_test.go b/plugin/storage/cassandra/spanstore/reader_test.go
index 83e509f361b..70bc7b5677a 100644
--- a/plugin/storage/cassandra/spanstore/reader_test.go
+++ b/plugin/storage/cassandra/spanstore/reader_test.go
@@ -133,7 +133,9 @@ func TestSpanReaderGetTrace(t *testing.T) {
 
 				r.session.On("Query", mock.AnythingOfType("string"), matchEverything()).Return(query)
 
-				trace, err := r.reader.GetTrace(context.Background(), model.TraceID{})
+				trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+					ID: model.TraceID{},
+				})
 				if testCase.expectedErr == "" {
 					assert.NoError(t, err)
 					assert.NotNil(t, trace)
@@ -159,7 +161,9 @@ func TestSpanReaderGetTrace_TraceNotFound(t *testing.T) {
 
 		r.session.On("Query", mock.AnythingOfType("string"), matchEverything()).Return(query)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.TraceID{})
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{},
+		})
 		assert.Nil(t, trace)
 		assert.EqualError(t, err, "trace not found")
 	})
diff --git a/plugin/storage/es/spanstore/reader.go b/plugin/storage/es/spanstore/reader.go
index 0d6ccaa7c29..bccf1bac4a5 100644
--- a/plugin/storage/es/spanstore/reader.go
+++ b/plugin/storage/es/spanstore/reader.go
@@ -238,11 +238,11 @@ func indexNames(prefix, index string) string {
 }
 
 // GetTrace takes a traceID and returns a Trace associated with that traceID
-func (s *SpanReader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
+func (s *SpanReader) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
 	span, ctx := opentracing.StartSpanFromContext(ctx, "GetTrace")
 	defer span.Finish()
 	currentTime := time.Now()
-	traces, err := s.multiRead(ctx, []model.TraceID{traceID}, currentTime.Add(-s.maxSpanAge), currentTime)
+	traces, err := s.multiRead(ctx, []model.TraceID{query.ID}, currentTime.Add(-s.maxSpanAge), currentTime)
 	if err != nil {
 		return nil, err
 	}
diff --git a/plugin/storage/es/spanstore/reader_test.go b/plugin/storage/es/spanstore/reader_test.go
index c581a423d1e..4c743bdcf00 100644
--- a/plugin/storage/es/spanstore/reader_test.go
+++ b/plugin/storage/es/spanstore/reader_test.go
@@ -306,7 +306,9 @@ func TestSpanReader_GetTrace(t *testing.T) {
 				},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.NoError(t, err)
 		require.NotNil(t, trace)
 
@@ -419,7 +421,9 @@ func TestSpanReader_SearchAfter(t *testing.T) {
 				},
 			}, nil).Times(2)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.NoError(t, err)
 		require.NotNil(t, trace)
 
@@ -438,7 +442,9 @@ func TestSpanReader_GetTraceQueryError(t *testing.T) {
 			Return(&elastic.MultiSearchResult{
 				Responses: []*elastic.SearchResult{},
 			}, nil)
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.EqualError(t, err, "trace not found")
 		require.Nil(t, trace)
 	})
@@ -457,7 +463,9 @@ func TestSpanReader_GetTraceNilHits(t *testing.T) {
 				},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.EqualError(t, err, "trace not found")
 		require.Nil(t, trace)
 	})
@@ -480,7 +488,9 @@ func TestSpanReader_GetTraceInvalidSpanError(t *testing.T) {
 				},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.Error(t, err, "invalid span")
 		require.Nil(t, trace)
 	})
@@ -504,7 +514,9 @@ func TestSpanReader_GetTraceSpanConversionError(t *testing.T) {
 				},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.NewTraceID(0, 1))
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.Error(t, err, "span conversion error, because lacks elements")
 		require.Nil(t, trace)
 	})
@@ -1233,7 +1245,9 @@ func TestSpanReader_ArchiveTraces(t *testing.T) {
 				Responses: []*elastic.SearchResult{},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.TraceID{})
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.Nil(t, trace)
 		assert.EqualError(t, err, "trace not found")
 	})
@@ -1248,7 +1262,9 @@ func TestSpanReader_ArchiveTraces_ReadAlias(t *testing.T) {
 				Responses: []*elastic.SearchResult{},
 			}, nil)
 
-		trace, err := r.reader.GetTrace(context.Background(), model.TraceID{})
+		trace, err := r.reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.NewTraceID(0, 1),
+		})
 		require.Nil(t, trace)
 		assert.EqualError(t, err, "trace not found")
 	})
diff --git a/plugin/storage/grpc/shared/archive.go b/plugin/storage/grpc/shared/archive.go
index 41741e7b950..af30fcd87fe 100644
--- a/plugin/storage/grpc/shared/archive.go
+++ b/plugin/storage/grpc/shared/archive.go
@@ -43,9 +43,9 @@ type archiveWriter struct {
 }
 
 // GetTrace takes a traceID and returns a Trace associated with that traceID from Archive Storage
-func (r *archiveReader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
+func (r *archiveReader) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
 	stream, err := r.client.GetArchiveTrace(upgradeContext(ctx), &storage_v1.GetTraceRequest{
-		TraceID: traceID,
+		TraceID: query.ID,
 	})
 	if status.Code(err) == codes.NotFound {
 		return nil, spanstore.ErrTraceNotFound
diff --git a/plugin/storage/grpc/shared/archive_test.go b/plugin/storage/grpc/shared/archive_test.go
index bad217c90e9..7e8b14e3ba4 100644
--- a/plugin/storage/grpc/shared/archive_test.go
+++ b/plugin/storage/grpc/shared/archive_test.go
@@ -69,7 +69,9 @@ func TestArchiveReader_GetTrace(t *testing.T) {
 	}).Return(traceClient, nil)
 	reader := &archiveReader{client: archiveSpanReader}
 
-	trace, err := reader.GetTrace(context.Background(), mockTraceID)
+	trace, err := reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.NoError(t, err)
 	assert.Equal(t, expected, trace)
 }
@@ -83,7 +85,9 @@ func TestArchiveReaderGetTrace_NoTrace(t *testing.T) {
 	}).Return(nil, status.Errorf(codes.NotFound, ""))
 	reader := &archiveReader{client: archiveSpanReader}
 
-	_, err := reader.GetTrace(context.Background(), mockTraceID)
+	_, err := reader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: mockTraceID,
+	})
 	assert.Equal(t, spanstore.ErrTraceNotFound, err)
 }
 
diff --git a/plugin/storage/grpc/shared/grpc_client.go b/plugin/storage/grpc/shared/grpc_client.go
index 4d230cec9af..cfda1aa5201 100644
--- a/plugin/storage/grpc/shared/grpc_client.go
+++ b/plugin/storage/grpc/shared/grpc_client.go
@@ -125,9 +125,9 @@ func (c *grpcClient) ArchiveSpanWriter() spanstore.Writer {
 }
 
 // GetTrace takes a traceID and returns a Trace associated with that traceID
-func (c *grpcClient) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
+func (c *grpcClient) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
 	stream, err := c.readerClient.GetTrace(upgradeContext(ctx), &storage_v1.GetTraceRequest{
-		TraceID: traceID,
+		TraceID: query.ID,
 	})
 	if status.Code(err) == codes.NotFound {
 		return nil, spanstore.ErrTraceNotFound
diff --git a/plugin/storage/grpc/shared/grpc_client_test.go b/plugin/storage/grpc/shared/grpc_client_test.go
index 010bf578a0b..232b384d4f0 100644
--- a/plugin/storage/grpc/shared/grpc_client_test.go
+++ b/plugin/storage/grpc/shared/grpc_client_test.go
@@ -199,7 +199,9 @@ func TestGRPCClientGetTrace(t *testing.T) {
 			expectedSpans = append(expectedSpans, &mockTraceSpans[i])
 		}
 
-		s, err := r.client.GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.NoError(t, err)
 		assert.Equal(t, &model.Trace{
 			Spans: expectedSpans,
@@ -215,7 +217,9 @@ func TestGRPCClientGetTrace_StreamError(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(traceClient, nil)
 
-		s, err := r.client.GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Error(t, err)
 		assert.Nil(t, s)
 	})
@@ -227,7 +231,9 @@ func TestGRPCClientGetTrace_NoTrace(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(nil, status.Errorf(codes.NotFound, ""))
 
-		s, err := r.client.GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Equal(t, spanstore.ErrTraceNotFound, err)
 		assert.Nil(t, s)
 	})
@@ -243,7 +249,9 @@ func TestGRPCClientGetTrace_StreamErrorTraceNotFound(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(traceClient, nil)
 
-		s, err := r.client.GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Equal(t, spanstore.ErrTraceNotFound, err)
 		assert.Nil(t, s)
 	})
@@ -406,7 +414,9 @@ func TestGrpcClientGetArchiveTrace(t *testing.T) {
 			expectedSpans = append(expectedSpans, &mockTraceSpans[i])
 		}
 
-		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.NoError(t, err)
 		assert.Equal(t, &model.Trace{
 			Spans: expectedSpans,
@@ -422,7 +432,9 @@ func TestGrpcClientGetArchiveTrace_StreamError(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(traceClient, nil)
 
-		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Error(t, err)
 		assert.Nil(t, s)
 	})
@@ -434,7 +446,9 @@ func TestGrpcClientGetArchiveTrace_NoTrace(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(nil, spanstore.ErrTraceNotFound)
 
-		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Error(t, err)
 		assert.Nil(t, s)
 	})
@@ -448,7 +462,9 @@ func TestGrpcClientGetArchiveTrace_StreamErrorTraceNotFound(t *testing.T) {
 			TraceID: mockTraceID,
 		}).Return(traceClient, nil)
 
-		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), mockTraceID)
+		s, err := r.client.ArchiveSpanReader().GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		})
 		assert.Equal(t, spanstore.ErrTraceNotFound, err)
 		assert.Nil(t, s)
 	})
diff --git a/plugin/storage/grpc/shared/grpc_handler.go b/plugin/storage/grpc/shared/grpc_handler.go
index 32c1434d2ef..73db72d254f 100644
--- a/plugin/storage/grpc/shared/grpc_handler.go
+++ b/plugin/storage/grpc/shared/grpc_handler.go
@@ -149,7 +149,9 @@ func (s *GRPCHandler) Close(ctx context.Context, r *storage_v1.CloseWriterReques
 
 // GetTrace takes a traceID and streams a Trace associated with that traceID
 func (s *GRPCHandler) GetTrace(r *storage_v1.GetTraceRequest, stream storage_v1.SpanReaderPlugin_GetTraceServer) error {
-	trace, err := s.impl.SpanReader().GetTrace(stream.Context(), r.TraceID)
+	trace, err := s.impl.SpanReader().GetTrace(stream.Context(), &spanstore.TraceIDQueryParameters{
+		ID: r.TraceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		return status.Errorf(codes.NotFound, spanstore.ErrTraceNotFound.Error())
 	}
@@ -274,7 +276,9 @@ func (s *GRPCHandler) GetArchiveTrace(r *storage_v1.GetTraceRequest, stream stor
 	if reader == nil {
 		return status.Error(codes.Unimplemented, "not implemented")
 	}
-	trace, err := reader.GetTrace(stream.Context(), r.TraceID)
+	trace, err := reader.GetTrace(stream.Context(), &spanstore.TraceIDQueryParameters{
+		ID: r.TraceID,
+	})
 	if err == spanstore.ErrTraceNotFound {
 		return status.Errorf(codes.NotFound, spanstore.ErrTraceNotFound.Error())
 	}
diff --git a/plugin/storage/grpc/shared/grpc_handler_test.go b/plugin/storage/grpc/shared/grpc_handler_test.go
index 0ca6629f038..689624c3e0c 100644
--- a/plugin/storage/grpc/shared/grpc_handler_test.go
+++ b/plugin/storage/grpc/shared/grpc_handler_test.go
@@ -144,7 +144,9 @@ func TestGRPCServerGetTrace(t *testing.T) {
 		for i := range mockTraceSpans {
 			traceSpans = append(traceSpans, &mockTraceSpans[i])
 		}
-		r.impl.spanReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.spanReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(&model.Trace{Spans: traceSpans}, nil)
 
 		err := r.server.GetTrace(&storage_v1.GetTraceRequest{
@@ -159,7 +161,9 @@ func TestGRPCServerGetTrace_NotFound(t *testing.T) {
 		traceSteam := new(grpcMocks.SpanReaderPlugin_GetTraceServer)
 		traceSteam.On("Context").Return(context.Background())
 
-		r.impl.spanReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.spanReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(nil, spanstore.ErrTraceNotFound)
 
 		err := r.server.GetTrace(&storage_v1.GetTraceRequest{
@@ -292,7 +296,9 @@ func TestGRPCServerGetArchiveTrace(t *testing.T) {
 		for i := range mockTraceSpans {
 			traceSpans = append(traceSpans, &mockTraceSpans[i])
 		}
-		r.impl.archiveReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.archiveReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(&model.Trace{Spans: traceSpans}, nil)
 
 		err := r.server.GetArchiveTrace(&storage_v1.GetTraceRequest{
@@ -307,7 +313,9 @@ func TestGRPCServerGetArchiveTrace_NotFound(t *testing.T) {
 		traceSteam := new(grpcMocks.SpanReaderPlugin_GetTraceServer)
 		traceSteam.On("Context").Return(context.Background())
 
-		r.impl.archiveReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.archiveReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(nil, spanstore.ErrTraceNotFound)
 
 		err := r.server.GetArchiveTrace(&storage_v1.GetTraceRequest{
@@ -322,7 +330,9 @@ func TestGRPCServerGetArchiveTrace_Error(t *testing.T) {
 		traceSteam := new(grpcMocks.SpanReaderPlugin_GetTraceServer)
 		traceSteam.On("Context").Return(context.Background())
 
-		r.impl.archiveReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.archiveReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(nil, fmt.Errorf("some error"))
 
 		err := r.server.GetArchiveTrace(&storage_v1.GetTraceRequest{
@@ -337,7 +347,9 @@ func TestGRPCServerGetArchiveTrace_NoImpl(t *testing.T) {
 		r.server.impl.ArchiveSpanReader = func() spanstore.Reader { return nil }
 		traceSteam := new(grpcMocks.SpanReaderPlugin_GetTraceServer)
 
-		r.impl.archiveReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.archiveReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(nil, fmt.Errorf("some error"))
 
 		err := r.server.GetArchiveTrace(&storage_v1.GetTraceRequest{
@@ -358,7 +370,9 @@ func TestGRPCServerGetArchiveTrace_StreamError(t *testing.T) {
 		for i := range mockTraceSpans {
 			traceSpans = append(traceSpans, &mockTraceSpans[i])
 		}
-		r.impl.archiveReader.On("GetTrace", mock.Anything, mockTraceID).
+		r.impl.archiveReader.On("GetTrace", mock.Anything, &spanstore.TraceIDQueryParameters{
+			ID: mockTraceID,
+		}).
 			Return(&model.Trace{Spans: traceSpans}, nil)
 
 		err := r.server.GetArchiveTrace(&storage_v1.GetTraceRequest{
diff --git a/plugin/storage/integration/elasticsearch_test.go b/plugin/storage/integration/elasticsearch_test.go
index 9d2ec031b1f..237c0cde6c0 100644
--- a/plugin/storage/integration/elasticsearch_test.go
+++ b/plugin/storage/integration/elasticsearch_test.go
@@ -38,6 +38,7 @@ import (
 	"github.com/jaegertracing/jaeger/plugin/storage/es/dependencystore"
 	"github.com/jaegertracing/jaeger/plugin/storage/es/mappings"
 	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore"
+	jaegerSpanStore "github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
 const (
@@ -256,7 +257,9 @@ func (s *StorageIntegration) testArchiveTrace(t *testing.T) {
 	var actual *model.Trace
 	found := s.waitForCondition(t, func(t *testing.T) bool {
 		var err error
-		actual, err = s.SpanReader.GetTrace(context.Background(), tID)
+		actual, err = s.SpanReader.GetTrace(context.Background(), &jaegerSpanStore.TraceIDQueryParameters{
+			ID: tID,
+		})
 		return err == nil && len(actual.Spans) == 1
 	})
 	if !assert.True(t, found) {
diff --git a/plugin/storage/integration/integration.go b/plugin/storage/integration/integration.go
index 3c965f45751..1afbffae118 100644
--- a/plugin/storage/integration/integration.go
+++ b/plugin/storage/integration/integration.go
@@ -143,7 +143,9 @@ func (s *StorageIntegration) testGetLargeSpan(t *testing.T) {
 	var actual *model.Trace
 	found := s.waitForCondition(t, func(t *testing.T) bool {
 		var err error
-		actual, err = s.SpanReader.GetTrace(context.Background(), expectedTraceID)
+		actual, err = s.SpanReader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: expectedTraceID,
+		})
 		return err == nil && len(actual.Spans) == len(expected.Spans)
 	})
 	if !assert.True(t, found) {
@@ -198,7 +200,9 @@ func (s *StorageIntegration) testGetTrace(t *testing.T) {
 	var actual *model.Trace
 	found := s.waitForCondition(t, func(t *testing.T) bool {
 		var err error
-		actual, err = s.SpanReader.GetTrace(context.Background(), expectedTraceID)
+		actual, err = s.SpanReader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: expectedTraceID,
+		})
 		if err != nil {
 			t.Log(err)
 		}
@@ -210,7 +214,9 @@ func (s *StorageIntegration) testGetTrace(t *testing.T) {
 
 	t.Run("NotFound error", func(t *testing.T) {
 		fakeTraceID := model.TraceID{High: 0, Low: 0}
-		trace, err := s.SpanReader.GetTrace(context.Background(), fakeTraceID)
+		trace, err := s.SpanReader.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: fakeTraceID,
+		})
 		assert.Equal(t, spanstore.ErrTraceNotFound, err)
 		assert.Nil(t, trace)
 	})
diff --git a/plugin/storage/integration/kafka_test.go b/plugin/storage/integration/kafka_test.go
index 29f87a89545..40385b3440c 100644
--- a/plugin/storage/integration/kafka_test.go
+++ b/plugin/storage/integration/kafka_test.go
@@ -111,8 +111,8 @@ type ingester struct {
 	traceStore *memory.Store
 }
 
-func (r *ingester) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
-	return r.traceStore.GetTrace(ctx, traceID)
+func (r *ingester) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
+	return r.traceStore.GetTrace(ctx, query)
 }
 
 func (r *ingester) GetServices(ctx context.Context) ([]string, error) {
diff --git a/plugin/storage/memory/memory.go b/plugin/storage/memory/memory.go
index a11c55e5be7..a8ff461b80c 100644
--- a/plugin/storage/memory/memory.go
+++ b/plugin/storage/memory/memory.go
@@ -195,11 +195,11 @@ func (st *Store) WriteSpan(ctx context.Context, span *model.Span) error {
 }
 
 // GetTrace gets a trace
-func (st *Store) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
+func (st *Store) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
 	m := st.getTenant(tenancy.GetTenant(ctx))
 	m.RLock()
 	defer m.RUnlock()
-	trace, ok := m.traces[traceID]
+	trace, ok := m.traces[query.ID]
 	if !ok {
 		return nil, spanstore.ErrTraceNotFound
 	}
diff --git a/plugin/storage/memory/memory_test.go b/plugin/storage/memory/memory_test.go
index 21d92ec26f1..f6f3f5ca4c9 100644
--- a/plugin/storage/memory/memory_test.go
+++ b/plugin/storage/memory/memory_test.go
@@ -198,7 +198,9 @@ func TestStoreWithLimit(t *testing.T) {
 
 func TestStoreGetTraceSuccess(t *testing.T) {
 	withPopulatedMemoryStore(func(store *Store) {
-		trace, err := store.GetTrace(context.Background(), testingSpan.TraceID)
+		trace, err := store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.NoError(t, err)
 		assert.Len(t, trace.Spans, 1)
 		assert.Equal(t, testingSpan, trace.Spans[0])
@@ -207,7 +209,9 @@ func TestStoreGetTraceSuccess(t *testing.T) {
 
 func TestStoreGetAndMutateTrace(t *testing.T) {
 	withPopulatedMemoryStore(func(store *Store) {
-		trace, err := store.GetTrace(context.Background(), testingSpan.TraceID)
+		trace, err := store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.NoError(t, err)
 		assert.Len(t, trace.Spans, 1)
 		assert.Equal(t, testingSpan, trace.Spans[0])
@@ -215,7 +219,9 @@ func TestStoreGetAndMutateTrace(t *testing.T) {
 
 		trace.Spans[0].Warnings = append(trace.Spans[0].Warnings, "the end is near")
 
-		trace, err = store.GetTrace(context.Background(), testingSpan.TraceID)
+		trace, err = store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.NoError(t, err)
 		assert.Len(t, trace.Spans, 1)
 		assert.Equal(t, testingSpan, trace.Spans[0])
@@ -228,14 +234,18 @@ func TestStoreGetTraceError(t *testing.T) {
 		store.getTenant("").traces[testingSpan.TraceID] = &model.Trace{
 			Spans: []*model.Span{nonSerializableSpan},
 		}
-		_, err := store.GetTrace(context.Background(), testingSpan.TraceID)
+		_, err := store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.Error(t, err)
 	})
 }
 
 func TestStoreGetTraceFailure(t *testing.T) {
 	withPopulatedMemoryStore(func(store *Store) {
-		trace, err := store.GetTrace(context.Background(), model.TraceID{})
+		trace, err := store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: model.TraceID{},
+		})
 		assert.EqualError(t, err, spanstore.ErrTraceNotFound.Error())
 		assert.Nil(t, trace)
 	})
@@ -459,12 +469,16 @@ func TestTenantStore(t *testing.T) {
 		assert.NoError(t, store.WriteSpan(ctxWonka, testingSpan2))
 
 		// Can we retrieve the spans with correct tenancy
-		trace1, err := store.GetTrace(ctxAcme, testingSpan.TraceID)
+		trace1, err := store.GetTrace(ctxAcme, &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.NoError(t, err)
 		assert.Len(t, trace1.Spans, 1)
 		assert.Equal(t, testingSpan, trace1.Spans[0])
 
-		trace2, err := store.GetTrace(ctxWonka, testingSpan2.TraceID)
+		trace2, err := store.GetTrace(ctxWonka, &spanstore.TraceIDQueryParameters{
+			ID: testingSpan2.TraceID,
+		})
 		assert.NoError(t, err)
 		assert.Len(t, trace2.Spans, 1)
 		assert.Equal(t, testingSpan2, trace2.Spans[0])
@@ -487,13 +501,19 @@ func TestTenantStore(t *testing.T) {
 		assert.Equal(t, testingSpan2, traces2[0].Spans[0])
 
 		// Do the spans fail with incorrect tenancy?
-		_, err = store.GetTrace(ctxAcme, testingSpan2.TraceID)
+		_, err = store.GetTrace(ctxAcme, &spanstore.TraceIDQueryParameters{
+			ID: testingSpan2.TraceID,
+		})
 		assert.Error(t, err)
 
-		_, err = store.GetTrace(ctxWonka, testingSpan.TraceID)
+		_, err = store.GetTrace(ctxWonka, &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.Error(t, err)
 
-		_, err = store.GetTrace(context.Background(), testingSpan.TraceID)
+		_, err = store.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+			ID: testingSpan.TraceID,
+		})
 		assert.Error(t, err)
 	})
 }
diff --git a/proto-gen/api_v3/query_service.pb.go b/proto-gen/api_v3/query_service.pb.go
index eb3ee8b4cc6..a0090b3595f 100644
--- a/proto-gen/api_v3/query_service.pb.go
+++ b/proto-gen/api_v3/query_service.pb.go
@@ -29,10 +29,14 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // Request object to get a trace.
 type GetTraceRequest struct {
 	// Hex encoded 64 or 128 bit trace ID.
-	TraceId              string   `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	TraceId string `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	// Optional. The start time to search trace id
+	Start *types.Timestamp `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"`
+	// Optional. The end time to search trace id
+	End                  *types.Timestamp `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
 }
 
 func (m *GetTraceRequest) Reset()         { *m = GetTraceRequest{} }
@@ -66,6 +70,20 @@ func (m *GetTraceRequest) GetTraceId() string {
 	return ""
 }
 
+func (m *GetTraceRequest) GetStart() *types.Timestamp {
+	if m != nil {
+		return m.Start
+	}
+	return nil
+}
+
+func (m *GetTraceRequest) GetEnd() *types.Timestamp {
+	if m != nil {
+		return m.End
+	}
+	return nil
+}
+
 // Response object with spans.
 type SpansResponseChunk struct {
 	// A list of OpenTelemetry ResourceSpans.
@@ -474,50 +492,51 @@ func init() {
 func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) }
 
 var fileDescriptor_5fcb6756dc1afb8d = []byte{
-	// 675 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x7f, 0x4f, 0xdb, 0x3a,
-	0x14, 0x25, 0x40, 0xa1, 0xbd, 0x6d, 0xe1, 0x3d, 0xd3, 0xa7, 0x17, 0x32, 0x8d, 0xb5, 0x61, 0x93,
-	0x2a, 0x6d, 0x4a, 0x47, 0xf9, 0x87, 0x4d, 0x4c, 0xda, 0x6f, 0x34, 0x4d, 0xb0, 0x11, 0xd8, 0xfe,
-	0x98, 0x26, 0x45, 0x86, 0xde, 0x95, 0x0c, 0xe2, 0x04, 0xdb, 0xa9, 0xda, 0xcf, 0xb1, 0xef, 0xb9,
-	0xcf, 0x30, 0xc5, 0x76, 0xb2, 0x36, 0x9d, 0x10, 0xfb, 0x2b, 0xb9, 0xf6, 0x39, 0xc7, 0xd7, 0xf7,
-	0xdc, 0x6b, 0xd8, 0xb8, 0x4e, 0x91, 0x4f, 0x02, 0x81, 0x7c, 0x14, 0x9e, 0xa3, 0x97, 0xf0, 0x58,
-	0xc6, 0xa4, 0xf9, 0x9d, 0xe2, 0x10, 0xb9, 0x47, 0x93, 0x30, 0x18, 0xed, 0x3a, 0xdd, 0x38, 0x41,
-	0x26, 0xf1, 0x0a, 0x23, 0x94, 0x7c, 0xd2, 0x53, 0x98, 0x9e, 0xe4, 0xf4, 0x1c, 0x7b, 0xa3, 0x1d,
-	0xfd, 0xa3, 0x89, 0xce, 0xbd, 0x61, 0x1c, 0x0f, 0xaf, 0x50, 0x43, 0xce, 0xd2, 0x6f, 0x3d, 0x19,
-	0x46, 0x28, 0x24, 0x8d, 0x12, 0x03, 0xd8, 0x2a, 0x03, 0x06, 0x29, 0xa7, 0x32, 0x8c, 0x99, 0xde,
-	0x77, 0x1f, 0xc1, 0xfa, 0x01, 0xca, 0xd3, 0x4c, 0xd2, 0xc7, 0xeb, 0x14, 0x85, 0x24, 0x9b, 0x50,
-	0x55, 0x47, 0x04, 0xe1, 0xc0, 0xb6, 0xda, 0x56, 0xb7, 0xe6, 0xaf, 0xaa, 0xf8, 0xdd, 0xc0, 0xbd,
-	0x00, 0x72, 0x92, 0x50, 0x26, 0x7c, 0x14, 0x49, 0xcc, 0x04, 0xbe, 0xba, 0x48, 0xd9, 0x25, 0xf1,
-	0x61, 0x8d, 0xa3, 0x88, 0x53, 0x7e, 0x8e, 0x81, 0xc8, 0xb6, 0x6d, 0xab, 0xbd, 0xd4, 0xad, 0xf7,
-	0x1f, 0x7a, 0x33, 0xf7, 0xd0, 0x27, 0x7a, 0x3a, 0xfd, 0xd1, 0x8e, 0xe7, 0x1b, 0x8e, 0x56, 0x6c,
-	0xf2, 0xe9, 0xd0, 0xfd, 0xb1, 0x0c, 0x2d, 0x95, 0xd5, 0x71, 0x56, 0xae, 0x8f, 0x94, 0xd3, 0x08,
-	0x25, 0x72, 0x41, 0x3a, 0xd0, 0x30, 0xb5, 0x0b, 0x18, 0x8d, 0xd0, 0x64, 0x58, 0x37, 0x6b, 0x47,
-	0x34, 0x42, 0xf2, 0x00, 0xd6, 0xe2, 0x04, 0xf5, 0x35, 0x35, 0x68, 0x51, 0x81, 0x9a, 0xc5, 0xaa,
-	0x82, 0x9d, 0x00, 0x50, 0x29, 0x79, 0x78, 0x96, 0x4a, 0x14, 0xf6, 0x92, 0x4a, 0x79, 0xd7, 0x9b,
-	0x71, 0xc2, 0xfb, 0x53, 0x0a, 0xde, 0x8b, 0x82, 0xf5, 0x86, 0x49, 0x3e, 0xf1, 0xa7, 0x64, 0xc8,
-	0x73, 0x58, 0x13, 0x92, 0x72, 0x19, 0x64, 0x46, 0x04, 0x51, 0xc8, 0xec, 0xe5, 0xb6, 0xd5, 0xad,
-	0xf7, 0x1d, 0x4f, 0x1b, 0xe1, 0xe5, 0x46, 0x78, 0xa7, 0xb9, 0x53, 0x7e, 0x43, 0x31, 0xb2, 0xf8,
-	0x30, 0x64, 0x65, 0x05, 0x3a, 0xb6, 0x2b, 0x7f, 0xa3, 0x40, 0xc7, 0x64, 0x1f, 0x1a, 0xb9, 0xcb,
-	0x2a, 0x83, 0x15, 0xc5, 0xdf, 0x9c, 0xe3, 0xbf, 0x36, 0x20, 0xbf, 0x9e, 0xc3, 0xb3, 0xf3, 0x67,
-	0xd8, 0x74, 0x6c, 0xaf, 0xde, 0x9e, 0x4d, 0xc7, 0xe4, 0x2e, 0x00, 0x4b, 0xa3, 0x40, 0x99, 0x2c,
-	0xec, 0x6a, 0xdb, 0xea, 0x56, 0xfc, 0x1a, 0x4b, 0x23, 0x55, 0x48, 0xe1, 0x3c, 0x83, 0xf5, 0x52,
-	0xf5, 0xc8, 0x3f, 0xb0, 0x74, 0x89, 0x13, 0xe3, 0x63, 0xf6, 0x4b, 0x5a, 0x50, 0x19, 0xd1, 0xab,
-	0x34, 0xb7, 0x4d, 0x07, 0x4f, 0x17, 0xf7, 0x2c, 0xf7, 0x08, 0xfe, 0x7d, 0x1b, 0xb2, 0x81, 0x16,
-	0xcb, 0xfb, 0xf5, 0x09, 0x54, 0xd4, 0x4c, 0x29, 0x89, 0x7a, 0x7f, 0xfb, 0x16, 0x16, 0xfa, 0x9a,
-	0xe1, 0xb6, 0x80, 0x1c, 0xa0, 0x3c, 0xd1, 0xbd, 0x93, 0x0b, 0xba, 0x3b, 0xb0, 0x31, 0xb3, 0xaa,
-	0x7b, 0x9d, 0x38, 0x50, 0x35, 0x5d, 0xa6, 0x1b, 0xbc, 0xe6, 0x17, 0xb1, 0x7b, 0x08, 0xad, 0x03,
-	0x94, 0x1f, 0xf2, 0xfe, 0x2a, 0x72, 0xb3, 0x61, 0xd5, 0x60, 0xf2, 0x51, 0x32, 0x21, 0xb9, 0x03,
-	0xb5, 0x6c, 0x56, 0x82, 0xcb, 0x90, 0x0d, 0xcc, 0x45, 0xab, 0xd9, 0xc2, 0xfb, 0x90, 0x0d, 0xdc,
-	0x7d, 0xa8, 0x15, 0x5a, 0x84, 0xc0, 0xf2, 0x54, 0xa7, 0xab, 0xff, 0x9b, 0xd9, 0xc7, 0xf0, 0x5f,
-	0x29, 0x19, 0x73, 0x83, 0x3d, 0x80, 0x62, 0x04, 0xf2, 0x21, 0xb5, 0x4b, 0xe5, 0x2a, 0x68, 0xfe,
-	0x14, 0xb6, 0xff, 0x73, 0x11, 0x1a, 0xaa, 0x86, 0xa6, 0x2a, 0xe4, 0x18, 0xaa, 0xf9, 0xbb, 0x41,
-	0xb6, 0x4a, 0x12, 0xa5, 0x07, 0xc5, 0xe9, 0x94, 0xf6, 0xe7, 0x9f, 0x10, 0x77, 0xe1, 0xb1, 0x45,
-	0x3e, 0x01, 0xfc, 0x36, 0x97, 0xb4, 0x4b, 0xa4, 0x39, 0xdf, 0x6f, 0x2b, 0xfb, 0x19, 0xea, 0x53,
-	0x6e, 0x92, 0xce, 0x7c, 0xb2, 0x25, 0xff, 0x1d, 0xf7, 0x26, 0x88, 0x96, 0x77, 0x17, 0xc8, 0x57,
-	0x68, 0xce, 0x54, 0x99, 0x6c, 0xcf, 0xd3, 0xe6, 0x1a, 0xc2, 0xb9, 0x7f, 0x33, 0x28, 0x57, 0x7f,
-	0xd9, 0x81, 0xff, 0xc3, 0xd8, 0x60, 0xb3, 0x61, 0x0a, 0xd9, 0xd0, 0x50, 0xbe, 0xac, 0xe8, 0xef,
-	0xd9, 0x8a, 0x1a, 0xc5, 0xdd, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x58, 0x79, 0x69, 0x52,
-	0x06, 0x00, 0x00,
+	// 698 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x5d, 0x4f, 0xdb, 0x4a,
+	0x10, 0xc5, 0x09, 0x81, 0x64, 0x92, 0xc0, 0xbd, 0x4b, 0xae, 0xae, 0x71, 0x55, 0x9a, 0x98, 0x56,
+	0x8a, 0xd4, 0xca, 0x81, 0xf0, 0x42, 0x2b, 0x2a, 0xf5, 0x1b, 0x55, 0x15, 0xb4, 0x18, 0xda, 0x87,
+	0xaa, 0x92, 0xb5, 0x90, 0x69, 0x70, 0xc1, 0x6b, 0xb3, 0x5e, 0x47, 0xc9, 0x7f, 0xe8, 0x5b, 0xff,
+	0x67, 0x7f, 0x43, 0xe5, 0xdd, 0xb5, 0x9b, 0x38, 0x15, 0xd0, 0x27, 0x7b, 0xd6, 0xe7, 0x1c, 0x8f,
+	0xcf, 0x99, 0x31, 0xac, 0x5d, 0x25, 0xc8, 0x27, 0x5e, 0x8c, 0x7c, 0xe4, 0x9f, 0xa1, 0x13, 0xf1,
+	0x50, 0x84, 0xa4, 0xf9, 0x8d, 0xe2, 0x10, 0xb9, 0x43, 0x23, 0xdf, 0x1b, 0xed, 0x58, 0xdd, 0x30,
+	0x42, 0x26, 0xf0, 0x12, 0x03, 0x14, 0x7c, 0xd2, 0x93, 0x98, 0x9e, 0xe0, 0xf4, 0x0c, 0x7b, 0xa3,
+	0x6d, 0x75, 0xa3, 0x88, 0xd6, 0xbd, 0x61, 0x18, 0x0e, 0x2f, 0x51, 0x41, 0x4e, 0x93, 0xaf, 0x3d,
+	0xe1, 0x07, 0x18, 0x0b, 0x1a, 0x44, 0x1a, 0xb0, 0x51, 0x04, 0x0c, 0x12, 0x4e, 0x85, 0x1f, 0x32,
+	0xf5, 0xdc, 0xfe, 0x6e, 0xc0, 0xea, 0x3e, 0x8a, 0x93, 0x54, 0xd3, 0xc5, 0xab, 0x04, 0x63, 0x41,
+	0xd6, 0xa1, 0x2a, 0xdf, 0xe1, 0xf9, 0x03, 0xd3, 0x68, 0x1b, 0xdd, 0x9a, 0xbb, 0x2c, 0xeb, 0xb7,
+	0x03, 0xb2, 0x05, 0x95, 0x58, 0x50, 0x2e, 0xcc, 0x52, 0xdb, 0xe8, 0xd6, 0xfb, 0x96, 0xa3, 0xe4,
+	0x9d, 0x4c, 0xde, 0x39, 0xc9, 0xde, 0xef, 0x2a, 0x20, 0x79, 0x04, 0x65, 0x64, 0x03, 0xb3, 0x7c,
+	0x23, 0x3e, 0x85, 0xd9, 0xe7, 0x40, 0x8e, 0x23, 0xca, 0x62, 0x17, 0xe3, 0x28, 0x64, 0x31, 0xbe,
+	0x3c, 0x4f, 0xd8, 0x05, 0x71, 0x61, 0x85, 0x63, 0x1c, 0x26, 0xfc, 0x0c, 0xbd, 0x38, 0x7d, 0x6c,
+	0x1a, 0xed, 0x72, 0xb7, 0xde, 0x7f, 0xe8, 0xcc, 0x18, 0xa5, 0x54, 0x1d, 0xe5, 0xcf, 0x68, 0xdb,
+	0x71, 0x35, 0x47, 0x29, 0x36, 0xf9, 0x74, 0x69, 0xff, 0x58, 0x84, 0x96, 0xfc, 0xea, 0xa3, 0x34,
+	0x8f, 0x0f, 0x94, 0xd3, 0x00, 0x05, 0xf2, 0x98, 0x74, 0xa0, 0xa1, 0xc3, 0xf1, 0x18, 0x0d, 0x50,
+	0x3b, 0x50, 0xd7, 0x67, 0x87, 0x34, 0x40, 0xf2, 0x00, 0x56, 0xc2, 0x08, 0x95, 0x8f, 0x0a, 0x54,
+	0x92, 0xa0, 0x66, 0x7e, 0x2a, 0x61, 0xc7, 0x00, 0x54, 0x08, 0xee, 0x9f, 0x26, 0x02, 0x63, 0xb3,
+	0x2c, 0x5b, 0xde, 0x71, 0x66, 0xa2, 0x76, 0xfe, 0xd4, 0x82, 0xf3, 0x3c, 0x67, 0xbd, 0x66, 0x82,
+	0x4f, 0xdc, 0x29, 0x19, 0xf2, 0x0c, 0x56, 0xa4, 0xb1, 0x5e, 0x9a, 0xb4, 0x17, 0xf8, 0xcc, 0x5c,
+	0xbc, 0xd1, 0xda, 0x86, 0x64, 0xa4, 0xf5, 0x81, 0xcf, 0x8a, 0x0a, 0x74, 0x6c, 0x56, 0xfe, 0x46,
+	0x81, 0x8e, 0xc9, 0x1e, 0x34, 0xb2, 0x31, 0x92, 0x1d, 0x2c, 0x49, 0xfe, 0xfa, 0x1c, 0xff, 0x95,
+	0x06, 0xb9, 0xf5, 0x0c, 0x9e, 0xbe, 0x7f, 0x86, 0x4d, 0xc7, 0xe6, 0xf2, 0xed, 0xd9, 0x74, 0x4c,
+	0xee, 0x02, 0xb0, 0x24, 0xf0, 0x64, 0xc8, 0xb1, 0x59, 0x6d, 0x1b, 0xdd, 0x8a, 0x5b, 0x63, 0x49,
+	0x20, 0x8d, 0x8c, 0xad, 0xa7, 0xb0, 0x5a, 0x70, 0x8f, 0xfc, 0x03, 0xe5, 0x0b, 0x9c, 0xe8, 0x1c,
+	0xd3, 0x5b, 0xd2, 0x82, 0xca, 0x88, 0x5e, 0x26, 0x59, 0x6c, 0xaa, 0x78, 0x52, 0xda, 0x35, 0xec,
+	0x43, 0xf8, 0xf7, 0x8d, 0xcf, 0x06, 0x4a, 0x2c, 0xdb, 0x87, 0xc7, 0x50, 0x91, 0x4b, 0x2b, 0x25,
+	0xea, 0xfd, 0xcd, 0x5b, 0x44, 0xe8, 0x2a, 0x86, 0xdd, 0x02, 0xb2, 0x8f, 0xe2, 0x58, 0xcd, 0x4e,
+	0x26, 0x68, 0x6f, 0xc3, 0xda, 0xcc, 0xa9, 0x9a, 0x75, 0x62, 0x41, 0x55, 0x4f, 0x99, 0x1a, 0xf0,
+	0x9a, 0x9b, 0xd7, 0xf6, 0x01, 0xb4, 0xf6, 0x51, 0xbc, 0xcf, 0xe6, 0x2b, 0xef, 0xcd, 0x84, 0x65,
+	0x8d, 0xc9, 0x56, 0x55, 0x97, 0xe4, 0x0e, 0xd4, 0xd2, 0x5d, 0xf1, 0x2e, 0x7c, 0x36, 0xd0, 0x1f,
+	0x5a, 0x4d, 0x0f, 0xde, 0xf9, 0x6c, 0x60, 0xef, 0x41, 0x2d, 0xd7, 0x22, 0x04, 0x16, 0xa7, 0x26,
+	0x5d, 0xde, 0x5f, 0xcf, 0x3e, 0x82, 0xff, 0x0a, 0xcd, 0xe8, 0x2f, 0xd8, 0x05, 0xc8, 0x57, 0x20,
+	0x5b, 0x52, 0xb3, 0x60, 0x57, 0x4e, 0x73, 0xa7, 0xb0, 0xfd, 0x9f, 0x25, 0x68, 0x48, 0x0f, 0xb5,
+	0x2b, 0xe4, 0x08, 0xaa, 0xd9, 0x7f, 0x89, 0x6c, 0x14, 0x24, 0x0a, 0x3f, 0x2c, 0xab, 0x53, 0x78,
+	0x3e, 0xff, 0x0b, 0xb1, 0x17, 0xb6, 0x0c, 0xf2, 0x11, 0xe0, 0x77, 0xb8, 0xa4, 0x5d, 0x20, 0xcd,
+	0xe5, 0x7e, 0x5b, 0xd9, 0x4f, 0x50, 0x9f, 0x4a, 0x93, 0x74, 0xe6, 0x9b, 0x2d, 0xe4, 0x6f, 0xd9,
+	0xd7, 0x41, 0x94, 0xbc, 0xbd, 0x40, 0xbe, 0x40, 0x73, 0xc6, 0x65, 0xb2, 0x39, 0x4f, 0x9b, 0x1b,
+	0x08, 0xeb, 0xfe, 0xf5, 0xa0, 0x4c, 0xfd, 0x45, 0x07, 0xfe, 0xf7, 0x43, 0x8d, 0x4d, 0x97, 0xc9,
+	0x67, 0x43, 0x4d, 0xf9, 0xbc, 0xa4, 0xae, 0xa7, 0x4b, 0x72, 0x15, 0x77, 0x7e, 0x05, 0x00, 0x00,
+	0xff, 0xff, 0x98, 0x70, 0xe0, 0x45, 0xb3, 0x06, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto-gen/api_v3/query_service.pb.gw.go b/proto-gen/api_v3/query_service.pb.gw.go
index 32a13f58271..d393094c306 100644
--- a/proto-gen/api_v3/query_service.pb.gw.go
+++ b/proto-gen/api_v3/query_service.pb.gw.go
@@ -33,6 +33,10 @@ var _ = utilities.NewDoubleArray
 var _ = descriptor.ForMessage
 var _ = metadata.Join
 
+var (
+	filter_QueryService_GetTrace_0 = &utilities.DoubleArray{Encoding: map[string]int{"trace_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
+)
+
 func request_QueryService_GetTrace_0(ctx context.Context, marshaler runtime.Marshaler, client QueryServiceClient, req *http.Request, pathParams map[string]string) (QueryService_GetTraceClient, runtime.ServerMetadata, error) {
 	var protoReq GetTraceRequest
 	var metadata runtime.ServerMetadata
@@ -55,6 +59,13 @@ func request_QueryService_GetTrace_0(ctx context.Context, marshaler runtime.Mars
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "trace_id", err)
 	}
 
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_QueryService_GetTrace_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
 	stream, err := client.GetTrace(ctx, &protoReq)
 	if err != nil {
 		return nil, metadata, err
diff --git a/storage/spanstore/interface.go b/storage/spanstore/interface.go
index 534cf8a2280..f602e9fe32d 100644
--- a/storage/spanstore/interface.go
+++ b/storage/spanstore/interface.go
@@ -36,7 +36,7 @@ type Reader interface {
 	// GetTrace retrieves the trace with a given id.
 	//
 	// If no spans are stored for this trace, it returns ErrTraceNotFound.
-	GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error)
+	GetTrace(ctx context.Context, query *TraceIDQueryParameters) (*model.Trace, error)
 
 	// GetServices returns all service names known to the backend from spans
 	// within its retention period.
@@ -61,6 +61,13 @@ type Reader interface {
 	FindTraceIDs(ctx context.Context, query *TraceQueryParameters) ([]model.TraceID, error)
 }
 
+// TraceIDQueryParameters contains parameters of a trace id query.
+type TraceIDQueryParameters struct {
+	ID    model.TraceID
+	Start time.Time
+	End   time.Time
+}
+
 // TraceQueryParameters contains parameters of a trace query.
 type TraceQueryParameters struct {
 	ServiceName   string
diff --git a/storage/spanstore/metrics/decorator.go b/storage/spanstore/metrics/decorator.go
index 492c37bb1ba..d545aeeaaa9 100644
--- a/storage/spanstore/metrics/decorator.go
+++ b/storage/spanstore/metrics/decorator.go
@@ -89,9 +89,9 @@ func (m *ReadMetricsDecorator) FindTraceIDs(ctx context.Context, traceQuery *spa
 }
 
 // GetTrace implements spanstore.Reader#GetTrace
-func (m *ReadMetricsDecorator) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
+func (m *ReadMetricsDecorator) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
 	start := time.Now()
-	retMe, err := m.spanReader.GetTrace(ctx, traceID)
+	retMe, err := m.spanReader.GetTrace(ctx, query)
 	m.getTraceMetrics.emit(err, time.Since(start), 1)
 	return retMe, err
 }
diff --git a/storage/spanstore/metrics/decorator_test.go b/storage/spanstore/metrics/decorator_test.go
index 13f61d20204..07d7bc66c6f 100644
--- a/storage/spanstore/metrics/decorator_test.go
+++ b/storage/spanstore/metrics/decorator_test.go
@@ -40,8 +40,12 @@ func TestSuccessfulUnderlyingCalls(t *testing.T) {
 	mockReader.On("GetOperations", context.Background(), operationQuery).
 		Return([]spanstore.Operation{}, nil)
 	mrs.GetOperations(context.Background(), operationQuery)
-	mockReader.On("GetTrace", context.Background(), model.TraceID{}).Return(&model.Trace{}, nil)
-	mrs.GetTrace(context.Background(), model.TraceID{})
+	mockReader.On("GetTrace", context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: model.TraceID{},
+	}).Return(&model.Trace{}, nil)
+	mrs.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: model.TraceID{},
+	})
 	mockReader.On("FindTraces", context.Background(), &spanstore.TraceQueryParameters{}).
 		Return([]*model.Trace{}, nil)
 	mrs.FindTraces(context.Background(), &spanstore.TraceQueryParameters{})
@@ -108,9 +112,13 @@ func TestFailingUnderlyingCalls(t *testing.T) {
 	mockReader.On("GetOperations", context.Background(), operationQuery).
 		Return(nil, errors.New("Failure"))
 	mrs.GetOperations(context.Background(), operationQuery)
-	mockReader.On("GetTrace", context.Background(), model.TraceID{}).
+	mockReader.On("GetTrace", context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: model.TraceID{},
+	}).
 		Return(nil, errors.New("Failure"))
-	mrs.GetTrace(context.Background(), model.TraceID{})
+	mrs.GetTrace(context.Background(), &spanstore.TraceIDQueryParameters{
+		ID: model.TraceID{},
+	})
 	mockReader.On("FindTraces", context.Background(), &spanstore.TraceQueryParameters{}).
 		Return(nil, errors.New("Failure"))
 	mrs.FindTraces(context.Background(), &spanstore.TraceQueryParameters{})
diff --git a/storage/spanstore/mocks/Reader.go b/storage/spanstore/mocks/Reader.go
index 5c6f43ef64e..d0b1a226f07 100644
--- a/storage/spanstore/mocks/Reader.go
+++ b/storage/spanstore/mocks/Reader.go
@@ -123,12 +123,12 @@ func (_m *Reader) GetServices(ctx context.Context) ([]string, error) {
 }
 
 // GetTrace provides a mock function with given fields: ctx, traceID
-func (_m *Reader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.Trace, error) {
-	ret := _m.Called(ctx, traceID)
+func (_m *Reader) GetTrace(ctx context.Context, query *spanstore.TraceIDQueryParameters) (*model.Trace, error) {
+	ret := _m.Called(ctx, query)
 
 	var r0 *model.Trace
 	if rf, ok := ret.Get(0).(func(context.Context, model.TraceID) *model.Trace); ok {
-		r0 = rf(ctx, traceID)
+		r0 = rf(ctx, query.ID)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*model.Trace)
@@ -137,7 +137,7 @@ func (_m *Reader) GetTrace(ctx context.Context, traceID model.TraceID) (*model.T
 
 	var r1 error
 	if rf, ok := ret.Get(1).(func(context.Context, model.TraceID) error); ok {
-		r1 = rf(ctx, traceID)
+		r1 = rf(ctx, query.ID)
 	} else {
 		r1 = ret.Error(1)
 	}