diff --git a/.github/workflows/ci-e2e-kafka.yml b/.github/workflows/ci-e2e-kafka.yml
index c79af13d1bcf..d07062d85477 100644
--- a/.github/workflows/ci-e2e-kafka.yml
+++ b/.github/workflows/ci-e2e-kafka.yml
@@ -18,7 +18,7 @@ jobs:
       fail-fast: false
       matrix:
         jaeger-version: [v1, v2]
-        kafka-version: ["3.x", "2.x"]
+        kafka-version: ["3.x"]
     name: kafka ${{matrix.kafka-version }} ${{ matrix.jaeger-version }}
     steps:
     - name: Harden Runner
diff --git a/Makefile b/Makefile
index 50d19d2ea7dd..ed23746c2893 100644
--- a/Makefile
+++ b/Makefile
@@ -48,19 +48,24 @@ SCRIPTS_SRC = $(shell find . \( -name '*.sh' -o -name '*.py' -o -name '*.mk' -o
 # ALL_PKGS is used with 'nocover' and 'goleak'
 ALL_PKGS = $(shell echo $(dir $(ALL_SRC)) | tr ' ' '\n' | sort -u)
 
-UNAME := $(shell uname -m)
-ifeq ($(UNAME), s390x)
+GO=go
+GOOS ?= $(shell $(GO) env GOOS)
+GOARCH ?= $(shell $(GO) env GOARCH)
+
 # go test does not support -race flag on s390x architecture
+ifeq ($(GOARCH), s390x)
 	RACE=
 else
 	RACE=-race
 endif
 # sed on Mac does not support the same syntax for in-place updates as sed on Linux
 # When running on MacOS it's best to install gsed and run Makefile with SED=gsed
-SED=sed
-GO=go
-GOOS ?= $(shell $(GO) env GOOS)
-GOARCH ?= $(shell $(GO) env GOARCH)
+ifeq ($(GOOS),darwin)
+	SED=gsed
+else
+	SED=sed
+endif
+
 GOTEST_QUIET=$(GO) test $(RACE)
 GOTEST=$(GOTEST_QUIET) -v
 COVEROUT=cover.out
diff --git a/Makefile.IntegrationTests.mk b/Makefile.IntegrationTests.mk
index f6fe85e669bd..332f7832238f 100644
--- a/Makefile.IntegrationTests.mk
+++ b/Makefile.IntegrationTests.mk
@@ -14,8 +14,8 @@ all-in-one-integration-test:
 .PHONY: jaeger-v2-storage-integration-test
 jaeger-v2-storage-integration-test:
 	(cd cmd/jaeger/ && go build .)
-	# Expire tests results for jaeger storage integration tests since the environment might change
-	# even though the code remains the same.
+	# Expire tests results for jaeger storage integration tests since the environment
+	# might have changed even though the code remains the same.
 	go clean -testcache
 	bash -c "set -e; set -o pipefail; $(GOTEST) -coverpkg=./... -coverprofile $(COVEROUT) $(JAEGER_V2_STORAGE_PKGS) $(COLORIZE)"
 
diff --git a/Makefile.Protobuf.mk b/Makefile.Protobuf.mk
index bb10b7d8ad01..843e3889b950 100644
--- a/Makefile.Protobuf.mk
+++ b/Makefile.Protobuf.mk
@@ -126,7 +126,7 @@ proto-zipkin:
 # only to fields in a struct, so we use regex search/replace to swap it.
 # Note that the .pb.go types must be generated into the same internal package $(API_V3_PATH)
 # where a manually defined traces.go file is located.
-API_V3_PATH=cmd/query/app/internal/api_v3
+API_V3_PATH=internal/proto/api_v3
 API_V3_PATCHED_DIR=proto-gen/.patched/api_v3
 API_V3_PATCHED=$(API_V3_PATCHED_DIR)/query_service.proto
 .PHONY: patch-api-v3
diff --git a/cmd/jaeger/config-kafka-ingester.yaml b/cmd/jaeger/config-kafka-ingester.yaml
index e3947f531b7a..4a5c22605ed0 100644
--- a/cmd/jaeger/config-kafka-ingester.yaml
+++ b/cmd/jaeger/config-kafka-ingester.yaml
@@ -12,7 +12,7 @@ service:
       level: detailed
       address: 0.0.0.0:8888
     logs:
-      level: debug
+      level: info
 
 extensions:
   healthcheckv2:
diff --git a/cmd/jaeger/internal/integration/binary.go b/cmd/jaeger/internal/integration/binary.go
new file mode 100644
index 000000000000..3ade67a93dab
--- /dev/null
+++ b/cmd/jaeger/internal/integration/binary.go
@@ -0,0 +1,145 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package integration
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/jaegertracing/jaeger/ports"
+)
+
+// Binary is a wrapper around exec.Cmd to help running binaries in tests.
+type Binary struct {
+	Name            string
+	HealthCheckPort int // overridable for Kafka tests which run two binaries and need different ports
+	exec.Cmd
+}
+
+func (b *Binary) Start(t *testing.T) {
+	outFile, err := os.OpenFile(
+		filepath.Join(t.TempDir(), "output_logs.txt"),
+		os.O_CREATE|os.O_WRONLY,
+		os.ModePerm,
+	)
+	require.NoError(t, err)
+	t.Logf("Writing the %s output logs into %s", b.Name, outFile.Name())
+
+	errFile, err := os.OpenFile(
+		filepath.Join(t.TempDir(), "error_logs.txt"),
+		os.O_CREATE|os.O_WRONLY,
+		os.ModePerm,
+	)
+	require.NoError(t, err)
+	t.Logf("Writing the %s error logs into %s", b.Name, errFile.Name())
+
+	b.Stdout = outFile
+	b.Stderr = errFile
+
+	t.Logf("Running command: %v", b.Args)
+	require.NoError(t, b.Cmd.Start())
+
+	t.Cleanup(func() {
+		if err := b.Process.Kill(); err != nil {
+			t.Errorf("Failed to kill %s process: %v", b.Name, err)
+		}
+		t.Logf("Waiting for %s to exit", b.Name)
+		b.Process.Wait()
+		t.Logf("%s exited", b.Name)
+		if t.Failed() {
+			b.dumpLogs(t, outFile, errFile)
+		}
+	})
+
+	// Wait for the binary to start and become ready to serve requests.
+	require.Eventually(t, func() bool { return b.doHealthCheck(t) },
+		60*time.Second, 3*time.Second, "%s did not start", b.Name)
+	t.Logf("%s is ready", b.Name)
+}
+
+func (b *Binary) doHealthCheck(t *testing.T) bool {
+	healthCheckPort := b.HealthCheckPort
+	if healthCheckPort == 0 {
+		healthCheckPort = ports.CollectorV2HealthChecks
+	}
+	healthCheckEndpoint := fmt.Sprintf("http://localhost:%d/status", healthCheckPort)
+	t.Logf("Checking if %s is available on %s", b.Name, healthCheckEndpoint)
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, healthCheckEndpoint, nil)
+	if err != nil {
+		t.Logf("HTTP request creation failed: %v", err)
+		return false
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Logf("HTTP request failed: %v", err)
+		return false
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Logf("Failed to read HTTP response body: %v", err)
+		return false
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Logf("HTTP response not OK: %v", string(body))
+		return false
+	}
+
+	var healthResponse struct {
+		Status string `json:"status"`
+	}
+	if err := json.NewDecoder(bytes.NewReader(body)).Decode(&healthResponse); err != nil {
+		t.Logf("Failed to decode JSON response '%s': %v", string(body), err)
+		return false
+	}
+
+	// Check if the status field in the JSON is "StatusOK"
+	if healthResponse.Status != "StatusOK" {
+		t.Logf("Received non-OK status %s: %s", healthResponse.Status, string(body))
+		return false
+	}
+	return true
+}
+
+// Special Github markers to create a foldable section in the GitHub Actions runner output.
+// https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#grouping-log-lines
+const (
+	githubBeginGroup = "::group::"
+	githubEndGroup   = "::endgroup::"
+)
+
+func (b *Binary) dumpLogs(t *testing.T, outFile, errFile *os.File) {
+	fmt.Printf(githubBeginGroup+" 🚧 🚧 🚧 %s binary logs\n", b.Name)
+	outLogs, err := os.ReadFile(outFile.Name())
+	if err != nil {
+		t.Errorf("Failed to read output logs: %v", err)
+	} else {
+		fmt.Printf("⏩⏩⏩ Start %s output logs:\n", b.Name)
+		fmt.Printf("%s\n", outLogs)
+		fmt.Printf("⏹️⏹️⏹️ End %s output logs.\n", b.Name)
+	}
+
+	errLogs, err := os.ReadFile(errFile.Name())
+	if err != nil {
+		t.Errorf("Failed to read error logs: %v", err)
+	} else {
+		fmt.Printf("⏩⏩⏩ Start %s error logs:\n", b.Name)
+		fmt.Printf("%s\n", errLogs)
+		fmt.Printf("⏹️⏹️⏹️ End %s error logs.\n", b.Name)
+	}
+	fmt.Println(githubEndGroup)
+}
diff --git a/cmd/jaeger/internal/integration/e2e_integration.go b/cmd/jaeger/internal/integration/e2e_integration.go
index 9cb44d210abc..ac85121478ed 100644
--- a/cmd/jaeger/internal/integration/e2e_integration.go
+++ b/cmd/jaeger/internal/integration/e2e_integration.go
@@ -4,17 +4,15 @@
 package integration
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
@@ -24,7 +22,6 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/jaeger/internal/integration/storagecleaner"
 	"github.com/jaegertracing/jaeger/plugin/storage/integration"
 	"github.com/jaegertracing/jaeger/ports"
-	"github.com/jaegertracing/jaeger/storage_v2/v1adapter"
 )
 
 const otlpPort = 4317
@@ -54,69 +51,10 @@ type E2EStorageIntegration struct {
 	EnvVarOverrides map[string]string
 }
 
-// Binary is a wrapper around exec.Cmd to help running binaries in tests.
-type Binary struct {
-	Name string
-	exec.Cmd
-}
-
-func (b *Binary) Start(t *testing.T) {
-	outFile, err := os.OpenFile(
-		filepath.Join(t.TempDir(), "output_logs.txt"),
-		os.O_CREATE|os.O_WRONLY,
-		os.ModePerm,
-	)
-	require.NoError(t, err)
-	t.Logf("Writing the %s output logs into %s", b.Name, outFile.Name())
-
-	errFile, err := os.OpenFile(
-		filepath.Join(t.TempDir(), "error_logs.txt"),
-		os.O_CREATE|os.O_WRONLY,
-		os.ModePerm,
-	)
-	require.NoError(t, err)
-	t.Logf("Writing the %s error logs into %s", b.Name, errFile.Name())
-
-	b.Stdout = outFile
-	b.Stderr = errFile
-
-	t.Logf("Running command: %v", b.Args)
-	require.NoError(t, b.Cmd.Start())
-	t.Cleanup(func() {
-		if err := b.Process.Kill(); err != nil {
-			t.Errorf("Failed to kill %s process: %v", b.Name, err)
-		}
-		if t.Failed() {
-			// A special annotation to create a foldable section in the GitHub Actions runner output.
-			// https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#grouping-log-lines
-			fmt.Printf("::group::🚧 🚧 🚧 %s binary logs\n", b.Name)
-			outLogs, err := os.ReadFile(outFile.Name())
-			if err != nil {
-				t.Errorf("Failed to read output logs: %v", err)
-			} else {
-				fmt.Printf("🚧 🚧 🚧 %s output logs:\n%s", b.Name, outLogs)
-			}
-
-			errLogs, err := os.ReadFile(errFile.Name())
-			if err != nil {
-				t.Errorf("Failed to read error logs: %v", err)
-			} else {
-				fmt.Printf("🚧 🚧 🚧 %s error logs:\n%s", b.Name, errLogs)
-			}
-			// End of Github Actions foldable section annotation.
-			fmt.Println("::endgroup::")
-		}
-	})
-}
-
 // e2eInitialize starts the Jaeger-v2 collector with the provided config file,
 // it also initialize the SpanWriter and SpanReader below.
 // This function should be called before any of the tests start.
 func (s *E2EStorageIntegration) e2eInitialize(t *testing.T, storage string) {
-	// set environment variable overrides
-	for key, value := range s.EnvVarOverrides {
-		t.Setenv(key, value)
-	}
 	logger := zaptest.NewLogger(t, zaptest.WrapOptions(zap.AddCaller()))
 	if s.BinaryName == "" {
 		s.BinaryName = "jaeger-v2"
@@ -130,8 +68,18 @@ func (s *E2EStorageIntegration) e2eInitialize(t *testing.T, storage string) {
 	require.FileExists(t, configFile, "Config file does not exist at the resolved path")
 
 	t.Logf("Starting %s in the background with config file %s", s.BinaryName, configFile)
+	cfgBytes, err := os.ReadFile(configFile)
+	require.NoError(t, err)
+	t.Logf("Config file content:\n%s", string(cfgBytes))
+
+	envVars := []string{"OTEL_TRACES_SAMPLER=always_off"}
+	for key, value := range s.EnvVarOverrides {
+		envVars = append(envVars, fmt.Sprintf("%s=%s", key, value))
+	}
+
 	cmd := Binary{
-		Name: s.BinaryName,
+		Name:            s.BinaryName,
+		HealthCheckPort: s.HealthCheckPort,
 		Cmd: exec.Cmd{
 			Path: "./cmd/jaeger/jaeger",
 			Args: []string{"jaeger", "--config", configFile},
@@ -139,82 +87,22 @@ func (s *E2EStorageIntegration) e2eInitialize(t *testing.T, storage string) {
 			// since the binary config file jaeger_query's ui.config_file points to
 			// "./cmd/jaeger/config-ui.json"
 			Dir: "../../../..",
+			Env: envVars,
 		},
 	}
 	cmd.Start(t)
 
-	// Wait for the binary to start and become ready to serve requests.
-	require.Eventually(t, func() bool { return s.doHealthCheck(t) },
-		60*time.Second, 3*time.Second, "%s did not start", s.BinaryName)
-	t.Logf("%s is ready", s.BinaryName)
-
 	s.SpanWriter, err = createSpanWriter(logger, otlpPort)
 	require.NoError(t, err)
-	spanReader, err := createSpanReader(logger, ports.QueryGRPC)
+	s.TraceReader, err = createTraceReader(logger, ports.QueryGRPC)
 	require.NoError(t, err)
-	s.TraceReader = v1adapter.NewTraceReader(spanReader)
 
 	t.Cleanup(func() {
-		// Call e2eCleanUp to close the SpanReader and SpanWriter gRPC connection.
-		s.e2eCleanUp(t)
+		require.NoError(t, s.TraceReader.(io.Closer).Close())
+		require.NoError(t, s.SpanWriter.(io.Closer).Close())
 	})
 }
 
-func (s *E2EStorageIntegration) doHealthCheck(t *testing.T) bool {
-	healthCheckPort := s.HealthCheckPort
-	if healthCheckPort == 0 {
-		healthCheckPort = ports.CollectorV2HealthChecks
-	}
-	healthCheckEndpoint := fmt.Sprintf("http://localhost:%d/status", healthCheckPort)
-	t.Logf("Checking if %s is available on %s", s.BinaryName, healthCheckEndpoint)
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, healthCheckEndpoint, nil)
-	if err != nil {
-		t.Logf("HTTP request creation failed: %v", err)
-		return false
-	}
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Logf("HTTP request failed: %v", err)
-		return false
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		t.Logf("Failed to read HTTP response body: %v", err)
-		return false
-	}
-	if resp.StatusCode != http.StatusOK {
-		t.Logf("HTTP response not OK: %v", string(body))
-		return false
-	}
-
-	var healthResponse struct {
-		Status string `json:"status"`
-	}
-	if err := json.NewDecoder(bytes.NewReader(body)).Decode(&healthResponse); err != nil {
-		t.Logf("Failed to decode JSON response '%s': %v", string(body), err)
-		return false
-	}
-
-	// Check if the status field in the JSON is "StatusOK"
-	if healthResponse.Status != "StatusOK" {
-		t.Logf("Received non-OK status %s: %s", healthResponse.Status, string(body))
-		return false
-	}
-	return true
-}
-
-// e2eCleanUp closes the SpanReader and SpanWriter gRPC connection.
-// This function should be called after all the tests are finished.
-func (s *E2EStorageIntegration) e2eCleanUp(t *testing.T) {
-	spanReader, err := v1adapter.GetV1Reader(s.TraceReader)
-	require.NoError(t, err)
-	require.NoError(t, spanReader.(io.Closer).Close())
-	require.NoError(t, s.SpanWriter.(io.Closer).Close())
-}
-
 func createStorageCleanerConfig(t *testing.T, configFile string, storage string) string {
 	data, err := os.ReadFile(configFile)
 	require.NoError(t, err)
@@ -261,7 +149,9 @@ func createStorageCleanerConfig(t *testing.T, configFile string, storage string)
 
 	newData, err := yaml.Marshal(config)
 	require.NoError(t, err)
-	tempFile := filepath.Join(t.TempDir(), "storageCleaner_config.yaml")
+	fileExt := filepath.Ext(filepath.Base(configFile))
+	fileName := strings.TrimSuffix(filepath.Base(configFile), fileExt)
+	tempFile := filepath.Join(t.TempDir(), fileName+"_with_storageCleaner"+fileExt)
 	err = os.WriteFile(tempFile, newData, 0o600)
 	require.NoError(t, err)
 
diff --git a/cmd/jaeger/internal/integration/span_reader.go b/cmd/jaeger/internal/integration/span_reader.go
deleted file mode 100644
index 3aaf0c09ecef..000000000000
--- a/cmd/jaeger/internal/integration/span_reader.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (c) 2024 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package integration
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"strings"
-
-	"go.uber.org/zap"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-	"google.golang.org/grpc/status"
-
-	"github.com/jaegertracing/jaeger/model"
-	"github.com/jaegertracing/jaeger/ports"
-	"github.com/jaegertracing/jaeger/proto-gen/api_v2"
-	"github.com/jaegertracing/jaeger/storage/spanstore"
-)
-
-var (
-	_ spanstore.Reader = (*spanReader)(nil)
-	_ io.Closer        = (*spanReader)(nil)
-)
-
-// SpanReader retrieve span data from Jaeger-v2 query with api_v2.QueryServiceClient.
-type spanReader struct {
-	logger     *zap.Logger
-	clientConn *grpc.ClientConn
-	client     api_v2.QueryServiceClient
-}
-
-func createSpanReader(logger *zap.Logger, port int) (*spanReader, error) {
-	logger.Info("Creating the span reader", zap.Int("port", port))
-	opts := []grpc.DialOption{
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
-	}
-
-	cc, err := grpc.NewClient(ports.PortToHostPort(port), opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &spanReader{
-		logger:     logger,
-		clientConn: cc,
-		client:     api_v2.NewQueryServiceClient(cc),
-	}, nil
-}
-
-func (r *spanReader) Close() error {
-	r.logger.Info("Closing the span writer")
-	return r.clientConn.Close()
-}
-
-func unwrapNotFoundErr(err error) error {
-	if s, _ := status.FromError(err); s != nil {
-		if strings.Contains(s.Message(), spanstore.ErrTraceNotFound.Error()) {
-			return spanstore.ErrTraceNotFound
-		}
-	}
-	return err
-}
-
-func (r *spanReader) GetTrace(ctx context.Context, query spanstore.GetTraceParameters) (*model.Trace, error) {
-	stream, err := r.client.GetTrace(ctx, &api_v2.GetTraceRequest{
-		TraceID:   query.TraceID,
-		StartTime: query.StartTime,
-		EndTime:   query.EndTime,
-	})
-	if err != nil {
-		return nil, unwrapNotFoundErr(err)
-	}
-
-	var spans []*model.Span
-	for received, err := stream.Recv(); !errors.Is(err, io.EOF); received, err = stream.Recv() {
-		if err != nil {
-			return nil, unwrapNotFoundErr(err)
-		}
-		for i := range received.Spans {
-			spans = append(spans, &received.Spans[i])
-		}
-		// r.logger.Info(fmt.Sprintf("GetTrace received %d spans (total %d)", len(received.Spans), len(spans)))
-	}
-	r.logger.Info(fmt.Sprintf("GetTraces received a total of %d spans", len(spans)))
-
-	return &model.Trace{
-		Spans: spans,
-	}, nil
-}
-
-func (r *spanReader) GetServices(ctx context.Context) ([]string, error) {
-	res, err := r.client.GetServices(ctx, &api_v2.GetServicesRequest{})
-	if err != nil {
-		return []string{}, err
-	}
-	return res.Services, nil
-}
-
-func (r *spanReader) GetOperations(ctx context.Context, query spanstore.OperationQueryParameters) ([]spanstore.Operation, error) {
-	var operations []spanstore.Operation
-	res, err := r.client.GetOperations(ctx, &api_v2.GetOperationsRequest{
-		Service:  query.ServiceName,
-		SpanKind: query.SpanKind,
-	})
-	if err != nil {
-		return operations, err
-	}
-	for _, operation := range res.Operations {
-		operations = append(operations, spanstore.Operation{
-			Name:     operation.Name,
-			SpanKind: operation.SpanKind,
-		})
-	}
-	return operations, nil
-}
-
-func (r *spanReader) FindTraces(ctx context.Context, query *spanstore.TraceQueryParameters) ([]*model.Trace, error) {
-	var traces []*model.Trace
-
-	if query.NumTraces > math.MaxInt32 {
-		return traces, fmt.Errorf("NumTraces must not greater than %d", math.MaxInt32)
-	}
-	stream, err := r.client.FindTraces(ctx, &api_v2.FindTracesRequest{
-		Query: &api_v2.TraceQueryParameters{
-			ServiceName:   query.ServiceName,
-			OperationName: query.OperationName,
-			Tags:          query.Tags,
-			StartTimeMin:  query.StartTimeMin,
-			StartTimeMax:  query.StartTimeMax,
-			DurationMin:   query.DurationMin,
-			DurationMax:   query.DurationMax,
-			//nolint: gosec // G115
-			SearchDepth: int32(query.NumTraces),
-		},
-	})
-	if err != nil {
-		return traces, err
-	}
-
-	totalSpans := 0
-	spanMaps := map[string][]*model.Span{}
-	for received, err := stream.Recv(); !errors.Is(err, io.EOF); received, err = stream.Recv() {
-		if err != nil {
-			return nil, unwrapNotFoundErr(err)
-		}
-		for i, span := range received.Spans {
-			traceID := span.TraceID.String()
-			if _, ok := spanMaps[traceID]; !ok {
-				spanMaps[traceID] = make([]*model.Span, 0)
-			}
-			spanMaps[traceID] = append(spanMaps[traceID], &received.Spans[i])
-		}
-		totalSpans += len(received.Spans)
-		r.logger.Info(fmt.Sprintf("FindTraces received %d spans (total %d)", len(received.Spans), totalSpans))
-	}
-	r.logger.Info(fmt.Sprintf("FindTraces received a total of %d spans", totalSpans))
-
-	for _, spans := range spanMaps {
-		traces = append(traces, &model.Trace{
-			Spans: spans,
-		})
-	}
-	return traces, nil
-}
-
-func (*spanReader) FindTraceIDs(context.Context, *spanstore.TraceQueryParameters) ([]model.TraceID, error) {
-	panic("not implemented")
-}
diff --git a/cmd/jaeger/internal/integration/trace_reader.go b/cmd/jaeger/internal/integration/trace_reader.go
new file mode 100644
index 000000000000..cfa102de13aa
--- /dev/null
+++ b/cmd/jaeger/internal/integration/trace_reader.go
@@ -0,0 +1,190 @@
+// Copyright (c) 2024 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package integration
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"strings"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/status"
+
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
+	"github.com/jaegertracing/jaeger/model"
+	"github.com/jaegertracing/jaeger/pkg/iter"
+	"github.com/jaegertracing/jaeger/ports"
+	"github.com/jaegertracing/jaeger/storage/spanstore"
+	"github.com/jaegertracing/jaeger/storage_v2/tracestore"
+)
+
+var (
+	_ tracestore.Reader = (*traceReader)(nil)
+	_ io.Closer         = (*traceReader)(nil)
+)
+
+// traceReader retrieves trace data from the jaeger-v2 query service through the api_v2.QueryServiceClient.
+type traceReader struct {
+	logger     *zap.Logger
+	clientConn *grpc.ClientConn
+	client     api_v3.QueryServiceClient
+}
+
+func createTraceReader(logger *zap.Logger, port int) (*traceReader, error) {
+	logger.Info("Creating the trace reader", zap.Int("port", port))
+	opts := []grpc.DialOption{
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	}
+
+	cc, err := grpc.NewClient(ports.PortToHostPort(port), opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &traceReader{
+		logger:     logger,
+		clientConn: cc,
+		client:     api_v3.NewQueryServiceClient(cc),
+	}, nil
+}
+
+func (r *traceReader) Close() error {
+	r.logger.Info("Closing the gRPC trace reader")
+	return r.clientConn.Close()
+}
+
+func (r *traceReader) GetTraces(
+	ctx context.Context,
+	traceIDs ...tracestore.GetTraceParams,
+) iter.Seq2[[]ptrace.Traces, error] {
+	return func(yield func([]ptrace.Traces, error) bool) {
+		// api_v3 does not support multi-get, so loop through IDs
+		for _, idParams := range traceIDs {
+			idStr := model.TraceIDFromOTEL(idParams.TraceID).String()
+			r.logger.Info("Calling api_v3.GetTrace", zap.String("trace_id", idStr))
+			stream, err := r.client.GetTrace(ctx, &api_v3.GetTraceRequest{
+				TraceId:   idStr,
+				StartTime: idParams.Start,
+				EndTime:   idParams.End,
+			})
+			if !r.consumeTraces(yield, stream, err) {
+				return
+			}
+		}
+	}
+}
+
+func (r *traceReader) GetServices(ctx context.Context) ([]string, error) {
+	res, err := r.client.GetServices(ctx, &api_v3.GetServicesRequest{})
+	if err != nil {
+		return []string{}, err
+	}
+	return res.Services, nil
+}
+
+func (r *traceReader) GetOperations(ctx context.Context, query tracestore.OperationQueryParameters) ([]tracestore.Operation, error) {
+	var operations []tracestore.Operation
+	res, err := r.client.GetOperations(ctx, &api_v3.GetOperationsRequest{
+		Service:  query.ServiceName,
+		SpanKind: query.SpanKind,
+	})
+	if err != nil {
+		return operations, err
+	}
+	for _, operation := range res.Operations {
+		operations = append(operations, tracestore.Operation{
+			Name:     operation.Name,
+			SpanKind: operation.SpanKind,
+		})
+	}
+	return operations, nil
+}
+
+func (r *traceReader) FindTraces(
+	ctx context.Context,
+	query tracestore.TraceQueryParams,
+) iter.Seq2[[]ptrace.Traces, error] {
+	return func(yield func([]ptrace.Traces, error) bool) {
+		if query.NumTraces > math.MaxInt32 {
+			yield(nil, fmt.Errorf("NumTraces must not be greater than %d", math.MaxInt32))
+			return
+		}
+		stream, err := r.client.FindTraces(ctx, &api_v3.FindTracesRequest{
+			Query: &api_v3.TraceQueryParameters{
+				ServiceName:   query.ServiceName,
+				OperationName: query.OperationName,
+				Attributes:    query.Tags,
+				StartTimeMin:  query.StartTimeMin,
+				StartTimeMax:  query.StartTimeMax,
+				DurationMin:   query.DurationMin,
+				DurationMax:   query.DurationMax,
+				//nolint: gosec // G115
+				SearchDepth: int32(query.NumTraces),
+				RawTraces:   true,
+			},
+		})
+		r.consumeTraces(yield, stream, err)
+	}
+}
+
+func (*traceReader) FindTraceIDs(
+	_ context.Context,
+	_ tracestore.TraceQueryParams,
+) iter.Seq2[[]pcommon.TraceID, error] {
+	panic("not implemented")
+}
+
+type traceStream interface {
+	Recv() (*api_v3.TracesData, error)
+}
+
+// consumeTraces reads the stream and calls yield for each chunk.
+// It also handles NotFound errors by terminating the stream.
+// It returns false if the processing was terminated through error.
+func (r *traceReader) consumeTraces(
+	yield func([]ptrace.Traces, error) bool,
+	stream traceStream,
+	startErr error,
+) bool {
+	handleError := func(err error) bool {
+		if err == nil {
+			return true
+		}
+		err = unwrapNotFoundErr(err)
+		r.logger.Info("Error received", zap.Error(err))
+		if !errors.Is(err, spanstore.ErrTraceNotFound) {
+			yield(nil, err)
+		}
+		return false
+	}
+	if !handleError(startErr) {
+		return false
+	}
+	for chunk, err := stream.Recv(); !errors.Is(err, io.EOF); chunk, err = stream.Recv() {
+		if !handleError(err) {
+			return false
+		}
+		traces := chunk.ToTraces() // unwrap ptrace.Traces from chunk
+		if !yield([]ptrace.Traces{traces}, nil) {
+			return false
+		}
+	}
+	return true
+}
+
+func unwrapNotFoundErr(err error) error {
+	if s, _ := status.FromError(err); s != nil {
+		if strings.Contains(s.Message(), spanstore.ErrTraceNotFound.Error()) {
+			return spanstore.ErrTraceNotFound
+		}
+	}
+	return err
+}
diff --git a/cmd/query/app/apiv3/gateway_test.go b/cmd/query/app/apiv3/gateway_test.go
index 64d71fa73cf6..1258d457eed7 100644
--- a/cmd/query/app/apiv3/gateway_test.go
+++ b/cmd/query/app/apiv3/gateway_test.go
@@ -19,7 +19,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/jaegertracing/jaeger/cmd/query/app/internal/api_v3"
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
 	"github.com/jaegertracing/jaeger/model"
 	_ "github.com/jaegertracing/jaeger/pkg/gogocodec" // force gogo codec registration
 	"github.com/jaegertracing/jaeger/storage/spanstore"
diff --git a/cmd/query/app/apiv3/grpc_handler.go b/cmd/query/app/apiv3/grpc_handler.go
index b12342214c89..48af72bad4c7 100644
--- a/cmd/query/app/apiv3/grpc_handler.go
+++ b/cmd/query/app/apiv3/grpc_handler.go
@@ -11,8 +11,8 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
-	"github.com/jaegertracing/jaeger/cmd/query/app/internal/api_v3"
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
diff --git a/cmd/query/app/apiv3/grpc_handler_test.go b/cmd/query/app/apiv3/grpc_handler_test.go
index b40ec48e3c21..bdf80e646461 100644
--- a/cmd/query/app/apiv3/grpc_handler_test.go
+++ b/cmd/query/app/apiv3/grpc_handler_test.go
@@ -16,8 +16,8 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 
-	"github.com/jaegertracing/jaeger/cmd/query/app/internal/api_v3"
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
 	"github.com/jaegertracing/jaeger/model"
 	_ "github.com/jaegertracing/jaeger/pkg/gogocodec" // force gogo codec registration
 	"github.com/jaegertracing/jaeger/storage/spanstore"
diff --git a/cmd/query/app/apiv3/http_gateway.go b/cmd/query/app/apiv3/http_gateway.go
index 0c577183e9a4..57f03b6ebc54 100644
--- a/cmd/query/app/apiv3/http_gateway.go
+++ b/cmd/query/app/apiv3/http_gateway.go
@@ -20,8 +20,8 @@ import (
 	"go.opentelemetry.io/otel/trace"
 	"go.uber.org/zap"
 
-	"github.com/jaegertracing/jaeger/cmd/query/app/internal/api_v3"
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
diff --git a/cmd/query/app/http_handler.go b/cmd/query/app/http_handler.go
index 02ed05c059fc..06c97c94dbfa 100644
--- a/cmd/query/app/http_handler.go
+++ b/cmd/query/app/http_handler.go
@@ -254,10 +254,7 @@ func (aH *APIHandler) search(w http.ResponseWriter, r *http.Request) {
 func (aH *APIHandler) tracesToResponse(traces []*model.Trace, adjust bool, uiErrors []structuredError) *structuredResponse {
 	uiTraces := make([]*ui.Trace, len(traces))
 	for i, v := range traces {
-		uiTrace, uiErr := aH.convertModelToUI(v, adjust)
-		if uiErr != nil {
-			uiErrors = append(uiErrors, *uiErr)
-		}
+		uiTrace := aH.convertModelToUI(v, adjust)
 		uiTraces[i] = uiTrace
 	}
 
@@ -364,24 +361,12 @@ func (aH *APIHandler) metrics(w http.ResponseWriter, r *http.Request, getMetrics
 	aH.writeJSON(w, r, m)
 }
 
-func (aH *APIHandler) convertModelToUI(trc *model.Trace, adjust bool) (*ui.Trace, *structuredError) {
-	var errs []error
+func (aH *APIHandler) convertModelToUI(trc *model.Trace, adjust bool) *ui.Trace {
 	if adjust {
-		var err error
-		trc, err = aH.queryService.Adjust(trc)
-		if err != nil {
-			errs = append(errs, err)
-		}
+		aH.queryService.Adjust(trc)
 	}
 	uiTrace := uiconv.FromDomain(trc)
-	var uiError *structuredError
-	if err := errors.Join(errs...); err != nil {
-		uiError = &structuredError{
-			Msg:     err.Error(),
-			TraceID: uiTrace.TraceID,
-		}
-	}
-	return uiTrace, uiError
+	return uiTrace
 }
 
 func (*APIHandler) deduplicateDependencies(dependencies []model.DependencyLink) []ui.DependencyLink {
diff --git a/cmd/query/app/http_handler_test.go b/cmd/query/app/http_handler_test.go
index 479466d0da04..015c8e0fb7ac 100644
--- a/cmd/query/app/http_handler_test.go
+++ b/cmd/query/app/http_handler_test.go
@@ -32,7 +32,6 @@ import (
 
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
 	"github.com/jaegertracing/jaeger/model"
-	"github.com/jaegertracing/jaeger/model/adjuster"
 	ui "github.com/jaegertracing/jaeger/model/json"
 	"github.com/jaegertracing/jaeger/pkg/jtracer"
 	"github.com/jaegertracing/jaeger/pkg/tenancy"
@@ -59,7 +58,6 @@ func (m *IoReaderMock) Read(b []byte) (int, error) {
 var (
 	errStorageMsg = "storage error"
 	errStorage    = errors.New(errStorageMsg)
-	errAdjustment = errors.New("adjustment error")
 
 	httpClient = &http.Client{
 		Timeout: 2 * time.Second,
@@ -375,25 +373,6 @@ func TestGetTraceNotFound(t *testing.T) {
 	require.EqualError(t, err, parsedError(404, "trace not found"))
 }
 
-func TestGetTraceAdjustmentFailure(t *testing.T) {
-	ts := initializeTestServerWithHandler(
-		t,
-		querysvc.QueryServiceOptions{
-			Adjuster: adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
-				return trace, errAdjustment
-			}),
-		},
-	)
-	ts.spanReader.On("GetTrace", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("spanstore.GetTraceParameters")).
-		Return(mockTrace, nil).Once()
-
-	var response structuredResponse
-	err := getJSON(ts.server.URL+`/api/traces/123456`, &response)
-	require.NoError(t, err)
-	assert.Len(t, response.Errors, 1)
-	assert.EqualValues(t, errAdjustment.Error(), response.Errors[0].Msg)
-}
-
 func TestGetTraceBadTraceID(t *testing.T) {
 	ts := initializeTestServer(t)
 
@@ -564,25 +543,6 @@ func TestSearchByTraceIDFailure(t *testing.T) {
 	require.EqualError(t, err, parsedError(500, whatsamattayou))
 }
 
-func TestSearchModelConversionFailure(t *testing.T) {
-	ts := initializeTestServerWithOptions(
-		t,
-		&tenancy.Manager{},
-		querysvc.QueryServiceOptions{
-			Adjuster: adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
-				return trace, errAdjustment
-			}),
-		},
-	)
-	ts.spanReader.On("FindTraces", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceQueryParameters")).
-		Return([]*model.Trace{mockTrace}, nil).Once()
-	var response structuredResponse
-	err := getJSON(ts.server.URL+`/api/traces?service=service&start=0&end=0&operation=operation&limit=200&minDuration=20ms`, &response)
-	require.NoError(t, err)
-	assert.Len(t, response.Errors, 1)
-	assert.EqualValues(t, errAdjustment.Error(), response.Errors[0].Msg)
-}
-
 func TestSearchDBFailure(t *testing.T) {
 	ts := initializeTestServer(t)
 	ts.spanReader.On("FindTraces", mock.AnythingOfType("*context.valueCtx"), mock.AnythingOfType("*spanstore.TraceQueryParameters")).
diff --git a/cmd/query/app/querysvc/query_service.go b/cmd/query/app/querysvc/query_service.go
index 724a2536583e..3f40b2d44cbd 100644
--- a/cmd/query/app/querysvc/query_service.go
+++ b/cmd/query/app/querysvc/query_service.go
@@ -128,8 +128,8 @@ func (qs QueryService) ArchiveTrace(ctx context.Context, query spanstore.GetTrac
 }
 
 // Adjust applies adjusters to the trace.
-func (qs QueryService) Adjust(trace *model.Trace) (*model.Trace, error) {
-	return qs.options.Adjuster.Adjust(trace)
+func (qs QueryService) Adjust(trace *model.Trace) {
+	qs.options.Adjuster.Adjust(trace)
 }
 
 // GetDependencies implements dependencystore.Reader.GetDependencies
diff --git a/cmd/query/app/querysvc/query_service_test.go b/cmd/query/app/querysvc/query_service_test.go
index 2b1176cf96fc..1d9217ade298 100644
--- a/cmd/query/app/querysvc/query_service_test.go
+++ b/cmd/query/app/querysvc/query_service_test.go
@@ -15,7 +15,6 @@ import (
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/model"
-	"github.com/jaegertracing/jaeger/model/adjuster"
 	"github.com/jaegertracing/jaeger/pkg/metrics"
 	"github.com/jaegertracing/jaeger/pkg/testutils"
 	"github.com/jaegertracing/jaeger/storage"
@@ -31,8 +30,6 @@ import (
 const millisToNanosMultiplier = int64(time.Millisecond / time.Nanosecond)
 
 var (
-	errAdjustment = errors.New("adjustment error")
-
 	defaultDependencyLookbackDuration = time.Hour * 24
 
 	mockTraceID = model.NewTraceID(0, 123456)
@@ -80,14 +77,6 @@ func withArchiveSpanWriter() testOption {
 	}
 }
 
-func withAdjuster() testOption {
-	return func(_ *testQueryService, options *QueryServiceOptions) {
-		options.Adjuster = adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
-			return trace, errAdjustment
-		})
-	}
-}
-
 func initializeTestService(optionAppliers ...testOption) *testQueryService {
 	readStorage := &spanstoremocks.Reader{}
 	traceReader := v1adapter.NewTraceReader(readStorage)
@@ -307,15 +296,6 @@ func TestArchiveTraceSuccess(t *testing.T) {
 	require.NoError(t, err)
 }
 
-// Test QueryService.Adjust()
-func TestTraceAdjustmentFailure(t *testing.T) {
-	tqs := initializeTestService(withAdjuster())
-
-	_, err := tqs.queryService.Adjust(mockTrace)
-	require.Error(t, err)
-	assert.EqualValues(t, errAdjustment.Error(), err.Error())
-}
-
 // Test QueryService.GetDependencies()
 func TestGetDependencies(t *testing.T) {
 	tqs := initializeTestService()
diff --git a/cmd/query/app/server.go b/cmd/query/app/server.go
index 5880dd835964..ab2e89aee6ca 100644
--- a/cmd/query/app/server.go
+++ b/cmd/query/app/server.go
@@ -27,8 +27,8 @@ import (
 	"google.golang.org/grpc/reflection"
 
 	"github.com/jaegertracing/jaeger/cmd/query/app/apiv3"
-	"github.com/jaegertracing/jaeger/cmd/query/app/internal/api_v3"
 	"github.com/jaegertracing/jaeger/cmd/query/app/querysvc"
+	"github.com/jaegertracing/jaeger/internal/proto/api_v3"
 	"github.com/jaegertracing/jaeger/pkg/bearertoken"
 	"github.com/jaegertracing/jaeger/pkg/netutils"
 	"github.com/jaegertracing/jaeger/pkg/recoveryhandler"
diff --git a/docker-compose/kafka/v2/docker-compose.yml b/docker-compose/kafka/v2/docker-compose.yml
deleted file mode 100644
index 5eb0b1d287ce..000000000000
--- a/docker-compose/kafka/v2/docker-compose.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-services:
-  zookeeper:
-    image: bitnami/zookeeper:3.9.3
-    ports:
-      - "2181:2181"
-    environment:
-      - ALLOW_ANONYMOUS_LOGIN=yes
-
-  kafka:
-    image: bitnami/kafka:2.8.0
-    ports:
-      - "9092:9092"
-    environment:
-      - KAFKA_BROKER_ID=1
-      - KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181
-      - KAFKA_LISTENERS=PLAINTEXT://:9092
-      - KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092
-      - KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR=1
-      - ALLOW_PLAINTEXT_LISTENER=yes
-    depends_on:
-      - zookeeper
\ No newline at end of file
diff --git a/idl b/idl
index de97430b579c..63f6e7e5b134 160000
--- a/idl
+++ b/idl
@@ -1 +1 @@
-Subproject commit de97430b579cac669422048a0becc5db981b05ad
+Subproject commit 63f6e7e5b134ec6fb78830f48bd4bd2f1e8fd295
diff --git a/cmd/query/app/internal/api_v3/query_service.pb.go b/internal/proto/api_v3/query_service.pb.go
similarity index 91%
rename from cmd/query/app/internal/api_v3/query_service.pb.go
rename to internal/proto/api_v3/query_service.pb.go
index 2f071becc4cc..6d687b9b2217 100644
--- a/cmd/query/app/internal/api_v3/query_service.pb.go
+++ b/internal/proto/api_v3/query_service.pb.go
@@ -39,10 +39,14 @@ type GetTraceRequest struct {
 	// Optional. The start time to search trace ID.
 	StartTime time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"`
 	// Optional. The end time to search trace ID.
-	EndTime              time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	EndTime time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"`
+	// Optional. If set to true, the response will not include any
+	// enrichments to the trace, such as clock skew adjustment.
+	// Instead, the trace will be returned exactly as stored.
+	RawTraces            bool     `protobuf:"varint,4,opt,name=raw_traces,json=rawTraces,proto3" json:"raw_traces,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *GetTraceRequest) Reset()         { *m = GetTraceRequest{} }
@@ -99,6 +103,13 @@ func (m *GetTraceRequest) GetEndTime() time.Time {
 	return time.Time{}
 }
 
+func (m *GetTraceRequest) GetRawTraces() bool {
+	if m != nil {
+		return m.RawTraces
+	}
+	return false
+}
+
 // Query parameters to find traces. Except for num_traces, all fields should be treated
 // as forming a conjunction, e.g., "service_name='X' AND operation_name='Y' AND ...".
 // All fields are matched against individual spans, not at the trace level.
@@ -129,7 +140,11 @@ type TraceQueryParameters struct {
 	// implementtaion this could be like a regular LIMIT clause in SQL,
 	// but not all implementations support such accuracy and for those
 	// the larger depth value simply means more traces returned.
-	SearchDepth          int32    `protobuf:"varint,8,opt,name=search_depth,json=searchDepth,proto3" json:"search_depth,omitempty"`
+	SearchDepth int32 `protobuf:"varint,8,opt,name=search_depth,json=searchDepth,proto3" json:"search_depth,omitempty"`
+	// Optional. If set to true, the response will not include any
+	// enrichments to the trace, such as clock skew adjustment.
+	// Instead, the trace will be returned exactly as stored.
+	RawTraces            bool     `protobuf:"varint,9,opt,name=raw_traces,json=rawTraces,proto3" json:"raw_traces,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -224,6 +239,13 @@ func (m *TraceQueryParameters) GetSearchDepth() int32 {
 	return 0
 }
 
+func (m *TraceQueryParameters) GetRawTraces() bool {
+	if m != nil {
+		return m.RawTraces
+	}
+	return false
+}
+
 // Request object to search traces.
 type FindTracesRequest struct {
 	Query                *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
@@ -720,61 +742,62 @@ func init() {
 func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) }
 
 var fileDescriptor_5fcb6756dc1afb8d = []byte{
-	// 851 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xdd, 0x6e, 0x1b, 0x55,
-	0x10, 0xce, 0xda, 0x71, 0x62, 0x8f, 0x93, 0xb6, 0x9c, 0x1a, 0x75, 0xbb, 0x48, 0x8e, 0xbb, 0x05,
+	// 871 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xdd, 0x6e, 0x1b, 0x45,
+	0x14, 0xce, 0xda, 0x71, 0xe2, 0x3d, 0x4e, 0xda, 0x32, 0x35, 0xea, 0x76, 0x11, 0x8e, 0xbb, 0x05,
 	0xc9, 0x37, 0x6c, 0x88, 0x73, 0x41, 0x41, 0x20, 0xa0, 0x49, 0x6b, 0x01, 0x4a, 0x69, 0x37, 0x55,
-	0x41, 0xa8, 0xd2, 0xea, 0x24, 0x3b, 0x6c, 0x96, 0x7a, 0x7f, 0x7a, 0xce, 0x59, 0x63, 0x3f, 0x03,
-	0x37, 0x5c, 0xf2, 0x1c, 0xbc, 0x00, 0xb7, 0xbd, 0xe4, 0x09, 0x00, 0xe5, 0x05, 0x78, 0x01, 0x2e,
-	0xd0, 0xf9, 0xd9, 0xad, 0xbd, 0xa6, 0x51, 0xd3, 0x2b, 0x9f, 0x99, 0xf3, 0xcd, 0x37, 0x73, 0xbe,
-	0x99, 0x59, 0xc3, 0xf5, 0xe7, 0x05, 0xb2, 0x79, 0xc0, 0x91, 0x4d, 0xe3, 0x53, 0xf4, 0x72, 0x96,
-	0x89, 0x8c, 0x6c, 0xff, 0x48, 0x31, 0x42, 0xe6, 0xd1, 0x3c, 0x0e, 0xa6, 0xfb, 0xce, 0x30, 0xcb,
-	0x31, 0x15, 0x38, 0xc1, 0x04, 0x05, 0x9b, 0xef, 0x2a, 0xcc, 0xae, 0x60, 0xf4, 0x14, 0x77, 0xa7,
-	0x7b, 0xfa, 0xa0, 0x03, 0x9d, 0x9d, 0x28, 0xcb, 0xa2, 0x09, 0x6a, 0xc8, 0x49, 0xf1, 0xc3, 0xae,
-	0x88, 0x13, 0xe4, 0x82, 0x26, 0xb9, 0x01, 0xf4, 0xeb, 0x80, 0xb0, 0x60, 0x54, 0xc4, 0x59, 0x6a,
-	0xee, 0x7b, 0x51, 0x16, 0x65, 0x3a, 0x81, 0x3c, 0x69, 0xaf, 0xfb, 0x9b, 0x05, 0x57, 0xc7, 0x28,
-	0x1e, 0xcb, 0x4c, 0x3e, 0x3e, 0x2f, 0x90, 0x0b, 0x72, 0x13, 0xda, 0x2a, 0x73, 0x10, 0x87, 0xb6,
-	0x35, 0xb0, 0x86, 0x1d, 0x7f, 0x53, 0xd9, 0x5f, 0x86, 0xe4, 0x00, 0x80, 0x0b, 0xca, 0x44, 0x20,
-	0xb3, 0xdb, 0x8d, 0x81, 0x35, 0xec, 0x8e, 0x1c, 0x4f, 0x67, 0xf6, 0xca, 0xcc, 0xde, 0xe3, 0xb2,
-	0xb4, 0xbb, 0xed, 0x17, 0x7f, 0xee, 0xac, 0xfd, 0xf2, 0xd7, 0x8e, 0xe5, 0x77, 0x54, 0x9c, 0xbc,
-	0x21, 0x9f, 0x41, 0x1b, 0xd3, 0x50, 0x53, 0x34, 0x2f, 0x41, 0xb1, 0x89, 0x69, 0x28, 0xfd, 0xee,
-	0xef, 0xeb, 0xd0, 0x53, 0x15, 0x3f, 0x92, 0x0a, 0x3f, 0xa4, 0x8c, 0x26, 0x28, 0x90, 0x71, 0x72,
-	0x0b, 0xb6, 0x8c, 0xdc, 0x41, 0x4a, 0x13, 0x34, 0xd5, 0x77, 0x8d, 0xef, 0x01, 0x4d, 0x90, 0xbc,
-	0x07, 0x57, 0xb2, 0x1c, 0xb5, 0x32, 0x1a, 0xd4, 0x50, 0xa0, 0xed, 0xca, 0xab, 0x60, 0xc7, 0x00,
-	0x54, 0x08, 0x16, 0x9f, 0x14, 0x02, 0xb9, 0xdd, 0x1c, 0x34, 0x87, 0xdd, 0xd1, 0xbe, 0xb7, 0xd4,
-	0x3c, 0xef, 0xff, 0x4a, 0xf0, 0xbe, 0xa8, 0xa2, 0xee, 0xa5, 0x82, 0xcd, 0xfd, 0x05, 0x1a, 0xf2,
-	0x15, 0x5c, 0x79, 0xa9, 0x5e, 0x90, 0xc4, 0xa9, 0xbd, 0x7e, 0x89, 0xe7, 0x6f, 0x55, 0x0a, 0x1e,
-	0xc5, 0x69, 0x9d, 0x8b, 0xce, 0xec, 0xd6, 0x9b, 0x71, 0xd1, 0x19, 0xb9, 0x0f, 0x5b, 0xe5, 0xb0,
-	0xa8, 0xaa, 0x36, 0x14, 0xd3, 0xcd, 0x15, 0xa6, 0x43, 0x03, 0xd2, 0x44, 0xbf, 0x4a, 0xa2, 0x6e,
-	0x19, 0x28, 0x6b, 0x5a, 0xe2, 0xa1, 0x33, 0x7b, 0xf3, 0x4d, 0x78, 0xe8, 0x4c, 0xb7, 0x91, 0xb2,
-	0xd3, 0xb3, 0x20, 0xc4, 0x5c, 0x9c, 0xd9, 0xed, 0x81, 0x35, 0x6c, 0xc9, 0x36, 0x4a, 0xdf, 0xa1,
-	0x74, 0x39, 0x9f, 0xc2, 0xd5, 0x9a, 0xd2, 0xe4, 0x1a, 0x34, 0x9f, 0xe1, 0xdc, 0xf4, 0x5c, 0x1e,
-	0x49, 0x0f, 0x5a, 0x53, 0x3a, 0x29, 0xca, 0x16, 0x6b, 0xe3, 0xe3, 0xc6, 0x1d, 0xcb, 0x7d, 0x00,
-	0x6f, 0xdd, 0x8f, 0xd3, 0x50, 0x75, 0x90, 0x97, 0x73, 0xff, 0x11, 0xb4, 0xd4, 0xca, 0x2a, 0x8a,
-	0xee, 0xe8, 0xf6, 0x6b, 0xb4, 0xdb, 0xd7, 0x11, 0x6e, 0x0f, 0xc8, 0x18, 0xc5, 0xb1, 0x9e, 0xb3,
-	0x92, 0xd0, 0xdd, 0x83, 0xeb, 0x4b, 0x5e, 0x9e, 0x67, 0x29, 0x47, 0xe2, 0x40, 0xdb, 0x4c, 0x24,
-	0xb7, 0xad, 0x41, 0x73, 0xd8, 0xf1, 0x2b, 0xdb, 0x3d, 0x82, 0xde, 0x18, 0xc5, 0x37, 0xe5, 0x2c,
-	0x56, 0xb5, 0xd9, 0xb0, 0x69, 0x30, 0xe5, 0x4a, 0x1a, 0x93, 0xbc, 0x03, 0x1d, 0x9e, 0xd3, 0x34,
-	0x78, 0x16, 0xa7, 0xa1, 0x79, 0x68, 0x5b, 0x3a, 0xbe, 0x8e, 0xd3, 0xd0, 0xfd, 0x04, 0x3a, 0x15,
-	0x17, 0x21, 0xb0, 0xbe, 0xb0, 0x15, 0xea, 0x7c, 0x71, 0xf4, 0x23, 0x78, 0xbb, 0x56, 0x8c, 0x79,
-	0xc1, 0x1d, 0x80, 0x6a, 0x5d, 0xf4, 0x1b, 0xba, 0x23, 0xbb, 0x26, 0x57, 0x15, 0xe6, 0x2f, 0x60,
-	0xdd, 0x7f, 0x2c, 0xb8, 0x36, 0xf6, 0x1f, 0x1e, 0x8c, 0xa9, 0xc0, 0x9f, 0xe8, 0xfc, 0x1e, 0x63,
-	0x19, 0x23, 0x47, 0xd0, 0x42, 0x79, 0x30, 0xc2, 0x7f, 0x58, 0x63, 0xaa, 0xe3, 0x57, 0x1c, 0x87,
-	0x28, 0x68, 0x3c, 0xe1, 0xbe, 0x66, 0x71, 0x7e, 0xb6, 0xe0, 0xc6, 0x2b, 0x20, 0x52, 0xfb, 0x88,
-	0xe5, 0xa7, 0x07, 0x59, 0xa8, 0x75, 0x68, 0xf9, 0x95, 0x2d, 0xef, 0xce, 0x84, 0xc8, 0xd5, 0x5d,
-	0x43, 0xdf, 0x95, 0xb6, 0xd4, 0x3f, 0x41, 0xce, 0x69, 0xa4, 0x3f, 0x59, 0x1d, 0xbf, 0x34, 0x49,
-	0x1f, 0x40, 0xa2, 0x8e, 0x05, 0x15, 0x05, 0x57, 0x0b, 0xdd, 0xf1, 0x17, 0x3c, 0xee, 0x13, 0x20,
-	0x0b, 0xc5, 0x7c, 0xcb, 0x68, 0x9e, 0x23, 0x23, 0x9f, 0xc3, 0x06, 0x43, 0x5e, 0x4c, 0x84, 0x79,
-	0xf3, 0xd0, 0x5b, 0xfa, 0x27, 0xd0, 0xbb, 0xe2, 0xe9, 0x3f, 0x80, 0xe9, 0x9e, 0x9e, 0x3d, 0x7e,
-	0x48, 0x05, 0xf5, 0x4d, 0xdc, 0xe8, 0xdf, 0x06, 0x6c, 0xa9, 0x69, 0x34, 0xf3, 0x45, 0xbe, 0x83,
-	0x76, 0xf9, 0x25, 0x27, 0xfd, 0xba, 0x84, 0xcb, 0x9f, 0x78, 0xe7, 0xb5, 0xd3, 0xb9, 0x6b, 0x1f,
-	0x58, 0xe4, 0x29, 0xc0, 0xcb, 0x6d, 0x21, 0x83, 0x1a, 0xf7, 0xca, 0x22, 0x5d, 0x92, 0xfd, 0x09,
-	0x74, 0x17, 0xb6, 0x84, 0xdc, 0x5a, 0x2d, 0xbd, 0xb6, 0x57, 0x8e, 0x7b, 0x11, 0x44, 0x8f, 0xa8,
-	0xbb, 0x46, 0x9e, 0xc2, 0xf6, 0xd2, 0xf4, 0x92, 0xdb, 0xab, 0x61, 0x2b, 0x8b, 0xe6, 0xbc, 0x7b,
-	0x31, 0xa8, 0x64, 0xbf, 0xfb, 0xfe, 0x8b, 0xf3, 0xbe, 0xf5, 0xc7, 0x79, 0xdf, 0xfa, 0xfb, 0xbc,
-	0x6f, 0xc1, 0x8d, 0x38, 0x33, 0x71, 0xf2, 0x95, 0x71, 0x1a, 0x99, 0xf0, 0xef, 0x37, 0xf4, 0xef,
-	0xc9, 0x86, 0xd2, 0x60, 0xff, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0x54, 0x95, 0xcd, 0x15,
-	0x08, 0x00, 0x00,
+	0x41, 0xa8, 0xd2, 0x6a, 0x92, 0x3d, 0x38, 0x4b, 0xbd, 0x3f, 0x9d, 0x99, 0x75, 0xe2, 0x67, 0xe0,
+	0x86, 0x4b, 0x1e, 0xa9, 0x97, 0xf0, 0x02, 0x05, 0xe5, 0x05, 0x78, 0x01, 0x2e, 0xd0, 0xfc, 0xec,
+	0xd6, 0x5e, 0xd3, 0x28, 0xed, 0x95, 0xe7, 0x9c, 0xf9, 0xce, 0x77, 0x7e, 0xe6, 0x3b, 0x5e, 0xb8,
+	0xfe, 0xbc, 0x40, 0x36, 0x0b, 0x39, 0xb2, 0x69, 0x7c, 0x8c, 0x7e, 0xce, 0x32, 0x91, 0x91, 0xcd,
+	0x5f, 0x28, 0x8e, 0x91, 0xf9, 0x34, 0x8f, 0xc3, 0xe9, 0xae, 0x3b, 0xc8, 0x72, 0x4c, 0x05, 0x4e,
+	0x30, 0x41, 0xc1, 0x66, 0xdb, 0x0a, 0xb3, 0x2d, 0x18, 0x3d, 0xc6, 0xed, 0xe9, 0x8e, 0x3e, 0xe8,
+	0x40, 0x77, 0x6b, 0x9c, 0x65, 0xe3, 0x09, 0x6a, 0xc8, 0x51, 0xf1, 0xf3, 0xb6, 0x88, 0x13, 0xe4,
+	0x82, 0x26, 0xb9, 0x01, 0xf4, 0xea, 0x80, 0xa8, 0x60, 0x54, 0xc4, 0x59, 0x6a, 0xee, 0xbb, 0xe3,
+	0x6c, 0x9c, 0xe9, 0x04, 0xf2, 0xa4, 0xbd, 0xde, 0x9f, 0x16, 0x5c, 0x1d, 0xa1, 0x78, 0x2c, 0x33,
+	0x05, 0xf8, 0xbc, 0x40, 0x2e, 0xc8, 0x4d, 0x68, 0xab, 0xcc, 0x61, 0x1c, 0x39, 0x56, 0xdf, 0x1a,
+	0xd8, 0xc1, 0xba, 0xb2, 0xbf, 0x89, 0xc8, 0x1e, 0x00, 0x17, 0x94, 0x89, 0x50, 0x66, 0x77, 0x1a,
+	0x7d, 0x6b, 0xd0, 0x19, 0xba, 0xbe, 0xce, 0xec, 0x97, 0x99, 0xfd, 0xc7, 0x65, 0x69, 0x77, 0xdb,
+	0x2f, 0x5e, 0x6e, 0xad, 0xfc, 0xf6, 0xd7, 0x96, 0x15, 0xd8, 0x2a, 0x4e, 0xde, 0x90, 0x2f, 0xa1,
+	0x8d, 0x69, 0xa4, 0x29, 0x9a, 0x6f, 0x40, 0xb1, 0x8e, 0x69, 0xa4, 0x08, 0xde, 0x07, 0x60, 0xf4,
+	0x34, 0x54, 0x45, 0x71, 0x67, 0xb5, 0x6f, 0x0d, 0xda, 0x81, 0xcd, 0xe8, 0xa9, 0xea, 0x82, 0x7b,
+	0x2f, 0x57, 0xa1, 0xab, 0x8e, 0x8f, 0xe4, 0x03, 0x3c, 0xa4, 0x8c, 0x26, 0x28, 0x90, 0x71, 0x72,
+	0x0b, 0x36, 0xcc, 0x6b, 0x84, 0x29, 0x4d, 0xd0, 0x34, 0xd7, 0x31, 0xbe, 0x07, 0x34, 0x41, 0xf2,
+	0x21, 0x5c, 0xc9, 0x72, 0xd4, 0x83, 0xd3, 0xa0, 0x86, 0x02, 0x6d, 0x56, 0x5e, 0x05, 0x3b, 0x04,
+	0xa0, 0x42, 0xb0, 0xf8, 0xa8, 0x10, 0xc8, 0x9d, 0x66, 0xbf, 0x39, 0xe8, 0x0c, 0x77, 0xfd, 0x85,
+	0xb7, 0xf5, 0xff, 0xaf, 0x04, 0xff, 0xeb, 0x2a, 0xea, 0x5e, 0x2a, 0xd8, 0x2c, 0x98, 0xa3, 0x21,
+	0xdf, 0xc2, 0x95, 0x57, 0xc3, 0x0d, 0x93, 0x38, 0x55, 0xad, 0x5d, 0x76, 0x3a, 0x1b, 0xd5, 0x80,
+	0x0f, 0xe2, 0xb4, 0xce, 0x45, 0xcf, 0x9c, 0xd6, 0xdb, 0x71, 0xd1, 0x33, 0x72, 0x1f, 0x36, 0x4a,
+	0x2d, 0xa9, 0xaa, 0xd6, 0x14, 0xd3, 0xcd, 0x25, 0xa6, 0x7d, 0x03, 0xd2, 0x44, 0xbf, 0x4b, 0xa2,
+	0x4e, 0x19, 0x28, 0x6b, 0x5a, 0xe0, 0xa1, 0x67, 0xce, 0xfa, 0xdb, 0xf0, 0xd0, 0x33, 0xfd, 0x8c,
+	0x94, 0x1d, 0x9f, 0x84, 0x11, 0xe6, 0xe2, 0xc4, 0x69, 0xf7, 0xad, 0x41, 0x4b, 0x3e, 0xa3, 0xf4,
+	0xed, 0x4b, 0x57, 0x4d, 0x21, 0x76, 0x4d, 0x21, 0xee, 0x17, 0x70, 0xb5, 0xf6, 0x10, 0xe4, 0x1a,
+	0x34, 0x9f, 0xe1, 0xcc, 0x48, 0x42, 0x1e, 0x49, 0x17, 0x5a, 0x53, 0x3a, 0x29, 0x4a, 0x05, 0x68,
+	0xe3, 0xb3, 0xc6, 0x1d, 0xcb, 0x7b, 0x00, 0xef, 0xdc, 0x8f, 0xd3, 0x48, 0x93, 0x95, 0x5b, 0xf3,
+	0x29, 0xb4, 0xd4, 0xc2, 0x2b, 0x8a, 0xce, 0xf0, 0xf6, 0x25, 0xd4, 0x10, 0xe8, 0x08, 0xaf, 0x0b,
+	0x64, 0x84, 0xe2, 0x50, 0xcb, 0xb0, 0x24, 0xf4, 0x76, 0xe0, 0xfa, 0x82, 0x97, 0xe7, 0x59, 0xca,
+	0x91, 0xb8, 0xd0, 0x36, 0x82, 0xe5, 0x8e, 0xd5, 0x6f, 0x0e, 0xec, 0xa0, 0xb2, 0xbd, 0x03, 0xe8,
+	0x8e, 0x50, 0x7c, 0x5f, 0x4a, 0xb5, 0xaa, 0xcd, 0x81, 0x75, 0x83, 0x29, 0x17, 0xda, 0x98, 0xe4,
+	0x3d, 0xb0, 0x79, 0x4e, 0xd3, 0xf0, 0x59, 0x9c, 0x46, 0xa6, 0xd1, 0xb6, 0x74, 0x7c, 0x17, 0xa7,
+	0x91, 0xf7, 0x39, 0xd8, 0x15, 0x17, 0x21, 0xb0, 0x3a, 0xb7, 0x34, 0xea, 0x7c, 0x71, 0xf4, 0x23,
+	0x78, 0xb7, 0x56, 0x8c, 0xe9, 0xe0, 0x0e, 0x40, 0xb5, 0x4d, 0xba, 0x87, 0xce, 0xd0, 0xa9, 0x8d,
+	0xab, 0x0a, 0x0b, 0xe6, 0xb0, 0xde, 0x3f, 0x16, 0x5c, 0x1b, 0x05, 0x0f, 0xf7, 0x46, 0x54, 0xe0,
+	0x29, 0x9d, 0xdd, 0x63, 0x2c, 0x63, 0xe4, 0x00, 0x5a, 0x28, 0x0f, 0x66, 0xf0, 0x9f, 0xd4, 0x98,
+	0xea, 0xf8, 0x25, 0xc7, 0x3e, 0x0a, 0x1a, 0x4f, 0x78, 0xa0, 0x59, 0xdc, 0x5f, 0x2d, 0xb8, 0xf1,
+	0x1a, 0x88, 0x9c, 0xfd, 0x98, 0xe5, 0xc7, 0x7b, 0x59, 0xa4, 0xe7, 0xd0, 0x0a, 0x2a, 0x5b, 0xde,
+	0x9d, 0x08, 0x91, 0xab, 0xbb, 0x86, 0xbe, 0x2b, 0x6d, 0x39, 0xff, 0x04, 0x39, 0xa7, 0x63, 0xfd,
+	0x87, 0x67, 0x07, 0xa5, 0x49, 0x7a, 0x00, 0x12, 0x75, 0x28, 0xa8, 0x28, 0xf4, 0x5f, 0x99, 0x1d,
+	0xcc, 0x79, 0xbc, 0x27, 0x40, 0xe6, 0x8a, 0xf9, 0x81, 0xd1, 0x3c, 0x47, 0x46, 0xbe, 0x82, 0x35,
+	0x86, 0xbc, 0x98, 0x08, 0xd3, 0xf3, 0xc0, 0x5f, 0xf8, 0x8e, 0xe8, 0x55, 0xf2, 0xf5, 0xe7, 0x63,
+	0xba, 0xa3, 0xb5, 0xc7, 0xf7, 0xa9, 0xa0, 0x81, 0x89, 0x1b, 0xfe, 0xdb, 0x80, 0x0d, 0xa5, 0x46,
+	0xa3, 0x2f, 0xf2, 0x23, 0xb4, 0xcb, 0xef, 0x00, 0xe9, 0xd5, 0x47, 0xb8, 0xf8, 0x81, 0x70, 0x2f,
+	0x9d, 0xce, 0x5b, 0xf9, 0xd8, 0x22, 0x4f, 0x01, 0x5e, 0x6d, 0x0b, 0xe9, 0xd7, 0xb8, 0x97, 0x16,
+	0xe9, 0x0d, 0xd9, 0x9f, 0x40, 0x67, 0x6e, 0x4b, 0xc8, 0xad, 0xe5, 0xd2, 0x6b, 0x7b, 0xe5, 0x7a,
+	0x17, 0x41, 0xb4, 0x44, 0xbd, 0x15, 0xf2, 0x14, 0x36, 0x17, 0xd4, 0x4b, 0x6e, 0x2f, 0x87, 0x2d,
+	0x2d, 0x9a, 0xfb, 0xc1, 0xc5, 0xa0, 0x92, 0xfd, 0xee, 0x47, 0x2f, 0xce, 0x7b, 0xd6, 0x1f, 0xe7,
+	0x3d, 0xeb, 0xef, 0xf3, 0x9e, 0x05, 0x37, 0xe2, 0xcc, 0xc4, 0xc9, 0x2e, 0xe3, 0x74, 0x6c, 0xc2,
+	0x7f, 0x5a, 0xd3, 0xbf, 0x47, 0x6b, 0x6a, 0x06, 0xbb, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x7d,
+	0x9f, 0xff, 0x8a, 0x53, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1062,6 +1085,16 @@ func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.RawTraces {
+		i--
+		if m.RawTraces {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x20
+	}
 	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):])
 	if err1 != nil {
 		return 0, err1
@@ -1112,6 +1145,16 @@ func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.RawTraces {
+		i--
+		if m.RawTraces {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x48
+	}
 	if m.SearchDepth != 0 {
 		i = encodeVarintQueryService(dAtA, i, uint64(m.SearchDepth))
 		i--
@@ -1564,6 +1607,9 @@ func (m *GetTraceRequest) Size() (n int) {
 	n += 1 + l + sovQueryService(uint64(l))
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime)
 	n += 1 + l + sovQueryService(uint64(l))
+	if m.RawTraces {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -1603,6 +1649,9 @@ func (m *TraceQueryParameters) Size() (n int) {
 	if m.SearchDepth != 0 {
 		n += 1 + sovQueryService(uint64(m.SearchDepth))
 	}
+	if m.RawTraces {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -1904,6 +1953,26 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RawTraces", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQueryService
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RawTraces = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQueryService(dAtA[iNdEx:])
@@ -2297,6 +2366,26 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RawTraces", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQueryService
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RawTraces = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQueryService(dAtA[iNdEx:])
diff --git a/cmd/query/app/internal/api_v3/traces.go b/internal/proto/api_v3/traces.go
similarity index 100%
rename from cmd/query/app/internal/api_v3/traces.go
rename to internal/proto/api_v3/traces.go
diff --git a/cmd/query/app/internal/api_v3/traces_test.go b/internal/proto/api_v3/traces_test.go
similarity index 100%
rename from cmd/query/app/internal/api_v3/traces_test.go
rename to internal/proto/api_v3/traces_test.go
diff --git a/model/adjuster/adjuster.go b/model/adjuster/adjuster.go
index ac808866326a..5f97741398db 100644
--- a/model/adjuster/adjuster.go
+++ b/model/adjuster/adjuster.go
@@ -5,57 +5,34 @@
 package adjuster
 
 import (
-	"errors"
-
 	"github.com/jaegertracing/jaeger/model"
 )
 
-// Adjuster applies certain modifications to a Trace object.
-// It returns adjusted Trace, which can be the same Trace updated in place.
-// If it detects a problem with the trace that prevents it from applying
-// adjustments, it must still return the original trace, and the error.
+// Adjuster is an interface for modifying a trace object in place.
 type Adjuster interface {
-	Adjust(trace *model.Trace) (*model.Trace, error)
+	Adjust(trace *model.Trace)
 }
 
 // Func wraps a function of appropriate signature and makes an Adjuster from it.
-type Func func(trace *model.Trace) (*model.Trace, error)
+type Func func(trace *model.Trace)
 
 // Adjust implements Adjuster interface.
-func (f Func) Adjust(trace *model.Trace) (*model.Trace, error) {
-	return f(trace)
+func (f Func) Adjust(trace *model.Trace) {
+	f(trace)
 }
 
 // Sequence creates an adjuster that combines a series of adjusters
-// applied in order. Errors from each step are accumulated and returned
-// in the end as a single wrapper error. Errors do not interrupt the
-// sequence of adapters.
+// applied in order.
 func Sequence(adjusters ...Adjuster) Adjuster {
 	return sequence{adjusters: adjusters}
 }
 
-// FailFastSequence is similar to Sequence() but returns immediately
-// if any adjuster returns an error.
-func FailFastSequence(adjusters ...Adjuster) Adjuster {
-	return sequence{adjusters: adjusters, failFast: true}
-}
-
 type sequence struct {
 	adjusters []Adjuster
-	failFast  bool
 }
 
-func (c sequence) Adjust(trace *model.Trace) (*model.Trace, error) {
-	var errs []error
+func (c sequence) Adjust(trace *model.Trace) {
 	for _, adjuster := range c.adjusters {
-		var err error
-		trace, err = adjuster.Adjust(trace)
-		if err != nil {
-			if c.failFast {
-				return trace, err
-			}
-			errs = append(errs, err)
-		}
+		adjuster.Adjust(trace)
 	}
-	return trace, errors.Join(errs...)
 }
diff --git a/model/adjuster/adjuster_test.go b/model/adjuster/adjuster_test.go
index 0a0960920b56..ddd7b26c7445 100644
--- a/model/adjuster/adjuster_test.go
+++ b/model/adjuster/adjuster_test.go
@@ -5,12 +5,9 @@
 package adjuster_test
 
 import (
-	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/model/adjuster"
@@ -18,41 +15,17 @@ import (
 
 func TestSequences(t *testing.T) {
 	// mock adjuster that increments span ID
-	adj := adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
+	adj := adjuster.Func(func(trace *model.Trace) {
 		trace.Spans[0].SpanID++
-		return trace, nil
 	})
 
-	adjErr := errors.New("mock adjuster error")
-	failingAdj := adjuster.Func(func(trace *model.Trace) (*model.Trace, error) {
-		return trace, adjErr
-	})
+	seqAdjuster := adjuster.Sequence(adj, adj)
+
+	span := &model.Span{}
+	trace := model.Trace{Spans: []*model.Span{span}}
+
+	seqAdjuster.Adjust(&trace)
 
-	testCases := []struct {
-		adjuster   adjuster.Adjuster
-		err        string
-		lastSpanID int
-	}{
-		{
-			adjuster:   adjuster.Sequence(adj, failingAdj, adj, failingAdj),
-			err:        fmt.Sprintf("%s\n%s", adjErr, adjErr),
-			lastSpanID: 2,
-		},
-		{
-			adjuster:   adjuster.FailFastSequence(adj, failingAdj, adj, failingAdj),
-			err:        adjErr.Error(),
-			lastSpanID: 1,
-		},
-	}
-
-	for _, testCase := range testCases {
-		span := &model.Span{}
-		trace := model.Trace{Spans: []*model.Span{span}}
-
-		adjTrace, err := testCase.adjuster.Adjust(&trace)
-
-		assert.Equal(t, span, adjTrace.Spans[0], "same trace & span returned")
-		assert.EqualValues(t, testCase.lastSpanID, span.SpanID, "expect span ID to be incremented")
-		require.EqualError(t, err, testCase.err)
-	}
+	assert.Equal(t, span, trace.Spans[0], "same trace & span returned")
+	assert.EqualValues(t, 2, span.SpanID, "expect span ID to be incremented")
 }
diff --git a/model/adjuster/bad_span_references.go b/model/adjuster/bad_span_references.go
index 3720be424b34..8f30ec3938b7 100644
--- a/model/adjuster/bad_span_references.go
+++ b/model/adjuster/bad_span_references.go
@@ -12,12 +12,11 @@ import (
 
 // SpanReferences creates an adjuster that removes invalid span references, e.g. with traceID==0
 func SpanReferences() Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		adjuster := spanReferenceAdjuster{}
 		for _, span := range trace.Spans {
 			adjuster.adjust(span)
 		}
-		return trace, nil
 	})
 }
 
diff --git a/model/adjuster/bad_span_references_test.go b/model/adjuster/bad_span_references_test.go
index 72952c30f402..4c671704e98e 100644
--- a/model/adjuster/bad_span_references_test.go
+++ b/model/adjuster/bad_span_references_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 )
@@ -29,8 +28,7 @@ func TestSpanReferencesAdjuster(t *testing.T) {
 			},
 		},
 	}
-	trace, err := SpanReferences().Adjust(trace)
-	require.NoError(t, err)
+	SpanReferences().Adjust(trace)
 	assert.Empty(t, trace.Spans[0].References)
 	assert.Empty(t, trace.Spans[1].References)
 	assert.Len(t, trace.Spans[2].References, 2)
diff --git a/model/adjuster/clockskew.go b/model/adjuster/clockskew.go
index 30f922307dcf..27cfc0851d53 100644
--- a/model/adjuster/clockskew.go
+++ b/model/adjuster/clockskew.go
@@ -21,10 +21,9 @@ import (
 // The algorithm assumes that all spans have unique IDs, so the trace may need
 // to go through another adjuster first, such as ZipkinSpanIDUniquifier.
 //
-// This adjuster never returns any errors. Instead it records any issues
-// it encounters in Span.Warnings.
+// Any issues encountered by the adjuster are recorded in Span.Warnings.
 func ClockSkew(maxDelta time.Duration) Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		adjuster := &clockSkewAdjuster{
 			trace:    trace,
 			maxDelta: maxDelta,
@@ -35,7 +34,6 @@ func ClockSkew(maxDelta time.Duration) Adjuster {
 			skew := clockSkew{hostKey: n.hostKey}
 			adjuster.adjustNode(n, nil, skew)
 		}
-		return adjuster.trace, nil
 	})
 }
 
diff --git a/model/adjuster/clockskew_test.go b/model/adjuster/clockskew_test.go
index 5d5023e4d493..1e0d2d8a62a4 100644
--- a/model/adjuster/clockskew_test.go
+++ b/model/adjuster/clockskew_test.go
@@ -187,8 +187,8 @@ func TestClockSkewAdjuster(t *testing.T) {
 		testCase := tt // capture loop var
 		t.Run(testCase.description, func(t *testing.T) {
 			adjuster := ClockSkew(tt.maxAdjust)
-			trace, err := adjuster.Adjust(makeTrace(testCase.trace))
-			require.NoError(t, err)
+			trace := makeTrace(testCase.trace)
+			adjuster.Adjust(trace)
 			if testCase.err != "" {
 				var err string
 				for _, span := range trace.Spans {
diff --git a/model/adjuster/ip_tag.go b/model/adjuster/ip_tag.go
index b3105fe6b5d4..2f11e304022a 100644
--- a/model/adjuster/ip_tag.go
+++ b/model/adjuster/ip_tag.go
@@ -49,12 +49,11 @@ func IPTagAdjuster() Adjuster {
 		}
 	}
 
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		for _, span := range trace.Spans {
 			adjustTags(span.Tags)
 			adjustTags(span.Process.Tags)
 			model.KeyValues(span.Process.Tags).Sort()
 		}
-		return trace, nil
 	})
 }
diff --git a/model/adjuster/ip_tag_test.go b/model/adjuster/ip_tag_test.go
index 716efb020b53..ae8ec352d38d 100644
--- a/model/adjuster/ip_tag_test.go
+++ b/model/adjuster/ip_tag_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 )
@@ -36,8 +35,7 @@ func TestIPTagAdjuster(t *testing.T) {
 			},
 		},
 	}
-	trace, err := IPTagAdjuster().Adjust(trace)
-	require.NoError(t, err)
+	IPTagAdjuster().Adjust(trace)
 
 	expectedSpanTags := model.KeyValues{
 		model.Int64("a", 42),
diff --git a/model/adjuster/otel_tag.go b/model/adjuster/otel_tag.go
index e579856726d2..7811e8ebb19a 100644
--- a/model/adjuster/otel_tag.go
+++ b/model/adjuster/otel_tag.go
@@ -32,11 +32,10 @@ func OTelTagAdjuster() Adjuster {
 		span.Tags = span.Tags[:newI]
 	}
 
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		for _, span := range trace.Spans {
 			adjustSpanTags(span)
 			model.KeyValues(span.Process.Tags).Sort()
 		}
-		return trace, nil
 	})
 }
diff --git a/model/adjuster/otel_tag_test.go b/model/adjuster/otel_tag_test.go
index 7e0b802d56c2..c87708a43ce7 100644
--- a/model/adjuster/otel_tag_test.go
+++ b/model/adjuster/otel_tag_test.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/pkg/otelsemconv"
@@ -79,8 +78,7 @@ func TestOTelTagAdjuster(t *testing.T) {
 			trace := &model.Trace{
 				Spans: []*model.Span{testCase.span},
 			}
-			trace, err := OTelTagAdjuster().Adjust(trace)
-			require.NoError(t, err)
+			OTelTagAdjuster().Adjust(trace)
 			assert.Equal(t, testCase.expected.Tags, trace.Spans[0].Tags)
 			assert.Equal(t, testCase.expected.Process.Tags, trace.Spans[0].Process.Tags)
 
diff --git a/model/adjuster/parent_reference.go b/model/adjuster/parent_reference.go
index 00e763d9b2b3..253243ad53a1 100644
--- a/model/adjuster/parent_reference.go
+++ b/model/adjuster/parent_reference.go
@@ -11,7 +11,7 @@ import (
 // This is necessary to match jaeger-ui expectations:
 // * https://github.com/jaegertracing/jaeger-ui/issues/966
 func ParentReference() Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		for _, span := range trace.Spans {
 			firstChildOfRef := -1
 			firstOtherRef := -1
@@ -33,7 +33,5 @@ func ParentReference() Adjuster {
 				span.References[swap], span.References[0] = span.References[0], span.References[swap]
 			}
 		}
-
-		return trace, nil
 	})
 }
diff --git a/model/adjuster/parent_reference_test.go b/model/adjuster/parent_reference_test.go
index fc9ba39b50fc..58447dc5bf97 100644
--- a/model/adjuster/parent_reference_test.go
+++ b/model/adjuster/parent_reference_test.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 )
@@ -96,8 +95,7 @@ func TestParentReference(t *testing.T) {
 					},
 				},
 			}
-			trace, err := ParentReference().Adjust(trace)
-			require.NoError(t, err)
+			ParentReference().Adjust(trace)
 			assert.Equal(t, testCase.expected, trace.Spans[0].References)
 		})
 	}
diff --git a/model/adjuster/sort_tags_and_log_fields.go b/model/adjuster/sort_tags_and_log_fields.go
index 0d6028a2d0cf..88891e507fb5 100644
--- a/model/adjuster/sort_tags_and_log_fields.go
+++ b/model/adjuster/sort_tags_and_log_fields.go
@@ -20,7 +20,7 @@ import (
 // place in the list. This adjuster needs some sort of config describing predefined
 // field names/types and their relative order.
 func SortTagsAndLogFields() Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		for _, span := range trace.Spans {
 			model.KeyValues(span.Tags).Sort()
 			if span.Process != nil {
@@ -45,6 +45,5 @@ func SortTagsAndLogFields() Adjuster {
 				}
 			}
 		}
-		return trace, nil
 	})
 }
diff --git a/model/adjuster/sort_tags_and_log_fields_test.go b/model/adjuster/sort_tags_and_log_fields_test.go
index afd1983cac0e..e87d3748267e 100644
--- a/model/adjuster/sort_tags_and_log_fields_test.go
+++ b/model/adjuster/sort_tags_and_log_fields_test.go
@@ -80,8 +80,7 @@ func TestSortTagsAndLogFieldsDoesSortFields(t *testing.T) {
 				},
 			},
 		}
-		trace, err := SortTagsAndLogFields().Adjust(trace)
-		require.NoError(t, err)
+		SortTagsAndLogFields().Adjust(trace)
 		assert.Equal(t, testCase.expected, model.KeyValues(trace.Spans[0].Logs[0].Fields))
 	}
 }
@@ -109,11 +108,10 @@ func TestSortTagsAndLogFieldsDoesSortTags(t *testing.T) {
 				},
 			},
 		}
-		sorted, err := SortTagsAndLogFields().Adjust(trace)
-		require.NoError(t, err)
-		assert.ElementsMatch(t, tags, sorted.Spans[0].Tags)
-		adjustedKeys := make([]string, len(sorted.Spans[0].Tags))
-		for i, kv := range sorted.Spans[0].Tags {
+		SortTagsAndLogFields().Adjust(trace)
+		assert.ElementsMatch(t, tags, trace.Spans[0].Tags)
+		adjustedKeys := make([]string, len(trace.Spans[0].Tags))
+		for i, kv := range trace.Spans[0].Tags {
 			adjustedKeys[i] = kv.Key
 		}
 		assert.IsIncreasing(t, adjustedKeys)
@@ -135,11 +133,9 @@ func TestSortTagsAndLogFieldsDoesSortProcessTags(t *testing.T) {
 			},
 		},
 	}
-	sorted, err := SortTagsAndLogFields().Adjust(trace)
-	require.NoError(t, err)
-	assert.ElementsMatch(t, trace.Spans[0].Process.Tags, sorted.Spans[0].Process.Tags)
-	adjustedKeys := make([]string, len(sorted.Spans[0].Process.Tags))
-	for i, kv := range sorted.Spans[0].Process.Tags {
+	SortTagsAndLogFields().Adjust(trace)
+	adjustedKeys := make([]string, len(trace.Spans[0].Process.Tags))
+	for i, kv := range trace.Spans[0].Process.Tags {
 		adjustedKeys[i] = kv.Key
 	}
 	assert.IsIncreasing(t, adjustedKeys)
@@ -151,6 +147,10 @@ func TestSortTagsAndLogFieldsHandlesNilProcessTags(t *testing.T) {
 			{},
 		},
 	}
-	_, err := SortTagsAndLogFields().Adjust(trace)
-	require.NoError(t, err)
+	SortTagsAndLogFields().Adjust(trace)
+	require.Equal(t, &model.Trace{
+		Spans: []*model.Span{
+			{},
+		},
+	}, trace)
 }
diff --git a/model/adjuster/span_hash_deduper.go b/model/adjuster/span_hash_deduper.go
index 5feb79e17694..e0d7a8df6db8 100644
--- a/model/adjuster/span_hash_deduper.go
+++ b/model/adjuster/span_hash_deduper.go
@@ -11,10 +11,9 @@ import (
 // This is useful for when spans are duplicated in archival storage, as happens with
 // ElasticSearch archival.
 func DedupeBySpanHash() Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		deduper := &spanHashDeduper{trace: trace}
 		deduper.groupSpansByHash()
-		return deduper.trace, nil
 	})
 }
 
diff --git a/model/adjuster/span_hash_deduper_test.go b/model/adjuster/span_hash_deduper_test.go
index d8bffd5bf82b..3660e9eb2538 100644
--- a/model/adjuster/span_hash_deduper_test.go
+++ b/model/adjuster/span_hash_deduper_test.go
@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 )
@@ -74,8 +73,7 @@ func getSpanIDs(spans []*model.Span) []int {
 func TestDedupeBySpanHashTriggers(t *testing.T) {
 	trc := newDuplicatedSpansTrace()
 	deduper := DedupeBySpanHash()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	assert.Len(t, trc.Spans, 2, "should dedupe spans")
 
@@ -86,8 +84,7 @@ func TestDedupeBySpanHashTriggers(t *testing.T) {
 func TestDedupeBySpanHashNotTriggered(t *testing.T) {
 	trc := newUniqueSpansTrace()
 	deduper := DedupeBySpanHash()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	assert.Len(t, trc.Spans, 2, "should not dedupe spans")
 
@@ -99,8 +96,7 @@ func TestDedupeBySpanHashNotTriggered(t *testing.T) {
 func TestDedupeBySpanHashEmpty(t *testing.T) {
 	trc := &model.Trace{}
 	deduper := DedupeBySpanHash()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	assert.Empty(t, trc.Spans, "should be empty")
 }
@@ -117,8 +113,7 @@ func TestDedupeBySpanHashManyManySpans(t *testing.T) {
 	}
 	trc := &model.Trace{Spans: spans}
 	deduper := DedupeBySpanHash()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	assert.Len(t, trc.Spans, distinctSpanIDs, "should dedupe spans")
 
diff --git a/model/adjuster/zipkin_span_id_uniquify.go b/model/adjuster/zipkin_span_id_uniquify.go
index 5f8a86a32ccc..3de8f20d77fa 100644
--- a/model/adjuster/zipkin_span_id_uniquify.go
+++ b/model/adjuster/zipkin_span_id_uniquify.go
@@ -20,11 +20,10 @@ import (
 // This adjuster never returns any errors. Instead it records any issues
 // it encounters in Span.Warnings.
 func ZipkinSpanIDUniquifier() Adjuster {
-	return Func(func(trace *model.Trace) (*model.Trace, error) {
+	return Func(func(trace *model.Trace) {
 		deduper := &spanIDDeduper{trace: trace}
 		deduper.groupSpansByID()
 		deduper.uniquifyServerSpanIDs()
-		return deduper.trace, nil
 	})
 }
 
diff --git a/model/adjuster/zipkin_span_id_uniquify_test.go b/model/adjuster/zipkin_span_id_uniquify_test.go
index c0b92799c212..8b65cad68aa3 100644
--- a/model/adjuster/zipkin_span_id_uniquify_test.go
+++ b/model/adjuster/zipkin_span_id_uniquify_test.go
@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger/model"
 )
@@ -53,8 +52,7 @@ func newZipkinTrace() *model.Trace {
 func TestZipkinSpanIDUniquifierTriggered(t *testing.T) {
 	trc := newZipkinTrace()
 	deduper := ZipkinSpanIDUniquifier()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	clientSpan := trc.Spans[0]
 	assert.Equal(t, clientSpanID, clientSpan.SpanID, "client span ID should not change")
@@ -73,8 +71,7 @@ func TestZipkinSpanIDUniquifierNotTriggered(t *testing.T) {
 	trc.Spans = trc.Spans[1:] // remove client span
 
 	deduper := ZipkinSpanIDUniquifier()
-	trc, err := deduper.Adjust(trc)
-	require.NoError(t, err)
+	deduper.Adjust(trc)
 
 	serverSpanID := clientSpanID // for better readability
 	serverSpan := trc.Spans[0]
diff --git a/plugin/storage/es/spanstore/dbmodel/fixtures/domain_01.json b/plugin/storage/es/spanstore/internal/dbmodel/fixtures/domain_01.json
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/fixtures/domain_01.json
rename to plugin/storage/es/spanstore/internal/dbmodel/fixtures/domain_01.json
diff --git a/plugin/storage/es/spanstore/dbmodel/fixtures/es_01.json b/plugin/storage/es/spanstore/internal/dbmodel/fixtures/es_01.json
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/fixtures/es_01.json
rename to plugin/storage/es/spanstore/internal/dbmodel/fixtures/es_01.json
diff --git a/plugin/storage/es/spanstore/dbmodel/from_domain.go b/plugin/storage/es/spanstore/internal/dbmodel/from_domain.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/from_domain.go
rename to plugin/storage/es/spanstore/internal/dbmodel/from_domain.go
diff --git a/plugin/storage/es/spanstore/dbmodel/from_domain_test.go b/plugin/storage/es/spanstore/internal/dbmodel/from_domain_test.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/from_domain_test.go
rename to plugin/storage/es/spanstore/internal/dbmodel/from_domain_test.go
diff --git a/plugin/storage/es/spanstore/dbmodel/json_span_compare_test.go b/plugin/storage/es/spanstore/internal/dbmodel/json_span_compare_test.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/json_span_compare_test.go
rename to plugin/storage/es/spanstore/internal/dbmodel/json_span_compare_test.go
diff --git a/plugin/storage/es/spanstore/dbmodel/model.go b/plugin/storage/es/spanstore/internal/dbmodel/model.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/model.go
rename to plugin/storage/es/spanstore/internal/dbmodel/model.go
diff --git a/plugin/storage/es/spanstore/dbmodel/package_test.go b/plugin/storage/es/spanstore/internal/dbmodel/package_test.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/package_test.go
rename to plugin/storage/es/spanstore/internal/dbmodel/package_test.go
diff --git a/plugin/storage/es/spanstore/dbmodel/to_domain.go b/plugin/storage/es/spanstore/internal/dbmodel/to_domain.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/to_domain.go
rename to plugin/storage/es/spanstore/internal/dbmodel/to_domain.go
diff --git a/plugin/storage/es/spanstore/dbmodel/to_domain_test.go b/plugin/storage/es/spanstore/internal/dbmodel/to_domain_test.go
similarity index 100%
rename from plugin/storage/es/spanstore/dbmodel/to_domain_test.go
rename to plugin/storage/es/spanstore/internal/dbmodel/to_domain_test.go
diff --git a/plugin/storage/es/spanstore/reader.go b/plugin/storage/es/spanstore/reader.go
index 64d88fb5abef..cb902972b68a 100644
--- a/plugin/storage/es/spanstore/reader.go
+++ b/plugin/storage/es/spanstore/reader.go
@@ -22,7 +22,7 @@ import (
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/pkg/es"
 	cfg "github.com/jaegertracing/jaeger/pkg/es/config"
-	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
+	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/internal/dbmodel"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
diff --git a/plugin/storage/es/spanstore/reader_test.go b/plugin/storage/es/spanstore/reader_test.go
index 4a6bdc48c01f..fcc85f59d896 100644
--- a/plugin/storage/es/spanstore/reader_test.go
+++ b/plugin/storage/es/spanstore/reader_test.go
@@ -29,7 +29,7 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/es/config"
 	"github.com/jaegertracing/jaeger/pkg/es/mocks"
 	"github.com/jaegertracing/jaeger/pkg/testutils"
-	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
+	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/internal/dbmodel"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
diff --git a/plugin/storage/es/spanstore/service_operation.go b/plugin/storage/es/spanstore/service_operation.go
index f2082d5afde1..2c0ae1596e13 100644
--- a/plugin/storage/es/spanstore/service_operation.go
+++ b/plugin/storage/es/spanstore/service_operation.go
@@ -20,7 +20,6 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/cache"
 	"github.com/jaegertracing/jaeger/pkg/es"
 	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
-	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
 const (
diff --git a/plugin/storage/es/spanstore/service_operation_test.go b/plugin/storage/es/spanstore/service_operation_test.go
index 9d04c2b4ce0b..20a5cf380ecf 100644
--- a/plugin/storage/es/spanstore/service_operation_test.go
+++ b/plugin/storage/es/spanstore/service_operation_test.go
@@ -15,7 +15,7 @@ import (
 
 	"github.com/jaegertracing/jaeger/model"
 	"github.com/jaegertracing/jaeger/pkg/es/mocks"
-	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
+	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/internal/dbmodel"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
diff --git a/plugin/storage/es/spanstore/writer.go b/plugin/storage/es/spanstore/writer.go
index 27e1dc6ddeb5..87b1b0f8b28f 100644
--- a/plugin/storage/es/spanstore/writer.go
+++ b/plugin/storage/es/spanstore/writer.go
@@ -16,7 +16,7 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/es"
 	cfg "github.com/jaegertracing/jaeger/pkg/es/config"
 	"github.com/jaegertracing/jaeger/pkg/metrics"
-	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
+	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/internal/dbmodel"
 	"github.com/jaegertracing/jaeger/storage/spanstore/spanstoremetrics"
 )
 
diff --git a/plugin/storage/es/spanstore/writer_test.go b/plugin/storage/es/spanstore/writer_test.go
index d5f3674936f2..13322534c7d7 100644
--- a/plugin/storage/es/spanstore/writer_test.go
+++ b/plugin/storage/es/spanstore/writer_test.go
@@ -22,7 +22,7 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/es/config"
 	"github.com/jaegertracing/jaeger/pkg/es/mocks"
 	"github.com/jaegertracing/jaeger/pkg/testutils"
-	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/dbmodel"
+	"github.com/jaegertracing/jaeger/plugin/storage/es/spanstore/internal/dbmodel"
 	"github.com/jaegertracing/jaeger/storage/spanstore"
 )
 
diff --git a/plugin/storage/integration/integration.go b/plugin/storage/integration/integration.go
index f9e6e9a9a78e..159e958c5bfa 100644
--- a/plugin/storage/integration/integration.go
+++ b/plugin/storage/integration/integration.go
@@ -157,7 +157,9 @@ func (s *StorageIntegration) testGetServices(t *testing.T) {
 			t.Log("🛑 Found unexpected services!")
 			for _, service := range actual {
 				iterTraces := s.TraceReader.FindTraces(context.Background(), tracestore.TraceQueryParams{
-					ServiceName: service,
+					ServiceName:  service,
+					StartTimeMin: time.Now().Add(-2 * time.Hour),
+					StartTimeMax: time.Now(),
 				})
 				traces, err := v1adapter.V1TracesFromSeq2(iterTraces)
 				if err != nil {
@@ -379,10 +381,13 @@ func (s *StorageIntegration) findTracesByQuery(t *testing.T, query *tracestore.T
 
 func (s *StorageIntegration) writeTrace(t *testing.T, trace *model.Trace) {
 	t.Logf("%-23s Writing trace with %d spans", time.Now().Format("2006-01-02 15:04:05.999"), len(trace.Spans))
+	ctx, cx := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cx()
 	for _, span := range trace.Spans {
-		err := s.SpanWriter.WriteSpan(context.Background(), span)
+		err := s.SpanWriter.WriteSpan(ctx, span)
 		require.NoError(t, err, "Not expecting error when writing trace to storage")
 	}
+	t.Logf("%-23s Finished writing trace with %d spans", time.Now().Format("2006-01-02 15:04:05.999"), len(trace.Spans))
 }
 
 func (s *StorageIntegration) loadParseAndWriteExampleTrace(t *testing.T) *model.Trace {
diff --git a/plugin/storage/memory/factory.go b/plugin/storage/memory/factory.go
index eb6924a65761..20dab08619cd 100644
--- a/plugin/storage/memory/factory.go
+++ b/plugin/storage/memory/factory.go
@@ -136,6 +136,7 @@ func (f *Factory) publishOpts() {
 // Purge removes all data from the Factory's underlying Memory store.
 // This function is intended for testing purposes only and should not be used in production environments.
 func (f *Factory) Purge(ctx context.Context) error {
+	f.logger.Info("Purging data from memory storage")
 	f.store.purge(ctx)
 	return nil
 }
diff --git a/plugin/storage/memory/memory.go b/plugin/storage/memory/memory.go
index 23ec0bd2d397..02dff26a584b 100644
--- a/plugin/storage/memory/memory.go
+++ b/plugin/storage/memory/memory.go
@@ -89,9 +89,8 @@ func (st *Store) GetDependencies(ctx context.Context, endTs time.Time, lookback
 	defer m.Unlock()
 	deps := map[string]*model.DependencyLink{}
 	startTs := endTs.Add(-1 * lookback)
-	for _, orig := range m.traces {
-		// ZipkinSpanIDUniquifier never returns an err
-		trace, _ := m.deduper.Adjust(orig)
+	for _, trace := range m.traces {
+		m.deduper.Adjust(trace)
 		if traceIsBetweenStartAndEnd(startTs, endTs, trace) {
 			for _, s := range trace.Spans {
 				parentSpan := findSpan(trace, s.ParentSpanID())
diff --git a/proto-gen/api_v2/query.pb.go b/proto-gen/api_v2/query.pb.go
index f9bbee7313f9..311b5c0cd46e 100644
--- a/proto-gen/api_v2/query.pb.go
+++ b/proto-gen/api_v2/query.pb.go
@@ -39,10 +39,14 @@ type GetTraceRequest struct {
 	// Optional. The start time to search trace ID.
 	StartTime time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"`
 	// Optional. The end time to search trace ID.
-	EndTime              time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	EndTime time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time"`
+	// Optional. If set to true, the response will not include any
+	// enrichments to the trace, such as clock skew adjustment.
+	// Instead, the trace will be returned exactly as stored.
+	RawTraces            bool     `protobuf:"varint,4,opt,name=raw_traces,json=rawTraces,proto3" json:"raw_traces,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *GetTraceRequest) Reset()         { *m = GetTraceRequest{} }
@@ -92,6 +96,13 @@ func (m *GetTraceRequest) GetEndTime() time.Time {
 	return time.Time{}
 }
 
+func (m *GetTraceRequest) GetRawTraces() bool {
+	if m != nil {
+		return m.RawTraces
+	}
+	return false
+}
+
 type SpansResponseChunk struct {
 	Spans                []model.Span `protobuf:"bytes,1,rep,name=spans,proto3" json:"spans"`
 	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
@@ -249,17 +260,21 @@ var xxx_messageInfo_ArchiveTraceResponse proto.InternalMessageInfo
 // Note: some storage implementations do not guarantee the correct implementation of all parameters.
 //
 type TraceQueryParameters struct {
-	ServiceName          string            `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
-	OperationName        string            `protobuf:"bytes,2,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"`
-	Tags                 map[string]string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	StartTimeMin         time.Time         `protobuf:"bytes,4,opt,name=start_time_min,json=startTimeMin,proto3,stdtime" json:"start_time_min"`
-	StartTimeMax         time.Time         `protobuf:"bytes,5,opt,name=start_time_max,json=startTimeMax,proto3,stdtime" json:"start_time_max"`
-	DurationMin          time.Duration     `protobuf:"bytes,6,opt,name=duration_min,json=durationMin,proto3,stdduration" json:"duration_min"`
-	DurationMax          time.Duration     `protobuf:"bytes,7,opt,name=duration_max,json=durationMax,proto3,stdduration" json:"duration_max"`
-	SearchDepth          int32             `protobuf:"varint,8,opt,name=search_depth,json=searchDepth,proto3" json:"search_depth,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
-	XXX_unrecognized     []byte            `json:"-"`
-	XXX_sizecache        int32             `json:"-"`
+	ServiceName   string            `protobuf:"bytes,1,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
+	OperationName string            `protobuf:"bytes,2,opt,name=operation_name,json=operationName,proto3" json:"operation_name,omitempty"`
+	Tags          map[string]string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	StartTimeMin  time.Time         `protobuf:"bytes,4,opt,name=start_time_min,json=startTimeMin,proto3,stdtime" json:"start_time_min"`
+	StartTimeMax  time.Time         `protobuf:"bytes,5,opt,name=start_time_max,json=startTimeMax,proto3,stdtime" json:"start_time_max"`
+	DurationMin   time.Duration     `protobuf:"bytes,6,opt,name=duration_min,json=durationMin,proto3,stdduration" json:"duration_min"`
+	DurationMax   time.Duration     `protobuf:"bytes,7,opt,name=duration_max,json=durationMax,proto3,stdduration" json:"duration_max"`
+	SearchDepth   int32             `protobuf:"varint,8,opt,name=search_depth,json=searchDepth,proto3" json:"search_depth,omitempty"`
+	// Optional. If set to true, the response will not include any
+	// enrichments to the trace, such as clock skew adjustment.
+	// Instead, the trace will be returned exactly as stored.
+	RawTraces            bool     `protobuf:"varint,9,opt,name=raw_traces,json=rawTraces,proto3" json:"raw_traces,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *TraceQueryParameters) Reset()         { *m = TraceQueryParameters{} }
@@ -351,6 +366,13 @@ func (m *TraceQueryParameters) GetSearchDepth() int32 {
 	return 0
 }
 
+func (m *TraceQueryParameters) GetRawTraces() bool {
+	if m != nil {
+		return m.RawTraces
+	}
+	return false
+}
+
 type FindTracesRequest struct {
 	Query                *TraceQueryParameters `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
@@ -771,68 +793,70 @@ func init() {
 func init() { proto.RegisterFile("query.proto", fileDescriptor_5c6ac9b241082464) }
 
 var fileDescriptor_5c6ac9b241082464 = []byte{
-	// 971 bytes of a gzipped FileDescriptorProto
+	// 995 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0x67, 0x9d, 0x38, 0xb6, 0xdf, 0xda, 0x2d, 0x7d, 0x76, 0xda, 0x65, 0x0b, 0xb6, 0xb3, 0xa1,
-	0x55, 0x84, 0x94, 0xdd, 0x62, 0x0e, 0x94, 0x0a, 0x09, 0x9a, 0xa6, 0xb5, 0x0a, 0xb4, 0xc0, 0x36,
-	0x27, 0x38, 0x58, 0x13, 0xef, 0xb0, 0x5e, 0x1c, 0xcf, 0xba, 0xbb, 0xe3, 0x10, 0x0b, 0x71, 0xe1,
-	0x13, 0x20, 0x71, 0xe1, 0xc4, 0x95, 0x13, 0xdf, 0xa3, 0x47, 0x24, 0x6e, 0x1c, 0x02, 0x8a, 0xf8,
-	0x08, 0x1c, 0x38, 0xa2, 0xf9, 0xb3, 0x8e, 0xbd, 0x8e, 0x42, 0x1b, 0x8e, 0x9c, 0xbc, 0xf3, 0xe6,
-	0xbd, 0xdf, 0xfb, 0xfb, 0x7b, 0x63, 0x30, 0x9f, 0x4e, 0x68, 0x32, 0x75, 0xc7, 0x49, 0xcc, 0x63,
-	0xac, 0x7d, 0x49, 0x68, 0x48, 0x13, 0x97, 0x8c, 0xa3, 0xde, 0x61, 0xc7, 0x36, 0x47, 0x71, 0x40,
-	0x0f, 0xd4, 0x9d, 0xdd, 0x08, 0xe3, 0x30, 0x96, 0x9f, 0x9e, 0xf8, 0xd2, 0xd2, 0x57, 0xc3, 0x38,
-	0x0e, 0x0f, 0xa8, 0x47, 0xc6, 0x91, 0x47, 0x18, 0x8b, 0x39, 0xe1, 0x51, 0xcc, 0x52, 0x7d, 0xdb,
-	0xd2, 0xb7, 0xf2, 0xb4, 0x3f, 0xf9, 0xc2, 0xe3, 0xd1, 0x88, 0xa6, 0x9c, 0x8c, 0xc6, 0x5a, 0xa1,
-	0x99, 0x57, 0x08, 0x26, 0x89, 0x44, 0x50, 0xf7, 0xce, 0x5f, 0x06, 0x5c, 0xee, 0x52, 0xbe, 0x97,
-	0x90, 0x3e, 0xf5, 0xe9, 0xd3, 0x09, 0x4d, 0x39, 0x7e, 0x0e, 0x65, 0x2e, 0xce, 0xbd, 0x28, 0xb0,
-	0x8c, 0xb6, 0xb1, 0x55, 0xdd, 0x79, 0xff, 0xd9, 0x71, 0xeb, 0xa5, 0xdf, 0x8e, 0x5b, 0xdb, 0x61,
-	0xc4, 0x07, 0x93, 0x7d, 0xb7, 0x1f, 0x8f, 0x3c, 0x95, 0x89, 0x50, 0x8c, 0x58, 0xa8, 0x4f, 0x9e,
-	0xca, 0x47, 0xa2, 0x3d, 0xdc, 0x3d, 0x39, 0x6e, 0x95, 0xf4, 0xa7, 0x5f, 0x92, 0x88, 0x0f, 0x03,
-	0xbc, 0x07, 0x90, 0x72, 0x92, 0xf0, 0x9e, 0x88, 0xd4, 0x2a, 0xb4, 0x8d, 0x2d, 0xb3, 0x63, 0xbb,
-	0x2a, 0x4a, 0x37, 0x8b, 0xd2, 0xdd, 0xcb, 0xd2, 0xd8, 0x29, 0x0b, 0xd7, 0xdf, 0xfd, 0xde, 0x32,
-	0xfc, 0x8a, 0xb4, 0x13, 0x37, 0xf8, 0x1e, 0x94, 0x29, 0x0b, 0x14, 0xc4, 0xca, 0x0b, 0x40, 0x94,
-	0x28, 0x0b, 0x84, 0xdc, 0xb9, 0x0f, 0xf8, 0x64, 0x4c, 0x58, 0xea, 0xd3, 0x74, 0x1c, 0xb3, 0x94,
-	0xde, 0x1b, 0x4c, 0xd8, 0x10, 0x3d, 0x28, 0xa6, 0x42, 0x6a, 0x19, 0xed, 0x95, 0x2d, 0xb3, 0x53,
-	0x77, 0x17, 0xba, 0xe5, 0x0a, 0x8b, 0x9d, 0x55, 0x01, 0xe6, 0x2b, 0x3d, 0xe7, 0x6f, 0x03, 0xea,
-	0x77, 0x93, 0xfe, 0x20, 0x3a, 0xa4, 0xff, 0xb7, 0x0a, 0x5e, 0x85, 0xc6, 0x62, 0xe6, 0xaa, 0x90,
-	0xce, 0x4f, 0xab, 0xd0, 0x90, 0x92, 0x4f, 0xc5, 0xd8, 0x7f, 0x42, 0x12, 0x32, 0xa2, 0x9c, 0x26,
-	0x29, 0x6e, 0x40, 0x35, 0xa5, 0xc9, 0x61, 0xd4, 0xa7, 0x3d, 0x46, 0x46, 0x54, 0xd6, 0xa5, 0xe2,
-	0x9b, 0x5a, 0xf6, 0x98, 0x8c, 0x28, 0xde, 0x80, 0x4b, 0xf1, 0x98, 0xaa, 0xf9, 0x54, 0x4a, 0x05,
-	0xa9, 0x54, 0x9b, 0x49, 0xa5, 0xda, 0x5d, 0x58, 0xe5, 0x24, 0x4c, 0xad, 0x15, 0xd9, 0xa5, 0xed,
-	0x5c, 0x97, 0xce, 0x72, 0xee, 0xee, 0x91, 0x30, 0xbd, 0xcf, 0x78, 0x32, 0xf5, 0xa5, 0x29, 0x7e,
-	0x00, 0x97, 0x4e, 0x6b, 0xd8, 0x1b, 0x45, 0xcc, 0x5a, 0x7d, 0x81, 0x22, 0x54, 0x67, 0x75, 0x7c,
-	0x14, 0xb1, 0x3c, 0x16, 0x39, 0xb2, 0x8a, 0x17, 0xc3, 0x22, 0x47, 0xf8, 0x00, 0xaa, 0x19, 0x41,
-	0x65, 0x54, 0x6b, 0x12, 0xe9, 0x95, 0x25, 0xa4, 0x5d, 0xad, 0xa4, 0x80, 0x7e, 0x10, 0x40, 0x66,
-	0x66, 0x28, 0x62, 0x5a, 0xc0, 0x21, 0x47, 0x56, 0xe9, 0x22, 0x38, 0xe4, 0x48, 0x35, 0x8d, 0x24,
-	0xfd, 0x41, 0x2f, 0xa0, 0x63, 0x3e, 0xb0, 0xca, 0x6d, 0x63, 0xab, 0x28, 0x9a, 0x26, 0x64, 0xbb,
-	0x42, 0x64, 0xbf, 0x0d, 0x95, 0x59, 0x75, 0xf1, 0x65, 0x58, 0x19, 0xd2, 0xa9, 0xee, 0xad, 0xf8,
-	0xc4, 0x06, 0x14, 0x0f, 0xc9, 0xc1, 0x24, 0x6b, 0xa5, 0x3a, 0xdc, 0x29, 0xdc, 0x36, 0x9c, 0xc7,
-	0x70, 0xe5, 0x41, 0xc4, 0x02, 0xd9, 0xaf, 0x34, 0x63, 0xce, 0x3b, 0x50, 0x94, 0xfb, 0x52, 0x42,
-	0x98, 0x9d, 0xcd, 0xe7, 0x68, 0xae, 0xaf, 0x2c, 0x9c, 0x06, 0x60, 0x97, 0xf2, 0x27, 0x6a, 0x9e,
-	0x32, 0x40, 0xe7, 0x4d, 0xa8, 0x2f, 0x48, 0xd5, 0x98, 0xa2, 0x0d, 0x65, 0x3d, 0x79, 0x8a, 0xed,
-	0x15, 0x7f, 0x76, 0x76, 0x1e, 0x41, 0xa3, 0x4b, 0xf9, 0xc7, 0xd9, 0xcc, 0xcd, 0x62, 0xb3, 0xa0,
-	0xa4, 0x75, 0x74, 0x82, 0xd9, 0x11, 0xaf, 0x43, 0x45, 0x2c, 0x84, 0xde, 0x30, 0x62, 0x81, 0x4e,
-	0xb4, 0x2c, 0x04, 0x1f, 0x46, 0x2c, 0x70, 0xde, 0x85, 0xca, 0x0c, 0x0b, 0x11, 0x56, 0xe7, 0xa6,
-	0x5f, 0x7e, 0x9f, 0x6f, 0x3d, 0x85, 0xf5, 0x5c, 0x30, 0x3a, 0x83, 0x9b, 0x73, 0x64, 0x11, 0xb4,
-	0xc8, 0xf2, 0xc8, 0x49, 0xf1, 0x36, 0xc0, 0x4c, 0x92, 0x5a, 0x05, 0xc9, 0x19, 0x2b, 0x57, 0xd6,
-	0x19, 0xbc, 0x3f, 0xa7, 0xeb, 0xfc, 0x68, 0xc0, 0xd5, 0x2e, 0xe5, 0xbb, 0x74, 0x4c, 0x59, 0x40,
-	0x59, 0x3f, 0x3a, 0x6d, 0xd3, 0xe2, 0x0e, 0x32, 0xfe, 0xfb, 0x0e, 0x2a, 0x5c, 0x64, 0x07, 0xed,
-	0xc3, 0xb5, 0xa5, 0xf8, 0x74, 0x75, 0xba, 0x50, 0x0d, 0xe6, 0xe4, 0x7a, 0xa3, 0xbf, 0x96, 0xcb,
-	0x7b, 0x66, 0x3a, 0xfd, 0x28, 0x62, 0x43, 0xbd, 0xdb, 0x17, 0x0c, 0x3b, 0x3f, 0x17, 0xa1, 0x2a,
-	0x07, 0x4e, 0x8f, 0x10, 0x0e, 0xa1, 0x9c, 0x3d, 0x98, 0xd8, 0xcc, 0xe1, 0xe5, 0x5e, 0x52, 0x7b,
-	0xe3, 0x8c, 0x17, 0x64, 0xf1, 0xcd, 0x71, 0xec, 0x6f, 0x7f, 0xfd, 0xf3, 0xfb, 0x42, 0x03, 0xd1,
-	0x93, 0xfb, 0x3d, 0xf5, 0xbe, 0xce, 0x5e, 0x8e, 0x6f, 0x6e, 0x19, 0xc8, 0xa1, 0x3a, 0xbf, 0x65,
-	0xd1, 0xc9, 0x01, 0x9e, 0xf1, 0xf8, 0xd8, 0x9b, 0xe7, 0xea, 0xe8, 0x35, 0x7d, 0x5d, 0xba, 0x5d,
-	0x77, 0xea, 0x1e, 0x51, 0xd7, 0x73, 0x7e, 0x31, 0x04, 0x38, 0x65, 0x26, 0xb6, 0x73, 0x78, 0x4b,
-	0xa4, 0x7d, 0x9e, 0x34, 0x51, 0xfa, 0xab, 0x3a, 0x25, 0x4f, 0xed, 0x8e, 0x3b, 0xc6, 0x1b, 0xb7,
-	0x0c, 0x0c, 0xc1, 0x9c, 0x23, 0x27, 0x6e, 0x2c, 0x97, 0x33, 0x47, 0x67, 0xdb, 0x39, 0x4f, 0x45,
-	0xe7, 0x76, 0x45, 0xfa, 0x32, 0xb1, 0xe2, 0x65, 0x94, 0xc6, 0x18, 0x6a, 0x0b, 0x2c, 0xc2, 0xcd,
-	0x65, 0x9c, 0x25, 0xc2, 0xdb, 0xaf, 0x9f, 0xaf, 0xa4, 0xdd, 0xd5, 0xa5, 0xbb, 0x1a, 0x9a, 0xde,
-	0x29, 0x77, 0xf0, 0x2b, 0xf9, 0xb7, 0x6a, 0x7e, 0x34, 0xf1, 0xc6, 0x32, 0xda, 0x19, 0xd4, 0xb2,
-	0x6f, 0xfe, 0x9b, 0x9a, 0x76, 0xbb, 0x2e, 0xdd, 0x5e, 0xc6, 0x9a, 0x37, 0x3f, 0xaf, 0x3b, 0xdb,
-	0xcf, 0x4e, 0x9a, 0xc6, 0x2f, 0x27, 0x4d, 0xe3, 0x8f, 0x93, 0xa6, 0x01, 0xd7, 0xa2, 0xd8, 0x5d,
-	0xf8, 0x9b, 0xa1, 0x51, 0x3f, 0x5b, 0x53, 0xbf, 0xfb, 0x6b, 0x92, 0x69, 0x6f, 0xfd, 0x13, 0x00,
-	0x00, 0xff, 0xff, 0x66, 0xd6, 0x53, 0xfb, 0xa6, 0x0a, 0x00, 0x00,
+	0x14, 0x67, 0x1d, 0x3b, 0xb6, 0xdf, 0xda, 0x2d, 0x1d, 0x3b, 0xed, 0xb2, 0xa5, 0xb6, 0xb3, 0xa1,
+	0x95, 0x85, 0x94, 0xdd, 0x62, 0x0e, 0x94, 0x0a, 0x09, 0x9a, 0xa6, 0xb5, 0x0a, 0xb4, 0xc0, 0x36,
+	0x27, 0x38, 0x58, 0x13, 0xef, 0xb0, 0x5e, 0x1c, 0xcf, 0xba, 0xbb, 0xe3, 0x24, 0x16, 0xe2, 0xc2,
+	0x27, 0x40, 0xea, 0x85, 0x13, 0xdf, 0x80, 0xaf, 0x81, 0x72, 0x44, 0xe2, 0xc6, 0x21, 0xa0, 0x88,
+	0x0f, 0xc1, 0x11, 0xcd, 0x9f, 0x75, 0x76, 0xd7, 0x51, 0x08, 0xe1, 0xd8, 0x93, 0x77, 0xde, 0xbc,
+	0xf7, 0x7b, 0x7f, 0x7f, 0x6f, 0x0c, 0xfa, 0x8b, 0x19, 0x89, 0xe6, 0xf6, 0x34, 0x0a, 0x59, 0x88,
+	0xea, 0xdf, 0x60, 0xe2, 0x93, 0xc8, 0xc6, 0xd3, 0x60, 0xb0, 0xdf, 0x33, 0xf5, 0x49, 0xe8, 0x91,
+	0x3d, 0x79, 0x67, 0x36, 0xfd, 0xd0, 0x0f, 0xc5, 0xa7, 0xc3, 0xbf, 0x94, 0xf4, 0x4d, 0x3f, 0x0c,
+	0xfd, 0x3d, 0xe2, 0xe0, 0x69, 0xe0, 0x60, 0x4a, 0x43, 0x86, 0x59, 0x10, 0xd2, 0x58, 0xdd, 0xb6,
+	0xd5, 0xad, 0x38, 0xed, 0xce, 0xbe, 0x76, 0x58, 0x30, 0x21, 0x31, 0xc3, 0x93, 0xa9, 0x52, 0x68,
+	0xe5, 0x15, 0xbc, 0x59, 0x24, 0x10, 0xe4, 0xbd, 0xf5, 0xb2, 0x00, 0x57, 0xfb, 0x84, 0xed, 0x44,
+	0x78, 0x48, 0x5c, 0xf2, 0x62, 0x46, 0x62, 0x86, 0xbe, 0x82, 0x0a, 0xe3, 0xe7, 0x41, 0xe0, 0x19,
+	0x5a, 0x47, 0xeb, 0xd6, 0xb6, 0x3e, 0x3a, 0x3a, 0x6e, 0xbf, 0xf6, 0xfb, 0x71, 0x7b, 0xd3, 0x0f,
+	0xd8, 0x68, 0xb6, 0x6b, 0x0f, 0xc3, 0x89, 0x23, 0x33, 0xe1, 0x8a, 0x01, 0xf5, 0xd5, 0xc9, 0x91,
+	0xf9, 0x08, 0xb4, 0x27, 0xdb, 0x27, 0xc7, 0xed, 0xb2, 0xfa, 0x74, 0xcb, 0x02, 0xf1, 0x89, 0x87,
+	0x1e, 0x02, 0xc4, 0x0c, 0x47, 0x6c, 0xc0, 0x23, 0x35, 0x0a, 0x1d, 0xad, 0xab, 0xf7, 0x4c, 0x5b,
+	0x46, 0x69, 0x27, 0x51, 0xda, 0x3b, 0x49, 0x1a, 0x5b, 0x15, 0xee, 0xfa, 0x87, 0x3f, 0xda, 0x9a,
+	0x5b, 0x15, 0x76, 0xfc, 0x06, 0x7d, 0x08, 0x15, 0x42, 0x3d, 0x09, 0xb1, 0xf2, 0x1f, 0x20, 0xca,
+	0x84, 0x7a, 0x02, 0xe0, 0x16, 0x40, 0x84, 0x0f, 0x06, 0x22, 0xa8, 0xd8, 0x28, 0x76, 0xb4, 0x6e,
+	0xc5, 0xad, 0x46, 0xf8, 0x40, 0x84, 0x1b, 0x5b, 0x8f, 0x00, 0x3d, 0x9f, 0x62, 0x1a, 0xbb, 0x24,
+	0x9e, 0x86, 0x34, 0x26, 0x0f, 0x47, 0x33, 0x3a, 0x46, 0x0e, 0x94, 0x62, 0x2e, 0x35, 0xb4, 0xce,
+	0x4a, 0x57, 0xef, 0x35, 0xec, 0x4c, 0x33, 0x6d, 0x6e, 0xb1, 0x55, 0xe4, 0xbe, 0x5c, 0xa9, 0x67,
+	0xfd, 0xad, 0x41, 0xe3, 0x41, 0x34, 0x1c, 0x05, 0xfb, 0xe4, 0x15, 0x2b, 0xb0, 0x75, 0x1d, 0x9a,
+	0xd9, 0xcc, 0x65, 0x21, 0xad, 0x5f, 0x8a, 0xd0, 0x14, 0x92, 0x2f, 0x38, 0x2b, 0x3e, 0xc7, 0x11,
+	0x9e, 0x10, 0x46, 0xa2, 0x18, 0xad, 0x43, 0x2d, 0x26, 0xd1, 0x7e, 0x30, 0x24, 0x03, 0x8a, 0x27,
+	0x44, 0xd4, 0xa5, 0xea, 0xea, 0x4a, 0xf6, 0x0c, 0x4f, 0x08, 0xba, 0x0d, 0x57, 0xc2, 0x29, 0x91,
+	0xe3, 0x2b, 0x95, 0x0a, 0x42, 0xa9, 0xbe, 0x90, 0x0a, 0xb5, 0x07, 0x50, 0x64, 0xd8, 0x8f, 0x8d,
+	0x15, 0xd1, 0xa5, 0xcd, 0x5c, 0x97, 0xce, 0x72, 0x6e, 0xef, 0x60, 0x3f, 0x7e, 0x44, 0x59, 0x34,
+	0x77, 0x85, 0x29, 0xfa, 0x18, 0xae, 0x9c, 0xd6, 0x70, 0x30, 0x09, 0xa8, 0x18, 0x91, 0x8b, 0x16,
+	0xa1, 0xb6, 0xa8, 0xe3, 0xd3, 0x80, 0xe6, 0xb1, 0xf0, 0xa1, 0x51, 0xba, 0x1c, 0x16, 0x3e, 0x44,
+	0x8f, 0xa1, 0x96, 0xf0, 0x57, 0x44, 0xb5, 0x2a, 0x90, 0xde, 0x58, 0x42, 0xda, 0x56, 0x4a, 0x12,
+	0xe8, 0x47, 0x0e, 0xa4, 0x27, 0x86, 0x3c, 0xa6, 0x0c, 0x0e, 0x3e, 0x34, 0xca, 0x97, 0xc1, 0xc1,
+	0x87, 0xb2, 0x69, 0x38, 0x1a, 0x8e, 0x06, 0x1e, 0x99, 0xb2, 0x91, 0x51, 0xe9, 0x68, 0xdd, 0x12,
+	0x6f, 0x1a, 0x97, 0x6d, 0x73, 0x51, 0x8e, 0x69, 0xd5, 0x1c, 0xd3, 0xcc, 0xf7, 0xa0, 0xba, 0x28,
+	0x3e, 0x7a, 0x1d, 0x56, 0xc6, 0x64, 0xae, 0x5a, 0xcf, 0x3f, 0x51, 0x13, 0x4a, 0xfb, 0x78, 0x6f,
+	0x96, 0x74, 0x5a, 0x1e, 0xee, 0x17, 0xee, 0x69, 0xd6, 0x33, 0xb8, 0xf6, 0x38, 0xa0, 0x9e, 0x84,
+	0x49, 0x88, 0xf5, 0x3e, 0x94, 0xc4, 0xb6, 0x15, 0x10, 0x7a, 0x6f, 0xe3, 0x02, 0xbd, 0x77, 0xa5,
+	0x85, 0xd5, 0x04, 0xd4, 0x27, 0xec, 0xb9, 0x1c, 0xb7, 0x04, 0xd0, 0x7a, 0x07, 0x1a, 0x19, 0xa9,
+	0x9c, 0x62, 0x64, 0x42, 0x45, 0x0d, 0xa6, 0x5c, 0x06, 0x55, 0x77, 0x71, 0xb6, 0x9e, 0x42, 0xb3,
+	0x4f, 0xd8, 0x67, 0xc9, 0x48, 0x2e, 0x62, 0x33, 0xa0, 0xac, 0x74, 0x54, 0x82, 0xc9, 0x11, 0xdd,
+	0x84, 0x2a, 0xdf, 0x17, 0x83, 0x71, 0x40, 0x3d, 0x95, 0x68, 0x85, 0x0b, 0x3e, 0x09, 0xa8, 0x67,
+	0x7d, 0x00, 0xd5, 0x05, 0x16, 0x42, 0x50, 0x4c, 0x91, 0x43, 0x7c, 0x9f, 0x6f, 0x3d, 0x87, 0xb5,
+	0x5c, 0x30, 0x2a, 0x83, 0x3b, 0x29, 0x2e, 0x71, 0xd6, 0x24, 0x79, 0xe4, 0xa4, 0xe8, 0x1e, 0xc0,
+	0x42, 0x12, 0x1b, 0x05, 0x41, 0x29, 0x23, 0x57, 0xd6, 0x05, 0xbc, 0x9b, 0xd2, 0xb5, 0x7e, 0xd2,
+	0xe0, 0x7a, 0x9f, 0xb0, 0x6d, 0x32, 0x25, 0xd4, 0x23, 0x74, 0x18, 0x9c, 0xb6, 0x29, 0xbb, 0xa2,
+	0xb4, 0xff, 0xbf, 0xa2, 0x0a, 0x97, 0x59, 0x51, 0xbb, 0x70, 0x63, 0x29, 0x3e, 0x55, 0x9d, 0x3e,
+	0xd4, 0xbc, 0x94, 0x5c, 0x2d, 0xfc, 0x5b, 0xb9, 0xbc, 0x17, 0xa6, 0xf3, 0x4f, 0x03, 0x3a, 0x56,
+	0xab, 0x3f, 0x63, 0xd8, 0xfb, 0xb9, 0x04, 0x35, 0x31, 0x70, 0x6a, 0x84, 0xd0, 0x18, 0x2a, 0xc9,
+	0x73, 0x8b, 0x5a, 0x39, 0xbc, 0xdc, 0x3b, 0x6c, 0xae, 0x9f, 0xf1, 0xc0, 0x64, 0x9f, 0x24, 0xcb,
+	0xfc, 0xfe, 0xb7, 0xbf, 0x5e, 0x16, 0x9a, 0x08, 0x39, 0x92, 0x60, 0xce, 0xb7, 0xc9, 0xc3, 0xf2,
+	0xdd, 0x5d, 0x0d, 0x31, 0xa8, 0xa5, 0x97, 0x30, 0xb2, 0x72, 0x80, 0x67, 0xbc, 0x4d, 0xe6, 0xc6,
+	0xb9, 0x3a, 0x6a, 0x8b, 0xdf, 0x14, 0x6e, 0xd7, 0xac, 0x86, 0x83, 0xe5, 0x75, 0xca, 0x2f, 0xf2,
+	0x01, 0x4e, 0x99, 0x89, 0x3a, 0x39, 0xbc, 0x25, 0xd2, 0x5e, 0x24, 0x4d, 0x24, 0xfc, 0xd5, 0xac,
+	0xb2, 0x23, 0x57, 0xcb, 0x7d, 0xed, 0xed, 0xbb, 0x1a, 0xf2, 0x41, 0x4f, 0x91, 0x13, 0xad, 0x2f,
+	0x97, 0x33, 0x47, 0x67, 0xd3, 0x3a, 0x4f, 0x45, 0xe5, 0x76, 0x4d, 0xf8, 0xd2, 0x51, 0xd5, 0x49,
+	0x28, 0x8d, 0x42, 0xa8, 0x67, 0x58, 0x84, 0x36, 0x96, 0x71, 0x96, 0x08, 0x6f, 0xbe, 0x75, 0xbe,
+	0x92, 0x72, 0xd7, 0x10, 0xee, 0xea, 0x48, 0x77, 0x4e, 0xb9, 0x83, 0x0e, 0xc4, 0x9f, 0xb2, 0xf4,
+	0x68, 0xa2, 0xdb, 0xcb, 0x68, 0x67, 0x50, 0xcb, 0xbc, 0xf3, 0x6f, 0x6a, 0xca, 0xed, 0x9a, 0x70,
+	0x7b, 0x15, 0xd5, 0x9d, 0xf4, 0xbc, 0x6e, 0x6d, 0x1e, 0x9d, 0xb4, 0xb4, 0x5f, 0x4f, 0x5a, 0xda,
+	0x9f, 0x27, 0x2d, 0x0d, 0x6e, 0x04, 0xa1, 0x9d, 0xf9, 0x17, 0xa2, 0x50, 0xbf, 0x5c, 0x95, 0xbf,
+	0xbb, 0xab, 0x82, 0x69, 0xef, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x43, 0x45, 0x1e, 0x73, 0xe4,
+	0x0a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1174,6 +1198,16 @@ func (m *GetTraceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.RawTraces {
+		i--
+		if m.RawTraces {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x20
+	}
 	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):])
 	if err1 != nil {
 		return 0, err1
@@ -1348,6 +1382,16 @@ func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.RawTraces {
+		i--
+		if m.RawTraces {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x48
+	}
 	if m.SearchDepth != 0 {
 		i = encodeVarintQuery(dAtA, i, uint64(m.SearchDepth))
 		i--
@@ -1762,6 +1806,9 @@ func (m *GetTraceRequest) Size() (n int) {
 	n += 1 + l + sovQuery(uint64(l))
 	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime)
 	n += 1 + l + sovQuery(uint64(l))
+	if m.RawTraces {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -1849,6 +1896,9 @@ func (m *TraceQueryParameters) Size() (n int) {
 	if m.SearchDepth != 0 {
 		n += 1 + sovQuery(uint64(m.SearchDepth))
 	}
+	if m.RawTraces {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -2133,6 +2183,26 @@ func (m *GetTraceRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RawTraces", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RawTraces = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -2812,6 +2882,26 @@ func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RawTraces", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RawTraces = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
diff --git a/scripts/kafka-integration-test.sh b/scripts/kafka-integration-test.sh
index c62f73a44f55..e779d08f4f91 100755
--- a/scripts/kafka-integration-test.sh
+++ b/scripts/kafka-integration-test.sh
@@ -6,28 +6,21 @@
 set -euf -o pipefail
 
 compose_file=""
-jaeger_version=""
-kafka_version=""
+jaeger_version="v2"
+kafka_version="v3"
 manage_kafka="true"
 success="false"
 
 usage() {
-  echo "Usage: $0 [-K] -j <jaeger_version> -v <kafka_version>"
-  echo "  -K: do not start or stop Kafka container (useful for local testing)"
-  echo "  -j: major version of Jaeger to test (v1|v2)"
-  echo "  -v: kafka major version (3.x|2.x)"
+  echo "Usage: $0 [-S] [-j <jaeger_version>] [-v <kafka_version>]"
+  echo "  -S: 'no storage' - do not start or stop Kafka container (useful for local testing)"
+  echo "  -j: major version of Jaeger to test (v1|v2); default: v2"
+  echo "  -v: kafka major version (3.x); default: 3.x"
   exit 1
 }
 
-check_arg() {
-  if [ ! $# -eq 3 ]; then
-      echo "ERROR: need exactly three arguments"
-      usage
-    fi
-}
-
 parse_args() {
-  while getopts "j:v:Kh" opt; do
+  while getopts "j:v:Sh" opt; do
     case "${opt}" in
     j)
       jaeger_version=${OPTARG}
@@ -46,7 +39,7 @@ parse_args() {
         ;;
       esac
       ;;
-    K)
+    S)
       manage_kafka="false"
       ;;
     *)
@@ -61,7 +54,6 @@ parse_args() {
   compose_file="docker-compose/kafka/${kafka_version}/docker-compose.yml"
 }
 
-
 setup_kafka() {
   echo "Starting Kafka using Docker Compose..."
   docker compose -f "${compose_file}" up -d kafka
@@ -121,7 +113,9 @@ run_integration_test() {
 main() {
   parse_args "$@"
 
-  echo "Executing Kafka integration test for version $2"
+  echo "Executing Kafka integration test."
+  echo "Kafka version ${kafka_version}."
+  echo "Jaeger version ${jaeger_version}."
   set -x
 
   if [[ "$manage_kafka" == "true" ]]; then