Repository: jaegertracing/jaeger

Issue:
[Bug]: Index cleaner only works once a day, even if it runs every hour.
### What happened?

I use helm chart with the images (cronjobs) jaeger-es-index-cleaner:1.57.0 and jaeger-es-rollover:1.57.0.
The rollover creates a new span every hour (for example). But the index cleaner only removes indexes older than 00:00 hours (once a day). And I would like indexes older than 24 hours to be deleted from the moment the index cleaner is launched. That is, 08:00, 09:00 and so on.
Here is the index cleaner log
```
{
  "level": "info",
  "ts": 1732172114.3503263,
  "caller": "es-index-cleaner/main.go:89",
  "msg": "Indices before this date will be deleted",
  "date": "2024-11-17T00:00:00Z"
}
```

### Steps to reproduce

Create cronjob jaeger-es-rollover whith `'{"max_age": "1h"}'` and run it every hour.
Run jaeger-es-index-cleaner every hour.

### Expected behavior

Indexes are deleted every hour, not once a day

### Relevant log output

```shell

```

### Screenshot

_No response_

### Additional context

_No response_

### Jaeger backend version

1.57.0

### SDK

_No response_

### Pipeline

_No response_

### Stogage backend

_No response_

### Operating system

_No response_

### Deployment model

_No response_

### Deployment configs

```shell

```

Discussion:
@shinigami-777: @vc43 did u try by passing 0 to `numberOfDays` ?

Solution patch:
diff --git a/cmd/es-index-cleaner/app/cutoff_time.go b/cmd/es-index-cleaner/app/cutoff_time.go
new file mode 100644
index 000000000..45896bdbc
--- /dev/null
+++ b/cmd/es-index-cleaner/app/cutoff_time.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"time"
+)
+
+func CalculateDeletionCutoff(currTime time.Time, numOfDays int, relativeIndexEnabled bool) time.Time {
+	year, month, day := currTime.Date()
+	// tomorrow midnight
+	cutoffTime := time.Date(year, month, day, 0, 0, 0, 0, time.UTC).AddDate(0, 0, 1)
+	if relativeIndexEnabled {
+		cutoffTime = currTime
+	}
+	return cutoffTime.Add(-time.Hour * 24 * time.Duration(numOfDays))
+}
diff --git a/cmd/es-index-cleaner/main.go b/cmd/es-index-cleaner/main.go
index 3c980b2da..baa6cba5a 100644
--- a/cmd/es-index-cleaner/main.go
+++ b/cmd/es-index-cleaner/main.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/base64"
 	"errors"
+	"flag"
 	"fmt"
 	"log"
 	"net/http"
@@ -14,7 +15,9 @@ import (
 	"time"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
+	"go.opentelemetry.io/collector/featuregate"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger/cmd/es-index-cleaner/app"
@@ -22,6 +25,21 @@ import (
 	"github.com/jaegertracing/jaeger/pkg/es/client"
 )
 
+var relativeIndexCleaner *featuregate.Gate
+
+func init() {
+	relativeIndexCleaner = featuregate.GlobalRegistry().MustRegister(
+		"es.index.relativeTimeIndexDeletion",
+		featuregate.StageAlpha,
+		featuregate.WithRegisterFromVersion("v2.5.0"),
+		featuregate.WithRegisterDescription("Controls whether the indices will be deleted relative to the current time or tomorrow midnight."),
+		featuregate.WithRegisterReferenceURL("https://github.com/jaegertracing/jaeger/issues/6236"),
+	)
+	featureGateFlagSet := flag.NewFlagSet("feature-gates", flag.ExitOnError)
+	featuregate.GlobalRegistry().RegisterFlags(featureGateFlagSet)
+	pflag.CommandLine.AddGoFlagSet(featureGateFlagSet)
+}
+
 func main() {
 	logger, _ := zap.NewProduction()
 	v := viper.New()
@@ -70,9 +88,7 @@ func main() {
 				return err
 			}
 
-			year, month, day := time.Now().UTC().Date()
-			tomorrowMidnight := time.Date(year, month, day, 0, 0, 0, 0, time.UTC).AddDate(0, 0, 1)
-			deleteIndicesBefore := tomorrowMidnight.Add(-time.Hour * 24 * time.Duration(numOfDays))
+			deleteIndicesBefore := app.CalculateDeletionCutoff(time.Now().UTC(), numOfDays, relativeIndexCleaner.IsEnabled())
 			logger.Info("Indices before this date will be deleted", zap.String("date", deleteIndicesBefore.Format(time.RFC3339)))
 
 			filter := &app.IndexFilter{
@@ -100,6 +116,7 @@ func main() {
 		cfg.AddFlags,
 	)
 
+	command.Flags().AddFlagSet(pflag.CommandLine)
 	if err := command.Execute(); err != nil {
 		log.Fatalln(err)
 	}
diff --git a/internal/storage/v2/grpc/dependency_storage.proto b/internal/storage/v2/grpc/dependency_storage.proto
index 2a2326590..98e1f496a 100644
--- a/internal/storage/v2/grpc/dependency_storage.proto
+++ b/internal/storage/v2/grpc/dependency_storage.proto
@@ -9,15 +9,9 @@ option go_package = "storage";
 
 message GetDependenciesRequest {
   // start_time is the start of the time interval to search for the dependencies.
-  google.protobuf.Timestamp start_time = 1 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
+  google.protobuf.Timestamp start_time = 1;
   // end_time is the end of the time interval to search for the dependencies.
-  google.protobuf.Timestamp end_time = 2 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
+  google.protobuf.Timestamp end_time = 2;
 }
 
 // Dependency represents a relationship between two services.
@@ -36,7 +30,7 @@ message Dependency {
 }
 
 message GetDependenciesResponse {
-  repeated Dependency dependencies = 1 [(gogoproto.nullable) = false];
+  repeated Dependency dependencies = 1;
 }
 
 service DependencyReader {
diff --git a/internal/storage/v2/grpc/trace_storage.proto b/internal/storage/v2/grpc/trace_storage.proto
index df5921b7c..0d34fde78 100644
--- a/internal/storage/v2/grpc/trace_storage.proto
+++ b/internal/storage/v2/grpc/trace_storage.proto
@@ -2,7 +2,6 @@ syntax = "proto3";
 
 package jaeger.storage.v2;
 
-import "gogoproto/gogo.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
 import "opentelemetry/proto/trace/v1/trace.proto";
@@ -17,12 +16,12 @@ message GetTraceParams {
   // start_time is the start of the time interval to search for the trace_id.
   //
   // This field is optional.
-  google.protobuf.Timestamp start_time = 2 [(gogoproto.stdtime) = true];
+  google.protobuf.Timestamp start_time = 2;
 
   // end_time is the end of the time interval to search for the trace_id.
   //
   // This field is optional.
-  google.protobuf.Timestamp end_time = 3 [(gogoproto.stdtime) = true];
+  google.protobuf.Timestamp end_time = 3;
 }
 
 // GetTracesRequest represents a request to retrieve multiple traces.
@@ -49,13 +48,13 @@ message GetOperationsRequest {
   // spans generated in a particular context.
   //
   // This field is optional.
-  opentelemetry.proto.trace.v1.Span.SpanKind span_kind = 2;
+  string span_kind = 2;
 }
 
 // Operation contains information about an operation for a given service.
 message Operation {
   string name = 1;
-  opentelemetry.proto.trace.v1.Span.SpanKind span_kind = 2;
+  string span_kind = 2;
 }
 
 // GetOperationsResponse represents the response for GetOperationsRequest.
@@ -98,22 +97,10 @@ message TraceQueryParameters {
   string service_name = 1;
   string operation_name = 2;
   repeated KeyValue attributes = 3;
-  google.protobuf.Timestamp start_time_min = 4 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
-  google.protobuf.Timestamp start_time_max = 5 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
-  google.protobuf.Duration duration_min = 6 [
-    (gogoproto.stdduration) = true,
-    (gogoproto.nullable) = false
-  ];
-  google.protobuf.Duration duration_max = 7 [
-    (gogoproto.stdduration) = true,
-    (gogoproto.nullable) = false
-  ];
+  google.protobuf.Timestamp start_time_min = 4;
+  google.protobuf.Timestamp start_time_max = 5;
+  google.protobuf.Duration duration_min = 6;
+  google.protobuf.Duration duration_max = 7;
   int32 search_depth = 8;
 }
 
@@ -133,14 +120,8 @@ message FindTracesRequest {
 // It is meant as a rough boundary and may not be populated in all cases.
 message FoundTraceID {
   bytes trace_id = 1;
-  google.protobuf.Timestamp start = 2 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
-  google.protobuf.Timestamp end = 3 [
-    (gogoproto.stdtime) = true,
-    (gogoproto.nullable) = false
-  ];
+  google.protobuf.Timestamp start = 2;
+  google.protobuf.Timestamp end = 3;
 }
 
 // FindTraceIDsResponse represents the response for FindTracesRequest.
diff --git a/proto-gen/patch-api-v3.sed b/proto-gen/patch.sed
similarity index 100%
rename from proto-gen/patch-api-v3.sed
rename to proto-gen/patch.sed
diff --git a/proto-gen/storage/v2/dependency_storage.pb.go b/proto-gen/storage/v2/dependency_storage.pb.go
index 24c7498fa..2ff49f064 100644
--- a/proto-gen/storage/v2/dependency_storage.pb.go
+++ b/proto-gen/storage/v2/dependency_storage.pb.go
@@ -144,10 +144,10 @@ func (m *Dependency) GetSource() string {
 }
 
 type GetDependenciesResponse struct {
-	Dependencies         []Dependency `protobuf:"bytes,1,rep,name=dependencies,proto3" json:"dependencies"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Dependencies         []*Dependency `protobuf:"bytes,1,rep,name=dependencies,proto3" json:"dependencies,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
 }
 
 func (m *GetDependenciesResponse) Reset()         { *m = GetDependenciesResponse{} }
@@ -174,7 +174,7 @@ func (m *GetDependenciesResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_GetDependenciesResponse proto.InternalMessageInfo
 
-func (m *GetDependenciesResponse) GetDependencies() []Dependency {
+func (m *GetDependenciesResponse) GetDependencies() []*Dependency {
 	if m != nil {
 		return m.Dependencies
 	}
@@ -190,29 +190,28 @@ func init() {
 func init() { proto.RegisterFile("dependency_storage.proto", fileDescriptor_17393f3b58692e2b) }
 
 var fileDescriptor_17393f3b58692e2b = []byte{
-	// 342 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0xc1, 0x4e, 0xea, 0x40,
-	0x14, 0x86, 0x6f, 0x2f, 0x5c, 0xa0, 0x87, 0x9b, 0xdc, 0xeb, 0x84, 0x60, 0xd3, 0x84, 0x40, 0x58,
-	0xa1, 0x8b, 0x92, 0xd4, 0x07, 0x30, 0x01, 0x13, 0xf6, 0x13, 0x57, 0x6e, 0xc8, 0xd0, 0x39, 0x16,
-	0x4c, 0x99, 0x29, 0x33, 0x53, 0x13, 0x12, 0x1f, 0xc2, 0x27, 0xf0, 0x79, 0x7c, 0x0a, 0x7d, 0x15,
-	0x33, 0x1d, 0x2a, 0x2a, 0x2c, 0x74, 0xd7, 0xff, 0x9f, 0xff, 0x7c, 0xe7, 0x9c, 0x1e, 0x08, 0x38,
-	0xe6, 0x28, 0x38, 0x8a, 0x64, 0x3b, 0xd7, 0x46, 0x2a, 0x96, 0x62, 0x94, 0x2b, 0x69, 0x24, 0x39,
-	0xb9, 0x63, 0x98, 0xa2, 0x8a, 0x2a, 0xf7, 0x3e, 0x0e, 0x3b, 0xa9, 0x4c, 0x65, 0xf9, 0x3a, 0xb6,
-	0x5f, 0x2e, 0x18, 0xf6, 0x53, 0x29, 0xd3, 0x0c, 0xc7, 0xa5, 0x5a, 0x14, 0xb7, 0x63, 0xb3, 0x5a,
-	0xa3, 0x36, 0x6c, 0x9d, 0xbb, 0xc0, 0xf0, 0xc9, 0x83, 0xee, 0x0c, 0xcd, 0x55, 0xd5, 0x69, 0x85,
-	0x9a, 0xe2, 0xa6, 0x40, 0x6d, 0xc8, 0x14, 0x40, 0x1b, 0xa6, 0xcc, 0xdc, 0xd6, 0x04, 0xde, 0xc0,
-	0x1b, 0xb5, 0xe3, 0x30, 0x72, 0xc0, 0xa8, 0x02, 0x46, 0xd7, 0x15, 0x70, 0xd2, 0x7a, 0x7e, 0xe9,
-	0xff, 0x7a, 0x7c, 0xed, 0x7b, 0xd4, 0x2f, 0xeb, 0xec, 0x0b, 0xb9, 0x84, 0x16, 0x0a, 0xee, 0x10,
-	0xbf, 0x7f, 0x80, 0x68, 0xa2, 0xe0, 0xd6, 0x1f, 0x6e, 0x00, 0xde, 0x87, 0xdb, 0x92, 0x2e, 0x34,
-	0x72, 0xa6, 0x50, 0x98, 0x72, 0x1e, 0x9f, 0xee, 0x14, 0xe9, 0xc0, 0x9f, 0x64, 0xb9, 0xca, 0x78,
-	0xd9, 0xc3, 0xa7, 0x4e, 0x90, 0x1e, 0x40, 0xc2, 0xb2, 0x6c, 0x9e, 0xc8, 0x42, 0x98, 0xa0, 0x36,
-	0xf0, 0x46, 0x75, 0xea, 0x5b, 0x67, 0x6a, 0x0d, 0x0b, 0xd3, 0xb2, 0x50, 0x09, 0x06, 0x75, 0x07,
-	0x73, 0x6a, 0xb8, 0x80, 0xd3, 0x83, 0x5f, 0xa2, 0x73, 0x29, 0x34, 0x92, 0x19, 0xfc, 0xe5, 0x1f,
-	0xfc, 0xc0, 0x1b, 0xd4, 0x46, 0xed, 0xb8, 0x17, 0x1d, 0xdc, 0x23, 0xda, 0x0f, 0x3d, 0xa9, 0xdb,
-	0xad, 0xe8, 0xa7, 0xc2, 0xf8, 0x01, 0xfe, 0xef, 0x13, 0x14, 0x19, 0x47, 0x45, 0x96, 0xf0, 0xef,
-	0x4b, 0x5f, 0x72, 0x76, 0x84, 0x7c, 0xfc, 0x5c, 0xe1, 0xf9, 0x77, 0xa2, 0x6e, 0x8d, 0x89, 0x7f,
-	0xd3, 0xdc, 0xa5, 0x16, 0x8d, 0xf2, 0x0c, 0x17, 0x6f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x23,
-	0x6a, 0x89, 0x6d, 0x02, 0x00, 0x00,
+	// 335 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0x51, 0x4e, 0xc2, 0x40,
+	0x10, 0x86, 0xad, 0x20, 0xd0, 0xc1, 0x44, 0xdd, 0x10, 0x6c, 0x9a, 0x10, 0x08, 0x4f, 0xe8, 0x43,
+	0x49, 0xea, 0x01, 0x8c, 0x60, 0xe2, 0x7b, 0xe3, 0x93, 0x31, 0x21, 0x4b, 0x77, 0x2c, 0x98, 0xb2,
+	0x5b, 0x76, 0xb7, 0x26, 0x24, 0x1e, 0xc2, 0x13, 0x78, 0x1e, 0x4f, 0xa1, 0x57, 0x31, 0xdb, 0xa5,
+	0x8a, 0xc2, 0x83, 0xbe, 0xf5, 0xff, 0xe7, 0x9f, 0x6f, 0xa6, 0x3b, 0xe0, 0x31, 0xcc, 0x90, 0x33,
+	0xe4, 0xf1, 0x6a, 0xa2, 0xb4, 0x90, 0x34, 0xc1, 0x20, 0x93, 0x42, 0x0b, 0x72, 0xf2, 0x48, 0x31,
+	0x41, 0x19, 0x94, 0xee, 0x53, 0xe8, 0xb7, 0x12, 0x91, 0x88, 0xa2, 0x3a, 0x34, 0x5f, 0x36, 0xe8,
+	0x77, 0x13, 0x21, 0x92, 0x14, 0x87, 0x85, 0x9a, 0xe6, 0x0f, 0x43, 0x3d, 0x5f, 0xa0, 0xd2, 0x74,
+	0x91, 0xd9, 0x40, 0xff, 0xd5, 0x81, 0xf6, 0x0d, 0xea, 0xeb, 0x72, 0xd2, 0x1c, 0x55, 0x84, 0xcb,
+	0x1c, 0x95, 0x26, 0x63, 0x00, 0xa5, 0xa9, 0xd4, 0x13, 0xd3, 0xe3, 0x39, 0x3d, 0x67, 0xd0, 0x0c,
+	0xfd, 0xc0, 0x02, 0x83, 0x12, 0x18, 0xdc, 0x96, 0xc0, 0x51, 0xe3, 0xed, 0xbd, 0xbb, 0xf7, 0xf2,
+	0xd1, 0x75, 0x22, 0xb7, 0xe8, 0x33, 0x15, 0x72, 0x09, 0x0d, 0xe4, 0xcc, 0x22, 0xf6, 0xff, 0x81,
+	0xa8, 0x23, 0x67, 0xc6, 0xef, 0x2f, 0x01, 0xbe, 0x96, 0x5b, 0x91, 0x36, 0xd4, 0x32, 0x2a, 0x91,
+	0xeb, 0x62, 0x1f, 0x37, 0x5a, 0x2b, 0xd2, 0x82, 0x83, 0x78, 0x36, 0x4f, 0x59, 0x31, 0xc3, 0x8d,
+	0xac, 0x20, 0x1d, 0x80, 0x98, 0xa6, 0xe9, 0x24, 0x16, 0x39, 0xd7, 0x5e, 0xa5, 0xe7, 0x0c, 0xaa,
+	0x91, 0x6b, 0x9c, 0xb1, 0x31, 0x0c, 0x4c, 0x89, 0x5c, 0xc6, 0xe8, 0x55, 0x2d, 0xcc, 0xaa, 0xfe,
+	0x3d, 0x9c, 0x6e, 0x3d, 0x89, 0xca, 0x04, 0x57, 0x48, 0xae, 0xe0, 0x90, 0x6d, 0xf8, 0x9e, 0xd3,
+	0xab, 0x0c, 0x9a, 0x61, 0x27, 0xd8, 0xba, 0x47, 0xf0, 0xbd, 0x74, 0xf4, 0xa3, 0x25, 0x7c, 0x86,
+	0xe3, 0x8d, 0x1a, 0x52, 0x86, 0x92, 0xcc, 0xe0, 0xe8, 0xd7, 0x44, 0x72, 0xb6, 0x83, 0xb9, 0xfb,
+	0x50, 0xfe, 0xf9, 0x5f, 0xa2, 0xf6, 0x07, 0x46, 0xee, 0x5d, 0x7d, 0x9d, 0x9a, 0xd6, 0x8a, 0x03,
+	0x5c, 0x7c, 0x06, 0x00, 0x00, 0xff, 0xff, 0x53, 0xb1, 0x32, 0x78, 0x67, 0x02, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/proto-gen/storage/v2/trace_storage.pb.go b/proto-gen/storage/v2/trace_storage.pb.go
index 8bdea1bed..4837c7d4b 100644
--- a/proto-gen/storage/v2/trace_storage.pb.go
+++ b/proto-gen/storage/v2/trace_storage.pb.go
@@ -5,15 +5,19 @@ package storage
 
 import (
 	context "context"
+	encoding_binary "encoding/binary"
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/gogo/protobuf/types"
-	v1 "go.opentelemetry.io/proto/otlp/trace/v1"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	v1 "github.com/jaegertracing/jaeger/internal/jptrace"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 	time "time"
 )
 
@@ -36,14 +40,14 @@ type GetTraceParams struct {
 	// start_time is the start of the time interval to search for the trace_id.
 	//
 	// This field is optional.
-	StartTime *time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time,omitempty"`
+	StartTime time.Time `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time"`
 	// end_time is the end of the time interval to search for the trace_id.
 	//
 	// This field is optional.
-	EndTime              *time.Time `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time,omitempty"`
-	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"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
 }
 
 func (m *GetTraceParams) Reset()         { *m = GetTraceParams{} }
@@ -53,16 +57,25 @@ func (*GetTraceParams) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{0}
 }
 func (m *GetTraceParams) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetTraceParams.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetTraceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetTraceParams.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetTraceParams.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetTraceParams) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetTraceParams.Merge(m, src)
 }
 func (m *GetTraceParams) XXX_Size() int {
-	return xxx_messageInfo_GetTraceParams.Size(m)
+	return m.Size()
 }
 func (m *GetTraceParams) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetTraceParams.DiscardUnknown(m)
@@ -77,18 +90,18 @@ func (m *GetTraceParams) GetTraceId() []byte {
 	return nil
 }
 
-func (m *GetTraceParams) GetStartTime() *time.Time {
+func (m *GetTraceParams) GetStartTime() time.Time {
 	if m != nil {
 		return m.StartTime
 	}
-	return nil
+	return time.Time{}
 }
 
-func (m *GetTraceParams) GetEndTime() *time.Time {
+func (m *GetTraceParams) GetEndTime() time.Time {
 	if m != nil {
 		return m.EndTime
 	}
-	return nil
+	return time.Time{}
 }
 
 // GetTracesRequest represents a request to retrieve multiple traces.
@@ -106,16 +119,25 @@ func (*GetTracesRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{1}
 }
 func (m *GetTracesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetTracesRequest.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetTracesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetTracesRequest.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetTracesRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetTracesRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetTracesRequest.Merge(m, src)
 }
 func (m *GetTracesRequest) XXX_Size() int {
-	return xxx_messageInfo_GetTracesRequest.Size(m)
+	return m.Size()
 }
 func (m *GetTracesRequest) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetTracesRequest.DiscardUnknown(m)
@@ -144,16 +166,25 @@ func (*GetServicesRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{2}
 }
 func (m *GetServicesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetServicesRequest.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetServicesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetServicesRequest.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetServicesRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetServicesRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetServicesRequest.Merge(m, src)
 }
 func (m *GetServicesRequest) XXX_Size() int {
-	return xxx_messageInfo_GetServicesRequest.Size(m)
+	return m.Size()
 }
 func (m *GetServicesRequest) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetServicesRequest.DiscardUnknown(m)
@@ -176,16 +207,25 @@ func (*GetServicesResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{3}
 }
 func (m *GetServicesResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetServicesResponse.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetServicesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetServicesResponse.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetServicesResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetServicesResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetServicesResponse.Merge(m, src)
 }
 func (m *GetServicesResponse) XXX_Size() int {
-	return xxx_messageInfo_GetServicesResponse.Size(m)
+	return m.Size()
 }
 func (m *GetServicesResponse) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetServicesResponse.DiscardUnknown(m)
@@ -210,10 +250,10 @@ type GetOperationsRequest struct {
 	// spans generated in a particular context.
 	//
 	// This field is optional.
-	SpanKind             v1.Span_SpanKind `protobuf:"varint,2,opt,name=span_kind,json=spanKind,proto3,enum=opentelemetry.proto.trace.v1.Span_SpanKind" json:"span_kind,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	SpanKind             string   `protobuf:"bytes,2,opt,name=span_kind,json=spanKind,proto3" json:"span_kind,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *GetOperationsRequest) Reset()         { *m = GetOperationsRequest{} }
@@ -223,16 +263,25 @@ func (*GetOperationsRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{4}
 }
 func (m *GetOperationsRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetOperationsRequest.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetOperationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetOperationsRequest.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetOperationsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetOperationsRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetOperationsRequest.Merge(m, src)
 }
 func (m *GetOperationsRequest) XXX_Size() int {
-	return xxx_messageInfo_GetOperationsRequest.Size(m)
+	return m.Size()
 }
 func (m *GetOperationsRequest) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetOperationsRequest.DiscardUnknown(m)
@@ -247,20 +296,20 @@ func (m *GetOperationsRequest) GetService() string {
 	return ""
 }
 
-func (m *GetOperationsRequest) GetSpanKind() v1.Span_SpanKind {
+func (m *GetOperationsRequest) GetSpanKind() string {
 	if m != nil {
 		return m.SpanKind
 	}
-	return v1.Span_SPAN_KIND_UNSPECIFIED
+	return ""
 }
 
 // Operation contains information about an operation for a given service.
 type Operation struct {
-	Name                 string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	SpanKind             v1.Span_SpanKind `protobuf:"varint,2,opt,name=span_kind,json=spanKind,proto3,enum=opentelemetry.proto.trace.v1.Span_SpanKind" json:"span_kind,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	SpanKind             string   `protobuf:"bytes,2,opt,name=span_kind,json=spanKind,proto3" json:"span_kind,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *Operation) Reset()         { *m = Operation{} }
@@ -270,16 +319,25 @@ func (*Operation) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{5}
 }
 func (m *Operation) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Operation.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Operation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Operation.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Operation.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Operation) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Operation.Merge(m, src)
 }
 func (m *Operation) XXX_Size() int {
-	return xxx_messageInfo_Operation.Size(m)
+	return m.Size()
 }
 func (m *Operation) XXX_DiscardUnknown() {
 	xxx_messageInfo_Operation.DiscardUnknown(m)
@@ -294,11 +352,11 @@ func (m *Operation) GetName() string {
 	return ""
 }
 
-func (m *Operation) GetSpanKind() v1.Span_SpanKind {
+func (m *Operation) GetSpanKind() string {
 	if m != nil {
 		return m.SpanKind
 	}
-	return v1.Span_SPAN_KIND_UNSPECIFIED
+	return ""
 }
 
 // GetOperationsResponse represents the response for GetOperationsRequest.
@@ -316,16 +374,25 @@ func (*GetOperationsResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{6}
 }
 func (m *GetOperationsResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_GetOperationsResponse.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *GetOperationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_GetOperationsResponse.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_GetOperationsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *GetOperationsResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetOperationsResponse.Merge(m, src)
 }
 func (m *GetOperationsResponse) XXX_Size() int {
-	return xxx_messageInfo_GetOperationsResponse.Size(m)
+	return m.Size()
 }
 func (m *GetOperationsResponse) XXX_DiscardUnknown() {
 	xxx_messageInfo_GetOperationsResponse.DiscardUnknown(m)
@@ -358,16 +425,25 @@ func (*KeyValue) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{7}
 }
 func (m *KeyValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_KeyValue.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_KeyValue.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *KeyValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_KeyValue.Merge(m, src)
 }
 func (m *KeyValue) XXX_Size() int {
-	return xxx_messageInfo_KeyValue.Size(m)
+	return m.Size()
 }
 func (m *KeyValue) XXX_DiscardUnknown() {
 	xxx_messageInfo_KeyValue.DiscardUnknown(m)
@@ -411,16 +487,25 @@ func (*AnyValue) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{8}
 }
 func (m *AnyValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_AnyValue.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *AnyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_AnyValue.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_AnyValue.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *AnyValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AnyValue.Merge(m, src)
 }
 func (m *AnyValue) XXX_Size() int {
-	return xxx_messageInfo_AnyValue.Size(m)
+	return m.Size()
 }
 func (m *AnyValue) XXX_DiscardUnknown() {
 	xxx_messageInfo_AnyValue.DiscardUnknown(m)
@@ -430,6 +515,8 @@ var xxx_messageInfo_AnyValue proto.InternalMessageInfo
 
 type isAnyValue_Value interface {
 	isAnyValue_Value()
+	MarshalTo([]byte) (int, error)
+	Size() int
 }
 
 type AnyValue_StringValue struct {
@@ -545,16 +632,25 @@ func (*KeyValueList) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{9}
 }
 func (m *KeyValueList) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_KeyValueList.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *KeyValueList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_KeyValueList.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_KeyValueList.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *KeyValueList) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_KeyValueList.Merge(m, src)
 }
 func (m *KeyValueList) XXX_Size() int {
-	return xxx_messageInfo_KeyValueList.Size(m)
+	return m.Size()
 }
 func (m *KeyValueList) XXX_DiscardUnknown() {
 	xxx_messageInfo_KeyValueList.DiscardUnknown(m)
@@ -583,16 +679,25 @@ func (*ArrayValue) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{10}
 }
 func (m *ArrayValue) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ArrayValue.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *ArrayValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ArrayValue.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_ArrayValue.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *ArrayValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ArrayValue.Merge(m, src)
 }
 func (m *ArrayValue) XXX_Size() int {
-	return xxx_messageInfo_ArrayValue.Size(m)
+	return m.Size()
 }
 func (m *ArrayValue) XXX_DiscardUnknown() {
 	xxx_messageInfo_ArrayValue.DiscardUnknown(m)
@@ -631,16 +736,25 @@ func (*TraceQueryParameters) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{11}
 }
 func (m *TraceQueryParameters) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_TraceQueryParameters.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *TraceQueryParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_TraceQueryParameters.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_TraceQueryParameters.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *TraceQueryParameters) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TraceQueryParameters.Merge(m, src)
 }
 func (m *TraceQueryParameters) XXX_Size() int {
-	return xxx_messageInfo_TraceQueryParameters.Size(m)
+	return m.Size()
 }
 func (m *TraceQueryParameters) XXX_DiscardUnknown() {
 	xxx_messageInfo_TraceQueryParameters.DiscardUnknown(m)
@@ -721,16 +835,25 @@ func (*FindTracesRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{12}
 }
 func (m *FindTracesRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FindTracesRequest.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *FindTracesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FindTracesRequest.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_FindTracesRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *FindTracesRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FindTracesRequest.Merge(m, src)
 }
 func (m *FindTracesRequest) XXX_Size() int {
-	return xxx_messageInfo_FindTracesRequest.Size(m)
+	return m.Size()
 }
 func (m *FindTracesRequest) XXX_DiscardUnknown() {
 	xxx_messageInfo_FindTracesRequest.DiscardUnknown(m)
@@ -768,16 +891,25 @@ func (*FoundTraceID) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{13}
 }
 func (m *FoundTraceID) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FoundTraceID.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *FoundTraceID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FoundTraceID.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_FoundTraceID.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *FoundTraceID) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FoundTraceID.Merge(m, src)
 }
 func (m *FoundTraceID) XXX_Size() int {
-	return xxx_messageInfo_FoundTraceID.Size(m)
+	return m.Size()
 }
 func (m *FoundTraceID) XXX_DiscardUnknown() {
 	xxx_messageInfo_FoundTraceID.DiscardUnknown(m)
@@ -821,16 +953,25 @@ func (*FindTraceIDsResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3441c0fd9397413c, []int{14}
 }
 func (m *FindTraceIDsResponse) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FindTraceIDsResponse.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *FindTraceIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FindTraceIDsResponse.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_FindTraceIDsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *FindTraceIDsResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FindTraceIDsResponse.Merge(m, src)
 }
 func (m *FindTraceIDsResponse) XXX_Size() int {
-	return xxx_messageInfo_FindTraceIDsResponse.Size(m)
+	return m.Size()
 }
 func (m *FindTraceIDsResponse) XXX_DiscardUnknown() {
 	xxx_messageInfo_FindTraceIDsResponse.DiscardUnknown(m)
@@ -866,68 +1007,68 @@ func init() {
 func init() { proto.RegisterFile("trace_storage.proto", fileDescriptor_3441c0fd9397413c) }
 
 var fileDescriptor_3441c0fd9397413c = []byte{
-	// 976 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x8e, 0xdb, 0x44,
-	0x14, 0x8e, 0x37, 0x9b, 0x8d, 0x7d, 0xec, 0xae, 0xda, 0x69, 0x90, 0xd2, 0x94, 0x92, 0xac, 0x4b,
-	0xd9, 0x48, 0x48, 0x0e, 0x9b, 0x4a, 0x20, 0x51, 0x10, 0x74, 0x89, 0x76, 0xb3, 0x2c, 0x50, 0x70,
-	0x17, 0x2e, 0xb8, 0xa8, 0x99, 0xd4, 0x43, 0x6a, 0x36, 0x19, 0xa7, 0x9e, 0x49, 0x94, 0xf0, 0x14,
-	0x5c, 0x72, 0xc3, 0x03, 0xf0, 0x26, 0x7d, 0x0a, 0xb8, 0xe5, 0x09, 0xb8, 0x46, 0xf3, 0x63, 0xc7,
-	0xc9, 0x5a, 0xd9, 0xac, 0xc4, 0x8d, 0xe5, 0xf9, 0xe6, 0x3b, 0xdf, 0x39, 0x73, 0xce, 0x99, 0x39,
-	0x70, 0x97, 0x27, 0xf8, 0x25, 0x09, 0x18, 0x8f, 0x13, 0x3c, 0x24, 0xde, 0x24, 0x89, 0x79, 0x8c,
-	0xee, 0xfc, 0x82, 0xc9, 0x90, 0x24, 0x5e, 0x8a, 0xce, 0xba, 0x8d, 0xda, 0x30, 0x1e, 0xc6, 0x72,
-	0xb7, 0x23, 0xfe, 0x14, 0xb1, 0xf1, 0xce, 0x30, 0x8e, 0x87, 0x23, 0xd2, 0x91, 0xab, 0xc1, 0xf4,
-	0xe7, 0x4e, 0x38, 0x4d, 0x30, 0x8f, 0x62, 0xaa, 0xf7, 0x9b, 0xeb, 0xfb, 0x3c, 0x1a, 0x13, 0xc6,
-	0xf1, 0x78, 0xa2, 0x09, 0xed, 0x78, 0x42, 0x28, 0x27, 0x23, 0x32, 0x26, 0x3c, 0x59, 0x28, 0x5e,
-	0x47, 0x86, 0xd4, 0x99, 0x1d, 0xa9, 0x1f, 0xc5, 0x74, 0xff, 0x34, 0x60, 0xff, 0x94, 0xf0, 0x0b,
-	0x01, 0x7d, 0x8b, 0x13, 0x3c, 0x66, 0xe8, 0x1e, 0x98, 0x2a, 0xfa, 0x28, 0xac, 0x1b, 0x2d, 0xa3,
-	0xed, 0xf8, 0x55, 0xb9, 0x3e, 0x0b, 0xd1, 0x67, 0x00, 0x8c, 0xe3, 0x84, 0x07, 0xc2, 0x61, 0x7d,
-	0xa7, 0x65, 0xb4, 0xed, 0x6e, 0xc3, 0x53, 0xd1, 0x78, 0x69, 0x34, 0xde, 0x45, 0x1a, 0xcd, 0xf1,
-	0xee, 0x6f, 0x7f, 0x37, 0x0d, 0xdf, 0x92, 0x36, 0x02, 0x45, 0x4f, 0xc0, 0x24, 0x34, 0x54, 0xe6,
-	0xe5, 0x2d, 0xcd, 0xab, 0x84, 0x86, 0x02, 0x73, 0xcf, 0xe1, 0x76, 0x1a, 0x2a, 0xf3, 0xc9, 0xeb,
-	0x29, 0x61, 0x1c, 0x7d, 0x04, 0x95, 0xd7, 0x53, 0x92, 0x2c, 0xea, 0x46, 0xab, 0xdc, 0xb6, 0xbb,
-	0x07, 0xde, 0x95, 0x1c, 0x7b, 0xab, 0xc7, 0xf3, 0x15, 0xdf, 0xad, 0x01, 0x3a, 0x25, 0xfc, 0x39,
-	0x49, 0x66, 0xd1, 0x52, 0xce, 0x3d, 0x82, 0xbb, 0x2b, 0x28, 0x9b, 0xc4, 0x94, 0x11, 0xd4, 0x00,
-	0x93, 0x69, 0x4c, 0x3a, 0xb2, 0xfc, 0x6c, 0xed, 0xfe, 0x0a, 0xb5, 0x53, 0xc2, 0x9f, 0x4d, 0x88,
-	0x2a, 0x51, 0x16, 0x59, 0x1d, 0xaa, 0x9a, 0x23, 0xb3, 0x68, 0xf9, 0xe9, 0x12, 0xf5, 0xc1, 0x62,
-	0x13, 0x4c, 0x83, 0xcb, 0x88, 0x86, 0x32, 0x89, 0xfb, 0xdd, 0xf7, 0xbd, 0x95, 0x8a, 0xa9, 0x64,
-	0x78, 0xaa, 0x50, 0xb3, 0x23, 0xef, 0xf9, 0x04, 0x53, 0xf9, 0x39, 0x8f, 0x68, 0xe8, 0x9b, 0x4c,
-	0xff, 0xb9, 0x11, 0x58, 0x99, 0x63, 0x84, 0x60, 0x97, 0xe2, 0x71, 0xea, 0x4d, 0xfe, 0xff, 0x8f,
-	0xae, 0xbe, 0x87, 0xb7, 0xd6, 0x8e, 0xa9, 0x73, 0xf3, 0x09, 0x40, 0x9c, 0xa1, 0xba, 0x0c, 0x6f,
-	0x17, 0x94, 0x21, 0x33, 0xf5, 0x73, 0x7c, 0xf7, 0x19, 0x98, 0xe7, 0x64, 0xf1, 0x03, 0x1e, 0x4d,
-	0x09, 0xba, 0x0d, 0xe5, 0x4b, 0xb2, 0xd0, 0xf1, 0x8b, 0x5f, 0x74, 0x04, 0x95, 0x99, 0xd8, 0xd2,
-	0xad, 0x76, 0xbf, 0x40, 0xf6, 0x29, 0x55, 0xd6, 0xbe, 0x62, 0xba, 0x6f, 0x76, 0xc0, 0x4c, 0x31,
-	0xf4, 0x10, 0x1c, 0xc6, 0x93, 0x88, 0x0e, 0x03, 0x25, 0x23, 0xa5, 0xfb, 0x25, 0xdf, 0x56, 0xa8,
-	0x22, 0x35, 0x01, 0x06, 0x71, 0x3c, 0x0a, 0x96, 0x9e, 0xcc, 0x7e, 0xc9, 0xb7, 0x04, 0xa6, 0x08,
-	0x0f, 0xc0, 0x8a, 0x28, 0xd7, 0xfb, 0xa2, 0x6b, 0xcb, 0xfd, 0x92, 0x6f, 0x46, 0x94, 0x67, 0x4e,
-	0xc2, 0x78, 0x3a, 0x18, 0x11, 0xcd, 0xd8, 0x6d, 0x19, 0x6d, 0x43, 0x38, 0x51, 0xa8, 0x22, 0x7d,
-	0x0e, 0x36, 0x4e, 0x12, 0xbc, 0xd0, 0x9c, 0x8a, 0x3c, 0xcf, 0x83, 0xa2, 0xf3, 0x08, 0x96, 0xb4,
-	0xe9, 0x97, 0x7c, 0xc0, 0xd9, 0x0a, 0xf5, 0xc0, 0xb9, 0x9c, 0x8d, 0x22, 0x96, 0x06, 0xb2, 0x27,
-	0x25, 0x9a, 0x05, 0x12, 0x69, 0x42, 0xbf, 0x8a, 0x18, 0x17, 0x71, 0x28, 0x33, 0xa5, 0x72, 0x00,
-	0xf6, 0x60, 0xc1, 0x09, 0xd3, 0x22, 0x55, 0x71, 0xbf, 0x85, 0x23, 0x09, 0x4a, 0xca, 0x71, 0x55,
-	0x27, 0xdd, 0xfd, 0x02, 0x9c, 0xbc, 0x14, 0x7a, 0x0c, 0x7b, 0x72, 0x23, 0xad, 0xf2, 0xfd, 0x0d,
-	0xbe, 0x7d, 0x4d, 0x75, 0x9f, 0x02, 0x2c, 0x8f, 0xb4, 0x95, 0x44, 0x56, 0xd1, 0x54, 0xe2, 0x9f,
-	0x32, 0xd4, 0xe4, 0x0d, 0xfe, 0x4e, 0xdc, 0x5c, 0x79, 0x8d, 0x09, 0x27, 0x09, 0x43, 0x07, 0xe0,
-	0xe8, 0x3b, 0x15, 0xe4, 0x3a, 0xdf, 0xd6, 0xd8, 0x37, 0xe2, 0x02, 0x3c, 0x82, 0xfd, 0xac, 0xdb,
-	0x14, 0x69, 0x47, 0x92, 0x6e, 0x65, 0xa8, 0xa4, 0x3d, 0x01, 0xc0, 0x9c, 0x27, 0xd1, 0x60, 0xca,
-	0x09, 0xab, 0x97, 0xaf, 0x3f, 0x5e, 0x8e, 0x8e, 0xbe, 0x84, 0xfd, 0xe5, 0xab, 0x18, 0x8c, 0x23,
-	0x2a, 0x5b, 0x60, 0xf3, 0xd3, 0x66, 0xbe, 0xf9, 0xab, 0x59, 0x92, 0xcf, 0x9b, 0x93, 0xbd, 0x8e,
-	0x5f, 0x47, 0x74, 0x5d, 0x0b, 0xcf, 0x75, 0xab, 0xdc, 0x58, 0x0b, 0xcf, 0xd1, 0x09, 0x38, 0xe9,
-	0xe0, 0x90, 0x51, 0xa9, 0x8e, 0xb9, 0x77, 0x45, 0xa9, 0xa7, 0x49, 0x4a, 0xe8, 0x77, 0x21, 0x64,
-	0xa7, 0x86, 0x22, 0xa6, 0x15, 0x1d, 0x3c, 0x97, 0x4d, 0x73, 0x63, 0x1d, 0x3c, 0x57, 0xe5, 0xc2,
-	0xc9, 0xcb, 0x57, 0x41, 0x48, 0x26, 0xfc, 0x55, 0xdd, 0x6c, 0x19, 0xed, 0x8a, 0x28, 0x97, 0xc0,
-	0x7a, 0x02, 0x72, 0x7d, 0xb8, 0x73, 0x12, 0xd1, 0x70, 0xf5, 0x8d, 0xff, 0x74, 0xf9, 0xc6, 0x0b,
-	0xc7, 0x87, 0x05, 0x75, 0x29, 0x6a, 0x8f, 0xf4, 0xa5, 0xff, 0xc3, 0x00, 0xe7, 0x24, 0x9e, 0x6a,
-	0xd5, 0xb3, 0xde, 0xa6, 0x01, 0xf7, 0x31, 0x54, 0x64, 0x0a, 0xb7, 0x98, 0x6d, 0xcb, 0xac, 0x2b,
-	0x13, 0xf4, 0x21, 0x94, 0x09, 0x0d, 0xb7, 0x18, 0x6b, 0x4b, 0x4b, 0x61, 0xe0, 0x5e, 0x40, 0x2d,
-	0x3b, 0xf3, 0x59, 0x2f, 0xff, 0xb0, 0x5a, 0x69, 0x98, 0xe9, 0x75, 0x29, 0xba, 0xed, 0xf9, 0xa3,
-	0xf9, 0xa6, 0x3e, 0x08, 0xeb, 0xfe, 0x5b, 0x06, 0x5b, 0xa2, 0x3e, 0xc1, 0x21, 0x49, 0xd0, 0x0b,
-	0xb0, 0xb2, 0xe1, 0x89, 0x1e, 0x6e, 0x18, 0x93, 0x69, 0xda, 0x1b, 0xed, 0xcd, 0x83, 0x42, 0x91,
-	0x7b, 0x98, 0x63, 0xb7, 0xf4, 0x81, 0x81, 0x5e, 0x80, 0x9d, 0x9b, 0x9c, 0xe8, 0x51, 0xb1, 0x87,
-	0xb5, 0x79, 0xdb, 0x78, 0xef, 0x3a, 0x9a, 0xca, 0x85, 0x5b, 0x42, 0x21, 0xdc, 0x5a, 0x99, 0x3f,
-	0xe8, 0xb0, 0xd8, 0xf4, 0xca, 0x20, 0x6e, 0xb4, 0xaf, 0x27, 0x66, 0x5e, 0x7e, 0x02, 0x58, 0xf6,
-	0x1f, 0x7a, 0xb7, 0x28, 0xdd, 0xeb, 0xed, 0x79, 0xc3, 0x3c, 0x05, 0xe0, 0xe4, 0xab, 0xbd, 0xa5,
-	0x8f, 0xc3, 0x4d, 0xac, 0x5c, 0xd3, 0xb8, 0xa5, 0x63, 0xeb, 0xc7, 0xaa, 0x26, 0x0d, 0xf6, 0x64,
-	0x28, 0x8f, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x79, 0x2b, 0x3c, 0x30, 0x8e, 0x0a, 0x00, 0x00,
+	// 968 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0xdd, 0x72, 0xdb, 0x44,
+	0x14, 0xb6, 0xea, 0x3a, 0x96, 0x8e, 0xd4, 0x4c, 0xbb, 0x75, 0x67, 0x5c, 0x87, 0xc6, 0x8e, 0x4a,
+	0x89, 0xaf, 0x64, 0x92, 0xce, 0xc0, 0x0c, 0x94, 0x81, 0xa6, 0x9e, 0xfc, 0x10, 0x4a, 0x41, 0x04,
+	0x2e, 0xb8, 0xa8, 0x58, 0x57, 0x8b, 0x2b, 0x62, 0xaf, 0x5c, 0xed, 0xda, 0x63, 0xbf, 0x05, 0x97,
+	0xdc, 0xf0, 0x10, 0xbc, 0x45, 0x2e, 0x79, 0x02, 0x60, 0x72, 0xc5, 0x13, 0x70, 0xcd, 0xec, 0x8f,
+	0x64, 0xd9, 0xd1, 0x38, 0xf1, 0xdd, 0xea, 0xd3, 0x77, 0xbe, 0xf3, 0xb3, 0x67, 0xcf, 0x81, 0xfb,
+	0x3c, 0xc1, 0x6f, 0x48, 0xc0, 0x78, 0x9c, 0xe0, 0x3e, 0xf1, 0x46, 0x49, 0xcc, 0x63, 0x74, 0xef,
+	0x17, 0x4c, 0xfa, 0x24, 0xf1, 0x52, 0x74, 0xb2, 0xdf, 0xd8, 0xee, 0xc7, 0x71, 0x7f, 0x40, 0x3a,
+	0x92, 0xd0, 0x1b, 0xff, 0xdc, 0x09, 0xc7, 0x09, 0xe6, 0x51, 0x4c, 0x95, 0x49, 0xa3, 0xd6, 0x8f,
+	0xfb, 0xb1, 0x3c, 0x76, 0xc4, 0x49, 0xa3, 0xcd, 0x65, 0x2b, 0x1e, 0x0d, 0x09, 0xe3, 0x78, 0x38,
+	0xd2, 0x84, 0x76, 0x3c, 0x22, 0x94, 0x93, 0x01, 0x19, 0x12, 0x9e, 0xcc, 0x14, 0xaf, 0x23, 0x43,
+	0xea, 0x4c, 0xf6, 0xd4, 0x41, 0x31, 0xdd, 0x3f, 0x0c, 0xd8, 0x3c, 0x22, 0xfc, 0x4c, 0x40, 0xdf,
+	0xe0, 0x04, 0x0f, 0x19, 0x7a, 0x08, 0xa6, 0x8a, 0x3e, 0x0a, 0xeb, 0x46, 0xcb, 0x68, 0x3b, 0x7e,
+	0x55, 0x7e, 0x9f, 0x84, 0xe8, 0x05, 0x00, 0xe3, 0x38, 0xe1, 0x81, 0x70, 0x58, 0xbf, 0xd5, 0x32,
+	0xda, 0xf6, 0x7e, 0xc3, 0x53, 0xd1, 0x78, 0x69, 0x34, 0xde, 0x59, 0x1a, 0xcd, 0x81, 0x79, 0xf1,
+	0x57, 0xb3, 0xf4, 0xeb, 0xdf, 0x4d, 0xc3, 0xb7, 0xa4, 0x9d, 0xf8, 0x83, 0x3e, 0x07, 0x93, 0xd0,
+	0x50, 0x49, 0x94, 0xd7, 0x90, 0xa8, 0x12, 0x1a, 0x0a, 0xdc, 0x3d, 0x85, 0xbb, 0x69, 0xc8, 0xcc,
+	0x27, 0xef, 0xc6, 0x84, 0x71, 0xf4, 0x31, 0x54, 0xde, 0x8d, 0x49, 0x32, 0xab, 0x1b, 0xad, 0x72,
+	0xdb, 0xde, 0xdf, 0xf1, 0xae, 0xd4, 0xda, 0x5b, 0x4c, 0xd3, 0x57, 0x7c, 0xb7, 0x06, 0xe8, 0x88,
+	0xf0, 0xef, 0x48, 0x32, 0x89, 0xe6, 0x72, 0xee, 0x1e, 0xdc, 0x5f, 0x40, 0xd9, 0x28, 0xa6, 0x8c,
+	0xa0, 0x06, 0x98, 0x4c, 0x63, 0xd2, 0x91, 0xe5, 0x67, 0xdf, 0xee, 0x4b, 0xa8, 0x1d, 0x11, 0xfe,
+	0x6a, 0x44, 0xd4, 0x05, 0x66, 0x91, 0xd5, 0xa1, 0xaa, 0x39, 0xb2, 0x9a, 0x96, 0x9f, 0x7e, 0xa2,
+	0x2d, 0xb0, 0xd8, 0x08, 0xd3, 0xe0, 0x3c, 0xa2, 0xa1, 0x2c, 0xa6, 0x90, 0x1b, 0x61, 0x7a, 0x1a,
+	0xd1, 0xd0, 0x7d, 0x06, 0x56, 0xa6, 0x85, 0x10, 0xdc, 0xa6, 0x78, 0x98, 0x0a, 0xc8, 0xf3, 0x6a,
+	0xeb, 0xef, 0xe1, 0xc1, 0x52, 0x30, 0x3a, 0x83, 0x67, 0x00, 0x71, 0x86, 0xea, 0x62, 0xbd, 0x57,
+	0x50, 0xac, 0xcc, 0xd4, 0xcf, 0xf1, 0xdd, 0x57, 0x60, 0x9e, 0x92, 0xd9, 0x0f, 0x78, 0x30, 0x26,
+	0xe8, 0x2e, 0x94, 0xcf, 0xc9, 0x4c, 0x87, 0x24, 0x8e, 0x68, 0x0f, 0x2a, 0x13, 0xf1, 0x4b, 0x37,
+	0xc6, 0x56, 0x81, 0xec, 0x73, 0xaa, 0xac, 0x7d, 0xc5, 0x74, 0x2f, 0x6e, 0x81, 0x99, 0x62, 0xe8,
+	0x31, 0x38, 0x8c, 0x27, 0x11, 0xed, 0x07, 0x4a, 0x46, 0x4a, 0x1f, 0x97, 0x7c, 0x5b, 0xa1, 0x8a,
+	0xd4, 0x04, 0xe8, 0xc5, 0xf1, 0x20, 0x98, 0x7b, 0x32, 0x8f, 0x4b, 0xbe, 0x25, 0x30, 0x45, 0x78,
+	0x04, 0x56, 0x44, 0xb9, 0xfe, 0x2f, 0xfa, 0xab, 0x7c, 0x5c, 0xf2, 0xcd, 0x88, 0xf2, 0xcc, 0x49,
+	0x18, 0x8f, 0x7b, 0x03, 0xa2, 0x19, 0xb7, 0x5b, 0x46, 0xdb, 0x10, 0x4e, 0x14, 0xaa, 0x48, 0x5f,
+	0x80, 0x8d, 0x93, 0x04, 0xcf, 0x34, 0xa7, 0x22, 0xf3, 0x79, 0x54, 0x94, 0x8f, 0x60, 0x49, 0x9b,
+	0xe3, 0x92, 0x0f, 0x38, 0xfb, 0x42, 0x5d, 0x70, 0xce, 0x27, 0x83, 0x88, 0xa5, 0x81, 0x6c, 0x48,
+	0x89, 0x66, 0x81, 0x44, 0x5a, 0xd0, 0xaf, 0x22, 0xc6, 0x45, 0x1c, 0xca, 0x4c, 0xa9, 0xec, 0x80,
+	0xdd, 0x9b, 0x71, 0xc2, 0xb4, 0x48, 0x55, 0xbc, 0x46, 0xe1, 0x48, 0x82, 0x92, 0x72, 0x50, 0xd5,
+	0x45, 0x77, 0x5f, 0x80, 0x93, 0x97, 0x42, 0x4f, 0x61, 0x43, 0xfe, 0x48, 0x6f, 0x79, 0x6b, 0x85,
+	0x6f, 0x5f, 0x53, 0xdd, 0xe7, 0x00, 0xf3, 0x94, 0x6e, 0x24, 0x91, 0xdd, 0x68, 0x2a, 0xf1, 0x6f,
+	0x19, 0x6a, 0xf2, 0x9d, 0x7d, 0x2b, 0xde, 0x97, 0x7c, 0x6c, 0x84, 0x93, 0x84, 0xa1, 0x1d, 0x70,
+	0x74, 0xe7, 0x07, 0xb9, 0x66, 0xb6, 0x35, 0xf6, 0xb5, 0xe8, 0xe9, 0x27, 0xb0, 0x99, 0x75, 0x9b,
+	0x22, 0xa9, 0xc6, 0xbe, 0x93, 0xa1, 0x92, 0xf6, 0x29, 0x00, 0xe6, 0x3c, 0x89, 0x7a, 0x63, 0x4e,
+	0x58, 0xbd, 0x7c, 0x7d, 0x7a, 0x39, 0x3a, 0xfa, 0x12, 0x36, 0xe7, 0x33, 0x2c, 0x18, 0x46, 0x54,
+	0xb6, 0xc0, 0x4d, 0x87, 0x90, 0x93, 0xcd, 0xb1, 0x97, 0x11, 0x5d, 0xd6, 0xc2, 0x53, 0xdd, 0x2a,
+	0x6b, 0x6b, 0xe1, 0x29, 0x3a, 0x04, 0x27, 0x1d, 0xfe, 0x32, 0x2a, 0xd5, 0x31, 0x0f, 0xaf, 0x28,
+	0x75, 0x35, 0x49, 0x09, 0xfd, 0x26, 0x84, 0xec, 0xd4, 0x50, 0xc4, 0xb4, 0xa0, 0x83, 0xa7, 0xb2,
+	0x69, 0xd6, 0xd6, 0xc1, 0x53, 0x75, 0x5d, 0x38, 0x79, 0xf3, 0x36, 0x08, 0xc9, 0x88, 0xbf, 0xad,
+	0x9b, 0x2d, 0xa3, 0x5d, 0x11, 0xd7, 0x25, 0xb0, 0xae, 0x80, 0x5c, 0x1f, 0xee, 0x1d, 0x46, 0x34,
+	0x5c, 0x9c, 0xc4, 0x9f, 0xcd, 0x27, 0xb1, 0x70, 0xbc, 0x5b, 0x70, 0x2f, 0x45, 0xed, 0x91, 0xce,
+	0xe3, 0xdf, 0x0d, 0x70, 0x0e, 0xe3, 0xb1, 0x56, 0x3d, 0xe9, 0xae, 0x5a, 0x47, 0x9f, 0x40, 0x45,
+	0x96, 0x70, 0xad, 0x4d, 0xa4, 0x4c, 0xd0, 0x47, 0x50, 0x26, 0x34, 0x5c, 0x6b, 0x01, 0x09, 0x03,
+	0xf7, 0x0c, 0x6a, 0x59, 0xce, 0x27, 0xdd, 0xfc, 0x60, 0xb5, 0xd2, 0x30, 0xd3, 0xe7, 0x52, 0xf4,
+	0xda, 0xf3, 0xa9, 0xf9, 0xa6, 0x4e, 0x84, 0xed, 0xff, 0x57, 0x06, 0x5b, 0xa2, 0x3e, 0xc1, 0x21,
+	0x49, 0xd0, 0x6b, 0xb0, 0xb2, 0x15, 0x87, 0x1e, 0xaf, 0x58, 0x66, 0x69, 0xd9, 0x1b, 0x6d, 0x6f,
+	0x61, 0xe7, 0xab, 0x4c, 0x3c, 0xb5, 0xea, 0x27, 0x7b, 0xaa, 0xe4, 0xac, 0x8b, 0x39, 0x76, 0x4b,
+	0x1f, 0x1a, 0xe8, 0x35, 0xd8, 0xb9, 0xfd, 0x86, 0x9e, 0x14, 0x7b, 0x58, 0xda, 0x8a, 0x8d, 0x0f,
+	0xae, 0xa3, 0xa9, 0x5a, 0xb8, 0x25, 0x14, 0xc2, 0x9d, 0x85, 0xfd, 0x83, 0x76, 0x8b, 0x4d, 0xaf,
+	0xac, 0xcb, 0x46, 0xfb, 0x7a, 0x62, 0xe6, 0xe5, 0x27, 0x80, 0x79, 0xff, 0xa1, 0xf7, 0x8b, 0xca,
+	0xbd, 0xdc, 0x9e, 0x6b, 0xd6, 0x29, 0x00, 0x27, 0x7f, 0xdb, 0x37, 0xf4, 0xb1, 0xbb, 0x8a, 0x95,
+	0x6b, 0x1a, 0xb7, 0x74, 0xf0, 0xe0, 0xe2, 0x72, 0xdb, 0xf8, 0xf3, 0x72, 0xdb, 0xf8, 0xe7, 0x72,
+	0xdb, 0xf8, 0xb1, 0xaa, 0x0d, 0x7a, 0x1b, 0x32, 0xac, 0xa7, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff,
+	0xba, 0xc1, 0x9f, 0xcf, 0x48, 0x0a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1262,3 +1403,3078 @@ var _TraceReader_serviceDesc = grpc.ServiceDesc{
 	},
 	Metadata: "trace_storage.proto",
 }
+
+func (m *GetTraceParams) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetTraceParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetTraceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	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
+	}
+	i -= n1
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n1))
+	i--
+	dAtA[i] = 0x1a
+	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):])
+	if err2 != nil {
+		return 0, err2
+	}
+	i -= n2
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n2))
+	i--
+	dAtA[i] = 0x12
+	if len(m.TraceId) > 0 {
+		i -= len(m.TraceId)
+		copy(dAtA[i:], m.TraceId)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.TraceId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *GetTracesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetTracesRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetTracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Query) > 0 {
+		for iNdEx := len(m.Query) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Query[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *GetServicesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetServicesRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetServicesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *GetServicesResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetServicesResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetServicesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Services) > 0 {
+		for iNdEx := len(m.Services) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Services[iNdEx])
+			copy(dAtA[i:], m.Services[iNdEx])
+			i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.Services[iNdEx])))
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *GetOperationsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetOperationsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetOperationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.SpanKind) > 0 {
+		i -= len(m.SpanKind)
+		copy(dAtA[i:], m.SpanKind)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.SpanKind)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Service) > 0 {
+		i -= len(m.Service)
+		copy(dAtA[i:], m.Service)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.Service)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Operation) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Operation) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Operation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.SpanKind) > 0 {
+		i -= len(m.SpanKind)
+		copy(dAtA[i:], m.SpanKind)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.SpanKind)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.Name)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *GetOperationsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *GetOperationsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GetOperationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Operations) > 0 {
+		for iNdEx := len(m.Operations) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Operations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *KeyValue) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Value != nil {
+		{
+			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Key) > 0 {
+		i -= len(m.Key)
+		copy(dAtA[i:], m.Key)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.Key)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *AnyValue) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AnyValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Value != nil {
+		{
+			size := m.Value.Size()
+			i -= size
+			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *AnyValue_StringValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i -= len(m.StringValue)
+	copy(dAtA[i:], m.StringValue)
+	i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.StringValue)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_BoolValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i--
+	if m.BoolValue {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i--
+	dAtA[i] = 0x10
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_IntValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_IntValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i = encodeVarintTraceStorage(dAtA, i, uint64(m.IntValue))
+	i--
+	dAtA[i] = 0x18
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_DoubleValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_DoubleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	i -= 8
+	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.DoubleValue))))
+	i--
+	dAtA[i] = 0x21
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_ArrayValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.ArrayValue != nil {
+		{
+			size, err := m.ArrayValue.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_KvlistValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_KvlistValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.KvlistValue != nil {
+		{
+			size, err := m.KvlistValue.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x32
+	}
+	return len(dAtA) - i, nil
+}
+func (m *AnyValue_BytesValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AnyValue_BytesValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.BytesValue != nil {
+		i -= len(m.BytesValue)
+		copy(dAtA[i:], m.BytesValue)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.BytesValue)))
+		i--
+		dAtA[i] = 0x3a
+	}
+	return len(dAtA) - i, nil
+}
+func (m *KeyValueList) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *KeyValueList) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *KeyValueList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Values) > 0 {
+		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ArrayValue) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ArrayValue) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ArrayValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Values) > 0 {
+		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *TraceQueryParameters) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TraceQueryParameters) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TraceQueryParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.SearchDepth != 0 {
+		i = encodeVarintTraceStorage(dAtA, i, uint64(m.SearchDepth))
+		i--
+		dAtA[i] = 0x40
+	}
+	n6, err6 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax):])
+	if err6 != nil {
+		return 0, err6
+	}
+	i -= n6
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n6))
+	i--
+	dAtA[i] = 0x3a
+	n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.DurationMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin):])
+	if err7 != nil {
+		return 0, err7
+	}
+	i -= n7
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n7))
+	i--
+	dAtA[i] = 0x32
+	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMax, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax):])
+	if err8 != nil {
+		return 0, err8
+	}
+	i -= n8
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n8))
+	i--
+	dAtA[i] = 0x2a
+	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTimeMin, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin):])
+	if err9 != nil {
+		return 0, err9
+	}
+	i -= n9
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n9))
+	i--
+	dAtA[i] = 0x22
+	if len(m.Attributes) > 0 {
+		for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.OperationName) > 0 {
+		i -= len(m.OperationName)
+		copy(dAtA[i:], m.OperationName)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.OperationName)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.ServiceName) > 0 {
+		i -= len(m.ServiceName)
+		copy(dAtA[i:], m.ServiceName)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.ServiceName)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FindTracesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FindTracesRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FindTracesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if m.Query != nil {
+		{
+			size, err := m.Query.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FoundTraceID) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FoundTraceID) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FoundTraceID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
+	if err11 != nil {
+		return 0, err11
+	}
+	i -= n11
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n11))
+	i--
+	dAtA[i] = 0x1a
+	n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
+	if err12 != nil {
+		return 0, err12
+	}
+	i -= n12
+	i = encodeVarintTraceStorage(dAtA, i, uint64(n12))
+	i--
+	dAtA[i] = 0x12
+	if len(m.TraceId) > 0 {
+		i -= len(m.TraceId)
+		copy(dAtA[i:], m.TraceId)
+		i = encodeVarintTraceStorage(dAtA, i, uint64(len(m.TraceId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FindTraceIDsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FindTraceIDsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FindTraceIDsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.TraceIds) > 0 {
+		for iNdEx := len(m.TraceIds) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.TraceIds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTraceStorage(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintTraceStorage(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTraceStorage(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *GetTraceParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.TraceId)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *GetTracesRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Query) > 0 {
+		for _, e := range m.Query {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *GetServicesRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *GetServicesResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Services) > 0 {
+		for _, s := range m.Services {
+			l = len(s)
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *GetOperationsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Service)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	l = len(m.SpanKind)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Operation) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	l = len(m.SpanKind)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *GetOperationsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Operations) > 0 {
+		for _, e := range m.Operations {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *KeyValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if m.Value != nil {
+		l = m.Value.Size()
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *AnyValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Value != nil {
+		n += m.Value.Size()
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *AnyValue_StringValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.StringValue)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	return n
+}
+func (m *AnyValue_BoolValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 2
+	return n
+}
+func (m *AnyValue_IntValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovTraceStorage(uint64(m.IntValue))
+	return n
+}
+func (m *AnyValue_DoubleValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 9
+	return n
+}
+func (m *AnyValue_ArrayValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ArrayValue != nil {
+		l = m.ArrayValue.Size()
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	return n
+}
+func (m *AnyValue_KvlistValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.KvlistValue != nil {
+		l = m.KvlistValue.Size()
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	return n
+}
+func (m *AnyValue_BytesValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BytesValue != nil {
+		l = len(m.BytesValue)
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	return n
+}
+func (m *KeyValueList) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Values) > 0 {
+		for _, e := range m.Values {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *ArrayValue) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Values) > 0 {
+		for _, e := range m.Values {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *TraceQueryParameters) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.ServiceName)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	l = len(m.OperationName)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if len(m.Attributes) > 0 {
+		for _, e := range m.Attributes {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMin)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTimeMax)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMin)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.DurationMax)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	if m.SearchDepth != 0 {
+		n += 1 + sovTraceStorage(uint64(m.SearchDepth))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *FindTracesRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Query != nil {
+		l = m.Query.Size()
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *FoundTraceID) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.TraceId)
+	if l > 0 {
+		n += 1 + l + sovTraceStorage(uint64(l))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Start)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.End)
+	n += 1 + l + sovTraceStorage(uint64(l))
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *FindTraceIDsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.TraceIds) > 0 {
+		for _, e := range m.TraceIds {
+			l = e.Size()
+			n += 1 + l + sovTraceStorage(uint64(l))
+		}
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovTraceStorage(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTraceStorage(x uint64) (n int) {
+	return sovTraceStorage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GetTraceParams) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetTraceParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetTraceParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
+			if m.TraceId == nil {
+				m.TraceId = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetTracesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetTracesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetTracesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Query = append(m.Query, &GetTraceParams{})
+			if err := m.Query[len(m.Query)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetServicesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetServicesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetServicesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetServicesResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetServicesResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetServicesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Services = append(m.Services, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetOperationsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetOperationsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetOperationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Service = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SpanKind = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Operation) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Operation: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SpanKind", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SpanKind = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetOperationsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetOperationsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetOperationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Operations = append(m.Operations, &Operation{})
+			if err := m.Operations[len(m.Operations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *KeyValue) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: KeyValue: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Value == nil {
+				m.Value = &AnyValue{}
+			}
+			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AnyValue) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AnyValue: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AnyValue: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = &AnyValue_StringValue{string(dAtA[iNdEx:postIndex])}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			b := bool(v != 0)
+			m.Value = &AnyValue_BoolValue{b}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Value = &AnyValue_IntValue{v}
+		case 4:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DoubleValue", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.Value = &AnyValue_DoubleValue{float64(math.Float64frombits(v))}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ArrayValue", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &ArrayValue{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Value = &AnyValue_ArrayValue{v}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field KvlistValue", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &KeyValueList{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Value = &AnyValue_KvlistValue{v}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BytesValue", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := make([]byte, postIndex-iNdEx)
+			copy(v, dAtA[iNdEx:postIndex])
+			m.Value = &AnyValue_BytesValue{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *KeyValueList) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: KeyValueList: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: KeyValueList: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Values = append(m.Values, &KeyValue{})
+			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ArrayValue) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ArrayValue: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ArrayValue: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Values = append(m.Values, &AnyValue{})
+			if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TraceQueryParameters) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TraceQueryParameters: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TraceQueryParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ServiceName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field OperationName", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.OperationName = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Attributes = append(m.Attributes, &KeyValue{})
+			if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMin", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMin, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeMax", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTimeMax, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DurationMin", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMin, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DurationMax", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.DurationMax, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SearchDepth", wireType)
+			}
+			m.SearchDepth = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SearchDepth |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FindTracesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FindTracesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FindTracesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Query == nil {
+				m.Query = &TraceQueryParameters{}
+			}
+			if err := m.Query.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FoundTraceID) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FoundTraceID: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FoundTraceID: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
+			if m.TraceId == nil {
+				m.TraceId = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Start, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.End, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FindTraceIDsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FindTraceIDsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FindTraceIDsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TraceIds", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TraceIds = append(m.TraceIds, &FoundTraceID{})
+			if err := m.TraceIds[len(m.TraceIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTraceStorage(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTraceStorage
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTraceStorage(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTraceStorage
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTraceStorage
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthTraceStorage
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupTraceStorage
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthTraceStorage
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthTraceStorage        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTraceStorage          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupTraceStorage = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/scripts/makefiles/Protobuf.mk b/scripts/makefiles/Protobuf.mk
index 6acf2ae1d..1e785d73f 100644
--- a/scripts/makefiles/Protobuf.mk
+++ b/scripts/makefiles/Protobuf.mk
@@ -109,10 +109,29 @@ proto-storage-v1:
 		--go_out=$(PWD)/internal/storage/v1/grpc/proto/ \
 		internal/storage/v1/grpc/proto/storage_test.proto
 
+STORAGE_V2_PATH=proto-gen/storage/v2
+STORAGE_V2_PATCHED_DIR=proto-gen/.patched/storage_v2
+STORAGE_V2_PATCHED_TRACE=$(STORAGE_V2_PATCHED_DIR)/trace_storage.proto
+STORAGE_V2_PATCHED_DEPENDENCY=$(STORAGE_V2_PATCHED_DIR)/dependency_storage.proto
+
+.PHONY: patch-storage-v2
+patch-storage-v2:
+	mkdir -p $(STORAGE_V2_PATCHED_DIR)
+	cat internal/storage/v2/grpc/trace_storage.proto | \
+		$(SED) -f ./proto-gen/patch.sed \
+		> $(STORAGE_V2_PATCHED_TRACE)
+	cat internal/storage/v2/grpc/dependency_storage.proto | \
+		$(SED) -f ./proto-gen/patch.sed \
+		> $(STORAGE_V2_PATCHED_DEPENDENCY)
+
 .PHONY: proto-storage-v2
-proto-storage-v2:
-	$(call proto_compile, proto-gen/storage/v2, internal/storage/v2/grpc/trace_storage.proto, -Iinternal/storage/v2/grpc/)
-	$(call proto_compile, proto-gen/storage/v2, internal/storage/v2/grpc/dependency_storage.proto, -Iinternal/storage/v2/grpc/)
+proto-storage-v2: patch-storage-v2
+	$(call proto_compile, $(STORAGE_V2_PATH), $(STORAGE_V2_PATCHED_TRACE), -I$(STORAGE_V2_PATCHED_DIR) -Iinternal/storage/v2/grpc/)
+	$(call proto_compile, $(STORAGE_V2_PATH), $(STORAGE_V2_PATCHED_DEPENDENCY), -I$(STORAGE_V2_PATCHED_DIR) -Iinternal/storage/v2/grpc/)
+	@echo "🏗️  replace first instance of OTEL import with internal type"
+	$(SED) -i '0,/go.opentelemetry.io\/proto\/otlp\/trace\/v1/s|go.opentelemetry.io/proto/otlp/trace/v1|github.com/jaegertracing/jaeger/internal/jptrace|' $(STORAGE_V2_PATH)/*.pb.go
+	@echo "🏗️  remove all remaining OTEL imports because we're not using any other OTLP types"
+	$(SED) -i 's+^.*v1 "go.opentelemetry.io/proto/otlp/trace/v1".*$$++' $(STORAGE_V2_PATH)/*.pb.go
 
 .PHONY: proto-hotrod
 proto-hotrod:
@@ -135,7 +154,7 @@ API_V3_PATCHED=$(API_V3_PATCHED_DIR)/query_service.proto
 patch-api-v3:
 	mkdir -p $(API_V3_PATCHED_DIR)
 	cat idl/proto/api_v3/query_service.proto | \
-		$(SED) -f ./proto-gen/patch-api-v3.sed \
+		$(SED) -f ./proto-gen/patch.sed \
 		> $(API_V3_PATCHED)
 
 .PHONY: proto-api-v3



Test patch:
diff --git a/cmd/es-index-cleaner/app/cutoff_time_test.go b/cmd/es-index-cleaner/app/cutoff_time_test.go
new file mode 100644
index 000000000..927cc8e11
--- /dev/null
+++ b/cmd/es-index-cleaner/app/cutoff_time_test.go
@@ -0,0 +1,72 @@
+// Copyright (c) 2025 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package app
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCalculateDeletionCutoff(t *testing.T) {
+	time20250309163053 := time.Date(2025, time.March, 9, 16, 30, 53, 0, time.UTC)
+	tests := []struct {
+		name                 string
+		currTime             time.Time
+		numOfDays            int
+		relativeIndexEnabled bool
+		expectedCutoff       time.Time
+	}{
+		{
+			name:                 "get today's midnight",
+			currTime:             time20250309163053,
+			numOfDays:            1,
+			relativeIndexEnabled: false,
+			expectedCutoff:       time.Date(2025, time.March, 9, 0, 0, 0, 0, time.UTC),
+		},
+		{
+			name:                 "get exactly 24 hours before execution time",
+			currTime:             time20250309163053,
+			numOfDays:            1,
+			relativeIndexEnabled: true,
+			expectedCutoff:       time.Date(2025, time.March, 8, 16, 30, 53, 0, time.UTC),
+		},
+		{
+			name:                 "get the current time if numOfDays is 0 and relativeIndexEnabled is true",
+			currTime:             time20250309163053,
+			numOfDays:            0,
+			relativeIndexEnabled: true,
+			expectedCutoff:       time20250309163053,
+		},
+		{
+			name:                 "get tomorrow's midnight if numOfDays is 0  relativeIndexEnabled is False",
+			currTime:             time20250309163053,
+			numOfDays:            0,
+			relativeIndexEnabled: false,
+			expectedCutoff:       time.Date(2025, time.March, 10, 0, 0, 0, 0, time.UTC),
+		},
+		{
+			name:                 "get (numOfDays-1)'s midnight",
+			currTime:             time20250309163053,
+			numOfDays:            3,
+			relativeIndexEnabled: false,
+			expectedCutoff:       time.Date(2025, time.March, 7, 0, 0, 0, 0, time.UTC),
+		},
+		{
+			name:                 "get exactly (24*numOfDays) hours before execution time",
+			currTime:             time20250309163053,
+			numOfDays:            3,
+			relativeIndexEnabled: true,
+			expectedCutoff:       time.Date(2025, time.March, 6, 16, 30, 53, 0, time.UTC),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cutoffTime := CalculateDeletionCutoff(time20250309163053, test.numOfDays, test.relativeIndexEnabled)
+			assert.Equal(t, test.expectedCutoff, cutoffTime)
+		})
+	}
+}