diff --git a/Makefile b/Makefile
index 042d97a848a..ef86fa255fa 100644
--- a/Makefile
+++ b/Makefile
@@ -240,7 +240,7 @@ images: ## Print all image names.
 	@echo > /dev/null
 
 # Generating proto code is automated.
-PROTO_DEFS := $(shell find . $(DONT_FIND) -type f -name '*.proto' -print)
+PROTO_DEFS := $(shell find . $(DONT_FIND) -type f -name '*_custom_types.proto' -prune -o -name '*.proto' -print)
 PROTO_GOS := $(patsubst %.proto,%.pb.go,$(PROTO_DEFS))
 
 # Generating OTLP translation code is automated.
@@ -324,7 +324,14 @@ GENERATE_FILES ?= true
 
 %.pb.go: %.proto
 ifeq ($(GENERATE_FILES),true)
-	protoc -I $(GOPATH)/src:./vendor/github.com/gogo/protobuf:./vendor:./$(@D):./pkg/storegateway/storepb --gogoslick_out=plugins=grpc,Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types,:./$(@D) ./$(patsubst %.pb.go,%.proto,$@)
+	if case "$@" in *_custom_types.pb.go) false ;; *) true ;; esac; then \
+		protoc \
+			-I ./vendor -I ./ -I ./vendor/github.com/gogo/protobuf \
+			--gogoslick_out=plugins=grpc,Mgoogle/protobuf/any.proto=github.com/gogo/protobuf/types:. \
+			./$(patsubst %.pb.go,%.proto,$@); \
+	else \
+		echo "Skipping $@"; \
+	fi
 else
 	@echo "Warning: generating files has been disabled, but the following file needs to be regenerated: $@"
 	@echo "If this is unexpected, check if the last modified timestamps on $@ and $(patsubst %.pb.go,%.proto,$@) are correct."
diff --git a/pkg/alertmanager/alertmanagerpb/alertmanager.pb.go b/pkg/alertmanager/alertmanagerpb/alertmanager.pb.go
index f3bb82fe59c..f220450f08f 100644
--- a/pkg/alertmanager/alertmanagerpb/alertmanager.pb.go
+++ b/pkg/alertmanager/alertmanagerpb/alertmanager.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: alertmanager.proto
+// source: pkg/alertmanager/alertmanagerpb/alertmanager.proto
 
 package alertmanagerpb
 
@@ -53,7 +53,7 @@ var UpdateStateStatus_value = map[string]int32{
 }
 
 func (UpdateStateStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_e60437b6e0c74c9a, []int{0}
+	return fileDescriptor_45f8028ac4adcdfb, []int{0}
 }
 
 type ReadStateStatus int32
@@ -80,7 +80,7 @@ var ReadStateStatus_value = map[string]int32{
 }
 
 func (ReadStateStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_e60437b6e0c74c9a, []int{1}
+	return fileDescriptor_45f8028ac4adcdfb, []int{1}
 }
 
 type UpdateStateResponse struct {
@@ -91,7 +91,7 @@ type UpdateStateResponse struct {
 func (m *UpdateStateResponse) Reset()      { *m = UpdateStateResponse{} }
 func (*UpdateStateResponse) ProtoMessage() {}
 func (*UpdateStateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e60437b6e0c74c9a, []int{0}
+	return fileDescriptor_45f8028ac4adcdfb, []int{0}
 }
 func (m *UpdateStateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -140,7 +140,7 @@ type ReadStateRequest struct {
 func (m *ReadStateRequest) Reset()      { *m = ReadStateRequest{} }
 func (*ReadStateRequest) ProtoMessage() {}
 func (*ReadStateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e60437b6e0c74c9a, []int{1}
+	return fileDescriptor_45f8028ac4adcdfb, []int{1}
 }
 func (m *ReadStateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -178,7 +178,7 @@ type ReadStateResponse struct {
 func (m *ReadStateResponse) Reset()      { *m = ReadStateResponse{} }
 func (*ReadStateResponse) ProtoMessage() {}
 func (*ReadStateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e60437b6e0c74c9a, []int{2}
+	return fileDescriptor_45f8028ac4adcdfb, []int{2}
 }
 func (m *ReadStateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -236,42 +236,44 @@ func init() {
 	proto.RegisterType((*ReadStateResponse)(nil), "alertmanagerpb.ReadStateResponse")
 }
 
-func init() { proto.RegisterFile("alertmanager.proto", fileDescriptor_e60437b6e0c74c9a) }
+func init() {
+	proto.RegisterFile("pkg/alertmanager/alertmanagerpb/alertmanager.proto", fileDescriptor_45f8028ac4adcdfb)
+}
 
-var fileDescriptor_e60437b6e0c74c9a = []byte{
-	// 505 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_45f8028ac4adcdfb = []byte{
+	// 512 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4f, 0x6f, 0x12, 0x41,
-	0x1c, 0x9d, 0x69, 0x2d, 0xa6, 0x3f, 0x14, 0xb6, 0x53, 0x54, 0xc2, 0x61, 0x4a, 0xf1, 0x42, 0x38,
-	0xec, 0x1a, 0x3c, 0x18, 0x3d, 0xb5, 0x95, 0xc5, 0x36, 0x8d, 0x40, 0x06, 0xb8, 0x98, 0x18, 0x32,
-	0xc0, 0x74, 0x69, 0x04, 0x76, 0x9d, 0x9d, 0xbd, 0xfb, 0x11, 0x3c, 0xf8, 0x01, 0x3c, 0xfa, 0x51,
-	0x3c, 0x72, 0xec, 0x51, 0x96, 0x4b, 0x13, 0x2f, 0xfd, 0x08, 0xa6, 0xfb, 0xcf, 0x75, 0x8d, 0x8d,
-	0xa7, 0xfd, 0xcd, 0x9b, 0xdf, 0x7b, 0x6f, 0x7e, 0x6f, 0x66, 0x81, 0xf0, 0xb9, 0x90, 0x6a, 0xc1,
-	0x97, 0xdc, 0x12, 0x52, 0x77, 0xa4, 0xad, 0x6c, 0x52, 0x48, 0x63, 0xce, 0xb8, 0x52, 0xb2, 0x6c,
-	0xcb, 0x0e, 0xb6, 0x8c, 0xdb, 0x2a, 0xec, 0xaa, 0x3c, 0xb3, 0x2e, 0xd5, 0xcc, 0x1b, 0xeb, 0x13,
-	0x7b, 0x61, 0x58, 0x92, 0x5f, 0xf0, 0x25, 0x37, 0xa6, 0xee, 0x87, 0x4b, 0x65, 0xcc, 0x94, 0x72,
-	0x2c, 0xe9, 0x4c, 0x92, 0x22, 0x62, 0x9c, 0xa4, 0x18, 0x8e, 0xb4, 0x17, 0x42, 0xcd, 0x84, 0xe7,
-	0x1a, 0x69, 0x37, 0x63, 0x32, 0xf7, 0x5c, 0xf5, 0xfb, 0xeb, 0x8c, 0xe3, 0x2a, 0xd4, 0xa8, 0x5d,
-	0xc0, 0xfe, 0xd0, 0x99, 0x72, 0x25, 0xfa, 0x8a, 0x2b, 0xc1, 0x84, 0xeb, 0xd8, 0x4b, 0x57, 0x90,
-	0x97, 0x90, 0x73, 0x15, 0x57, 0x9e, 0x5b, 0xc6, 0x55, 0x5c, 0x2f, 0x34, 0x0f, 0xf5, 0x3f, 0x67,
-	0xd0, 0x53, 0xa4, 0x7e, 0xd0, 0xc8, 0x22, 0x02, 0x29, 0xc1, 0x8e, 0x90, 0xd2, 0x96, 0xe5, 0xad,
-	0x2a, 0xae, 0xef, 0xb2, 0x70, 0x51, 0x23, 0xa0, 0x31, 0xc1, 0xa7, 0x91, 0xcb, 0x47, 0x4f, 0xb8,
-	0xaa, 0xf6, 0x05, 0xc3, 0x5e, 0x0a, 0x8c, 0xac, 0x5f, 0x64, 0xac, 0x0f, 0xb2, 0xd6, 0x09, 0xe5,
-	0x7f, 0x8c, 0x49, 0x03, 0x76, 0x6e, 0xf7, 0x45, 0x79, 0xbb, 0x8a, 0xeb, 0xf9, 0x66, 0x49, 0x4f,
-	0x92, 0xd0, 0xdb, 0xde, 0x7c, 0x1e, 0x7a, 0x87, 0x2d, 0xaf, 0xee, 0x5d, 0x7f, 0x3d, 0x40, 0x8d,
-	0x23, 0xd8, 0xfb, 0x6b, 0x3a, 0x92, 0x83, 0xad, 0xee, 0xb9, 0x86, 0x48, 0x11, 0xf2, 0x6f, 0x4d,
-	0xf6, 0xc6, 0x1c, 0x99, 0x8c, 0x75, 0x99, 0xb6, 0x45, 0x08, 0x14, 0x86, 0x7d, 0x93, 0x8d, 0x3a,
-	0xdd, 0xc1, 0xa8, 0xdd, 0x1d, 0x76, 0x5a, 0xda, 0x76, 0xe3, 0x3d, 0x14, 0x33, 0x87, 0x24, 0x25,
-	0xd0, 0x98, 0x79, 0xdc, 0x1a, 0x0d, 0x3b, 0xfd, 0x9e, 0xf9, 0xfa, 0xac, 0x7d, 0x66, 0xb6, 0x34,
-	0x44, 0xf2, 0x70, 0x3f, 0x40, 0xbb, 0xe7, 0x1a, 0x26, 0x05, 0x80, 0x60, 0x11, 0x2b, 0x3f, 0x81,
-	0xfd, 0x90, 0x92, 0x91, 0x6f, 0xfe, 0xc4, 0xf0, 0xe0, 0x38, 0x95, 0x09, 0x39, 0x82, 0x87, 0xa7,
-	0x7c, 0x39, 0x9d, 0xc7, 0xc9, 0x92, 0x47, 0x7a, 0xf2, 0x54, 0x4e, 0x07, 0x83, 0x5e, 0x04, 0x57,
-	0x1e, 0x67, 0xe1, 0x30, 0xf2, 0x1a, 0x22, 0x26, 0xe4, 0x53, 0x33, 0x93, 0x62, 0x2a, 0xa5, 0x1e,
-	0x97, 0xaa, 0xf2, 0xf4, 0x8e, 0xfb, 0x4f, 0xc9, 0x30, 0xd8, 0x4d, 0x06, 0x27, 0xd5, 0x7f, 0x5e,
-	0x5c, 0x7c, 0x9e, 0xc3, 0x3b, 0x3a, 0x62, 0xcd, 0x93, 0xd6, 0x6a, 0x4d, 0xd1, 0xd5, 0x9a, 0xa2,
-	0x9b, 0x35, 0xc5, 0x9f, 0x7c, 0x8a, 0xbf, 0xf9, 0x14, 0x7f, 0xf7, 0x29, 0x5e, 0xf9, 0x14, 0xff,
-	0xf0, 0x29, 0xbe, 0xf6, 0x29, 0xba, 0xf1, 0x29, 0xfe, 0xbc, 0xa1, 0x68, 0xb5, 0xa1, 0xe8, 0x6a,
-	0x43, 0xd1, 0xbb, 0xcc, 0x3f, 0x37, 0xce, 0x05, 0xcf, 0xfd, 0xf9, 0xaf, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0xd2, 0x51, 0xe3, 0x22, 0xa0, 0x03, 0x00, 0x00,
+	0x14, 0x9f, 0x69, 0x2d, 0xa6, 0x0f, 0x85, 0xed, 0x14, 0x95, 0x70, 0x98, 0x52, 0xbc, 0x10, 0x0e,
+	0x8b, 0xc1, 0x83, 0xd1, 0x53, 0x5b, 0x59, 0x6c, 0xd3, 0x08, 0x64, 0x80, 0x8b, 0x89, 0x21, 0x03,
+	0x4c, 0x97, 0xa6, 0xc0, 0xae, 0xb3, 0xb3, 0x77, 0x3f, 0x82, 0x07, 0x3f, 0x80, 0x47, 0x3f, 0x8a,
+	0x47, 0x8e, 0x3d, 0xca, 0x72, 0x69, 0xe2, 0xa5, 0x1f, 0xc1, 0x94, 0xfd, 0xe3, 0xee, 0x1a, 0x1b,
+	0x4f, 0xfb, 0xde, 0x9b, 0xf7, 0xfb, 0xfd, 0xde, 0xfb, 0xcd, 0x2c, 0x34, 0xec, 0x2b, 0xb3, 0xce,
+	0x67, 0x42, 0xaa, 0x39, 0x5f, 0x70, 0x53, 0xc8, 0x44, 0x62, 0x8f, 0x12, 0xa9, 0x6e, 0x4b, 0x4b,
+	0x59, 0x24, 0x97, 0x6c, 0x29, 0x15, 0x4c, 0xcb, 0xb4, 0x36, 0x47, 0xf5, 0xbb, 0xc8, 0xef, 0x2a,
+	0xbd, 0x30, 0x2f, 0xd5, 0xd4, 0x1d, 0xe9, 0x63, 0x6b, 0x5e, 0x37, 0x25, 0xbf, 0xe0, 0x0b, 0x5e,
+	0x9f, 0x38, 0x57, 0x97, 0xaa, 0x3e, 0x55, 0xca, 0x36, 0xa5, 0x3d, 0x8e, 0x82, 0x00, 0x71, 0x12,
+	0x43, 0xd8, 0xd2, 0x9a, 0x0b, 0x35, 0x15, 0xae, 0x93, 0x9c, 0x6e, 0x3c, 0x73, 0x1d, 0xf5, 0xe7,
+	0x6b, 0x8f, 0xc2, 0xc8, 0xe7, 0xa8, 0x5c, 0xc0, 0xfe, 0xc0, 0x9e, 0x70, 0x25, 0x7a, 0x8a, 0x2b,
+	0xc1, 0x84, 0x63, 0x5b, 0x0b, 0x47, 0x90, 0xd7, 0x90, 0x71, 0x14, 0x57, 0xae, 0x53, 0xc4, 0x65,
+	0x5c, 0xcd, 0x35, 0x0e, 0xf5, 0xe4, 0x0e, 0x7a, 0x0c, 0xd4, 0xdb, 0x34, 0xb2, 0x00, 0x40, 0x0a,
+	0xb0, 0x23, 0xa4, 0xb4, 0x64, 0x71, 0xab, 0x8c, 0xab, 0xbb, 0xcc, 0x4f, 0x2a, 0x04, 0x34, 0x26,
+	0xf8, 0x24, 0x50, 0xf9, 0xe4, 0x0a, 0x47, 0x55, 0xbe, 0x62, 0xd8, 0x8b, 0x15, 0x03, 0xe9, 0x57,
+	0x29, 0xe9, 0x83, 0xb4, 0x74, 0x04, 0xf9, 0x1f, 0x61, 0x52, 0x83, 0x9d, 0xbb, 0x73, 0x51, 0xdc,
+	0x2e, 0xe3, 0x6a, 0xb6, 0x51, 0xd0, 0x23, 0x27, 0xf4, 0x96, 0x3b, 0x9b, 0xf9, 0xda, 0x7e, 0xcb,
+	0x9b, 0x07, 0x37, 0xdf, 0x0e, 0x50, 0xed, 0x08, 0xf6, 0xfe, 0xda, 0x8e, 0x64, 0x60, 0xab, 0x73,
+	0xae, 0x21, 0x92, 0x87, 0xec, 0x7b, 0x83, 0xbd, 0x33, 0x86, 0x06, 0x63, 0x1d, 0xa6, 0x6d, 0x11,
+	0x02, 0xb9, 0x41, 0xcf, 0x60, 0xc3, 0x76, 0xa7, 0x3f, 0x6c, 0x75, 0x06, 0xed, 0xa6, 0xb6, 0x5d,
+	0xfb, 0x08, 0xf9, 0xd4, 0x90, 0xa4, 0x00, 0x1a, 0x33, 0x8e, 0x9b, 0xc3, 0x41, 0xbb, 0xd7, 0x35,
+	0xde, 0x9e, 0xb5, 0xce, 0x8c, 0xa6, 0x86, 0x48, 0x16, 0x1e, 0x6e, 0xaa, 0x9d, 0x73, 0x0d, 0x93,
+	0x1c, 0xc0, 0x26, 0x09, 0x99, 0x9f, 0xc1, 0xbe, 0x0f, 0x49, 0xd1, 0x37, 0x7e, 0x61, 0x78, 0x74,
+	0x1c, 0xf3, 0x84, 0x1c, 0xc1, 0xe3, 0x53, 0xbe, 0x98, 0xcc, 0x42, 0x67, 0xc9, 0x13, 0x3d, 0x7a,
+	0x2a, 0xa7, 0xfd, 0x7e, 0x37, 0x28, 0x97, 0x9e, 0xa6, 0xcb, 0xbe, 0xe5, 0x15, 0x44, 0x0c, 0xc8,
+	0xc6, 0x76, 0x26, 0xf9, 0x98, 0x4b, 0x5d, 0x2e, 0x55, 0xe9, 0xf9, 0x3d, 0xf7, 0x1f, 0xa3, 0x61,
+	0xb0, 0x1b, 0x2d, 0x4e, 0xca, 0xff, 0xbc, 0xb8, 0x70, 0x9e, 0xc3, 0x7b, 0x3a, 0x42, 0xce, 0x93,
+	0xe6, 0x72, 0x45, 0xd1, 0xf5, 0x8a, 0xa2, 0xdb, 0x15, 0xc5, 0x9f, 0x3d, 0x8a, 0xbf, 0x7b, 0x14,
+	0xff, 0xf0, 0x28, 0x5e, 0x7a, 0x14, 0xff, 0xf4, 0x28, 0xbe, 0xf1, 0x28, 0xba, 0xf5, 0x28, 0xfe,
+	0xb2, 0xa6, 0x68, 0xb9, 0xa6, 0xe8, 0x7a, 0x4d, 0xd1, 0x87, 0xd4, 0x3f, 0x37, 0xca, 0x6c, 0x9e,
+	0xfb, 0xcb, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x42, 0x3c, 0xe2, 0xc0, 0x03, 0x00, 0x00,
 }
 
 func (x UpdateStateStatus) String() string {
@@ -528,7 +530,7 @@ var _Alertmanager_serviceDesc = grpc.ServiceDesc{
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
-	Metadata: "alertmanager.proto",
+	Metadata: "pkg/alertmanager/alertmanagerpb/alertmanager.proto",
 }
 
 func (m *UpdateStateResponse) Marshal() (dAtA []byte, err error) {
diff --git a/pkg/alertmanager/alertmanagerpb/alertmanager.proto b/pkg/alertmanager/alertmanagerpb/alertmanager.proto
index 618fdca94f1..6b482f4419a 100644
--- a/pkg/alertmanager/alertmanagerpb/alertmanager.proto
+++ b/pkg/alertmanager/alertmanagerpb/alertmanager.proto
@@ -7,7 +7,6 @@ syntax = "proto3";
 
 package alertmanagerpb;
 import "gogoproto/gogo.proto";
-
 option go_package = "alertmanagerpb";
 
 import "github.com/grafana/dskit/httpgrpc/httpgrpc.proto";
diff --git a/pkg/alertmanager/alertspb/alerts.pb.go b/pkg/alertmanager/alertspb/alerts.pb.go
index 51179f21fff..8b273895b86 100644
--- a/pkg/alertmanager/alertspb/alerts.pb.go
+++ b/pkg/alertmanager/alertspb/alerts.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: alerts.proto
+// source: pkg/alertmanager/alertspb/alerts.proto
 
 package alertspb
 
@@ -36,7 +36,7 @@ type AlertConfigDesc struct {
 func (m *AlertConfigDesc) Reset()      { *m = AlertConfigDesc{} }
 func (*AlertConfigDesc) ProtoMessage() {}
 func (*AlertConfigDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_20493709c38b81dc, []int{0}
+	return fileDescriptor_304358a0ba7ca332, []int{0}
 }
 func (m *AlertConfigDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -94,7 +94,7 @@ type TemplateDesc struct {
 func (m *TemplateDesc) Reset()      { *m = TemplateDesc{} }
 func (*TemplateDesc) ProtoMessage() {}
 func (*TemplateDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_20493709c38b81dc, []int{1}
+	return fileDescriptor_304358a0ba7ca332, []int{1}
 }
 func (m *TemplateDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -144,7 +144,7 @@ type FullStateDesc struct {
 func (m *FullStateDesc) Reset()      { *m = FullStateDesc{} }
 func (*FullStateDesc) ProtoMessage() {}
 func (*FullStateDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_20493709c38b81dc, []int{2}
+	return fileDescriptor_304358a0ba7ca332, []int{2}
 }
 func (m *FullStateDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -194,7 +194,7 @@ type GrafanaAlertConfigDesc struct {
 func (m *GrafanaAlertConfigDesc) Reset()      { *m = GrafanaAlertConfigDesc{} }
 func (*GrafanaAlertConfigDesc) ProtoMessage() {}
 func (*GrafanaAlertConfigDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_20493709c38b81dc, []int{3}
+	return fileDescriptor_304358a0ba7ca332, []int{3}
 }
 func (m *GrafanaAlertConfigDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -287,42 +287,44 @@ func init() {
 	proto.RegisterMapType((map[string]string)(nil), "alerts.GrafanaAlertConfigDesc.StaticHeadersEntry")
 }
 
-func init() { proto.RegisterFile("alerts.proto", fileDescriptor_20493709c38b81dc) }
+func init() {
+	proto.RegisterFile("pkg/alertmanager/alertspb/alerts.proto", fileDescriptor_304358a0ba7ca332)
+}
 
-var fileDescriptor_20493709c38b81dc = []byte{
-	// 506 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x52, 0xbb, 0x6e, 0x13, 0x4d,
-	0x18, 0xdd, 0xc9, 0xae, 0x13, 0xfb, 0x8b, 0xf3, 0xff, 0xd1, 0xc8, 0x42, 0x2b, 0x4b, 0x0c, 0xc6,
-	0x95, 0x45, 0x61, 0x43, 0x68, 0x50, 0x8a, 0x08, 0x87, 0xab, 0x28, 0x37, 0x41, 0x42, 0x34, 0xd6,
-	0x78, 0xfd, 0xf9, 0x22, 0x66, 0x2f, 0x9a, 0x99, 0x25, 0x71, 0xc7, 0x23, 0x20, 0x9e, 0x80, 0x92,
-	0x47, 0xa1, 0x74, 0x99, 0x12, 0xaf, 0x9b, 0x94, 0x79, 0x04, 0x34, 0xb3, 0xbb, 0x4e, 0x24, 0x28,
-	0xa9, 0xf6, 0x9c, 0x39, 0xe7, 0xcc, 0x7c, 0x97, 0x85, 0x26, 0x17, 0x28, 0xb5, 0xea, 0xa7, 0x32,
-	0xd1, 0x09, 0xdd, 0x2d, 0x58, 0xbb, 0x35, 0x4b, 0x66, 0x89, 0x3d, 0x1a, 0x18, 0x54, 0xa8, 0xed,
-	0xd3, 0xd9, 0x42, 0xcf, 0xb3, 0x71, 0x3f, 0x4c, 0xa2, 0x41, 0x2a, 0x93, 0x08, 0xf5, 0x1c, 0x33,
-	0x35, 0xb0, 0x99, 0x88, 0xc7, 0x7c, 0x86, 0x72, 0x10, 0x8a, 0x4c, 0xe9, 0xdb, 0x6f, 0x3a, 0xae,
-	0x50, 0x71, 0x47, 0xf7, 0x12, 0xfe, 0x1f, 0x1a, 0xff, 0x8b, 0x24, 0x9e, 0x2e, 0x66, 0x2f, 0x51,
-	0x85, 0x94, 0x82, 0x97, 0x29, 0x94, 0x3e, 0xe9, 0x90, 0x5e, 0x23, 0xb0, 0x98, 0xde, 0x07, 0x90,
-	0xfc, 0x62, 0x14, 0x5a, 0x97, 0xbf, 0x63, 0x95, 0x86, 0xe4, 0x17, 0x45, 0x8c, 0x1e, 0x41, 0x43,
-	0x63, 0x94, 0x0a, 0xae, 0x51, 0xf9, 0x6e, 0xc7, 0xed, 0xed, 0x1f, 0xb5, 0xfa, 0x65, 0x27, 0xe7,
-	0xa5, 0x60, 0xee, 0x0e, 0x6e, 0x6d, 0xdd, 0x13, 0x68, 0xde, 0x95, 0x68, 0x1b, 0xea, 0xd3, 0x85,
-	0xc0, 0x98, 0x47, 0x58, 0x3e, 0xbd, 0xe5, 0xa6, 0xa4, 0x71, 0x32, 0x59, 0x96, 0x0f, 0x5b, 0xdc,
-	0x1d, 0xc2, 0xc1, 0xeb, 0x4c, 0x88, 0x33, 0x5d, 0x5d, 0xf0, 0x08, 0x6a, 0xca, 0x10, 0x9b, 0x36,
-	0x05, 0x6c, 0x7b, 0xee, 0x6f, 0x8d, 0x41, 0x61, 0x39, 0xf6, 0xae, 0xbf, 0x3f, 0x70, 0xba, 0xdf,
-	0x5c, 0xb8, 0xf7, 0x46, 0xf2, 0x29, 0x8f, 0xf9, 0x3f, 0x18, 0x02, 0x05, 0x6f, 0xce, 0xd5, 0xdc,
-	0xf7, 0x8a, 0x88, 0xc1, 0xf4, 0x31, 0xb4, 0x42, 0x89, 0x5c, 0xe3, 0x64, 0xc4, 0xf5, 0x48, 0x2f,
-	0x22, 0x54, 0x9a, 0x47, 0xa9, 0x5f, 0xeb, 0x90, 0x9e, 0x1b, 0xd0, 0x52, 0x1b, 0xea, 0xf3, 0x4a,
-	0xa1, 0x3e, 0xec, 0x4d, 0x70, 0xca, 0x33, 0xa1, 0xfd, 0xbd, 0x0e, 0xe9, 0xd5, 0x83, 0x8a, 0x9a,
-	0x01, 0x99, 0x2d, 0x27, 0x1a, 0x27, 0x7e, 0xdd, 0x4a, 0x5b, 0x4e, 0x1f, 0x42, 0x13, 0x2f, 0x35,
-	0xca, 0x98, 0x8b, 0x51, 0x26, 0x85, 0xdf, 0xb0, 0x35, 0xec, 0x57, 0x67, 0xef, 0xa5, 0xa0, 0x1f,
-	0xe0, 0x3f, 0xd3, 0xfb, 0x22, 0x1c, 0xcd, 0x91, 0x4f, 0x50, 0x2a, 0x1f, 0xec, 0xa2, 0x9e, 0x54,
-	0x8b, 0xfa, 0xfb, 0x24, 0xfa, 0x67, 0x36, 0xf4, 0xb6, 0xc8, 0xbc, 0x8a, 0xb5, 0x5c, 0x06, 0x07,
-	0xea, 0xee, 0x59, 0xfb, 0x39, 0xd0, 0x3f, 0x4d, 0xf4, 0x10, 0xdc, 0x4f, 0xb8, 0x2c, 0x07, 0x68,
-	0x20, 0x6d, 0x41, 0xed, 0x33, 0x17, 0x19, 0x96, 0xa3, 0x2b, 0xc8, 0xf1, 0xce, 0x33, 0x52, 0xac,
-	0xe3, 0x9d, 0x57, 0x77, 0x0f, 0xbd, 0xd3, 0x93, 0xd5, 0x9a, 0x39, 0x57, 0x6b, 0xe6, 0xdc, 0xac,
-	0x19, 0xf9, 0x92, 0x33, 0xf2, 0x23, 0x67, 0xe4, 0x67, 0xce, 0xc8, 0x2a, 0x67, 0xe4, 0x57, 0xce,
-	0xc8, 0x75, 0xce, 0x9c, 0x9b, 0x9c, 0x91, 0xaf, 0x1b, 0xe6, 0xac, 0x36, 0xcc, 0xb9, 0xda, 0x30,
-	0xe7, 0x63, 0xbd, 0x68, 0x22, 0x1d, 0x8f, 0x77, 0xed, 0x8f, 0xfd, 0xf4, 0x77, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x87, 0x3a, 0xd2, 0x37, 0x4a, 0x03, 0x00, 0x00,
+var fileDescriptor_304358a0ba7ca332 = []byte{
+	// 512 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x53, 0xbb, 0x6e, 0x13, 0x41,
+	0x14, 0xdd, 0xc9, 0x6e, 0x12, 0x7b, 0x92, 0x40, 0x34, 0xb2, 0xd0, 0xca, 0x12, 0x83, 0x71, 0x81,
+	0x2c, 0x0a, 0x1b, 0x42, 0x83, 0x52, 0x44, 0x38, 0x3c, 0x45, 0xb9, 0x09, 0x12, 0xa2, 0xb1, 0xc6,
+	0xeb, 0xeb, 0xf5, 0x2a, 0xb3, 0x0f, 0xcd, 0xcc, 0x92, 0xb8, 0xe3, 0x13, 0x10, 0x5f, 0x40, 0xc9,
+	0xa7, 0x50, 0xba, 0x4c, 0x89, 0xd7, 0x4d, 0xca, 0x7c, 0x02, 0x9a, 0x99, 0x5d, 0x27, 0x08, 0x4a,
+	0x2a, 0x9f, 0x73, 0xcf, 0xb9, 0x77, 0xee, 0xc3, 0x8b, 0x1f, 0xe5, 0x67, 0xd1, 0x80, 0x71, 0x10,
+	0x2a, 0x61, 0x29, 0x8b, 0x40, 0x58, 0x22, 0xf3, 0x71, 0x05, 0xfa, 0xb9, 0xc8, 0x54, 0x46, 0xb6,
+	0x2c, 0x6b, 0xb7, 0xa2, 0x2c, 0xca, 0x4c, 0x68, 0xa0, 0x91, 0x55, 0xdb, 0xc7, 0x51, 0xac, 0x66,
+	0xc5, 0xb8, 0x1f, 0x66, 0xc9, 0x20, 0x17, 0x59, 0x02, 0x6a, 0x06, 0x85, 0xfc, 0xb3, 0x6e, 0xc8,
+	0x0b, 0xa9, 0x6e, 0x7e, 0xf3, 0x71, 0x8d, 0x6c, 0x8d, 0xee, 0x05, 0xbe, 0x3b, 0xd4, 0xfe, 0x97,
+	0x59, 0x3a, 0x8d, 0xa3, 0x57, 0x20, 0x43, 0x42, 0xb0, 0x57, 0x48, 0x10, 0x3e, 0xea, 0xa0, 0x5e,
+	0x33, 0x30, 0x98, 0xdc, 0xc7, 0x58, 0xb0, 0xf3, 0x51, 0x68, 0x5c, 0xfe, 0x86, 0x51, 0x9a, 0x82,
+	0x9d, 0xdb, 0x34, 0x72, 0x80, 0x9b, 0x0a, 0x92, 0x9c, 0x33, 0x05, 0xd2, 0x77, 0x3b, 0x6e, 0x6f,
+	0xe7, 0xa0, 0xd5, 0xaf, 0x26, 0x39, 0xad, 0x04, 0x5d, 0x3b, 0xb8, 0xb1, 0x75, 0x8f, 0xf0, 0xee,
+	0x6d, 0x89, 0xb4, 0x71, 0x63, 0x1a, 0x73, 0x48, 0x59, 0x02, 0xd5, 0xd3, 0x6b, 0xae, 0x5b, 0x1a,
+	0x67, 0x93, 0x79, 0xf5, 0xb0, 0xc1, 0xdd, 0x21, 0xde, 0x7b, 0x53, 0x70, 0x7e, 0xa2, 0xea, 0x02,
+	0x8f, 0xf1, 0xa6, 0xd4, 0xc4, 0x64, 0xeb, 0x06, 0xd6, 0x33, 0xf7, 0xd7, 0xc6, 0xc0, 0x5a, 0x0e,
+	0xbd, 0xab, 0xef, 0x0f, 0x9c, 0xee, 0x37, 0x17, 0xdf, 0x7b, 0x2b, 0xd8, 0x94, 0xa5, 0xec, 0x3f,
+	0x2c, 0x81, 0x60, 0x6f, 0xc6, 0xe4, 0xcc, 0xf7, 0x6c, 0x8a, 0xc6, 0xe4, 0x09, 0x6e, 0x85, 0x02,
+	0x98, 0x82, 0xc9, 0x88, 0xa9, 0x91, 0x8a, 0x13, 0x90, 0x8a, 0x25, 0xb9, 0xbf, 0xd9, 0x41, 0x3d,
+	0x37, 0x20, 0x95, 0x36, 0x54, 0xa7, 0xb5, 0x42, 0x7c, 0xbc, 0x3d, 0x81, 0x29, 0x2b, 0xb8, 0xf2,
+	0xb7, 0x3b, 0xa8, 0xd7, 0x08, 0x6a, 0xaa, 0x17, 0xa4, 0xaf, 0x9c, 0x29, 0x98, 0xf8, 0x0d, 0x23,
+	0xad, 0x39, 0x79, 0x88, 0x77, 0xe1, 0x42, 0x81, 0x48, 0x19, 0x1f, 0x15, 0x82, 0xfb, 0x4d, 0xd3,
+	0xc3, 0x4e, 0x1d, 0xfb, 0x20, 0x38, 0xf9, 0x88, 0xef, 0xe8, 0xd9, 0xe3, 0x70, 0x34, 0x03, 0x36,
+	0x01, 0x21, 0x7d, 0x6c, 0x0e, 0xf5, 0xb4, 0x3e, 0xd4, 0xbf, 0x37, 0xd1, 0x3f, 0x31, 0x49, 0xef,
+	0x6c, 0xce, 0xeb, 0x54, 0x89, 0x79, 0xb0, 0x27, 0x6f, 0xc7, 0xda, 0x2f, 0x30, 0xf9, 0xdb, 0x44,
+	0xf6, 0xb1, 0x7b, 0x06, 0xf3, 0x6a, 0x81, 0x1a, 0x92, 0x16, 0xde, 0xfc, 0xcc, 0x78, 0x01, 0xd5,
+	0xea, 0x2c, 0x39, 0xdc, 0x78, 0x8e, 0xec, 0x39, 0xde, 0x7b, 0x0d, 0x77, 0xdf, 0x3b, 0x3e, 0x5a,
+	0x2c, 0xa9, 0x73, 0xb9, 0xa4, 0xce, 0xf5, 0x92, 0xa2, 0x2f, 0x25, 0x45, 0x3f, 0x4a, 0x8a, 0x7e,
+	0x96, 0x14, 0x2d, 0x4a, 0x8a, 0x7e, 0x95, 0x14, 0x5d, 0x95, 0xd4, 0xb9, 0x2e, 0x29, 0xfa, 0xba,
+	0xa2, 0xce, 0x62, 0x45, 0x9d, 0xcb, 0x15, 0x75, 0x3e, 0x35, 0xea, 0x0f, 0x68, 0xbc, 0x65, 0xfe,
+	0xd8, 0xcf, 0x7e, 0x07, 0x00, 0x00, 0xff, 0xff, 0x1a, 0x5a, 0xc4, 0xef, 0x64, 0x03, 0x00, 0x00,
 }
 
 func (this *AlertConfigDesc) Equal(that interface{}) bool {
diff --git a/pkg/blockbuilder/schedulerpb/scheduler.pb.go b/pkg/blockbuilder/schedulerpb/scheduler.pb.go
index c613fb27bae..85b089d8b28 100644
--- a/pkg/blockbuilder/schedulerpb/scheduler.pb.go
+++ b/pkg/blockbuilder/schedulerpb/scheduler.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: scheduler.proto
+// source: pkg/blockbuilder/schedulerpb/scheduler.proto
 
 package schedulerpb
 
@@ -41,7 +41,7 @@ type JobKey struct {
 func (m *JobKey) Reset()      { *m = JobKey{} }
 func (*JobKey) ProtoMessage() {}
 func (*JobKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{0}
+	return fileDescriptor_f07d57b63f6c1662, []int{0}
 }
 func (m *JobKey) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -97,7 +97,7 @@ type JobSpec struct {
 func (m *JobSpec) Reset()      { *m = JobSpec{} }
 func (*JobSpec) ProtoMessage() {}
 func (*JobSpec) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{1}
+	return fileDescriptor_f07d57b63f6c1662, []int{1}
 }
 func (m *JobSpec) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -182,7 +182,7 @@ type AssignJobRequest struct {
 func (m *AssignJobRequest) Reset()      { *m = AssignJobRequest{} }
 func (*AssignJobRequest) ProtoMessage() {}
 func (*AssignJobRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{2}
+	return fileDescriptor_f07d57b63f6c1662, []int{2}
 }
 func (m *AssignJobRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -226,7 +226,7 @@ type AssignJobResponse struct {
 func (m *AssignJobResponse) Reset()      { *m = AssignJobResponse{} }
 func (*AssignJobResponse) ProtoMessage() {}
 func (*AssignJobResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{3}
+	return fileDescriptor_f07d57b63f6c1662, []int{3}
 }
 func (m *AssignJobResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -279,7 +279,7 @@ type UpdateJobRequest struct {
 func (m *UpdateJobRequest) Reset()      { *m = UpdateJobRequest{} }
 func (*UpdateJobRequest) ProtoMessage() {}
 func (*UpdateJobRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{4}
+	return fileDescriptor_f07d57b63f6c1662, []int{4}
 }
 func (m *UpdateJobRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -342,7 +342,7 @@ type UpdateJobResponse struct {
 func (m *UpdateJobResponse) Reset()      { *m = UpdateJobResponse{} }
 func (*UpdateJobResponse) ProtoMessage() {}
 func (*UpdateJobResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{5}
+	return fileDescriptor_f07d57b63f6c1662, []int{5}
 }
 func (m *UpdateJobResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -380,44 +380,47 @@ func init() {
 	proto.RegisterType((*UpdateJobResponse)(nil), "schedulerpb.UpdateJobResponse")
 }
 
-func init() { proto.RegisterFile("scheduler.proto", fileDescriptor_2b3fc28395a6d9c5) }
-
-var fileDescriptor_2b3fc28395a6d9c5 = []byte{
-	// 530 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0xf5, 0x26, 0x4d, 0x1a, 0x8f, 0x51, 0x69, 0xb7, 0x41, 0xb2, 0x02, 0xdd, 0x04, 0x4b, 0xa0,
-	0x9c, 0x1c, 0x29, 0xf0, 0x03, 0x44, 0x02, 0x89, 0x80, 0x84, 0xe4, 0x84, 0x73, 0x15, 0xdb, 0x93,
-	0xd4, 0x8a, 0xe3, 0x35, 0xde, 0x8d, 0x50, 0x6f, 0x7c, 0x42, 0x3f, 0x80, 0x0f, 0xe0, 0xc6, 0x17,
-	0x70, 0xef, 0x31, 0xc7, 0x9e, 0x80, 0x38, 0x17, 0x8e, 0xfd, 0x04, 0x94, 0x75, 0x62, 0x12, 0x23,
-	0x04, 0xdc, 0x76, 0xde, 0xbc, 0x99, 0x79, 0xf3, 0x66, 0xe1, 0xae, 0xf0, 0x2e, 0xd0, 0x9f, 0x87,
-	0x98, 0xd8, 0x71, 0xc2, 0x25, 0xa7, 0x46, 0x0e, 0xc4, 0x6e, 0xa3, 0x3e, 0xe1, 0x13, 0xae, 0xf0,
-	0xce, 0xfa, 0x95, 0x51, 0x1a, 0xcd, 0x09, 0xe7, 0x93, 0x10, 0x3b, 0x2a, 0x72, 0xe7, 0xe3, 0x8e,
-	0x0c, 0x66, 0x28, 0xe4, 0x68, 0x16, 0x67, 0x04, 0xcb, 0x86, 0x6a, 0x9f, 0xbb, 0xaf, 0xf0, 0x92,
-	0x1e, 0x41, 0x29, 0xf0, 0x4d, 0xd2, 0x22, 0x6d, 0xdd, 0x29, 0x05, 0x3e, 0xad, 0x43, 0x05, 0x63,
-	0xee, 0x5d, 0x98, 0xa5, 0x16, 0x69, 0x97, 0x9d, 0x2c, 0xb0, 0xbe, 0x94, 0xe0, 0xb0, 0xcf, 0xdd,
-	0x41, 0x8c, 0xde, 0x9a, 0x21, 0x79, 0x1c, 0x78, 0x9b, 0xa2, 0x2c, 0xa0, 0x0f, 0x40, 0x8f, 0x47,
-	0x89, 0x0c, 0x64, 0xc0, 0x23, 0x55, 0x5b, 0x71, 0x7e, 0x01, 0xf4, 0x21, 0xdc, 0x11, 0x72, 0x94,
-	0xc8, 0x73, 0x3e, 0x1e, 0x0b, 0x94, 0x66, 0x59, 0x35, 0x37, 0x14, 0xf6, 0x46, 0x41, 0xf4, 0x0c,
-	0x00, 0x23, 0x7f, 0x4b, 0x38, 0x50, 0x04, 0x1d, 0x23, 0x7f, 0x93, 0x7e, 0x01, 0x86, 0xc7, 0x67,
-	0xb3, 0x40, 0x3a, 0xe8, 0x0d, 0x85, 0x59, 0x69, 0x91, 0xb6, 0xd1, 0x6d, 0xd8, 0xd9, 0xa2, 0xf6,
-	0x76, 0x51, 0x7b, 0xb8, 0x5d, 0xb4, 0x57, 0xbb, 0xfe, 0xda, 0xd4, 0xae, 0xbe, 0x35, 0x89, 0xb3,
-	0x5b, 0x48, 0x1f, 0xc3, 0x51, 0x38, 0x12, 0x72, 0x80, 0x18, 0x65, 0x9d, 0xcd, 0xaa, 0x1a, 0x55,
-	0x40, 0xe9, 0xeb, 0x8c, 0xd7, 0x0b, 0xb9, 0x37, 0x7d, 0x1e, 0xf9, 0x43, 0x61, 0x1e, 0xfe, 0xc7,
-	0xc8, 0x42, 0xad, 0xd5, 0x81, 0xe3, 0x67, 0x42, 0x04, 0x93, 0xa8, 0xcf, 0x5d, 0x07, 0xdf, 0xcd,
-	0x51, 0x48, 0x7a, 0x1f, 0xf4, 0xf7, 0x3c, 0x99, 0x62, 0x72, 0x9e, 0x1f, 0xa0, 0x96, 0x01, 0x2f,
-	0x7d, 0xcb, 0x87, 0x93, 0x9d, 0x02, 0x11, 0xf3, 0x48, 0x20, 0x7d, 0x04, 0xe5, 0x29, 0x5e, 0x2a,
-	0xae, 0xd1, 0x3d, 0xb5, 0x77, 0xfe, 0x81, 0x9d, 0x5d, 0xd3, 0x59, 0xe7, 0x69, 0x1b, 0x0e, 0x44,
-	0x8c, 0x9e, 0xba, 0x82, 0xd1, 0xad, 0x17, 0x79, 0xeb, 0x23, 0x3a, 0x8a, 0x61, 0x7d, 0x24, 0x70,
-	0xfc, 0x36, 0xf6, 0x47, 0x12, 0x77, 0x74, 0xfd, 0xe3, 0x94, 0x3d, 0xf9, 0xa5, 0x7d, 0xf9, 0xb9,
-	0x84, 0xf2, 0xdf, 0x24, 0xd0, 0x06, 0xd4, 0x3c, 0x3e, 0x8b, 0x43, 0x94, 0xa8, 0x8e, 0x5e, 0x73,
-	0xf2, 0xd8, 0x3a, 0x85, 0x93, 0x1d, 0x75, 0x99, 0x09, 0xdd, 0xcf, 0x04, 0xee, 0x29, 0x67, 0x7b,
-	0xf3, 0x20, 0xf4, 0x31, 0x19, 0x6c, 0x5b, 0xd3, 0x3e, 0xe8, 0xb9, 0x67, 0xf4, 0x6c, 0x6f, 0x66,
-	0xd1, 0xfc, 0x06, 0xfb, 0x53, 0x7a, 0x63, 0x75, 0x1f, 0xf4, 0x7c, 0x74, 0xa1, 0x57, 0xd1, 0xb0,
-	0x42, 0xaf, 0xdf, 0x14, 0xf7, 0x9e, 0x2e, 0x96, 0x4c, 0xbb, 0x59, 0x32, 0xed, 0x76, 0xc9, 0xc8,
-	0x87, 0x94, 0x91, 0x4f, 0x29, 0x23, 0xd7, 0x29, 0x23, 0x8b, 0x94, 0x91, 0xef, 0x29, 0x23, 0x3f,
-	0x52, 0xa6, 0xdd, 0xa6, 0x8c, 0x5c, 0xad, 0x98, 0xb6, 0x58, 0x31, 0xed, 0x66, 0xc5, 0x34, 0xb7,
-	0xaa, 0x3e, 0xd8, 0x93, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x89, 0x7b, 0x1b, 0x9d, 0x00, 0x04,
-	0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/blockbuilder/schedulerpb/scheduler.proto", fileDescriptor_f07d57b63f6c1662)
+}
+
+var fileDescriptor_f07d57b63f6c1662 = []byte{
+	// 545 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xc1, 0x6e, 0xd3, 0x4c,
+	0x10, 0xf6, 0x26, 0x4d, 0x1a, 0xaf, 0x7f, 0x55, 0xed, 0x36, 0xbf, 0x64, 0x05, 0xba, 0x09, 0x96,
+	0x40, 0x39, 0x20, 0x5b, 0x0a, 0xbc, 0x00, 0x91, 0x40, 0x22, 0x20, 0x21, 0x39, 0xe1, 0x5c, 0xc5,
+	0xf6, 0xc4, 0xb5, 0xe2, 0x78, 0x17, 0xef, 0x46, 0xa8, 0x37, 0x1e, 0xa1, 0x0f, 0xc0, 0x03, 0x70,
+	0xe3, 0x09, 0xb8, 0xf7, 0x98, 0x63, 0x4f, 0x40, 0x9c, 0x0b, 0xc7, 0x3e, 0x02, 0xca, 0x3a, 0x49,
+	0x1d, 0x23, 0x04, 0xdc, 0x3c, 0x33, 0xdf, 0xcc, 0x7c, 0xf3, 0x7d, 0x6b, 0xfc, 0x98, 0x4f, 0x43,
+	0xc7, 0x8b, 0x99, 0x3f, 0xf5, 0xe6, 0x51, 0x1c, 0x40, 0xea, 0x08, 0xff, 0x02, 0x82, 0x79, 0x0c,
+	0x29, 0xf7, 0xee, 0xbe, 0x6d, 0x9e, 0x32, 0xc9, 0x88, 0x51, 0x28, 0xb6, 0x9a, 0x21, 0x0b, 0x99,
+	0xca, 0x3b, 0xeb, 0xaf, 0x1c, 0xd2, 0x6a, 0x87, 0x8c, 0x85, 0x31, 0x38, 0x2a, 0xf2, 0xe6, 0x13,
+	0x47, 0x46, 0x33, 0x10, 0x72, 0x3c, 0xe3, 0x39, 0xc0, 0xb2, 0x71, 0x7d, 0xc0, 0xbc, 0x57, 0x70,
+	0x49, 0x8e, 0x70, 0x25, 0x0a, 0x4c, 0xd4, 0x41, 0x5d, 0xdd, 0xad, 0x44, 0x01, 0x69, 0xe2, 0x1a,
+	0x70, 0xe6, 0x5f, 0x98, 0x95, 0x0e, 0xea, 0x56, 0xdd, 0x3c, 0xb0, 0xbe, 0x54, 0xf0, 0xe1, 0x80,
+	0x79, 0x43, 0x0e, 0xfe, 0x1a, 0x21, 0x19, 0x8f, 0xfc, 0x4d, 0x53, 0x1e, 0x90, 0xfb, 0x58, 0xe7,
+	0xe3, 0x54, 0x46, 0x32, 0x62, 0x89, 0xea, 0xad, 0xb9, 0x77, 0x09, 0xf2, 0x00, 0xff, 0x27, 0xe4,
+	0x38, 0x95, 0xe7, 0x6c, 0x32, 0x11, 0x20, 0xcd, 0xaa, 0x1a, 0x6e, 0xa8, 0xdc, 0x1b, 0x95, 0x22,
+	0x67, 0x18, 0x43, 0x12, 0x6c, 0x01, 0x07, 0x0a, 0xa0, 0x43, 0x12, 0x6c, 0xca, 0x2f, 0xb0, 0xe1,
+	0xb3, 0xd9, 0x2c, 0x92, 0x2e, 0xf8, 0x23, 0x61, 0xd6, 0x3a, 0xa8, 0x6b, 0xf4, 0x5a, 0x76, 0x7e,
+	0xa8, 0xbd, 0x3d, 0xd4, 0x1e, 0x6d, 0x0f, 0xed, 0x37, 0xae, 0xbf, 0xb6, 0xb5, 0xab, 0x6f, 0x6d,
+	0xe4, 0x16, 0x1b, 0xc9, 0x23, 0x7c, 0x14, 0x8f, 0x85, 0x1c, 0x02, 0x24, 0xf9, 0x64, 0xb3, 0xae,
+	0x56, 0x95, 0xb2, 0xe4, 0x75, 0x8e, 0xeb, 0xaf, 0x5d, 0x79, 0x9e, 0x04, 0x23, 0x61, 0x1e, 0xfe,
+	0xc3, 0xca, 0x52, 0xaf, 0xe5, 0xe0, 0xe3, 0x67, 0x42, 0x44, 0x61, 0x32, 0x60, 0x9e, 0x0b, 0xef,
+	0xe6, 0x20, 0x24, 0xb9, 0x87, 0xf5, 0xf7, 0x2c, 0x9d, 0x42, 0x7a, 0xbe, 0x33, 0xa0, 0x91, 0x27,
+	0x5e, 0x06, 0x56, 0x80, 0x4f, 0x0a, 0x0d, 0x82, 0xb3, 0x44, 0x00, 0x79, 0x88, 0xab, 0x53, 0xb8,
+	0x54, 0x58, 0xa3, 0x77, 0x6a, 0x17, 0xde, 0x81, 0x9d, 0xbb, 0xe9, 0xae, 0xeb, 0xa4, 0x8b, 0x0f,
+	0x04, 0x07, 0x5f, 0xb9, 0x60, 0xf4, 0x9a, 0x65, 0xdc, 0xda, 0x44, 0x57, 0x21, 0xac, 0x8f, 0x08,
+	0x1f, 0xbf, 0xe5, 0xc1, 0x58, 0x42, 0x81, 0xd7, 0x5f, 0x6e, 0xd9, 0xa3, 0x5f, 0xd9, 0xa7, 0xbf,
+	0xa3, 0x50, 0xfd, 0x13, 0x05, 0xd2, 0xc2, 0x0d, 0x9f, 0xcd, 0x78, 0x0c, 0x12, 0x94, 0xe9, 0x0d,
+	0x77, 0x17, 0x5b, 0xa7, 0xf8, 0xa4, 0xc0, 0x2e, 0x17, 0xa1, 0xf7, 0x19, 0xe1, 0xff, 0x95, 0xb2,
+	0xfd, 0xfc, 0x5f, 0x19, 0x6e, 0x47, 0x93, 0x01, 0xd6, 0x77, 0x9a, 0x91, 0xb3, 0xbd, 0x9d, 0x65,
+	0xf1, 0x5b, 0xf4, 0x77, 0xe5, 0x8d, 0xd4, 0x03, 0xac, 0xef, 0x56, 0x97, 0x66, 0x95, 0x05, 0x2b,
+	0xcd, 0xfa, 0x85, 0x71, 0xff, 0xe9, 0x62, 0x49, 0xb5, 0x9b, 0x25, 0xd5, 0x6e, 0x97, 0x14, 0x7d,
+	0xc8, 0x28, 0xfa, 0x94, 0x51, 0x74, 0x9d, 0x51, 0xb4, 0xc8, 0x28, 0xfa, 0x9e, 0x51, 0xf4, 0x23,
+	0xa3, 0xda, 0x6d, 0x46, 0xd1, 0xd5, 0x8a, 0x6a, 0x8b, 0x15, 0xd5, 0x6e, 0x56, 0x54, 0xf3, 0xea,
+	0xea, 0x81, 0x3d, 0xf9, 0x19, 0x00, 0x00, 0xff, 0xff, 0xac, 0x24, 0xb5, 0x89, 0x1d, 0x04, 0x00,
+	0x00,
 }
 
 func (this *JobKey) Equal(that interface{}) bool {
@@ -794,7 +797,7 @@ var _BlockBuilderScheduler_serviceDesc = grpc.ServiceDesc{
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
-	Metadata: "scheduler.proto",
+	Metadata: "pkg/blockbuilder/schedulerpb/scheduler.proto",
 }
 
 func (m *JobKey) Marshal() (dAtA []byte, err error) {
diff --git a/pkg/distributor/distributorpb/distributor.pb.go b/pkg/distributor/distributorpb/distributor.pb.go
index 8ffe5387f26..ee342d2e517 100644
--- a/pkg/distributor/distributorpb/distributor.pb.go
+++ b/pkg/distributor/distributorpb/distributor.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: distributor.proto
+// source: pkg/distributor/distributorpb/distributor.proto
 
 package distributorpb
 
@@ -8,11 +8,11 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 	math "math"
+	mimirpb "pkg/mimirpb"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -26,25 +26,25 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-func init() { proto.RegisterFile("distributor.proto", fileDescriptor_c518e33639ca565d) }
-
-var fileDescriptor_c518e33639ca565d = []byte{
-	// 225 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4c, 0xc9, 0x2c, 0x2e,
-	0x29, 0xca, 0x4c, 0x2a, 0x2d, 0xc9, 0x2f, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x46,
-	0x12, 0x92, 0xd2, 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf,
-	0x4f, 0xcf, 0xd7, 0x07, 0xab, 0x49, 0x2a, 0x4d, 0x03, 0xf3, 0xc0, 0x1c, 0x30, 0x0b, 0xa2, 0x57,
-	0xca, 0x00, 0x59, 0x79, 0x51, 0x62, 0x5a, 0x62, 0x5e, 0xa2, 0x7e, 0x6e, 0x66, 0x6e, 0x66, 0x91,
-	0x7e, 0x41, 0x76, 0x3a, 0x84, 0x55, 0x90, 0x04, 0xa1, 0x21, 0x3a, 0x8c, 0x3c, 0xb8, 0xb8, 0x5d,
-	0x10, 0xf6, 0x09, 0x59, 0x72, 0xb1, 0x04, 0x94, 0x16, 0x67, 0x08, 0x89, 0xe9, 0x25, 0xe7, 0x17,
-	0x95, 0xa4, 0x56, 0x14, 0x24, 0xe9, 0x85, 0x17, 0x65, 0x96, 0xa4, 0x06, 0xa5, 0x16, 0x96, 0xa6,
-	0x16, 0x97, 0x48, 0x89, 0x63, 0x88, 0x17, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x2a, 0x31, 0x38, 0x39,
-	0x5f, 0x78, 0x28, 0xc7, 0x70, 0xe3, 0xa1, 0x1c, 0xc3, 0x87, 0x87, 0x72, 0x8c, 0x0d, 0x8f, 0xe4,
-	0x18, 0x57, 0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f,
-	0xe4, 0x18, 0x5f, 0x3c, 0x92, 0x63, 0xf8, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b,
-	0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xe2, 0x45, 0xf2, 0x6d, 0x41, 0x52, 0x12, 0x1b,
-	0xd8, 0x55, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x85, 0x48, 0xef, 0xb2, 0x18, 0x01, 0x00,
-	0x00,
+func init() {
+	proto.RegisterFile("pkg/distributor/distributorpb/distributor.proto", fileDescriptor_2a8cc59121793d59)
+}
+
+var fileDescriptor_2a8cc59121793d59 = []byte{
+	// 201 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2f, 0xc8, 0x4e, 0xd7,
+	0x4f, 0xc9, 0x2c, 0x2e, 0x29, 0xca, 0x4c, 0x2a, 0x2d, 0xc9, 0x2f, 0x42, 0x66, 0x17, 0x24, 0x21,
+	0xf3, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xb8, 0x91, 0x84, 0xa4, 0x44, 0xd2, 0xf3, 0xd3,
+	0xf3, 0xc1, 0xe2, 0xfa, 0x20, 0x16, 0x44, 0x89, 0x94, 0x38, 0xc8, 0xcc, 0xdc, 0xcc, 0xdc, 0x4c,
+	0x90, 0x09, 0x60, 0x1a, 0x22, 0x61, 0xe4, 0xc1, 0xc5, 0xed, 0x82, 0xd0, 0x2d, 0x64, 0xc9, 0xc5,
+	0x12, 0x50, 0x5a, 0x9c, 0x21, 0x24, 0xa6, 0x97, 0x9c, 0x5f, 0x54, 0x92, 0x5a, 0x51, 0x90, 0xa4,
+	0x17, 0x5e, 0x94, 0x59, 0x92, 0x1a, 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0x22, 0x25, 0x8e, 0x21,
+	0x5e, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0xaa, 0xc4, 0xe0, 0xe4, 0x7c, 0xe1, 0xa1, 0x1c, 0xc3, 0x8d,
+	0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0x36, 0x3c, 0x92, 0x63, 0x5c, 0xf1, 0x48, 0x8e, 0xf1,
+	0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x7c, 0xf1, 0x48, 0x8e,
+	0xe1, 0xc3, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58,
+	0x8e, 0x21, 0x8a, 0x17, 0xc5, 0x73, 0x49, 0x6c, 0x60, 0x57, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff,
+	0xff, 0x78, 0x11, 0x0c, 0xc4, 0x04, 0x01, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -124,5 +124,5 @@ var _Distributor_serviceDesc = grpc.ServiceDesc{
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
-	Metadata: "distributor.proto",
+	Metadata: "pkg/distributor/distributorpb/distributor.proto",
 }
diff --git a/pkg/distributor/distributorpb/distributor.proto b/pkg/distributor/distributorpb/distributor.proto
index 576a244afcd..5168fd929f5 100644
--- a/pkg/distributor/distributorpb/distributor.proto
+++ b/pkg/distributor/distributorpb/distributor.proto
@@ -9,8 +9,8 @@ package distributor;
 
 option go_package = "distributorpb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
diff --git a/pkg/distributor/ha_tracker.pb.go b/pkg/distributor/ha_tracker.pb.go
index 6d0bba4668a..da758091283 100644
--- a/pkg/distributor/ha_tracker.pb.go
+++ b/pkg/distributor/ha_tracker.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: ha_tracker.proto
+// source: pkg/distributor/ha_tracker.proto
 
 package distributor
 
@@ -44,7 +44,7 @@ type ReplicaDesc struct {
 func (m *ReplicaDesc) Reset()      { *m = ReplicaDesc{} }
 func (*ReplicaDesc) ProtoMessage() {}
 func (*ReplicaDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86f0e7bcf71d860b, []int{0}
+	return fileDescriptor_673277e9cf9b9f67, []int{0}
 }
 func (m *ReplicaDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -112,26 +112,26 @@ func init() {
 	proto.RegisterType((*ReplicaDesc)(nil), "distributor.ReplicaDesc")
 }
 
-func init() { proto.RegisterFile("ha_tracker.proto", fileDescriptor_86f0e7bcf71d860b) }
+func init() { proto.RegisterFile("pkg/distributor/ha_tracker.proto", fileDescriptor_673277e9cf9b9f67) }
 
-var fileDescriptor_86f0e7bcf71d860b = []byte{
-	// 253 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0x8f, 0x3f, 0x4e, 0xc3, 0x30,
-	0x14, 0x87, 0xfd, 0x28, 0x7f, 0x54, 0x57, 0x02, 0xe4, 0x29, 0x42, 0xe2, 0x51, 0xb1, 0xd0, 0x85,
-	0x76, 0x80, 0x0b, 0x14, 0x38, 0x41, 0x2e, 0x50, 0x39, 0xce, 0x23, 0xb1, 0x08, 0xb8, 0x72, 0x1c,
-	0x66, 0x8e, 0xc0, 0x31, 0xd8, 0xb8, 0x06, 0x63, 0xc6, 0x8e, 0xc4, 0x59, 0x18, 0x7b, 0x04, 0x24,
-	0x3b, 0xd9, 0xfc, 0x7d, 0xdf, 0xcf, 0xc3, 0xe3, 0xe7, 0xa5, 0xdc, 0x38, 0x2b, 0xd5, 0x0b, 0xd9,
-	0xe5, 0xd6, 0x1a, 0x67, 0xc4, 0x2c, 0xd7, 0xb5, 0xb3, 0x3a, 0x6b, 0x9c, 0xb1, 0x17, 0xb7, 0x85,
-	0x76, 0x65, 0x93, 0x2d, 0x95, 0x79, 0x5d, 0x15, 0xa6, 0x30, 0xab, 0xb0, 0xc9, 0x9a, 0xe7, 0x40,
-	0x01, 0xc2, 0x2b, 0xfe, 0xbd, 0xfe, 0x06, 0x3e, 0x4b, 0x69, 0x5b, 0x69, 0x25, 0x9f, 0xa8, 0x56,
-	0x22, 0xe1, 0x27, 0x36, 0x62, 0x02, 0x73, 0x58, 0x4c, 0xd3, 0x11, 0xc5, 0x15, 0x9f, 0x59, 0x52,
-	0xa4, 0xdf, 0x29, 0xdf, 0x48, 0x97, 0x1c, 0xcc, 0x61, 0x31, 0x49, 0xf9, 0xa8, 0xd6, 0x4e, 0x5c,
-	0x72, 0x9e, 0x53, 0x45, 0x2e, 0xf6, 0x49, 0xe8, 0xd3, 0xc1, 0xc4, 0x4c, 0x15, 0xa9, 0x21, 0x1f,
-	0xc6, 0x3c, 0x98, 0xb5, 0x13, 0x37, 0xfc, 0x6c, 0xcc, 0xaa, 0x94, 0x6f, 0x05, 0xd5, 0xc9, 0x51,
-	0xd8, 0x9c, 0x0e, 0xfa, 0x31, 0xda, 0x87, 0xfb, 0xb6, 0x43, 0xb6, 0xeb, 0x90, 0xed, 0x3b, 0x84,
-	0x0f, 0x8f, 0xf0, 0xe5, 0x11, 0x7e, 0x3c, 0x42, 0xeb, 0x11, 0x7e, 0x3d, 0xc2, 0x9f, 0x47, 0xb6,
-	0xf7, 0x08, 0x9f, 0x3d, 0xb2, 0xb6, 0x47, 0xb6, 0xeb, 0x91, 0x65, 0xc7, 0xe1, 0xdc, 0xbb, 0xff,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x84, 0x4a, 0xc8, 0x3e, 0x01, 0x00, 0x00,
+var fileDescriptor_673277e9cf9b9f67 = []byte{
+	// 246 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0xcf, 0x3f, 0x4e, 0xc3, 0x30,
+	0x14, 0xc7, 0x71, 0x3f, 0xca, 0x1f, 0xd5, 0x91, 0x40, 0xb2, 0x18, 0x22, 0x24, 0x1e, 0x11, 0x0b,
+	0x9d, 0xc8, 0x00, 0x17, 0x28, 0x70, 0x82, 0x5c, 0xa0, 0x72, 0x9d, 0xa7, 0x34, 0x6a, 0x84, 0x23,
+	0xe7, 0xc1, 0xcc, 0x11, 0x38, 0x06, 0x1b, 0xd7, 0x60, 0xcc, 0xd8, 0x91, 0x38, 0x0b, 0x63, 0x8f,
+	0x80, 0x88, 0x13, 0x89, 0xcd, 0xef, 0xfb, 0xf9, 0x2d, 0x96, 0x49, 0xbd, 0x2d, 0xd2, 0xbc, 0x6c,
+	0xd8, 0x95, 0xeb, 0x17, 0xb6, 0x2e, 0xdd, 0xe8, 0x15, 0x3b, 0x6d, 0xb6, 0xe4, 0x6e, 0x6b, 0x67,
+	0xd9, 0xaa, 0xe8, 0x9f, 0x5e, 0x9c, 0x17, 0xb6, 0xb0, 0x43, 0x4f, 0xff, 0x5e, 0x61, 0x72, 0xfd,
+	0x09, 0x32, 0xca, 0xa8, 0xae, 0x4a, 0xa3, 0x9f, 0xa8, 0x31, 0x2a, 0x96, 0x27, 0x2e, 0x9c, 0x31,
+	0x24, 0xb0, 0x98, 0x67, 0xd3, 0xa9, 0xae, 0x64, 0xe4, 0xc8, 0x50, 0xf9, 0x4a, 0xf9, 0x4a, 0x73,
+	0x7c, 0x90, 0xc0, 0x62, 0x96, 0xc9, 0x29, 0x2d, 0x59, 0x5d, 0x4a, 0x99, 0x53, 0x45, 0x1c, 0x7c,
+	0x36, 0xf8, 0x7c, 0x2c, 0x81, 0xa9, 0x22, 0x33, 0xf2, 0x61, 0xe0, 0xb1, 0x2c, 0x59, 0xdd, 0xc8,
+	0xb3, 0x89, 0xcd, 0x46, 0x3f, 0x17, 0xd4, 0xc4, 0x47, 0xc3, 0xe6, 0x74, 0xcc, 0x8f, 0xa1, 0x3e,
+	0xdc, 0xb7, 0x1d, 0x8a, 0x5d, 0x87, 0x62, 0xdf, 0x21, 0xbc, 0x79, 0x84, 0x0f, 0x8f, 0xf0, 0xe5,
+	0x11, 0x5a, 0x8f, 0xf0, 0xed, 0x11, 0x7e, 0x3c, 0x8a, 0xbd, 0x47, 0x78, 0xef, 0x51, 0xb4, 0x3d,
+	0x8a, 0x5d, 0x8f, 0x62, 0x7d, 0x3c, 0x7c, 0xf7, 0xee, 0x37, 0x00, 0x00, 0xff, 0xff, 0x74, 0xd4,
+	0xca, 0x36, 0x35, 0x01, 0x00, 0x00,
 }
 
 func (this *ReplicaDesc) Equal(that interface{}) bool {
diff --git a/pkg/distributor/ha_tracker.proto b/pkg/distributor/ha_tracker.proto
index d5cdfd4b97b..63b46df4451 100644
--- a/pkg/distributor/ha_tracker.proto
+++ b/pkg/distributor/ha_tracker.proto
@@ -7,8 +7,7 @@ syntax = "proto3";
 
 package distributor;
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-
+import "gogoproto/gogo.proto";
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
 
diff --git a/pkg/frontend/querymiddleware/model.pb.go b/pkg/frontend/querymiddleware/model.pb.go
index 47f80838c30..137d06b2aed 100644
--- a/pkg/frontend/querymiddleware/model.pb.go
+++ b/pkg/frontend/querymiddleware/model.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: model.proto
+// source: pkg/frontend/querymiddleware/model.proto
 
 // Uses queryrange package to offer backwards compatibility with cached extents.
 
@@ -11,11 +11,10 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	types "github.com/gogo/protobuf/types"
-	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
-	mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	mimirpb "pkg/mimirpb"
 	reflect "reflect"
 	strings "strings"
 )
@@ -39,7 +38,7 @@ type PrometheusHeader struct {
 func (m *PrometheusHeader) Reset()      { *m = PrometheusHeader{} }
 func (*PrometheusHeader) ProtoMessage() {}
 func (*PrometheusHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{0}
+	return fileDescriptor_2515e0a4916c2504, []int{0}
 }
 func (m *PrometheusHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -95,7 +94,7 @@ type PrometheusResponse struct {
 func (m *PrometheusResponse) Reset()      { *m = PrometheusResponse{} }
 func (*PrometheusResponse) ProtoMessage() {}
 func (*PrometheusResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{1}
+	return fileDescriptor_2515e0a4916c2504, []int{1}
 }
 func (m *PrometheusResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -181,7 +180,7 @@ type PrometheusData struct {
 func (m *PrometheusData) Reset()      { *m = PrometheusData{} }
 func (*PrometheusData) ProtoMessage() {}
 func (*PrometheusData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{2}
+	return fileDescriptor_2515e0a4916c2504, []int{2}
 }
 func (m *PrometheusData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -225,15 +224,15 @@ func (m *PrometheusData) GetResult() []SampleStream {
 }
 
 type SampleStream struct {
-	Labels     []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"metric"`
-	Samples    []mimirpb.Sample                                    `protobuf:"bytes,2,rep,name=samples,proto3" json:"values"`
-	Histograms []mimirpb.FloatHistogramPair                        `protobuf:"bytes,3,rep,name=histograms,proto3" json:"histograms"`
+	Labels     []mimirpb.LabelAdapter       `protobuf:"bytes,1,rep,name=labels,proto3" json:"metric"`
+	Samples    []mimirpb.Sample             `protobuf:"bytes,2,rep,name=samples,proto3" json:"values"`
+	Histograms []mimirpb.FloatHistogramPair `protobuf:"bytes,3,rep,name=histograms,proto3" json:"histograms"`
 }
 
 func (m *SampleStream) Reset()      { *m = SampleStream{} }
 func (*SampleStream) ProtoMessage() {}
 func (*SampleStream) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{3}
+	return fileDescriptor_2515e0a4916c2504, []int{3}
 }
 func (m *SampleStream) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -262,6 +261,13 @@ func (m *SampleStream) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_SampleStream proto.InternalMessageInfo
 
+func (m *SampleStream) GetLabels() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 func (m *SampleStream) GetSamples() []mimirpb.Sample {
 	if m != nil {
 		return m.Samples
@@ -285,7 +291,7 @@ type CachedError struct {
 func (m *CachedError) Reset()      { *m = CachedError{} }
 func (*CachedError) ProtoMessage() {}
 func (*CachedError) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{4}
+	return fileDescriptor_2515e0a4916c2504, []int{4}
 }
 func (m *CachedError) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -344,7 +350,7 @@ type CachedResponse struct {
 func (m *CachedResponse) Reset()      { *m = CachedResponse{} }
 func (*CachedResponse) ProtoMessage() {}
 func (*CachedResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{5}
+	return fileDescriptor_2515e0a4916c2504, []int{5}
 }
 func (m *CachedResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -401,7 +407,7 @@ type Extent struct {
 func (m *Extent) Reset()      { *m = Extent{} }
 func (*Extent) ProtoMessage() {}
 func (*Extent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{6}
+	return fileDescriptor_2515e0a4916c2504, []int{6}
 }
 func (m *Extent) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -477,7 +483,7 @@ type Options struct {
 func (m *Options) Reset()      { *m = Options{} }
 func (*Options) ProtoMessage() {}
 func (*Options) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{7}
+	return fileDescriptor_2515e0a4916c2504, []int{7}
 }
 func (m *Options) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -548,7 +554,7 @@ type QueryStatistics struct {
 func (m *QueryStatistics) Reset()      { *m = QueryStatistics{} }
 func (*QueryStatistics) ProtoMessage() {}
 func (*QueryStatistics) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{8}
+	return fileDescriptor_2515e0a4916c2504, []int{8}
 }
 func (m *QueryStatistics) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -600,7 +606,7 @@ type CachedHTTPResponse struct {
 func (m *CachedHTTPResponse) Reset()      { *m = CachedHTTPResponse{} }
 func (*CachedHTTPResponse) ProtoMessage() {}
 func (*CachedHTTPResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{9}
+	return fileDescriptor_2515e0a4916c2504, []int{9}
 }
 func (m *CachedHTTPResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -666,7 +672,7 @@ type CachedHTTPHeader struct {
 func (m *CachedHTTPHeader) Reset()      { *m = CachedHTTPHeader{} }
 func (*CachedHTTPHeader) ProtoMessage() {}
 func (*CachedHTTPHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_4c16552f9fdb66d8, []int{10}
+	return fileDescriptor_2515e0a4916c2504, []int{10}
 }
 func (m *CachedHTTPHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -723,77 +729,78 @@ func init() {
 	proto.RegisterType((*CachedHTTPHeader)(nil), "queryrange.CachedHTTPHeader")
 }
 
-func init() { proto.RegisterFile("model.proto", fileDescriptor_4c16552f9fdb66d8) }
-
-var fileDescriptor_4c16552f9fdb66d8 = []byte{
-	// 1061 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0xf7, 0xc6, 0xff, 0x9f, 0xd3, 0xc4, 0x9a, 0x44, 0xe0, 0x04, 0xd8, 0xb5, 0x56, 0x1c, 0x02,
-	0xb4, 0x0e, 0x84, 0x3f, 0x07, 0x44, 0x11, 0x75, 0x1a, 0x94, 0x40, 0x0b, 0x61, 0x1c, 0x81, 0xc4,
-	0x25, 0x1a, 0x7b, 0x27, 0xf6, 0xd2, 0xdd, 0x9d, 0x65, 0x66, 0xdc, 0xd6, 0x37, 0xc4, 0x15, 0x09,
-	0xf1, 0x09, 0x38, 0xf3, 0x51, 0x7a, 0xcc, 0xb1, 0xea, 0x61, 0x45, 0x1c, 0x21, 0xa1, 0x3d, 0xf5,
-	0x03, 0x70, 0x40, 0x3b, 0xb3, 0xff, 0xd2, 0x46, 0x88, 0x8b, 0x3d, 0xef, 0xf7, 0x7e, 0xbf, 0x37,
-	0x6f, 0xde, 0xbc, 0x79, 0x0b, 0x1d, 0x9f, 0x39, 0xd4, 0x1b, 0x84, 0x9c, 0x49, 0x86, 0xe0, 0xc7,
-	0x39, 0xe5, 0x0b, 0x4e, 0x82, 0x29, 0xdd, 0xbe, 0x35, 0x75, 0xe5, 0x6c, 0x3e, 0x1e, 0x4c, 0x98,
-	0xbf, 0x3b, 0x65, 0x53, 0xb6, 0xab, 0x28, 0xe3, 0xf9, 0x99, 0xb2, 0x94, 0xa1, 0x56, 0x5a, 0xba,
-	0xfd, 0x6e, 0x99, 0xce, 0xc9, 0x19, 0x09, 0xc8, 0xae, 0xef, 0xfa, 0x2e, 0xdf, 0x0d, 0x1f, 0x4c,
-	0xf5, 0x2a, 0x1c, 0xeb, 0xff, 0x54, 0xb1, 0x35, 0x65, 0x6c, 0xea, 0xd1, 0x22, 0x2e, 0x09, 0x16,
-	0xda, 0x65, 0xdf, 0x83, 0xee, 0x31, 0x67, 0x3e, 0x95, 0x33, 0x3a, 0x17, 0x87, 0x94, 0x38, 0x94,
-	0xa3, 0x2d, 0xa8, 0x7d, 0x45, 0x7c, 0xda, 0x33, 0xfa, 0xc6, 0x4e, 0x7b, 0x58, 0x8f, 0x23, 0xcb,
-	0xb8, 0x85, 0x15, 0x84, 0xde, 0x80, 0xc6, 0xb7, 0xc4, 0x9b, 0x53, 0xd1, 0x5b, 0xe9, 0x57, 0x0b,
-	0x67, 0x0a, 0xda, 0xff, 0xac, 0x00, 0x2a, 0xc2, 0x61, 0x2a, 0x42, 0x16, 0x08, 0x8a, 0x6c, 0x68,
-	0x8c, 0x24, 0x91, 0x73, 0x91, 0x86, 0x84, 0x38, 0xb2, 0x1a, 0x42, 0x21, 0x38, 0xf5, 0xa0, 0x21,
-	0xd4, 0xee, 0x12, 0x49, 0x7a, 0x2b, 0x7d, 0x63, 0xa7, 0xb3, 0xb7, 0x3d, 0x28, 0xea, 0x33, 0x28,
-	0x22, 0x26, 0x8c, 0x21, 0x8a, 0x23, 0x6b, 0xcd, 0x21, 0x92, 0xdc, 0x64, 0xbe, 0x2b, 0xa9, 0x1f,
-	0xca, 0x05, 0x56, 0x5a, 0xf4, 0x21, 0xb4, 0x0f, 0x38, 0x67, 0xfc, 0x64, 0x11, 0xd2, 0x5e, 0x55,
-	0x6d, 0xf5, 0x6a, 0x1c, 0x59, 0x1b, 0x34, 0x03, 0x4b, 0x8a, 0x82, 0x89, 0xde, 0x82, 0xba, 0x32,
-	0x7a, 0x35, 0x25, 0xd9, 0x88, 0x23, 0x6b, 0x5d, 0x49, 0x4a, 0x74, 0xcd, 0x40, 0xb7, 0xa1, 0xa9,
-	0x8b, 0x24, 0x7a, 0xf5, 0x7e, 0x75, 0xa7, 0xb3, 0xf7, 0xfa, 0xf5, 0x89, 0x6a, 0x52, 0x56, 0x9e,
-	0x4c, 0x83, 0xf6, 0xa0, 0xf5, 0x1d, 0xe1, 0x81, 0x1b, 0x4c, 0x45, 0xaf, 0xa1, 0x0a, 0xf8, 0x4a,
-	0x1c, 0x59, 0xe8, 0x51, 0x8a, 0x95, 0xf6, 0xcb, 0x79, 0x49, 0x76, 0x47, 0xc1, 0x19, 0x13, 0xbd,
-	0xa6, 0x12, 0xa8, 0xec, 0xdc, 0x04, 0x28, 0x67, 0xa7, 0x18, 0xf6, 0xcf, 0x06, 0xac, 0x5d, 0x2d,
-	0x16, 0x1a, 0x00, 0x60, 0x2a, 0xe6, 0x9e, 0x54, 0x35, 0xd1, 0xe5, 0x5f, 0x8b, 0x23, 0x0b, 0x78,
-	0x8e, 0xe2, 0x12, 0x03, 0x7d, 0x06, 0x0d, 0x6d, 0xa9, 0x0b, 0xee, 0xec, 0xf5, 0xca, 0xe7, 0x1b,
-	0x11, 0x3f, 0xf4, 0xe8, 0x48, 0x72, 0x4a, 0xfc, 0xe1, 0xda, 0x93, 0xc8, 0xaa, 0x24, 0x17, 0xa9,
-	0x23, 0xe1, 0x54, 0x67, 0xff, 0xba, 0x02, 0xab, 0x65, 0x22, 0x0a, 0xa1, 0xe1, 0x91, 0x31, 0xf5,
-	0x92, 0xdb, 0x4f, 0x42, 0x6e, 0x0c, 0x26, 0x8c, 0x4b, 0xfa, 0x38, 0x1c, 0x0f, 0xee, 0x25, 0xf8,
-	0x31, 0x71, 0xf9, 0x70, 0x3f, 0x89, 0xf6, 0x2c, 0xb2, 0xde, 0xfb, 0x3f, 0xcd, 0xad, 0x75, 0x77,
-	0x1c, 0x12, 0x4a, 0xca, 0x93, 0x14, 0x7c, 0x2a, 0xb9, 0x3b, 0xc1, 0xe9, 0x3e, 0xe8, 0x63, 0x68,
-	0x0a, 0x95, 0x81, 0x48, 0x4f, 0xd1, 0x2d, 0xb6, 0xd4, 0xa9, 0x15, 0xd9, 0x3f, 0x54, 0x9d, 0x8b,
-	0x33, 0x01, 0x3a, 0x06, 0x98, 0xb9, 0x42, 0xb2, 0x29, 0x27, 0xbe, 0xe8, 0x55, 0xd3, 0x4b, 0xce,
-	0xe5, 0x9f, 0x7b, 0x8c, 0xc8, 0xc3, 0x8c, 0xa0, 0x52, 0x47, 0x69, 0xa8, 0x92, 0x0e, 0x97, 0xd6,
-	0xf6, 0x2f, 0x06, 0x74, 0xf6, 0xc9, 0x64, 0x46, 0x1d, 0xdd, 0x43, 0x5b, 0x50, 0x7d, 0x40, 0x17,
-	0xe9, 0x5d, 0x34, 0xe3, 0xc8, 0x4a, 0x4c, 0x9c, 0xfc, 0xa0, 0x77, 0xa0, 0x9d, 0xf7, 0xaa, 0x7a,
-	0x09, 0xed, 0xe1, 0x8d, 0x38, 0xb2, 0x0a, 0x10, 0x17, 0x4b, 0xf4, 0x01, 0xac, 0x2a, 0xe3, 0x3e,
-	0x15, 0x82, 0x4c, 0xb3, 0x86, 0xef, 0xc6, 0x91, 0x75, 0x05, 0xc7, 0x57, 0x2c, 0xfb, 0x07, 0x58,
-	0xd3, 0xc9, 0xe4, 0xaf, 0xf3, 0x3f, 0xf2, 0xb9, 0x0d, 0x4d, 0xfa, 0x58, 0xd2, 0x40, 0x66, 0x85,
-	0x44, 0xe5, 0x76, 0x38, 0x50, 0xae, 0xe1, 0x7a, 0x7a, 0xfe, 0x8c, 0x8a, 0xb3, 0x85, 0xfd, 0xcc,
-	0x80, 0x86, 0x26, 0x21, 0x0b, 0xea, 0x42, 0x12, 0x2e, 0xd5, 0x36, 0xd5, 0x61, 0x3b, 0x8e, 0x2c,
-	0x0d, 0x60, 0xfd, 0x97, 0x64, 0x41, 0x03, 0x47, 0x1d, 0xba, 0xaa, 0xb3, 0xa0, 0x81, 0x83, 0x93,
-	0x1f, 0xd4, 0x87, 0x96, 0xe4, 0x64, 0x42, 0x4f, 0x5d, 0x27, 0x7d, 0xa2, 0xd9, 0xbb, 0x52, 0xf0,
-	0x91, 0x83, 0x3e, 0x85, 0x16, 0x4f, 0x8f, 0xd3, 0xab, 0xab, 0x01, 0xb2, 0x39, 0xd0, 0x33, 0x6f,
-	0x90, 0xcd, 0xbc, 0xc1, 0x9d, 0x60, 0x31, 0x5c, 0x8d, 0x23, 0x2b, 0x67, 0xe2, 0x7c, 0x85, 0x6e,
-	0x02, 0x52, 0xe7, 0x3a, 0x95, 0xae, 0x4f, 0x85, 0x24, 0x7e, 0x78, 0xea, 0x27, 0x2f, 0xd4, 0xd8,
-	0xa9, 0xe2, 0xae, 0xf2, 0x9c, 0x64, 0x8e, 0xfb, 0xe2, 0x8b, 0x5a, 0xab, 0xda, 0xad, 0xd9, 0x7f,
-	0x19, 0xd0, 0xfc, 0x3a, 0x94, 0x2e, 0x0b, 0x04, 0x7a, 0x13, 0x6e, 0xa8, 0xa2, 0xde, 0x75, 0x05,
-	0x19, 0x7b, 0xd4, 0x51, 0xa7, 0x6c, 0xe1, 0xab, 0x20, 0x7a, 0x1b, 0xba, 0xa3, 0x19, 0xe1, 0x8e,
-	0x1b, 0x4c, 0x73, 0xe2, 0x8a, 0x22, 0xbe, 0x84, 0xa3, 0x3e, 0x74, 0x4e, 0x98, 0x24, 0x9e, 0x72,
-	0x08, 0x75, 0xb7, 0x75, 0x5c, 0x86, 0xd0, 0x1e, 0x6c, 0x1e, 0x05, 0x42, 0x92, 0x40, 0x8e, 0x42,
-	0xcf, 0x95, 0x79, 0xc4, 0x9a, 0x8a, 0x78, 0xad, 0xef, 0x45, 0xcd, 0x51, 0x20, 0x29, 0x7f, 0x48,
-	0x3c, 0x55, 0xb3, 0x2a, 0xbe, 0xd6, 0x67, 0x1f, 0xc0, 0xfa, 0x37, 0x49, 0x05, 0x92, 0x39, 0xed,
-	0x0a, 0xe9, 0x4e, 0xd4, 0xd6, 0x07, 0x42, 0xba, 0x3e, 0x91, 0xd4, 0x19, 0x51, 0xee, 0x52, 0xb1,
-	0xcf, 0xe6, 0x81, 0xbe, 0xdb, 0x1a, 0xbe, 0xd6, 0x67, 0xff, 0x6e, 0x00, 0xd2, 0x8d, 0x77, 0x78,
-	0x72, 0x72, 0x9c, 0x37, 0xdf, 0x6b, 0xd0, 0x9e, 0x24, 0xe8, 0x69, 0xde, 0x82, 0xb8, 0xa5, 0x80,
-	0x2f, 0xe9, 0x02, 0x59, 0xd0, 0xd1, 0x5f, 0x89, 0xd3, 0x09, 0x73, 0xf4, 0x83, 0xa8, 0x63, 0xd0,
-	0xd0, 0x3e, 0x73, 0x28, 0xfa, 0x08, 0x9a, 0xb3, 0x74, 0x1c, 0x57, 0x5f, 0x1e, 0xc7, 0xc5, 0x76,
-	0x7a, 0xfe, 0xe2, 0x8c, 0x8c, 0x10, 0xd4, 0xc6, 0xcc, 0x59, 0xa8, 0x5a, 0xad, 0x62, 0xb5, 0xb6,
-	0x3f, 0x81, 0xee, 0x8b, 0x82, 0x84, 0x17, 0xe4, 0x5f, 0x42, 0xac, 0xd6, 0x68, 0x13, 0xea, 0x6a,
-	0x66, 0xe8, 0xf7, 0x89, 0xb5, 0x31, 0x3c, 0x38, 0xbf, 0x30, 0x2b, 0x4f, 0x2f, 0xcc, 0xca, 0xf3,
-	0x0b, 0xd3, 0xf8, 0x69, 0x69, 0x1a, 0x7f, 0x2c, 0x4d, 0xe3, 0xc9, 0xd2, 0x34, 0xce, 0x97, 0xa6,
-	0xf1, 0xe7, 0xd2, 0x34, 0xfe, 0x5e, 0x9a, 0x95, 0xe7, 0x4b, 0xd3, 0xf8, 0xed, 0xd2, 0xac, 0x9c,
-	0x5f, 0x9a, 0x95, 0xa7, 0x97, 0x66, 0xe5, 0xfb, 0x75, 0x95, 0xad, 0xef, 0x3a, 0x8e, 0x47, 0x1f,
-	0x11, 0x4e, 0xc7, 0x0d, 0xd5, 0xae, 0xef, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x48, 0x21,
-	0x5e, 0x2c, 0x08, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/frontend/querymiddleware/model.proto", fileDescriptor_2515e0a4916c2504)
+}
+
+var fileDescriptor_2515e0a4916c2504 = []byte{
+	// 1055 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0x4d, 0x6f, 0x1c, 0x45,
+	0x13, 0xde, 0xf1, 0x7e, 0xd7, 0x3a, 0xf6, 0xaa, 0x63, 0x25, 0x9b, 0xbc, 0x2f, 0x33, 0xab, 0x51,
+	0x0e, 0x06, 0xc2, 0xae, 0x64, 0x3e, 0x0e, 0x88, 0x44, 0x64, 0x1d, 0x23, 0x1b, 0x12, 0x30, 0xbd,
+	0x16, 0x48, 0x5c, 0x56, 0xbd, 0x3b, 0xed, 0xf5, 0x90, 0x99, 0xe9, 0xa1, 0xbb, 0x37, 0xc9, 0xde,
+	0x10, 0x57, 0x2e, 0xfc, 0x02, 0xce, 0xfc, 0x94, 0x1c, 0x7d, 0x8c, 0x10, 0x1a, 0xe1, 0xb5, 0x90,
+	0xd0, 0x9c, 0xf2, 0x03, 0x38, 0xa0, 0xe9, 0x9e, 0x2f, 0x7f, 0x88, 0xcb, 0x6e, 0xf7, 0x53, 0xcf,
+	0x53, 0x5d, 0x5d, 0x55, 0x5d, 0x03, 0xdb, 0xe1, 0xb3, 0xf9, 0xf0, 0x98, 0xb3, 0x40, 0xd2, 0xc0,
+	0x19, 0xfe, 0xb0, 0xa0, 0x7c, 0xe9, 0xbb, 0x8e, 0xe3, 0xd1, 0x17, 0x84, 0xd3, 0xa1, 0xcf, 0x1c,
+	0xea, 0x0d, 0x42, 0xce, 0x24, 0x43, 0xa0, 0x8c, 0x9c, 0x04, 0x73, 0x7a, 0x77, 0x6b, 0xce, 0xe6,
+	0x4c, 0xc1, 0xc3, 0x64, 0xa5, 0x19, 0x77, 0x6f, 0x27, 0xbe, 0x7c, 0xd7, 0x77, 0x79, 0x38, 0xd5,
+	0xff, 0xa9, 0xe1, 0xde, 0x15, 0xc3, 0x64, 0xb6, 0x10, 0x92, 0xf9, 0x13, 0xb9, 0x0c, 0xa9, 0x48,
+	0x59, 0x77, 0xe6, 0x8c, 0xcd, 0x3d, 0x3a, 0x54, 0xbb, 0xe9, 0xe2, 0x78, 0x48, 0x82, 0xa5, 0x36,
+	0xd9, 0x4f, 0xa0, 0x7b, 0xc8, 0x99, 0x4f, 0xe5, 0x09, 0x5d, 0x88, 0x7d, 0x4a, 0x1c, 0xca, 0xd1,
+	0x1d, 0xa8, 0x7d, 0x49, 0x7c, 0xda, 0x33, 0xfa, 0xc6, 0x76, 0x7b, 0x54, 0x8f, 0x23, 0xcb, 0x78,
+	0x0f, 0x2b, 0x08, 0xbd, 0x05, 0x8d, 0x6f, 0x88, 0xb7, 0xa0, 0xa2, 0xb7, 0xd6, 0xaf, 0x16, 0xc6,
+	0x14, 0xb4, 0xff, 0x59, 0x03, 0x54, 0xb8, 0xc3, 0x54, 0x84, 0x2c, 0x10, 0x14, 0xd9, 0xd0, 0x18,
+	0x4b, 0x22, 0x17, 0x22, 0x75, 0x09, 0x71, 0x64, 0x35, 0x84, 0x42, 0x70, 0x6a, 0x41, 0x23, 0xa8,
+	0x3d, 0x26, 0x92, 0xf4, 0xd6, 0xfa, 0xc6, 0x76, 0x67, 0xe7, 0xee, 0xa0, 0xc8, 0xc9, 0xa0, 0xf0,
+	0x98, 0x30, 0x46, 0x28, 0x8e, 0xac, 0x0d, 0x87, 0x48, 0x72, 0x9f, 0xf9, 0xae, 0xa4, 0x7e, 0x28,
+	0x97, 0x58, 0x69, 0xd1, 0x87, 0xd0, 0xde, 0xe3, 0x9c, 0xf1, 0xa3, 0x65, 0x48, 0x7b, 0x55, 0x75,
+	0xd4, 0xed, 0x38, 0xb2, 0x6e, 0xd2, 0x0c, 0x2c, 0x29, 0x0a, 0x26, 0x7a, 0x1b, 0xea, 0x6a, 0xd3,
+	0xab, 0x29, 0xc9, 0xcd, 0x38, 0xb2, 0x36, 0x95, 0xa4, 0x44, 0xd7, 0x0c, 0xf4, 0x00, 0x9a, 0x3a,
+	0x49, 0xa2, 0x57, 0xef, 0x57, 0xb7, 0x3b, 0x3b, 0xff, 0xbf, 0x3e, 0x50, 0x4d, 0xca, 0xd2, 0x93,
+	0x69, 0xd0, 0x0e, 0xb4, 0xbe, 0x25, 0x3c, 0x70, 0x83, 0xb9, 0xe8, 0x35, 0x54, 0x02, 0x6f, 0xc5,
+	0x91, 0x85, 0x5e, 0xa4, 0x58, 0xe9, 0xbc, 0x9c, 0x97, 0x44, 0x77, 0x10, 0x1c, 0x33, 0xd1, 0x6b,
+	0x2a, 0x81, 0x8a, 0xce, 0x4d, 0x80, 0x72, 0x74, 0x8a, 0x61, 0xff, 0x64, 0xc0, 0xc6, 0xc5, 0x64,
+	0xa1, 0x01, 0x00, 0xa6, 0x62, 0xe1, 0x49, 0x95, 0x13, 0x9d, 0xfe, 0x8d, 0x38, 0xb2, 0x80, 0xe7,
+	0x28, 0x2e, 0x31, 0xd0, 0xa7, 0xd0, 0xd0, 0x3b, 0x55, 0xe0, 0xce, 0x4e, 0xaf, 0x7c, 0xbf, 0x31,
+	0xf1, 0x43, 0x8f, 0x8e, 0x25, 0xa7, 0xc4, 0x1f, 0x6d, 0xbc, 0x8a, 0xac, 0x4a, 0x52, 0x48, 0xed,
+	0x09, 0xa7, 0x3a, 0xfb, 0x0f, 0x03, 0xd6, 0xcb, 0x44, 0xf4, 0x10, 0x1a, 0x1e, 0x99, 0x52, 0x2f,
+	0xa9, 0x7e, 0xe2, 0xf2, 0xd6, 0x60, 0xc6, 0xb8, 0xa4, 0x2f, 0xc3, 0xe9, 0xe0, 0x49, 0x82, 0x3f,
+	0x72, 0x48, 0x28, 0x29, 0x2f, 0x1c, 0xfa, 0x54, 0x72, 0x77, 0x86, 0x53, 0x15, 0xfa, 0x18, 0x9a,
+	0x42, 0xf9, 0x13, 0x69, 0x4c, 0xdd, 0xc2, 0x81, 0x3e, 0xa8, 0x90, 0x3e, 0x57, 0x7d, 0x88, 0x33,
+	0x01, 0x3a, 0x04, 0x38, 0x71, 0x85, 0x64, 0x73, 0x4e, 0x7c, 0xd1, 0xab, 0xa6, 0x25, 0xcb, 0xe5,
+	0x9f, 0x79, 0x8c, 0xc8, 0xfd, 0x8c, 0x70, 0x48, 0x5c, 0x3e, 0x42, 0xa9, 0xab, 0x92, 0x0e, 0x97,
+	0xd6, 0xf6, 0xcf, 0x06, 0x74, 0x76, 0xc9, 0xec, 0x84, 0x3a, 0xba, 0x23, 0xee, 0x40, 0xf5, 0x19,
+	0x5d, 0xa6, 0x99, 0x6d, 0xc6, 0x91, 0x95, 0x6c, 0x71, 0xf2, 0x83, 0xde, 0x85, 0x76, 0xde, 0x79,
+	0xaa, 0xaf, 0xdb, 0xa3, 0x1b, 0x71, 0x64, 0x15, 0x20, 0x2e, 0x96, 0xe8, 0x03, 0x58, 0x57, 0x9b,
+	0xa7, 0x54, 0x08, 0x32, 0xcf, 0xda, 0xb7, 0x1b, 0x47, 0xd6, 0x05, 0x1c, 0x5f, 0xd8, 0xd9, 0xdf,
+	0xc3, 0x86, 0x0e, 0x26, 0x7f, 0x6b, 0xff, 0x11, 0xcf, 0x03, 0x68, 0xd2, 0x97, 0x92, 0x06, 0x32,
+	0x4b, 0x24, 0x2a, 0x17, 0x77, 0x4f, 0x99, 0x46, 0x9b, 0xe9, 0xfd, 0x33, 0x2a, 0xce, 0x16, 0xf6,
+	0xef, 0x06, 0x34, 0x34, 0x09, 0x59, 0x50, 0x17, 0x92, 0x70, 0xa9, 0x8e, 0xa9, 0x8e, 0xda, 0x71,
+	0x64, 0x69, 0x00, 0xeb, 0xbf, 0x24, 0x0a, 0x1a, 0x38, 0xea, 0xd2, 0x55, 0x1d, 0x05, 0x0d, 0x1c,
+	0x9c, 0xfc, 0xa0, 0x3e, 0xb4, 0x24, 0x27, 0x33, 0x3a, 0x71, 0x9d, 0xf4, 0xc1, 0x65, 0xaf, 0x44,
+	0xc1, 0x07, 0x0e, 0x7a, 0x08, 0x2d, 0x9e, 0x5e, 0xa7, 0x57, 0x57, 0xe3, 0x60, 0x6b, 0xa0, 0x27,
+	0xd8, 0x20, 0x9b, 0x60, 0x83, 0x47, 0xc1, 0x72, 0xb4, 0x1e, 0x47, 0x56, 0xce, 0xc4, 0xf9, 0x0a,
+	0xdd, 0x07, 0xa4, 0xee, 0x35, 0x91, 0xae, 0x4f, 0x85, 0x24, 0x7e, 0x38, 0xf1, 0x93, 0xf7, 0x66,
+	0x6c, 0x57, 0x71, 0x57, 0x59, 0x8e, 0x32, 0xc3, 0x53, 0xf1, 0x79, 0xad, 0x55, 0xed, 0xd6, 0xec,
+	0xbf, 0x0c, 0x68, 0x7e, 0x15, 0x4a, 0x97, 0x05, 0x02, 0xdd, 0x83, 0x1b, 0x2a, 0xa9, 0x8f, 0x5d,
+	0x41, 0xa6, 0x1e, 0x75, 0xd4, 0x2d, 0x5b, 0xf8, 0x22, 0x88, 0xde, 0x81, 0xee, 0xf8, 0x84, 0x70,
+	0xc7, 0x0d, 0xe6, 0x39, 0x71, 0x4d, 0x11, 0xaf, 0xe0, 0xa8, 0x0f, 0x9d, 0x23, 0x26, 0x89, 0xa7,
+	0x0c, 0x42, 0xd5, 0xb6, 0x8e, 0xcb, 0x10, 0xda, 0x81, 0xad, 0x83, 0x40, 0x48, 0x12, 0xc8, 0x71,
+	0xe8, 0xb9, 0x32, 0xf7, 0x58, 0x53, 0x1e, 0xaf, 0xb5, 0x5d, 0xd6, 0x1c, 0x04, 0x92, 0xf2, 0xe7,
+	0xc4, 0x53, 0x39, 0xab, 0xe2, 0x6b, 0x6d, 0xf6, 0x1e, 0x6c, 0x7e, 0x9d, 0x64, 0x20, 0x99, 0xba,
+	0xae, 0x90, 0xee, 0x4c, 0x1d, 0xbd, 0x27, 0xa4, 0xeb, 0x13, 0x49, 0x9d, 0x31, 0xe5, 0x2e, 0x15,
+	0xbb, 0x6c, 0x11, 0xe8, 0xda, 0xd6, 0xf0, 0xb5, 0x36, 0xfb, 0x57, 0x03, 0x90, 0x6e, 0xbc, 0xfd,
+	0xa3, 0xa3, 0xc3, 0xbc, 0xf9, 0xfe, 0x07, 0xed, 0x59, 0x82, 0x4e, 0xf2, 0x16, 0xc4, 0x2d, 0x05,
+	0x7c, 0x41, 0x97, 0xc8, 0x82, 0x8e, 0x9e, 0xf9, 0x93, 0x19, 0x73, 0xf4, 0x83, 0xa8, 0x63, 0xd0,
+	0xd0, 0x2e, 0x73, 0x28, 0xfa, 0x08, 0x9a, 0x27, 0xe9, 0x70, 0xad, 0x5e, 0x1d, 0xae, 0xc5, 0x71,
+	0x7a, 0x9a, 0xe2, 0x8c, 0x8c, 0x10, 0xd4, 0xa6, 0xcc, 0x59, 0xaa, 0x5c, 0xad, 0x63, 0xb5, 0xb6,
+	0x3f, 0x81, 0xee, 0x65, 0x41, 0xc2, 0x0b, 0xf2, 0xef, 0x1a, 0x56, 0x6b, 0xb4, 0x05, 0x75, 0x35,
+	0x33, 0xf4, 0xfb, 0xc4, 0x7a, 0x33, 0xda, 0x3b, 0x3d, 0x33, 0x2b, 0xaf, 0xcf, 0xcc, 0xca, 0x9b,
+	0x33, 0xd3, 0xf8, 0x71, 0x65, 0x1a, 0xbf, 0xad, 0x4c, 0xe3, 0xd5, 0xca, 0x34, 0x4e, 0x57, 0xa6,
+	0xf1, 0xe7, 0xca, 0x34, 0xfe, 0x5e, 0x99, 0x95, 0x37, 0x2b, 0xd3, 0xf8, 0xe5, 0xdc, 0xac, 0x9c,
+	0x9e, 0x9b, 0x95, 0xd7, 0xe7, 0x66, 0xe5, 0xbb, 0xcd, 0x4b, 0x1f, 0xf9, 0x69, 0x43, 0xb5, 0xeb,
+	0xfb, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x2a, 0xd8, 0xe8, 0xaf, 0x0b, 0x08, 0x00, 0x00,
 }
 
 func (this *PrometheusHeader) Equal(that interface{}) bool {
@@ -940,7 +947,7 @@ func (this *SampleStream) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -1239,7 +1246,13 @@ func (this *SampleStream) GoString() string {
 	}
 	s := make([]string, 0, 7)
 	s = append(s, "&querymiddleware.SampleStream{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	if this.Samples != nil {
 		vs := make([]*mimirpb.Sample, len(this.Samples))
 		for i := range vs {
@@ -1582,11 +1595,11 @@ func (m *SampleStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintModel(dAtA, i, uint64(size))
 			}
 			i--
@@ -2247,6 +2260,11 @@ func (this *SampleStream) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	repeatedStringForSamples := "[]Sample{"
 	for _, f := range this.Samples {
 		repeatedStringForSamples += fmt.Sprintf("%v", f) + ","
@@ -2258,7 +2276,7 @@ func (this *SampleStream) String() string {
 	}
 	repeatedStringForHistograms += "}"
 	s := strings.Join([]string{`&SampleStream{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`Samples:` + repeatedStringForSamples + `,`,
 		`Histograms:` + repeatedStringForHistograms + `,`,
 		`}`,
@@ -2945,7 +2963,7 @@ func (m *SampleStream) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/frontend/querymiddleware/model.proto b/pkg/frontend/querymiddleware/model.proto
index 0a4951cfcd5..54ad527f4fe 100644
--- a/pkg/frontend/querymiddleware/model.proto
+++ b/pkg/frontend/querymiddleware/model.proto
@@ -10,8 +10,9 @@ package queryrange;
 
 option go_package = "querymiddleware";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 import "google/protobuf/any.proto";
 
 option (gogoproto.marshaler_all) = true;
@@ -38,7 +39,7 @@ message PrometheusData {
 }
 
 message SampleStream {
-  repeated cortexpb.LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "metric", (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"];
+  repeated cortexpb.LabelAdapter labels = 1 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "metric"];
   repeated cortexpb.Sample samples = 2 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "values"];
   repeated cortexpb.FloatHistogramPair histograms = 3 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "histograms"];
 }
diff --git a/pkg/frontend/v1/frontendv1pb/frontend.pb.go b/pkg/frontend/v1/frontendv1pb/frontend.pb.go
index 305178a0d45..158f89f950b 100644
--- a/pkg/frontend/v1/frontendv1pb/frontend.pb.go
+++ b/pkg/frontend/v1/frontendv1pb/frontend.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: frontend.proto
+// source: pkg/frontend/v1/frontendv1pb/frontend.proto
 
 // Protobuf package should not be changed when moving around go packages
 // in order to not break backward compatibility.
@@ -12,13 +12,13 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	httpgrpc "github.com/grafana/dskit/httpgrpc"
-	stats "github.com/grafana/mimir/pkg/querier/stats"
 	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"
+	stats "pkg/querier/stats"
 	reflect "reflect"
 	strconv "strconv"
 	strings "strings"
@@ -53,12 +53,12 @@ var Type_value = map[string]int32{
 }
 
 func (Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{0}
+	return fileDescriptor_c0c8bcb817149daf, []int{0}
 }
 
 type FrontendToClient struct {
 	HttpRequest *httpgrpc.HTTPRequest `protobuf:"bytes,1,opt,name=httpRequest,proto3" json:"httpRequest,omitempty"`
-	Type        Type                  `protobuf:"varint,2,opt,name=type,proto3,enum=frontend.Type" json:"type,omitempty"`
+	Type        Type                  `protobuf:"varint,2,opt,name=type,proto3,enum=frontendv1pb.Type" json:"type,omitempty"`
 	// Whether query statistics tracking should be enabled. The response will include
 	// statistics only when this option is enabled.
 	StatsEnabled bool `protobuf:"varint,3,opt,name=statsEnabled,proto3" json:"statsEnabled,omitempty"`
@@ -69,7 +69,7 @@ type FrontendToClient struct {
 func (m *FrontendToClient) Reset()      { *m = FrontendToClient{} }
 func (*FrontendToClient) ProtoMessage() {}
 func (*FrontendToClient) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{0}
+	return fileDescriptor_c0c8bcb817149daf, []int{0}
 }
 func (m *FrontendToClient) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -135,7 +135,7 @@ type ClientToFrontend struct {
 func (m *ClientToFrontend) Reset()      { *m = ClientToFrontend{} }
 func (*ClientToFrontend) ProtoMessage() {}
 func (*ClientToFrontend) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{1}
+	return fileDescriptor_c0c8bcb817149daf, []int{1}
 }
 func (m *ClientToFrontend) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -192,7 +192,7 @@ type NotifyClientShutdownRequest struct {
 func (m *NotifyClientShutdownRequest) Reset()      { *m = NotifyClientShutdownRequest{} }
 func (*NotifyClientShutdownRequest) ProtoMessage() {}
 func (*NotifyClientShutdownRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{2}
+	return fileDescriptor_c0c8bcb817149daf, []int{2}
 }
 func (m *NotifyClientShutdownRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -234,7 +234,7 @@ type NotifyClientShutdownResponse struct {
 func (m *NotifyClientShutdownResponse) Reset()      { *m = NotifyClientShutdownResponse{} }
 func (*NotifyClientShutdownResponse) ProtoMessage() {}
 func (*NotifyClientShutdownResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{3}
+	return fileDescriptor_c0c8bcb817149daf, []int{3}
 }
 func (m *NotifyClientShutdownResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -264,49 +264,51 @@ func (m *NotifyClientShutdownResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_NotifyClientShutdownResponse proto.InternalMessageInfo
 
 func init() {
-	proto.RegisterEnum("frontend.Type", Type_name, Type_value)
-	proto.RegisterType((*FrontendToClient)(nil), "frontend.FrontendToClient")
-	proto.RegisterType((*ClientToFrontend)(nil), "frontend.ClientToFrontend")
-	proto.RegisterType((*NotifyClientShutdownRequest)(nil), "frontend.NotifyClientShutdownRequest")
-	proto.RegisterType((*NotifyClientShutdownResponse)(nil), "frontend.NotifyClientShutdownResponse")
-}
-
-func init() { proto.RegisterFile("frontend.proto", fileDescriptor_eca3873955a29cfe) }
-
-var fileDescriptor_eca3873955a29cfe = []byte{
-	// 498 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0x41, 0x6e, 0xd3, 0x40,
-	0x14, 0x86, 0xfd, 0x68, 0x28, 0xe1, 0xc5, 0x8a, 0xac, 0x51, 0x41, 0x91, 0x41, 0xa3, 0xc8, 0x82,
-	0xca, 0x62, 0x61, 0x97, 0x20, 0x81, 0x60, 0x59, 0x1a, 0x4a, 0x37, 0x55, 0x71, 0xcc, 0x86, 0x4d,
-	0xe5, 0x24, 0x13, 0xc7, 0x6a, 0xe3, 0x71, 0xec, 0x31, 0x28, 0x3b, 0x4e, 0x80, 0x38, 0x06, 0x67,
-	0x80, 0x0b, 0xb0, 0xcc, 0xb2, 0x4b, 0xe2, 0x6c, 0x58, 0xf6, 0x08, 0xc8, 0x9e, 0xc4, 0x4d, 0xa2,
-	0x88, 0x6e, 0x46, 0x33, 0xf3, 0xbf, 0xf7, 0xfc, 0xfd, 0xbf, 0x07, 0xeb, 0x83, 0x98, 0x87, 0x82,
-	0x85, 0x7d, 0x2b, 0x8a, 0xb9, 0xe0, 0xa4, 0xba, 0x3c, 0xeb, 0x7b, 0x3e, 0xf7, 0x79, 0x71, 0x69,
-	0xe7, 0x3b, 0xa9, 0xeb, 0x07, 0x7e, 0x20, 0x86, 0x69, 0xd7, 0xea, 0xf1, 0x91, 0xed, 0xc7, 0xde,
-	0xc0, 0x0b, 0x3d, 0xbb, 0x9f, 0x5c, 0x04, 0xc2, 0x1e, 0x0a, 0x11, 0xf9, 0x71, 0xd4, 0x2b, 0x37,
-	0x8b, 0x8e, 0x97, 0x5b, 0x3a, 0x46, 0xc1, 0x28, 0x88, 0xed, 0xe8, 0xc2, 0xb7, 0xc7, 0x29, 0x8b,
-	0x03, 0x16, 0xdb, 0x89, 0xf0, 0x44, 0x22, 0x57, 0xd9, 0x67, 0xfc, 0x02, 0xd4, 0xde, 0x2d, 0x60,
-	0x5c, 0xfe, 0xf6, 0x32, 0x60, 0xa1, 0x20, 0xaf, 0xb0, 0x96, 0x8f, 0x77, 0xd8, 0x38, 0x65, 0x89,
-	0x68, 0x40, 0x13, 0xcc, 0x5a, 0xeb, 0x81, 0x55, 0x7e, 0xf2, 0xbd, 0xeb, 0x9e, 0x2d, 0x44, 0x67,
-	0xb5, 0x92, 0x18, 0x58, 0x11, 0x93, 0x88, 0x35, 0xee, 0x34, 0xc1, 0xac, 0xb7, 0xea, 0x56, 0x69,
-	0xdb, 0x9d, 0x44, 0xcc, 0x29, 0x34, 0x62, 0xa0, 0x5a, 0x00, 0xb4, 0x43, 0xaf, 0x7b, 0xc9, 0xfa,
-	0x8d, 0x9d, 0x26, 0x98, 0x55, 0x67, 0xed, 0x8e, 0xec, 0x63, 0x7d, 0x9c, 0xb2, 0x94, 0xb9, 0xc1,
-	0x88, 0x9d, 0x7a, 0x21, 0x4f, 0x1a, 0x95, 0x26, 0x98, 0x3b, 0xce, 0xc6, 0xad, 0xf1, 0x0d, 0x50,
-	0x93, 0xcc, 0x2e, 0x5f, 0xba, 0x20, 0x6f, 0x50, 0x95, 0x4c, 0x49, 0xc4, 0xc3, 0x84, 0x2d, 0xf0,
-	0x1f, 0x6e, 0xe2, 0x4b, 0xd5, 0x59, 0xab, 0x25, 0x3a, 0x56, 0x7b, 0xc5, 0xbc, 0x93, 0xa3, 0xc2,
-	0xc4, 0x7d, 0xa7, 0x3c, 0x13, 0x03, 0xef, 0x16, 0x90, 0x05, 0x71, 0xad, 0xa5, 0x5a, 0x32, 0xc7,
-	0x4e, 0xbe, 0x3a, 0x52, 0x32, 0x5e, 0xe3, 0xa3, 0x53, 0x2e, 0x82, 0xc1, 0x44, 0x52, 0x75, 0x86,
-	0xa9, 0xe8, 0xf3, 0x2f, 0xe1, 0x32, 0x9f, 0xd5, 0xf1, 0xb0, 0x3e, 0xde, 0xa0, 0xf8, 0x78, 0x7b,
-	0xab, 0x44, 0x7b, 0xf6, 0x04, 0x2b, 0x79, 0x8a, 0x44, 0x43, 0x35, 0x37, 0x70, 0xee, 0xb4, 0x3f,
-	0x7c, 0x6c, 0x77, 0x5c, 0x4d, 0x21, 0x88, 0xbb, 0xc7, 0x6d, 0xf7, 0xfc, 0xe4, 0x48, 0x83, 0xd6,
-	0x4f, 0xc0, 0x6a, 0x99, 0xc4, 0x31, 0xde, 0x3b, 0x8b, 0x79, 0x8f, 0x25, 0x09, 0xd1, 0x6f, 0xfe,
-	0xc5, 0x66, 0x60, 0xfa, 0x8a, 0xb6, 0xf9, 0x14, 0x0c, 0xc5, 0x84, 0x03, 0x20, 0x0c, 0xf7, 0xb6,
-	0xb1, 0x91, 0xa7, 0x37, 0x9d, 0xff, 0xb1, 0xad, 0xef, 0xdf, 0x56, 0x26, 0x2d, 0x1e, 0x1e, 0x4e,
-	0x67, 0x54, 0xb9, 0x9a, 0x51, 0xe5, 0x7a, 0x46, 0xe1, 0x6b, 0x46, 0xe1, 0x47, 0x46, 0xe1, 0x77,
-	0x46, 0x61, 0x9a, 0x51, 0xf8, 0x93, 0x51, 0xf8, 0x9b, 0x51, 0xe5, 0x3a, 0xa3, 0xf0, 0x7d, 0x4e,
-	0x95, 0xe9, 0x9c, 0x2a, 0x57, 0x73, 0xaa, 0x7c, 0x52, 0x97, 0xc3, 0x3f, 0x3f, 0x8f, 0xba, 0xdd,
-	0xdd, 0xe2, 0x5d, 0xbf, 0xf8, 0x17, 0x00, 0x00, 0xff, 0xff, 0x90, 0xf8, 0xe3, 0x38, 0x73, 0x03,
-	0x00, 0x00,
+	proto.RegisterEnum("frontendv1pb.Type", Type_name, Type_value)
+	proto.RegisterType((*FrontendToClient)(nil), "frontendv1pb.FrontendToClient")
+	proto.RegisterType((*ClientToFrontend)(nil), "frontendv1pb.ClientToFrontend")
+	proto.RegisterType((*NotifyClientShutdownRequest)(nil), "frontendv1pb.NotifyClientShutdownRequest")
+	proto.RegisterType((*NotifyClientShutdownResponse)(nil), "frontendv1pb.NotifyClientShutdownResponse")
+}
+
+func init() {
+	proto.RegisterFile("pkg/frontend/v1/frontendv1pb/frontend.proto", fileDescriptor_c0c8bcb817149daf)
+}
+
+var fileDescriptor_c0c8bcb817149daf = []byte{
+	// 500 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
+	0x10, 0xf5, 0xd0, 0x50, 0xc2, 0x24, 0xaa, 0xac, 0x55, 0x41, 0x91, 0x81, 0x55, 0x64, 0xa1, 0xca,
+	0x14, 0xc9, 0x6e, 0xc3, 0x01, 0xc1, 0xb1, 0x34, 0x40, 0x2f, 0xa5, 0x38, 0xe6, 0xc2, 0xa5, 0x72,
+	0x92, 0x8d, 0x63, 0xb5, 0xf1, 0x3a, 0xf6, 0xba, 0x28, 0x37, 0xbe, 0x00, 0xf1, 0x19, 0xfc, 0x05,
+	0x57, 0xc4, 0x29, 0xc7, 0x1e, 0x89, 0x73, 0xe1, 0xd8, 0x4f, 0x40, 0xf6, 0xa6, 0x56, 0x6c, 0x55,
+	0xa8, 0x97, 0xd5, 0xec, 0xbe, 0x99, 0xe7, 0xf7, 0x9e, 0x77, 0xf1, 0x79, 0x78, 0xe6, 0x59, 0xa3,
+	0x88, 0x07, 0x82, 0x05, 0x43, 0xeb, 0x62, 0xbf, 0xa8, 0x2f, 0xf6, 0xc3, 0x7e, 0xb1, 0x31, 0xc3,
+	0x88, 0x0b, 0x4e, 0x9a, 0xeb, 0xa0, 0xb6, 0xed, 0x71, 0x8f, 0xe7, 0x80, 0x95, 0x55, 0xb2, 0x47,
+	0xdb, 0xf3, 0x7c, 0x31, 0x4e, 0xfa, 0xe6, 0x80, 0x4f, 0x2c, 0x2f, 0x72, 0x47, 0x6e, 0xe0, 0x5a,
+	0xc3, 0xf8, 0xcc, 0x17, 0xd6, 0x58, 0x88, 0xd0, 0x8b, 0xc2, 0x41, 0x51, 0xac, 0x26, 0x9e, 0x64,
+	0x12, 0xa6, 0x09, 0x8b, 0x7c, 0x16, 0x59, 0xb1, 0x70, 0x45, 0x2c, 0x57, 0x09, 0xeb, 0x3f, 0x01,
+	0xd5, 0xb7, 0xab, 0xef, 0x3a, 0xfc, 0xcd, 0xb9, 0xcf, 0x02, 0x41, 0x5e, 0x62, 0x23, 0x63, 0xb1,
+	0xd9, 0x34, 0x61, 0xb1, 0x68, 0x41, 0x1b, 0x8c, 0x46, 0xe7, 0x81, 0x59, 0x30, 0xbf, 0x77, 0x9c,
+	0x93, 0x15, 0x68, 0xaf, 0x77, 0x92, 0x1d, 0xac, 0x89, 0x59, 0xc8, 0x5a, 0x77, 0xda, 0x60, 0x6c,
+	0x75, 0x88, 0xb9, 0xee, 0xc8, 0x74, 0x66, 0x21, 0xb3, 0x73, 0x9c, 0xe8, 0xd8, 0xcc, 0x45, 0x74,
+	0x03, 0xb7, 0x7f, 0xce, 0x86, 0xad, 0x8d, 0x36, 0x18, 0x75, 0xbb, 0x74, 0x46, 0x76, 0x70, 0x6b,
+	0x9a, 0xb0, 0x84, 0x39, 0xfe, 0x84, 0x1d, 0xbb, 0x01, 0x8f, 0x5b, 0xb5, 0x36, 0x18, 0x1b, 0x76,
+	0xe5, 0x54, 0xff, 0x06, 0xa8, 0x4a, 0xdd, 0x0e, 0xbf, 0x76, 0x42, 0x5e, 0x63, 0x53, 0xea, 0x8a,
+	0x43, 0x1e, 0xc4, 0x6c, 0x65, 0xe1, 0x61, 0xd5, 0x82, 0x44, 0xed, 0x52, 0x2f, 0xd1, 0xb0, 0x3e,
+	0xc8, 0xf9, 0x8e, 0x0e, 0x73, 0x23, 0xf7, 0xed, 0x62, 0x4f, 0x74, 0xbc, 0x9b, 0x8b, 0xcc, 0x15,
+	0x37, 0x3a, 0x4d, 0x53, 0x66, 0xd9, 0xcb, 0x56, 0x5b, 0x42, 0xfa, 0x2b, 0x7c, 0x74, 0xcc, 0x85,
+	0x3f, 0x9a, 0x49, 0x55, 0xbd, 0x71, 0x22, 0x86, 0xfc, 0x4b, 0x70, 0x9d, 0xd1, 0x3a, 0x3d, 0x94,
+	0xe9, 0x75, 0x8a, 0x8f, 0x6f, 0x1e, 0x95, 0xd2, 0x76, 0x9f, 0x62, 0x2d, 0x4b, 0x91, 0xa8, 0xd8,
+	0xcc, 0x0c, 0x9c, 0xda, 0xdd, 0x8f, 0x9f, 0xba, 0x3d, 0x47, 0x55, 0x08, 0xe2, 0xe6, 0xbb, 0xae,
+	0x73, 0x7a, 0x74, 0xa8, 0x42, 0xe7, 0x37, 0x60, 0xbd, 0x48, 0xe2, 0x03, 0xde, 0x3b, 0x89, 0xf8,
+	0x80, 0xc5, 0x31, 0xa1, 0xe5, 0xff, 0x51, 0x0d, 0x4d, 0xab, 0xe0, 0xd5, 0x6b, 0xa1, 0x2b, 0x06,
+	0xec, 0x01, 0x99, 0xe0, 0xf6, 0x4d, 0x1a, 0xc9, 0xb3, 0xf2, 0xf4, 0x7f, 0x22, 0xd0, 0x76, 0x6f,
+	0xd3, 0x2a, 0x2d, 0x1f, 0x1c, 0xcc, 0x17, 0x54, 0xb9, 0x5c, 0x50, 0xe5, 0x6a, 0x41, 0xe1, 0x6b,
+	0x4a, 0xe1, 0x47, 0x4a, 0xe1, 0x57, 0x4a, 0x61, 0x9e, 0x52, 0xf8, 0x93, 0x52, 0xf8, 0x9b, 0x52,
+	0xe5, 0x2a, 0xa5, 0xf0, 0x7d, 0x49, 0x95, 0xf9, 0x92, 0x2a, 0x97, 0x4b, 0xaa, 0x7c, 0x2e, 0xbd,
+	0xa5, 0xfe, 0x66, 0x7e, 0xd7, 0x5f, 0xfc, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x72, 0xa2, 0x43, 0xae,
+	0x8f, 0x03, 0x00, 0x00,
 }
 
 func (x Type) String() string {
@@ -511,7 +513,7 @@ func NewFrontendClient(cc *grpc.ClientConn) FrontendClient {
 }
 
 func (c *frontendClient) Process(ctx context.Context, opts ...grpc.CallOption) (Frontend_ProcessClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_Frontend_serviceDesc.Streams[0], "/frontend.Frontend/Process", opts...)
+	stream, err := c.cc.NewStream(ctx, &_Frontend_serviceDesc.Streams[0], "/frontendv1pb.Frontend/Process", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -543,7 +545,7 @@ func (x *frontendProcessClient) Recv() (*FrontendToClient, error) {
 
 func (c *frontendClient) NotifyClientShutdown(ctx context.Context, in *NotifyClientShutdownRequest, opts ...grpc.CallOption) (*NotifyClientShutdownResponse, error) {
 	out := new(NotifyClientShutdownResponse)
-	err := c.cc.Invoke(ctx, "/frontend.Frontend/NotifyClientShutdown", in, out, opts...)
+	err := c.cc.Invoke(ctx, "/frontendv1pb.Frontend/NotifyClientShutdown", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -610,7 +612,7 @@ func _Frontend_NotifyClientShutdown_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/frontend.Frontend/NotifyClientShutdown",
+		FullMethod: "/frontendv1pb.Frontend/NotifyClientShutdown",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(FrontendServer).NotifyClientShutdown(ctx, req.(*NotifyClientShutdownRequest))
@@ -619,7 +621,7 @@ func _Frontend_NotifyClientShutdown_Handler(srv interface{}, ctx context.Context
 }
 
 var _Frontend_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "frontend.Frontend",
+	ServiceName: "frontendv1pb.Frontend",
 	HandlerType: (*FrontendServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
@@ -635,7 +637,7 @@ var _Frontend_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 	},
-	Metadata: "frontend.proto",
+	Metadata: "pkg/frontend/v1/frontendv1pb/frontend.proto",
 }
 
 func (m *FrontendToClient) Marshal() (dAtA []byte, err error) {
diff --git a/pkg/frontend/v1/frontendv1pb/frontend.proto b/pkg/frontend/v1/frontendv1pb/frontend.proto
index c232c985455..ced62f4eafb 100644
--- a/pkg/frontend/v1/frontendv1pb/frontend.proto
+++ b/pkg/frontend/v1/frontendv1pb/frontend.proto
@@ -7,13 +7,13 @@ syntax = "proto3";
 
 // Protobuf package should not be changed when moving around go packages
 // in order to not break backward compatibility.
-package frontend;
+package frontendv1pb;
 
 option go_package = "frontendv1pb";
 
 import "gogoproto/gogo.proto";
 import "github.com/grafana/dskit/httpgrpc/httpgrpc.proto";
-import "github.com/grafana/mimir/pkg/querier/stats/stats.proto";
+import "pkg/querier/stats/stats.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
diff --git a/pkg/frontend/v2/frontendv2pb/frontend.pb.go b/pkg/frontend/v2/frontendv2pb/frontend.pb.go
index c861bdb1da9..2b43dc6f0e9 100644
--- a/pkg/frontend/v2/frontendv2pb/frontend.pb.go
+++ b/pkg/frontend/v2/frontendv2pb/frontend.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: frontend.proto
+// source: pkg/frontend/v2/frontendv2pb/frontend.proto
 
 package frontendv2pb
 
@@ -10,13 +10,13 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	httpgrpc "github.com/grafana/dskit/httpgrpc"
-	stats "github.com/grafana/mimir/pkg/querier/stats"
 	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"
+	stats "pkg/querier/stats"
 	reflect "reflect"
 	strings "strings"
 )
@@ -41,7 +41,7 @@ type QueryResultRequest struct {
 func (m *QueryResultRequest) Reset()      { *m = QueryResultRequest{} }
 func (*QueryResultRequest) ProtoMessage() {}
 func (*QueryResultRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{0}
+	return fileDescriptor_b3ea5a9cadd775d4, []int{0}
 }
 func (m *QueryResultRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -102,7 +102,7 @@ type QueryResultStreamRequest struct {
 func (m *QueryResultStreamRequest) Reset()      { *m = QueryResultStreamRequest{} }
 func (*QueryResultStreamRequest) ProtoMessage() {}
 func (*QueryResultStreamRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{1}
+	return fileDescriptor_b3ea5a9cadd775d4, []int{1}
 }
 func (m *QueryResultStreamRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -193,7 +193,7 @@ type QueryResultMetadata struct {
 func (m *QueryResultMetadata) Reset()      { *m = QueryResultMetadata{} }
 func (*QueryResultMetadata) ProtoMessage() {}
 func (*QueryResultMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{2}
+	return fileDescriptor_b3ea5a9cadd775d4, []int{2}
 }
 func (m *QueryResultMetadata) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -250,7 +250,7 @@ type QueryResultBody struct {
 func (m *QueryResultBody) Reset()      { *m = QueryResultBody{} }
 func (*QueryResultBody) ProtoMessage() {}
 func (*QueryResultBody) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{3}
+	return fileDescriptor_b3ea5a9cadd775d4, []int{3}
 }
 func (m *QueryResultBody) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -292,7 +292,7 @@ type QueryResultResponse struct {
 func (m *QueryResultResponse) Reset()      { *m = QueryResultResponse{} }
 func (*QueryResultResponse) ProtoMessage() {}
 func (*QueryResultResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_eca3873955a29cfe, []int{4}
+	return fileDescriptor_b3ea5a9cadd775d4, []int{4}
 }
 func (m *QueryResultResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -329,40 +329,42 @@ func init() {
 	proto.RegisterType((*QueryResultResponse)(nil), "frontendv2pb.QueryResultResponse")
 }
 
-func init() { proto.RegisterFile("frontend.proto", fileDescriptor_eca3873955a29cfe) }
-
-var fileDescriptor_eca3873955a29cfe = []byte{
-	// 480 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0x6e, 0xd3, 0x40,
-	0x10, 0xc6, 0xbd, 0x6d, 0xd2, 0xa2, 0x49, 0xc4, 0x9f, 0xa5, 0x20, 0x2b, 0x12, 0xab, 0xd4, 0x07,
-	0x88, 0x38, 0xd8, 0x28, 0x95, 0x38, 0x70, 0x41, 0x8a, 0x50, 0x15, 0x0e, 0x48, 0x74, 0x9b, 0x13,
-	0xb7, 0x75, 0xbc, 0x75, 0xac, 0x60, 0xaf, 0xbb, 0x5e, 0x23, 0xf9, 0xc6, 0x13, 0x20, 0x1e, 0x83,
-	0x33, 0x4f, 0xc1, 0x09, 0xe5, 0xd8, 0x23, 0x71, 0x2e, 0x1c, 0xfb, 0x08, 0xc8, 0x6b, 0x3b, 0x72,
-	0xa0, 0xa1, 0xb9, 0xac, 0x66, 0x34, 0xdf, 0xb7, 0xf3, 0xf3, 0x8c, 0x17, 0xee, 0x5e, 0x48, 0x11,
-	0x29, 0x1e, 0x79, 0x76, 0x2c, 0x85, 0x12, 0xb8, 0x5b, 0xe7, 0x9f, 0x86, 0xb1, 0xdb, 0x3b, 0xf2,
-	0x85, 0x2f, 0x74, 0xc1, 0x29, 0xa2, 0x52, 0xd3, 0x7b, 0xe1, 0x07, 0x6a, 0x96, 0xba, 0xf6, 0x54,
-	0x84, 0x8e, 0x2f, 0xd9, 0x05, 0x8b, 0x98, 0xe3, 0x25, 0xf3, 0x40, 0x39, 0x33, 0xa5, 0x62, 0x5f,
-	0xc6, 0xd3, 0x75, 0x50, 0x39, 0x5e, 0xde, 0xe0, 0x08, 0x83, 0x30, 0x90, 0x4e, 0x3c, 0xf7, 0x9d,
-	0xcb, 0x94, 0xcb, 0x80, 0x4b, 0x27, 0x51, 0x4c, 0x25, 0xe5, 0x59, 0xfa, 0xac, 0x2f, 0x08, 0xf0,
-	0x59, 0xca, 0x65, 0x46, 0x79, 0x92, 0x7e, 0x54, 0x94, 0x5f, 0xa6, 0x3c, 0x51, 0xd8, 0x84, 0xc3,
-	0xc2, 0x93, 0xbd, 0x7d, 0x63, 0xa2, 0x3e, 0x1a, 0xb4, 0x68, 0x9d, 0xe2, 0x57, 0xd0, 0x2d, 0x5a,
-	0x53, 0x9e, 0xc4, 0x22, 0x4a, 0xb8, 0xb9, 0xd7, 0x47, 0x83, 0xce, 0xf0, 0xb1, 0xbd, 0xe6, 0x19,
-	0x4f, 0x26, 0xef, 0xeb, 0x2a, 0xdd, 0xd0, 0x62, 0x0b, 0xda, 0xba, 0xb7, 0xb9, 0xaf, 0x4d, 0x5d,
-	0xbb, 0x24, 0x39, 0x2f, 0x4e, 0x5a, 0x96, 0xac, 0xef, 0x08, 0xcc, 0x06, 0xd0, 0xb9, 0x92, 0x9c,
-	0x85, 0xb7, 0x63, 0xbd, 0x86, 0x3b, 0x21, 0x57, 0xcc, 0x63, 0x8a, 0x55, 0x48, 0xc7, 0x76, 0x73,
-	0xd0, 0x76, 0xe3, 0xce, 0x77, 0x95, 0x70, 0x6c, 0xd0, 0xb5, 0x09, 0x9f, 0x40, 0xcb, 0x15, 0x5e,
-	0x56, 0xa1, 0x3d, 0xd9, 0x6a, 0x1e, 0x09, 0x2f, 0x1b, 0x1b, 0x54, 0x8b, 0x47, 0x07, 0xd0, 0x2a,
-	0xcc, 0x56, 0x06, 0x0f, 0x6f, 0xb8, 0x1f, 0x63, 0x68, 0x4d, 0x85, 0xc7, 0x35, 0x6b, 0x9b, 0xea,
-	0x18, 0x3f, 0x87, 0xc3, 0x19, 0x67, 0x1e, 0x97, 0x89, 0xb9, 0xd7, 0xdf, 0x1f, 0x74, 0x86, 0xf7,
-	0x1b, 0xa3, 0xd3, 0x05, 0x5a, 0x0b, 0x76, 0x9a, 0xd7, 0x33, 0xb8, 0xf7, 0x17, 0x1d, 0x3e, 0x82,
-	0xf6, 0x74, 0x96, 0x46, 0x73, 0xdd, 0xb7, 0x4b, 0xcb, 0xc4, 0x7a, 0xb4, 0xc1, 0x58, 0xef, 0x64,
-	0xf8, 0x13, 0x01, 0x3e, 0xad, 0xbe, 0xf5, 0x54, 0xc8, 0xb3, 0xf2, 0x4f, 0xc1, 0x13, 0xe8, 0x34,
-	0xd4, 0xb8, 0xbf, 0x75, 0x1e, 0xd5, 0x6a, 0x7a, 0xc7, 0xff, 0x51, 0x94, 0xad, 0x2c, 0x03, 0xbb,
-	0xf0, 0xe0, 0x9f, 0xdd, 0xe2, 0xa7, 0x5b, 0x9d, 0x1b, 0xcb, 0xdf, 0xa9, 0xc3, 0x00, 0x8d, 0x46,
-	0x8b, 0x25, 0x31, 0xae, 0x96, 0xc4, 0xb8, 0x5e, 0x12, 0xf4, 0x39, 0x27, 0xe8, 0x5b, 0x4e, 0xd0,
-	0x8f, 0x9c, 0xa0, 0x45, 0x4e, 0xd0, 0xaf, 0x9c, 0xa0, 0xdf, 0x39, 0x31, 0xae, 0x73, 0x82, 0xbe,
-	0xae, 0x88, 0xb1, 0x58, 0x11, 0xe3, 0x6a, 0x45, 0x8c, 0x0f, 0x1b, 0xaf, 0xd2, 0x3d, 0xd0, 0x8f,
-	0xe3, 0xe4, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xca, 0x18, 0x1f, 0x97, 0xbc, 0x03, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/frontend/v2/frontendv2pb/frontend.proto", fileDescriptor_b3ea5a9cadd775d4)
+}
+
+var fileDescriptor_b3ea5a9cadd775d4 = []byte{
+	// 479 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xc1, 0x6e, 0xd3, 0x4a,
+	0x14, 0x9d, 0x69, 0x93, 0xf6, 0xe9, 0x26, 0xd2, 0x83, 0xa1, 0x20, 0x2b, 0x52, 0x47, 0xa9, 0x17,
+	0x10, 0x81, 0x64, 0x23, 0x77, 0xc7, 0x06, 0x29, 0x42, 0x55, 0x58, 0x20, 0xd1, 0x69, 0x56, 0xec,
+	0xc6, 0xf1, 0xd4, 0x89, 0x42, 0x3c, 0xee, 0x78, 0x5c, 0xc9, 0x3b, 0xbe, 0x00, 0xf1, 0x19, 0xac,
+	0xf9, 0x0a, 0x56, 0x28, 0xcb, 0x2e, 0x89, 0xb3, 0x61, 0xd9, 0x4f, 0x40, 0x1e, 0x3b, 0x96, 0x03,
+	0x04, 0xba, 0x19, 0xdd, 0xab, 0x73, 0xce, 0x9c, 0xe3, 0x7b, 0x3d, 0xf0, 0x2c, 0x9e, 0x87, 0xee,
+	0xa5, 0x92, 0x91, 0x16, 0x51, 0xe0, 0x5e, 0x7b, 0x75, 0x7d, 0xed, 0xc5, 0x7e, 0xdd, 0x38, 0xb1,
+	0x92, 0x5a, 0x92, 0x6e, 0x13, 0xec, 0x1d, 0x85, 0x32, 0x94, 0x06, 0x70, 0x8b, 0xaa, 0xe4, 0xf4,
+	0x9e, 0x87, 0x33, 0x3d, 0x4d, 0x7d, 0x67, 0x22, 0x17, 0x6e, 0xa8, 0xf8, 0x25, 0x8f, 0xb8, 0x1b,
+	0x24, 0xf3, 0x99, 0x76, 0xa7, 0x5a, 0xc7, 0xa1, 0x8a, 0x27, 0x75, 0x51, 0x29, 0x8e, 0x8b, 0x08,
+	0x57, 0xa9, 0x50, 0x33, 0xa1, 0xdc, 0x44, 0x73, 0x9d, 0x94, 0x67, 0x09, 0xdb, 0x1f, 0x31, 0x90,
+	0xf3, 0x54, 0xa8, 0x8c, 0x89, 0x24, 0x7d, 0xaf, 0x99, 0xb8, 0x4a, 0x45, 0xa2, 0x89, 0x05, 0x87,
+	0x85, 0x26, 0x7b, 0xfd, 0xca, 0xc2, 0x7d, 0x3c, 0x68, 0xb1, 0x4d, 0x4b, 0x5e, 0x40, 0xb7, 0x70,
+	0x60, 0x22, 0x89, 0x65, 0x94, 0x08, 0x6b, 0xaf, 0x8f, 0x07, 0x1d, 0xef, 0x91, 0x53, 0xdb, 0x8e,
+	0xc6, 0xe3, 0xb7, 0x1b, 0x94, 0x6d, 0x71, 0x89, 0x0d, 0x6d, 0xe3, 0x6d, 0xed, 0x1b, 0x51, 0xd7,
+	0x29, 0x93, 0x5c, 0x14, 0x27, 0x2b, 0x21, 0xfb, 0x0b, 0x06, 0xab, 0x11, 0xe8, 0x42, 0x2b, 0xc1,
+	0x17, 0xff, 0x8e, 0xf5, 0x12, 0xfe, 0x5b, 0x08, 0xcd, 0x03, 0xae, 0x79, 0x15, 0xe9, 0xc4, 0x69,
+	0xce, 0xd3, 0x69, 0xdc, 0xf9, 0xa6, 0x22, 0x8e, 0x10, 0xab, 0x45, 0xe4, 0x14, 0x5a, 0xbe, 0x0c,
+	0xb2, 0x2a, 0xda, 0xf1, 0x4e, 0xf1, 0x50, 0x06, 0xd9, 0x08, 0x31, 0x43, 0x1e, 0x1e, 0x40, 0xab,
+	0x10, 0xdb, 0x19, 0x3c, 0xf8, 0xc3, 0xfd, 0x84, 0x40, 0x6b, 0x22, 0x03, 0x61, 0xb2, 0xb6, 0x99,
+	0xa9, 0xc9, 0x53, 0x38, 0x9c, 0x0a, 0x1e, 0x08, 0x95, 0x58, 0x7b, 0xfd, 0xfd, 0x41, 0xc7, 0xbb,
+	0xd7, 0x18, 0x9d, 0x01, 0xd8, 0x86, 0x70, 0xa7, 0x79, 0x3d, 0x81, 0xff, 0x7f, 0x49, 0x47, 0x8e,
+	0xa0, 0x3d, 0x99, 0xa6, 0xd1, 0xdc, 0xf8, 0x76, 0x59, 0xd9, 0xd8, 0x0f, 0xb7, 0x32, 0x6e, 0x76,
+	0xe2, 0x7d, 0xc3, 0x40, 0xce, 0xaa, 0x6f, 0x3d, 0x93, 0xea, 0xbc, 0xfc, 0x53, 0xc8, 0x18, 0x3a,
+	0x0d, 0x36, 0xe9, 0xef, 0x9c, 0x47, 0xb5, 0x9a, 0xde, 0xc9, 0x5f, 0x18, 0xa5, 0x95, 0x8d, 0x88,
+	0x0f, 0xf7, 0x7f, 0xdb, 0x2d, 0x79, 0xbc, 0x53, 0xb9, 0xb5, 0xfc, 0x3b, 0x39, 0x0c, 0xf0, 0x70,
+	0xb8, 0x5c, 0x51, 0x74, 0xb3, 0xa2, 0xe8, 0x76, 0x45, 0xf1, 0x87, 0x9c, 0xe2, 0xcf, 0x39, 0xc5,
+	0x5f, 0x73, 0x8a, 0x97, 0x39, 0xc5, 0xdf, 0x73, 0x8a, 0x7f, 0xe4, 0x14, 0xdd, 0xe6, 0x14, 0x7f,
+	0x5a, 0x53, 0xb4, 0x5c, 0x53, 0x74, 0xb3, 0xa6, 0xe8, 0xdd, 0xd6, 0xe3, 0xf3, 0x0f, 0xcc, 0xe3,
+	0x38, 0xfd, 0x19, 0x00, 0x00, 0xff, 0xff, 0x45, 0x14, 0xbf, 0x52, 0xc0, 0x03, 0x00, 0x00,
 }
 
 func (this *QueryResultRequest) Equal(that interface{}) bool {
@@ -793,7 +795,7 @@ var _FrontendForQuerier_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 	},
-	Metadata: "frontend.proto",
+	Metadata: "pkg/frontend/v2/frontendv2pb/frontend.proto",
 }
 
 func (m *QueryResultRequest) Marshal() (dAtA []byte, err error) {
diff --git a/pkg/frontend/v2/frontendv2pb/frontend.proto b/pkg/frontend/v2/frontendv2pb/frontend.proto
index de147278360..5fd85bf4909 100644
--- a/pkg/frontend/v2/frontendv2pb/frontend.proto
+++ b/pkg/frontend/v2/frontendv2pb/frontend.proto
@@ -11,7 +11,7 @@ option go_package = "frontendv2pb";
 
 import "gogoproto/gogo.proto";
 import "github.com/grafana/dskit/httpgrpc/httpgrpc.proto";
-import "github.com/grafana/mimir/pkg/querier/stats/stats.proto";
+import "pkg/querier/stats/stats.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
diff --git a/pkg/ingester/client/ingester.pb.go b/pkg/ingester/client/ingester.pb.go
index bbefc14b1e4..008a6780845 100644
--- a/pkg/ingester/client/ingester.pb.go
+++ b/pkg/ingester/client/ingester.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: ingester.proto
+// source: pkg/ingester/client/ingester.proto
 
 // TODO: Rename to ingesterpb
 
@@ -13,13 +13,13 @@ import (
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
-	mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	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"
+	mimirpb "pkg/mimirpb"
 	reflect "reflect"
 	strconv "strconv"
 	strings "strings"
@@ -54,7 +54,7 @@ var CountMethod_value = map[string]int32{
 }
 
 func (CountMethod) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{0}
+	return fileDescriptor_5b6c87318632a5b2, []int{0}
 }
 
 type MatchType int32
@@ -81,7 +81,7 @@ var MatchType_value = map[string]int32{
 }
 
 func (MatchType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{1}
+	return fileDescriptor_5b6c87318632a5b2, []int{1}
 }
 
 type ActiveSeriesRequest_RequestType int32
@@ -102,7 +102,7 @@ var ActiveSeriesRequest_RequestType_value = map[string]int32{
 }
 
 func (ActiveSeriesRequest_RequestType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{8, 0}
+	return fileDescriptor_5b6c87318632a5b2, []int{8, 0}
 }
 
 type LabelNamesAndValuesRequest struct {
@@ -113,7 +113,7 @@ type LabelNamesAndValuesRequest struct {
 func (m *LabelNamesAndValuesRequest) Reset()      { *m = LabelNamesAndValuesRequest{} }
 func (*LabelNamesAndValuesRequest) ProtoMessage() {}
 func (*LabelNamesAndValuesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{0}
+	return fileDescriptor_5b6c87318632a5b2, []int{0}
 }
 func (m *LabelNamesAndValuesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -163,7 +163,7 @@ type LabelNamesAndValuesResponse struct {
 func (m *LabelNamesAndValuesResponse) Reset()      { *m = LabelNamesAndValuesResponse{} }
 func (*LabelNamesAndValuesResponse) ProtoMessage() {}
 func (*LabelNamesAndValuesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{1}
+	return fileDescriptor_5b6c87318632a5b2, []int{1}
 }
 func (m *LabelNamesAndValuesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -207,7 +207,7 @@ type LabelValues struct {
 func (m *LabelValues) Reset()      { *m = LabelValues{} }
 func (*LabelValues) ProtoMessage() {}
 func (*LabelValues) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{2}
+	return fileDescriptor_5b6c87318632a5b2, []int{2}
 }
 func (m *LabelValues) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -259,7 +259,7 @@ type LabelValuesCardinalityRequest struct {
 func (m *LabelValuesCardinalityRequest) Reset()      { *m = LabelValuesCardinalityRequest{} }
 func (*LabelValuesCardinalityRequest) ProtoMessage() {}
 func (*LabelValuesCardinalityRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{3}
+	return fileDescriptor_5b6c87318632a5b2, []int{3}
 }
 func (m *LabelValuesCardinalityRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -316,7 +316,7 @@ type LabelValuesCardinalityResponse struct {
 func (m *LabelValuesCardinalityResponse) Reset()      { *m = LabelValuesCardinalityResponse{} }
 func (*LabelValuesCardinalityResponse) ProtoMessage() {}
 func (*LabelValuesCardinalityResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{4}
+	return fileDescriptor_5b6c87318632a5b2, []int{4}
 }
 func (m *LabelValuesCardinalityResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -360,7 +360,7 @@ type LabelValueSeriesCount struct {
 func (m *LabelValueSeriesCount) Reset()      { *m = LabelValueSeriesCount{} }
 func (*LabelValueSeriesCount) ProtoMessage() {}
 func (*LabelValueSeriesCount) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{5}
+	return fileDescriptor_5b6c87318632a5b2, []int{5}
 }
 func (m *LabelValueSeriesCount) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -414,7 +414,7 @@ type QueryRequest struct {
 func (m *QueryRequest) Reset()      { *m = QueryRequest{} }
 func (*QueryRequest) ProtoMessage() {}
 func (*QueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{6}
+	return fileDescriptor_5b6c87318632a5b2, []int{6}
 }
 func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -480,7 +480,7 @@ type ExemplarQueryRequest struct {
 func (m *ExemplarQueryRequest) Reset()      { *m = ExemplarQueryRequest{} }
 func (*ExemplarQueryRequest) ProtoMessage() {}
 func (*ExemplarQueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{7}
+	return fileDescriptor_5b6c87318632a5b2, []int{7}
 }
 func (m *ExemplarQueryRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -538,7 +538,7 @@ type ActiveSeriesRequest struct {
 func (m *ActiveSeriesRequest) Reset()      { *m = ActiveSeriesRequest{} }
 func (*ActiveSeriesRequest) ProtoMessage() {}
 func (*ActiveSeriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{8}
+	return fileDescriptor_5b6c87318632a5b2, []int{8}
 }
 func (m *ActiveSeriesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -588,7 +588,7 @@ type QueryResponse struct {
 func (m *QueryResponse) Reset()      { *m = QueryResponse{} }
 func (*QueryResponse) ProtoMessage() {}
 func (*QueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{9}
+	return fileDescriptor_5b6c87318632a5b2, []int{9}
 }
 func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -643,7 +643,7 @@ type QueryStreamResponse struct {
 func (m *QueryStreamResponse) Reset()      { *m = QueryStreamResponse{} }
 func (*QueryStreamResponse) ProtoMessage() {}
 func (*QueryStreamResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{10}
+	return fileDescriptor_5b6c87318632a5b2, []int{10}
 }
 func (m *QueryStreamResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -708,14 +708,14 @@ func (m *QueryStreamResponse) GetStreamingSeriesChunks() []QueryStreamSeriesChun
 }
 
 type QueryStreamSeries struct {
-	Labels     []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
-	ChunkCount int64                                               `protobuf:"varint,2,opt,name=chunk_count,json=chunkCount,proto3" json:"chunk_count,omitempty"`
+	Labels     []mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
+	ChunkCount int64                  `protobuf:"varint,2,opt,name=chunk_count,json=chunkCount,proto3" json:"chunk_count,omitempty"`
 }
 
 func (m *QueryStreamSeries) Reset()      { *m = QueryStreamSeries{} }
 func (*QueryStreamSeries) ProtoMessage() {}
 func (*QueryStreamSeries) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{11}
+	return fileDescriptor_5b6c87318632a5b2, []int{11}
 }
 func (m *QueryStreamSeries) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -744,6 +744,13 @@ func (m *QueryStreamSeries) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryStreamSeries proto.InternalMessageInfo
 
+func (m *QueryStreamSeries) GetLabels() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 func (m *QueryStreamSeries) GetChunkCount() int64 {
 	if m != nil {
 		return m.ChunkCount
@@ -759,7 +766,7 @@ type QueryStreamSeriesChunks struct {
 func (m *QueryStreamSeriesChunks) Reset()      { *m = QueryStreamSeriesChunks{} }
 func (*QueryStreamSeriesChunks) ProtoMessage() {}
 func (*QueryStreamSeriesChunks) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{12}
+	return fileDescriptor_5b6c87318632a5b2, []int{12}
 }
 func (m *QueryStreamSeriesChunks) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -809,7 +816,7 @@ type ExemplarQueryResponse struct {
 func (m *ExemplarQueryResponse) Reset()      { *m = ExemplarQueryResponse{} }
 func (*ExemplarQueryResponse) ProtoMessage() {}
 func (*ExemplarQueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{13}
+	return fileDescriptor_5b6c87318632a5b2, []int{13}
 }
 func (m *ExemplarQueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -855,7 +862,7 @@ type LabelValuesRequest struct {
 func (m *LabelValuesRequest) Reset()      { *m = LabelValuesRequest{} }
 func (*LabelValuesRequest) ProtoMessage() {}
 func (*LabelValuesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{14}
+	return fileDescriptor_5b6c87318632a5b2, []int{14}
 }
 func (m *LabelValuesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -919,7 +926,7 @@ type LabelValuesResponse struct {
 func (m *LabelValuesResponse) Reset()      { *m = LabelValuesResponse{} }
 func (*LabelValuesResponse) ProtoMessage() {}
 func (*LabelValuesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{15}
+	return fileDescriptor_5b6c87318632a5b2, []int{15}
 }
 func (m *LabelValuesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -964,7 +971,7 @@ type LabelNamesRequest struct {
 func (m *LabelNamesRequest) Reset()      { *m = LabelNamesRequest{} }
 func (*LabelNamesRequest) ProtoMessage() {}
 func (*LabelNamesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{16}
+	return fileDescriptor_5b6c87318632a5b2, []int{16}
 }
 func (m *LabelNamesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1021,7 +1028,7 @@ type LabelNamesResponse struct {
 func (m *LabelNamesResponse) Reset()      { *m = LabelNamesResponse{} }
 func (*LabelNamesResponse) ProtoMessage() {}
 func (*LabelNamesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{17}
+	return fileDescriptor_5b6c87318632a5b2, []int{17}
 }
 func (m *LabelNamesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1064,7 +1071,7 @@ type UserStatsRequest struct {
 func (m *UserStatsRequest) Reset()      { *m = UserStatsRequest{} }
 func (*UserStatsRequest) ProtoMessage() {}
 func (*UserStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{18}
+	return fileDescriptor_5b6c87318632a5b2, []int{18}
 }
 func (m *UserStatsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1110,7 +1117,7 @@ type UserStatsResponse struct {
 func (m *UserStatsResponse) Reset()      { *m = UserStatsResponse{} }
 func (*UserStatsResponse) ProtoMessage() {}
 func (*UserStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{19}
+	return fileDescriptor_5b6c87318632a5b2, []int{19}
 }
 func (m *UserStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1175,7 +1182,7 @@ type UserIDStatsResponse struct {
 func (m *UserIDStatsResponse) Reset()      { *m = UserIDStatsResponse{} }
 func (*UserIDStatsResponse) ProtoMessage() {}
 func (*UserIDStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{20}
+	return fileDescriptor_5b6c87318632a5b2, []int{20}
 }
 func (m *UserIDStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1225,7 +1232,7 @@ type UsersStatsResponse struct {
 func (m *UsersStatsResponse) Reset()      { *m = UsersStatsResponse{} }
 func (*UsersStatsResponse) ProtoMessage() {}
 func (*UsersStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{21}
+	return fileDescriptor_5b6c87318632a5b2, []int{21}
 }
 func (m *UsersStatsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1270,7 +1277,7 @@ type MetricsForLabelMatchersRequest struct {
 func (m *MetricsForLabelMatchersRequest) Reset()      { *m = MetricsForLabelMatchersRequest{} }
 func (*MetricsForLabelMatchersRequest) ProtoMessage() {}
 func (*MetricsForLabelMatchersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{22}
+	return fileDescriptor_5b6c87318632a5b2, []int{22}
 }
 func (m *MetricsForLabelMatchersRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1327,7 +1334,7 @@ type MetricsForLabelMatchersResponse struct {
 func (m *MetricsForLabelMatchersResponse) Reset()      { *m = MetricsForLabelMatchersResponse{} }
 func (*MetricsForLabelMatchersResponse) ProtoMessage() {}
 func (*MetricsForLabelMatchersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{23}
+	return fileDescriptor_5b6c87318632a5b2, []int{23}
 }
 func (m *MetricsForLabelMatchersResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1372,7 +1379,7 @@ type MetricsMetadataRequest struct {
 func (m *MetricsMetadataRequest) Reset()      { *m = MetricsMetadataRequest{} }
 func (*MetricsMetadataRequest) ProtoMessage() {}
 func (*MetricsMetadataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{24}
+	return fileDescriptor_5b6c87318632a5b2, []int{24}
 }
 func (m *MetricsMetadataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1429,7 +1436,7 @@ type MetricsMetadataResponse struct {
 func (m *MetricsMetadataResponse) Reset()      { *m = MetricsMetadataResponse{} }
 func (*MetricsMetadataResponse) ProtoMessage() {}
 func (*MetricsMetadataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{25}
+	return fileDescriptor_5b6c87318632a5b2, []int{25}
 }
 func (m *MetricsMetadataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1475,7 +1482,7 @@ type ActiveSeriesResponse struct {
 func (m *ActiveSeriesResponse) Reset()      { *m = ActiveSeriesResponse{} }
 func (*ActiveSeriesResponse) ProtoMessage() {}
 func (*ActiveSeriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{26}
+	return fileDescriptor_5b6c87318632a5b2, []int{26}
 }
 func (m *ActiveSeriesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1519,16 +1526,16 @@ func (m *ActiveSeriesResponse) GetBucketCount() []uint64 {
 }
 
 type TimeSeriesChunk struct {
-	FromIngesterId string                                              `protobuf:"bytes,1,opt,name=from_ingester_id,json=fromIngesterId,proto3" json:"from_ingester_id,omitempty"`
-	UserId         string                                              `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
-	Labels         []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,3,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
-	Chunks         []Chunk                                             `protobuf:"bytes,4,rep,name=chunks,proto3" json:"chunks"`
+	FromIngesterId string                 `protobuf:"bytes,1,opt,name=from_ingester_id,json=fromIngesterId,proto3" json:"from_ingester_id,omitempty"`
+	UserId         string                 `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
+	Labels         []mimirpb.LabelAdapter `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels"`
+	Chunks         []Chunk                `protobuf:"bytes,4,rep,name=chunks,proto3" json:"chunks"`
 }
 
 func (m *TimeSeriesChunk) Reset()      { *m = TimeSeriesChunk{} }
 func (*TimeSeriesChunk) ProtoMessage() {}
 func (*TimeSeriesChunk) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{27}
+	return fileDescriptor_5b6c87318632a5b2, []int{27}
 }
 func (m *TimeSeriesChunk) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1571,6 +1578,13 @@ func (m *TimeSeriesChunk) GetUserId() string {
 	return ""
 }
 
+func (m *TimeSeriesChunk) GetLabels() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 func (m *TimeSeriesChunk) GetChunks() []Chunk {
 	if m != nil {
 		return m.Chunks
@@ -1588,7 +1602,7 @@ type Chunk struct {
 func (m *Chunk) Reset()      { *m = Chunk{} }
 func (*Chunk) ProtoMessage() {}
 func (*Chunk) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{28}
+	return fileDescriptor_5b6c87318632a5b2, []int{28}
 }
 func (m *Chunk) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1645,7 +1659,7 @@ type LabelMatchers struct {
 func (m *LabelMatchers) Reset()      { *m = LabelMatchers{} }
 func (*LabelMatchers) ProtoMessage() {}
 func (*LabelMatchers) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{29}
+	return fileDescriptor_5b6c87318632a5b2, []int{29}
 }
 func (m *LabelMatchers) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1690,7 +1704,7 @@ type LabelMatcher struct {
 func (m *LabelMatcher) Reset()      { *m = LabelMatcher{} }
 func (*LabelMatcher) ProtoMessage() {}
 func (*LabelMatcher) Descriptor() ([]byte, []int) {
-	return fileDescriptor_60f6df4f3586b478, []int{30}
+	return fileDescriptor_5b6c87318632a5b2, []int{30}
 }
 func (m *LabelMatcher) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1778,120 +1792,122 @@ func init() {
 	proto.RegisterType((*LabelMatcher)(nil), "cortex.LabelMatcher")
 }
 
-func init() { proto.RegisterFile("ingester.proto", fileDescriptor_60f6df4f3586b478) }
-
-var fileDescriptor_60f6df4f3586b478 = []byte{
-	// 1748 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4b, 0x6f, 0x1b, 0xc9,
-	0x11, 0x66, 0xf3, 0xb5, 0x62, 0x91, 0x92, 0xa8, 0xa6, 0x24, 0x72, 0x47, 0xab, 0x91, 0x76, 0x02,
-	0xef, 0x32, 0x9b, 0x5d, 0xc9, 0xaf, 0x2c, 0xbc, 0x9b, 0x0d, 0x02, 0x4a, 0xa6, 0x2d, 0xda, 0xa6,
-	0x24, 0x0f, 0x25, 0xe7, 0x01, 0x18, 0x83, 0x21, 0xd9, 0x92, 0x06, 0xe2, 0x0c, 0x99, 0x99, 0xa6,
-	0x61, 0xf9, 0x94, 0x53, 0xce, 0xf9, 0x01, 0x41, 0x80, 0xdc, 0x82, 0x1c, 0x73, 0xc9, 0x25, 0xc8,
-	0xd9, 0x97, 0x00, 0xbe, 0xc5, 0x08, 0x10, 0x23, 0x96, 0x2f, 0xc9, 0xcd, 0x40, 0xfe, 0x40, 0x30,
-	0xdd, 0x3d, 0x4f, 0x52, 0x12, 0x65, 0xc4, 0x3e, 0x91, 0x5d, 0xaf, 0xfe, 0xaa, 0xba, 0xba, 0xaa,
-	0xa6, 0x61, 0xc6, 0xb0, 0x0e, 0x89, 0x43, 0x89, 0xbd, 0x36, 0xb0, 0xfb, 0xb4, 0x8f, 0xb3, 0x9d,
-	0xbe, 0x4d, 0xc9, 0x53, 0xe9, 0xab, 0x43, 0x83, 0x1e, 0x0d, 0xdb, 0x6b, 0x9d, 0xbe, 0xb9, 0x7e,
-	0xd8, 0x3f, 0xec, 0xaf, 0x33, 0x76, 0x7b, 0x78, 0xc0, 0x56, 0x6c, 0xc1, 0xfe, 0x71, 0x35, 0xe9,
-	0x6a, 0x58, 0xdc, 0xd6, 0x0f, 0x74, 0x4b, 0x5f, 0x37, 0x0d, 0xd3, 0xb0, 0xd7, 0x07, 0xc7, 0x87,
-	0xfc, 0xdf, 0xa0, 0xcd, 0x7f, 0xb9, 0x86, 0xf2, 0x6b, 0x04, 0xd2, 0x03, 0xbd, 0x4d, 0x7a, 0xdb,
-	0xba, 0x49, 0x9c, 0x9a, 0xd5, 0x7d, 0xa4, 0xf7, 0x86, 0xc4, 0x51, 0xc9, 0x2f, 0x87, 0xc4, 0xa1,
-	0xf8, 0x2a, 0x4c, 0x99, 0x3a, 0xed, 0x1c, 0x11, 0xdb, 0xa9, 0xa0, 0xd5, 0x54, 0x35, 0x7f, 0x7d,
-	0x7e, 0x8d, 0x43, 0x5b, 0x63, 0x5a, 0x4d, 0xce, 0x54, 0x7d, 0x29, 0xfc, 0x35, 0x14, 0x3a, 0xfd,
-	0xa1, 0x45, 0x35, 0x93, 0xd0, 0xa3, 0x7e, 0xb7, 0x92, 0x5c, 0x45, 0xd5, 0x99, 0xeb, 0x25, 0x4f,
-	0x6b, 0xd3, 0xe5, 0x35, 0x19, 0x4b, 0xcd, 0x77, 0x82, 0x85, 0xb2, 0x05, 0x4b, 0x63, 0x71, 0x38,
-	0x83, 0xbe, 0xe5, 0x10, 0xfc, 0x7d, 0xc8, 0x18, 0x94, 0x98, 0x1e, 0x8a, 0x52, 0x04, 0x85, 0x90,
-	0xe5, 0x12, 0xca, 0x6d, 0xc8, 0x87, 0xa8, 0x78, 0x19, 0xa0, 0xe7, 0x2e, 0x35, 0x4b, 0x37, 0x49,
-	0x05, 0xad, 0xa2, 0x6a, 0x4e, 0xcd, 0xf5, 0xbc, 0xad, 0xf0, 0x22, 0x64, 0x9f, 0x30, 0xc1, 0x4a,
-	0x72, 0x35, 0x55, 0xcd, 0xa9, 0x62, 0xa5, 0xfc, 0x11, 0xc1, 0x72, 0xc8, 0xcc, 0xa6, 0x6e, 0x77,
-	0x0d, 0x4b, 0xef, 0x19, 0xf4, 0xc4, 0x8b, 0xcd, 0x0a, 0xe4, 0x03, 0xc3, 0x1c, 0x58, 0x4e, 0x05,
-	0xdf, 0xb2, 0x13, 0x09, 0x5e, 0xf2, 0x9d, 0x82, 0x97, 0x9a, 0x30, 0x78, 0xfb, 0x20, 0x9f, 0x85,
-	0x55, 0xc4, 0xef, 0x46, 0x34, 0x7e, 0xcb, 0xa3, 0xf1, 0x6b, 0x11, 0xdb, 0x20, 0x0e, 0xdb, 0xc2,
-	0x8b, 0xe4, 0x2b, 0x04, 0x0b, 0x63, 0x05, 0x2e, 0x0a, 0xaa, 0x0e, 0x98, 0xb3, 0x59, 0x30, 0x35,
-	0x87, 0x69, 0x8a, 0x18, 0xdc, 0x38, 0x77, 0xeb, 0x11, 0x6a, 0xdd, 0xa2, 0xf6, 0x89, 0x5a, 0xec,
-	0xc5, 0xc8, 0xd2, 0xe6, 0x28, 0x34, 0x26, 0x8a, 0x8b, 0x90, 0x3a, 0x26, 0x27, 0x02, 0x93, 0xfb,
-	0x17, 0xcf, 0x43, 0x86, 0xe1, 0x60, 0xb9, 0x98, 0x56, 0xf9, 0xe2, 0xdb, 0xe4, 0x2d, 0xa4, 0xfc,
-	0x1d, 0x41, 0xe1, 0xe1, 0x90, 0xd8, 0xfe, 0x99, 0x7e, 0x09, 0xd8, 0xa1, 0xba, 0x4d, 0x35, 0x6a,
-	0x98, 0xc4, 0xa1, 0xba, 0x39, 0xd0, 0x58, 0xcc, 0x50, 0x35, 0xa5, 0x16, 0x19, 0x67, 0xcf, 0x63,
-	0x34, 0x1d, 0x5c, 0x85, 0x22, 0xb1, 0xba, 0x51, 0xd9, 0x24, 0x93, 0x9d, 0x21, 0x56, 0x37, 0x2c,
-	0x19, 0x4e, 0x85, 0xd4, 0x44, 0xa9, 0xf0, 0x63, 0x58, 0x72, 0xa8, 0x4d, 0x74, 0xd3, 0xb0, 0x0e,
-	0xb5, 0xce, 0xd1, 0xd0, 0x3a, 0x76, 0xb4, 0xb6, 0xcb, 0xd4, 0x1c, 0xe3, 0x19, 0xa9, 0x74, 0x99,
-	0x2b, 0x15, 0x5f, 0x64, 0x93, 0x49, 0x6c, 0xb8, 0x02, 0x2d, 0xe3, 0x19, 0x51, 0x7e, 0x8f, 0x60,
-	0xbe, 0xfe, 0x94, 0x98, 0x83, 0x9e, 0x6e, 0x7f, 0x10, 0x0f, 0xaf, 0x8d, 0x78, 0xb8, 0x30, 0xce,
-	0x43, 0x27, 0x70, 0x51, 0xf9, 0x0b, 0x82, 0x52, 0xad, 0x43, 0x8d, 0x27, 0xe2, 0xfc, 0xde, 0xbd,
-	0xe8, 0xfc, 0x08, 0xd2, 0xf4, 0x64, 0x40, 0x44, 0xb1, 0xf9, 0xdc, 0x93, 0x1e, 0x63, 0x7c, 0x4d,
-	0xfc, 0xee, 0x9d, 0x0c, 0x88, 0xca, 0x94, 0x94, 0xaf, 0x21, 0x1f, 0x22, 0x62, 0x80, 0x6c, 0xab,
-	0xae, 0x36, 0xea, 0xad, 0x62, 0x02, 0x2f, 0x41, 0x79, 0xbb, 0xb6, 0xd7, 0x78, 0x54, 0xd7, 0xb6,
-	0x1a, 0xad, 0xbd, 0x9d, 0xbb, 0x6a, 0xad, 0xa9, 0x09, 0x26, 0x52, 0xee, 0xc3, 0xb4, 0x88, 0xac,
-	0xb8, 0x63, 0xdf, 0x02, 0xb0, 0x40, 0xf1, 0x6c, 0x8f, 0x22, 0x1f, 0xb4, 0xd7, 0xdc, 0x68, 0x71,
-	0x2c, 0x1b, 0xe9, 0xe7, 0xaf, 0x56, 0x12, 0x6a, 0x48, 0x5a, 0xf9, 0x6f, 0x12, 0x4a, 0xcc, 0x5a,
-	0x8b, 0x9d, 0xa8, 0x6f, 0xf3, 0x27, 0x90, 0xe7, 0x87, 0x1f, 0x36, 0x5a, 0xf6, 0x1c, 0x0c, 0x4c,
-	0xb2, 0xf3, 0x17, 0x76, 0xc3, 0x1a, 0x31, 0x50, 0xc9, 0xcb, 0x80, 0xc2, 0xf7, 0xa0, 0x18, 0xe4,
-	0xa0, 0xb0, 0xc0, 0xcf, 0xf6, 0x63, 0x0f, 0x41, 0x08, 0x73, 0xc4, 0xcc, 0xac, 0xaf, 0xc8, 0xc9,
-	0xf8, 0x26, 0x94, 0x0d, 0x47, 0x73, 0x93, 0xa9, 0x7f, 0x20, 0x6c, 0x69, 0x5c, 0xa6, 0x92, 0x5e,
-	0x45, 0xd5, 0x29, 0xb5, 0x64, 0x38, 0x75, 0xab, 0xbb, 0x73, 0xc0, 0xe5, 0xb9, 0x49, 0xfc, 0x18,
-	0xca, 0x71, 0x04, 0xe2, 0x32, 0x54, 0x32, 0x0c, 0xc8, 0xca, 0x99, 0x40, 0xc4, 0x8d, 0xe0, 0x70,
-	0x16, 0x62, 0x70, 0x38, 0x53, 0xf9, 0x2d, 0x82, 0xb9, 0x11, 0x45, 0x7c, 0x00, 0x59, 0x56, 0x6e,
-	0xe2, 0xcd, 0x66, 0xd0, 0xe6, 0xf9, 0xb7, 0xab, 0x1b, 0xf6, 0xc6, 0x37, 0xae, 0xdd, 0x7f, 0xbc,
-	0x5a, 0xb9, 0x36, 0x49, 0xcb, 0xe5, 0x7a, 0xb5, 0xae, 0x3e, 0xa0, 0xc4, 0x56, 0x85, 0x75, 0xb7,
-	0x81, 0x30, 0x5f, 0x34, 0x56, 0xca, 0xc5, 0xbd, 0x02, 0x46, 0x62, 0xb5, 0x50, 0x31, 0xa0, 0x7c,
-	0x86, 0x5b, 0xf8, 0x53, 0x28, 0x88, 0x70, 0x18, 0x56, 0x97, 0x3c, 0x65, 0x17, 0x38, 0xad, 0xe6,
-	0x39, 0xad, 0xe1, 0x92, 0xf0, 0x0f, 0x20, 0x2b, 0x42, 0xc5, 0x4f, 0x7d, 0xda, 0x6f, 0x23, 0xa1,
-	0x5c, 0x11, 0x22, 0x4a, 0x0b, 0x16, 0x62, 0xe5, 0xe2, 0xff, 0x90, 0xd4, 0x7f, 0x45, 0x80, 0xc3,
-	0x0d, 0x5a, 0xdc, 0xef, 0x0b, 0x9a, 0xc7, 0xf8, 0x0a, 0x95, 0xbc, 0x44, 0x85, 0x4a, 0x5d, 0x58,
-	0xa1, 0xdc, 0x94, 0x9b, 0xa0, 0x42, 0xdd, 0x82, 0x52, 0x04, 0xbf, 0x88, 0xc9, 0xa7, 0x50, 0x08,
-	0xb5, 0x37, 0xaf, 0xf5, 0xe7, 0x83, 0x1e, 0xe5, 0x28, 0xbf, 0x43, 0x30, 0x17, 0xcc, 0x33, 0x1f,
-	0xb6, 0xf8, 0x4e, 0xe4, 0xda, 0x0f, 0xc5, 0xd1, 0x08, 0x7c, 0xc2, 0xb3, 0x8b, 0x66, 0x1a, 0xe5,
-	0x1e, 0x14, 0xf7, 0x1d, 0x62, 0xb7, 0xa8, 0x4e, 0x7d, 0xaf, 0xe2, 0x53, 0x0b, 0x9a, 0x70, 0x6a,
-	0xf9, 0x33, 0x82, 0xb9, 0x90, 0x31, 0x01, 0xe1, 0x8a, 0x37, 0x0c, 0x1b, 0x7d, 0x4b, 0xb3, 0x75,
-	0xca, 0x33, 0x04, 0xa9, 0xd3, 0x3e, 0x55, 0xd5, 0x29, 0x71, 0x93, 0xc8, 0x1a, 0x9a, 0xc1, 0x68,
-	0xe1, 0xa6, 0x7f, 0xce, 0x1a, 0x7a, 0x77, 0xf8, 0x4b, 0xc0, 0xfa, 0xc0, 0xd0, 0x62, 0x96, 0x52,
-	0xcc, 0x52, 0x51, 0x1f, 0x18, 0x8d, 0x88, 0xb1, 0x35, 0x28, 0xd9, 0xc3, 0x1e, 0x89, 0x8b, 0xa7,
-	0x99, 0xf8, 0x9c, 0xcb, 0x8a, 0xc8, 0x2b, 0x8f, 0xa1, 0xe4, 0x02, 0x6f, 0xdc, 0x8e, 0x42, 0x2f,
-	0xc3, 0x47, 0x43, 0x87, 0xd8, 0x9a, 0xd1, 0x15, 0x59, 0x9d, 0x75, 0x97, 0x8d, 0x2e, 0xfe, 0x0a,
-	0xd2, 0x5d, 0x9d, 0xea, 0x0c, 0x66, 0xa8, 0x78, 0x8e, 0x38, 0xaf, 0x32, 0x31, 0xe5, 0x2e, 0x60,
-	0x97, 0xe5, 0x44, 0xad, 0x5f, 0x83, 0x8c, 0xe3, 0x12, 0xc4, 0x25, 0x5c, 0x0a, 0x5b, 0x89, 0x21,
-	0x51, 0xb9, 0xa4, 0xf2, 0x27, 0x04, 0x72, 0x93, 0x50, 0xdb, 0xe8, 0x38, 0x77, 0xfa, 0x76, 0x34,
-	0x15, 0xde, 0x73, 0x4a, 0xde, 0x82, 0x82, 0x97, 0x6b, 0x9a, 0x43, 0xe8, 0xf9, 0x33, 0x41, 0xde,
-	0x13, 0x6d, 0x11, 0xaa, 0xdc, 0x87, 0x95, 0x33, 0x31, 0x8b, 0x50, 0x54, 0x21, 0x6b, 0x32, 0x11,
-	0x11, 0x8b, 0x62, 0x50, 0x90, 0xb8, 0xaa, 0x2a, 0xf8, 0xca, 0x00, 0x16, 0x85, 0xb1, 0x26, 0xa1,
-	0xba, 0x1b, 0x5d, 0xcf, 0xf1, 0x79, 0xc8, 0xf4, 0x0c, 0xd3, 0xa0, 0xcc, 0xd7, 0x39, 0x95, 0x2f,
-	0x5c, 0x07, 0xd9, 0x1f, 0x6d, 0x40, 0x6c, 0x4d, 0xec, 0x91, 0x64, 0x02, 0x33, 0x8c, 0xbe, 0x4b,
-	0x6c, 0x6e, 0xcf, 0xfd, 0x70, 0x10, 0xfc, 0x14, 0x3f, 0x6b, 0xb1, 0xe3, 0x0e, 0x94, 0x47, 0x76,
-	0x14, 0xb0, 0x6f, 0xc2, 0x94, 0x29, 0x68, 0x02, 0x78, 0x25, 0x0e, 0xdc, 0xd7, 0xf1, 0x25, 0x95,
-	0x0e, 0xcc, 0x47, 0x07, 0x99, 0xcb, 0x06, 0xc1, 0xad, 0x57, 0xed, 0x61, 0xe7, 0x98, 0x50, 0xbf,
-	0xd3, 0xa4, 0xdc, 0x66, 0xc1, 0x69, 0xbc, 0xd5, 0xfc, 0x07, 0xc1, 0x6c, 0x6c, 0x9a, 0x70, 0x63,
-	0x71, 0x60, 0xf7, 0x4d, 0xcd, 0xfb, 0x36, 0x0d, 0xf2, 0x7a, 0xc6, 0xa5, 0x37, 0x04, 0xb9, 0xd1,
-	0x0d, 0x27, 0x7e, 0x32, 0x92, 0xf8, 0x41, 0x2b, 0x4d, 0xbd, 0xd7, 0x56, 0x1a, 0xf4, 0xba, 0xf4,
-	0xc5, 0xbd, 0xee, 0x6f, 0x08, 0x32, 0xdc, 0xc3, 0xf7, 0x95, 0xfc, 0x12, 0x4c, 0x11, 0xab, 0xd3,
-	0xef, 0x1a, 0xd6, 0x21, 0xcb, 0x8e, 0x8c, 0xea, 0xaf, 0xf1, 0xae, 0xa8, 0x05, 0x6e, 0x71, 0x29,
-	0x6c, 0x7c, 0x27, 0x7c, 0xbf, 0x39, 0x91, 0xef, 0xfb, 0x96, 0xa3, 0x1f, 0x90, 0x8d, 0x13, 0x4a,
-	0x5a, 0x3d, 0xa3, 0xe3, 0x95, 0x8b, 0x1a, 0x4c, 0x47, 0xae, 0xc9, 0xe5, 0x07, 0x68, 0x45, 0x83,
-	0x42, 0x98, 0x83, 0xaf, 0x88, 0x81, 0x9a, 0x97, 0xf2, 0x39, 0x4f, 0x9b, 0xb1, 0x83, 0xd1, 0x19,
-	0x63, 0x48, 0xb3, 0x1e, 0xce, 0x0f, 0x9d, 0xfd, 0x0f, 0xbe, 0xb6, 0xf8, 0xb5, 0xe0, 0x8b, 0x2f,
-	0xaa, 0x90, 0x0f, 0xf5, 0x01, 0x3c, 0x0d, 0xb9, 0xc6, 0xb6, 0xd6, 0xac, 0x37, 0x77, 0xd4, 0x9f,
-	0x17, 0x13, 0xee, 0xcc, 0x5d, 0xdb, 0x74, 0xe7, 0xec, 0x22, 0xfa, 0xe2, 0x1e, 0xe4, 0xfc, 0x6d,
-	0x70, 0x0e, 0x32, 0xf5, 0x87, 0xfb, 0xb5, 0x07, 0xc5, 0x84, 0xab, 0xb2, 0xbd, 0xb3, 0xa7, 0xf1,
-	0x25, 0xc2, 0xb3, 0x90, 0x57, 0xeb, 0x77, 0xeb, 0x3f, 0xd3, 0x9a, 0xb5, 0xbd, 0xcd, 0xad, 0x62,
-	0x12, 0x63, 0x98, 0xe1, 0x84, 0xed, 0x1d, 0x41, 0x4b, 0x5d, 0xff, 0xe7, 0x47, 0x30, 0xe5, 0xa5,
-	0x29, 0xfe, 0x06, 0xd2, 0xbb, 0x43, 0xe7, 0x08, 0x2f, 0x06, 0x39, 0xf8, 0x53, 0xdb, 0xa0, 0x44,
-	0x14, 0x04, 0xa9, 0x3c, 0x42, 0xe7, 0x17, 0x4d, 0x49, 0xe0, 0xdb, 0x90, 0x0f, 0x0d, 0x62, 0x78,
-	0x3e, 0x32, 0x74, 0x7a, 0xfa, 0x4b, 0x63, 0x46, 0xd1, 0xc0, 0xc6, 0x55, 0x84, 0x77, 0x60, 0x86,
-	0xb1, 0xbc, 0x41, 0xcb, 0xc1, 0x9f, 0x78, 0x2a, 0xe3, 0x3e, 0xd5, 0xa4, 0xe5, 0x33, 0xb8, 0x3e,
-	0xac, 0xad, 0xe8, 0x4b, 0x87, 0x34, 0xee, 0x51, 0x24, 0x0e, 0x6e, 0xcc, 0x3c, 0xa3, 0x24, 0x70,
-	0x1d, 0x20, 0x98, 0x06, 0xf0, 0xc7, 0x11, 0xe1, 0xf0, 0x04, 0x23, 0x49, 0xe3, 0x58, 0xbe, 0x99,
-	0x0d, 0xc8, 0xf9, 0x3d, 0x0d, 0x57, 0xc6, 0xb4, 0x39, 0x6e, 0xe4, 0xec, 0x06, 0xa8, 0x24, 0xf0,
-	0x1d, 0x28, 0xd4, 0x7a, 0xbd, 0x49, 0xcc, 0x48, 0x61, 0x8e, 0x13, 0xb7, 0xd3, 0xf3, 0xeb, 0x70,
-	0xbc, 0x8d, 0xe0, 0xcf, 0xfc, 0x7c, 0x3e, 0xb7, 0x37, 0x4a, 0x9f, 0x5f, 0x28, 0xe7, 0xef, 0xb6,
-	0x07, 0xb3, 0xb1, 0xaa, 0x8f, 0xe5, 0x98, 0x76, 0xac, 0x01, 0x49, 0x2b, 0x67, 0xf2, 0x7d, 0xab,
-	0x6d, 0x31, 0x7f, 0x46, 0x1f, 0xc5, 0xb0, 0x32, 0x7a, 0x08, 0xf1, 0x97, 0x3b, 0xe9, 0x7b, 0xe7,
-	0xca, 0x84, 0xb2, 0xf2, 0x18, 0x16, 0xc7, 0xbf, 0x1d, 0xe1, 0x2b, 0x63, 0x72, 0x66, 0xf4, 0x1d,
-	0x4c, 0xfa, 0xec, 0x22, 0xb1, 0xd0, 0x66, 0x4d, 0x28, 0x84, 0x7b, 0x19, 0x5e, 0x3a, 0xe7, 0x53,
-	0x5d, 0xfa, 0x64, 0x3c, 0x33, 0x30, 0xb7, 0xf1, 0xdd, 0x8b, 0xd7, 0x72, 0xe2, 0xe5, 0x6b, 0x39,
-	0xf1, 0xf6, 0xb5, 0x8c, 0x7e, 0x75, 0x2a, 0xa3, 0x3f, 0x9c, 0xca, 0xe8, 0xf9, 0xa9, 0x8c, 0x5e,
-	0x9c, 0xca, 0xe8, 0x5f, 0xa7, 0x32, 0xfa, 0xf7, 0xa9, 0x9c, 0x78, 0x7b, 0x2a, 0xa3, 0xdf, 0xbc,
-	0x91, 0x13, 0x2f, 0xde, 0xc8, 0x89, 0x97, 0x6f, 0xe4, 0xc4, 0x2f, 0xb2, 0x9d, 0x9e, 0x41, 0x2c,
-	0xda, 0xce, 0xb2, 0x27, 0xd0, 0x1b, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x69, 0x8a, 0xb2, 0x58,
-	0x7d, 0x15, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/ingester/client/ingester.proto", fileDescriptor_5b6c87318632a5b2)
+}
+
+var fileDescriptor_5b6c87318632a5b2 = []byte{
+	// 1752 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6f, 0x1b, 0xc7,
+	0x15, 0xe7, 0x90, 0x14, 0x23, 0x3e, 0x52, 0x32, 0x35, 0x92, 0x4d, 0x66, 0x15, 0xaf, 0x94, 0x6d,
+	0x9d, 0xb0, 0x69, 0x4a, 0x25, 0xb6, 0x1b, 0xb8, 0x69, 0x8a, 0x82, 0x92, 0x19, 0x9b, 0x4e, 0x28,
+	0x39, 0x4b, 0x29, 0xfd, 0x00, 0x82, 0xc5, 0x92, 0x1c, 0x51, 0x5b, 0x71, 0x97, 0xec, 0xce, 0x30,
+	0xb0, 0x72, 0xea, 0xa9, 0xe7, 0xfe, 0x05, 0x05, 0x7a, 0x2b, 0x7a, 0xec, 0x25, 0x97, 0xa2, 0xe7,
+	0x5c, 0x0a, 0xf8, 0xd6, 0xa0, 0x40, 0x8d, 0x5a, 0xbe, 0xf4, 0x18, 0xa0, 0xff, 0x40, 0x31, 0x1f,
+	0xfb, 0x49, 0xea, 0x2b, 0x48, 0x72, 0x22, 0xe7, 0xbd, 0xdf, 0xbc, 0xf9, 0xcd, 0x9b, 0x37, 0xef,
+	0xbd, 0x1d, 0x30, 0x26, 0xc7, 0xc3, 0x2d, 0xc7, 0x1b, 0x12, 0xca, 0x88, 0xbf, 0xd5, 0x1f, 0x39,
+	0xc4, 0x63, 0xe1, 0xb8, 0x31, 0xf1, 0xc7, 0x6c, 0x8c, 0x0b, 0xfd, 0xb1, 0xcf, 0xc8, 0x13, 0x6d,
+	0x6d, 0x38, 0x1e, 0x8e, 0x85, 0x68, 0x8b, 0xff, 0x93, 0x5a, 0xad, 0xca, 0x2d, 0xb8, 0x8e, 0xeb,
+	0xf8, 0x93, 0x9e, 0xfc, 0x55, 0x8a, 0xef, 0xcf, 0x28, 0xac, 0xfe, 0x94, 0xb2, 0xb1, 0x6b, 0xb1,
+	0x93, 0x09, 0xa1, 0x12, 0x65, 0xfc, 0x1e, 0x81, 0xf6, 0xa1, 0xdd, 0x23, 0xa3, 0x5d, 0xdb, 0x25,
+	0xb4, 0xe9, 0x0d, 0x3e, 0xb6, 0x47, 0x53, 0x42, 0x4d, 0xf2, 0xdb, 0x29, 0xa1, 0x0c, 0xbf, 0x05,
+	0x8b, 0xae, 0xcd, 0xfa, 0x47, 0xc4, 0xa7, 0x35, 0xb4, 0x99, 0xab, 0x97, 0x6e, 0xaf, 0x35, 0x24,
+	0x9d, 0x86, 0x98, 0xd5, 0x91, 0x4a, 0x33, 0x44, 0xe1, 0x77, 0xa0, 0xdc, 0x1f, 0x4f, 0x3d, 0x66,
+	0xb9, 0x84, 0x1d, 0x8d, 0x07, 0xb5, 0xec, 0x26, 0xaa, 0x2f, 0xdf, 0x5e, 0x0d, 0x66, 0xed, 0x70,
+	0x5d, 0x47, 0xa8, 0xcc, 0x52, 0x3f, 0x1a, 0x18, 0x0f, 0x61, 0x7d, 0x2e, 0x0f, 0x3a, 0x19, 0x7b,
+	0x94, 0xe0, 0x1f, 0xc0, 0x82, 0xc3, 0x88, 0x1b, 0xb0, 0x58, 0x4d, 0xb0, 0x50, 0x58, 0x89, 0x30,
+	0xee, 0x43, 0x29, 0x26, 0xc5, 0x37, 0x01, 0x46, 0x7c, 0x68, 0x79, 0xb6, 0x4b, 0x6a, 0x68, 0x13,
+	0xd5, 0x8b, 0x66, 0x71, 0x14, 0x2c, 0x85, 0x6f, 0x40, 0xe1, 0x53, 0x01, 0xac, 0x65, 0x37, 0x73,
+	0xf5, 0xa2, 0xa9, 0x46, 0xc6, 0x5f, 0x10, 0xdc, 0x8c, 0x99, 0xd9, 0xb1, 0xfd, 0x81, 0xe3, 0xd9,
+	0x23, 0x87, 0x9d, 0x04, 0xbe, 0xd9, 0x80, 0x52, 0x64, 0x58, 0x12, 0x2b, 0x9a, 0x10, 0x5a, 0xa6,
+	0x09, 0xe7, 0x65, 0xbf, 0x96, 0xf3, 0x72, 0x97, 0x74, 0xde, 0x01, 0xe8, 0x67, 0x71, 0x55, 0xfe,
+	0xbb, 0x93, 0xf4, 0xdf, 0xcd, 0x59, 0xff, 0x75, 0x89, 0xef, 0x10, 0x2a, 0x96, 0x08, 0x3c, 0xf9,
+	0x0c, 0xc1, 0xf5, 0xb9, 0x80, 0x8b, 0x9c, 0x6a, 0x03, 0x96, 0x6a, 0xe1, 0x4c, 0x8b, 0x8a, 0x99,
+	0xca, 0x07, 0x77, 0xce, 0x5d, 0x7a, 0x46, 0xda, 0xf2, 0x98, 0x7f, 0x62, 0x56, 0x46, 0x29, 0xb1,
+	0xb6, 0x33, 0x4b, 0x4d, 0x40, 0x71, 0x05, 0x72, 0xc7, 0xe4, 0x44, 0x71, 0xe2, 0x7f, 0xf1, 0x1a,
+	0x2c, 0x08, 0x1e, 0x22, 0x16, 0xf3, 0xa6, 0x1c, 0xbc, 0x9b, 0xbd, 0x87, 0x8c, 0x7f, 0x22, 0x28,
+	0x7f, 0x34, 0x25, 0x7e, 0x78, 0xa6, 0x6f, 0x02, 0xa6, 0xcc, 0xf6, 0x99, 0xc5, 0x1c, 0x97, 0x50,
+	0x66, 0xbb, 0x13, 0x4b, 0xf8, 0x0c, 0xd5, 0x73, 0x66, 0x45, 0x68, 0xf6, 0x03, 0x45, 0x87, 0xe2,
+	0x3a, 0x54, 0x88, 0x37, 0x48, 0x62, 0xb3, 0x02, 0xbb, 0x4c, 0xbc, 0x41, 0x1c, 0x19, 0x0f, 0x85,
+	0xdc, 0xa5, 0x42, 0xe1, 0x67, 0xb0, 0x4e, 0x99, 0x4f, 0x6c, 0xd7, 0xf1, 0x86, 0x56, 0xff, 0x68,
+	0xea, 0x1d, 0x53, 0xab, 0xc7, 0x95, 0x16, 0x75, 0x3e, 0x23, 0xb5, 0x81, 0xd8, 0x4a, 0x2d, 0x84,
+	0xec, 0x08, 0xc4, 0x36, 0x07, 0x74, 0x9d, 0xcf, 0x88, 0xf1, 0x27, 0x04, 0x6b, 0xad, 0x27, 0xc4,
+	0x9d, 0x8c, 0x6c, 0xff, 0x3b, 0xd9, 0xe1, 0xdb, 0x33, 0x3b, 0xbc, 0x3e, 0x6f, 0x87, 0x34, 0xda,
+	0xa2, 0xf1, 0x37, 0x04, 0xab, 0xcd, 0x3e, 0x73, 0x3e, 0x55, 0xe7, 0xf7, 0xf5, 0x93, 0xce, 0x4f,
+	0x21, 0xcf, 0x93, 0x9a, 0x4a, 0x36, 0xaf, 0x07, 0xe8, 0x39, 0xc6, 0x1b, 0xea, 0x77, 0xff, 0x64,
+	0x42, 0x4c, 0x31, 0xc9, 0x78, 0x07, 0x4a, 0x31, 0x21, 0x06, 0x28, 0x74, 0x5b, 0x66, 0xbb, 0xd5,
+	0xad, 0x64, 0xf0, 0x3a, 0x54, 0x77, 0x9b, 0xfb, 0xed, 0x8f, 0x5b, 0xd6, 0xc3, 0x76, 0x77, 0x7f,
+	0xef, 0x81, 0xd9, 0xec, 0x58, 0x4a, 0x89, 0x8c, 0x0f, 0x60, 0x49, 0x79, 0x56, 0xdd, 0xb1, 0x77,
+	0x01, 0x84, 0xa3, 0x64, 0xb4, 0x27, 0x99, 0x4f, 0x7a, 0x0d, 0xee, 0x2d, 0xc9, 0x65, 0x3b, 0xff,
+	0xc5, 0xb3, 0x8d, 0x8c, 0x19, 0x43, 0x1b, 0xff, 0xcb, 0xc2, 0xaa, 0xb0, 0xd6, 0x15, 0x27, 0x1a,
+	0xda, 0xfc, 0x39, 0x94, 0xe4, 0xe1, 0xc7, 0x8d, 0x56, 0x83, 0x0d, 0x46, 0x26, 0xc5, 0xf9, 0x2b,
+	0xbb, 0xf1, 0x19, 0x29, 0x52, 0xd9, 0xab, 0x90, 0xc2, 0x8f, 0xa0, 0x12, 0xc5, 0xa0, 0xb2, 0x20,
+	0xcf, 0xf6, 0xe5, 0x80, 0x41, 0x8c, 0x73, 0xc2, 0xcc, 0xb5, 0x70, 0xa2, 0x14, 0xe3, 0xbb, 0x50,
+	0x75, 0xa8, 0xc5, 0x83, 0x69, 0x7c, 0xa8, 0x6c, 0x59, 0x12, 0x53, 0xcb, 0x6f, 0xa2, 0xfa, 0xa2,
+	0xb9, 0xea, 0xd0, 0x96, 0x37, 0xd8, 0x3b, 0x94, 0x78, 0x69, 0x12, 0x7f, 0x02, 0xd5, 0x34, 0x03,
+	0x75, 0x19, 0x6a, 0x0b, 0x82, 0xc8, 0xc6, 0x99, 0x44, 0xd4, 0x8d, 0x90, 0x74, 0xae, 0xa7, 0xe8,
+	0x48, 0xa5, 0xf1, 0x1b, 0x58, 0x99, 0x99, 0x87, 0xef, 0x42, 0x41, 0x64, 0x9b, 0xc0, 0xdb, 0x37,
+	0x22, 0x6f, 0x89, 0xf0, 0x6b, 0x0e, 0xec, 0x09, 0x23, 0xbe, 0xb2, 0xac, 0xb0, 0xbc, 0x1a, 0x08,
+	0x62, 0x96, 0xc8, 0xcb, 0xea, 0x92, 0x80, 0x10, 0x89, 0xc4, 0x66, 0x38, 0x50, 0x3d, 0x83, 0x23,
+	0x7e, 0x15, 0xca, 0x6a, 0x6f, 0x8e, 0x37, 0x20, 0x4f, 0xc4, 0x6d, 0xcc, 0x9b, 0x25, 0x29, 0x6b,
+	0x73, 0x11, 0xfe, 0x21, 0x14, 0xd4, 0xbe, 0xe5, 0x11, 0x2e, 0x85, 0x35, 0x21, 0x76, 0xf0, 0x0a,
+	0x62, 0x74, 0xe1, 0x7a, 0xea, 0xee, 0x7f, 0x03, 0x11, 0xfa, 0x77, 0x04, 0x38, 0x5e, 0x6d, 0xd5,
+	0x65, 0xbd, 0xa0, 0x12, 0xcc, 0x4f, 0x37, 0xd9, 0x2b, 0xa4, 0x9b, 0xdc, 0x85, 0xe9, 0x86, 0xc7,
+	0xcf, 0x25, 0xd2, 0xcd, 0x3d, 0x58, 0x4d, 0xf0, 0x57, 0x3e, 0x79, 0x15, 0xca, 0xb1, 0x5a, 0x15,
+	0xd4, 0xf1, 0x52, 0x54, 0x70, 0xa8, 0xf1, 0x47, 0x04, 0x2b, 0x51, 0x73, 0xf2, 0xdd, 0x66, 0xd2,
+	0x4b, 0x6d, 0xed, 0xc7, 0xea, 0x68, 0x14, 0x3f, 0xb5, 0xb3, 0x8b, 0x1a, 0x14, 0xe3, 0x11, 0x54,
+	0x0e, 0x28, 0xf1, 0xbb, 0xcc, 0x66, 0xe1, 0xae, 0xd2, 0x2d, 0x08, 0xba, 0x64, 0x0b, 0xf2, 0x39,
+	0x82, 0x95, 0x98, 0x31, 0x45, 0xe1, 0x16, 0x2c, 0xcb, 0x6e, 0xd6, 0x19, 0x7b, 0x96, 0x6f, 0x33,
+	0x19, 0x21, 0xc8, 0x5c, 0x0a, 0xa5, 0xa6, 0xcd, 0x08, 0x0f, 0x22, 0x6f, 0xea, 0x46, 0x7d, 0x02,
+	0x0f, 0xff, 0xa2, 0x37, 0x0d, 0x6e, 0xe4, 0x9b, 0x80, 0xed, 0x89, 0x63, 0xa5, 0x2c, 0xe5, 0x84,
+	0xa5, 0x8a, 0x3d, 0x71, 0xda, 0x09, 0x63, 0x0d, 0x58, 0xf5, 0xa7, 0x23, 0x92, 0x86, 0xe7, 0x05,
+	0x7c, 0x85, 0xab, 0x12, 0x78, 0xe3, 0x13, 0x58, 0xe5, 0xc4, 0xdb, 0xf7, 0x93, 0xd4, 0xab, 0xf0,
+	0xd2, 0x94, 0x12, 0xdf, 0x72, 0x06, 0x2a, 0xaa, 0x0b, 0x7c, 0xd8, 0x1e, 0xe0, 0x1f, 0x41, 0x7e,
+	0x60, 0x33, 0x5b, 0xd0, 0x8c, 0x65, 0xc2, 0x99, 0xcd, 0x9b, 0x02, 0x66, 0x3c, 0x00, 0xcc, 0x55,
+	0x34, 0x69, 0xfd, 0x6d, 0x58, 0xa0, 0x5c, 0xa0, 0x2e, 0xe1, 0x7a, 0xdc, 0x4a, 0x8a, 0x89, 0x29,
+	0x91, 0xc6, 0x5f, 0x11, 0xe8, 0x1d, 0xc2, 0x7c, 0xa7, 0x4f, 0xdf, 0x1f, 0xfb, 0xc9, 0x50, 0xf8,
+	0x96, 0x43, 0xf2, 0x1e, 0x94, 0x83, 0x58, 0xb3, 0x28, 0x61, 0xe7, 0x17, 0xf8, 0x52, 0x00, 0xed,
+	0x12, 0x66, 0x7c, 0x00, 0x1b, 0x67, 0x72, 0x56, 0xae, 0xa8, 0x43, 0xc1, 0x15, 0x10, 0xe5, 0x8b,
+	0x4a, 0x94, 0x90, 0xe4, 0x54, 0x53, 0xe9, 0x8d, 0x09, 0xdc, 0x50, 0xc6, 0x3a, 0x84, 0xd9, 0xdc,
+	0xbb, 0xc1, 0xc6, 0xd7, 0x60, 0x61, 0xe4, 0xb8, 0x0e, 0x13, 0x7b, 0x5d, 0x31, 0xe5, 0x80, 0x6f,
+	0x50, 0xfc, 0xb1, 0x26, 0xc4, 0xb7, 0xd4, 0x1a, 0x59, 0x01, 0x58, 0x16, 0xf2, 0xc7, 0xc4, 0x97,
+	0xf6, 0xf8, 0x57, 0x80, 0xd2, 0xe7, 0xe4, 0x59, 0xab, 0x15, 0xf7, 0xa0, 0x3a, 0xb3, 0xa2, 0xa2,
+	0x7d, 0x17, 0x16, 0x5d, 0x25, 0x53, 0xc4, 0x6b, 0x69, 0xe2, 0xe1, 0x9c, 0x10, 0x69, 0xf4, 0x61,
+	0x2d, 0xd9, 0x95, 0x5c, 0xd5, 0x09, 0x3c, 0x5f, 0xf5, 0xa6, 0xfd, 0x63, 0xc2, 0xc2, 0x4a, 0x93,
+	0xe3, 0xc5, 0x42, 0xca, 0x64, 0xa9, 0xf9, 0x1c, 0xc1, 0xb5, 0x54, 0x6b, 0xc0, 0x7d, 0x71, 0xe8,
+	0x8f, 0x5d, 0x2b, 0xf8, 0xb8, 0x8c, 0xe2, 0x7a, 0x99, 0xcb, 0xdb, 0x4a, 0xdc, 0x1e, 0xc4, 0x03,
+	0x3f, 0x9b, 0x08, 0xfc, 0xa8, 0x30, 0xe6, 0xae, 0x50, 0x18, 0xa3, 0xca, 0x95, 0xbf, 0xb8, 0x72,
+	0xfd, 0x03, 0xc1, 0x82, 0xe4, 0xfb, 0x6d, 0x85, 0xb2, 0x06, 0x8b, 0xc4, 0xeb, 0x8f, 0x07, 0x8e,
+	0x37, 0x14, 0x67, 0xbd, 0x60, 0x86, 0x63, 0xfc, 0x58, 0xdd, 0x6c, 0x9e, 0x2a, 0xca, 0xdb, 0xef,
+	0x71, 0x66, 0xff, 0x7a, 0xb6, 0x71, 0x77, 0xe8, 0xb0, 0xa3, 0x69, 0xaf, 0xd1, 0x1f, 0xbb, 0x5b,
+	0x43, 0xdf, 0x3e, 0xb4, 0x3d, 0x5b, 0x7e, 0x4f, 0x6f, 0xc5, 0xbe, 0xb0, 0x1b, 0x07, 0x1e, 0xb5,
+	0x0f, 0xc9, 0xf6, 0x09, 0x23, 0xdd, 0x91, 0xd3, 0x0f, 0x2e, 0x7f, 0x13, 0x96, 0x12, 0x41, 0x7f,
+	0xf5, 0xde, 0xd6, 0xb0, 0xa0, 0x1c, 0xd7, 0xe0, 0x5b, 0xaa, 0xd7, 0x95, 0x89, 0x79, 0x25, 0x98,
+	0x2d, 0xd4, 0x51, 0x57, 0x8b, 0x31, 0xe4, 0x45, 0x45, 0x96, 0x47, 0x28, 0xfe, 0x47, 0x1f, 0x42,
+	0x32, 0xc8, 0xe5, 0xe0, 0x8d, 0x3a, 0x94, 0x62, 0x59, 0x1d, 0x2f, 0x41, 0xb1, 0xbd, 0x6b, 0x75,
+	0x5a, 0x9d, 0x3d, 0xf3, 0x57, 0x95, 0x0c, 0x6f, 0x87, 0x9b, 0x3b, 0xbc, 0x05, 0xae, 0xa0, 0x37,
+	0x1e, 0x41, 0x31, 0x5c, 0x06, 0x17, 0x61, 0xa1, 0xf5, 0xd1, 0x41, 0xf3, 0xc3, 0x4a, 0x86, 0x4f,
+	0xd9, 0xdd, 0xdb, 0xb7, 0xe4, 0x10, 0xe1, 0x6b, 0x50, 0x32, 0x5b, 0x0f, 0x5a, 0xbf, 0xb4, 0x3a,
+	0xcd, 0xfd, 0x9d, 0x87, 0x95, 0x2c, 0xc6, 0xb0, 0x2c, 0x05, 0xbb, 0x7b, 0x4a, 0x96, 0xbb, 0xfd,
+	0xef, 0x97, 0x60, 0x31, 0x08, 0x3a, 0xfc, 0x13, 0xc8, 0x3f, 0x9e, 0xd2, 0x23, 0x1c, 0x8b, 0xa8,
+	0x5f, 0xf8, 0x0e, 0x23, 0xea, 0x7a, 0x6b, 0xd5, 0x19, 0xb9, 0xbc, 0x36, 0x46, 0x06, 0xdf, 0x87,
+	0x52, 0xac, 0xad, 0xc2, 0x6b, 0x89, 0x7e, 0x30, 0x98, 0xbf, 0x3e, 0xa7, 0x4b, 0x8c, 0x6c, 0xbc,
+	0x85, 0xf0, 0x1e, 0x2c, 0x0b, 0x55, 0xd0, 0x36, 0x51, 0xfc, 0x4a, 0x30, 0x65, 0xde, 0x57, 0x94,
+	0x76, 0xf3, 0x0c, 0x6d, 0x48, 0xeb, 0x61, 0xf2, 0x11, 0x42, 0x9b, 0xf7, 0x5e, 0x91, 0x26, 0x37,
+	0xa7, 0x3b, 0x31, 0x32, 0xb8, 0x05, 0x10, 0xd5, 0x76, 0xfc, 0x72, 0x02, 0x1c, 0xef, 0x47, 0x34,
+	0x6d, 0x9e, 0x2a, 0x34, 0xb3, 0x0d, 0xc5, 0xb0, 0x42, 0xe1, 0xda, 0x9c, 0xa2, 0x25, 0x8d, 0x9c,
+	0x5d, 0xce, 0x8c, 0x0c, 0x7e, 0x1f, 0xca, 0xcd, 0xd1, 0xe8, 0x32, 0x66, 0xb4, 0xb8, 0x86, 0xa6,
+	0xed, 0x8c, 0xc2, 0xac, 0x9a, 0x2e, 0x0a, 0xf8, 0xb5, 0x30, 0x9e, 0xcf, 0xad, 0x74, 0xda, 0xeb,
+	0x17, 0xe2, 0xc2, 0xd5, 0xf6, 0xe1, 0x5a, 0x2a, 0x87, 0x63, 0x3d, 0x35, 0x3b, 0x55, 0x4e, 0xb4,
+	0x8d, 0x33, 0xf5, 0xa1, 0xd5, 0x9e, 0xea, 0x26, 0x93, 0xef, 0x55, 0xd8, 0x98, 0x3d, 0x84, 0xf4,
+	0xa3, 0x9a, 0xf6, 0xbd, 0x73, 0x31, 0xb1, 0xa8, 0x3c, 0x86, 0x1b, 0xf3, 0x9f, 0x75, 0xf0, 0xad,
+	0x39, 0x31, 0x33, 0xfb, 0x44, 0xa5, 0xbd, 0x76, 0x11, 0x2c, 0xb6, 0x58, 0x07, 0xca, 0xf1, 0xca,
+	0x84, 0xd7, 0xcf, 0xf9, 0x8a, 0xd6, 0x5e, 0x99, 0xaf, 0x8c, 0xcc, 0x6d, 0xbf, 0xf7, 0xf4, 0xb9,
+	0x9e, 0xf9, 0xf2, 0xb9, 0x9e, 0xf9, 0xea, 0xb9, 0x8e, 0x7e, 0x77, 0xaa, 0xa3, 0x3f, 0x9f, 0xea,
+	0xe8, 0x8b, 0x53, 0x1d, 0x3d, 0x3d, 0xd5, 0xd1, 0x7f, 0x4e, 0x75, 0xf4, 0xdf, 0x53, 0x3d, 0xf3,
+	0xd5, 0xa9, 0x8e, 0xfe, 0xf0, 0x42, 0xcf, 0x3c, 0x7d, 0xa1, 0x67, 0xbe, 0x7c, 0xa1, 0x67, 0x7e,
+	0x5d, 0x90, 0x4f, 0xa0, 0xbd, 0x82, 0x78, 0x9d, 0xbc, 0xf3, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x47, 0x14, 0x6f, 0xa3, 0x20, 0x15, 0x00, 0x00,
 }
 
 func (x CountMethod) String() string {
@@ -2322,7 +2338,7 @@ func (this *QueryStreamSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -2815,7 +2831,7 @@ func (this *TimeSeriesChunk) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -3108,7 +3124,13 @@ func (this *QueryStreamSeries) GoString() string {
 	}
 	s := make([]string, 0, 6)
 	s = append(s, "&client.QueryStreamSeries{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "ChunkCount: "+fmt.Sprintf("%#v", this.ChunkCount)+",\n")
 	s = append(s, "}")
 	return strings.Join(s, "")
@@ -3314,7 +3336,13 @@ func (this *TimeSeriesChunk) GoString() string {
 	s = append(s, "&client.TimeSeriesChunk{")
 	s = append(s, "FromIngesterId: "+fmt.Sprintf("%#v", this.FromIngesterId)+",\n")
 	s = append(s, "UserId: "+fmt.Sprintf("%#v", this.UserId)+",\n")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	if this.Chunks != nil {
 		vs := make([]*Chunk, len(this.Chunks))
 		for i := range vs {
@@ -3963,7 +3991,7 @@ var _Ingester_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 		},
 	},
-	Metadata: "ingester.proto",
+	Metadata: "pkg/ingester/client/ingester.proto",
 }
 
 func (m *LabelNamesAndValuesRequest) Marshal() (dAtA []byte, err error) {
@@ -4516,11 +4544,11 @@ func (m *QueryStreamSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintIngester(dAtA, i, uint64(size))
 			}
 			i--
@@ -5176,11 +5204,11 @@ func (m *TimeSeriesChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintIngester(dAtA, i, uint64(size))
 			}
 			i--
@@ -6137,8 +6165,13 @@ func (this *QueryStreamSeries) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&QueryStreamSeries{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`ChunkCount:` + fmt.Sprintf("%v", this.ChunkCount) + `,`,
 		`}`,
 	}, "")
@@ -6348,6 +6381,11 @@ func (this *TimeSeriesChunk) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	repeatedStringForChunks := "[]Chunk{"
 	for _, f := range this.Chunks {
 		repeatedStringForChunks += strings.Replace(strings.Replace(f.String(), "Chunk", "Chunk", 1), `&`, ``, 1) + ","
@@ -6356,7 +6394,7 @@ func (this *TimeSeriesChunk) String() string {
 	s := strings.Join([]string{`&TimeSeriesChunk{`,
 		`FromIngesterId:` + fmt.Sprintf("%v", this.FromIngesterId) + `,`,
 		`UserId:` + fmt.Sprintf("%v", this.UserId) + `,`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`Chunks:` + repeatedStringForChunks + `,`,
 		`}`,
 	}, "")
@@ -7872,7 +7910,7 @@ func (m *QueryStreamSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -9665,7 +9703,7 @@ func (m *TimeSeriesChunk) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/ingester/client/ingester.proto b/pkg/ingester/client/ingester.proto
index b2dd18b2a90..bdba5ad2ec2 100644
--- a/pkg/ingester/client/ingester.proto
+++ b/pkg/ingester/client/ingester.proto
@@ -10,8 +10,9 @@ package cortex;
 
 option go_package = "client";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
@@ -123,7 +124,7 @@ message QueryStreamResponse {
 }
 
 message QueryStreamSeries {
-  repeated cortexpb.LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"];
+  repeated cortexpb.LabelAdapter labels = 1 [(gogoproto.nullable) = false];
   int64 chunk_count = 2;
 }
 
@@ -207,7 +208,7 @@ message ActiveSeriesResponse {
 message TimeSeriesChunk {
   string from_ingester_id = 1;
   string user_id = 2;
-  repeated cortexpb.LabelPair labels = 3 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"];
+  repeated cortexpb.LabelAdapter labels = 3 [(gogoproto.nullable) = false];
   repeated Chunk chunks = 4 [(gogoproto.nullable) = false];
 }
 
diff --git a/pkg/mimirpb/mimir.pb.go b/pkg/mimirpb/mimir.pb.go
index 2fcc5ccde13..d7617b0f2c9 100644
--- a/pkg/mimirpb/mimir.pb.go
+++ b/pkg/mimirpb/mimir.pb.go
@@ -1,10 +1,9 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: mimir.proto
+// source: pkg/mimirpb/mimir.proto
 
 package mimirpb
 
 import (
-	bytes "bytes"
 	encoding_binary "encoding/binary"
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
@@ -80,7 +79,7 @@ var ErrorCause_value = map[string]int32{
 }
 
 func (ErrorCause) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{0}
+	return fileDescriptor_e7552b50e8c2985e, []int{0}
 }
 
 type WriteRequest_SourceEnum int32
@@ -101,7 +100,7 @@ var WriteRequest_SourceEnum_value = map[string]int32{
 }
 
 func (WriteRequest_SourceEnum) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{0, 0}
+	return fileDescriptor_e7552b50e8c2985e, []int{0, 0}
 }
 
 type MetricMetadata_MetricType int32
@@ -140,7 +139,7 @@ var MetricMetadata_MetricType_value = map[string]int32{
 }
 
 func (MetricMetadata_MetricType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{6, 0}
+	return fileDescriptor_e7552b50e8c2985e, []int{5, 0}
 }
 
 type Histogram_ResetHint int32
@@ -167,7 +166,7 @@ var Histogram_ResetHint_value = map[string]int32{
 }
 
 func (Histogram_ResetHint) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{9, 0}
+	return fileDescriptor_e7552b50e8c2985e, []int{8, 0}
 }
 
 // These values correspond to the possible status values defined in https://github.com/prometheus/prometheus/blob/main/web/api/v1/api.go.
@@ -189,7 +188,7 @@ var QueryResponse_Status_value = map[string]int32{
 }
 
 func (QueryResponse_Status) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{16, 0}
+	return fileDescriptor_e7552b50e8c2985e, []int{15, 0}
 }
 
 // These values correspond to the possible error type values defined in https://github.com/prometheus/prometheus/blob/main/web/api/v1/api.go.
@@ -232,7 +231,7 @@ var QueryResponse_ErrorType_value = map[string]int32{
 }
 
 func (QueryResponse_ErrorType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{16, 1}
+	return fileDescriptor_e7552b50e8c2985e, []int{15, 1}
 }
 
 type WriteRequest struct {
@@ -243,15 +242,12 @@ type WriteRequest struct {
 	SkipLabelValidation bool `protobuf:"varint,1000,opt,name=skip_label_validation,json=skipLabelValidation,proto3" json:"skip_label_validation,omitempty"`
 	// Skip label count validation.
 	SkipLabelCountValidation bool `protobuf:"varint,1001,opt,name=skip_label_count_validation,json=skipLabelCountValidation,proto3" json:"skip_label_count_validation,omitempty"`
-
-	// Skip unmarshaling of exemplars.
-	skipUnmarshalingExemplars bool
 }
 
 func (m *WriteRequest) Reset()      { *m = WriteRequest{} }
 func (*WriteRequest) ProtoMessage() {}
 func (*WriteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{0}
+	return fileDescriptor_e7552b50e8c2985e, []int{0}
 }
 func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -314,7 +310,7 @@ type WriteResponse struct {
 func (m *WriteResponse) Reset()      { *m = WriteResponse{} }
 func (*WriteResponse) ProtoMessage() {}
 func (*WriteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{1}
+	return fileDescriptor_e7552b50e8c2985e, []int{1}
 }
 func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -350,7 +346,7 @@ type ErrorDetails struct {
 func (m *ErrorDetails) Reset()      { *m = ErrorDetails{} }
 func (*ErrorDetails) ProtoMessage() {}
 func (*ErrorDetails) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{2}
+	return fileDescriptor_e7552b50e8c2985e, []int{2}
 }
 func (m *ErrorDetails) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -387,20 +383,17 @@ func (m *ErrorDetails) GetCause() ErrorCause {
 }
 
 type TimeSeries struct {
-	Labels []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=LabelAdapter" json:"labels"`
+	Labels []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
 	// Sorted by time, oldest sample first.
 	Samples    []Sample    `protobuf:"bytes,2,rep,name=samples,proto3" json:"samples"`
 	Exemplars  []Exemplar  `protobuf:"bytes,3,rep,name=exemplars,proto3" json:"exemplars"`
 	Histograms []Histogram `protobuf:"bytes,4,rep,name=histograms,proto3" json:"histograms"`
-
-	// Skip unmarshaling of exemplars.
-	SkipUnmarshalingExemplars bool
 }
 
 func (m *TimeSeries) Reset()      { *m = TimeSeries{} }
 func (*TimeSeries) ProtoMessage() {}
 func (*TimeSeries) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{3}
+	return fileDescriptor_e7552b50e8c2985e, []int{3}
 }
 func (m *TimeSeries) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -429,6 +422,13 @@ func (m *TimeSeries) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_TimeSeries proto.InternalMessageInfo
 
+func (m *TimeSeries) GetLabels() []LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 func (m *TimeSeries) GetSamples() []Sample {
 	if m != nil {
 		return m.Samples
@@ -450,57 +450,6 @@ func (m *TimeSeries) GetHistograms() []Histogram {
 	return nil
 }
 
-type LabelPair struct {
-	Name  []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
-}
-
-func (m *LabelPair) Reset()      { *m = LabelPair{} }
-func (*LabelPair) ProtoMessage() {}
-func (*LabelPair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{4}
-}
-func (m *LabelPair) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *LabelPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_LabelPair.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 *LabelPair) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_LabelPair.Merge(m, src)
-}
-func (m *LabelPair) XXX_Size() int {
-	return m.Size()
-}
-func (m *LabelPair) XXX_DiscardUnknown() {
-	xxx_messageInfo_LabelPair.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_LabelPair proto.InternalMessageInfo
-
-func (m *LabelPair) GetName() []byte {
-	if m != nil {
-		return m.Name
-	}
-	return nil
-}
-
-func (m *LabelPair) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
 type Sample struct {
 	// Fields order MUST match promql.FPoint so that we can cast types between them.
 	TimestampMs int64   `protobuf:"varint,2,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
@@ -510,7 +459,7 @@ type Sample struct {
 func (m *Sample) Reset()      { *m = Sample{} }
 func (*Sample) ProtoMessage() {}
 func (*Sample) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{5}
+	return fileDescriptor_e7552b50e8c2985e, []int{4}
 }
 func (m *Sample) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -563,7 +512,7 @@ type MetricMetadata struct {
 func (m *MetricMetadata) Reset()      { *m = MetricMetadata{} }
 func (*MetricMetadata) ProtoMessage() {}
 func (*MetricMetadata) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{6}
+	return fileDescriptor_e7552b50e8c2985e, []int{5}
 }
 func (m *MetricMetadata) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -621,13 +570,13 @@ func (m *MetricMetadata) GetUnit() string {
 }
 
 type Metric struct {
-	Labels []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=LabelAdapter" json:"labels"`
+	Labels []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
 }
 
 func (m *Metric) Reset()      { *m = Metric{} }
 func (*Metric) ProtoMessage() {}
 func (*Metric) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{7}
+	return fileDescriptor_e7552b50e8c2985e, []int{6}
 }
 func (m *Metric) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -656,9 +605,16 @@ func (m *Metric) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Metric proto.InternalMessageInfo
 
+func (m *Metric) GetLabels() []LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 type Exemplar struct {
 	// Exemplar labels, different than series labels
-	Labels      []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=LabelAdapter" json:"labels"`
+	Labels      []LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
 	Value       float64        `protobuf:"fixed64,2,opt,name=value,proto3" json:"value,omitempty"`
 	TimestampMs int64          `protobuf:"varint,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"`
 }
@@ -666,7 +622,7 @@ type Exemplar struct {
 func (m *Exemplar) Reset()      { *m = Exemplar{} }
 func (*Exemplar) ProtoMessage() {}
 func (*Exemplar) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{8}
+	return fileDescriptor_e7552b50e8c2985e, []int{7}
 }
 func (m *Exemplar) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -695,6 +651,13 @@ func (m *Exemplar) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Exemplar proto.InternalMessageInfo
 
+func (m *Exemplar) GetLabels() []LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
 func (m *Exemplar) GetValue() float64 {
 	if m != nil {
 		return m.Value
@@ -753,7 +716,7 @@ type Histogram struct {
 func (m *Histogram) Reset()      { *m = Histogram{} }
 func (*Histogram) ProtoMessage() {}
 func (*Histogram) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{9}
+	return fileDescriptor_e7552b50e8c2985e, []int{8}
 }
 func (m *Histogram) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -961,7 +924,7 @@ type FloatHistogram struct {
 func (m *FloatHistogram) Reset()      { *m = FloatHistogram{} }
 func (*FloatHistogram) ProtoMessage() {}
 func (*FloatHistogram) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{10}
+	return fileDescriptor_e7552b50e8c2985e, []int{9}
 }
 func (m *FloatHistogram) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1084,7 +1047,7 @@ type BucketSpan struct {
 func (m *BucketSpan) Reset()      { *m = BucketSpan{} }
 func (*BucketSpan) ProtoMessage() {}
 func (*BucketSpan) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{11}
+	return fileDescriptor_e7552b50e8c2985e, []int{10}
 }
 func (m *BucketSpan) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1136,7 +1099,7 @@ type FloatHistogramPair struct {
 func (m *FloatHistogramPair) Reset()      { *m = FloatHistogramPair{} }
 func (*FloatHistogramPair) ProtoMessage() {}
 func (*FloatHistogramPair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{12}
+	return fileDescriptor_e7552b50e8c2985e, []int{11}
 }
 func (m *FloatHistogramPair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1191,7 +1154,7 @@ type SampleHistogram struct {
 func (m *SampleHistogram) Reset()      { *m = SampleHistogram{} }
 func (*SampleHistogram) ProtoMessage() {}
 func (*SampleHistogram) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{13}
+	return fileDescriptor_e7552b50e8c2985e, []int{12}
 }
 func (m *SampleHistogram) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1252,7 +1215,7 @@ type HistogramBucket struct {
 func (m *HistogramBucket) Reset()      { *m = HistogramBucket{} }
 func (*HistogramBucket) ProtoMessage() {}
 func (*HistogramBucket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{14}
+	return fileDescriptor_e7552b50e8c2985e, []int{13}
 }
 func (m *HistogramBucket) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1318,7 +1281,7 @@ type SampleHistogramPair struct {
 func (m *SampleHistogramPair) Reset()      { *m = SampleHistogramPair{} }
 func (*SampleHistogramPair) ProtoMessage() {}
 func (*SampleHistogramPair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{15}
+	return fileDescriptor_e7552b50e8c2985e, []int{14}
 }
 func (m *SampleHistogramPair) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1379,7 +1342,7 @@ type QueryResponse struct {
 func (m *QueryResponse) Reset()      { *m = QueryResponse{} }
 func (*QueryResponse) ProtoMessage() {}
 func (*QueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{16}
+	return fileDescriptor_e7552b50e8c2985e, []int{15}
 }
 func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1521,7 +1484,7 @@ type StringData struct {
 func (m *StringData) Reset()      { *m = StringData{} }
 func (*StringData) ProtoMessage() {}
 func (*StringData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{17}
+	return fileDescriptor_e7552b50e8c2985e, []int{16}
 }
 func (m *StringData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1572,7 +1535,7 @@ type VectorData struct {
 func (m *VectorData) Reset()      { *m = VectorData{} }
 func (*VectorData) ProtoMessage() {}
 func (*VectorData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{18}
+	return fileDescriptor_e7552b50e8c2985e, []int{17}
 }
 func (m *VectorData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1625,7 +1588,7 @@ type VectorSample struct {
 func (m *VectorSample) Reset()      { *m = VectorSample{} }
 func (*VectorSample) ProtoMessage() {}
 func (*VectorSample) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{19}
+	return fileDescriptor_e7552b50e8c2985e, []int{18}
 }
 func (m *VectorSample) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1685,7 +1648,7 @@ type VectorHistogram struct {
 func (m *VectorHistogram) Reset()      { *m = VectorHistogram{} }
 func (*VectorHistogram) ProtoMessage() {}
 func (*VectorHistogram) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{20}
+	return fileDescriptor_e7552b50e8c2985e, []int{19}
 }
 func (m *VectorHistogram) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1743,7 +1706,7 @@ type ScalarData struct {
 func (m *ScalarData) Reset()      { *m = ScalarData{} }
 func (*ScalarData) ProtoMessage() {}
 func (*ScalarData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{21}
+	return fileDescriptor_e7552b50e8c2985e, []int{20}
 }
 func (m *ScalarData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1793,7 +1756,7 @@ type MatrixData struct {
 func (m *MatrixData) Reset()      { *m = MatrixData{} }
 func (*MatrixData) ProtoMessage() {}
 func (*MatrixData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{22}
+	return fileDescriptor_e7552b50e8c2985e, []int{21}
 }
 func (m *MatrixData) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1839,7 +1802,7 @@ type MatrixSeries struct {
 func (m *MatrixSeries) Reset()      { *m = MatrixSeries{} }
 func (*MatrixSeries) ProtoMessage() {}
 func (*MatrixSeries) Descriptor() ([]byte, []int) {
-	return fileDescriptor_86d4d7485f544059, []int{23}
+	return fileDescriptor_e7552b50e8c2985e, []int{22}
 }
 func (m *MatrixSeries) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1900,7 +1863,6 @@ func init() {
 	proto.RegisterType((*WriteResponse)(nil), "cortexpb.WriteResponse")
 	proto.RegisterType((*ErrorDetails)(nil), "cortexpb.ErrorDetails")
 	proto.RegisterType((*TimeSeries)(nil), "cortexpb.TimeSeries")
-	proto.RegisterType((*LabelPair)(nil), "cortexpb.LabelPair")
 	proto.RegisterType((*Sample)(nil), "cortexpb.Sample")
 	proto.RegisterType((*MetricMetadata)(nil), "cortexpb.MetricMetadata")
 	proto.RegisterType((*Metric)(nil), "cortexpb.Metric")
@@ -1922,137 +1884,136 @@ func init() {
 	proto.RegisterType((*MatrixSeries)(nil), "cortexpb.MatrixSeries")
 }
 
-func init() { proto.RegisterFile("mimir.proto", fileDescriptor_86d4d7485f544059) }
-
-var fileDescriptor_86d4d7485f544059 = []byte{
-	// 2029 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x93, 0xdb, 0x48,
-	0xf5, 0xb7, 0x6c, 0xf9, 0x87, 0xde, 0xd8, 0x33, 0x9d, 0x4e, 0x36, 0x5f, 0x6f, 0xbe, 0x1b, 0x27,
-	0xd1, 0x16, 0xcb, 0x90, 0x82, 0x09, 0xb5, 0x81, 0x6c, 0x6d, 0x2a, 0xfc, 0x90, 0x6d, 0x25, 0xe3,
-	0xc4, 0x96, 0x67, 0x5b, 0xf2, 0x84, 0x70, 0x51, 0x69, 0x3c, 0x3d, 0x33, 0xaa, 0xb5, 0x2c, 0x23,
-	0xc9, 0xd9, 0x0c, 0x27, 0x2e, 0x50, 0x14, 0x27, 0x2e, 0x5c, 0x28, 0x6e, 0x5c, 0xa8, 0xe2, 0x1f,
-	0x49, 0x15, 0x97, 0x1c, 0x17, 0x0e, 0x29, 0x32, 0xb9, 0x2c, 0x07, 0xaa, 0xb6, 0x28, 0x4e, 0x9c,
-	0xa8, 0xee, 0xd6, 0x4f, 0xcf, 0x0c, 0x04, 0xc8, 0x4d, 0xef, 0xbd, 0xcf, 0x7b, 0xfd, 0xba, 0xdf,
-	0x8f, 0x7e, 0x2d, 0x58, 0xf3, 0x5c, 0xcf, 0x0d, 0xb6, 0x16, 0x81, 0x1f, 0xf9, 0xb8, 0x31, 0xf5,
-	0x83, 0x88, 0x3e, 0x5b, 0xec, 0x5d, 0xf9, 0xc6, 0xa1, 0x1b, 0x1d, 0x2d, 0xf7, 0xb6, 0xa6, 0xbe,
-	0x77, 0xeb, 0xd0, 0x3f, 0xf4, 0x6f, 0x71, 0xc0, 0xde, 0xf2, 0x80, 0x53, 0x9c, 0xe0, 0x5f, 0x42,
-	0x51, 0xfd, 0x6b, 0x19, 0x9a, 0x8f, 0x03, 0x37, 0xa2, 0x84, 0xfe, 0x68, 0x49, 0xc3, 0x08, 0xef,
-	0x00, 0x44, 0xae, 0x47, 0x43, 0x1a, 0xb8, 0x34, 0x6c, 0x4b, 0xd7, 0x2b, 0x9b, 0x6b, 0x1f, 0x5e,
-	0xda, 0x4a, 0xcc, 0x6f, 0x59, 0xae, 0x47, 0x4d, 0x2e, 0xeb, 0x5e, 0x79, 0xfe, 0xf2, 0x5a, 0xe9,
-	0x4f, 0x2f, 0xaf, 0xe1, 0x9d, 0x80, 0x3a, 0xb3, 0x99, 0x3f, 0xb5, 0x52, 0x3d, 0x92, 0xb3, 0x81,
-	0x3f, 0x86, 0x9a, 0xe9, 0x2f, 0x83, 0x29, 0x6d, 0x97, 0xaf, 0x4b, 0x9b, 0xeb, 0x1f, 0xde, 0xc8,
-	0xac, 0xe5, 0x57, 0xde, 0x12, 0x20, 0x7d, 0xbe, 0xf4, 0x48, 0xac, 0x80, 0xef, 0x42, 0xc3, 0xa3,
-	0x91, 0xb3, 0xef, 0x44, 0x4e, 0xbb, 0xc2, 0x5d, 0x69, 0x67, 0xca, 0x23, 0x1a, 0x05, 0xee, 0x74,
-	0x14, 0xcb, 0xbb, 0xf2, 0xf3, 0x97, 0xd7, 0x24, 0x92, 0xe2, 0xf1, 0x6d, 0x78, 0x27, 0xfc, 0xd4,
-	0x5d, 0xd8, 0x33, 0x67, 0x8f, 0xce, 0xec, 0xa7, 0xce, 0xcc, 0xdd, 0x77, 0x22, 0xd7, 0x9f, 0xb7,
-	0xbf, 0xa8, 0x5f, 0x97, 0x36, 0x1b, 0xe4, 0x22, 0x93, 0x0e, 0x99, 0x70, 0x37, 0x95, 0xe1, 0xef,
-	0xc2, 0xff, 0xe7, 0x94, 0xa6, 0xfe, 0x72, 0x1e, 0xe5, 0x55, 0xff, 0x22, 0x54, 0xdb, 0xa9, 0x6a,
-	0x8f, 0x21, 0x32, 0x7d, 0xf5, 0x1a, 0x40, 0xb6, 0x0d, 0x5c, 0x87, 0x8a, 0xb6, 0x33, 0x40, 0x25,
-	0xdc, 0x00, 0x99, 0x4c, 0x86, 0x3a, 0x92, 0xd4, 0x0d, 0x68, 0xc5, 0x9b, 0x0e, 0x17, 0xfe, 0x3c,
-	0xa4, 0xea, 0x5d, 0x68, 0xea, 0x41, 0xe0, 0x07, 0x7d, 0x1a, 0x39, 0xee, 0x2c, 0xc4, 0x37, 0xa1,
-	0xda, 0x73, 0x96, 0x21, 0x6d, 0x4b, 0xfc, 0xb0, 0x72, 0x47, 0xcf, 0x61, 0x5c, 0x46, 0x04, 0x44,
-	0xfd, 0xbb, 0x04, 0x90, 0x05, 0x04, 0x6b, 0x50, 0xe3, 0x7e, 0x27, 0x61, 0xbb, 0x98, 0xe9, 0x72,
-	0x67, 0x77, 0x1c, 0x37, 0xe8, 0x5e, 0x8a, 0xa3, 0xd6, 0xe4, 0x2c, 0x6d, 0xdf, 0x59, 0x44, 0x34,
-	0x20, 0xb1, 0x22, 0xfe, 0x26, 0xd4, 0x43, 0xc7, 0x5b, 0xcc, 0x68, 0xd8, 0x2e, 0x73, 0x1b, 0x28,
-	0xb3, 0x61, 0x72, 0x01, 0x3f, 0xe7, 0x12, 0x49, 0x60, 0xf8, 0x0e, 0x28, 0xf4, 0x19, 0xf5, 0x16,
-	0x33, 0x27, 0x08, 0xe3, 0x18, 0xe1, 0x9c, 0xcf, 0xb1, 0x28, 0xd6, 0xca, 0xa0, 0xf8, 0x63, 0x80,
-	0x23, 0x37, 0x8c, 0xfc, 0xc3, 0xc0, 0xf1, 0xc2, 0xb6, 0xbc, 0xea, 0xf0, 0x76, 0x22, 0x8b, 0x35,
-	0x73, 0x60, 0xf5, 0xdb, 0xa0, 0xa4, 0xfb, 0xc1, 0x18, 0xe4, 0xb9, 0xe3, 0x89, 0xe3, 0x6a, 0x12,
-	0xfe, 0x8d, 0x2f, 0x41, 0xf5, 0xa9, 0x33, 0x5b, 0x8a, 0x84, 0x6b, 0x12, 0x41, 0xa8, 0x1a, 0xd4,
-	0xc4, 0x16, 0xf0, 0x0d, 0x68, 0xf2, 0xfc, 0x8c, 0x1c, 0x6f, 0x61, 0x7b, 0x21, 0x87, 0x55, 0xc8,
-	0x5a, 0xca, 0x1b, 0x85, 0x99, 0x09, 0x66, 0x57, 0x4a, 0x4c, 0xfc, 0xba, 0x0c, 0xeb, 0xc5, 0xb4,
-	0xc3, 0x1f, 0x81, 0x1c, 0x1d, 0x2f, 0x92, 0x70, 0xbd, 0x7f, 0x5e, 0x7a, 0xc6, 0xa4, 0x75, 0xbc,
-	0xa0, 0x84, 0x2b, 0xe0, 0xaf, 0x03, 0xf6, 0x38, 0xcf, 0x3e, 0x70, 0x3c, 0x77, 0x76, 0x6c, 0xf3,
-	0x6d, 0x30, 0x57, 0x14, 0x82, 0x84, 0xe4, 0x3e, 0x17, 0x18, 0x6c, 0x4b, 0x18, 0xe4, 0x23, 0x3a,
-	0x5b, 0xb4, 0x65, 0x2e, 0xe7, 0xdf, 0x8c, 0xb7, 0x9c, 0xbb, 0x51, 0xbb, 0x2a, 0x78, 0xec, 0x5b,
-	0x3d, 0x06, 0xc8, 0x56, 0xc2, 0x6b, 0x50, 0x9f, 0x18, 0x8f, 0x8c, 0xf1, 0x63, 0x03, 0x95, 0x18,
-	0xd1, 0x1b, 0x4f, 0x0c, 0x4b, 0x27, 0x48, 0xc2, 0x0a, 0x54, 0x1f, 0x68, 0x93, 0x07, 0x3a, 0x2a,
-	0xe3, 0x16, 0x28, 0xdb, 0x03, 0xd3, 0x1a, 0x3f, 0x20, 0xda, 0x08, 0x55, 0x30, 0x86, 0x75, 0x2e,
-	0xc9, 0x78, 0x32, 0x53, 0x35, 0x27, 0xa3, 0x91, 0x46, 0x9e, 0xa0, 0x2a, 0x4b, 0xe6, 0x81, 0x71,
-	0x7f, 0x8c, 0x6a, 0xb8, 0x09, 0x0d, 0xd3, 0xd2, 0x2c, 0xdd, 0xd4, 0x2d, 0x54, 0x57, 0x1f, 0x41,
-	0x4d, 0x2c, 0xfd, 0x16, 0x12, 0x51, 0xfd, 0x99, 0x04, 0x8d, 0x24, 0x79, 0xde, 0x46, 0x62, 0x17,
-	0x52, 0x22, 0x89, 0xe7, 0xa9, 0x44, 0xa8, 0x9c, 0x4a, 0x04, 0xf5, 0x0f, 0x55, 0x50, 0xd2, 0x64,
-	0xc4, 0x57, 0x41, 0x11, 0x4d, 0xc1, 0x9d, 0x47, 0x3c, 0xe4, 0xf2, 0x76, 0x89, 0x34, 0x38, 0x6b,
-	0x30, 0x8f, 0xf0, 0x0d, 0x58, 0x13, 0xe2, 0x83, 0x99, 0xef, 0x44, 0x62, 0xad, 0xed, 0x12, 0x01,
-	0xce, 0xbc, 0xcf, 0x78, 0x18, 0x41, 0x25, 0x5c, 0x7a, 0x7c, 0x25, 0x89, 0xb0, 0x4f, 0x7c, 0x19,
-	0x6a, 0xe1, 0xf4, 0x88, 0x7a, 0x0e, 0x0f, 0xee, 0x05, 0x12, 0x53, 0xf8, 0x2b, 0xb0, 0xfe, 0x63,
-	0x1a, 0xf8, 0x76, 0x74, 0x14, 0xd0, 0xf0, 0xc8, 0x9f, 0xed, 0xf3, 0x40, 0x4b, 0xa4, 0xc5, 0xb8,
-	0x56, 0xc2, 0xc4, 0x1f, 0xc4, 0xb0, 0xcc, 0xaf, 0x1a, 0xf7, 0x4b, 0x22, 0x4d, 0xc6, 0xef, 0x25,
-	0xbe, 0xdd, 0x04, 0x94, 0xc3, 0x09, 0x07, 0xeb, 0xdc, 0x41, 0x89, 0xac, 0xa7, 0x48, 0xe1, 0xa4,
-	0x06, 0xeb, 0x73, 0x7a, 0xe8, 0x44, 0xee, 0x53, 0x6a, 0x87, 0x0b, 0x67, 0x1e, 0xb6, 0x1b, 0xab,
-	0x17, 0x41, 0x77, 0x39, 0xfd, 0x94, 0x46, 0xe6, 0xc2, 0x99, 0xc7, 0x15, 0xda, 0x4a, 0x34, 0x18,
-	0x2f, 0xc4, 0x5f, 0x85, 0x8d, 0xd4, 0xc4, 0x3e, 0x9d, 0x45, 0x4e, 0xd8, 0x56, 0xae, 0x57, 0x36,
-	0x31, 0x49, 0x2d, 0xf7, 0x39, 0xb7, 0x00, 0xe4, 0xbe, 0x85, 0x6d, 0xb8, 0x5e, 0xd9, 0x94, 0x32,
-	0x20, 0x77, 0x8c, 0xb5, 0xb7, 0xf5, 0x85, 0x1f, 0xba, 0x39, 0xa7, 0xd6, 0xfe, 0xbd, 0x53, 0x89,
-	0x46, 0xea, 0x54, 0x6a, 0x22, 0x76, 0xaa, 0x29, 0x9c, 0x4a, 0xd8, 0x99, 0x53, 0x29, 0x30, 0x76,
-	0xaa, 0x25, 0x9c, 0x4a, 0xd8, 0xb1, 0x53, 0xf7, 0x00, 0x02, 0x1a, 0xd2, 0xc8, 0x3e, 0x62, 0x27,
-	0xbf, 0xce, 0x9b, 0xc0, 0xd5, 0x33, 0xda, 0xd8, 0x16, 0x61, 0xa8, 0x6d, 0x77, 0x1e, 0x11, 0x25,
-	0x48, 0x3e, 0xf1, 0x7b, 0xa0, 0xa4, 0xb9, 0xd6, 0xde, 0xe0, 0xc9, 0x97, 0x31, 0xd4, 0xbb, 0xa0,
-	0xa4, 0x5a, 0xc5, 0x52, 0xae, 0x43, 0xe5, 0x89, 0x6e, 0x22, 0x09, 0xd7, 0xa0, 0x6c, 0x8c, 0x51,
-	0x39, 0x2b, 0xe7, 0xca, 0x15, 0xf9, 0xe7, 0xbf, 0xed, 0x48, 0xdd, 0x3a, 0x54, 0xb9, 0xdf, 0xdd,
-	0x26, 0x40, 0x16, 0x76, 0xf5, 0x6f, 0x32, 0xac, 0xf3, 0x10, 0x67, 0x29, 0x1d, 0x02, 0xe6, 0x32,
-	0x1a, 0xd8, 0x2b, 0x3b, 0x69, 0x75, 0xf5, 0x7f, 0xbc, 0xbc, 0xa6, 0xe5, 0x06, 0x8a, 0x45, 0xe0,
-	0x7b, 0x34, 0x3a, 0xa2, 0xcb, 0x30, 0xff, 0xe9, 0xf9, 0xfb, 0x74, 0x76, 0x2b, 0x6d, 0xd0, 0x5b,
-	0x3d, 0x61, 0x2e, 0xdb, 0x31, 0x9a, 0xae, 0x70, 0xfe, 0xd7, 0x9c, 0xbf, 0x9a, 0xdf, 0x94, 0xc8,
-	0x62, 0xa2, 0xa4, 0x39, 0xcc, 0x8a, 0x5d, 0x48, 0xe2, 0x62, 0xe7, 0xc4, 0x19, 0x95, 0xf7, 0x16,
-	0x32, 0xea, 0x2d, 0x54, 0xca, 0xd7, 0x00, 0xa5, 0x5e, 0xec, 0x71, 0x6c, 0x92, 0x6c, 0x69, 0x0e,
-	0x0a, 0x13, 0x1c, 0x9a, 0xae, 0x96, 0x40, 0x45, 0xb1, 0xa4, 0x35, 0x94, 0x40, 0xdf, 0x87, 0xd6,
-	0x74, 0x19, 0x46, 0xbe, 0x67, 0xf3, 0x56, 0x17, 0xb6, 0x11, 0xc7, 0x35, 0x05, 0x73, 0x97, 0xf3,
-	0x1e, 0xca, 0x0d, 0x09, 0x95, 0x1f, 0xca, 0x8d, 0x1a, 0xaa, 0x3f, 0x94, 0x1b, 0x0a, 0x82, 0x87,
-	0x72, 0xa3, 0x89, 0x5a, 0x0f, 0xe5, 0xc6, 0x06, 0x42, 0x24, 0x6b, 0x75, 0x64, 0xa5, 0xc5, 0x90,
-	0xd5, 0xda, 0x26, 0xab, 0x75, 0x95, 0xcf, 0xe3, 0x7b, 0x00, 0xd9, 0x19, 0xb0, 0xd0, 0xfb, 0x07,
-	0x07, 0x21, 0x15, 0xfd, 0xf3, 0x02, 0x89, 0x29, 0xc6, 0x9f, 0xd1, 0xf9, 0x61, 0x74, 0xc4, 0xa3,
-	0xd6, 0x22, 0x31, 0xa5, 0x2e, 0x01, 0x17, 0x33, 0x96, 0x5f, 0xfb, 0x6f, 0x70, 0x85, 0xdf, 0x03,
-	0x25, 0xcd, 0x49, 0xbe, 0x56, 0x61, 0x7a, 0x2c, 0xda, 0x8c, 0xa7, 0xc7, 0x4c, 0x41, 0x9d, 0xc3,
-	0x86, 0x98, 0x16, 0xb2, 0x4a, 0x49, 0xd3, 0x4a, 0x3a, 0x23, 0xad, 0xca, 0x59, 0x5a, 0xdd, 0x86,
-	0x7a, 0x12, 0x1c, 0x31, 0x10, 0xbd, 0x7b, 0xd6, 0x5c, 0xc3, 0x11, 0x24, 0x41, 0xaa, 0x21, 0x6c,
-	0xac, 0xc8, 0x70, 0x07, 0x60, 0xcf, 0x5f, 0xce, 0xf7, 0x9d, 0x78, 0x14, 0x97, 0x36, 0xab, 0x24,
-	0xc7, 0x61, 0xfe, 0xcc, 0xfc, 0xcf, 0x68, 0x90, 0xa4, 0x39, 0x27, 0x18, 0x77, 0xb9, 0x58, 0xd0,
-	0x20, 0x4e, 0x74, 0x41, 0x64, 0xbe, 0xcb, 0x39, 0xdf, 0xd5, 0x19, 0x5c, 0x5c, 0xd9, 0x24, 0x3f,
-	0xdc, 0x42, 0x5b, 0x2a, 0xaf, 0xb4, 0x25, 0xfc, 0xd1, 0xe9, 0x73, 0x7d, 0x77, 0x75, 0x4a, 0x4c,
-	0xed, 0xe5, 0x8f, 0xf4, 0x8f, 0x32, 0xb4, 0x3e, 0x59, 0xd2, 0xe0, 0x38, 0x19, 0x7e, 0xf1, 0x1d,
-	0xa8, 0x85, 0x91, 0x13, 0x2d, 0xc3, 0x78, 0x7c, 0xea, 0x64, 0x76, 0x0a, 0xc0, 0x2d, 0x93, 0xa3,
-	0x48, 0x8c, 0xc6, 0xdf, 0x07, 0xa0, 0x6c, 0x1a, 0xb6, 0xf9, 0xe8, 0x75, 0xea, 0x59, 0x51, 0xd4,
-	0xe5, 0x73, 0x33, 0x1f, 0xbc, 0x14, 0x9a, 0x7c, 0xb2, 0xf3, 0xe0, 0x04, 0x3f, 0x25, 0x85, 0x08,
-	0x02, 0x6f, 0x31, 0x7f, 0x02, 0x77, 0x7e, 0xc8, 0x8f, 0xa9, 0x50, 0xc5, 0x26, 0xe7, 0xf7, 0x9d,
-	0xc8, 0xd9, 0x2e, 0x91, 0x18, 0xc5, 0xf0, 0x4f, 0xe9, 0x34, 0xf2, 0x03, 0xde, 0xa6, 0x0a, 0xf8,
-	0x5d, 0xce, 0x4f, 0xf0, 0x02, 0xc5, 0xed, 0x4f, 0x9d, 0x99, 0x13, 0xf0, 0x3b, 0xba, 0x68, 0x9f,
-	0xf3, 0x53, 0xfb, 0x9c, 0x62, 0x78, 0xcf, 0x89, 0x02, 0xf7, 0x19, 0xef, 0x71, 0x05, 0xfc, 0x88,
-	0xf3, 0x13, 0xbc, 0x40, 0xe1, 0x2b, 0xd0, 0xf8, 0xcc, 0x09, 0xe6, 0xee, 0xfc, 0x50, 0xf4, 0x21,
-	0x85, 0xa4, 0x34, 0xdb, 0xb1, 0x3b, 0x3f, 0xf0, 0xc5, 0x35, 0xac, 0x10, 0x41, 0xa8, 0x1f, 0x40,
-	0x4d, 0x9c, 0x2d, 0xbb, 0x42, 0x74, 0x42, 0xc6, 0x44, 0x4c, 0x8a, 0xe6, 0xa4, 0xd7, 0xd3, 0x4d,
-	0x13, 0x49, 0xe2, 0x3e, 0x51, 0x7f, 0x25, 0x81, 0x92, 0x1e, 0x24, 0x1b, 0x01, 0x8d, 0xb1, 0xa1,
-	0x0b, 0xa8, 0x35, 0x18, 0xe9, 0xe3, 0x89, 0x85, 0x24, 0x36, 0x0f, 0xf6, 0x34, 0xa3, 0xa7, 0x0f,
-	0xf5, 0xbe, 0x98, 0x2b, 0xf5, 0x1f, 0xe8, 0xbd, 0x89, 0x35, 0x18, 0x1b, 0xa8, 0xc2, 0x84, 0x5d,
-	0xad, 0x6f, 0xf7, 0x35, 0x4b, 0x43, 0x32, 0xa3, 0x06, 0x6c, 0x14, 0x35, 0xb4, 0x21, 0xaa, 0xe2,
-	0x0d, 0x58, 0x9b, 0x18, 0xda, 0xae, 0x36, 0x18, 0x6a, 0xdd, 0xa1, 0x8e, 0x6a, 0x4c, 0xd7, 0x18,
-	0x5b, 0xf6, 0xfd, 0xf1, 0xc4, 0xe8, 0xa3, 0x3a, 0x9b, 0x49, 0x19, 0xa9, 0xf5, 0x7a, 0xfa, 0x8e,
-	0xc5, 0x21, 0x8d, 0xf8, 0x9e, 0xab, 0x81, 0xcc, 0xc6, 0x6b, 0x55, 0x07, 0xc8, 0x22, 0x54, 0x9c,
-	0xde, 0x95, 0xf3, 0xa6, 0xbd, 0xd3, 0x3d, 0x43, 0xfd, 0xa9, 0x04, 0x90, 0x45, 0x0e, 0xdf, 0xc9,
-	0x9e, 0x43, 0x62, 0xf2, 0xbc, 0xbc, 0x1a, 0xe0, 0xb3, 0x1f, 0x45, 0xdf, 0x2b, 0x3c, 0x6e, 0xca,
-	0xab, 0x4d, 0x40, 0xa8, 0xfe, 0xab, 0x27, 0x8e, 0x0d, 0xcd, 0xbc, 0x7d, 0xd6, 0x1c, 0xc5, 0x93,
-	0x80, 0xfb, 0xa1, 0x90, 0x98, 0xfa, 0xef, 0xc7, 0xda, 0x5f, 0x48, 0xb0, 0xb1, 0xe2, 0xc6, 0xb9,
-	0x8b, 0x14, 0x1a, 0x69, 0xf9, 0x0d, 0x1a, 0x69, 0x29, 0x57, 0xf5, 0x6f, 0xe2, 0x0c, 0x0b, 0x5e,
-	0x9a, 0xfe, 0x67, 0x3f, 0xbd, 0xde, 0x24, 0x78, 0x5d, 0x80, 0xac, 0x2a, 0xf0, 0xb7, 0xa0, 0x56,
-	0xf8, 0x89, 0x71, 0x79, 0xb5, 0x76, 0xe2, 0xdf, 0x18, 0xc2, 0xe1, 0x18, 0xab, 0xfe, 0x46, 0x82,
-	0x66, 0x5e, 0x7c, 0xee, 0xa1, 0xfc, 0xe7, 0x2f, 0xe5, 0x6e, 0x21, 0x29, 0xc4, 0xcd, 0xf0, 0xde,
-	0x79, 0xe7, 0xc8, 0x9f, 0x34, 0xa7, 0xf2, 0xe2, 0xe6, 0xef, 0xcb, 0x00, 0xd9, 0x7f, 0x00, 0x7c,
-	0x01, 0x5a, 0xf1, 0x50, 0x68, 0xf7, 0xb4, 0x89, 0xc9, 0x0a, 0xf2, 0x0a, 0x5c, 0x26, 0xfa, 0xce,
-	0x70, 0xd0, 0xd3, 0x4c, 0xbb, 0x3f, 0xe8, 0xdb, 0xac, 0x6e, 0x46, 0x9a, 0xd5, 0xdb, 0x46, 0x12,
-	0x7e, 0x07, 0x2e, 0x58, 0xe3, 0xb1, 0x3d, 0xd2, 0x8c, 0x27, 0x76, 0x6f, 0x38, 0x31, 0x2d, 0x9d,
-	0x98, 0xa8, 0x5c, 0xa8, 0xcc, 0x0a, 0x33, 0x30, 0x30, 0x1e, 0xe8, 0x26, 0x2b, 0x5b, 0x9b, 0x68,
-	0x96, 0x6e, 0x0f, 0x07, 0xa3, 0x81, 0xa5, 0xf7, 0x91, 0x8c, 0xdb, 0x70, 0x89, 0xe8, 0x9f, 0x4c,
-	0x74, 0xd3, 0x2a, 0x4a, 0xaa, 0xac, 0x42, 0x07, 0x86, 0x69, 0xb1, 0xea, 0x17, 0x5c, 0x54, 0xc3,
-	0xff, 0x07, 0x17, 0x4d, 0x9d, 0xec, 0x0e, 0x7a, 0xba, 0x9d, 0xaf, 0xee, 0x3a, 0xbe, 0x04, 0xc8,
-	0x32, 0xfb, 0xdd, 0x02, 0xb7, 0xc1, 0xdc, 0x60, 0xde, 0x75, 0x27, 0xe6, 0x13, 0xa4, 0xb0, 0xa5,
-	0x7a, 0x03, 0xd2, 0x9b, 0x0c, 0x2c, 0xbb, 0x4b, 0x74, 0xed, 0x91, 0x4e, 0xec, 0xf1, 0x8e, 0x6e,
-	0x20, 0xc0, 0x97, 0x01, 0x8f, 0x74, 0x6b, 0x7b, 0x2c, 0xf6, 0xa6, 0x0d, 0x87, 0xe3, 0xc7, 0x7a,
-	0x1f, 0xad, 0x61, 0x04, 0x4d, 0x4b, 0x37, 0x34, 0xc3, 0x8a, 0x1d, 0x68, 0x76, 0xbf, 0xf3, 0xe2,
-	0x55, 0xa7, 0xf4, 0xf9, 0xab, 0x4e, 0xe9, 0xcb, 0x57, 0x1d, 0xe9, 0x27, 0x27, 0x1d, 0xe9, 0x77,
-	0x27, 0x1d, 0xe9, 0xf9, 0x49, 0x47, 0x7a, 0x71, 0xd2, 0x91, 0xfe, 0x7c, 0xd2, 0x91, 0xbe, 0x38,
-	0xe9, 0x94, 0xbe, 0x3c, 0xe9, 0x48, 0xbf, 0x7c, 0xdd, 0x29, 0xbd, 0x78, 0xdd, 0x29, 0x7d, 0xfe,
-	0xba, 0x53, 0xfa, 0x61, 0x9d, 0xff, 0x58, 0x5b, 0xec, 0xed, 0xd5, 0xf8, 0x2f, 0xb2, 0xdb, 0xff,
-	0x0c, 0x00, 0x00, 0xff, 0xff, 0xc3, 0xd5, 0x81, 0xca, 0x6a, 0x13, 0x00, 0x00,
+func init() { proto.RegisterFile("pkg/mimirpb/mimir.proto", fileDescriptor_e7552b50e8c2985e) }
+
+var fileDescriptor_e7552b50e8c2985e = []byte{
+	// 2008 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x93, 0xdb, 0x48,
+	0x15, 0xb7, 0x6c, 0xf9, 0x43, 0x6f, 0xec, 0x99, 0x4e, 0x27, 0x9b, 0xf5, 0x0e, 0xbb, 0x4e, 0xa2,
+	0x85, 0x65, 0x48, 0x51, 0x13, 0x6a, 0x43, 0x65, 0x6b, 0x53, 0x61, 0x41, 0xb6, 0x95, 0x8c, 0xb3,
+	0xb6, 0x3c, 0xdb, 0x92, 0x13, 0xc2, 0x45, 0xa5, 0xf1, 0xf4, 0xcc, 0xa8, 0x62, 0x59, 0x46, 0x92,
+	0xb3, 0x19, 0x4e, 0x5c, 0xa8, 0xa2, 0x38, 0x71, 0xe1, 0x42, 0x71, 0xe3, 0x42, 0x15, 0xff, 0x48,
+	0xaa, 0xb8, 0xe4, 0xb8, 0x70, 0x48, 0x91, 0xc9, 0x81, 0xe5, 0x40, 0xd5, 0x16, 0x47, 0x4e, 0x54,
+	0x77, 0xeb, 0xd3, 0x33, 0x03, 0x21, 0xec, 0xc9, 0xea, 0xf7, 0x7e, 0xaf, 0xfb, 0xa7, 0xf7, 0xa5,
+	0xd7, 0x86, 0xb7, 0x17, 0x8f, 0x0f, 0x6f, 0x78, 0xae, 0xe7, 0x06, 0x8b, 0x3d, 0xf1, 0xbb, 0xbd,
+	0x08, 0xfc, 0xc8, 0xc7, 0x8d, 0xa9, 0x1f, 0x44, 0xf4, 0xe9, 0x62, 0x6f, 0xf3, 0xd2, 0xa1, 0x7f,
+	0xe8, 0x73, 0xe1, 0x0d, 0xf6, 0x24, 0xf4, 0x9b, 0xdf, 0x3c, 0x65, 0x68, 0x4f, 0x97, 0x61, 0xe4,
+	0x7b, 0x76, 0x74, 0xbc, 0xa0, 0xa1, 0x40, 0xa9, 0xff, 0x28, 0x43, 0xf3, 0x61, 0xe0, 0x46, 0x94,
+	0xd0, 0x9f, 0x2e, 0x69, 0x18, 0xe1, 0x5d, 0x80, 0xc8, 0xf5, 0x68, 0x48, 0x03, 0x97, 0x86, 0x6d,
+	0xe9, 0x6a, 0x65, 0x6b, 0xed, 0xc3, 0x4b, 0xdb, 0xc9, 0x59, 0xdb, 0x96, 0xeb, 0x51, 0x93, 0xeb,
+	0xba, 0x9b, 0xcf, 0x5e, 0x5c, 0x29, 0xfd, 0xe5, 0xc5, 0x15, 0xbc, 0x1b, 0x50, 0x67, 0x36, 0xf3,
+	0xa7, 0x56, 0x6a, 0x47, 0x72, 0x7b, 0xe0, 0x8f, 0xa1, 0x66, 0xfa, 0xcb, 0x60, 0x4a, 0xdb, 0xe5,
+	0xab, 0xd2, 0xd6, 0xfa, 0x87, 0xd7, 0xb2, 0xdd, 0xf2, 0x27, 0x6f, 0x0b, 0x90, 0x3e, 0x5f, 0x7a,
+	0x24, 0x36, 0xc0, 0xb7, 0xa1, 0xe1, 0xd1, 0xc8, 0xd9, 0x77, 0x22, 0xa7, 0x5d, 0xe1, 0x54, 0xda,
+	0x99, 0xf1, 0x88, 0x46, 0x81, 0x3b, 0x1d, 0xc5, 0xfa, 0xae, 0xfc, 0xec, 0xc5, 0x15, 0x89, 0xa4,
+	0x78, 0x7c, 0x13, 0xde, 0x0a, 0x1f, 0xbb, 0x0b, 0x7b, 0xe6, 0xec, 0xd1, 0x99, 0xfd, 0xc4, 0x99,
+	0xb9, 0xfb, 0x4e, 0xe4, 0xfa, 0xf3, 0xf6, 0x97, 0xf5, 0xab, 0xd2, 0x56, 0x83, 0x5c, 0x64, 0xda,
+	0x21, 0x53, 0x3e, 0x48, 0x75, 0xf8, 0x13, 0xf8, 0x46, 0xce, 0x68, 0xea, 0x2f, 0xe7, 0x51, 0xde,
+	0xf4, 0xef, 0xc2, 0xb4, 0x9d, 0x9a, 0xf6, 0x18, 0x22, 0xb3, 0x57, 0xaf, 0x00, 0x64, 0xaf, 0x81,
+	0xeb, 0x50, 0xd1, 0x76, 0x07, 0xa8, 0x84, 0x1b, 0x20, 0x93, 0xc9, 0x50, 0x47, 0x92, 0xba, 0x01,
+	0xad, 0xf8, 0xa5, 0xc3, 0x85, 0x3f, 0x0f, 0xa9, 0x7a, 0x1b, 0x9a, 0x7a, 0x10, 0xf8, 0x41, 0x9f,
+	0x46, 0x8e, 0x3b, 0x0b, 0xf1, 0x75, 0xa8, 0xf6, 0x9c, 0x65, 0x48, 0xdb, 0x12, 0x77, 0x56, 0xce,
+	0xf5, 0x1c, 0xc6, 0x75, 0x44, 0x40, 0xd4, 0xbf, 0x49, 0x00, 0x59, 0x40, 0xf0, 0xf7, 0xa1, 0xc6,
+	0x79, 0x27, 0x61, 0xbb, 0x9c, 0xd9, 0x72, 0xb2, 0xda, 0xbe, 0xb3, 0x88, 0x68, 0xc0, 0x3d, 0x55,
+	0x22, 0x31, 0x16, 0x7f, 0x0f, 0xea, 0xa1, 0xe3, 0x2d, 0x66, 0x34, 0x6c, 0x97, 0xb9, 0x19, 0xca,
+	0xcc, 0x4c, 0xae, 0x88, 0x0d, 0x12, 0x18, 0xbe, 0x05, 0x0a, 0x7d, 0x4a, 0xbd, 0xc5, 0xcc, 0x09,
+	0xc2, 0x38, 0x2c, 0x38, 0x47, 0x33, 0x56, 0xc5, 0x56, 0x19, 0x14, 0x7f, 0x0c, 0x70, 0xe4, 0x86,
+	0x91, 0x7f, 0x18, 0x38, 0x5e, 0xd8, 0x96, 0xb9, 0xe1, 0xc5, 0xcc, 0x70, 0x27, 0xd1, 0xc5, 0x96,
+	0x39, 0xb0, 0xaa, 0x41, 0x4d, 0x70, 0xc1, 0xd7, 0xa0, 0xc9, 0x73, 0x2b, 0x72, 0xbc, 0x85, 0xed,
+	0x85, 0x3c, 0xa7, 0x2a, 0x64, 0x2d, 0x95, 0x8d, 0x42, 0x7c, 0x09, 0xaa, 0x4f, 0x9c, 0xd9, 0x52,
+	0xb8, 0x50, 0x22, 0x62, 0xa1, 0xfe, 0xb6, 0x0c, 0xeb, 0xc5, 0x94, 0xc1, 0x1f, 0x81, 0xcc, 0x6a,
+	0x21, 0x76, 0xf5, 0xfb, 0xe7, 0xa5, 0x56, 0xbc, 0xb4, 0x8e, 0x17, 0x94, 0x70, 0x03, 0xfc, 0x5d,
+	0xc0, 0x1e, 0x97, 0xd9, 0x07, 0x8e, 0xe7, 0xce, 0x8e, 0xed, 0xb9, 0xe3, 0x89, 0xf4, 0x56, 0x08,
+	0x12, 0x9a, 0xbb, 0x5c, 0x61, 0x38, 0x1e, 0xc5, 0x18, 0xe4, 0x23, 0x3a, 0x5b, 0xb4, 0x65, 0xae,
+	0xe7, 0xcf, 0x4c, 0xb6, 0x9c, 0xbb, 0x51, 0xbb, 0x2a, 0x64, 0xec, 0x59, 0x3d, 0x06, 0xc8, 0x4e,
+	0xc2, 0x6b, 0x50, 0x9f, 0x18, 0x9f, 0x1a, 0xe3, 0x87, 0x06, 0x2a, 0xb1, 0x45, 0x6f, 0x3c, 0x31,
+	0x2c, 0x9d, 0x20, 0x09, 0x2b, 0x50, 0xbd, 0xa7, 0x4d, 0xee, 0xe9, 0xa8, 0x8c, 0x5b, 0xa0, 0xec,
+	0x0c, 0x4c, 0x6b, 0x7c, 0x8f, 0x68, 0x23, 0x54, 0xc1, 0x18, 0xd6, 0xb9, 0x26, 0x93, 0xc9, 0xcc,
+	0xd4, 0x9c, 0x8c, 0x46, 0x1a, 0x79, 0x84, 0xaa, 0x2c, 0x11, 0x07, 0xc6, 0xdd, 0x31, 0xaa, 0xe1,
+	0x26, 0x34, 0x4c, 0x4b, 0xb3, 0x74, 0x53, 0xb7, 0x50, 0x5d, 0xfd, 0x04, 0x6a, 0xe2, 0xe8, 0x37,
+	0x4b, 0x22, 0xf5, 0x18, 0x1a, 0x49, 0xdc, 0xdf, 0x30, 0x0d, 0xd3, 0xa0, 0x95, 0x73, 0x41, 0x3b,
+	0x15, 0xed, 0xca, 0xa9, 0x68, 0xab, 0x7f, 0xaa, 0x82, 0x92, 0xa6, 0x0e, 0x7e, 0x0f, 0x14, 0x51,
+	0xb5, 0xee, 0x3c, 0xe2, 0x71, 0x95, 0x77, 0x4a, 0xa4, 0xc1, 0x45, 0x83, 0x79, 0x84, 0xaf, 0xc1,
+	0x9a, 0x50, 0x1f, 0xcc, 0x7c, 0x27, 0x12, 0x67, 0xed, 0x94, 0x08, 0x70, 0xe1, 0x5d, 0x26, 0xc3,
+	0x08, 0x2a, 0xe1, 0xd2, 0xe3, 0x27, 0x49, 0x84, 0x3d, 0xe2, 0xcb, 0x50, 0x0b, 0xa7, 0x47, 0xd4,
+	0x73, 0x78, 0x04, 0x2f, 0x90, 0x78, 0x85, 0xbf, 0x05, 0xeb, 0x3f, 0xa3, 0x81, 0x6f, 0x47, 0x47,
+	0x01, 0x0d, 0x8f, 0xfc, 0xd9, 0x3e, 0x8f, 0xa6, 0x44, 0x5a, 0x4c, 0x6a, 0x25, 0x42, 0xfc, 0x41,
+	0x0c, 0xcb, 0x78, 0xd5, 0x38, 0x2f, 0x89, 0x34, 0x99, 0xbc, 0x97, 0x70, 0xbb, 0x0e, 0x28, 0x87,
+	0x13, 0x04, 0xeb, 0x9c, 0xa0, 0x44, 0xd6, 0x53, 0xa4, 0x20, 0xa9, 0xc1, 0xfa, 0x9c, 0x1e, 0x3a,
+	0x91, 0xfb, 0x84, 0xda, 0xe1, 0xc2, 0x99, 0x87, 0xed, 0xc6, 0x6a, 0xa7, 0xee, 0x2e, 0xa7, 0x8f,
+	0x69, 0x64, 0x2e, 0x9c, 0x79, 0xec, 0xe9, 0x56, 0x62, 0xc1, 0x64, 0x21, 0xfe, 0x36, 0x6c, 0xa4,
+	0x5b, 0xec, 0xd3, 0x59, 0xe4, 0x84, 0x6d, 0xe5, 0x6a, 0x65, 0x0b, 0x93, 0x74, 0xe7, 0x3e, 0x97,
+	0x16, 0x80, 0x9c, 0x5b, 0xd8, 0x86, 0xab, 0x95, 0x2d, 0x29, 0x03, 0x72, 0x62, 0x21, 0x23, 0xb5,
+	0xf0, 0x43, 0x37, 0x47, 0x6a, 0xed, 0xbf, 0x93, 0x4a, 0x2c, 0x52, 0x52, 0xe9, 0x16, 0x31, 0xa9,
+	0xa6, 0x20, 0x95, 0x88, 0x33, 0x52, 0x29, 0x30, 0x26, 0xd5, 0x12, 0xa4, 0x12, 0x71, 0x4c, 0xea,
+	0x0e, 0x40, 0x40, 0x43, 0x1a, 0xd9, 0x47, 0xcc, 0xf3, 0xeb, 0xbc, 0xd2, 0xdf, 0x3b, 0xa3, 0xe9,
+	0x6c, 0x13, 0x86, 0xda, 0x71, 0xe7, 0x11, 0x51, 0x82, 0xe4, 0x11, 0xbf, 0x0b, 0x4a, 0x9a, 0x6b,
+	0xed, 0x0d, 0x9e, 0x7c, 0x99, 0x40, 0xbd, 0x0d, 0x4a, 0x6a, 0x55, 0xac, 0xd7, 0x3a, 0x54, 0x1e,
+	0xe9, 0x26, 0x92, 0x70, 0x0d, 0xca, 0xc6, 0x18, 0x95, 0xb3, 0x9a, 0xad, 0x6c, 0xca, 0xbf, 0xfc,
+	0x7d, 0x47, 0xea, 0xd6, 0xa1, 0xca, 0x79, 0x77, 0x9b, 0x00, 0x59, 0xd8, 0xd5, 0x7f, 0xca, 0xb0,
+	0xce, 0x43, 0x9c, 0xa5, 0x74, 0x08, 0x98, 0xeb, 0x68, 0x60, 0xaf, 0xbc, 0x49, 0xab, 0xab, 0xff,
+	0xeb, 0xc5, 0x15, 0xed, 0xd0, 0x8d, 0x8e, 0x96, 0x7b, 0xdb, 0x53, 0xdf, 0xbb, 0xb1, 0x08, 0x7c,
+	0x8f, 0x46, 0x47, 0x74, 0x19, 0xe6, 0x1f, 0x3d, 0x7f, 0x9f, 0xce, 0x6e, 0xa4, 0xed, 0x74, 0xbb,
+	0x27, 0xb6, 0xcb, 0xde, 0x18, 0x4d, 0x57, 0x24, 0xff, 0x6f, 0xce, 0xbf, 0x97, 0x7f, 0x29, 0x91,
+	0xc5, 0x44, 0x49, 0x73, 0x98, 0x15, 0xbb, 0xd0, 0xc4, 0xc5, 0xce, 0x17, 0x67, 0x54, 0xde, 0xd7,
+	0x90, 0x51, 0x5f, 0x43, 0xa5, 0x7c, 0x07, 0x50, 0xca, 0x62, 0x8f, 0x63, 0x93, 0x64, 0x4b, 0x73,
+	0x50, 0x6c, 0xc1, 0xa1, 0xe9, 0x69, 0x09, 0x54, 0x14, 0x4b, 0x5a, 0x43, 0x09, 0xf4, 0x7d, 0x68,
+	0xc5, 0xf3, 0x18, 0x6f, 0x75, 0x61, 0x1b, 0x71, 0x5c, 0x53, 0x08, 0x1f, 0x70, 0xd9, 0x7d, 0xb9,
+	0x21, 0xa1, 0xf2, 0x7d, 0xb9, 0x51, 0x43, 0xf5, 0xfb, 0x72, 0x43, 0x41, 0x70, 0x5f, 0x6e, 0x34,
+	0x51, 0xeb, 0xbe, 0xdc, 0xd8, 0x40, 0x88, 0x64, 0xad, 0x8e, 0xac, 0xb4, 0x18, 0xb2, 0x5a, 0xdb,
+	0x64, 0xb5, 0xae, 0xf2, 0x79, 0x7c, 0x07, 0x20, 0xf3, 0x01, 0x0b, 0xbd, 0x7f, 0x70, 0x10, 0x52,
+	0xd1, 0x3f, 0x2f, 0x90, 0x78, 0xc5, 0xe4, 0x33, 0x3a, 0x3f, 0x8c, 0x8e, 0x78, 0xd4, 0x5a, 0x24,
+	0x5e, 0xa9, 0x4b, 0xc0, 0xc5, 0x8c, 0xdd, 0x75, 0xdc, 0xe0, 0x75, 0xbe, 0xd3, 0x77, 0x40, 0x49,
+	0x73, 0x92, 0x9f, 0x55, 0x18, 0xef, 0x8a, 0x7b, 0xc6, 0xe3, 0x5d, 0x66, 0xa0, 0xce, 0x61, 0x43,
+	0x8c, 0x04, 0x59, 0xa5, 0xa4, 0x69, 0x25, 0x9d, 0x91, 0x56, 0xe5, 0x2c, 0xad, 0x6e, 0x42, 0x3d,
+	0x09, 0x8e, 0x18, 0x5f, 0xde, 0x39, 0x6b, 0x0a, 0xe1, 0x08, 0x92, 0x20, 0xd5, 0x10, 0x36, 0x56,
+	0x74, 0xb8, 0x03, 0xb0, 0xe7, 0x2f, 0xe7, 0xfb, 0x4e, 0x3c, 0x2b, 0x4b, 0x5b, 0x55, 0x92, 0x93,
+	0x30, 0x3e, 0x33, 0xff, 0x73, 0x1a, 0x24, 0x69, 0xce, 0x17, 0x4c, 0xba, 0x5c, 0x2c, 0x68, 0x10,
+	0x27, 0xba, 0x58, 0x64, 0xdc, 0xe5, 0x1c, 0x77, 0x75, 0x06, 0x17, 0x57, 0x5e, 0x92, 0x3b, 0xb7,
+	0xd0, 0x96, 0xca, 0x2b, 0x6d, 0x09, 0x7f, 0x74, 0xda, 0xaf, 0xef, 0xac, 0xce, 0x74, 0xe9, 0x7e,
+	0x79, 0x97, 0xfe, 0x59, 0x86, 0xd6, 0x67, 0x4b, 0x1a, 0x1c, 0x27, 0xd3, 0x29, 0xbe, 0x05, 0xb5,
+	0x30, 0x72, 0xa2, 0x65, 0x18, 0xcf, 0x48, 0x9d, 0x6c, 0x9f, 0x02, 0x70, 0xdb, 0xe4, 0x28, 0x12,
+	0xa3, 0xf1, 0x8f, 0x00, 0x28, 0x1b, 0x57, 0xf9, 0x5d, 0xe3, 0xf4, 0xdc, 0x5f, 0xb4, 0xe5, 0x83,
+	0x2d, 0x9f, 0xae, 0x14, 0x9a, 0x3c, 0x32, 0x7f, 0xf0, 0x05, 0xf7, 0x92, 0x42, 0xc4, 0x02, 0x6f,
+	0x33, 0x3e, 0x81, 0x3b, 0x3f, 0xe4, 0x6e, 0x2a, 0x54, 0xb1, 0xc9, 0xe5, 0x7d, 0x27, 0x72, 0x76,
+	0x4a, 0x24, 0x46, 0x31, 0xfc, 0x13, 0x3a, 0x8d, 0xfc, 0x80, 0xb7, 0xa9, 0x02, 0xfe, 0x01, 0x97,
+	0x27, 0x78, 0x81, 0xe2, 0xfb, 0x4f, 0x9d, 0x99, 0x13, 0xf0, 0x6f, 0x74, 0x71, 0x7f, 0x2e, 0x4f,
+	0xf7, 0xe7, 0x2b, 0x86, 0xf7, 0x9c, 0x28, 0x70, 0x9f, 0xf2, 0x1e, 0x57, 0xc0, 0x8f, 0xb8, 0x3c,
+	0xc1, 0x0b, 0x14, 0xde, 0x84, 0xc6, 0xe7, 0x4e, 0x30, 0x77, 0xe7, 0x87, 0xa2, 0x0f, 0x29, 0x24,
+	0x5d, 0xb3, 0x37, 0x76, 0xe7, 0x07, 0xbe, 0xf8, 0x0c, 0x2b, 0x44, 0x2c, 0xd4, 0x0f, 0xa0, 0x26,
+	0x7c, 0xcb, 0x3e, 0x21, 0x3a, 0x21, 0x63, 0x22, 0xc6, 0x41, 0x73, 0xd2, 0xeb, 0xe9, 0xa6, 0x89,
+	0x24, 0xf1, 0x3d, 0x51, 0x7f, 0x23, 0x81, 0x92, 0x3a, 0x92, 0xcd, 0x79, 0xc6, 0xd8, 0xd0, 0x05,
+	0xd4, 0x1a, 0x8c, 0xf4, 0xf1, 0xc4, 0x42, 0x12, 0x1b, 0xfa, 0x7a, 0x9a, 0xd1, 0xd3, 0x87, 0x7a,
+	0x5f, 0x0c, 0x8f, 0xfa, 0x8f, 0xf5, 0xde, 0xc4, 0x1a, 0x8c, 0x0d, 0x54, 0x61, 0xca, 0xae, 0xd6,
+	0xb7, 0xfb, 0x9a, 0xa5, 0x21, 0x99, 0xad, 0x06, 0x6c, 0xde, 0x34, 0xb4, 0x21, 0xaa, 0xe2, 0x0d,
+	0x58, 0x9b, 0x18, 0xda, 0x03, 0x6d, 0x30, 0xd4, 0xba, 0x43, 0x1d, 0xd5, 0x98, 0xad, 0x31, 0xb6,
+	0xec, 0xbb, 0xe3, 0x89, 0xd1, 0x47, 0x75, 0x36, 0x78, 0xb2, 0xa5, 0xd6, 0xeb, 0xe9, 0xbb, 0x16,
+	0x87, 0x34, 0xe2, 0xef, 0x5c, 0x0d, 0x64, 0x36, 0x43, 0xab, 0x3a, 0x40, 0x16, 0xa1, 0xe2, 0x88,
+	0xae, 0x9c, 0x37, 0xed, 0x9d, 0xee, 0x19, 0xea, 0x2f, 0x24, 0x80, 0x2c, 0x72, 0xf8, 0x56, 0x76,
+	0x79, 0x39, 0x35, 0x6c, 0x0a, 0xd8, 0xd9, 0x57, 0x98, 0x1f, 0x16, 0xae, 0x22, 0xe5, 0xd5, 0x26,
+	0x20, 0x4c, 0xff, 0xd3, 0x85, 0xc4, 0x86, 0x66, 0x7e, 0x7f, 0xd6, 0x1c, 0xc5, 0xdc, 0xcf, 0x79,
+	0x28, 0x24, 0x5e, 0xbd, 0xf9, 0x58, 0xfb, 0x2b, 0x09, 0x36, 0x56, 0x68, 0x9c, 0x7b, 0x48, 0xa1,
+	0x91, 0x96, 0x5f, 0xa3, 0x91, 0x96, 0x72, 0x55, 0xff, 0x3a, 0x64, 0x58, 0xf0, 0xd2, 0xf4, 0x3f,
+	0xfb, 0x7e, 0xf5, 0x3a, 0xc1, 0xeb, 0x02, 0x64, 0x55, 0xc1, 0xee, 0x09, 0x85, 0x7f, 0x19, 0x2e,
+	0xaf, 0xd6, 0x4e, 0xfc, 0x3f, 0x43, 0x7c, 0x4f, 0x10, 0x58, 0xf5, 0x77, 0x12, 0x34, 0xf3, 0xea,
+	0x73, 0x9d, 0xf2, 0xbf, 0xdf, 0x6b, 0xbb, 0x85, 0xa4, 0x10, 0x5f, 0x86, 0x77, 0xcf, 0xf3, 0x23,
+	0xeb, 0xc3, 0xa7, 0xf3, 0xe2, 0xfa, 0x1f, 0xcb, 0x00, 0xd9, 0x45, 0x1d, 0x5f, 0x80, 0x56, 0x3c,
+	0x14, 0xda, 0x3d, 0x6d, 0x62, 0xb2, 0x82, 0xdc, 0x84, 0xcb, 0x44, 0xdf, 0x1d, 0x0e, 0x7a, 0x9a,
+	0x69, 0xf7, 0x07, 0x7d, 0x9b, 0xd5, 0xcd, 0x48, 0xb3, 0x7a, 0x3b, 0x48, 0xc2, 0x6f, 0xc1, 0x05,
+	0x6b, 0x3c, 0xb6, 0x47, 0x9a, 0xf1, 0xc8, 0xee, 0x0d, 0x27, 0xa6, 0xa5, 0x13, 0x13, 0x95, 0x0b,
+	0x95, 0x59, 0x61, 0x1b, 0x0c, 0x8c, 0x7b, 0xba, 0xc9, 0xca, 0xd6, 0x26, 0x9a, 0xa5, 0xdb, 0xc3,
+	0xc1, 0x68, 0x60, 0xe9, 0x7d, 0x24, 0xe3, 0x36, 0x5c, 0x22, 0xfa, 0x67, 0x13, 0xdd, 0xb4, 0x8a,
+	0x9a, 0x2a, 0xab, 0xd0, 0x81, 0x61, 0x5a, 0xac, 0xfa, 0x85, 0x14, 0xd5, 0xf0, 0xdb, 0x70, 0xd1,
+	0xd4, 0xc9, 0x83, 0x41, 0x4f, 0xb7, 0xf3, 0xd5, 0x5d, 0xc7, 0x97, 0x00, 0x59, 0x66, 0xbf, 0x5b,
+	0x90, 0x36, 0x18, 0x0d, 0xc6, 0xae, 0x3b, 0x31, 0x1f, 0x21, 0x85, 0x1d, 0xd5, 0x1b, 0x90, 0xde,
+	0x64, 0x60, 0xd9, 0x5d, 0xa2, 0x6b, 0x9f, 0xea, 0xc4, 0x1e, 0xef, 0xea, 0x06, 0x02, 0x7c, 0x19,
+	0xf0, 0x48, 0xb7, 0x76, 0xc6, 0xe2, 0xdd, 0xb4, 0xe1, 0x70, 0xfc, 0x50, 0xef, 0xa3, 0x35, 0x8c,
+	0xa0, 0x69, 0xe9, 0x86, 0x66, 0x58, 0x31, 0x81, 0x66, 0xf7, 0x07, 0xcf, 0x5f, 0x76, 0x4a, 0x5f,
+	0xbc, 0xec, 0x94, 0xbe, 0x7a, 0xd9, 0x91, 0x7e, 0x7e, 0xd2, 0x91, 0xfe, 0x70, 0xd2, 0x91, 0x9e,
+	0x9d, 0x74, 0xa4, 0xe7, 0x27, 0x1d, 0xe9, 0xaf, 0x27, 0x1d, 0xe9, 0xcb, 0x93, 0x4e, 0xe9, 0xab,
+	0x93, 0x8e, 0xf4, 0xeb, 0x57, 0x9d, 0xd2, 0xf3, 0x57, 0x9d, 0xd2, 0x17, 0xaf, 0x3a, 0xa5, 0x9f,
+	0xd4, 0xe3, 0x7f, 0xb5, 0xf6, 0x6a, 0xfc, 0x3f, 0xac, 0x9b, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff,
+	0x61, 0x5f, 0x9f, 0x04, 0x24, 0x13, 0x00, 0x00,
 }
 
 func (x ErrorCause) String() string {
@@ -2211,7 +2172,7 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -2241,33 +2202,6 @@ func (this *TimeSeries) Equal(that interface{}) bool {
 	}
 	return true
 }
-func (this *LabelPair) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*LabelPair)
-	if !ok {
-		that2, ok := that.(LabelPair)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if !bytes.Equal(this.Name, that1.Name) {
-		return false
-	}
-	if !bytes.Equal(this.Value, that1.Value) {
-		return false
-	}
-	return true
-}
 func (this *Sample) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
@@ -2351,7 +2285,7 @@ func (this *Metric) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -2380,7 +2314,7 @@ func (this *Exemplar) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -3245,7 +3179,13 @@ func (this *TimeSeries) GoString() string {
 	}
 	s := make([]string, 0, 8)
 	s = append(s, "&mimirpb.TimeSeries{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	if this.Samples != nil {
 		vs := make([]*Sample, len(this.Samples))
 		for i := range vs {
@@ -3270,17 +3210,6 @@ func (this *TimeSeries) GoString() string {
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
-func (this *LabelPair) GoString() string {
-	if this == nil {
-		return "nil"
-	}
-	s := make([]string, 0, 6)
-	s = append(s, "&mimirpb.LabelPair{")
-	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
-	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
-	s = append(s, "}")
-	return strings.Join(s, "")
-}
 func (this *Sample) GoString() string {
 	if this == nil {
 		return "nil"
@@ -3311,7 +3240,13 @@ func (this *Metric) GoString() string {
 	}
 	s := make([]string, 0, 5)
 	s = append(s, "&mimirpb.Metric{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
@@ -3321,7 +3256,13 @@ func (this *Exemplar) GoString() string {
 	}
 	s := make([]string, 0, 7)
 	s = append(s, "&mimirpb.Exemplar{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
 	s = append(s, "TimestampMs: "+fmt.Sprintf("%#v", this.TimestampMs)+",\n")
 	s = append(s, "}")
@@ -3855,11 +3796,11 @@ func (m *TimeSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintMimir(dAtA, i, uint64(size))
 			}
 			i--
@@ -3869,43 +3810,6 @@ func (m *TimeSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *LabelPair) 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 *LabelPair) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *LabelPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Value) > 0 {
-		i -= len(m.Value)
-		copy(dAtA[i:], m.Value)
-		i = encodeVarintMimir(dAtA, i, uint64(len(m.Value)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintMimir(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *Sample) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -4012,11 +3916,11 @@ func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintMimir(dAtA, i, uint64(size))
 			}
 			i--
@@ -4060,11 +3964,11 @@ func (m *Exemplar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintMimir(dAtA, i, uint64(size))
 			}
 			i--
@@ -5148,23 +5052,6 @@ func (m *TimeSeries) Size() (n int) {
 	return n
 }
 
-func (m *LabelPair) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Name)
-	if l > 0 {
-		n += 1 + l + sovMimir(uint64(l))
-	}
-	l = len(m.Value)
-	if l > 0 {
-		n += 1 + l + sovMimir(uint64(l))
-	}
-	return n
-}
-
 func (m *Sample) Size() (n int) {
 	if m == nil {
 		return 0
@@ -5740,6 +5627,11 @@ func (this *TimeSeries) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	repeatedStringForSamples := "[]Sample{"
 	for _, f := range this.Samples {
 		repeatedStringForSamples += strings.Replace(strings.Replace(f.String(), "Sample", "Sample", 1), `&`, ``, 1) + ","
@@ -5756,7 +5648,7 @@ func (this *TimeSeries) String() string {
 	}
 	repeatedStringForHistograms += "}"
 	s := strings.Join([]string{`&TimeSeries{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`Samples:` + repeatedStringForSamples + `,`,
 		`Exemplars:` + repeatedStringForExemplars + `,`,
 		`Histograms:` + repeatedStringForHistograms + `,`,
@@ -5764,17 +5656,6 @@ func (this *TimeSeries) String() string {
 	}, "")
 	return s
 }
-func (this *LabelPair) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&LabelPair{`,
-		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
-		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
-		`}`,
-	}, "")
-	return s
-}
 func (this *Sample) String() string {
 	if this == nil {
 		return "nil"
@@ -5803,8 +5684,13 @@ func (this *Metric) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&Metric{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`}`,
 	}, "")
 	return s
@@ -5813,8 +5699,13 @@ func (this *Exemplar) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&Exemplar{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
 		`TimestampMs:` + fmt.Sprintf("%v", this.TimestampMs) + `,`,
 		`}`,
@@ -6212,7 +6103,6 @@ func (m *WriteRequest) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			m.Timeseries = append(m.Timeseries, PreallocTimeseries{})
-			m.Timeseries[len(m.Timeseries)-1].skipUnmarshalingExemplars = m.skipUnmarshalingExemplars
 			if err := m.Timeseries[len(m.Timeseries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -6585,11 +6475,9 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if !m.SkipUnmarshalingExemplars {
-				m.Exemplars = append(m.Exemplars, Exemplar{})
-				if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-					return err
-				}
+			m.Exemplars = append(m.Exemplars, Exemplar{})
+			if err := m.Exemplars[len(m.Exemplars)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 4:
@@ -6650,127 +6538,6 @@ func (m *TimeSeries) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *LabelPair) 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 ErrIntOverflowMimir
-			}
-			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: LabelPair: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: LabelPair: 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 byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowMimir
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthMimir
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthMimir
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
-			if m.Name == nil {
-				m.Name = []byte{}
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowMimir
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthMimir
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthMimir
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
-			if m.Value == nil {
-				m.Value = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipMimir(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthMimir
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthMimir
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *Sample) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/pkg/mimirpb/mimir.proto b/pkg/mimirpb/mimir.proto
index a22b619cdfe..f6c6474b221 100644
--- a/pkg/mimirpb/mimir.proto
+++ b/pkg/mimirpb/mimir.proto
@@ -12,7 +12,8 @@ package cortexpb;
 
 option go_package = "mimirpb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
@@ -58,18 +59,13 @@ message ErrorDetails {
 }
 
 message TimeSeries {
-  repeated LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "LabelAdapter"];
+  repeated LabelAdapter labels = 1 [(gogoproto.nullable) = false];
   // Sorted by time, oldest sample first.
   repeated Sample samples = 2 [(gogoproto.nullable) = false];
   repeated Exemplar exemplars = 3 [(gogoproto.nullable) = false];
   repeated Histogram histograms = 4 [(gogoproto.nullable) = false];
 }
 
-message LabelPair {
-  bytes name  = 1;
-  bytes value = 2;
-}
-
 message Sample {
 	// Fields order MUST match promql.FPoint so that we can cast types between them.
   int64 timestamp_ms = 2;
@@ -95,12 +91,12 @@ message MetricMetadata {
 }
 
 message Metric {
-  repeated LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "LabelAdapter"];
+  repeated LabelAdapter labels = 1 [(gogoproto.nullable) = false];
 }
 
 message Exemplar {
   // Exemplar labels, different than series labels
-  repeated LabelPair labels = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "LabelAdapter"];
+  repeated LabelAdapter labels = 1 [(gogoproto.nullable) = false];
   double value = 2;
   int64 timestamp_ms = 3;
 }
diff --git a/pkg/mimirpb/mimir_custom_types.proto b/pkg/mimirpb/mimir_custom_types.proto
new file mode 100644
index 00000000000..6168bcf18f8
--- /dev/null
+++ b/pkg/mimirpb/mimir_custom_types.proto
@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+package cortexpb;
+
+option go_package = "mimirpb";
+
+message LabelAdapter {
+  string name  = 1;
+  string value = 2;
+}
\ No newline at end of file
diff --git a/pkg/mimirpb/timeseries.go b/pkg/mimirpb/timeseries.go
index 3726621775e..7aec4d91a63 100644
--- a/pkg/mimirpb/timeseries.go
+++ b/pkg/mimirpb/timeseries.go
@@ -439,12 +439,12 @@ func (bs *LabelAdapter) Size() (n int) {
 }
 
 // Equal implements proto.Equaler.
-func (bs *LabelAdapter) Equal(other LabelAdapter) bool {
+func (bs *LabelAdapter) Equal(other *LabelAdapter) bool {
 	return bs.Name == other.Name && bs.Value == other.Value
 }
 
 // Compare implements proto.Comparer.
-func (bs *LabelAdapter) Compare(other LabelAdapter) int {
+func (bs *LabelAdapter) Compare(other *LabelAdapter) int {
 	if c := strings.Compare(bs.Name, other.Name); c != 0 {
 		return c
 	}
diff --git a/pkg/querier/stats/stats.pb.go b/pkg/querier/stats/stats.pb.go
index 60c208a2a4a..85d5cec7c3d 100644
--- a/pkg/querier/stats/stats.pb.go
+++ b/pkg/querier/stats/stats.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: stats.proto
+// source: pkg/querier/stats/stats.proto
 
 package stats
 
@@ -57,7 +57,7 @@ type Stats struct {
 func (m *Stats) Reset()      { *m = Stats{} }
 func (*Stats) ProtoMessage() {}
 func (*Stats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_b4756a0aec8b9d44, []int{0}
+	return fileDescriptor_8ca2404f80bab2e8, []int{0}
 }
 func (m *Stats) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -167,37 +167,37 @@ func init() {
 	proto.RegisterType((*Stats)(nil), "stats.Stats")
 }
 
-func init() { proto.RegisterFile("stats.proto", fileDescriptor_b4756a0aec8b9d44) }
+func init() { proto.RegisterFile("pkg/querier/stats/stats.proto", fileDescriptor_8ca2404f80bab2e8) }
 
-var fileDescriptor_b4756a0aec8b9d44 = []byte{
-	// 422 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x8e, 0xd3, 0x40,
-	0x10, 0x86, 0xbd, 0x90, 0x1c, 0xc9, 0x9a, 0x03, 0xce, 0x44, 0xc8, 0x5c, 0xb1, 0x17, 0x41, 0x41,
-	0x24, 0x24, 0x07, 0x01, 0x1d, 0x0d, 0xf2, 0xa5, 0xa1, 0x83, 0x84, 0x8a, 0xc6, 0x72, 0xec, 0x89,
-	0x63, 0x61, 0x7b, 0x1d, 0xef, 0x5a, 0x40, 0xc7, 0x23, 0x50, 0xf2, 0x08, 0x3c, 0x4a, 0xca, 0x94,
-	0xa9, 0x80, 0x38, 0x0d, 0x65, 0x1e, 0x01, 0x79, 0x76, 0x1d, 0x25, 0x57, 0xa5, 0xf3, 0xce, 0x37,
-	0xdf, 0xce, 0xaf, 0x1d, 0x53, 0x53, 0x48, 0x5f, 0x0a, 0x27, 0x2f, 0xb8, 0xe4, 0x56, 0x1b, 0x0f,
-	0x97, 0xbd, 0x88, 0x47, 0x1c, 0x2b, 0xc3, 0xfa, 0x4b, 0xc1, 0x4b, 0x16, 0x71, 0x1e, 0x25, 0x30,
-	0xc4, 0xd3, 0xb4, 0x9c, 0x0d, 0xc3, 0xb2, 0xf0, 0x65, 0xcc, 0x33, 0xc5, 0x9f, 0x2c, 0x5b, 0xb4,
-	0x3d, 0xa9, 0x7d, 0xeb, 0x2d, 0xed, 0x7e, 0xf1, 0x93, 0xc4, 0x93, 0x71, 0x0a, 0x36, 0xe9, 0x93,
-	0x81, 0xf9, 0xf2, 0xb1, 0xa3, 0x6c, 0xa7, 0xb1, 0x9d, 0x91, 0xb6, 0xdd, 0xce, 0xf2, 0xf7, 0x95,
-	0xf1, 0xf3, 0xcf, 0x15, 0x19, 0x77, 0x6a, 0xeb, 0x63, 0x9c, 0x82, 0xf5, 0x82, 0xf6, 0x66, 0x20,
-	0x83, 0x39, 0x84, 0x9e, 0x80, 0x22, 0x06, 0xe1, 0x05, 0xbc, 0xcc, 0xa4, 0x7d, 0xab, 0x4f, 0x06,
-	0xad, 0xb1, 0xa5, 0xd9, 0x04, 0xd1, 0x75, 0x4d, 0x2c, 0x87, 0x3e, 0x6c, 0x8c, 0x60, 0x5e, 0x66,
-	0x9f, 0xbd, 0xe9, 0x37, 0x09, 0xc2, 0xbe, 0x8d, 0xc2, 0x85, 0x46, 0xd7, 0x35, 0x71, 0x6b, 0x70,
-	0x38, 0x01, 0xfb, 0x9b, 0x09, 0xad, 0xa3, 0x09, 0x28, 0xe8, 0x09, 0xcf, 0xe8, 0x7d, 0x31, 0xf7,
-	0x8b, 0x10, 0x42, 0x6f, 0x51, 0xe2, 0x64, 0xbb, 0xdd, 0x27, 0x83, 0xf3, 0xf1, 0x3d, 0x5d, 0xfe,
-	0xa0, 0xaa, 0xd6, 0x53, 0x7a, 0x2e, 0xf2, 0x24, 0x96, 0xfb, 0xb6, 0x33, 0x6c, 0xbb, 0x8b, 0xc5,
-	0xa6, 0xe9, 0x20, 0x6f, 0x9c, 0x85, 0xf0, 0x55, 0xe7, 0xbd, 0x73, 0x94, 0xf7, 0x5d, 0x4d, 0x54,
-	0xde, 0xd7, 0xf4, 0x11, 0x08, 0x19, 0xa7, 0xbe, 0xbc, 0xf9, 0x26, 0x1d, 0x54, 0x7a, 0x7b, 0x7a,
-	0xf8, 0x2a, 0x2e, 0xa5, 0x8b, 0x12, 0x4a, 0x50, 0xab, 0xe8, 0x9e, 0xbe, 0x8a, 0x2e, 0x6a, 0xb8,
-	0x8b, 0x11, 0x35, 0x21, 0x0b, 0x78, 0xa8, 0x2f, 0xa1, 0xa7, 0x5f, 0x42, 0x95, 0x87, 0xb7, 0x3c,
-	0xa7, 0x17, 0xc2, 0x4f, 0xf3, 0x04, 0x84, 0x97, 0x17, 0x3c, 0x00, 0x21, 0x20, 0xb4, 0x4d, 0x8c,
-	0xfe, 0x40, 0x83, 0xf7, 0x4d, 0xdd, 0x7d, 0xb3, 0xda, 0x30, 0x63, 0xbd, 0x61, 0xc6, 0x6e, 0xc3,
-	0xc8, 0xf7, 0x8a, 0x91, 0x5f, 0x15, 0x23, 0xcb, 0x8a, 0x91, 0x55, 0xc5, 0xc8, 0xdf, 0x8a, 0x91,
-	0x7f, 0x15, 0x33, 0x76, 0x15, 0x23, 0x3f, 0xb6, 0xcc, 0x58, 0x6d, 0x99, 0xb1, 0xde, 0x32, 0xe3,
-	0x93, 0xfa, 0x7b, 0xa7, 0x67, 0x18, 0xe9, 0xd5, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x44, 0x02,
-	0xa0, 0xdb, 0xda, 0x02, 0x00, 0x00,
+var fileDescriptor_8ca2404f80bab2e8 = []byte{
+	// 432 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcf, 0xae, 0xd2, 0x40,
+	0x14, 0x87, 0x3b, 0x0a, 0x57, 0x18, 0xbc, 0xea, 0xad, 0xc4, 0xd4, 0x9b, 0x38, 0x10, 0x5d, 0x48,
+	0x62, 0xd2, 0x1a, 0x75, 0xe7, 0xc6, 0x14, 0x36, 0xee, 0x14, 0x5c, 0xb9, 0x69, 0x4a, 0x7b, 0x28,
+	0x0d, 0x6d, 0xa7, 0x74, 0xa6, 0x51, 0x77, 0x3e, 0x82, 0x4b, 0x1f, 0xc1, 0x47, 0x61, 0xc9, 0x92,
+	0x95, 0x4a, 0xd9, 0xb8, 0xe4, 0x11, 0xcc, 0xfc, 0x29, 0x81, 0xbb, 0x62, 0x43, 0x98, 0xf3, 0x9d,
+	0x6f, 0xce, 0x2f, 0x73, 0x8a, 0x9f, 0xe4, 0x8b, 0xc8, 0x59, 0x96, 0x50, 0xc4, 0x50, 0x38, 0x8c,
+	0xfb, 0x9c, 0xa9, 0x5f, 0x3b, 0x2f, 0x28, 0xa7, 0x66, 0x53, 0x1e, 0xae, 0xbb, 0x11, 0x8d, 0xa8,
+	0xac, 0x38, 0xe2, 0x9f, 0x82, 0xd7, 0x24, 0xa2, 0x34, 0x4a, 0xc0, 0x91, 0xa7, 0x69, 0x39, 0x73,
+	0xc2, 0xb2, 0xf0, 0x79, 0x4c, 0x33, 0xc5, 0x9f, 0xae, 0x1a, 0xb8, 0x39, 0x11, 0xbe, 0xf9, 0x0e,
+	0xb7, 0xbf, 0xf8, 0x49, 0xe2, 0xf1, 0x38, 0x05, 0x0b, 0xf5, 0xd1, 0xa0, 0xf3, 0xea, 0xb1, 0xad,
+	0x6c, 0xbb, 0xb6, 0xed, 0x91, 0xb6, 0xdd, 0xd6, 0xea, 0x77, 0xcf, 0xf8, 0xf9, 0xa7, 0x87, 0xc6,
+	0x2d, 0x61, 0x7d, 0x8a, 0x53, 0x30, 0x5f, 0xe2, 0xee, 0x0c, 0x78, 0x30, 0x87, 0xd0, 0x63, 0x22,
+	0x2c, 0xf3, 0x02, 0x5a, 0x66, 0xdc, 0xba, 0xd5, 0x47, 0x83, 0xc6, 0xd8, 0xd4, 0x6c, 0x22, 0xd1,
+	0x50, 0x10, 0xd3, 0xc6, 0x0f, 0x6b, 0x23, 0x98, 0x97, 0xd9, 0xc2, 0x9b, 0x7e, 0xe3, 0xc0, 0xac,
+	0xdb, 0x52, 0xb8, 0xd2, 0x68, 0x28, 0x88, 0x2b, 0xc0, 0xf1, 0x04, 0xd9, 0x5f, 0x4f, 0x68, 0x9c,
+	0x4c, 0x90, 0x82, 0x9e, 0xf0, 0x1c, 0xdf, 0x67, 0x73, 0xbf, 0x08, 0x21, 0xf4, 0xd4, 0x0b, 0x32,
+	0xab, 0xd9, 0x47, 0x83, 0xcb, 0xf1, 0x3d, 0x5d, 0xfe, 0xa8, 0xaa, 0xe6, 0x33, 0x7c, 0xc9, 0xf2,
+	0x24, 0xe6, 0x87, 0xb6, 0x0b, 0xd9, 0x76, 0x57, 0x16, 0xeb, 0xa6, 0xa3, 0xbc, 0x71, 0x16, 0xc2,
+	0x57, 0x9d, 0xf7, 0xce, 0x49, 0xde, 0xf7, 0x82, 0xa8, 0xbc, 0x6f, 0xf0, 0x23, 0x60, 0x3c, 0x4e,
+	0x7d, 0x7e, 0xf3, 0x4d, 0x5a, 0x52, 0xe9, 0x1e, 0xe8, 0xf1, 0xab, 0xb8, 0x18, 0x2f, 0x4b, 0x28,
+	0x41, 0xad, 0xa2, 0x7d, 0xfe, 0x2a, 0xda, 0x52, 0x93, 0xbb, 0x18, 0xe1, 0x0e, 0x64, 0x01, 0x0d,
+	0xf5, 0x25, 0xf8, 0xfc, 0x4b, 0xb0, 0xf2, 0xe4, 0x2d, 0x2f, 0xf0, 0x15, 0xf3, 0xd3, 0x3c, 0x01,
+	0xe6, 0xe5, 0x05, 0x0d, 0x80, 0x31, 0x08, 0xad, 0x8e, 0x8c, 0xfe, 0x40, 0x83, 0x0f, 0x75, 0xdd,
+	0x7d, 0xbb, 0xde, 0x12, 0x63, 0xb3, 0x25, 0xc6, 0x7e, 0x4b, 0xd0, 0xf7, 0x8a, 0xa0, 0x5f, 0x15,
+	0x41, 0xab, 0x8a, 0xa0, 0x75, 0x45, 0xd0, 0xdf, 0x8a, 0xa0, 0x7f, 0x15, 0x31, 0xf6, 0x15, 0x41,
+	0x3f, 0x76, 0xc4, 0x58, 0xef, 0x88, 0xb1, 0xd9, 0x11, 0xe3, 0xb3, 0xfa, 0x7a, 0xa7, 0x17, 0x32,
+	0xd2, 0xeb, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x63, 0xbc, 0x98, 0x09, 0xec, 0x02, 0x00, 0x00,
 }
 
 func (this *Stats) Equal(that interface{}) bool {
diff --git a/pkg/ruler/ruler.pb.go b/pkg/ruler/ruler.pb.go
index 73d87f439ec..7686dbce8c5 100644
--- a/pkg/ruler/ruler.pb.go
+++ b/pkg/ruler/ruler.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: ruler.proto
+// source: pkg/ruler/ruler.proto
 
 package ruler
 
@@ -10,9 +10,6 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/grafana/mimir/pkg/mimirpb"
-	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
-	rulespb "github.com/grafana/mimir/pkg/ruler/rulespb"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -21,6 +18,8 @@ import (
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	mimirpb "pkg/mimirpb"
+	rulespb "pkg/ruler/rulespb"
 	reflect "reflect"
 	strconv "strconv"
 	strings "strings"
@@ -60,7 +59,7 @@ var RulesRequest_RuleType_value = map[string]int32{
 }
 
 func (RulesRequest_RuleType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{0, 0}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{0, 0}
 }
 
 type RulesRequest struct {
@@ -76,7 +75,7 @@ type RulesRequest struct {
 func (m *RulesRequest) Reset()      { *m = RulesRequest{} }
 func (*RulesRequest) ProtoMessage() {}
 func (*RulesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{0}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{0}
 }
 func (m *RulesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -161,7 +160,7 @@ type RulesResponse struct {
 func (m *RulesResponse) Reset()      { *m = RulesResponse{} }
 func (*RulesResponse) ProtoMessage() {}
 func (*RulesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{1}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{1}
 }
 func (m *RulesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -206,7 +205,7 @@ type SyncRulesRequest struct {
 func (m *SyncRulesRequest) Reset()      { *m = SyncRulesRequest{} }
 func (*SyncRulesRequest) ProtoMessage() {}
 func (*SyncRulesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{2}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{2}
 }
 func (m *SyncRulesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -249,7 +248,7 @@ type SyncRulesResponse struct {
 func (m *SyncRulesResponse) Reset()      { *m = SyncRulesResponse{} }
 func (*SyncRulesResponse) ProtoMessage() {}
 func (*SyncRulesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{3}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{3}
 }
 func (m *SyncRulesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -289,7 +288,7 @@ type GroupStateDesc struct {
 func (m *GroupStateDesc) Reset()      { *m = GroupStateDesc{} }
 func (*GroupStateDesc) ProtoMessage() {}
 func (*GroupStateDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{4}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{4}
 }
 func (m *GroupStateDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -360,7 +359,7 @@ type RuleStateDesc struct {
 func (m *RuleStateDesc) Reset()      { *m = RuleStateDesc{} }
 func (*RuleStateDesc) ProtoMessage() {}
 func (*RuleStateDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{5}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{5}
 }
 func (m *RuleStateDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -439,22 +438,22 @@ func (m *RuleStateDesc) GetEvaluationDuration() time.Duration {
 }
 
 type AlertStateDesc struct {
-	State           string                                              `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
-	Labels          []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,2,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
-	Annotations     []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,3,rep,name=annotations,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"annotations"`
-	Value           float64                                             `protobuf:"fixed64,4,opt,name=value,proto3" json:"value,omitempty"`
-	ActiveAt        time.Time                                           `protobuf:"bytes,5,opt,name=active_at,json=activeAt,proto3,stdtime" json:"active_at"`
-	FiredAt         time.Time                                           `protobuf:"bytes,6,opt,name=fired_at,json=firedAt,proto3,stdtime" json:"fired_at"`
-	ResolvedAt      time.Time                                           `protobuf:"bytes,7,opt,name=resolved_at,json=resolvedAt,proto3,stdtime" json:"resolved_at"`
-	LastSentAt      time.Time                                           `protobuf:"bytes,8,opt,name=last_sent_at,json=lastSentAt,proto3,stdtime" json:"last_sent_at"`
-	ValidUntil      time.Time                                           `protobuf:"bytes,9,opt,name=valid_until,json=validUntil,proto3,stdtime" json:"valid_until"`
-	KeepFiringSince time.Time                                           `protobuf:"bytes,10,opt,name=keep_firing_since,json=keepFiringSince,proto3,stdtime" json:"keep_firing_since"`
+	State           string                 `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
+	Labels          []mimirpb.LabelAdapter `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels"`
+	Annotations     []mimirpb.LabelAdapter `protobuf:"bytes,3,rep,name=annotations,proto3" json:"annotations"`
+	Value           float64                `protobuf:"fixed64,4,opt,name=value,proto3" json:"value,omitempty"`
+	ActiveAt        time.Time              `protobuf:"bytes,5,opt,name=active_at,json=activeAt,proto3,stdtime" json:"active_at"`
+	FiredAt         time.Time              `protobuf:"bytes,6,opt,name=fired_at,json=firedAt,proto3,stdtime" json:"fired_at"`
+	ResolvedAt      time.Time              `protobuf:"bytes,7,opt,name=resolved_at,json=resolvedAt,proto3,stdtime" json:"resolved_at"`
+	LastSentAt      time.Time              `protobuf:"bytes,8,opt,name=last_sent_at,json=lastSentAt,proto3,stdtime" json:"last_sent_at"`
+	ValidUntil      time.Time              `protobuf:"bytes,9,opt,name=valid_until,json=validUntil,proto3,stdtime" json:"valid_until"`
+	KeepFiringSince time.Time              `protobuf:"bytes,10,opt,name=keep_firing_since,json=keepFiringSince,proto3,stdtime" json:"keep_firing_since"`
 }
 
 func (m *AlertStateDesc) Reset()      { *m = AlertStateDesc{} }
 func (*AlertStateDesc) ProtoMessage() {}
 func (*AlertStateDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9ecbec0a4cfddea6, []int{6}
+	return fileDescriptor_3c19a8c4b40c8e7b, []int{6}
 }
 func (m *AlertStateDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -490,6 +489,20 @@ func (m *AlertStateDesc) GetState() string {
 	return ""
 }
 
+func (m *AlertStateDesc) GetLabels() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
+func (m *AlertStateDesc) GetAnnotations() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Annotations
+	}
+	return nil
+}
+
 func (m *AlertStateDesc) GetValue() float64 {
 	if m != nil {
 		return m.Value
@@ -550,68 +563,67 @@ func init() {
 	proto.RegisterType((*AlertStateDesc)(nil), "ruler.AlertStateDesc")
 }
 
-func init() { proto.RegisterFile("ruler.proto", fileDescriptor_9ecbec0a4cfddea6) }
-
-var fileDescriptor_9ecbec0a4cfddea6 = []byte{
-	// 924 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0x23, 0x45,
-	0x10, 0x9e, 0x71, 0xe2, 0x9f, 0x29, 0x27, 0xd9, 0xa4, 0x13, 0x60, 0xd6, 0x2c, 0x13, 0xcb, 0x08,
-	0xc9, 0x42, 0xca, 0x04, 0x42, 0x04, 0x42, 0x42, 0x80, 0xa3, 0xdd, 0x45, 0x48, 0x08, 0xad, 0xc6,
-	0x81, 0xeb, 0xa8, 0x6d, 0xb7, 0x27, 0xa3, 0xcc, 0x1f, 0xdd, 0x3d, 0x91, 0x73, 0x82, 0x47, 0xd8,
-	0x23, 0x67, 0x4e, 0xbc, 0x01, 0x77, 0x4e, 0x7b, 0xcc, 0x71, 0x85, 0xd0, 0x42, 0x9c, 0x0b, 0xc7,
-	0x7d, 0x04, 0xd4, 0xd5, 0x33, 0xb1, 0xbd, 0x1b, 0x50, 0x2c, 0xd8, 0x4b, 0xdc, 0xf5, 0xf3, 0x7d,
-	0xd5, 0xf5, 0x55, 0x4d, 0x07, 0x9a, 0x3c, 0x8f, 0x18, 0x77, 0x33, 0x9e, 0xca, 0x94, 0x54, 0xd1,
-	0x68, 0xed, 0x05, 0xa1, 0x3c, 0xc9, 0x07, 0xee, 0x30, 0x8d, 0xf7, 0x83, 0x34, 0x48, 0xf7, 0x31,
-	0x3a, 0xc8, 0xc7, 0x68, 0xa1, 0x81, 0x27, 0x8d, 0x6a, 0x39, 0x41, 0x9a, 0x06, 0x11, 0x9b, 0x65,
-	0x8d, 0x72, 0x4e, 0x65, 0x98, 0x26, 0x45, 0x7c, 0xf7, 0xc5, 0xb8, 0x0c, 0x63, 0x26, 0x24, 0x8d,
-	0xb3, 0x22, 0xe1, 0xbd, 0xf9, 0x7a, 0x9c, 0x8e, 0x69, 0x42, 0xf7, 0xe3, 0x30, 0x0e, 0xf9, 0x7e,
-	0x76, 0x1a, 0xe8, 0x53, 0x36, 0xd0, 0xbf, 0x05, 0xe2, 0xc3, 0x7f, 0x45, 0x60, 0x17, 0xf8, 0x57,
-	0x64, 0x03, 0xfd, 0xab, 0x71, 0x9d, 0x5f, 0x2a, 0xb0, 0xe6, 0x29, 0xdb, 0x63, 0xdf, 0xe5, 0x4c,
-	0x48, 0x72, 0x08, 0xb5, 0x71, 0x18, 0x49, 0xc6, 0x6d, 0xb3, 0x6d, 0x76, 0x37, 0x0e, 0xee, 0xb9,
-	0x5a, 0x8f, 0xf9, 0x24, 0x34, 0x8e, 0xcf, 0x33, 0xe6, 0x15, 0xb9, 0xe4, 0x4d, 0xb0, 0x54, 0x9a,
-	0x9f, 0xd0, 0x98, 0xd9, 0x95, 0xf6, 0x4a, 0xd7, 0xf2, 0x1a, 0xca, 0xf1, 0x35, 0x8d, 0x19, 0x79,
-	0x0b, 0x00, 0x83, 0x01, 0x4f, 0xf3, 0xcc, 0x5e, 0xc1, 0x28, 0xa6, 0x7f, 0xa1, 0x1c, 0x84, 0xc0,
-	0xea, 0x38, 0x8c, 0x98, 0xbd, 0x8a, 0x01, 0x3c, 0x93, 0x77, 0x60, 0x83, 0x4d, 0x86, 0x51, 0x3e,
-	0x62, 0x3e, 0x8d, 0x18, 0x97, 0xc2, 0xae, 0xb6, 0xcd, 0x6e, 0xc3, 0x5b, 0x2f, 0xbc, 0x3d, 0x74,
-	0x2a, 0xe6, 0x98, 0x4e, 0x34, 0xb1, 0xb0, 0x6b, 0x6d, 0xb3, 0x5b, 0xf5, 0xac, 0x98, 0x4e, 0x90,
-	0x18, 0xc3, 0x09, 0x9b, 0x48, 0x5f, 0xa6, 0xa7, 0x2c, 0xb1, 0xeb, 0x6d, 0x53, 0x15, 0x56, 0x9e,
-	0x63, 0xe5, 0xe8, 0x7c, 0x02, 0x8d, 0xb2, 0x11, 0xd2, 0x84, 0x7a, 0x2f, 0x39, 0x57, 0xe6, 0xa6,
-	0x41, 0x36, 0x61, 0x0d, 0x0b, 0x84, 0x49, 0x80, 0x1e, 0x93, 0x6c, 0xc1, 0xba, 0xc7, 0x86, 0x29,
-	0x1f, 0x95, 0xae, 0x4a, 0xe7, 0x53, 0x58, 0x2f, 0x34, 0x11, 0x59, 0x9a, 0x08, 0x46, 0xf6, 0xa0,
-	0x56, 0x5c, 0xc4, 0x6c, 0xaf, 0x74, 0x9b, 0x07, 0xaf, 0x15, 0xca, 0xe1, 0x65, 0xfa, 0x92, 0x4a,
-	0x76, 0x9f, 0x89, 0xa1, 0x57, 0x24, 0x75, 0xf6, 0x60, 0xb3, 0x7f, 0x9e, 0x0c, 0x17, 0xc4, 0xbf,
-	0x0b, 0x8d, 0x5c, 0x30, 0xee, 0x87, 0x23, 0x4d, 0x62, 0x79, 0x75, 0x65, 0x7f, 0x39, 0x12, 0x9d,
-	0x6d, 0xd8, 0x9a, 0x4b, 0xd7, 0x25, 0x3b, 0x3f, 0x55, 0x60, 0x63, 0x91, 0x9e, 0xbc, 0x0b, 0x55,
-	0xad, 0xb3, 0x1a, 0x5f, 0xf3, 0x60, 0xc7, 0xd5, 0xd3, 0xf6, 0x4a, 0xb9, 0xf1, 0x0e, 0x3a, 0x85,
-	0x7c, 0x04, 0x6b, 0x74, 0x28, 0xc3, 0x33, 0xe6, 0x63, 0x12, 0x0e, 0xae, 0x84, 0xe8, 0x89, 0xcf,
-	0xae, 0xdd, 0xd4, 0x99, 0x58, 0x9f, 0x7c, 0x0b, 0xdb, 0xec, 0x8c, 0x46, 0x39, 0x2e, 0xf5, 0x71,
-	0xb9, 0xbc, 0xf6, 0x0a, 0x96, 0x6c, 0xb9, 0x7a, 0xbd, 0xdd, 0x72, 0xbd, 0xdd, 0xeb, 0x8c, 0xa3,
-	0xc6, 0x93, 0x67, 0xbb, 0xc6, 0xe3, 0x3f, 0x76, 0x4d, 0xef, 0x26, 0x02, 0xd2, 0x07, 0x32, 0x73,
-	0xdf, 0x2f, 0x3e, 0x1a, 0x7b, 0x15, 0x69, 0xef, 0xbe, 0x44, 0x5b, 0x26, 0x68, 0xd6, 0x1f, 0x15,
-	0xeb, 0x0d, 0xf0, 0xce, 0xef, 0x15, 0x3d, 0xa9, 0x99, 0x46, 0x6f, 0xc3, 0xaa, 0x6a, 0xb1, 0x90,
-	0xe8, 0xce, 0x9c, 0x44, 0xd8, 0x2a, 0x06, 0xc9, 0x0e, 0x54, 0x85, 0x42, 0xd8, 0x15, 0xdc, 0x1b,
-	0x6d, 0x90, 0xd7, 0xa1, 0x76, 0xc2, 0x68, 0x24, 0x4f, 0xb0, 0x59, 0xcb, 0x2b, 0x2c, 0x72, 0x0f,
-	0xac, 0x88, 0x0a, 0xf9, 0x80, 0xf3, 0x94, 0xe3, 0x85, 0x2d, 0x6f, 0xe6, 0x50, 0xab, 0x71, 0xbd,
-	0xc6, 0xf3, 0xab, 0x81, 0x5b, 0x36, 0xb7, 0x1a, 0x3a, 0xe9, 0x9f, 0xe4, 0xad, 0xbd, 0x1a, 0x79,
-	0xeb, 0xff, 0x4d, 0xde, 0x5f, 0xab, 0xb0, 0xb1, 0xd8, 0xc7, 0x4c, 0x3a, 0x73, 0x5e, 0xba, 0x31,
-	0xd4, 0x22, 0x3a, 0x60, 0x51, 0xb9, 0x67, 0xdb, 0xee, 0x30, 0xe5, 0x92, 0x4d, 0xb2, 0x81, 0xfb,
-	0x95, 0xf2, 0x3f, 0xa2, 0x21, 0x3f, 0xfa, 0x58, 0xd5, 0xfa, 0xed, 0xd9, 0xee, 0xfb, 0xb7, 0x79,
-	0x01, 0x35, 0xae, 0x37, 0xa2, 0x99, 0x64, 0xdc, 0x2b, 0xd8, 0x49, 0x06, 0x4d, 0x9a, 0x24, 0xa9,
-	0xc4, 0xeb, 0x09, 0x7c, 0x6f, 0xfe, 0xff, 0x62, 0xf3, 0x25, 0x54, 0xbf, 0x4a, 0x17, 0x86, 0x83,
-	0x37, 0x3d, 0x6d, 0x90, 0x1e, 0x58, 0xc5, 0xd7, 0x45, 0x25, 0x3e, 0x5f, 0xb7, 0x9d, 0x5d, 0x43,
-	0xc3, 0x7a, 0x92, 0x7c, 0x06, 0x8d, 0x71, 0xc8, 0xd9, 0x48, 0x31, 0x2c, 0x33, 0xfd, 0x3a, 0xa2,
-	0x7a, 0x92, 0x3c, 0x80, 0x26, 0x67, 0x22, 0x8d, 0xce, 0x34, 0x47, 0x7d, 0x09, 0x0e, 0x28, 0x81,
-	0x3d, 0x49, 0x1e, 0xc2, 0x9a, 0x5a, 0x66, 0x5f, 0xb0, 0x44, 0x2a, 0x9e, 0xc6, 0x32, 0x3c, 0x0a,
-	0xd9, 0x67, 0x89, 0xd4, 0xd7, 0x39, 0xa3, 0x51, 0x38, 0xf2, 0xf3, 0x44, 0x86, 0x91, 0x6d, 0x2d,
-	0x43, 0x83, 0xc0, 0x6f, 0x14, 0x8e, 0x3c, 0x82, 0xad, 0x53, 0xc6, 0x32, 0x7f, 0x1c, 0xf2, 0x30,
-	0x09, 0x7c, 0x11, 0x26, 0x43, 0x66, 0xc3, 0x12, 0x64, 0x77, 0x14, 0xfc, 0x21, 0xa2, 0xfb, 0x0a,
-	0x7c, 0xf0, 0x3d, 0x54, 0xd5, 0xe7, 0xcf, 0xc9, 0xa1, 0x3e, 0x08, 0xb2, 0x7d, 0xc3, 0xff, 0xbd,
-	0xd6, 0xce, 0xa2, 0xb3, 0x78, 0x85, 0x0d, 0xf2, 0x39, 0x58, 0xd7, 0x8f, 0x33, 0x79, 0xa3, 0x48,
-	0x7a, 0xf1, 0x75, 0x6f, 0xd9, 0x2f, 0x07, 0x4a, 0x86, 0xa3, 0xc3, 0x8b, 0x4b, 0xc7, 0x78, 0x7a,
-	0xe9, 0x18, 0xcf, 0x2f, 0x1d, 0xf3, 0x87, 0xa9, 0x63, 0xfe, 0x3c, 0x75, 0xcc, 0x27, 0x53, 0xc7,
-	0xbc, 0x98, 0x3a, 0xe6, 0x9f, 0x53, 0xc7, 0xfc, 0x6b, 0xea, 0x18, 0xcf, 0xa7, 0x8e, 0xf9, 0xf8,
-	0xca, 0x31, 0x2e, 0xae, 0x1c, 0xe3, 0xe9, 0x95, 0x63, 0x0c, 0x6a, 0xd8, 0xe5, 0x07, 0x7f, 0x07,
-	0x00, 0x00, 0xff, 0xff, 0x98, 0xb6, 0x46, 0xf9, 0xb4, 0x08, 0x00, 0x00,
+func init() { proto.RegisterFile("pkg/ruler/ruler.proto", fileDescriptor_3c19a8c4b40c8e7b) }
+
+var fileDescriptor_3c19a8c4b40c8e7b = []byte{
+	// 905 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4f, 0x6f, 0x1b, 0x55,
+	0x10, 0xdf, 0x75, 0xfc, 0x6f, 0xc7, 0x49, 0x9a, 0xbc, 0xa4, 0xed, 0xd6, 0xb4, 0x1b, 0xcb, 0x80,
+	0x64, 0x21, 0xd5, 0x91, 0x42, 0x24, 0x2e, 0xa8, 0xe0, 0xa8, 0x2d, 0x42, 0x42, 0x08, 0xad, 0x03,
+	0xd7, 0xd5, 0xda, 0x1e, 0xbb, 0xab, 0xec, 0x3f, 0xde, 0x7b, 0x1b, 0xd9, 0x27, 0xf8, 0x08, 0x3d,
+	0x72, 0xe6, 0xc4, 0x37, 0xe0, 0x2b, 0xf4, 0x98, 0x63, 0x0f, 0xa8, 0x10, 0xe7, 0xc2, 0xb1, 0x1f,
+	0x01, 0xbd, 0x79, 0xbb, 0xb1, 0xdd, 0x04, 0x81, 0x85, 0xb8, 0x78, 0x77, 0x66, 0x7e, 0xf3, 0x9b,
+	0x79, 0xbf, 0x99, 0x7d, 0x86, 0xbb, 0xe9, 0xd9, 0xe4, 0x90, 0x67, 0x21, 0x72, 0xfd, 0xdb, 0x4d,
+	0x79, 0x22, 0x13, 0x56, 0x21, 0xa3, 0xb9, 0x3f, 0x49, 0x26, 0x09, 0x79, 0x0e, 0xd5, 0x9b, 0x0e,
+	0x36, 0x9d, 0x49, 0x92, 0x4c, 0x42, 0x3c, 0x24, 0x6b, 0x90, 0x8d, 0x0f, 0x47, 0x19, 0xf7, 0x65,
+	0x90, 0xc4, 0x79, 0xfc, 0xe0, 0xdd, 0xb8, 0x0c, 0x22, 0x14, 0xd2, 0x8f, 0xd2, 0x1c, 0x70, 0x5f,
+	0x15, 0x8d, 0x82, 0x28, 0xe0, 0xe9, 0x40, 0x3f, 0xf3, 0xc0, 0x07, 0x37, 0x02, 0xde, 0x30, 0x13,
+	0x32, 0x89, 0x3c, 0x39, 0x4b, 0x51, 0xe4, 0xa8, 0x47, 0xab, 0x3d, 0x8b, 0x74, 0xa0, 0x9f, 0x3a,
+	0xdc, 0xfe, 0xb5, 0x04, 0x9b, 0xae, 0xb2, 0x5d, 0xfc, 0x3e, 0x43, 0x21, 0xd9, 0x31, 0x54, 0xc7,
+	0x41, 0x28, 0x91, 0xdb, 0x66, 0xcb, 0xec, 0x6c, 0x1f, 0x3d, 0xec, 0xea, 0xa3, 0x2e, 0x83, 0xc8,
+	0x38, 0x9d, 0xa5, 0xe8, 0xe6, 0x58, 0xf6, 0x1e, 0x58, 0x0a, 0xe6, 0xc5, 0x7e, 0x84, 0x76, 0xa9,
+	0xb5, 0xd1, 0xb1, 0xdc, 0xba, 0x72, 0x7c, 0xed, 0x47, 0xc8, 0x1e, 0x01, 0x50, 0x70, 0xc2, 0x93,
+	0x2c, 0xb5, 0x37, 0x28, 0x4a, 0xf0, 0x2f, 0x94, 0x83, 0x31, 0x28, 0x8f, 0x83, 0x10, 0xed, 0x32,
+	0x05, 0xe8, 0x9d, 0x7d, 0x08, 0xdb, 0x38, 0x1d, 0x86, 0xd9, 0x08, 0x3d, 0x3f, 0x44, 0x2e, 0x85,
+	0x5d, 0x69, 0x99, 0x9d, 0xba, 0xbb, 0x95, 0x7b, 0x7b, 0xe4, 0x54, 0xcc, 0x91, 0x3f, 0xd5, 0xc4,
+	0xc2, 0xae, 0xb6, 0xcc, 0x4e, 0xc5, 0xb5, 0x22, 0x7f, 0x4a, 0xc4, 0x14, 0x8e, 0x71, 0x2a, 0x3d,
+	0x99, 0x9c, 0x61, 0x6c, 0xd7, 0x5a, 0xa6, 0x2a, 0xac, 0x3c, 0xa7, 0xca, 0xd1, 0xfe, 0x14, 0xea,
+	0xc5, 0x41, 0x58, 0x03, 0x6a, 0xbd, 0x78, 0xa6, 0xcc, 0x1d, 0x83, 0xed, 0xc0, 0x26, 0x15, 0x08,
+	0xe2, 0x09, 0x79, 0x4c, 0xb6, 0x0b, 0x5b, 0x2e, 0x0e, 0x13, 0x3e, 0x2a, 0x5c, 0xa5, 0xf6, 0x13,
+	0xd8, 0xca, 0x35, 0x11, 0x69, 0x12, 0x0b, 0x64, 0x8f, 0xa1, 0x9a, 0x37, 0x62, 0xb6, 0x36, 0x3a,
+	0x8d, 0xa3, 0xbb, 0xb9, 0x72, 0xd4, 0x4c, 0x5f, 0xfa, 0x12, 0x9f, 0xa2, 0x18, 0xba, 0x39, 0xa8,
+	0xfd, 0x18, 0x76, 0xfa, 0xb3, 0x78, 0xb8, 0x22, 0xfe, 0x03, 0xa8, 0x67, 0x02, 0xb9, 0x17, 0x8c,
+	0x34, 0x89, 0xe5, 0xd6, 0x94, 0xfd, 0xe5, 0x48, 0xb4, 0xf7, 0x60, 0x77, 0x09, 0xae, 0x4b, 0xb6,
+	0x7f, 0x2e, 0xc1, 0xf6, 0x2a, 0x3d, 0xfb, 0x08, 0x2a, 0x5a, 0x67, 0x35, 0xbe, 0xc6, 0xd1, 0x7e,
+	0x57, 0x4f, 0xdb, 0x2d, 0xe4, 0xa6, 0x1e, 0x34, 0x84, 0x7d, 0x02, 0x9b, 0xfe, 0x50, 0x06, 0xe7,
+	0xe8, 0x11, 0x88, 0x06, 0x57, 0xa4, 0xe8, 0x89, 0x2f, 0xda, 0x6e, 0x68, 0x24, 0xd5, 0x67, 0xdf,
+	0xc1, 0x1e, 0x9e, 0xfb, 0x61, 0x46, 0x8b, 0x7c, 0x5a, 0x2c, 0xac, 0xbd, 0x41, 0x25, 0x9b, 0x5d,
+	0xbd, 0xd2, 0xdd, 0x62, 0xa5, 0xbb, 0xd7, 0x88, 0x93, 0xfa, 0xab, 0x37, 0x07, 0xc6, 0xcb, 0xdf,
+	0x0f, 0x4c, 0xf7, 0x36, 0x02, 0xd6, 0x07, 0xb6, 0x70, 0x3f, 0xcd, 0x3f, 0x14, 0xbb, 0x4c, 0xb4,
+	0x0f, 0x6e, 0xd0, 0x16, 0x00, 0xcd, 0xfa, 0x93, 0x62, 0xbd, 0x25, 0xbd, 0xfd, 0x5b, 0x49, 0x4f,
+	0x6a, 0xa1, 0xd1, 0xfb, 0x50, 0x56, 0x47, 0xcc, 0x25, 0xba, 0xb3, 0x24, 0x11, 0x1d, 0x95, 0x82,
+	0x6c, 0x1f, 0x2a, 0x42, 0x65, 0xd8, 0x25, 0xda, 0x1b, 0x6d, 0xb0, 0x7b, 0x50, 0x7d, 0x81, 0x7e,
+	0x28, 0x5f, 0xd0, 0x61, 0x2d, 0x37, 0xb7, 0xd8, 0x43, 0xb0, 0x42, 0x5f, 0xc8, 0x67, 0x9c, 0x27,
+	0x9c, 0x1a, 0xb6, 0xdc, 0x85, 0x43, 0xad, 0xc6, 0xf5, 0x1a, 0x2f, 0xaf, 0x06, 0x6d, 0xd9, 0xd2,
+	0x6a, 0x68, 0xd0, 0xdf, 0xc9, 0x5b, 0xfd, 0x7f, 0xe4, 0xad, 0xfd, 0x37, 0x79, 0xdf, 0x94, 0x61,
+	0x7b, 0xf5, 0x1c, 0x0b, 0xe9, 0xcc, 0x65, 0xe9, 0x8e, 0xa1, 0x1a, 0xfa, 0x03, 0x0c, 0x8b, 0x3d,
+	0xbb, 0xd7, 0x1d, 0x26, 0x5c, 0xe2, 0x34, 0x1d, 0x74, 0xbf, 0x52, 0xfe, 0xde, 0xc8, 0x4f, 0x25,
+	0xf2, 0x93, 0xb2, 0x2a, 0xe7, 0xe6, 0x58, 0xf6, 0x04, 0x1a, 0x7e, 0x1c, 0x27, 0x92, 0x8a, 0x09,
+	0xba, 0x3d, 0xfe, 0x29, 0x75, 0x39, 0x41, 0xf5, 0xa2, 0x7a, 0x46, 0x1a, 0x8a, 0xe9, 0x6a, 0x83,
+	0xf5, 0xc0, 0xca, 0x37, 0xdf, 0x97, 0x74, 0xb5, 0xfc, 0x5b, 0x5d, 0xeb, 0x3a, 0xad, 0x27, 0xd9,
+	0x67, 0x50, 0x1f, 0x07, 0x1c, 0x47, 0x8a, 0x61, 0x9d, 0xc9, 0xd4, 0x28, 0xab, 0x27, 0xd9, 0x33,
+	0x68, 0x70, 0x14, 0x49, 0x78, 0xae, 0x39, 0x6a, 0x6b, 0x70, 0x40, 0x91, 0xd8, 0x93, 0xec, 0x39,
+	0x6c, 0xaa, 0x45, 0xf3, 0x04, 0xc6, 0x52, 0xf1, 0xd4, 0xd7, 0xe1, 0x51, 0x99, 0x7d, 0x8c, 0xa5,
+	0x6e, 0xe7, 0xdc, 0x0f, 0x83, 0x91, 0x97, 0xc5, 0x32, 0x08, 0x6d, 0x6b, 0x1d, 0x1a, 0x4a, 0xfc,
+	0x56, 0xe5, 0xb1, 0x6f, 0x60, 0xf7, 0x0c, 0x31, 0xf5, 0xc6, 0x01, 0x0f, 0xe2, 0x89, 0x27, 0x82,
+	0x78, 0x88, 0x36, 0xac, 0x41, 0x76, 0x47, 0xa5, 0x3f, 0xa7, 0xec, 0xbe, 0x4a, 0x3e, 0xfa, 0x01,
+	0x2a, 0xea, 0xd3, 0xe4, 0xec, 0x58, 0xbf, 0x08, 0xb6, 0x77, 0xcb, 0x7f, 0x52, 0x73, 0x7f, 0xd5,
+	0x99, 0xdf, 0x90, 0x06, 0xfb, 0x1c, 0xac, 0xeb, 0x8b, 0x93, 0xdd, 0xcf, 0x41, 0xef, 0xde, 0xbc,
+	0x4d, 0xfb, 0x66, 0xa0, 0x60, 0x38, 0x39, 0xbe, 0xb8, 0x74, 0x8c, 0xd7, 0x97, 0x8e, 0xf1, 0xf6,
+	0xd2, 0x31, 0x7f, 0x9c, 0x3b, 0xe6, 0x2f, 0x73, 0xc7, 0x7c, 0x35, 0x77, 0xcc, 0x8b, 0xb9, 0x63,
+	0xfe, 0x31, 0x77, 0xcc, 0x3f, 0xe7, 0x8e, 0xf1, 0x76, 0xee, 0x98, 0x2f, 0xaf, 0x1c, 0xe3, 0xe2,
+	0xca, 0x31, 0x5e, 0x5f, 0x39, 0xc6, 0xa0, 0x4a, 0xa7, 0xfc, 0xf8, 0xaf, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x91, 0xfd, 0x20, 0x5e, 0x35, 0x08, 0x00, 0x00,
 }
 
 func (x RulesRequest_RuleType) String() string {
@@ -868,7 +880,7 @@ func (this *AlertStateDesc) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -876,7 +888,7 @@ func (this *AlertStateDesc) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Annotations {
-		if !this.Annotations[i].Equal(that1.Annotations[i]) {
+		if !this.Annotations[i].Equal(&that1.Annotations[i]) {
 			return false
 		}
 	}
@@ -994,8 +1006,20 @@ func (this *AlertStateDesc) GoString() string {
 	s := make([]string, 0, 14)
 	s = append(s, "&ruler.AlertStateDesc{")
 	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
-	s = append(s, "Annotations: "+fmt.Sprintf("%#v", this.Annotations)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
+	if this.Annotations != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Annotations))
+		for i := range vs {
+			vs[i] = &this.Annotations[i]
+		}
+		s = append(s, "Annotations: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
 	s = append(s, "ActiveAt: "+fmt.Sprintf("%#v", this.ActiveAt)+",\n")
 	s = append(s, "FiredAt: "+fmt.Sprintf("%#v", this.FiredAt)+",\n")
@@ -1132,7 +1156,7 @@ var _Ruler_serviceDesc = grpc.ServiceDesc{
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
-	Metadata: "ruler.proto",
+	Metadata: "pkg/ruler/ruler.proto",
 }
 
 func (m *RulesRequest) Marshal() (dAtA []byte, err error) {
@@ -1532,11 +1556,11 @@ func (m *AlertStateDesc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Annotations) > 0 {
 		for iNdEx := len(m.Annotations) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Annotations[iNdEx].Size()
-				i -= size
-				if _, err := m.Annotations[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Annotations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintRuler(dAtA, i, uint64(size))
 			}
 			i--
@@ -1546,11 +1570,11 @@ func (m *AlertStateDesc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintRuler(dAtA, i, uint64(size))
 			}
 			i--
@@ -1854,10 +1878,20 @@ func (this *AlertStateDesc) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
+	repeatedStringForAnnotations := "[]LabelAdapter{"
+	for _, f := range this.Annotations {
+		repeatedStringForAnnotations += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForAnnotations += "}"
 	s := strings.Join([]string{`&AlertStateDesc{`,
 		`State:` + fmt.Sprintf("%v", this.State) + `,`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
-		`Annotations:` + fmt.Sprintf("%v", this.Annotations) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
+		`Annotations:` + repeatedStringForAnnotations + `,`,
 		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
 		`ActiveAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ActiveAt), "Timestamp", "timestamppb.Timestamp", 1), `&`, ``, 1) + `,`,
 		`FiredAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FiredAt), "Timestamp", "timestamppb.Timestamp", 1), `&`, ``, 1) + `,`,
@@ -2905,7 +2939,7 @@ func (m *AlertStateDesc) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2939,7 +2973,7 @@ func (m *AlertStateDesc) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Annotations = append(m.Annotations, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Annotations = append(m.Annotations, mimirpb.LabelAdapter{})
 			if err := m.Annotations[len(m.Annotations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/ruler/ruler.proto b/pkg/ruler/ruler.proto
index 0777b1f7250..d0bd96ecc48 100644
--- a/pkg/ruler/ruler.proto
+++ b/pkg/ruler/ruler.proto
@@ -9,11 +9,12 @@
 syntax = "proto3";
 package ruler;
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+import "gogoproto/gogo.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
-import "github.com/grafana/mimir/pkg/ruler/rulespb/rules.proto";
+import "pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
+import "pkg/ruler/rulespb/rules.proto";
 
 
 option (gogoproto.marshaler_all) = true;
@@ -76,14 +77,8 @@ message RuleStateDesc {
 
 message AlertStateDesc {
   string state = 1;
-  repeated cortexpb.LabelPair labels = 2 [
-    (gogoproto.nullable) = false,
-    (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"
-  ];
-  repeated cortexpb.LabelPair annotations = 3 [
-    (gogoproto.nullable) = false,
-    (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"
-  ];
+  repeated cortexpb.LabelAdapter labels = 2 [(gogoproto.nullable) = false];
+  repeated cortexpb.LabelAdapter annotations = 3 [(gogoproto.nullable) = false];
   double value = 4;
   google.protobuf.Timestamp active_at = 5
       [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
diff --git a/pkg/ruler/rulespb/rules.pb.go b/pkg/ruler/rulespb/rules.pb.go
index f5f5a11dbf7..3cbe5a1c89a 100644
--- a/pkg/ruler/rulespb/rules.pb.go
+++ b/pkg/ruler/rulespb/rules.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: rules.proto
+// source: pkg/ruler/rulespb/rules.proto
 
 package rulespb
 
@@ -9,12 +9,11 @@ import (
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	types "github.com/gogo/protobuf/types"
-	_ "github.com/grafana/mimir/pkg/mimirpb"
-	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	_ "google.golang.org/protobuf/types/known/durationpb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	mimirpb "pkg/mimirpb"
 	reflect "reflect"
 	strings "strings"
 	time "time"
@@ -54,7 +53,7 @@ type RuleGroupDesc struct {
 func (m *RuleGroupDesc) Reset()      { *m = RuleGroupDesc{} }
 func (*RuleGroupDesc) ProtoMessage() {}
 func (*RuleGroupDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8e722d3e922f0937, []int{0}
+	return fileDescriptor_dd3ef3757f506fba, []int{0}
 }
 func (m *RuleGroupDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -155,19 +154,19 @@ func (m *RuleGroupDesc) GetAlignEvaluationTimeOnInterval() bool {
 
 // RuleDesc is a proto representation of a Prometheus Rule
 type RuleDesc struct {
-	Expr          string                                              `protobuf:"bytes,1,opt,name=expr,proto3" json:"expr,omitempty"`
-	Record        string                                              `protobuf:"bytes,2,opt,name=record,proto3" json:"record,omitempty"`
-	Alert         string                                              `protobuf:"bytes,3,opt,name=alert,proto3" json:"alert,omitempty"`
-	For           time.Duration                                       `protobuf:"bytes,4,opt,name=for,proto3,stdduration" json:"for"`
-	KeepFiringFor time.Duration                                       `protobuf:"bytes,13,opt,name=keep_firing_for,json=keepFiringFor,proto3,stdduration" json:"keep_firing_for"`
-	Labels        []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,5,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
-	Annotations   []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,6,rep,name=annotations,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"annotations"`
+	Expr          string                 `protobuf:"bytes,1,opt,name=expr,proto3" json:"expr,omitempty"`
+	Record        string                 `protobuf:"bytes,2,opt,name=record,proto3" json:"record,omitempty"`
+	Alert         string                 `protobuf:"bytes,3,opt,name=alert,proto3" json:"alert,omitempty"`
+	For           time.Duration          `protobuf:"bytes,4,opt,name=for,proto3,stdduration" json:"for"`
+	KeepFiringFor time.Duration          `protobuf:"bytes,13,opt,name=keep_firing_for,json=keepFiringFor,proto3,stdduration" json:"keep_firing_for"`
+	Labels        []mimirpb.LabelAdapter `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels"`
+	Annotations   []mimirpb.LabelAdapter `protobuf:"bytes,6,rep,name=annotations,proto3" json:"annotations"`
 }
 
 func (m *RuleDesc) Reset()      { *m = RuleDesc{} }
 func (*RuleDesc) ProtoMessage() {}
 func (*RuleDesc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8e722d3e922f0937, []int{1}
+	return fileDescriptor_dd3ef3757f506fba, []int{1}
 }
 func (m *RuleDesc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -231,53 +230,67 @@ func (m *RuleDesc) GetKeepFiringFor() time.Duration {
 	return 0
 }
 
+func (m *RuleDesc) GetLabels() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Labels
+	}
+	return nil
+}
+
+func (m *RuleDesc) GetAnnotations() []mimirpb.LabelAdapter {
+	if m != nil {
+		return m.Annotations
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*RuleGroupDesc)(nil), "rules.RuleGroupDesc")
 	proto.RegisterType((*RuleDesc)(nil), "rules.RuleDesc")
 }
 
-func init() { proto.RegisterFile("rules.proto", fileDescriptor_8e722d3e922f0937) }
+func init() { proto.RegisterFile("pkg/ruler/rulespb/rules.proto", fileDescriptor_dd3ef3757f506fba) }
 
-var fileDescriptor_8e722d3e922f0937 = []byte{
-	// 608 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x31, 0x6f, 0xd3, 0x40,
-	0x14, 0xb6, 0x89, 0x93, 0x3a, 0x17, 0xa2, 0x56, 0x47, 0x85, 0xdc, 0x0a, 0xae, 0xa1, 0x02, 0x29,
-	0x0b, 0x0e, 0x14, 0x31, 0x30, 0x20, 0xd4, 0xaa, 0x2d, 0x50, 0x40, 0x45, 0x56, 0x27, 0x96, 0xe8,
-	0x9c, 0x3e, 0x1b, 0xab, 0xce, 0xdd, 0x71, 0xb6, 0xab, 0x66, 0x63, 0x61, 0x67, 0xe4, 0x27, 0x30,
-	0xf2, 0x33, 0x3a, 0x76, 0xac, 0x18, 0x0a, 0x75, 0x17, 0xc6, 0xfe, 0x04, 0x74, 0x77, 0x4e, 0x1b,
-	0xca, 0x12, 0x06, 0xa6, 0x7b, 0xef, 0xde, 0xfb, 0xde, 0xfb, 0xee, 0x7b, 0xef, 0x50, 0x4b, 0x16,
-	0x29, 0x64, 0xbe, 0x90, 0x3c, 0xe7, 0xb8, 0xae, 0x9d, 0xc5, 0xfb, 0x71, 0x92, 0xbf, 0x2f, 0x42,
-	0x7f, 0xc0, 0x87, 0xbd, 0x98, 0xc7, 0xbc, 0xa7, 0xa3, 0x61, 0x11, 0x69, 0x4f, 0x3b, 0xda, 0x32,
-	0xa8, 0x45, 0x12, 0x73, 0x1e, 0xa7, 0x70, 0x99, 0xb5, 0x5b, 0x48, 0x9a, 0x27, 0x9c, 0x55, 0xf1,
-	0x85, 0xab, 0x71, 0xca, 0x46, 0x55, 0xe8, 0xc1, 0x64, 0x27, 0x49, 0x23, 0xca, 0x68, 0x6f, 0x98,
-	0x0c, 0x13, 0xd9, 0x13, 0x7b, 0xb1, 0xb1, 0x44, 0x68, 0x4e, 0x83, 0x58, 0xfe, 0xe4, 0xa0, 0x76,
-	0x50, 0xa4, 0xf0, 0x5c, 0xf2, 0x42, 0xac, 0x43, 0x36, 0xc0, 0x18, 0x39, 0x8c, 0x0e, 0xc1, 0xb3,
-	0x3b, 0x76, 0xb7, 0x19, 0x68, 0x1b, 0xdf, 0x42, 0x4d, 0x75, 0x66, 0x82, 0x0e, 0xc0, 0xbb, 0xa6,
-	0x03, 0x97, 0x17, 0xf8, 0x19, 0x72, 0x13, 0x96, 0x83, 0xdc, 0xa7, 0xa9, 0x57, 0xeb, 0xd8, 0xdd,
-	0xd6, 0xca, 0x82, 0x6f, 0x38, 0xfa, 0x63, 0x8e, 0xfe, 0x7a, 0xf5, 0x86, 0x35, 0xf7, 0xf0, 0x64,
-	0xc9, 0xfa, 0xf2, 0x63, 0xc9, 0x0e, 0x2e, 0x40, 0xf8, 0x1e, 0x32, 0x4a, 0x79, 0x4e, 0xa7, 0xd6,
-	0x6d, 0xad, 0xcc, 0xfa, 0x46, 0x44, 0xc5, 0x4b, 0x51, 0x0a, 0x4c, 0x54, 0x31, 0x2b, 0x32, 0x90,
-	0x5e, 0xc3, 0x30, 0x53, 0x36, 0xf6, 0xd1, 0x0c, 0x17, 0xaa, 0x70, 0xe6, 0x35, 0x35, 0x78, 0xfe,
-	0xaf, 0xd6, 0xab, 0x6c, 0x14, 0x8c, 0x93, 0xf0, 0x5d, 0xd4, 0xce, 0x78, 0x21, 0x07, 0xb0, 0x03,
-	0x8c, 0xb2, 0x3c, 0xf3, 0x50, 0xa7, 0xd6, 0x6d, 0x06, 0x7f, 0x5e, 0xe2, 0x37, 0x68, 0x16, 0xf6,
-	0x69, 0x5a, 0x68, 0xca, 0xeb, 0x90, 0xd2, 0x91, 0xd7, 0x9a, 0xfe, 0x61, 0x57, 0xb1, 0x78, 0x03,
-	0xb5, 0x3e, 0x14, 0x20, 0x47, 0xdb, 0x51, 0x94, 0x41, 0xee, 0xb5, 0xa7, 0x2f, 0x35, 0x89, 0xc3,
-	0x2f, 0xd0, 0x1d, 0x9a, 0x26, 0x31, 0xeb, 0x5f, 0xd6, 0xef, 0xe7, 0xc9, 0x10, 0xfa, 0x9c, 0xf5,
-	0x2f, 0x06, 0x70, 0xbd, 0x63, 0x77, 0xdd, 0xe0, 0xb6, 0x4e, 0xdc, 0xb8, 0xc8, 0xdb, 0x49, 0x86,
-	0xb0, 0xcd, 0x5e, 0x56, 0x49, 0x5b, 0x8e, 0x5b, 0x9f, 0x6b, 0x6c, 0x39, 0xee, 0xcc, 0x9c, 0xbb,
-	0xe5, 0xb8, 0xee, 0x5c, 0x73, 0xf9, 0x5b, 0x0d, 0xb9, 0x63, 0xbd, 0x95, 0xd0, 0x70, 0x20, 0xe4,
-	0x78, 0x05, 0x94, 0x8d, 0x6f, 0xa2, 0x86, 0x84, 0x01, 0x97, 0xbb, 0xd5, 0xfc, 0x2b, 0x0f, 0xcf,
-	0xa3, 0x3a, 0x4d, 0x41, 0xe6, 0x7a, 0xf2, 0xcd, 0xc0, 0x38, 0xf8, 0x31, 0xaa, 0x45, 0x5c, 0x7a,
-	0xce, 0xf4, 0x2f, 0x55, 0xf9, 0xf8, 0x15, 0x9a, 0xdd, 0x03, 0x10, 0xfd, 0x28, 0x91, 0x09, 0x8b,
-	0xfb, 0xaa, 0xc4, 0x3f, 0x88, 0xd5, 0x56, 0xd8, 0x4d, 0x0d, 0xdd, 0xe4, 0x12, 0x47, 0xa8, 0x91,
-	0xd2, 0x10, 0xd2, 0xcc, 0xab, 0xeb, 0xcd, 0xb8, 0xe1, 0x0f, 0xb8, 0xcc, 0xe1, 0x40, 0x84, 0xfe,
-	0x6b, 0x75, 0xff, 0x96, 0x26, 0x72, 0xed, 0x89, 0x42, 0x7f, 0x3f, 0x59, 0x7a, 0x38, 0xcd, 0xcf,
-	0x31, 0xb8, 0xd5, 0x5d, 0x2a, 0x72, 0x90, 0x41, 0x55, 0x1d, 0x0b, 0xd4, 0xa2, 0x8c, 0xf1, 0x9c,
-	0x9a, 0x35, 0x6c, 0xfc, 0x97, 0x66, 0x93, 0x2d, 0xf4, 0xe0, 0xda, 0x6b, 0x4f, 0x8f, 0x4e, 0x89,
-	0x75, 0x7c, 0x4a, 0xac, 0xf3, 0x53, 0x62, 0x7f, 0x2c, 0x89, 0xfd, 0xb5, 0x24, 0xf6, 0x61, 0x49,
-	0xec, 0xa3, 0x92, 0xd8, 0x3f, 0x4b, 0x62, 0xff, 0x2a, 0x89, 0x75, 0x5e, 0x12, 0xfb, 0xf3, 0x19,
-	0xb1, 0x8e, 0xce, 0x88, 0x75, 0x7c, 0x46, 0xac, 0x77, 0x33, 0xfa, 0x2f, 0x89, 0x30, 0x6c, 0x68,
-	0x29, 0x1f, 0xfd, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x3e, 0xea, 0x89, 0xb2, 0x04, 0x00, 0x00,
+var fileDescriptor_dd3ef3757f506fba = []byte{
+	// 593 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x41, 0x4f, 0xd4, 0x40,
+	0x14, 0xee, 0xb0, 0xdd, 0xa5, 0x3b, 0xeb, 0x06, 0x32, 0x21, 0x58, 0x88, 0x0c, 0x2b, 0xc1, 0x64,
+	0x4f, 0xdd, 0x04, 0xf5, 0xa8, 0x06, 0x02, 0xa8, 0xa8, 0x21, 0x69, 0x38, 0x79, 0x69, 0x66, 0x97,
+	0xb7, 0x4d, 0x43, 0x77, 0x66, 0x9c, 0x4e, 0x09, 0x7b, 0xf3, 0xe2, 0xdd, 0xa3, 0x3f, 0xc1, 0x9f,
+	0xc2, 0xc1, 0x03, 0x47, 0x4e, 0x2a, 0xe5, 0xe2, 0x91, 0x9f, 0x60, 0x66, 0xda, 0x05, 0x84, 0xcb,
+	0x7a, 0xe9, 0xbc, 0xf7, 0xbe, 0xf7, 0xbd, 0xf9, 0xde, 0x9b, 0x97, 0xe2, 0x15, 0x79, 0x14, 0xf7,
+	0x54, 0x9e, 0x82, 0xb2, 0xdf, 0x4c, 0xf6, 0xcb, 0x33, 0x90, 0x4a, 0x68, 0x41, 0xea, 0xd6, 0x59,
+	0x5e, 0x88, 0x45, 0x2c, 0x6c, 0xa4, 0x67, 0xac, 0x12, 0x5c, 0xa6, 0xb1, 0x10, 0x71, 0x0a, 0x3d,
+	0xeb, 0xf5, 0xf3, 0x61, 0xef, 0x30, 0x57, 0x4c, 0x27, 0x82, 0x57, 0xf8, 0xd2, 0x5d, 0x9c, 0xf1,
+	0x71, 0x05, 0x3d, 0x34, 0xd7, 0x8e, 0x92, 0x51, 0xa2, 0x64, 0xbf, 0x3c, 0x2b, 0x60, 0xfd, 0x1e,
+	0x10, 0x0d, 0xf2, 0x4c, 0x8b, 0x51, 0xa4, 0xc7, 0x72, 0x22, 0x6b, 0xed, 0x8b, 0x8b, 0xdb, 0x61,
+	0x9e, 0xc2, 0x6b, 0x25, 0x72, 0xb9, 0x0d, 0xd9, 0x80, 0x10, 0xec, 0x72, 0x36, 0x02, 0x1f, 0x75,
+	0x50, 0xb7, 0x19, 0x5a, 0x9b, 0x3c, 0xc2, 0x4d, 0x73, 0x66, 0x92, 0x0d, 0xc0, 0x9f, 0xb1, 0xc0,
+	0x4d, 0x80, 0xbc, 0xc2, 0x5e, 0xc2, 0x35, 0xa8, 0x63, 0x96, 0xfa, 0xb5, 0x0e, 0xea, 0xb6, 0x36,
+	0x96, 0x82, 0x52, 0x70, 0x30, 0x11, 0x1c, 0x6c, 0x57, 0x0d, 0x6d, 0x79, 0xa7, 0x3f, 0x57, 0x9d,
+	0x6f, 0xbf, 0x56, 0x51, 0x78, 0x4d, 0x22, 0x4f, 0x70, 0x39, 0x1d, 0xdf, 0xed, 0xd4, 0xba, 0xad,
+	0x8d, 0xb9, 0xa0, 0x1c, 0x9c, 0xd1, 0x65, 0x24, 0x85, 0x25, 0x6a, 0x94, 0xe5, 0x19, 0x28, 0xbf,
+	0x51, 0x2a, 0x33, 0x36, 0x09, 0xf0, 0xac, 0x90, 0xa6, 0x70, 0xe6, 0x37, 0x2d, 0x79, 0xe1, 0xde,
+	0xd5, 0x9b, 0x7c, 0x1c, 0x4e, 0x92, 0xc8, 0x3a, 0x6e, 0x67, 0x22, 0x57, 0x03, 0x38, 0x00, 0xce,
+	0xb8, 0xce, 0x7c, 0xdc, 0xa9, 0x75, 0x9b, 0xe1, 0xbf, 0x41, 0xf2, 0x01, 0xcf, 0xc1, 0x31, 0x4b,
+	0x73, 0x2b, 0x79, 0x1b, 0x52, 0x36, 0xf6, 0x5b, 0xd3, 0x37, 0x76, 0x97, 0x4b, 0x76, 0x70, 0xeb,
+	0x53, 0x0e, 0x6a, 0xbc, 0x3f, 0x1c, 0x66, 0xa0, 0xfd, 0xf6, 0xf4, 0xa5, 0x6e, 0xf3, 0xc8, 0x1b,
+	0xfc, 0x98, 0xa5, 0x49, 0xcc, 0xa3, 0x9b, 0xfa, 0x91, 0x4e, 0x46, 0x10, 0x09, 0x1e, 0x5d, 0x3f,
+	0xc0, 0x83, 0x0e, 0xea, 0x7a, 0xe1, 0x8a, 0x4d, 0xdc, 0xb9, 0xce, 0x3b, 0x48, 0x46, 0xb0, 0xcf,
+	0xdf, 0x56, 0x49, 0x7b, 0xae, 0x57, 0x9f, 0x6f, 0xec, 0xb9, 0xde, 0xec, 0xbc, 0xb7, 0xe7, 0x7a,
+	0xde, 0x7c, 0x73, 0xed, 0xc7, 0x0c, 0xf6, 0x26, 0xf3, 0x36, 0x83, 0x86, 0x13, 0xa9, 0x26, 0x2b,
+	0x60, 0x6c, 0xb2, 0x88, 0x1b, 0x0a, 0x06, 0x42, 0x1d, 0x56, 0xef, 0x5f, 0x79, 0x64, 0x01, 0xd7,
+	0x59, 0x0a, 0x4a, 0xdb, 0x97, 0x6f, 0x86, 0xa5, 0x43, 0x9e, 0xe3, 0xda, 0x50, 0x28, 0xdf, 0x9d,
+	0xbe, 0x53, 0x93, 0x4f, 0xde, 0xe1, 0xb9, 0x23, 0x00, 0x19, 0x0d, 0x13, 0x95, 0xf0, 0x38, 0x32,
+	0x25, 0xfe, 0x63, 0x58, 0x6d, 0xc3, 0xdd, 0xb5, 0xd4, 0x5d, 0xa1, 0xc8, 0x33, 0xdc, 0x48, 0x59,
+	0x1f, 0xd2, 0xcc, 0xaf, 0xdb, 0xcd, 0x58, 0x0c, 0x06, 0x42, 0x69, 0x38, 0x91, 0xfd, 0xe0, 0xbd,
+	0x89, 0x6f, 0x1e, 0x32, 0xa9, 0x41, 0x6d, 0xb9, 0xa6, 0x40, 0x58, 0xe5, 0x92, 0x97, 0xb8, 0xc5,
+	0x38, 0x17, 0x9a, 0x95, 0x4b, 0xd5, 0x98, 0x82, 0x7a, 0x9b, 0x60, 0x87, 0xda, 0xde, 0x7a, 0x71,
+	0x76, 0x41, 0x9d, 0xf3, 0x0b, 0xea, 0x5c, 0x5d, 0x50, 0xf4, 0xb9, 0xa0, 0xe8, 0x7b, 0x41, 0xd1,
+	0x69, 0x41, 0xd1, 0x59, 0x41, 0xd1, 0xef, 0x82, 0xa2, 0x3f, 0x05, 0x75, 0xae, 0x0a, 0x8a, 0xbe,
+	0x5e, 0x52, 0xe7, 0xec, 0x92, 0x3a, 0xe7, 0x97, 0xd4, 0xf9, 0x38, 0x5b, 0xfd, 0x38, 0xfa, 0x0d,
+	0xdb, 0xe6, 0xd3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xaf, 0xec, 0x01, 0x54, 0x04, 0x00,
+	0x00,
 }
 
 func (this *RuleGroupDesc) Equal(that interface{}) bool {
@@ -384,7 +397,7 @@ func (this *RuleDesc) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -392,7 +405,7 @@ func (this *RuleDesc) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Annotations {
-		if !this.Annotations[i].Equal(that1.Annotations[i]) {
+		if !this.Annotations[i].Equal(&that1.Annotations[i]) {
 			return false
 		}
 	}
@@ -432,8 +445,20 @@ func (this *RuleDesc) GoString() string {
 	s = append(s, "Alert: "+fmt.Sprintf("%#v", this.Alert)+",\n")
 	s = append(s, "For: "+fmt.Sprintf("%#v", this.For)+",\n")
 	s = append(s, "KeepFiringFor: "+fmt.Sprintf("%#v", this.KeepFiringFor)+",\n")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
-	s = append(s, "Annotations: "+fmt.Sprintf("%#v", this.Annotations)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
+	if this.Annotations != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Annotations))
+		for i := range vs {
+			vs[i] = &this.Annotations[i]
+		}
+		s = append(s, "Annotations: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
@@ -591,11 +616,11 @@ func (m *RuleDesc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Annotations) > 0 {
 		for iNdEx := len(m.Annotations) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Annotations[iNdEx].Size()
-				i -= size
-				if _, err := m.Annotations[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Annotations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintRules(dAtA, i, uint64(size))
 			}
 			i--
@@ -605,11 +630,11 @@ func (m *RuleDesc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintRules(dAtA, i, uint64(size))
 			}
 			i--
@@ -783,13 +808,23 @@ func (this *RuleDesc) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
+	repeatedStringForAnnotations := "[]LabelAdapter{"
+	for _, f := range this.Annotations {
+		repeatedStringForAnnotations += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForAnnotations += "}"
 	s := strings.Join([]string{`&RuleDesc{`,
 		`Expr:` + fmt.Sprintf("%v", this.Expr) + `,`,
 		`Record:` + fmt.Sprintf("%v", this.Record) + `,`,
 		`Alert:` + fmt.Sprintf("%v", this.Alert) + `,`,
 		`For:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.For), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
-		`Annotations:` + fmt.Sprintf("%v", this.Annotations) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
+		`Annotations:` + repeatedStringForAnnotations + `,`,
 		`KeepFiringFor:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.KeepFiringFor), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
 		`}`,
 	}, "")
@@ -1358,7 +1393,7 @@ func (m *RuleDesc) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1392,7 +1427,7 @@ func (m *RuleDesc) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Annotations = append(m.Annotations, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Annotations = append(m.Annotations, mimirpb.LabelAdapter{})
 			if err := m.Annotations[len(m.Annotations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/ruler/rulespb/rules.proto b/pkg/ruler/rulespb/rules.proto
index 0bcdfd05e56..ce59e6df9ac 100644
--- a/pkg/ruler/rulespb/rules.proto
+++ b/pkg/ruler/rulespb/rules.proto
@@ -9,10 +9,11 @@ package rules;
 
 option go_package = "rulespb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+import "gogoproto/gogo.proto";
 import "google/protobuf/duration.proto";
 import "google/protobuf/any.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
@@ -47,12 +48,6 @@ message RuleDesc {
   string alert = 3;
   google.protobuf.Duration for = 4 [(gogoproto.nullable) = false,(gogoproto.stdduration) = true];
   google.protobuf.Duration keep_firing_for = 13 [(gogoproto.nullable) = false,(gogoproto.stdduration) = true];
-  repeated cortexpb.LabelPair labels = 5 [
-    (gogoproto.nullable) = false,
-    (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"
-  ];
-  repeated cortexpb.LabelPair annotations = 6 [
-    (gogoproto.nullable) = false,
-    (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"
-  ];
+  repeated cortexpb.LabelAdapter labels = 5 [(gogoproto.nullable) = false];
+  repeated cortexpb.LabelAdapter annotations = 6 [(gogoproto.nullable) = false];
 }
diff --git a/pkg/scheduler/schedulerpb/scheduler.pb.go b/pkg/scheduler/schedulerpb/scheduler.pb.go
index fb2e838db30..4c0fc65694c 100644
--- a/pkg/scheduler/schedulerpb/scheduler.pb.go
+++ b/pkg/scheduler/schedulerpb/scheduler.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: scheduler.proto
+// source: pkg/scheduler/schedulerpb/scheduler.proto
 
 package schedulerpb
 
@@ -52,7 +52,7 @@ var FrontendToSchedulerType_value = map[string]int32{
 }
 
 func (FrontendToSchedulerType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{0}
+	return fileDescriptor_c3657184e8d38989, []int{0}
 }
 
 type SchedulerToFrontendStatus int32
@@ -79,7 +79,7 @@ var SchedulerToFrontendStatus_value = map[string]int32{
 }
 
 func (SchedulerToFrontendStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{1}
+	return fileDescriptor_c3657184e8d38989, []int{1}
 }
 
 // Querier reports its own clientID when it connects, so that scheduler knows how many *different* queriers are connected.
@@ -91,7 +91,7 @@ type QuerierToScheduler struct {
 func (m *QuerierToScheduler) Reset()      { *m = QuerierToScheduler{} }
 func (*QuerierToScheduler) ProtoMessage() {}
 func (*QuerierToScheduler) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{0}
+	return fileDescriptor_c3657184e8d38989, []int{0}
 }
 func (m *QuerierToScheduler) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -146,7 +146,7 @@ type SchedulerToQuerier struct {
 func (m *SchedulerToQuerier) Reset()      { *m = SchedulerToQuerier{} }
 func (*SchedulerToQuerier) ProtoMessage() {}
 func (*SchedulerToQuerier) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{1}
+	return fileDescriptor_c3657184e8d38989, []int{1}
 }
 func (m *SchedulerToQuerier) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -234,7 +234,7 @@ type FrontendToScheduler struct {
 func (m *FrontendToScheduler) Reset()      { *m = FrontendToScheduler{} }
 func (*FrontendToScheduler) ProtoMessage() {}
 func (*FrontendToScheduler) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{2}
+	return fileDescriptor_c3657184e8d38989, []int{2}
 }
 func (m *FrontendToScheduler) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -320,7 +320,7 @@ type SchedulerToFrontend struct {
 func (m *SchedulerToFrontend) Reset()      { *m = SchedulerToFrontend{} }
 func (*SchedulerToFrontend) ProtoMessage() {}
 func (*SchedulerToFrontend) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{3}
+	return fileDescriptor_c3657184e8d38989, []int{3}
 }
 func (m *SchedulerToFrontend) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -370,7 +370,7 @@ type NotifyQuerierShutdownRequest struct {
 func (m *NotifyQuerierShutdownRequest) Reset()      { *m = NotifyQuerierShutdownRequest{} }
 func (*NotifyQuerierShutdownRequest) ProtoMessage() {}
 func (*NotifyQuerierShutdownRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{4}
+	return fileDescriptor_c3657184e8d38989, []int{4}
 }
 func (m *NotifyQuerierShutdownRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -412,7 +412,7 @@ type NotifyQuerierShutdownResponse struct {
 func (m *NotifyQuerierShutdownResponse) Reset()      { *m = NotifyQuerierShutdownResponse{} }
 func (*NotifyQuerierShutdownResponse) ProtoMessage() {}
 func (*NotifyQuerierShutdownResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2b3fc28395a6d9c5, []int{5}
+	return fileDescriptor_c3657184e8d38989, []int{5}
 }
 func (m *NotifyQuerierShutdownResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -452,54 +452,56 @@ func init() {
 	proto.RegisterType((*NotifyQuerierShutdownResponse)(nil), "schedulerpb.NotifyQuerierShutdownResponse")
 }
 
-func init() { proto.RegisterFile("scheduler.proto", fileDescriptor_2b3fc28395a6d9c5) }
-
-var fileDescriptor_2b3fc28395a6d9c5 = []byte{
-	// 690 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x4f, 0x53, 0xda, 0x40,
-	0x18, 0xc6, 0xb3, 0xfc, 0x53, 0x5e, 0xac, 0xd2, 0x55, 0x5b, 0x64, 0x6c, 0xcc, 0x30, 0x1d, 0x87,
-	0x7a, 0x00, 0x87, 0x1e, 0xda, 0x83, 0xd3, 0x19, 0xaa, 0xb1, 0x32, 0xb5, 0x41, 0x96, 0x30, 0xfd,
-	0x73, 0x61, 0x02, 0x59, 0x21, 0xa3, 0x66, 0x63, 0x36, 0x99, 0x0e, 0xb7, 0x7e, 0x84, 0x7e, 0x8c,
-	0x7e, 0x92, 0x4e, 0x8f, 0x1e, 0x3d, 0xf4, 0x50, 0xe3, 0xa5, 0x47, 0x2f, 0xbd, 0x77, 0x08, 0x81,
-	0x06, 0x0a, 0xea, 0x6d, 0xf7, 0xe5, 0x79, 0xd8, 0x7d, 0x7e, 0xef, 0x9b, 0x85, 0x25, 0xde, 0xee,
-	0x52, 0xdd, 0x3d, 0xa5, 0x76, 0xc1, 0xb2, 0x99, 0xc3, 0x70, 0x6a, 0x54, 0xb0, 0x5a, 0xd9, 0x95,
-	0x0e, 0xeb, 0x30, 0xbf, 0x5e, 0xec, 0xaf, 0x06, 0x92, 0xec, 0x76, 0xc7, 0x70, 0xba, 0x6e, 0xab,
-	0xd0, 0x66, 0x67, 0xc5, 0x8e, 0xad, 0x1d, 0x6b, 0xa6, 0x56, 0xd4, 0xf9, 0x89, 0xe1, 0x14, 0xbb,
-	0x8e, 0x63, 0x75, 0x6c, 0xab, 0x3d, 0x5a, 0x0c, 0x1c, 0xb9, 0x12, 0xe0, 0x9a, 0x4b, 0x6d, 0x83,
-	0xda, 0x2a, 0xab, 0x0f, 0xff, 0x1f, 0xaf, 0x43, 0xf2, 0x7c, 0x50, 0xad, 0xec, 0x65, 0x90, 0x84,
-	0xf2, 0x49, 0xf2, 0xaf, 0x90, 0xfb, 0x83, 0x00, 0x8f, 0xb4, 0x2a, 0x0b, 0xfc, 0x38, 0x03, 0x73,
-	0x7d, 0x4d, 0x2f, 0xb0, 0xc4, 0xc8, 0x70, 0x8b, 0x5f, 0x40, 0xaa, 0x7f, 0x2c, 0xa1, 0xe7, 0x2e,
-	0xe5, 0x4e, 0x26, 0x22, 0xa1, 0x7c, 0xaa, 0xb4, 0x5a, 0x18, 0x5d, 0xe5, 0x40, 0x55, 0x8f, 0x82,
-	0x1f, 0x49, 0x58, 0x89, 0xf3, 0xb0, 0x74, 0x6c, 0x33, 0xd3, 0xa1, 0xa6, 0x5e, 0xd6, 0x75, 0x9b,
-	0x72, 0x9e, 0x89, 0xfa, 0xb7, 0x99, 0x2c, 0xe3, 0x47, 0x90, 0x70, 0xb9, 0x7f, 0xdd, 0x98, 0x2f,
-	0x08, 0x76, 0x38, 0x07, 0x0b, 0xdc, 0xd1, 0x1c, 0x2e, 0x9b, 0x5a, 0xeb, 0x94, 0xea, 0x99, 0xb8,
-	0x84, 0xf2, 0xf3, 0x64, 0xac, 0x86, 0x37, 0x61, 0xf1, 0xdc, 0xa5, 0x2e, 0x55, 0x8d, 0x33, 0xaa,
-	0x68, 0x26, 0xe3, 0x99, 0x84, 0x84, 0xf2, 0x51, 0x32, 0x51, 0xcd, 0x7d, 0x8f, 0xc0, 0xf2, 0x7e,
-	0x70, 0x6e, 0x98, 0xd6, 0x4b, 0x88, 0x39, 0x3d, 0x8b, 0xfa, 0xa9, 0x17, 0x4b, 0x4f, 0x0b, 0xa1,
-	0x3e, 0x15, 0xa6, 0xe8, 0xd5, 0x9e, 0x45, 0x89, 0xef, 0x98, 0x96, 0x2f, 0x32, 0x3d, 0x5f, 0x08,
-	0x6e, 0x74, 0x1c, 0xee, 0xac, 0xe4, 0x13, 0xd0, 0xe3, 0xf7, 0x86, 0x3e, 0x89, 0x2c, 0x31, 0x05,
-	0xd9, 0x0e, 0xac, 0x69, 0xba, 0x6e, 0x38, 0x06, 0x33, 0xb5, 0xd3, 0x5a, 0x1f, 0xd3, 0x9e, 0x71,
-	0x46, 0x4d, 0x6e, 0x30, 0x93, 0x67, 0xe6, 0xa4, 0x68, 0x3e, 0x49, 0x66, 0x0b, 0x72, 0x27, 0xb0,
-	0x1c, 0x9a, 0x9f, 0x21, 0x22, 0xfc, 0x0a, 0x12, 0xfd, 0x43, 0x5c, 0x1e, 0x90, 0xdc, 0x1c, 0x23,
-	0x39, 0xc5, 0x51, 0xf7, 0xd5, 0x24, 0x70, 0xe1, 0x15, 0x88, 0x53, 0xdb, 0x66, 0x76, 0xc0, 0x70,
-	0xb0, 0xc9, 0xed, 0xc0, 0xba, 0xc2, 0x1c, 0xe3, 0xb8, 0x17, 0xcc, 0x69, 0xbd, 0xeb, 0x3a, 0x3a,
-	0xfb, 0x6c, 0x0e, 0xe3, 0xde, 0x3e, 0xeb, 0x1b, 0xf0, 0x64, 0x86, 0x9b, 0x5b, 0xcc, 0xe4, 0x74,
-	0x6b, 0x07, 0x1e, 0xcf, 0xe8, 0x31, 0x9e, 0x87, 0x58, 0x45, 0xa9, 0xa8, 0x69, 0x01, 0xa7, 0x60,
-	0x4e, 0x56, 0x6a, 0x0d, 0xb9, 0x21, 0xa7, 0x11, 0x06, 0x48, 0xec, 0x96, 0x95, 0x5d, 0xf9, 0x30,
-	0x1d, 0xd9, 0x6a, 0xc3, 0xda, 0xcc, 0x5c, 0x38, 0x01, 0x91, 0xea, 0xdb, 0xb4, 0x80, 0x25, 0x58,
-	0x57, 0xab, 0xd5, 0xe6, 0xbb, 0xb2, 0xf2, 0xb1, 0x49, 0xe4, 0x5a, 0x43, 0xae, 0xab, 0xf5, 0xe6,
-	0x91, 0x4c, 0x9a, 0xaa, 0xac, 0x94, 0x15, 0x35, 0x8d, 0x70, 0x12, 0xe2, 0x32, 0x21, 0x55, 0x92,
-	0x8e, 0xe0, 0x87, 0xf0, 0xa0, 0x7e, 0xd0, 0x50, 0xd5, 0x8a, 0xf2, 0xa6, 0xb9, 0x57, 0x7d, 0xaf,
-	0xa4, 0xa3, 0xa5, 0x9f, 0x28, 0xc4, 0x7b, 0x9f, 0xd9, 0xc3, 0x0f, 0xb6, 0x01, 0xa9, 0x60, 0x79,
-	0xc8, 0x98, 0x85, 0x37, 0xc6, 0x70, 0xff, 0xff, 0x2a, 0x64, 0x37, 0x66, 0xf5, 0x23, 0xd0, 0xe6,
-	0x84, 0x3c, 0xda, 0x46, 0xd8, 0x84, 0xd5, 0xa9, 0xc8, 0xf0, 0xb3, 0x31, 0xff, 0x6d, 0x4d, 0xc9,
-	0x6e, 0xdd, 0x47, 0x3a, 0xe8, 0x40, 0xc9, 0x82, 0x95, 0x70, 0xba, 0xd1, 0x38, 0x7d, 0x80, 0x85,
-	0xe1, 0xda, 0xcf, 0x27, 0xdd, 0xf5, 0x61, 0x66, 0xa5, 0xbb, 0x06, 0x6e, 0x90, 0xf0, 0x75, 0xf9,
-	0xe2, 0x4a, 0x14, 0x2e, 0xaf, 0x44, 0xe1, 0xe6, 0x4a, 0x44, 0x5f, 0x3c, 0x11, 0x7d, 0xf3, 0x44,
-	0xf4, 0xc3, 0x13, 0xd1, 0x85, 0x27, 0xa2, 0x5f, 0x9e, 0x88, 0x7e, 0x7b, 0xa2, 0x70, 0xe3, 0x89,
-	0xe8, 0xeb, 0xb5, 0x28, 0x5c, 0x5c, 0x8b, 0xc2, 0xe5, 0xb5, 0x28, 0x7c, 0x0a, 0xbf, 0xdf, 0xad,
-	0x84, 0xff, 0xfc, 0x3e, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x68, 0xe9, 0x45, 0x9c, 0xe6, 0x05,
-	0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/scheduler/schedulerpb/scheduler.proto", fileDescriptor_c3657184e8d38989)
+}
+
+var fileDescriptor_c3657184e8d38989 = []byte{
+	// 699 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0x4d, 0x4f, 0xdb, 0x4c,
+	0x10, 0xc7, 0xbd, 0x79, 0x83, 0x4c, 0x78, 0x78, 0xd2, 0x05, 0xda, 0x10, 0x51, 0x63, 0x45, 0x15,
+	0x0a, 0x1c, 0x12, 0x94, 0x1e, 0xda, 0x03, 0xaa, 0x94, 0x82, 0x29, 0x51, 0xa9, 0x43, 0x36, 0x8e,
+	0xfa, 0x72, 0x89, 0x9c, 0x78, 0x49, 0x2c, 0xc0, 0x6b, 0xbc, 0xb6, 0xaa, 0xdc, 0xfa, 0x11, 0xfa,
+	0x31, 0xfa, 0x49, 0xaa, 0x1e, 0x39, 0x72, 0xe8, 0xa1, 0x98, 0x4b, 0x8f, 0x5c, 0x7a, 0xaf, 0xe2,
+	0x38, 0xc1, 0x49, 0x13, 0xe0, 0x36, 0x3b, 0xfe, 0x8f, 0x77, 0xff, 0xbf, 0x99, 0x5d, 0xd8, 0xb4,
+	0x4e, 0x3a, 0x45, 0xde, 0xee, 0x52, 0xdd, 0x3d, 0xa5, 0xf6, 0x6d, 0x64, 0xb5, 0x6e, 0xe3, 0x82,
+	0x65, 0x33, 0x87, 0xe1, 0x54, 0xe8, 0x63, 0x76, 0xb9, 0xc3, 0x3a, 0xcc, 0xcf, 0x17, 0xfb, 0xd1,
+	0x40, 0x92, 0xdd, 0xee, 0x18, 0x4e, 0xd7, 0x6d, 0x15, 0xda, 0xec, 0xac, 0xd8, 0xb1, 0xb5, 0x63,
+	0xcd, 0xd4, 0x8a, 0x3a, 0x3f, 0x31, 0x9c, 0x62, 0xd7, 0x71, 0xac, 0x8e, 0x6d, 0xb5, 0x47, 0xc1,
+	0xa0, 0x22, 0x57, 0x02, 0x5c, 0x73, 0xa9, 0x6d, 0x50, 0x5b, 0x65, 0xf5, 0xe1, 0xff, 0xf1, 0x1a,
+	0x24, 0xcf, 0x07, 0xd9, 0xca, 0x5e, 0x06, 0x49, 0x28, 0x9f, 0x24, 0xb7, 0x89, 0xdc, 0x1f, 0x04,
+	0x78, 0xa4, 0x55, 0x59, 0x50, 0x8f, 0x33, 0x30, 0xd7, 0xd7, 0xf4, 0x82, 0x92, 0x18, 0x19, 0x2e,
+	0xf1, 0x0b, 0x48, 0xf5, 0xb7, 0x25, 0xf4, 0xdc, 0xa5, 0xdc, 0xc9, 0x44, 0x24, 0x94, 0x4f, 0x95,
+	0x56, 0x0a, 0xa3, 0xa3, 0x1c, 0xa8, 0xea, 0x51, 0xf0, 0x91, 0x84, 0x95, 0x38, 0x0f, 0xff, 0x1f,
+	0xdb, 0xcc, 0x74, 0xa8, 0xa9, 0x97, 0x75, 0xdd, 0xa6, 0x9c, 0x67, 0xa2, 0xfe, 0x69, 0x26, 0xd3,
+	0xf8, 0x31, 0x24, 0x5c, 0xee, 0x1f, 0x37, 0xe6, 0x0b, 0x82, 0x15, 0xce, 0xc1, 0x02, 0x77, 0x34,
+	0x87, 0xcb, 0xa6, 0xd6, 0x3a, 0xa5, 0x7a, 0x26, 0x2e, 0xa1, 0xfc, 0x3c, 0x19, 0xcb, 0xe1, 0x0d,
+	0x58, 0x3c, 0x77, 0xa9, 0x4b, 0x55, 0xe3, 0x8c, 0x2a, 0x9a, 0xc9, 0x78, 0x26, 0x21, 0xa1, 0x7c,
+	0x94, 0x4c, 0x64, 0x73, 0xdf, 0x23, 0xb0, 0xb4, 0x1f, 0xec, 0x1b, 0xa6, 0xf5, 0x12, 0x62, 0x4e,
+	0xcf, 0xa2, 0xbe, 0xeb, 0xc5, 0xd2, 0xb3, 0x42, 0xa8, 0x4f, 0x85, 0x29, 0x7a, 0xb5, 0x67, 0x51,
+	0xe2, 0x57, 0x4c, 0xf3, 0x17, 0x99, 0xee, 0x2f, 0x04, 0x37, 0x3a, 0x0e, 0x77, 0x96, 0xf3, 0x09,
+	0xe8, 0xf1, 0x07, 0x43, 0x9f, 0x44, 0x96, 0x98, 0x82, 0x6c, 0x07, 0x56, 0x35, 0x5d, 0x37, 0x1c,
+	0x83, 0x99, 0xda, 0x69, 0xad, 0x8f, 0x69, 0xcf, 0x38, 0xa3, 0x26, 0x37, 0x98, 0xc9, 0x33, 0x73,
+	0x52, 0x34, 0x9f, 0x24, 0xb3, 0x05, 0xb9, 0x13, 0x58, 0x0a, 0xcd, 0xcf, 0x10, 0x11, 0x7e, 0x05,
+	0x89, 0xfe, 0x26, 0x2e, 0x0f, 0x48, 0x6e, 0x8c, 0x91, 0x9c, 0x52, 0x51, 0xf7, 0xd5, 0x24, 0xa8,
+	0xc2, 0xcb, 0x10, 0xa7, 0xb6, 0xcd, 0xec, 0x80, 0xe1, 0x60, 0x91, 0xdb, 0x81, 0x35, 0x85, 0x39,
+	0xc6, 0x71, 0x2f, 0x98, 0xd3, 0x7a, 0xd7, 0x75, 0x74, 0xf6, 0xd9, 0x1c, 0xda, 0xbd, 0x7b, 0xd6,
+	0xd7, 0xe1, 0xe9, 0x8c, 0x6a, 0x6e, 0x31, 0x93, 0xd3, 0xad, 0x1d, 0x78, 0x32, 0xa3, 0xc7, 0x78,
+	0x1e, 0x62, 0x15, 0xa5, 0xa2, 0xa6, 0x05, 0x9c, 0x82, 0x39, 0x59, 0xa9, 0x35, 0xe4, 0x86, 0x9c,
+	0x46, 0x18, 0x20, 0xb1, 0x5b, 0x56, 0x76, 0xe5, 0xc3, 0x74, 0x64, 0xab, 0x0d, 0xab, 0x33, 0x7d,
+	0xe1, 0x04, 0x44, 0xaa, 0x6f, 0xd3, 0x02, 0x96, 0x60, 0x4d, 0xad, 0x56, 0x9b, 0xef, 0xca, 0xca,
+	0xc7, 0x26, 0x91, 0x6b, 0x0d, 0xb9, 0xae, 0xd6, 0x9b, 0x47, 0x32, 0x69, 0xaa, 0xb2, 0x52, 0x56,
+	0xd4, 0x34, 0xc2, 0x49, 0x88, 0xcb, 0x84, 0x54, 0x49, 0x3a, 0x82, 0x1f, 0xc1, 0x7f, 0xf5, 0x83,
+	0x86, 0xaa, 0x56, 0x94, 0x37, 0xcd, 0xbd, 0xea, 0x7b, 0x25, 0x1d, 0x2d, 0xfd, 0x44, 0x21, 0xde,
+	0xfb, 0xcc, 0x1e, 0x5e, 0xd8, 0x06, 0xa4, 0x82, 0xf0, 0x90, 0x31, 0x0b, 0xaf, 0x8f, 0xe1, 0xfe,
+	0xf7, 0x55, 0xc8, 0xae, 0xcf, 0xea, 0x47, 0xa0, 0xcd, 0x09, 0x79, 0xb4, 0x8d, 0xb0, 0x09, 0x2b,
+	0x53, 0x91, 0xe1, 0xcd, 0xb1, 0xfa, 0xbb, 0x9a, 0x92, 0xdd, 0x7a, 0x88, 0x74, 0xd0, 0x81, 0x92,
+	0x05, 0xcb, 0x61, 0x77, 0xa3, 0x71, 0xfa, 0x00, 0x0b, 0xc3, 0xd8, 0xf7, 0x27, 0xdd, 0x77, 0x31,
+	0xb3, 0xd2, 0x7d, 0x03, 0x37, 0x70, 0xf8, 0xba, 0x7c, 0x71, 0x25, 0x0a, 0x97, 0x57, 0xa2, 0x70,
+	0x73, 0x25, 0xa2, 0x2f, 0x9e, 0x88, 0xbe, 0x79, 0x22, 0xfa, 0xe1, 0x89, 0xe8, 0xc2, 0x13, 0xd1,
+	0x2f, 0x4f, 0x44, 0xbf, 0x3d, 0x51, 0xb8, 0xf1, 0x44, 0xf4, 0xf5, 0x5a, 0x14, 0x2e, 0xae, 0x45,
+	0xe1, 0xf2, 0x5a, 0x14, 0x3e, 0x85, 0xdf, 0xef, 0x56, 0xc2, 0x7f, 0x7e, 0x9f, 0xff, 0x0d, 0x00,
+	0x00, 0xff, 0xff, 0x0e, 0x44, 0xbb, 0xb3, 0x00, 0x06, 0x00, 0x00,
 }
 
 func (x FrontendToSchedulerType) String() string {
@@ -942,7 +944,7 @@ var _SchedulerForQuerier_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 	},
-	Metadata: "scheduler.proto",
+	Metadata: "pkg/scheduler/schedulerpb/scheduler.proto",
 }
 
 // SchedulerForFrontendClient is the client API for SchedulerForFrontend service.
@@ -1058,7 +1060,7 @@ var _SchedulerForFrontend_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 	},
-	Metadata: "scheduler.proto",
+	Metadata: "pkg/scheduler/schedulerpb/scheduler.proto",
 }
 
 func (m *QuerierToScheduler) Marshal() (dAtA []byte, err error) {
diff --git a/pkg/storegateway/hintspb/hints.pb.go b/pkg/storegateway/hintspb/hints.pb.go
index f4eca23af54..9b3e803ab29 100644
--- a/pkg/storegateway/hintspb/hints.pb.go
+++ b/pkg/storegateway/hintspb/hints.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: hints.proto
+// source: pkg/storegateway/hintspb/hints.proto
 
 package hintspb
 
@@ -7,10 +7,10 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	storepb "github.com/grafana/mimir/pkg/storegateway/storepb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	storepb "pkg/storegateway/storepb"
 	reflect "reflect"
 	strings "strings"
 )
@@ -36,7 +36,7 @@ type SeriesRequestHints struct {
 func (m *SeriesRequestHints) Reset()      { *m = SeriesRequestHints{} }
 func (*SeriesRequestHints) ProtoMessage() {}
 func (*SeriesRequestHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{0}
+	return fileDescriptor_1e01189b3b04d593, []int{0}
 }
 func (m *SeriesRequestHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -73,7 +73,7 @@ type SeriesResponseHints struct {
 func (m *SeriesResponseHints) Reset()      { *m = SeriesResponseHints{} }
 func (*SeriesResponseHints) ProtoMessage() {}
 func (*SeriesResponseHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{1}
+	return fileDescriptor_1e01189b3b04d593, []int{1}
 }
 func (m *SeriesResponseHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -109,7 +109,7 @@ type Block struct {
 func (m *Block) Reset()      { *m = Block{} }
 func (*Block) ProtoMessage() {}
 func (*Block) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{2}
+	return fileDescriptor_1e01189b3b04d593, []int{2}
 }
 func (m *Block) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -148,7 +148,7 @@ type LabelNamesRequestHints struct {
 func (m *LabelNamesRequestHints) Reset()      { *m = LabelNamesRequestHints{} }
 func (*LabelNamesRequestHints) ProtoMessage() {}
 func (*LabelNamesRequestHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{3}
+	return fileDescriptor_1e01189b3b04d593, []int{3}
 }
 func (m *LabelNamesRequestHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -185,7 +185,7 @@ type LabelNamesResponseHints struct {
 func (m *LabelNamesResponseHints) Reset()      { *m = LabelNamesResponseHints{} }
 func (*LabelNamesResponseHints) ProtoMessage() {}
 func (*LabelNamesResponseHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{4}
+	return fileDescriptor_1e01189b3b04d593, []int{4}
 }
 func (m *LabelNamesResponseHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -224,7 +224,7 @@ type LabelValuesRequestHints struct {
 func (m *LabelValuesRequestHints) Reset()      { *m = LabelValuesRequestHints{} }
 func (*LabelValuesRequestHints) ProtoMessage() {}
 func (*LabelValuesRequestHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{5}
+	return fileDescriptor_1e01189b3b04d593, []int{5}
 }
 func (m *LabelValuesRequestHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -261,7 +261,7 @@ type LabelValuesResponseHints struct {
 func (m *LabelValuesResponseHints) Reset()      { *m = LabelValuesResponseHints{} }
 func (*LabelValuesResponseHints) ProtoMessage() {}
 func (*LabelValuesResponseHints) Descriptor() ([]byte, []int) {
-	return fileDescriptor_522be8e0d2634375, []int{6}
+	return fileDescriptor_1e01189b3b04d593, []int{6}
 }
 func (m *LabelValuesResponseHints) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -300,33 +300,33 @@ func init() {
 	proto.RegisterType((*LabelValuesResponseHints)(nil), "hintspb.LabelValuesResponseHints")
 }
 
-func init() { proto.RegisterFile("hints.proto", fileDescriptor_522be8e0d2634375) }
-
-var fileDescriptor_522be8e0d2634375 = []byte{
-	// 358 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0xb1, 0x4e, 0xfb, 0x30,
-	0x10, 0xc6, 0xed, 0xfe, 0xff, 0x80, 0x70, 0x45, 0x86, 0x80, 0x68, 0xd5, 0xe1, 0xa8, 0x32, 0x75,
-	0x21, 0x91, 0x60, 0x44, 0x0c, 0xed, 0xc4, 0x00, 0x0c, 0x41, 0x6a, 0x25, 0x40, 0xaa, 0x9c, 0xd6,
-	0x4d, 0xa2, 0x36, 0x71, 0x1a, 0x3b, 0x42, 0xdd, 0x78, 0x04, 0x1e, 0x83, 0x47, 0xe9, 0xd8, 0xb1,
-	0x13, 0x22, 0xe9, 0xc2, 0xd8, 0x47, 0x40, 0x75, 0x12, 0xa9, 0xec, 0xd9, 0xfc, 0x7d, 0x77, 0xf7,
-	0xf3, 0x77, 0xd2, 0x91, 0xba, 0xe7, 0x87, 0x52, 0x98, 0x51, 0xcc, 0x25, 0xd7, 0x8f, 0x94, 0x88,
-	0x9c, 0xd6, 0xa5, 0xeb, 0x4b, 0x2f, 0x71, 0xcc, 0x11, 0x0f, 0x2c, 0x97, 0xbb, 0xdc, 0x52, 0x75,
-	0x27, 0x99, 0x28, 0xa5, 0x84, 0x7a, 0xe5, 0x73, 0xad, 0xdb, 0xfd, 0xf6, 0x98, 0x4e, 0x68, 0x48,
-	0xad, 0xc0, 0x0f, 0xfc, 0xd8, 0x8a, 0xa6, 0xae, 0x25, 0x24, 0x8f, 0x99, 0x4b, 0x25, 0x7b, 0xa3,
-	0x8b, 0x5c, 0x44, 0x8e, 0x25, 0x17, 0x11, 0x2b, 0xbe, 0x35, 0x06, 0x44, 0x7f, 0x62, 0xb1, 0xcf,
-	0x84, 0xcd, 0xe6, 0x09, 0x13, 0xf2, 0x6e, 0x97, 0x42, 0xef, 0x12, 0xcd, 0x99, 0xf1, 0xd1, 0x74,
-	0x18, 0x50, 0x39, 0xf2, 0x58, 0x2c, 0x9a, 0xb8, 0xfd, 0xaf, 0x53, 0xbf, 0x3a, 0x33, 0xa5, 0x47,
-	0x43, 0x2e, 0xcc, 0x7b, 0xea, 0xb0, 0xd9, 0x43, 0x5e, 0xec, 0xfd, 0x5f, 0x7e, 0x5d, 0x20, 0xfb,
-	0x44, 0x4d, 0x14, 0x9e, 0x30, 0x6c, 0x72, 0x5a, 0x82, 0x45, 0xc4, 0x43, 0xc1, 0x72, 0xf2, 0x0d,
-	0xd1, 0xe6, 0xc9, 0xce, 0x1f, 0x0f, 0x55, 0x7f, 0x49, 0xd6, 0xcc, 0x62, 0x7f, 0xb3, 0xb7, 0xb3,
-	0x4b, 0x66, 0xd1, 0xab, 0x3c, 0x61, 0x34, 0xc8, 0x81, 0x7a, 0xe9, 0x1a, 0xa9, 0xf9, 0xe3, 0x26,
-	0x6e, 0xe3, 0xce, 0xb1, 0x5d, 0xf3, 0xc7, 0xc6, 0x0b, 0x39, 0x57, 0x89, 0x1e, 0x69, 0x50, 0xfd,
-	0x26, 0x7d, 0xd2, 0xd8, 0x87, 0x57, 0xb6, 0xcd, 0x6b, 0xc1, 0xed, 0xd3, 0x59, 0x52, 0x7d, 0xea,
-	0x01, 0x69, 0xfe, 0xa1, 0x57, 0x15, 0xbb, 0xd7, 0x5d, 0xa6, 0x80, 0x56, 0x29, 0xa0, 0x75, 0x0a,
-	0x68, 0x9b, 0x02, 0x7e, 0xcf, 0x00, 0x7f, 0x66, 0x80, 0x97, 0x19, 0xe0, 0x55, 0x06, 0xf8, 0x3b,
-	0x03, 0xfc, 0x93, 0x01, 0xda, 0x66, 0x80, 0x3f, 0x36, 0x80, 0x56, 0x1b, 0x40, 0xeb, 0x0d, 0xa0,
-	0xe7, 0xf2, 0xc4, 0x9d, 0x43, 0x75, 0x7b, 0xd7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x13,
-	0x56, 0x30, 0x01, 0x03, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/storegateway/hintspb/hints.proto", fileDescriptor_1e01189b3b04d593)
+}
+
+var fileDescriptor_1e01189b3b04d593 = []byte{
+	// 334 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0xbd, 0x4e, 0xc3, 0x30,
+	0x10, 0xc7, 0xed, 0xf2, 0x25, 0x8c, 0xc8, 0x10, 0x2a, 0x5a, 0x75, 0x38, 0xaa, 0x88, 0xa1, 0x53,
+	0x22, 0xc1, 0xc8, 0xd4, 0x4e, 0x0c, 0xc0, 0x10, 0xa4, 0x56, 0x02, 0xa4, 0xca, 0x69, 0xad, 0x34,
+	0xea, 0x87, 0xd3, 0xd8, 0x15, 0xea, 0xc6, 0x23, 0xf0, 0x18, 0x3c, 0x4a, 0xc7, 0x8e, 0x9d, 0x10,
+	0x71, 0x17, 0xc6, 0x3e, 0x02, 0x8a, 0xe3, 0x48, 0x20, 0xd6, 0x4c, 0xb9, 0xfc, 0xee, 0xfc, 0xd3,
+	0xfd, 0xa5, 0x23, 0x97, 0xf1, 0x38, 0xf4, 0x84, 0xe4, 0x09, 0x0b, 0xa9, 0x64, 0xaf, 0x74, 0xe9,
+	0x8d, 0xa2, 0x99, 0x14, 0x71, 0x90, 0x7f, 0xdd, 0x38, 0xe1, 0x92, 0xdb, 0x47, 0x06, 0x36, 0xaa,
+	0x21, 0x0f, 0xb9, 0x66, 0x5e, 0x56, 0xe5, 0xed, 0xc6, 0x7f, 0x89, 0xfe, 0x89, 0x03, 0x4f, 0x2e,
+	0x63, 0x66, 0x24, 0x4e, 0x8f, 0xd8, 0x8f, 0x2c, 0x89, 0x98, 0xf0, 0xd9, 0x7c, 0xc1, 0x84, 0xbc,
+	0xcd, 0x9c, 0x76, 0x9b, 0x58, 0xc1, 0x84, 0x0f, 0xc6, 0xfd, 0x29, 0x95, 0x83, 0x11, 0x4b, 0x44,
+	0x1d, 0x37, 0xf7, 0x5a, 0x27, 0x57, 0x55, 0x57, 0x8e, 0xe8, 0x8c, 0x0b, 0xf7, 0x8e, 0x06, 0x6c,
+	0x72, 0x9f, 0x37, 0x3b, 0xfb, 0xab, 0xcf, 0x0b, 0xe4, 0x9f, 0xea, 0x17, 0x86, 0x09, 0xc7, 0x27,
+	0x67, 0x85, 0x58, 0xc4, 0x7c, 0x26, 0x58, 0x6e, 0xbe, 0x21, 0xd6, 0x7c, 0x91, 0xf1, 0x61, 0x5f,
+	0xcf, 0x17, 0x66, 0xcb, 0x35, 0x69, 0xdc, 0x4e, 0x86, 0x0b, 0xa7, 0x99, 0xd5, 0x4c, 0x38, 0x35,
+	0x72, 0xa0, 0x2b, 0xdb, 0x22, 0x95, 0x68, 0x58, 0xc7, 0x4d, 0xdc, 0x3a, 0xf6, 0x2b, 0xd1, 0xd0,
+	0x79, 0x26, 0xe7, 0x7a, 0xa3, 0x07, 0x3a, 0x2d, 0x3f, 0x49, 0x97, 0xd4, 0x7e, 0xcb, 0x4b, 0x4b,
+	0xf3, 0x62, 0xbc, 0x5d, 0x3a, 0x59, 0x94, 0xbf, 0x75, 0x8f, 0xd4, 0xff, 0xd8, 0xcb, 0x5a, 0xbb,
+	0xd3, 0x5e, 0xa5, 0x80, 0xd6, 0x29, 0xa0, 0x4d, 0x0a, 0x68, 0x97, 0x02, 0x7e, 0x53, 0x80, 0x3f,
+	0x14, 0xe0, 0x95, 0x02, 0xbc, 0x56, 0x80, 0xbf, 0x14, 0xe0, 0x6f, 0x05, 0x68, 0xa7, 0x00, 0xbf,
+	0x6f, 0x01, 0xad, 0xb7, 0x80, 0x36, 0x5b, 0x40, 0x4f, 0xc5, 0xc1, 0x06, 0x87, 0xfa, 0xf6, 0xae,
+	0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xda, 0x2c, 0x82, 0x96, 0xe8, 0x02, 0x00, 0x00,
 }
 
 func (this *SeriesRequestHints) Equal(that interface{}) bool {
diff --git a/pkg/storegateway/hintspb/hints.proto b/pkg/storegateway/hintspb/hints.proto
index 032b5f5a373..00f6a353900 100644
--- a/pkg/storegateway/hintspb/hints.proto
+++ b/pkg/storegateway/hintspb/hints.proto
@@ -6,8 +6,8 @@
 syntax = "proto3";
 package hintspb;
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/storegateway/storepb/types.proto";
+import "gogoproto/gogo.proto";
+import "pkg/storegateway/storepb/types.proto";
 
 option go_package = "hintspb";
 
diff --git a/pkg/storegateway/indexheader/indexheaderpb/sparse.pb.go b/pkg/storegateway/indexheader/indexheaderpb/sparse.pb.go
index 4e96f6aeba7..3fcb1c17756 100644
--- a/pkg/storegateway/indexheader/indexheaderpb/sparse.pb.go
+++ b/pkg/storegateway/indexheader/indexheaderpb/sparse.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: sparse.proto
+// source: pkg/storegateway/indexheader/indexheaderpb/sparse.proto
 
 package indexheaderpb
 
@@ -34,7 +34,7 @@ type Sparse struct {
 func (m *Sparse) Reset()      { *m = Sparse{} }
 func (*Sparse) ProtoMessage() {}
 func (*Sparse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c442573753a956c7, []int{0}
+	return fileDescriptor_b9cb09fcd4698826, []int{0}
 }
 func (m *Sparse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -85,7 +85,7 @@ type Symbols struct {
 func (m *Symbols) Reset()      { *m = Symbols{} }
 func (*Symbols) ProtoMessage() {}
 func (*Symbols) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c442573753a956c7, []int{1}
+	return fileDescriptor_b9cb09fcd4698826, []int{1}
 }
 func (m *Symbols) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -136,7 +136,7 @@ type PostingOffsetTable struct {
 func (m *PostingOffsetTable) Reset()      { *m = PostingOffsetTable{} }
 func (*PostingOffsetTable) ProtoMessage() {}
 func (*PostingOffsetTable) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c442573753a956c7, []int{2}
+	return fileDescriptor_b9cb09fcd4698826, []int{2}
 }
 func (m *PostingOffsetTable) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -182,7 +182,7 @@ type PostingValueOffsets struct {
 func (m *PostingValueOffsets) Reset()      { *m = PostingValueOffsets{} }
 func (*PostingValueOffsets) ProtoMessage() {}
 func (*PostingValueOffsets) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c442573753a956c7, []int{3}
+	return fileDescriptor_b9cb09fcd4698826, []int{3}
 }
 func (m *PostingValueOffsets) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -234,7 +234,7 @@ type PostingOffset struct {
 func (m *PostingOffset) Reset()      { *m = PostingOffset{} }
 func (*PostingOffset) ProtoMessage() {}
 func (*PostingOffset) Descriptor() ([]byte, []int) {
-	return fileDescriptor_c442573753a956c7, []int{4}
+	return fileDescriptor_b9cb09fcd4698826, []int{4}
 }
 func (m *PostingOffset) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -286,36 +286,38 @@ func init() {
 	proto.RegisterType((*PostingOffset)(nil), "indexheaderpb.PostingOffset")
 }
 
-func init() { proto.RegisterFile("sparse.proto", fileDescriptor_c442573753a956c7) }
+func init() {
+	proto.RegisterFile("pkg/storegateway/indexheader/indexheaderpb/sparse.proto", fileDescriptor_b9cb09fcd4698826)
+}
 
-var fileDescriptor_c442573753a956c7 = []byte{
-	// 402 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x3f, 0x4f, 0xf2, 0x40,
-	0x18, 0xef, 0xd1, 0xbc, 0xc0, 0x7b, 0x40, 0x42, 0x0e, 0x63, 0x08, 0x21, 0x17, 0x6d, 0x1c, 0x58,
-	0x2c, 0x06, 0x13, 0x43, 0xdc, 0x84, 0x38, 0x31, 0x60, 0x8a, 0x61, 0x70, 0x31, 0xad, 0xb4, 0x85,
-	0x58, 0x7a, 0x4d, 0xef, 0x6a, 0x64, 0xf3, 0x1b, 0xe8, 0xc7, 0xf0, 0x73, 0x38, 0x39, 0x32, 0x32,
-	0x4a, 0x59, 0x1c, 0xf9, 0x08, 0xa6, 0x77, 0x2d, 0x5a, 0x25, 0xba, 0xdd, 0xf3, 0x3c, 0xbf, 0x3f,
-	0xcf, 0xf3, 0xcb, 0xc1, 0x22, 0xf5, 0x74, 0x9f, 0x9a, 0xaa, 0xe7, 0x13, 0x46, 0x50, 0x69, 0xe2,
-	0x8e, 0xcc, 0xfb, 0xb1, 0xa9, 0x8f, 0x4c, 0xdf, 0x33, 0x6a, 0x87, 0xf6, 0x84, 0x8d, 0x03, 0x43,
-	0xbd, 0x21, 0xd3, 0xa6, 0x4d, 0x6c, 0xd2, 0xe4, 0x28, 0x23, 0xb0, 0x78, 0xc5, 0x0b, 0xfe, 0x12,
-	0x6c, 0xe5, 0x11, 0xc0, 0xec, 0x80, 0xcb, 0xa1, 0x23, 0x98, 0xa3, 0xb3, 0xa9, 0x41, 0x1c, 0x5a,
-	0x05, 0x7b, 0xa0, 0x51, 0x68, 0xed, 0xaa, 0x29, 0x69, 0x75, 0x20, 0xa6, 0x5a, 0x02, 0x43, 0x03,
-	0x58, 0xf1, 0x08, 0x65, 0x13, 0xd7, 0xa6, 0x7d, 0xcb, 0xa2, 0x26, 0xbb, 0xd4, 0x0d, 0xc7, 0xac,
-	0x66, 0x38, 0x7b, 0xff, 0x1b, 0xfb, 0x42, 0x20, 0xbf, 0x00, 0xb5, 0x6d, 0x6c, 0xa5, 0x07, 0x73,
-	0xb1, 0x11, 0xaa, 0xc3, 0x1c, 0xe1, 0x93, 0x68, 0x23, 0xb9, 0x21, 0x77, 0x32, 0x65, 0xa0, 0x25,
-	0x2d, 0xa4, 0xc0, 0x62, 0xbc, 0x48, 0x97, 0x04, 0x2e, 0xe3, 0xb6, 0xb2, 0x96, 0xea, 0x29, 0x2f,
-	0x00, 0xa2, 0x9f, 0xc6, 0xa8, 0x07, 0xf3, 0x89, 0x35, 0x57, 0x2e, 0xb4, 0x9a, 0x7f, 0x6e, 0x9b,
-	0xb4, 0xe8, 0xb9, 0xcb, 0xfc, 0x99, 0xb6, 0x11, 0xa8, 0x5d, 0xc3, 0x52, 0x6a, 0x84, 0xca, 0x50,
-	0xbe, 0x35, 0x67, 0x3c, 0xc4, 0xff, 0x5a, 0xf4, 0x44, 0x6d, 0xf8, 0xef, 0x4e, 0x77, 0x82, 0x24,
-	0x1a, 0x65, 0xbb, 0xd9, 0x30, 0x82, 0x08, 0x47, 0xaa, 0x09, 0xc2, 0x69, 0xa6, 0x0d, 0x14, 0x0a,
-	0x2b, 0x5b, 0x10, 0xe8, 0x24, 0x9d, 0x4e, 0xa1, 0x55, 0xff, 0xed, 0x86, 0xcf, 0xdc, 0x0e, 0x60,
-	0xc9, 0xd1, 0x29, 0x1b, 0xea, 0x8e, 0x98, 0xc4, 0xc1, 0xa5, 0x9b, 0xca, 0xd9, 0xe6, 0x2a, 0xd1,
-	0x40, 0x3b, 0xc9, 0x0d, 0xe2, 0x2e, 0x51, 0xa0, 0x1a, 0xcc, 0xb3, 0x28, 0x9d, 0xbe, 0x65, 0xc5,
-	0x3a, 0x9b, 0xba, 0xd3, 0x9d, 0x2f, 0xb1, 0xb4, 0x58, 0x62, 0x69, 0xbd, 0xc4, 0xe0, 0x21, 0xc4,
-	0xe0, 0x39, 0xc4, 0xe0, 0x35, 0xc4, 0x60, 0x1e, 0x62, 0xf0, 0x16, 0x62, 0xf0, 0x1e, 0x62, 0x69,
-	0x1d, 0x62, 0xf0, 0xb4, 0xc2, 0xd2, 0x7c, 0x85, 0xa5, 0xc5, 0x0a, 0x4b, 0x57, 0xe9, 0xff, 0x6c,
-	0x64, 0xf9, 0x3f, 0x3d, 0xfe, 0x08, 0x00, 0x00, 0xff, 0xff, 0x81, 0x2f, 0x9e, 0xda, 0xf5, 0x02,
-	0x00, 0x00,
+var fileDescriptor_b9cb09fcd4698826 = []byte{
+	// 409 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x31, 0x6f, 0xda, 0x40,
+	0x14, 0xf6, 0x61, 0x15, 0xe8, 0x51, 0x24, 0x74, 0xa0, 0x0a, 0x21, 0x74, 0x6a, 0xad, 0x0e, 0x4c,
+	0xb8, 0xa2, 0x52, 0x8b, 0xba, 0x15, 0xd4, 0x89, 0x81, 0xca, 0x54, 0x0c, 0x5d, 0xaa, 0xb3, 0x38,
+	0x3b, 0x08, 0xc7, 0x67, 0xf9, 0x8e, 0x24, 0xde, 0xf2, 0x0f, 0x92, 0x9f, 0x91, 0xdf, 0x91, 0x29,
+	0x23, 0x23, 0x63, 0x30, 0x4b, 0x46, 0x7e, 0x42, 0xe4, 0x3b, 0x9b, 0xe0, 0x04, 0x25, 0xdb, 0xbb,
+	0xf7, 0x7d, 0xdf, 0xfb, 0xde, 0xfb, 0x74, 0xf0, 0x47, 0xb0, 0x70, 0x4d, 0x2e, 0x58, 0x48, 0x5d,
+	0x22, 0xe8, 0x39, 0x89, 0xcc, 0xb9, 0x3f, 0xa3, 0x17, 0x27, 0x94, 0xcc, 0x68, 0x78, 0x58, 0x07,
+	0xb6, 0xc9, 0x03, 0x12, 0x72, 0xda, 0x0d, 0x42, 0x26, 0x18, 0xaa, 0xe6, 0xb0, 0x56, 0xc3, 0x65,
+	0x2e, 0x93, 0x88, 0x99, 0x54, 0x8a, 0x64, 0x5c, 0x01, 0x58, 0x9c, 0x48, 0x15, 0xfa, 0x0a, 0x4b,
+	0x3c, 0x3a, 0xb5, 0x99, 0xc7, 0x9b, 0xe0, 0x13, 0xe8, 0x54, 0x7a, 0x1f, 0xbb, 0xb9, 0x09, 0xdd,
+	0x89, 0x42, 0xad, 0x8c, 0x86, 0x26, 0xb0, 0x1e, 0x30, 0x2e, 0xe6, 0xbe, 0xcb, 0xc7, 0x8e, 0xc3,
+	0xa9, 0xf8, 0x4b, 0x6c, 0x8f, 0x36, 0x0b, 0x52, 0xfd, 0xf9, 0x99, 0xfa, 0x8f, 0x62, 0x1e, 0x10,
+	0xad, 0x63, 0x6a, 0x63, 0x04, 0x4b, 0xa9, 0x11, 0x6a, 0xc3, 0x12, 0x93, 0x48, 0xb2, 0x91, 0xde,
+	0xd1, 0x07, 0x85, 0x1a, 0xb0, 0xb2, 0x16, 0x32, 0xe0, 0x87, 0x74, 0x91, 0x21, 0x5b, 0xfa, 0x42,
+	0xda, 0xea, 0x56, 0xae, 0x67, 0xdc, 0x02, 0x88, 0x5e, 0x1a, 0xa3, 0x11, 0x2c, 0x67, 0xd6, 0x72,
+	0x72, 0xa5, 0x67, 0xbe, 0xb9, 0x6d, 0xd6, 0xe2, 0xbf, 0x7d, 0x11, 0x46, 0xd6, 0x7e, 0x40, 0xeb,
+	0x3f, 0xac, 0xe6, 0x20, 0x54, 0x83, 0xfa, 0x82, 0x46, 0x32, 0xc4, 0xf7, 0x56, 0x52, 0xa2, 0x3e,
+	0x7c, 0x77, 0x46, 0xbc, 0x65, 0x16, 0x8d, 0x71, 0xdc, 0x6c, 0x9a, 0x50, 0x94, 0x23, 0xb7, 0x94,
+	0xe0, 0x67, 0xa1, 0x0f, 0x0c, 0x0e, 0xeb, 0x47, 0x18, 0xe8, 0x7b, 0x3e, 0x9d, 0x4a, 0xaf, 0xfd,
+	0xda, 0x0d, 0x4f, 0xb9, 0x7d, 0x81, 0x55, 0x8f, 0x70, 0x31, 0x25, 0x9e, 0x42, 0xd2, 0xe0, 0xf2,
+	0x4d, 0xe3, 0xd7, 0xfe, 0x2a, 0xd5, 0x40, 0x8d, 0xec, 0x06, 0x75, 0x97, 0x7a, 0xa0, 0x16, 0x2c,
+	0x8b, 0x24, 0x9d, 0xb1, 0xe3, 0xa4, 0x73, 0xf6, 0xef, 0xc1, 0x70, 0xb5, 0xc1, 0xda, 0x7a, 0x83,
+	0xb5, 0xdd, 0x06, 0x83, 0xcb, 0x18, 0x83, 0x9b, 0x18, 0x83, 0xbb, 0x18, 0x83, 0x55, 0x8c, 0xc1,
+	0x7d, 0x8c, 0xc1, 0x43, 0x8c, 0xb5, 0x5d, 0x8c, 0xc1, 0xf5, 0x16, 0x6b, 0xab, 0x2d, 0xd6, 0xd6,
+	0x5b, 0xac, 0xfd, 0xcb, 0x7f, 0x5b, 0xbb, 0x28, 0xff, 0xe9, 0xb7, 0xc7, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x81, 0x04, 0x1d, 0xbe, 0x07, 0x03, 0x00, 0x00,
 }
 
 func (this *Sparse) Equal(that interface{}) bool {
diff --git a/pkg/storegateway/indexheader/indexheaderpb/sparse.proto b/pkg/storegateway/indexheader/indexheaderpb/sparse.proto
index c20c45f1ebd..14be0f7bdef 100644
--- a/pkg/storegateway/indexheader/indexheaderpb/sparse.proto
+++ b/pkg/storegateway/indexheader/indexheaderpb/sparse.proto
@@ -6,8 +6,7 @@ package indexheaderpb;
 
 option go_package = "indexheaderpb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-
+import "gogoproto/gogo.proto";
 // Do not generate XXX fields to reduce memory footprint.
 option (gogoproto.goproto_unkeyed_all) = false;
 option (gogoproto.goproto_unrecognized_all) = false;
diff --git a/pkg/storegateway/storegatewaypb/gateway.pb.go b/pkg/storegateway/storegatewaypb/gateway.pb.go
index 0bb5696eb92..f23dddd738c 100644
--- a/pkg/storegateway/storegatewaypb/gateway.pb.go
+++ b/pkg/storegateway/storegatewaypb/gateway.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: gateway.proto
+// source: pkg/storegateway/storegatewaypb/gateway.proto
 
 package storegatewaypb
 
@@ -7,11 +7,11 @@ import (
 	context "context"
 	fmt "fmt"
 	proto "github.com/gogo/protobuf/proto"
-	storepb "github.com/grafana/mimir/pkg/storegateway/storepb"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
 	math "math"
+	storepb "pkg/storegateway/storepb"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -25,27 +25,28 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
-
-var fileDescriptor_f1a937782ebbded5 = []byte{
-	// 263 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xbd, 0x4a, 0x04, 0x31,
-	0x14, 0x46, 0x93, 0x66, 0xc1, 0xf8, 0x53, 0x04, 0x14, 0x5c, 0xe1, 0x3e, 0xc2, 0x44, 0xb4, 0x12,
-	0x3b, 0x15, 0x6d, 0xc4, 0xc2, 0x05, 0x0b, 0xbb, 0x9b, 0xe5, 0x3a, 0x3b, 0xb8, 0x33, 0x89, 0x49,
-	0x06, 0xb1, 0xf3, 0x11, 0x7c, 0x0c, 0x1f, 0xc5, 0x72, 0x2a, 0xd9, 0xd2, 0xc9, 0x34, 0x96, 0xfb,
-	0x08, 0xe2, 0x66, 0x07, 0x7f, 0xd8, 0xf2, 0x3b, 0xf7, 0x70, 0x8a, 0x2b, 0x36, 0x73, 0x0c, 0xf4,
-	0x88, 0x4f, 0x99, 0x75, 0x26, 0x18, 0xb9, 0xb6, 0x9c, 0x56, 0x0f, 0x8f, 0xf3, 0x22, 0x4c, 0x6a,
-	0x9d, 0x8d, 0x4d, 0xa9, 0x72, 0x87, 0x77, 0x58, 0xa1, 0x2a, 0x8b, 0xb2, 0x70, 0xca, 0xde, 0xe7,
-	0xca, 0x07, 0xe3, 0x68, 0x29, 0xa7, 0x61, 0xb5, 0x72, 0x76, 0x9c, 0x3a, 0x07, 0xef, 0x5c, 0x6c,
-	0x8c, 0xbe, 0xe9, 0x45, 0x52, 0xe4, 0x91, 0x18, 0x8c, 0xc8, 0x15, 0xe4, 0xe5, 0x76, 0x16, 0x26,
-	0x58, 0x19, 0x9f, 0xa5, 0x7d, 0x4d, 0x0f, 0x35, 0xf9, 0x30, 0xdc, 0xf9, 0x8f, 0xbd, 0x35, 0x95,
-	0xa7, 0x7d, 0x2e, 0x4f, 0x85, 0xb8, 0x44, 0x4d, 0xd3, 0x2b, 0x2c, 0xc9, 0xcb, 0xdd, 0xde, 0xfb,
-	0x61, 0x7d, 0x62, 0xb8, 0xea, 0x94, 0x32, 0xf2, 0x5c, 0xac, 0x2f, 0xe8, 0x0d, 0x4e, 0x6b, 0xf2,
-	0xf2, 0xaf, 0x9a, 0x60, 0x9f, 0xd9, 0x5b, 0x79, 0x4b, 0x9d, 0x93, 0xb3, 0xa6, 0x05, 0x36, 0x6b,
-	0x81, 0xcd, 0x5b, 0xe0, 0xcf, 0x11, 0xf8, 0x6b, 0x04, 0xfe, 0x16, 0x81, 0x37, 0x11, 0xf8, 0x47,
-	0x04, 0xfe, 0x19, 0x81, 0xcd, 0x23, 0xf0, 0x97, 0x0e, 0x58, 0xd3, 0x01, 0x9b, 0x75, 0xc0, 0x6e,
-	0xb7, 0x7e, 0xbf, 0xcb, 0x6a, 0x3d, 0x58, 0x7c, 0xe9, 0xf0, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xb9,
-	0xbe, 0x15, 0x37, 0x7e, 0x01, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/storegateway/storegatewaypb/gateway.proto", fileDescriptor_3b0b40cab91a425a)
+}
+
+var fileDescriptor_3b0b40cab91a425a = []byte{
+	// 241 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2d, 0xc8, 0x4e, 0xd7,
+	0x2f, 0x2e, 0xc9, 0x2f, 0x4a, 0x4d, 0x4f, 0x2c, 0x49, 0x2d, 0x4f, 0xac, 0x44, 0xe1, 0x14, 0x24,
+	0xe9, 0x43, 0x59, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x9c, 0x70, 0x09, 0x29, 0x25, 0xec,
+	0x3a, 0x0b, 0x92, 0xf4, 0x8b, 0x0a, 0x92, 0x21, 0xca, 0x8d, 0xae, 0x31, 0x72, 0xf1, 0x04, 0x83,
+	0x44, 0xdd, 0x21, 0x4a, 0x84, 0x2c, 0xb9, 0xd8, 0x82, 0x53, 0x8b, 0x32, 0x53, 0x8b, 0x85, 0x44,
+	0xf5, 0x4a, 0x32, 0x12, 0xf3, 0xf2, 0x8b, 0xf5, 0x20, 0xfc, 0xa0, 0xd4, 0xc2, 0xd2, 0xd4, 0xe2,
+	0x12, 0x29, 0x31, 0x74, 0xe1, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x03, 0x46, 0x21, 0x67, 0x2e,
+	0x2e, 0x9f, 0xc4, 0xa4, 0xd4, 0x1c, 0xbf, 0xc4, 0xdc, 0xd4, 0x62, 0x21, 0x49, 0x98, 0x3a, 0x84,
+	0x18, 0xcc, 0x08, 0x29, 0x6c, 0x52, 0x10, 0x63, 0x84, 0xdc, 0xb8, 0xb8, 0xc1, 0xa2, 0x61, 0x89,
+	0x39, 0xa5, 0xa9, 0xc5, 0x42, 0xa8, 0x4a, 0x21, 0x82, 0x30, 0x63, 0xa4, 0xb1, 0xca, 0x41, 0xcc,
+	0x71, 0x72, 0xb9, 0xf0, 0x50, 0x8e, 0xe1, 0xc6, 0x43, 0x39, 0x86, 0x0f, 0x0f, 0xe5, 0x18, 0x1b,
+	0x1e, 0xc9, 0x31, 0xae, 0x78, 0x24, 0xc7, 0x78, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c,
+	0x0f, 0x1e, 0xc9, 0x31, 0xbe, 0x78, 0x24, 0xc7, 0xf0, 0xe1, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72,
+	0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xc5, 0x87, 0x1a, 0xb6, 0x49, 0x6c,
+	0xe0, 0x50, 0x32, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x4d, 0x59, 0xe7, 0x85, 0x01, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -243,5 +244,5 @@ var _StoreGateway_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 		},
 	},
-	Metadata: "gateway.proto",
+	Metadata: "pkg/storegateway/storegatewaypb/gateway.proto",
 }
diff --git a/pkg/storegateway/storegatewaypb/gateway.proto b/pkg/storegateway/storegatewaypb/gateway.proto
index 9d2c3ff5803..11c643a12ae 100644
--- a/pkg/storegateway/storegatewaypb/gateway.proto
+++ b/pkg/storegateway/storegatewaypb/gateway.proto
@@ -6,7 +6,7 @@
 syntax = "proto3";
 package gatewaypb;
 
-import "github.com/grafana/mimir/pkg/storegateway/storepb/rpc.proto";
+import "pkg/storegateway/storepb/rpc.proto";
 
 option go_package = "storegatewaypb";
 
diff --git a/pkg/storegateway/storepb/cache.pb.go b/pkg/storegateway/storepb/cache.pb.go
index 5e8a1298335..5d6a4fe7a2b 100644
--- a/pkg/storegateway/storepb/cache.pb.go
+++ b/pkg/storegateway/storepb/cache.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: cache.proto
+// source: pkg/storegateway/storepb/cache.proto
 
 package storepb
 
@@ -8,11 +8,11 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	_ "github.com/grafana/mimir/pkg/mimirpb"
 	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	_ "pkg/mimirpb"
 	reflect "reflect"
 	strings "strings"
 )
@@ -36,7 +36,7 @@ type CachedSeries struct {
 func (m *CachedSeries) Reset()      { *m = CachedSeries{} }
 func (*CachedSeries) ProtoMessage() {}
 func (*CachedSeries) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5fca3b110c9bbf3a, []int{0}
+	return fileDescriptor_93d2ffe5e80ed10c, []int{0}
 }
 func (m *CachedSeries) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -69,29 +69,33 @@ func init() {
 	proto.RegisterType((*CachedSeries)(nil), "thanos.CachedSeries")
 }
 
-func init() { proto.RegisterFile("cache.proto", fileDescriptor_5fca3b110c9bbf3a) }
+func init() {
+	proto.RegisterFile("pkg/storegateway/storepb/cache.proto", fileDescriptor_93d2ffe5e80ed10c)
+}
 
-var fileDescriptor_5fca3b110c9bbf3a = []byte{
-	// 303 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x90, 0x31, 0x4f, 0x02, 0x31,
-	0x1c, 0xc5, 0x5b, 0x39, 0x90, 0x1c, 0x0c, 0x17, 0x5c, 0x08, 0xc3, 0x1f, 0xe2, 0xc4, 0xe2, 0x1d,
-	0xd1, 0xc5, 0x51, 0x31, 0x2e, 0x24, 0x26, 0x04, 0x37, 0xb7, 0xb6, 0xd7, 0x3b, 0xaa, 0x70, 0xbd,
-	0xb4, 0x25, 0x71, 0xf4, 0x23, 0xf8, 0x31, 0xfc, 0x14, 0xce, 0x8c, 0x8c, 0xc4, 0x81, 0x78, 0xbd,
-	0xc5, 0x91, 0x8f, 0x60, 0xe8, 0x39, 0x38, 0x38, 0x38, 0xf5, 0xbd, 0xbc, 0xf7, 0xfa, 0x4b, 0xfe,
-	0x7e, 0x8b, 0x11, 0x36, 0xe7, 0x61, 0xae, 0xa4, 0x91, 0x9d, 0x86, 0x99, 0x93, 0x4c, 0xea, 0xde,
-	0x59, 0x2a, 0xcc, 0x7c, 0x45, 0x43, 0x26, 0x97, 0x51, 0x2a, 0x53, 0x19, 0xb9, 0x98, 0xae, 0x12,
-	0xe7, 0x9c, 0x71, 0xaa, 0x9a, 0xf5, 0x46, 0xbf, 0xeb, 0x8a, 0x24, 0x24, 0x23, 0xd1, 0x52, 0x2c,
-	0x85, 0x8a, 0xf2, 0xa7, 0xb4, 0x52, 0x39, 0xad, 0xde, 0x6a, 0x71, 0xfa, 0x8e, 0xfd, 0xf6, 0xcd,
-	0x01, 0x1c, 0xdf, 0x73, 0x25, 0xb8, 0xee, 0x3c, 0xfa, 0x0d, 0xed, 0x54, 0x17, 0x0f, 0x6a, 0xc3,
-	0xd6, 0x79, 0x10, 0x32, 0xa9, 0x0c, 0x7f, 0xce, 0x69, 0x78, 0xc7, 0x8d, 0x12, 0x6c, 0x7c, 0xb5,
-	0xde, 0xf5, 0xd1, 0xc7, 0xae, 0x7f, 0xf9, 0x1f, 0x58, 0x38, 0x55, 0x9c, 0x2c, 0x16, 0x92, 0x11,
-	0x23, 0xb2, 0xb4, 0xfa, 0x61, 0xf6, 0x43, 0xe8, 0x8c, 0xfc, 0x93, 0x58, 0x24, 0xc9, 0x6d, 0xc6,
-	0x64, 0xcc, 0xe3, 0xa9, 0xd4, 0x87, 0x8e, 0xee, 0xd6, 0x07, 0x78, 0xd8, 0x9e, 0xfd, 0x15, 0x4d,
-	0xbc, 0xe6, 0x51, 0x50, 0x9b, 0x78, 0xcd, 0x5a, 0xe0, 0x4d, 0xbc, 0xa6, 0x17, 0xd4, 0xc7, 0xd7,
-	0xeb, 0x02, 0xd0, 0xa6, 0x00, 0xb4, 0x2d, 0x00, 0xed, 0x0b, 0xc0, 0x2f, 0x16, 0xf0, 0x9b, 0x05,
-	0xbc, 0xb6, 0x80, 0x37, 0x16, 0xf0, 0xa7, 0x05, 0xfc, 0x65, 0x01, 0xed, 0x2d, 0xe0, 0xd7, 0x12,
-	0xd0, 0xa6, 0x04, 0xb4, 0x2d, 0x01, 0x3d, 0x1c, 0x6b, 0x23, 0x15, 0xcf, 0x29, 0x6d, 0xb8, 0x53,
-	0x5c, 0x7c, 0x07, 0x00, 0x00, 0xff, 0xff, 0x86, 0x0e, 0x5e, 0xee, 0x82, 0x01, 0x00, 0x00,
+var fileDescriptor_93d2ffe5e80ed10c = []byte{
+	// 326 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x31, 0x4f, 0x32, 0x31,
+	0x18, 0xc7, 0xdb, 0x97, 0x83, 0x97, 0x9c, 0x0c, 0x17, 0x34, 0x91, 0x30, 0x3c, 0x10, 0xc3, 0xc0,
+	0x74, 0x67, 0x74, 0x71, 0x54, 0x8c, 0x0b, 0x89, 0x09, 0xc1, 0xcd, 0x85, 0xf4, 0x7a, 0xa5, 0x54,
+	0xb9, 0xeb, 0xa5, 0x2d, 0x51, 0x36, 0x3f, 0x82, 0x1f, 0xc3, 0x4f, 0xe1, 0xcc, 0xc8, 0x48, 0x1c,
+	0x88, 0x57, 0x16, 0x47, 0x3e, 0x82, 0x39, 0x8e, 0xc1, 0x44, 0xa7, 0x3e, 0x7d, 0x7e, 0x4f, 0xfe,
+	0xbf, 0xe4, 0xef, 0x76, 0xd2, 0x47, 0x1e, 0x68, 0x23, 0x15, 0xe3, 0xc4, 0xb0, 0x27, 0x32, 0x2f,
+	0x3e, 0x69, 0x18, 0x50, 0x42, 0x27, 0xcc, 0x4f, 0x95, 0x34, 0xb2, 0x5e, 0x31, 0x13, 0x92, 0x48,
+	0xdd, 0x3c, 0xe2, 0x92, 0xcb, 0xdd, 0x2a, 0xc8, 0xa7, 0x82, 0x36, 0x8f, 0xf3, 0x8c, 0x58, 0xc4,
+	0x42, 0xa5, 0x61, 0xf1, 0xee, 0x41, 0xe7, 0x17, 0x18, 0xd1, 0x99, 0x36, 0x32, 0x1e, 0x99, 0x79,
+	0xca, 0x74, 0x71, 0x75, 0xf2, 0x8e, 0xdd, 0xda, 0x75, 0x2e, 0x8b, 0xee, 0x98, 0x12, 0x4c, 0xd7,
+	0x1f, 0xdc, 0x8a, 0xde, 0x4d, 0x0d, 0xdc, 0x2e, 0x75, 0x0f, 0xce, 0x3c, 0x9f, 0x4a, 0x65, 0xd8,
+	0x73, 0x1a, 0xfa, 0xb7, 0xcc, 0x28, 0x41, 0x7b, 0x97, 0x8b, 0x75, 0x0b, 0x7d, 0xac, 0x5b, 0x17,
+	0x5c, 0x98, 0xc9, 0x2c, 0xf4, 0xa9, 0x8c, 0x03, 0xae, 0xc8, 0x98, 0x24, 0xa4, 0xf0, 0x04, 0x3f,
+	0xcc, 0xfe, 0x40, 0x31, 0x32, 0x9d, 0x4a, 0x4a, 0x8c, 0x48, 0x78, 0x91, 0x30, 0xdc, 0x1b, 0xea,
+	0xa7, 0xee, 0x61, 0x24, 0xc6, 0xe3, 0x9b, 0x84, 0xca, 0x88, 0x45, 0x03, 0xa9, 0xf3, 0x1b, 0xdd,
+	0x28, 0xb7, 0x71, 0xb7, 0x36, 0xfc, 0x0b, 0xf5, 0x9d, 0xea, 0x3f, 0xaf, 0xd4, 0x77, 0xaa, 0x25,
+	0xcf, 0xe9, 0x3b, 0x55, 0xc7, 0x2b, 0xf7, 0xae, 0x16, 0x19, 0xa0, 0x65, 0x06, 0x68, 0x95, 0x01,
+	0xda, 0x66, 0x80, 0x5f, 0x2c, 0xe0, 0x37, 0x0b, 0x78, 0x61, 0x01, 0x2f, 0x2d, 0xe0, 0x4f, 0x0b,
+	0xf8, 0xcb, 0x02, 0xda, 0x5a, 0xc0, 0xaf, 0x1b, 0x40, 0xcb, 0x0d, 0xa0, 0xd5, 0x06, 0xd0, 0xfd,
+	0xff, 0x7d, 0xd9, 0x61, 0x65, 0x57, 0xc5, 0xf9, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x13,
+	0xc1, 0x27, 0x8f, 0x01, 0x00, 0x00,
 }
 
 func (this *CachedSeries) Equal(that interface{}) bool {
diff --git a/pkg/storegateway/storepb/cache.proto b/pkg/storegateway/storepb/cache.proto
index eea39defb1a..26efad7ab9b 100644
--- a/pkg/storegateway/storepb/cache.proto
+++ b/pkg/storegateway/storepb/cache.proto
@@ -6,8 +6,9 @@ package thanos;
 
 option go_package = "storepb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 
 option (gogoproto.sizer_all) = true;
 option (gogoproto.marshaler_all) = true;
diff --git a/pkg/storegateway/storepb/rpc.pb.go b/pkg/storegateway/storepb/rpc.pb.go
index 763f925f01d..be6e27e0034 100644
--- a/pkg/storegateway/storepb/rpc.pb.go
+++ b/pkg/storegateway/storepb/rpc.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: rpc.proto
+// source: pkg/storegateway/storepb/rpc.proto
 
 package storepb
 
@@ -11,6 +11,7 @@ import (
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	_ "pkg/mimirpb"
 	reflect "reflect"
 	strings "strings"
 )
@@ -53,7 +54,7 @@ type SeriesRequest struct {
 func (m *SeriesRequest) Reset()      { *m = SeriesRequest{} }
 func (*SeriesRequest) ProtoMessage() {}
 func (*SeriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{0}
+	return fileDescriptor_ac432b1772b50434, []int{0}
 }
 func (m *SeriesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -90,7 +91,7 @@ type Stats struct {
 func (m *Stats) Reset()      { *m = Stats{} }
 func (*Stats) ProtoMessage() {}
 func (*Stats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{1}
+	return fileDescriptor_ac432b1772b50434, []int{1}
 }
 func (m *Stats) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -134,7 +135,7 @@ type SeriesResponse struct {
 func (m *SeriesResponse) Reset()      { *m = SeriesResponse{} }
 func (*SeriesResponse) ProtoMessage() {}
 func (*SeriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{2}
+	return fileDescriptor_ac432b1772b50434, []int{2}
 }
 func (m *SeriesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -282,7 +283,7 @@ type LabelNamesRequest struct {
 func (m *LabelNamesRequest) Reset()      { *m = LabelNamesRequest{} }
 func (*LabelNamesRequest) ProtoMessage() {}
 func (*LabelNamesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{3}
+	return fileDescriptor_ac432b1772b50434, []int{3}
 }
 func (m *LabelNamesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -323,7 +324,7 @@ type LabelNamesResponse struct {
 func (m *LabelNamesResponse) Reset()      { *m = LabelNamesResponse{} }
 func (*LabelNamesResponse) ProtoMessage() {}
 func (*LabelNamesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{4}
+	return fileDescriptor_ac432b1772b50434, []int{4}
 }
 func (m *LabelNamesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -366,7 +367,7 @@ type LabelValuesRequest struct {
 func (m *LabelValuesRequest) Reset()      { *m = LabelValuesRequest{} }
 func (*LabelValuesRequest) ProtoMessage() {}
 func (*LabelValuesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{5}
+	return fileDescriptor_ac432b1772b50434, []int{5}
 }
 func (m *LabelValuesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -407,7 +408,7 @@ type LabelValuesResponse struct {
 func (m *LabelValuesResponse) Reset()      { *m = LabelValuesResponse{} }
 func (*LabelValuesResponse) ProtoMessage() {}
 func (*LabelValuesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{6}
+	return fileDescriptor_ac432b1772b50434, []int{6}
 }
 func (m *LabelValuesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -446,57 +447,60 @@ func init() {
 	proto.RegisterType((*LabelValuesResponse)(nil), "thanos.LabelValuesResponse")
 }
 
-func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
-
-var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 740 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0xc1, 0x6e, 0x13, 0x3b,
-	0x14, 0x86, 0xc7, 0x19, 0xcf, 0xc4, 0x71, 0x9a, 0xde, 0xe9, 0xb4, 0xba, 0x77, 0x9a, 0x7b, 0x35,
-	0x8d, 0x22, 0x5d, 0x29, 0x42, 0x90, 0x4a, 0x45, 0x82, 0x15, 0x8b, 0x06, 0x21, 0xa5, 0x23, 0x60,
-	0xe1, 0x22, 0x16, 0x48, 0x28, 0x9a, 0x24, 0x6e, 0x62, 0x35, 0xe3, 0x09, 0x63, 0x07, 0x9a, 0xae,
-	0x78, 0x04, 0x1e, 0x03, 0xc1, 0x13, 0xb0, 0x65, 0xd5, 0x65, 0x97, 0x5d, 0x21, 0x92, 0x6e, 0x58,
-	0xf6, 0x11, 0xd0, 0x78, 0x9c, 0xa4, 0x11, 0xad, 0x4a, 0x25, 0x76, 0x3e, 0xff, 0x7f, 0x7c, 0x7c,
-	0xfc, 0xf9, 0x18, 0x17, 0x92, 0x61, 0xa7, 0x3e, 0x4c, 0x62, 0x19, 0xbb, 0xb6, 0xec, 0x87, 0x3c,
-	0x16, 0xe5, 0xa2, 0x1c, 0x0f, 0xa9, 0xc8, 0xc4, 0xf2, 0xbd, 0x1e, 0x93, 0xfd, 0x51, 0xbb, 0xde,
-	0x89, 0xa3, 0xed, 0x5e, 0xdc, 0x8b, 0xb7, 0x95, 0xdc, 0x1e, 0x1d, 0xa8, 0x48, 0x05, 0x6a, 0xa5,
-	0xd3, 0x37, 0x7b, 0x71, 0xdc, 0x1b, 0xd0, 0x45, 0x56, 0xc8, 0xc7, 0x99, 0x55, 0xfd, 0x92, 0xc3,
-	0xa5, 0x7d, 0x9a, 0x30, 0x2a, 0x08, 0x7d, 0x33, 0xa2, 0x42, 0xba, 0x9b, 0x18, 0x45, 0x8c, 0xb7,
-	0x24, 0x8b, 0xa8, 0x07, 0x2a, 0xa0, 0x66, 0x92, 0x7c, 0xc4, 0xf8, 0x0b, 0x16, 0x51, 0x65, 0x85,
-	0x47, 0x99, 0x95, 0xd3, 0x56, 0x78, 0xa4, 0xac, 0x07, 0xa9, 0x25, 0x3b, 0x7d, 0x9a, 0x08, 0xcf,
-	0xac, 0x98, 0xb5, 0xe2, 0xce, 0x46, 0x3d, 0xeb, 0xbc, 0xfe, 0x34, 0x6c, 0xd3, 0xc1, 0xb3, 0xcc,
-	0x6c, 0xc0, 0x93, 0x6f, 0x5b, 0x06, 0x99, 0xe7, 0xba, 0x5b, 0xb8, 0x28, 0x0e, 0xd9, 0xb0, 0xd5,
-	0xe9, 0x8f, 0xf8, 0xa1, 0xf0, 0x50, 0x05, 0xd4, 0x10, 0xc1, 0xa9, 0xf4, 0x58, 0x29, 0xee, 0x1d,
-	0x6c, 0xf5, 0x19, 0x97, 0xc2, 0x2b, 0x54, 0x80, 0xaa, 0x9a, 0xdd, 0xa5, 0x3e, 0xbb, 0x4b, 0x7d,
-	0x97, 0x8f, 0x49, 0x96, 0xe2, 0x3e, 0xc2, 0xff, 0x0a, 0x99, 0xd0, 0x30, 0x62, 0xbc, 0xa7, 0x2b,
-	0xb6, 0xda, 0xe9, 0x49, 0x2d, 0xc1, 0x8e, 0xa9, 0xd7, 0xad, 0x80, 0x1a, 0x24, 0xde, 0x3c, 0x25,
-	0x3b, 0xa1, 0x91, 0x26, 0xec, 0xb3, 0x63, 0x1a, 0x40, 0x04, 0x1d, 0x2b, 0x80, 0xc8, 0x72, 0xec,
-	0x00, 0x22, 0xdb, 0xc9, 0x07, 0x10, 0xe5, 0x1d, 0x14, 0x40, 0x84, 0x9d, 0x62, 0x00, 0x51, 0xd1,
-	0x59, 0x09, 0x20, 0x5a, 0x71, 0x4a, 0x01, 0x44, 0x25, 0x67, 0xb5, 0xfa, 0x10, 0x5b, 0xfb, 0x32,
-	0x94, 0xc2, 0xad, 0xe3, 0xf5, 0x03, 0x9a, 0x5e, 0xa8, 0xdb, 0x62, 0xbc, 0x4b, 0x8f, 0x5a, 0xed,
-	0xb1, 0xa4, 0x42, 0xd1, 0x83, 0x64, 0x4d, 0x5b, 0x7b, 0xa9, 0xd3, 0x48, 0x8d, 0xea, 0x27, 0x13,
-	0xaf, 0xce, 0xa0, 0x8b, 0x61, 0xcc, 0x05, 0x75, 0x6b, 0xd8, 0x16, 0x4a, 0x51, 0xbb, 0x8a, 0x3b,
-	0xab, 0x33, 0x7a, 0x59, 0x5e, 0xd3, 0x20, 0xda, 0x77, 0xcb, 0x38, 0xff, 0x2e, 0x4c, 0x38, 0xe3,
-	0x3d, 0xf5, 0x06, 0x85, 0xa6, 0x41, 0x66, 0x82, 0x7b, 0x77, 0x06, 0xcb, 0xbc, 0x1e, 0x56, 0xd3,
-	0x98, 0xe1, 0xfa, 0x1f, 0x5b, 0x22, 0xed, 0xdf, 0x83, 0x2a, 0xbb, 0x34, 0x3f, 0x32, 0x15, 0xd3,
-	0x34, 0xe5, 0xba, 0x7b, 0xd8, 0x59, 0x50, 0xd5, 0x4d, 0x5a, 0x6a, 0xc7, 0x7f, 0x8b, 0x1d, 0xda,
-	0xcf, 0xba, 0x55, 0x48, 0x9b, 0x06, 0xf9, 0x4b, 0x2c, 0xeb, 0xcb, 0xa5, 0xf4, 0x93, 0xdb, 0xd7,
-	0x94, 0xba, 0xf4, 0x3a, 0x4b, 0xa5, 0xf4, 0x5c, 0xbc, 0xc6, 0x9b, 0xbf, 0xbc, 0x35, 0x15, 0x92,
-	0x45, 0xa1, 0xa4, 0x5e, 0x5e, 0xd5, 0xdc, 0xba, 0xa6, 0xe6, 0x13, 0x9d, 0xd6, 0x34, 0xc8, 0x3f,
-	0xe2, 0x6a, 0xab, 0x81, 0xb0, 0x9d, 0x50, 0x31, 0x1a, 0xc8, 0xea, 0x67, 0x80, 0xd7, 0xd4, 0x08,
-	0x3f, 0x0f, 0xa3, 0xc5, 0x2f, 0xd9, 0x50, 0xec, 0x12, 0xa9, 0x48, 0x9b, 0x24, 0x0b, 0x5c, 0x07,
-	0x9b, 0x94, 0x77, 0x15, 0x4f, 0x93, 0xa4, 0xcb, 0xc5, 0xf8, 0x5a, 0x37, 0x8f, 0xef, 0xe5, 0x3f,
-	0x64, 0xff, 0xfe, 0x1f, 0x0a, 0x20, 0x02, 0x4e, 0x2e, 0x80, 0x28, 0xe7, 0x98, 0xd5, 0x04, 0xbb,
-	0x97, 0x9b, 0xd5, 0xd3, 0xb5, 0x81, 0x2d, 0x9e, 0x0a, 0x1e, 0xa8, 0x98, 0xb5, 0x02, 0xc9, 0x02,
-	0xb7, 0x8c, 0x91, 0x1e, 0x1c, 0xe1, 0xe5, 0x94, 0x31, 0x8f, 0x17, 0x7d, 0x9b, 0x37, 0xf6, 0x5d,
-	0xfd, 0x0a, 0xf4, 0xa1, 0x2f, 0xc3, 0xc1, 0x68, 0x09, 0xd1, 0x20, 0x55, 0xd5, 0x44, 0x17, 0x48,
-	0x16, 0x2c, 0xc0, 0xc1, 0x2b, 0xc0, 0x59, 0x57, 0x80, 0xb3, 0x6f, 0x07, 0x2e, 0x7f, 0x2b, 0x70,
-	0x39, 0xc7, 0x0c, 0x20, 0x32, 0x1d, 0x58, 0x1d, 0xe1, 0xf5, 0xa5, 0x3b, 0x68, 0x72, 0x7f, 0x63,
-	0xfb, 0xad, 0x52, 0x34, 0x3a, 0x1d, 0xfd, 0x29, 0x76, 0x8d, 0xdd, 0x93, 0x89, 0x6f, 0x9c, 0x4e,
-	0x7c, 0xe3, 0x6c, 0xe2, 0x1b, 0x17, 0x13, 0x1f, 0xbc, 0x9f, 0xfa, 0xe0, 0xe3, 0xd4, 0x07, 0x27,
-	0x53, 0x1f, 0x9c, 0x4e, 0x7d, 0xf0, 0x7d, 0xea, 0x83, 0x1f, 0x53, 0xdf, 0xb8, 0x98, 0xfa, 0xe0,
-	0xc3, 0xb9, 0x6f, 0x9c, 0x9e, 0xfb, 0xc6, 0xd9, 0xb9, 0x6f, 0xbc, 0xca, 0x0b, 0x19, 0x27, 0x74,
-	0xd8, 0x6e, 0xdb, 0xaa, 0xee, 0xfd, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfa, 0xb6, 0x7d, 0x6f,
-	0x35, 0x06, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/storegateway/storepb/rpc.proto", fileDescriptor_ac432b1772b50434)
+}
+
+var fileDescriptor_ac432b1772b50434 = []byte{
+	// 765 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0x4d, 0x6f, 0xdb, 0x36,
+	0x18, 0xc7, 0x45, 0x8b, 0x92, 0x69, 0x3a, 0xce, 0x14, 0xc5, 0xd8, 0x94, 0x6c, 0x50, 0x0c, 0x61,
+	0x03, 0x8c, 0x61, 0xb0, 0x81, 0x0c, 0xd8, 0x4e, 0x3b, 0xc4, 0xc3, 0x00, 0x47, 0xd8, 0x76, 0x50,
+	0x86, 0x1d, 0x0a, 0x14, 0x82, 0x6c, 0x33, 0xb2, 0x10, 0xeb, 0xa5, 0x22, 0xdd, 0xc4, 0x39, 0xf5,
+	0x23, 0xf4, 0x63, 0x14, 0xed, 0x27, 0xe8, 0xb5, 0xa7, 0x1c, 0x73, 0xcc, 0xa9, 0xa8, 0x9d, 0x4b,
+	0x8f, 0xf9, 0x08, 0x85, 0x48, 0xfa, 0x0d, 0x8d, 0x91, 0x06, 0xe8, 0xc9, 0x7a, 0x9e, 0xff, 0x9f,
+	0x0f, 0x1f, 0xfe, 0xf8, 0x10, 0xc6, 0x4e, 0x76, 0x16, 0xb6, 0x29, 0x4b, 0x73, 0x12, 0x06, 0x8c,
+	0x9c, 0x07, 0x13, 0x11, 0x64, 0xbd, 0x76, 0x9e, 0xf5, 0x5b, 0x59, 0x9e, 0xb2, 0xd4, 0xd4, 0xd9,
+	0x30, 0x48, 0x52, 0xba, 0xff, 0xe3, 0x46, 0x2f, 0x9b, 0x64, 0x84, 0x0a, 0xb7, 0x70, 0xc5, 0x51,
+	0x1c, 0xe5, 0x59, 0x4f, 0xfc, 0xfa, 0xfd, 0x31, 0x65, 0x69, 0xec, 0xaf, 0xba, 0xea, 0x61, 0x1a,
+	0xa6, 0xfc, 0xb3, 0x5d, 0x7c, 0xc9, 0xec, 0x5e, 0x98, 0xa6, 0xe1, 0x88, 0xb4, 0x79, 0xd4, 0x1b,
+	0x9f, 0xb6, 0x83, 0x64, 0x22, 0x24, 0xe7, 0x6d, 0x09, 0xd7, 0x4e, 0x48, 0x1e, 0x11, 0xea, 0x91,
+	0x67, 0x63, 0x42, 0x99, 0xb9, 0x87, 0x51, 0x1c, 0x25, 0x3e, 0x8b, 0x62, 0x62, 0x81, 0x06, 0x68,
+	0xaa, 0x5e, 0x39, 0x8e, 0x92, 0xff, 0xa2, 0x98, 0x70, 0x29, 0xb8, 0x10, 0x52, 0x49, 0x4a, 0xc1,
+	0x05, 0x97, 0x7e, 0x2b, 0x24, 0xd6, 0x1f, 0x92, 0x9c, 0x5a, 0x6a, 0x43, 0x6d, 0x56, 0x0f, 0xeb,
+	0x2d, 0x71, 0xbe, 0xd6, 0xdf, 0x41, 0x8f, 0x8c, 0xfe, 0x11, 0x62, 0x07, 0x5e, 0xbd, 0x3f, 0x50,
+	0xbc, 0x85, 0xd7, 0x3c, 0xc0, 0x55, 0x7a, 0x16, 0x65, 0x7e, 0x7f, 0x38, 0x4e, 0xce, 0xa8, 0x85,
+	0x1a, 0xa0, 0x89, 0x3c, 0x5c, 0xa4, 0xfe, 0xe4, 0x19, 0xf3, 0x67, 0xac, 0x0d, 0xa3, 0x84, 0x51,
+	0xab, 0xd2, 0x00, 0xbc, 0xaa, 0x38, 0x4b, 0x6b, 0x7e, 0x96, 0xd6, 0x51, 0x32, 0xf1, 0x84, 0xc5,
+	0xfc, 0x03, 0x7f, 0x4f, 0x59, 0x4e, 0x82, 0x38, 0x4a, 0x42, 0x59, 0xd1, 0xef, 0x15, 0x3b, 0xf9,
+	0x34, 0xba, 0x24, 0xd6, 0xa0, 0x01, 0x9a, 0xd0, 0xb3, 0x16, 0x16, 0xb1, 0x43, 0xa7, 0x30, 0x9c,
+	0x44, 0x97, 0xc4, 0x85, 0x08, 0x1a, 0x9a, 0x0b, 0x91, 0x66, 0xe8, 0x2e, 0x44, 0xba, 0x51, 0x76,
+	0x21, 0x2a, 0x1b, 0xc8, 0x85, 0x08, 0x1b, 0x55, 0x17, 0xa2, 0xaa, 0xb1, 0xe5, 0x42, 0xb4, 0x65,
+	0xd4, 0x5c, 0x88, 0x6a, 0xc6, 0xb6, 0xf3, 0x3b, 0xd6, 0x4e, 0x58, 0xc0, 0xa8, 0xd9, 0xc2, 0xbb,
+	0xa7, 0xa4, 0x38, 0xd0, 0xc0, 0x8f, 0x92, 0x01, 0xb9, 0xf0, 0x7b, 0x13, 0x46, 0x28, 0xa7, 0x07,
+	0xbd, 0x1d, 0x29, 0x1d, 0x17, 0x4a, 0xa7, 0x10, 0x9c, 0xd7, 0x2a, 0xde, 0x9e, 0x43, 0xa7, 0x59,
+	0x9a, 0x50, 0x62, 0x36, 0xb1, 0x4e, 0x79, 0x86, 0xaf, 0xaa, 0x1e, 0x6e, 0xcf, 0xe9, 0x09, 0x5f,
+	0x57, 0xf1, 0xa4, 0x6e, 0xee, 0xe3, 0xf2, 0x79, 0x90, 0x27, 0x51, 0x12, 0xf2, 0x3b, 0xa8, 0x74,
+	0x15, 0x6f, 0x9e, 0x30, 0x7f, 0x99, 0xc3, 0x52, 0x37, 0xc3, 0xea, 0x2a, 0x73, 0x5c, 0x3f, 0x61,
+	0x8d, 0x16, 0xfd, 0x5b, 0x90, 0xbb, 0x6b, 0x8b, 0x2d, 0x8b, 0x64, 0x61, 0xe3, 0xaa, 0x79, 0x8c,
+	0x8d, 0x25, 0x55, 0xd9, 0xa4, 0xc6, 0x57, 0xfc, 0xb0, 0x5c, 0x21, 0x75, 0xd1, 0x2d, 0x47, 0xda,
+	0x55, 0xbc, 0x6f, 0xe8, 0x7a, 0x7e, 0xbd, 0x94, 0xbc, 0x72, 0x7d, 0x43, 0xa9, 0x95, 0xdb, 0x59,
+	0x2b, 0x25, 0xe7, 0xe2, 0x29, 0xde, 0xfb, 0xec, 0xae, 0x09, 0x65, 0x51, 0x1c, 0x30, 0x62, 0x95,
+	0x79, 0xcd, 0x83, 0x0d, 0x35, 0xff, 0x92, 0xb6, 0xae, 0xe2, 0x7d, 0x47, 0xef, 0x97, 0x3a, 0x08,
+	0xeb, 0x39, 0xa1, 0xe3, 0x11, 0x73, 0xde, 0x00, 0xbc, 0xc3, 0x47, 0xf8, 0xdf, 0x20, 0x5e, 0xbe,
+	0x92, 0x3a, 0x67, 0x97, 0x33, 0x4e, 0x5a, 0xf5, 0x44, 0x60, 0x1a, 0x58, 0x25, 0xc9, 0x80, 0xf3,
+	0x54, 0xbd, 0xe2, 0x73, 0x39, 0xbe, 0xda, 0xc3, 0xe3, 0xbb, 0xfa, 0x86, 0xf4, 0x2f, 0x7f, 0x43,
+	0x2e, 0x44, 0xc0, 0x28, 0xb9, 0x10, 0x95, 0x0c, 0xd5, 0xc9, 0xb1, 0xb9, 0xda, 0xac, 0x9c, 0xae,
+	0x3a, 0xd6, 0x92, 0x22, 0x61, 0x81, 0x86, 0xda, 0xac, 0x78, 0x22, 0x30, 0xf7, 0x31, 0x92, 0x83,
+	0x43, 0xad, 0x12, 0x17, 0x16, 0xf1, 0xb2, 0x6f, 0xf5, 0xc1, 0xbe, 0x9d, 0x77, 0x40, 0x6e, 0xfa,
+	0x7f, 0x30, 0x1a, 0xaf, 0x21, 0x1a, 0x15, 0x59, 0x3e, 0xd1, 0x15, 0x4f, 0x04, 0x4b, 0x70, 0xf0,
+	0x1e, 0x70, 0xda, 0x3d, 0xe0, 0xf4, 0xc7, 0x81, 0x2b, 0x3f, 0x0a, 0x5c, 0xc9, 0x50, 0x5d, 0x88,
+	0x54, 0x03, 0x3a, 0x63, 0xbc, 0xbb, 0x76, 0x06, 0x49, 0xee, 0x5b, 0xac, 0x3f, 0xe7, 0x19, 0x89,
+	0x4e, 0x46, 0x5f, 0x8b, 0x5d, 0xe7, 0xe8, 0x6a, 0x6a, 0x2b, 0xd7, 0x53, 0x5b, 0xb9, 0x99, 0xda,
+	0xca, 0xdd, 0xd4, 0x06, 0x2f, 0x66, 0x36, 0x78, 0x35, 0xb3, 0xc1, 0xd5, 0xcc, 0x06, 0xd7, 0x33,
+	0x1b, 0x7c, 0x98, 0xd9, 0xe0, 0xe3, 0xcc, 0x56, 0xee, 0x66, 0x36, 0x78, 0x79, 0x6b, 0x2b, 0xd7,
+	0xb7, 0xb6, 0x72, 0x73, 0x6b, 0x2b, 0x4f, 0xca, 0xf2, 0x5f, 0xa2, 0xa7, 0xf3, 0xba, 0xbf, 0x7e,
+	0x0a, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x20, 0xff, 0xde, 0x74, 0x06, 0x00, 0x00,
 }
 
 func (this *SeriesRequest) Equal(that interface{}) bool {
diff --git a/pkg/storegateway/storepb/rpc.proto b/pkg/storegateway/storepb/rpc.proto
index e8a4404fc7b..df001a573ed 100644
--- a/pkg/storegateway/storepb/rpc.proto
+++ b/pkg/storegateway/storepb/rpc.proto
@@ -6,8 +6,9 @@
 syntax = "proto3";
 package thanos;
 
-import "types.proto";
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+import "pkg/storegateway/storepb/types.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
+import "gogoproto/gogo.proto";
 import "google/protobuf/any.proto";
 
 option go_package = "storepb";
diff --git a/pkg/storegateway/storepb/types.pb.go b/pkg/storegateway/storepb/types.pb.go
index 59b78b88a11..57c179f234c 100644
--- a/pkg/storegateway/storepb/types.pb.go
+++ b/pkg/storegateway/storepb/types.pb.go
@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: types.proto
+// source: pkg/storegateway/storepb/types.proto
 
 package storepb
 
@@ -7,11 +7,11 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	_ "github.com/grafana/mimir/pkg/mimirpb"
 	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
 	io "io"
 	math "math"
 	math_bits "math/bits"
+	mimirpb "pkg/mimirpb"
 	reflect "reflect"
 	strconv "strconv"
 	strings "strings"
@@ -49,7 +49,7 @@ var Chunk_Encoding_value = map[string]int32{
 }
 
 func (Chunk_Encoding) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{0, 0}
+	return fileDescriptor_648f792207ebdc5f, []int{0, 0}
 }
 
 type LabelMatcher_Type int32
@@ -76,7 +76,7 @@ var LabelMatcher_Type_value = map[string]int32{
 }
 
 func (LabelMatcher_Type) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{8, 0}
+	return fileDescriptor_648f792207ebdc5f, []int{8, 0}
 }
 
 type Chunk struct {
@@ -87,7 +87,7 @@ type Chunk struct {
 func (m *Chunk) Reset()      { *m = Chunk{} }
 func (*Chunk) ProtoMessage() {}
 func (*Chunk) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{0}
+	return fileDescriptor_648f792207ebdc5f, []int{0}
 }
 func (m *Chunk) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -117,14 +117,14 @@ func (m *Chunk) XXX_DiscardUnknown() {
 var xxx_messageInfo_Chunk proto.InternalMessageInfo
 
 type Series struct {
-	Labels []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
-	Chunks []AggrChunk                                         `protobuf:"bytes,2,rep,name=chunks,proto3" json:"chunks"`
+	Labels []mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
+	Chunks []AggrChunk            `protobuf:"bytes,2,rep,name=chunks,proto3" json:"chunks"`
 }
 
 func (m *Series) Reset()      { *m = Series{} }
 func (*Series) ProtoMessage() {}
 func (*Series) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{1}
+	return fileDescriptor_648f792207ebdc5f, []int{1}
 }
 func (m *Series) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -154,13 +154,13 @@ func (m *Series) XXX_DiscardUnknown() {
 var xxx_messageInfo_Series proto.InternalMessageInfo
 
 type StreamingSeries struct {
-	Labels []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"labels"`
+	Labels []mimirpb.LabelAdapter `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels"`
 }
 
 func (m *StreamingSeries) Reset()      { *m = StreamingSeries{} }
 func (*StreamingSeries) ProtoMessage() {}
 func (*StreamingSeries) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{2}
+	return fileDescriptor_648f792207ebdc5f, []int{2}
 }
 func (m *StreamingSeries) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -197,7 +197,7 @@ type StreamingSeriesBatch struct {
 func (m *StreamingSeriesBatch) Reset()      { *m = StreamingSeriesBatch{} }
 func (*StreamingSeriesBatch) ProtoMessage() {}
 func (*StreamingSeriesBatch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{3}
+	return fileDescriptor_648f792207ebdc5f, []int{3}
 }
 func (m *StreamingSeriesBatch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -234,7 +234,7 @@ type StreamingChunks struct {
 func (m *StreamingChunks) Reset()      { *m = StreamingChunks{} }
 func (*StreamingChunks) ProtoMessage() {}
 func (*StreamingChunks) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{4}
+	return fileDescriptor_648f792207ebdc5f, []int{4}
 }
 func (m *StreamingChunks) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -270,7 +270,7 @@ type StreamingChunksBatch struct {
 func (m *StreamingChunksBatch) Reset()      { *m = StreamingChunksBatch{} }
 func (*StreamingChunksBatch) ProtoMessage() {}
 func (*StreamingChunksBatch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{5}
+	return fileDescriptor_648f792207ebdc5f, []int{5}
 }
 func (m *StreamingChunksBatch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -306,7 +306,7 @@ type StreamingChunksEstimate struct {
 func (m *StreamingChunksEstimate) Reset()      { *m = StreamingChunksEstimate{} }
 func (*StreamingChunksEstimate) ProtoMessage() {}
 func (*StreamingChunksEstimate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{6}
+	return fileDescriptor_648f792207ebdc5f, []int{6}
 }
 func (m *StreamingChunksEstimate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -344,7 +344,7 @@ type AggrChunk struct {
 func (m *AggrChunk) Reset()      { *m = AggrChunk{} }
 func (*AggrChunk) ProtoMessage() {}
 func (*AggrChunk) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{7}
+	return fileDescriptor_648f792207ebdc5f, []int{7}
 }
 func (m *AggrChunk) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -383,7 +383,7 @@ type LabelMatcher struct {
 func (m *LabelMatcher) Reset()      { *m = LabelMatcher{} }
 func (*LabelMatcher) ProtoMessage() {}
 func (*LabelMatcher) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d938547f84707355, []int{8}
+	return fileDescriptor_648f792207ebdc5f, []int{8}
 }
 func (m *LabelMatcher) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -426,55 +426,56 @@ func init() {
 	proto.RegisterType((*LabelMatcher)(nil), "thanos.LabelMatcher")
 }
 
-func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) }
-
-var fileDescriptor_d938547f84707355 = []byte{
-	// 715 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4d, 0x6f, 0xd3, 0x4a,
-	0x14, 0xf5, 0x24, 0x4e, 0xe2, 0x4c, 0xda, 0x57, 0xbf, 0x49, 0xde, 0x6b, 0xda, 0x85, 0x1b, 0x2c,
-	0x21, 0x45, 0x48, 0x75, 0x20, 0x74, 0x83, 0xc4, 0xa6, 0xa9, 0x02, 0x25, 0xa2, 0xb4, 0x75, 0x8b,
-	0x84, 0x10, 0x92, 0x35, 0x49, 0x26, 0xce, 0xa8, 0xf1, 0x87, 0x3c, 0x13, 0x48, 0x16, 0x48, 0xac,
-	0x58, 0xf3, 0x17, 0xd8, 0xf1, 0x47, 0x90, 0xba, 0xa3, 0xcb, 0x8a, 0x45, 0x45, 0xd2, 0x0d, 0xcb,
-	0xfe, 0x04, 0xe4, 0x19, 0xa7, 0xa4, 0xed, 0xa6, 0x6c, 0x58, 0x79, 0xee, 0x3d, 0xe7, 0xde, 0x73,
-	0xee, 0xd5, 0x8c, 0x61, 0x81, 0x8f, 0x43, 0xc2, 0xac, 0x30, 0x0a, 0x78, 0x80, 0xb2, 0xbc, 0x8f,
-	0xfd, 0x80, 0xad, 0xae, 0xbb, 0x94, 0xf7, 0x87, 0x6d, 0xab, 0x13, 0x78, 0x35, 0x37, 0x70, 0x83,
-	0x9a, 0x80, 0xdb, 0xc3, 0x9e, 0x88, 0x44, 0x20, 0x4e, 0xb2, 0x6c, 0xf5, 0xfe, 0x3c, 0x3d, 0xc2,
-	0x3d, 0xec, 0xe3, 0x9a, 0x47, 0x3d, 0x1a, 0xd5, 0xc2, 0x23, 0x57, 0x9e, 0xc2, 0xb6, 0xfc, 0xca,
-	0x0a, 0xf3, 0x1b, 0x80, 0x99, 0xad, 0xfe, 0xd0, 0x3f, 0x42, 0xf7, 0xa0, 0x1a, 0x3b, 0x28, 0x83,
-	0x0a, 0xa8, 0xfe, 0x53, 0xff, 0xdf, 0x92, 0x0e, 0x2c, 0x01, 0x5a, 0x4d, 0xbf, 0x13, 0x74, 0xa9,
-	0xef, 0xda, 0x82, 0x83, 0xf6, 0xa0, 0xda, 0xc5, 0x1c, 0x97, 0x53, 0x15, 0x50, 0x5d, 0x68, 0x3c,
-	0x3e, 0x3e, 0x5b, 0x53, 0xbe, 0x9f, 0xad, 0x6d, 0xdc, 0x46, 0xdd, 0x7a, 0xe9, 0x33, 0xdc, 0x23,
-	0x8d, 0x31, 0x27, 0x07, 0x03, 0xda, 0x21, 0xb6, 0xe8, 0x64, 0x6e, 0x43, 0x6d, 0xa6, 0x81, 0x16,
-	0x61, 0x5e, 0xa8, 0x3a, 0xaf, 0x76, 0x6d, 0x5d, 0x41, 0x45, 0xb8, 0x24, 0xc3, 0x6d, 0xca, 0x78,
-	0xe0, 0x46, 0xd8, 0xd3, 0x01, 0x2a, 0xc3, 0x92, 0x4c, 0x3e, 0x19, 0x04, 0x98, 0xff, 0x46, 0x52,
-	0xe6, 0x67, 0x00, 0xb3, 0x07, 0x24, 0xa2, 0x84, 0xa1, 0x1e, 0xcc, 0x0e, 0x70, 0x9b, 0x0c, 0x58,
-	0x19, 0x54, 0xd2, 0xd5, 0x42, 0xbd, 0x68, 0x75, 0x82, 0x88, 0x93, 0x51, 0xd8, 0xb6, 0x9e, 0xc7,
-	0xf9, 0x3d, 0x4c, 0xa3, 0xc6, 0xa3, 0xc4, 0xfd, 0x83, 0x5b, 0xb9, 0x17, 0x75, 0x9b, 0x5d, 0x1c,
-	0x72, 0x12, 0xd9, 0x49, 0x77, 0x54, 0x83, 0xd9, 0x4e, 0x6c, 0x86, 0x95, 0x53, 0x42, 0xe7, 0xdf,
-	0xd9, 0xf2, 0x36, 0x5d, 0x37, 0x12, 0x36, 0x1b, 0x6a, 0xac, 0x62, 0x27, 0x34, 0x73, 0x0c, 0x97,
-	0x0e, 0x78, 0x44, 0xb0, 0x47, 0x7d, 0xf7, 0xef, 0x7a, 0x35, 0xdf, 0xc3, 0xd2, 0x35, 0xe9, 0x06,
-	0xe6, 0x9d, 0x7e, 0x3c, 0x03, 0x13, 0x61, 0xa2, 0xbf, 0x3c, 0x9b, 0xe1, 0x1a, 0xdb, 0x4e, 0x68,
-	0x68, 0x03, 0x2e, 0x53, 0xe6, 0x10, 0xbf, 0xeb, 0x04, 0x3d, 0x47, 0xe6, 0x1c, 0x26, 0xb8, 0xe2,
-	0x5a, 0x68, 0x76, 0x91, 0xb2, 0xa6, 0xdf, 0xdd, 0xed, 0xc9, 0x3a, 0xd9, 0xc6, 0x24, 0x73, 0x93,
-	0x8b, 0xcd, 0x30, 0x74, 0x07, 0x2e, 0x24, 0xe5, 0xd4, 0xef, 0x92, 0x91, 0xb8, 0x80, 0xaa, 0x5d,
-	0x90, 0xb9, 0x67, 0x71, 0xea, 0xcf, 0x17, 0xfc, 0x74, 0x6e, 0x4a, 0x29, 0x73, 0xdb, 0x29, 0x25,
-	0x7b, 0x36, 0xa5, 0xb9, 0x03, 0x97, 0xaf, 0x41, 0x4d, 0xc6, 0xa9, 0x87, 0x39, 0x41, 0x75, 0xf8,
-	0x1f, 0x49, 0xce, 0x5d, 0x47, 0xe8, 0x3a, 0x9d, 0x60, 0xe8, 0xf3, 0x64, 0x80, 0xe2, 0x25, 0x28,
-	0xea, 0xb6, 0x62, 0xc8, 0xfc, 0x08, 0x60, 0xfe, 0xd2, 0x33, 0x5a, 0x81, 0x9a, 0x47, 0x7d, 0x87,
-	0x53, 0x4f, 0x3e, 0xbb, 0xb4, 0x9d, 0xf3, 0xa8, 0x7f, 0x48, 0x3d, 0x22, 0x20, 0x3c, 0x92, 0x50,
-	0x2a, 0x81, 0xf0, 0x48, 0x40, 0x77, 0x61, 0x3a, 0xc2, 0xef, 0xca, 0xe9, 0x0a, 0xa8, 0x16, 0xea,
-	0x8b, 0x57, 0xde, 0x69, 0xb2, 0x85, 0x18, 0x6f, 0xa9, 0x9a, 0xaa, 0x67, 0x5a, 0xaa, 0x96, 0xd1,
-	0xb3, 0x2d, 0x55, 0xcb, 0xea, 0xb9, 0x96, 0xaa, 0xe5, 0x74, 0xad, 0xa5, 0x6a, 0x9a, 0x9e, 0x37,
-	0xbf, 0x02, 0xb8, 0x20, 0xee, 0xc7, 0x4e, 0xbc, 0x17, 0x12, 0xa1, 0xf5, 0x2b, 0xcf, 0x7f, 0x65,
-	0xd6, 0x76, 0x9e, 0x63, 0x1d, 0x8e, 0x43, 0x92, 0xfc, 0x01, 0x10, 0x54, 0x7d, 0x9c, 0x78, 0xcb,
-	0xdb, 0xe2, 0x8c, 0x4a, 0x30, 0xf3, 0x16, 0x0f, 0x86, 0x44, 0x58, 0xcb, 0xdb, 0x32, 0x30, 0xdf,
-	0x40, 0x35, 0xae, 0x8b, 0x9f, 0xf1, 0x7c, 0x33, 0xa7, 0xb9, 0xaf, 0x2b, 0xa8, 0x04, 0xf5, 0x2b,
-	0xc9, 0x17, 0xcd, 0x7d, 0x1d, 0xdc, 0xa0, 0xda, 0x4d, 0x3d, 0x75, 0x93, 0x6a, 0x37, 0xf5, 0x74,
-	0x63, 0xf3, 0x78, 0x62, 0x28, 0x27, 0x13, 0x43, 0x39, 0x9d, 0x18, 0xca, 0xc5, 0xc4, 0x00, 0x1f,
-	0xa6, 0x06, 0xf8, 0x32, 0x35, 0xc0, 0xf1, 0xd4, 0x00, 0x27, 0x53, 0x03, 0xfc, 0x98, 0x1a, 0xe0,
-	0xe7, 0xd4, 0x50, 0x2e, 0xa6, 0x06, 0xf8, 0x74, 0x6e, 0x28, 0x27, 0xe7, 0x86, 0x72, 0x7a, 0x6e,
-	0x28, 0xaf, 0x73, 0x8c, 0x07, 0x11, 0x09, 0xdb, 0xed, 0xac, 0xf8, 0x13, 0x3e, 0xfc, 0x15, 0x00,
-	0x00, 0xff, 0xff, 0x58, 0xdc, 0x9c, 0x04, 0x81, 0x05, 0x00, 0x00,
+func init() {
+	proto.RegisterFile("pkg/storegateway/storepb/types.proto", fileDescriptor_648f792207ebdc5f)
+}
+
+var fileDescriptor_648f792207ebdc5f = []byte{
+	// 704 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4f, 0x4f, 0x13, 0x41,
+	0x14, 0xdf, 0x69, 0xb7, 0xed, 0x76, 0x00, 0x59, 0x87, 0x0a, 0x85, 0xc3, 0x52, 0x37, 0x9a, 0x34,
+	0x26, 0x6e, 0x93, 0xca, 0xd1, 0x0b, 0x25, 0x55, 0x6c, 0x44, 0x64, 0xc1, 0xc4, 0x18, 0x93, 0xcd,
+	0x74, 0x3b, 0xdd, 0x4e, 0xe8, 0xfe, 0xc9, 0xce, 0x54, 0xda, 0x83, 0x89, 0x27, 0xcf, 0x7e, 0x0c,
+	0xbf, 0x88, 0x09, 0x37, 0x39, 0x12, 0x0f, 0xc4, 0x96, 0x8b, 0x47, 0x3e, 0x82, 0xd9, 0x99, 0x2d,
+	0x96, 0x72, 0x31, 0x7a, 0xda, 0x79, 0xef, 0xf7, 0x7b, 0xbf, 0xf7, 0x67, 0xe7, 0x0d, 0x7c, 0x10,
+	0x1d, 0x7b, 0x35, 0xc6, 0xc3, 0x98, 0x78, 0x98, 0x93, 0x13, 0x3c, 0x92, 0x46, 0xd4, 0xae, 0xf1,
+	0x51, 0x44, 0x98, 0x15, 0xc5, 0x21, 0x0f, 0x51, 0x9e, 0xf7, 0x70, 0x10, 0xb2, 0x8d, 0x92, 0x17,
+	0x7a, 0xa1, 0x70, 0xd5, 0x92, 0x93, 0x44, 0x37, 0x84, 0x86, 0x4f, 0x7d, 0x1a, 0x47, 0x6d, 0xf9,
+	0x75, 0xdc, 0x01, 0xe3, 0xa1, 0xef, 0xcc, 0x68, 0x98, 0xdf, 0x01, 0xcc, 0xed, 0xf4, 0x06, 0xc1,
+	0x31, 0x7a, 0x04, 0xd5, 0x04, 0x28, 0x83, 0x0a, 0xa8, 0xde, 0xa9, 0xaf, 0x5a, 0x52, 0xdc, 0x12,
+	0xa0, 0xd5, 0x0c, 0xdc, 0xb0, 0x43, 0x03, 0xcf, 0x16, 0x1c, 0xf4, 0x1a, 0xaa, 0x1d, 0xcc, 0x71,
+	0x39, 0x53, 0x01, 0xd5, 0xc5, 0xc6, 0xd3, 0xd3, 0x8b, 0x4d, 0xe5, 0xc7, 0xc5, 0xe6, 0x96, 0x47,
+	0x79, 0x6f, 0xd0, 0xb6, 0xdc, 0xd0, 0xaf, 0x79, 0x31, 0xee, 0xe2, 0x00, 0xcb, 0xc4, 0xb5, 0x99,
+	0x52, 0xac, 0x37, 0x01, 0xc3, 0x5d, 0xd2, 0x18, 0x71, 0x72, 0xd8, 0xa7, 0x2e, 0xb1, 0x85, 0x92,
+	0xb9, 0x0b, 0xb5, 0x69, 0x0e, 0xb4, 0x04, 0x8b, 0x22, 0xab, 0xf3, 0x76, 0xdf, 0xd6, 0x15, 0xb4,
+	0x02, 0x97, 0xa5, 0xb9, 0x4b, 0x19, 0x0f, 0xbd, 0x18, 0xfb, 0x3a, 0x40, 0x65, 0x58, 0x92, 0xce,
+	0x67, 0xfd, 0x10, 0xf3, 0x3f, 0x48, 0xc6, 0x0c, 0x61, 0xfe, 0x90, 0xc4, 0x94, 0x30, 0xb4, 0x05,
+	0xf3, 0x7d, 0xdc, 0x26, 0x7d, 0x56, 0x06, 0x95, 0x6c, 0x75, 0xa1, 0xbe, 0x6a, 0xb9, 0x61, 0xcc,
+	0xc9, 0x30, 0x6a, 0x5b, 0x2f, 0x13, 0xff, 0x76, 0x07, 0x47, 0x9c, 0xc4, 0x0d, 0x35, 0xa9, 0xdf,
+	0x4e, 0xb9, 0xa8, 0x06, 0xf3, 0x6e, 0xa2, 0xcc, 0xca, 0x19, 0x11, 0x75, 0x77, 0x3a, 0x89, 0x6d,
+	0xcf, 0x8b, 0x45, 0xce, 0x69, 0x80, 0xa4, 0x99, 0xcf, 0xe1, 0xf2, 0x21, 0x8f, 0x09, 0xf6, 0x69,
+	0xe0, 0xfd, 0x4f, 0x66, 0xf3, 0x23, 0x2c, 0xcd, 0x09, 0x35, 0x30, 0x77, 0x7b, 0x49, 0x45, 0x4c,
+	0x98, 0xa9, 0xda, 0xda, 0xb4, 0xa2, 0x39, 0xb6, 0x9d, 0xd2, 0xd0, 0x16, 0x5c, 0xa3, 0xcc, 0x21,
+	0x41, 0xc7, 0x09, 0xbb, 0x8e, 0xf4, 0x39, 0x4c, 0x70, 0xc5, 0x1f, 0xd3, 0xec, 0x15, 0xca, 0x9a,
+	0x41, 0x67, 0xbf, 0x2b, 0xe3, 0xa4, 0x8c, 0x49, 0x66, 0xfa, 0x10, 0x7d, 0x32, 0x74, 0x1f, 0x2e,
+	0xa6, 0xe1, 0x34, 0xe8, 0x90, 0xa1, 0xb8, 0x1b, 0xaa, 0xbd, 0x20, 0x7d, 0x2f, 0x12, 0xd7, 0xbf,
+	0x8c, 0xab, 0x34, 0x97, 0xe6, 0x6f, 0xbb, 0x94, 0xec, 0x69, 0x97, 0xe6, 0x1e, 0x5c, 0x9b, 0x83,
+	0x9a, 0x8c, 0x53, 0x1f, 0x73, 0x82, 0xea, 0xf0, 0x1e, 0x49, 0xcf, 0x1d, 0x47, 0xe4, 0x75, 0xdc,
+	0x70, 0x10, 0xf0, 0xb4, 0x81, 0x95, 0x6b, 0x50, 0xc4, 0xed, 0x24, 0x90, 0xf9, 0x19, 0xc0, 0xe2,
+	0x75, 0xcd, 0x68, 0x1d, 0x6a, 0x3e, 0x0d, 0x1c, 0x4e, 0x7d, 0xb9, 0x11, 0x59, 0xbb, 0xe0, 0xd3,
+	0xe0, 0x88, 0xfa, 0x44, 0x40, 0x78, 0x28, 0xa1, 0x4c, 0x0a, 0xe1, 0xa1, 0x80, 0x1e, 0xc2, 0x6c,
+	0x8c, 0x4f, 0xca, 0xd9, 0x0a, 0xa8, 0x2e, 0xd4, 0x97, 0x6e, 0xac, 0x50, 0x3a, 0x85, 0x04, 0x6f,
+	0xa9, 0x9a, 0xaa, 0xe7, 0x5a, 0xaa, 0x96, 0xd3, 0xf3, 0x2d, 0x55, 0xcb, 0xeb, 0x85, 0x96, 0xaa,
+	0x15, 0x74, 0xad, 0xa5, 0x6a, 0x9a, 0x5e, 0x34, 0xbf, 0x01, 0xb8, 0x28, 0x6e, 0xc9, 0x5e, 0x32,
+	0x17, 0x12, 0xa3, 0xc7, 0x37, 0x36, 0x73, 0x7d, 0x2a, 0x3b, 0xcb, 0xb1, 0x8e, 0x46, 0x11, 0x49,
+	0x97, 0x13, 0x41, 0x35, 0xc0, 0x69, 0x6d, 0x45, 0x5b, 0x9c, 0x51, 0x09, 0xe6, 0x3e, 0xe0, 0xfe,
+	0x80, 0x88, 0xd2, 0x8a, 0xb6, 0x34, 0xcc, 0xf7, 0x50, 0x4d, 0xe2, 0x92, 0x0d, 0x9b, 0x15, 0x73,
+	0x9a, 0x07, 0xba, 0x82, 0x4a, 0x50, 0xbf, 0xe1, 0x7c, 0xd5, 0x3c, 0xd0, 0xc1, 0x2d, 0xaa, 0xdd,
+	0xd4, 0x33, 0xb7, 0xa9, 0x76, 0x53, 0xcf, 0x36, 0xb6, 0x4f, 0xc7, 0x86, 0x72, 0x36, 0x36, 0x94,
+	0xf3, 0xb1, 0xa1, 0x5c, 0x8d, 0x0d, 0xf0, 0x69, 0x62, 0x80, 0xaf, 0x13, 0x03, 0x9c, 0x4e, 0x0c,
+	0x70, 0x36, 0x31, 0xc0, 0xcf, 0x89, 0x01, 0x7e, 0x4d, 0x0c, 0xe5, 0x6a, 0x62, 0x80, 0x2f, 0x97,
+	0x86, 0x72, 0x76, 0x69, 0x28, 0xe7, 0x97, 0x86, 0xf2, 0xae, 0x90, 0xbe, 0x76, 0xed, 0xbc, 0x78,
+	0xa4, 0x9e, 0xfc, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x16, 0x22, 0xe5, 0x10, 0x05, 0x00, 0x00,
 }
 
 func (x Chunk_Encoding) String() string {
@@ -541,7 +542,7 @@ func (this *Series) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -578,7 +579,7 @@ func (this *StreamingSeries) Equal(that interface{}) bool {
 		return false
 	}
 	for i := range this.Labels {
-		if !this.Labels[i].Equal(that1.Labels[i]) {
+		if !this.Labels[i].Equal(&that1.Labels[i]) {
 			return false
 		}
 	}
@@ -778,7 +779,13 @@ func (this *Series) GoString() string {
 	}
 	s := make([]string, 0, 6)
 	s = append(s, "&storepb.Series{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	if this.Chunks != nil {
 		vs := make([]*AggrChunk, len(this.Chunks))
 		for i := range vs {
@@ -795,7 +802,13 @@ func (this *StreamingSeries) GoString() string {
 	}
 	s := make([]string, 0, 5)
 	s = append(s, "&storepb.StreamingSeries{")
-	s = append(s, "Labels: "+fmt.Sprintf("%#v", this.Labels)+",\n")
+	if this.Labels != nil {
+		vs := make([]*mimirpb.LabelAdapter, len(this.Labels))
+		for i := range vs {
+			vs[i] = &this.Labels[i]
+		}
+		s = append(s, "Labels: "+fmt.Sprintf("%#v", vs)+",\n")
+	}
 	s = append(s, "}")
 	return strings.Join(s, "")
 }
@@ -958,11 +971,11 @@ func (m *Series) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintTypes(dAtA, i, uint64(size))
 			}
 			i--
@@ -995,11 +1008,11 @@ func (m *StreamingSeries) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	if len(m.Labels) > 0 {
 		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
 			{
-				size := m.Labels[iNdEx].Size()
-				i -= size
-				if _, err := m.Labels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
+				size, err := m.Labels[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
 					return 0, err
 				}
+				i -= size
 				i = encodeVarintTypes(dAtA, i, uint64(size))
 			}
 			i--
@@ -1430,13 +1443,18 @@ func (this *Series) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	repeatedStringForChunks := "[]AggrChunk{"
 	for _, f := range this.Chunks {
 		repeatedStringForChunks += strings.Replace(strings.Replace(f.String(), "AggrChunk", "AggrChunk", 1), `&`, ``, 1) + ","
 	}
 	repeatedStringForChunks += "}"
 	s := strings.Join([]string{`&Series{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`Chunks:` + repeatedStringForChunks + `,`,
 		`}`,
 	}, "")
@@ -1446,8 +1464,13 @@ func (this *StreamingSeries) String() string {
 	if this == nil {
 		return "nil"
 	}
+	repeatedStringForLabels := "[]LabelAdapter{"
+	for _, f := range this.Labels {
+		repeatedStringForLabels += fmt.Sprintf("%v", f) + ","
+	}
+	repeatedStringForLabels += "}"
 	s := strings.Join([]string{`&StreamingSeries{`,
-		`Labels:` + fmt.Sprintf("%v", this.Labels) + `,`,
+		`Labels:` + repeatedStringForLabels + `,`,
 		`}`,
 	}, "")
 	return s
@@ -1704,7 +1727,7 @@ func (m *Series) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -1825,7 +1848,7 @@ func (m *StreamingSeries) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Labels = append(m.Labels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
+			m.Labels = append(m.Labels, mimirpb.LabelAdapter{})
 			if err := m.Labels[len(m.Labels)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/pkg/storegateway/storepb/types.proto b/pkg/storegateway/storepb/types.proto
index 0baeaf78d8a..b2b0df637f8 100644
--- a/pkg/storegateway/storepb/types.proto
+++ b/pkg/storegateway/storepb/types.proto
@@ -8,8 +8,8 @@ package thanos;
 
 option go_package = "storepb";
 
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
-import "github.com/grafana/mimir/pkg/mimirpb/mimir.proto";
+import "gogoproto/gogo.proto";
+import "pkg/mimirpb/mimir_custom_types.proto";
 
 option (gogoproto.sizer_all) = true;
 option (gogoproto.marshaler_all) = true;
@@ -33,12 +33,12 @@ message Chunk {
 }
 
 message Series {
-  repeated cortexpb.LabelPair labels      = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"];
+  repeated cortexpb.LabelAdapter labels      = 1 [(gogoproto.nullable) = false];
   repeated AggrChunk chunks  = 2 [(gogoproto.nullable) = false];
 }
 
 message StreamingSeries {
-  repeated cortexpb.LabelPair labels  = 1 [(gogoproto.nullable) = false, (gogoproto.customtype) = "github.com/grafana/mimir/pkg/mimirpb.LabelAdapter"];
+  repeated cortexpb.LabelAdapter labels  = 1 [(gogoproto.nullable) = false];
 }
 
 message StreamingSeriesBatch {
diff --git a/tools/apply-expected-diffs.sh b/tools/apply-expected-diffs.sh
index bfa66e6644e..98bf6adec34 100755
--- a/tools/apply-expected-diffs.sh
+++ b/tools/apply-expected-diffs.sh
@@ -20,7 +20,7 @@ function apply_expected_diffs {
         fi
 
         echo "$file: applying expected diff: $expdiff_file"
-        git apply -R "$expdiff_file"
+        git apply --allow-empty -R "$expdiff_file"
     done
 }