From 5d10c2a9d140cd3e4be0e18ed11d383b6fa75dcd Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <anton.e.kolesnikov@gmail.com>
Date: Mon, 19 Aug 2024 18:09:11 +0800
Subject: [PATCH] chore: refine metastore API (#3502)

---
 api/gen/proto/go/metastore/v1/metastore.pb.go | 335 +++++++++---------
 .../go/metastore/v1/metastore_vtproto.pb.go   | 255 +++++++++----
 .../metastorev1connect/metastore.connect.go   |  52 +--
 .../metastore.connect.mux.go                  |   6 +-
 api/metastore/v1/metastore.proto              |  19 +-
 api/openapiv2/gen/phlare.swagger.json         | 117 +++---
 .../index.md                                  |   7 +-
 pkg/experiment/compactor/compaction_worker.go |   2 +-
 pkg/experiment/ingester/segment.go            |   8 +-
 pkg/experiment/ingester/segment_test.go       |  50 +--
 .../metastore_state_query_metadata.go         | 148 ++++++++
 .../querybackend/block/compaction.go          |  92 ++---
 .../querybackend/block/constants.go           |   2 +-
 pkg/experiment/querybackend/block/object.go   |   4 +-
 .../querybackend/block/section_profiles.go    |  12 +-
 .../querybackend/block/section_symbols.go     |   2 +-
 .../querybackend/block/section_tsdb.go        |   2 +-
 .../querybackend/block/tenant_service.go      |  72 ++--
 .../block/testdata/block-metas.json           |  20 +-
 pkg/experiment/querybackend/block/writer.go   |   2 +-
 pkg/experiment/querybackend/block_reader.go   |  22 +-
 pkg/experiment/querybackend/query.go          |  12 +-
 .../querybackend/query_label_names.go         |   4 +-
 .../querybackend/query_label_values.go        |   4 +-
 .../querybackend/query_profile_entry.go       |   8 +-
 .../querybackend/query_series_labels.go       |   4 +-
 .../querybackend/query_time_series.go         |   4 +-
 pkg/experiment/querybackend/query_tree.go     |   6 +-
 pkg/experiment/queryfrontend/frontend_meta.go |   4 +-
 .../queryfrontend/frontend_profile_types.go   |   2 +-
 30 files changed, 777 insertions(+), 500 deletions(-)
 create mode 100644 pkg/experiment/metastore/metastore_state_query_metadata.go

diff --git a/api/gen/proto/go/metastore/v1/metastore.pb.go b/api/gen/proto/go/metastore/v1/metastore.pb.go
index 90dbbf42d0..0f2e7710d7 100644
--- a/api/gen/proto/go/metastore/v1/metastore.pb.go
+++ b/api/gen/proto/go/metastore/v1/metastore.pb.go
@@ -7,6 +7,7 @@
 package metastorev1
 
 import (
+	v1 "github.com/grafana/pyroscope/api/gen/proto/go/types/v1"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
@@ -117,10 +118,9 @@ type BlockMeta struct {
 	Shard           uint32 `protobuf:"varint,5,opt,name=shard,proto3" json:"shard,omitempty"`
 	CompactionLevel uint32 `protobuf:"varint,6,opt,name=compaction_level,json=compactionLevel,proto3" json:"compaction_level,omitempty"`
 	// Optional. Empty if compaction level is 0.
-	TenantId string `protobuf:"bytes,7,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
-	// TODO(kolesnikovae): Partitions with labels?
-	TenantServices []*TenantService `protobuf:"bytes,8,rep,name=tenant_services,json=tenantServices,proto3" json:"tenant_services,omitempty"`
-	Size           uint64           `protobuf:"varint,9,opt,name=size,proto3" json:"size,omitempty"`
+	TenantId string     `protobuf:"bytes,7,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
+	Datasets []*Dataset `protobuf:"bytes,8,rep,name=datasets,proto3" json:"datasets,omitempty"`
+	Size     uint64     `protobuf:"varint,9,opt,name=size,proto3" json:"size,omitempty"`
 }
 
 func (x *BlockMeta) Reset() {
@@ -204,9 +204,9 @@ func (x *BlockMeta) GetTenantId() string {
 	return ""
 }
 
-func (x *BlockMeta) GetTenantServices() []*TenantService {
+func (x *BlockMeta) GetDatasets() []*Dataset {
 	if x != nil {
-		return x.TenantServices
+		return x.Datasets
 	}
 	return nil
 }
@@ -218,17 +218,16 @@ func (x *BlockMeta) GetSize() uint64 {
 	return 0
 }
 
-// TenantService object points to the offset in the block at which
-// the tenant service data is located.
-type TenantService struct {
+type Dataset struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	TenantId string `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
-	Name     string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
-	MinTime  int64  `protobuf:"varint,3,opt,name=min_time,json=minTime,proto3" json:"min_time,omitempty"`
-	MaxTime  int64  `protobuf:"varint,4,opt,name=max_time,json=maxTime,proto3" json:"max_time,omitempty"`
+	Labels   []*v1.Labels `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty"`
+	TenantId string       `protobuf:"bytes,1,opt,name=tenant_id,json=tenantId,proto3" json:"tenant_id,omitempty"`
+	Name     string       `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	MinTime  int64        `protobuf:"varint,3,opt,name=min_time,json=minTime,proto3" json:"min_time,omitempty"`
+	MaxTime  int64        `protobuf:"varint,4,opt,name=max_time,json=maxTime,proto3" json:"max_time,omitempty"`
 	// Table of contents lists data sections within the tenant
 	// service region. The offsets are absolute.
 	//
@@ -240,12 +239,13 @@ type TenantService struct {
 	TableOfContents []uint64 `protobuf:"varint,5,rep,packed,name=table_of_contents,json=tableOfContents,proto3" json:"table_of_contents,omitempty"`
 	// Size of the section in bytes.
 	Size uint64 `protobuf:"varint,6,opt,name=size,proto3" json:"size,omitempty"`
+	// TODO: delete
 	// Profile types present in the tenant service data.
 	ProfileTypes []string `protobuf:"bytes,7,rep,name=profile_types,json=profileTypes,proto3" json:"profile_types,omitempty"`
 }
 
-func (x *TenantService) Reset() {
-	*x = TenantService{}
+func (x *Dataset) Reset() {
+	*x = Dataset{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_metastore_v1_metastore_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -253,13 +253,13 @@ func (x *TenantService) Reset() {
 	}
 }
 
-func (x *TenantService) String() string {
+func (x *Dataset) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*TenantService) ProtoMessage() {}
+func (*Dataset) ProtoMessage() {}
 
-func (x *TenantService) ProtoReflect() protoreflect.Message {
+func (x *Dataset) ProtoReflect() protoreflect.Message {
 	mi := &file_metastore_v1_metastore_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -271,61 +271,68 @@ func (x *TenantService) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use TenantService.ProtoReflect.Descriptor instead.
-func (*TenantService) Descriptor() ([]byte, []int) {
+// Deprecated: Use Dataset.ProtoReflect.Descriptor instead.
+func (*Dataset) Descriptor() ([]byte, []int) {
 	return file_metastore_v1_metastore_proto_rawDescGZIP(), []int{3}
 }
 
-func (x *TenantService) GetTenantId() string {
+func (x *Dataset) GetLabels() []*v1.Labels {
+	if x != nil {
+		return x.Labels
+	}
+	return nil
+}
+
+func (x *Dataset) GetTenantId() string {
 	if x != nil {
 		return x.TenantId
 	}
 	return ""
 }
 
-func (x *TenantService) GetName() string {
+func (x *Dataset) GetName() string {
 	if x != nil {
 		return x.Name
 	}
 	return ""
 }
 
-func (x *TenantService) GetMinTime() int64 {
+func (x *Dataset) GetMinTime() int64 {
 	if x != nil {
 		return x.MinTime
 	}
 	return 0
 }
 
-func (x *TenantService) GetMaxTime() int64 {
+func (x *Dataset) GetMaxTime() int64 {
 	if x != nil {
 		return x.MaxTime
 	}
 	return 0
 }
 
-func (x *TenantService) GetTableOfContents() []uint64 {
+func (x *Dataset) GetTableOfContents() []uint64 {
 	if x != nil {
 		return x.TableOfContents
 	}
 	return nil
 }
 
-func (x *TenantService) GetSize() uint64 {
+func (x *Dataset) GetSize() uint64 {
 	if x != nil {
 		return x.Size
 	}
 	return 0
 }
 
-func (x *TenantService) GetProfileTypes() []string {
+func (x *Dataset) GetProfileTypes() []string {
 	if x != nil {
 		return x.ProfileTypes
 	}
 	return nil
 }
 
-type ListBlocksForQueryRequest struct {
+type QueryMetadataRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -336,8 +343,8 @@ type ListBlocksForQueryRequest struct {
 	Query     string   `protobuf:"bytes,4,opt,name=query,proto3" json:"query,omitempty"`
 }
 
-func (x *ListBlocksForQueryRequest) Reset() {
-	*x = ListBlocksForQueryRequest{}
+func (x *QueryMetadataRequest) Reset() {
+	*x = QueryMetadataRequest{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_metastore_v1_metastore_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -345,13 +352,13 @@ func (x *ListBlocksForQueryRequest) Reset() {
 	}
 }
 
-func (x *ListBlocksForQueryRequest) String() string {
+func (x *QueryMetadataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ListBlocksForQueryRequest) ProtoMessage() {}
+func (*QueryMetadataRequest) ProtoMessage() {}
 
-func (x *ListBlocksForQueryRequest) ProtoReflect() protoreflect.Message {
+func (x *QueryMetadataRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_metastore_v1_metastore_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -363,40 +370,40 @@ func (x *ListBlocksForQueryRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use ListBlocksForQueryRequest.ProtoReflect.Descriptor instead.
-func (*ListBlocksForQueryRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use QueryMetadataRequest.ProtoReflect.Descriptor instead.
+func (*QueryMetadataRequest) Descriptor() ([]byte, []int) {
 	return file_metastore_v1_metastore_proto_rawDescGZIP(), []int{4}
 }
 
-func (x *ListBlocksForQueryRequest) GetTenantId() []string {
+func (x *QueryMetadataRequest) GetTenantId() []string {
 	if x != nil {
 		return x.TenantId
 	}
 	return nil
 }
 
-func (x *ListBlocksForQueryRequest) GetStartTime() int64 {
+func (x *QueryMetadataRequest) GetStartTime() int64 {
 	if x != nil {
 		return x.StartTime
 	}
 	return 0
 }
 
-func (x *ListBlocksForQueryRequest) GetEndTime() int64 {
+func (x *QueryMetadataRequest) GetEndTime() int64 {
 	if x != nil {
 		return x.EndTime
 	}
 	return 0
 }
 
-func (x *ListBlocksForQueryRequest) GetQuery() string {
+func (x *QueryMetadataRequest) GetQuery() string {
 	if x != nil {
 		return x.Query
 	}
 	return ""
 }
 
-type ListBlocksForQueryResponse struct {
+type QueryMetadataResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
@@ -404,8 +411,8 @@ type ListBlocksForQueryResponse struct {
 	Blocks []*BlockMeta `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
 }
 
-func (x *ListBlocksForQueryResponse) Reset() {
-	*x = ListBlocksForQueryResponse{}
+func (x *QueryMetadataResponse) Reset() {
+	*x = QueryMetadataResponse{}
 	if protoimpl.UnsafeEnabled {
 		mi := &file_metastore_v1_metastore_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -413,13 +420,13 @@ func (x *ListBlocksForQueryResponse) Reset() {
 	}
 }
 
-func (x *ListBlocksForQueryResponse) String() string {
+func (x *QueryMetadataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*ListBlocksForQueryResponse) ProtoMessage() {}
+func (*QueryMetadataResponse) ProtoMessage() {}
 
-func (x *ListBlocksForQueryResponse) ProtoReflect() protoreflect.Message {
+func (x *QueryMetadataResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_metastore_v1_metastore_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -431,12 +438,12 @@ func (x *ListBlocksForQueryResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use ListBlocksForQueryResponse.ProtoReflect.Descriptor instead.
-func (*ListBlocksForQueryResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use QueryMetadataResponse.ProtoReflect.Descriptor instead.
+func (*QueryMetadataResponse) Descriptor() ([]byte, []int) {
 	return file_metastore_v1_metastore_proto_rawDescGZIP(), []int{5}
 }
 
-func (x *ListBlocksForQueryResponse) GetBlocks() []*BlockMeta {
+func (x *QueryMetadataResponse) GetBlocks() []*BlockMeta {
 	if x != nil {
 		return x.Blocks
 	}
@@ -542,97 +549,97 @@ var File_metastore_v1_metastore_proto protoreflect.FileDescriptor
 var file_metastore_v1_metastore_proto_rawDesc = []byte{
 	0x0a, 0x1c, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6d,
 	0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c,
-	0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x22, 0x40, 0x0a, 0x0f,
-	0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x2d, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17,
-	0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c,
-	0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x12,
-	0x0a, 0x10, 0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0xb0, 0x02, 0x0a, 0x09, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61,
-	0x12, 0x25, 0x0a, 0x0e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69,
-	0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x69, 0x6e, 0x5f, 0x74,
-	0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x54, 0x69,
-	0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a,
-	0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x73, 0x68,
-	0x61, 0x72, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x63,
-	0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b,
-	0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x44, 0x0a, 0x0f, 0x74,
-	0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x08,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65,
-	0x2e, 0x76, 0x31, 0x2e, 0x54, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x52, 0x0e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
-	0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52,
-	0x04, 0x73, 0x69, 0x7a, 0x65, 0x22, 0xdb, 0x01, 0x0a, 0x0d, 0x54, 0x65, 0x6e, 0x61, 0x6e, 0x74,
-	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e,
-	0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61,
-	0x6e, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x69, 0x6e, 0x5f,
-	0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x54,
-	0x69, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2a,
-	0x0a, 0x11, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65,
-	0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65,
-	0x4f, 0x66, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69,
-	0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x23,
-	0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18,
-	0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x79,
-	0x70, 0x65, 0x73, 0x22, 0x88, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x73, 0x46, 0x6f, 0x72, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x1d,
-	0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x19, 0x0a,
-	0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52,
-	0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72,
-	0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0x4d,
-	0x0a, 0x1a, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x46, 0x6f, 0x72, 0x51,
-	0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d,
-	0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x06, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x22, 0x3c, 0x0a,
-	0x10, 0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x28, 0x0a, 0x10, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x64, 0x65, 0x62,
-	0x75, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x22, 0x32, 0x0a, 0x11, 0x52,
-	0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x72, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x32,
-	0x9a, 0x02, 0x0a, 0x10, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x53, 0x65, 0x72,
-	0x76, 0x69, 0x63, 0x65, 0x12, 0x4b, 0x0a, 0x08, 0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
-	0x12, 0x1d, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x1e, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41,
-	0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x00, 0x12, 0x69, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x46,
-	0x6f, 0x72, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x27, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74,
-	0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
-	0x73, 0x46, 0x6f, 0x72, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x28, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x46, 0x6f, 0x72, 0x51, 0x75, 0x65,
-	0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x09,
-	0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1e, 0x2e, 0x6d, 0x65, 0x74, 0x61,
-	0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x65, 0x74, 0x61,
-	0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xbb, 0x01, 0x0a,
-	0x10, 0x63, 0x6f, 0x6d, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76,
-	0x31, 0x42, 0x0e, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x74,
-	0x6f, 0x50, 0x01, 0x5a, 0x46, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
-	0x67, 0x72, 0x61, 0x66, 0x61, 0x6e, 0x61, 0x2f, 0x70, 0x79, 0x72, 0x6f, 0x73, 0x63, 0x6f, 0x70,
-	0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
-	0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x76, 0x31, 0x3b,
-	0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4d, 0x58,
-	0x58, 0xaa, 0x02, 0x0c, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x31,
-	0xca, 0x02, 0x0c, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5c, 0x56, 0x31, 0xe2,
-	0x02, 0x18, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5c, 0x56, 0x31, 0x5c, 0x47,
-	0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0d, 0x4d, 0x65, 0x74,
-	0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x33,
+	0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x14, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x22, 0x40, 0x0a, 0x0f, 0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65,
+	0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x05, 0x62,
+	0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x12, 0x0a, 0x10, 0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9d, 0x02, 0x0a, 0x09, 0x42, 0x6c, 0x6f,
+	0x63, 0x6b, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
+	0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d,
+	0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a,
+	0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a,
+	0x08, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52,
+	0x07, 0x6d, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61, 0x78, 0x5f,
+	0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61, 0x78, 0x54,
+	0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x63, 0x6f, 0x6d,
+	0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20,
+	0x01, 0x28, 0x0d, 0x52, 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c,
+	0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x69,
+	0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x49,
+	0x64, 0x12, 0x31, 0x0a, 0x08, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x18, 0x08, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e,
+	0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61,
+	0x73, 0x65, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x09, 0x20, 0x01,
+	0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x22, 0xff, 0x01, 0x0a, 0x07, 0x44, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x18, 0x08,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x76, 0x31, 0x2e,
+	0x4c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x52, 0x06, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x73, 0x12, 0x1b,
+	0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e,
+	0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
+	0x19, 0x0a, 0x08, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x61,
+	0x78, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x61,
+	0x78, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6f,
+	0x66, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x04,
+	0x52, 0x0f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x66, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,
+	0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65,
+	0x5f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72,
+	0x6f, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x79, 0x70, 0x65, 0x73, 0x22, 0x83, 0x01, 0x0a, 0x14, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x5f, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x49, 0x64,
+	0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12,
+	0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75,
+	0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79,
+	0x22, 0x48, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+	0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x62, 0x6c, 0x6f,
+	0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x65, 0x74, 0x61,
+	0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4d, 0x65,
+	0x74, 0x61, 0x52, 0x06, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x22, 0x3c, 0x0a, 0x10, 0x52, 0x65,
+	0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28,
+	0x0a, 0x10, 0x64, 0x65, 0x62, 0x75, 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x64, 0x65, 0x62, 0x75, 0x67, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x22, 0x32, 0x0a, 0x11, 0x52, 0x65, 0x61, 0x64,
+	0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a,
+	0x0a, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x09, 0x72, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x32, 0x8b, 0x02, 0x0a,
+	0x10, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x12, 0x4b, 0x0a, 0x08, 0x41, 0x64, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x2e,
+	0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x64, 0x64,
+	0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6d,
+	0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x64, 0x64, 0x42,
+	0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a,
+	0x0a, 0x0d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12,
+	0x22, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x51,
+	0x75, 0x65, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e,
+	0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x09, 0x52, 0x65,
+	0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1e, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74,
+	0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74,
+	0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0xbb, 0x01, 0x0a, 0x10, 0x63,
+	0x6f, 0x6d, 0x2e, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x42,
+	0x0e, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50,
+	0x01, 0x5a, 0x46, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72,
+	0x61, 0x66, 0x61, 0x6e, 0x61, 0x2f, 0x70, 0x79, 0x72, 0x6f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x2f,
+	0x61, 0x70, 0x69, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f,
+	0x2f, 0x6d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x65,
+	0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4d, 0x58, 0x58, 0xaa,
+	0x02, 0x0c, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02,
+	0x0c, 0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x18,
+	0x4d, 0x65, 0x74, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x0d, 0x4d, 0x65, 0x74, 0x61, 0x73,
+	0x74, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -649,30 +656,32 @@ func file_metastore_v1_metastore_proto_rawDescGZIP() []byte {
 
 var file_metastore_v1_metastore_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
 var file_metastore_v1_metastore_proto_goTypes = []any{
-	(*AddBlockRequest)(nil),            // 0: metastore.v1.AddBlockRequest
-	(*AddBlockResponse)(nil),           // 1: metastore.v1.AddBlockResponse
-	(*BlockMeta)(nil),                  // 2: metastore.v1.BlockMeta
-	(*TenantService)(nil),              // 3: metastore.v1.TenantService
-	(*ListBlocksForQueryRequest)(nil),  // 4: metastore.v1.ListBlocksForQueryRequest
-	(*ListBlocksForQueryResponse)(nil), // 5: metastore.v1.ListBlocksForQueryResponse
-	(*ReadIndexRequest)(nil),           // 6: metastore.v1.ReadIndexRequest
-	(*ReadIndexResponse)(nil),          // 7: metastore.v1.ReadIndexResponse
+	(*AddBlockRequest)(nil),       // 0: metastore.v1.AddBlockRequest
+	(*AddBlockResponse)(nil),      // 1: metastore.v1.AddBlockResponse
+	(*BlockMeta)(nil),             // 2: metastore.v1.BlockMeta
+	(*Dataset)(nil),               // 3: metastore.v1.Dataset
+	(*QueryMetadataRequest)(nil),  // 4: metastore.v1.QueryMetadataRequest
+	(*QueryMetadataResponse)(nil), // 5: metastore.v1.QueryMetadataResponse
+	(*ReadIndexRequest)(nil),      // 6: metastore.v1.ReadIndexRequest
+	(*ReadIndexResponse)(nil),     // 7: metastore.v1.ReadIndexResponse
+	(*v1.Labels)(nil),             // 8: types.v1.Labels
 }
 var file_metastore_v1_metastore_proto_depIdxs = []int32{
 	2, // 0: metastore.v1.AddBlockRequest.block:type_name -> metastore.v1.BlockMeta
-	3, // 1: metastore.v1.BlockMeta.tenant_services:type_name -> metastore.v1.TenantService
-	2, // 2: metastore.v1.ListBlocksForQueryResponse.blocks:type_name -> metastore.v1.BlockMeta
-	0, // 3: metastore.v1.MetastoreService.AddBlock:input_type -> metastore.v1.AddBlockRequest
-	4, // 4: metastore.v1.MetastoreService.ListBlocksForQuery:input_type -> metastore.v1.ListBlocksForQueryRequest
-	6, // 5: metastore.v1.MetastoreService.ReadIndex:input_type -> metastore.v1.ReadIndexRequest
-	1, // 6: metastore.v1.MetastoreService.AddBlock:output_type -> metastore.v1.AddBlockResponse
-	5, // 7: metastore.v1.MetastoreService.ListBlocksForQuery:output_type -> metastore.v1.ListBlocksForQueryResponse
-	7, // 8: metastore.v1.MetastoreService.ReadIndex:output_type -> metastore.v1.ReadIndexResponse
-	6, // [6:9] is the sub-list for method output_type
-	3, // [3:6] is the sub-list for method input_type
-	3, // [3:3] is the sub-list for extension type_name
-	3, // [3:3] is the sub-list for extension extendee
-	0, // [0:3] is the sub-list for field type_name
+	3, // 1: metastore.v1.BlockMeta.datasets:type_name -> metastore.v1.Dataset
+	8, // 2: metastore.v1.Dataset.labels:type_name -> types.v1.Labels
+	2, // 3: metastore.v1.QueryMetadataResponse.blocks:type_name -> metastore.v1.BlockMeta
+	0, // 4: metastore.v1.MetastoreService.AddBlock:input_type -> metastore.v1.AddBlockRequest
+	4, // 5: metastore.v1.MetastoreService.QueryMetadata:input_type -> metastore.v1.QueryMetadataRequest
+	6, // 6: metastore.v1.MetastoreService.ReadIndex:input_type -> metastore.v1.ReadIndexRequest
+	1, // 7: metastore.v1.MetastoreService.AddBlock:output_type -> metastore.v1.AddBlockResponse
+	5, // 8: metastore.v1.MetastoreService.QueryMetadata:output_type -> metastore.v1.QueryMetadataResponse
+	7, // 9: metastore.v1.MetastoreService.ReadIndex:output_type -> metastore.v1.ReadIndexResponse
+	7, // [7:10] is the sub-list for method output_type
+	4, // [4:7] is the sub-list for method input_type
+	4, // [4:4] is the sub-list for extension type_name
+	4, // [4:4] is the sub-list for extension extendee
+	0, // [0:4] is the sub-list for field type_name
 }
 
 func init() { file_metastore_v1_metastore_proto_init() }
@@ -718,7 +727,7 @@ func file_metastore_v1_metastore_proto_init() {
 			}
 		}
 		file_metastore_v1_metastore_proto_msgTypes[3].Exporter = func(v any, i int) any {
-			switch v := v.(*TenantService); i {
+			switch v := v.(*Dataset); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -730,7 +739,7 @@ func file_metastore_v1_metastore_proto_init() {
 			}
 		}
 		file_metastore_v1_metastore_proto_msgTypes[4].Exporter = func(v any, i int) any {
-			switch v := v.(*ListBlocksForQueryRequest); i {
+			switch v := v.(*QueryMetadataRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -742,7 +751,7 @@ func file_metastore_v1_metastore_proto_init() {
 			}
 		}
 		file_metastore_v1_metastore_proto_msgTypes[5].Exporter = func(v any, i int) any {
-			switch v := v.(*ListBlocksForQueryResponse); i {
+			switch v := v.(*QueryMetadataResponse); i {
 			case 0:
 				return &v.state
 			case 1:
diff --git a/api/gen/proto/go/metastore/v1/metastore_vtproto.pb.go b/api/gen/proto/go/metastore/v1/metastore_vtproto.pb.go
index 809156debf..fca443b263 100644
--- a/api/gen/proto/go/metastore/v1/metastore_vtproto.pb.go
+++ b/api/gen/proto/go/metastore/v1/metastore_vtproto.pb.go
@@ -7,6 +7,7 @@ package metastorev1
 import (
 	context "context"
 	fmt "fmt"
+	v1 "github.com/grafana/pyroscope/api/gen/proto/go/types/v1"
 	protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -69,12 +70,12 @@ func (m *BlockMeta) CloneVT() *BlockMeta {
 	r.CompactionLevel = m.CompactionLevel
 	r.TenantId = m.TenantId
 	r.Size = m.Size
-	if rhs := m.TenantServices; rhs != nil {
-		tmpContainer := make([]*TenantService, len(rhs))
+	if rhs := m.Datasets; rhs != nil {
+		tmpContainer := make([]*Dataset, len(rhs))
 		for k, v := range rhs {
 			tmpContainer[k] = v.CloneVT()
 		}
-		r.TenantServices = tmpContainer
+		r.Datasets = tmpContainer
 	}
 	if len(m.unknownFields) > 0 {
 		r.unknownFields = make([]byte, len(m.unknownFields))
@@ -87,16 +88,27 @@ func (m *BlockMeta) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
-func (m *TenantService) CloneVT() *TenantService {
+func (m *Dataset) CloneVT() *Dataset {
 	if m == nil {
-		return (*TenantService)(nil)
+		return (*Dataset)(nil)
 	}
-	r := new(TenantService)
+	r := new(Dataset)
 	r.TenantId = m.TenantId
 	r.Name = m.Name
 	r.MinTime = m.MinTime
 	r.MaxTime = m.MaxTime
 	r.Size = m.Size
+	if rhs := m.Labels; rhs != nil {
+		tmpContainer := make([]*v1.Labels, len(rhs))
+		for k, v := range rhs {
+			if vtpb, ok := interface{}(v).(interface{ CloneVT() *v1.Labels }); ok {
+				tmpContainer[k] = vtpb.CloneVT()
+			} else {
+				tmpContainer[k] = proto.Clone(v).(*v1.Labels)
+			}
+		}
+		r.Labels = tmpContainer
+	}
 	if rhs := m.TableOfContents; rhs != nil {
 		tmpContainer := make([]uint64, len(rhs))
 		copy(tmpContainer, rhs)
@@ -114,15 +126,15 @@ func (m *TenantService) CloneVT() *TenantService {
 	return r
 }
 
-func (m *TenantService) CloneMessageVT() proto.Message {
+func (m *Dataset) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
-func (m *ListBlocksForQueryRequest) CloneVT() *ListBlocksForQueryRequest {
+func (m *QueryMetadataRequest) CloneVT() *QueryMetadataRequest {
 	if m == nil {
-		return (*ListBlocksForQueryRequest)(nil)
+		return (*QueryMetadataRequest)(nil)
 	}
-	r := new(ListBlocksForQueryRequest)
+	r := new(QueryMetadataRequest)
 	r.StartTime = m.StartTime
 	r.EndTime = m.EndTime
 	r.Query = m.Query
@@ -138,15 +150,15 @@ func (m *ListBlocksForQueryRequest) CloneVT() *ListBlocksForQueryRequest {
 	return r
 }
 
-func (m *ListBlocksForQueryRequest) CloneMessageVT() proto.Message {
+func (m *QueryMetadataRequest) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
-func (m *ListBlocksForQueryResponse) CloneVT() *ListBlocksForQueryResponse {
+func (m *QueryMetadataResponse) CloneVT() *QueryMetadataResponse {
 	if m == nil {
-		return (*ListBlocksForQueryResponse)(nil)
+		return (*QueryMetadataResponse)(nil)
 	}
-	r := new(ListBlocksForQueryResponse)
+	r := new(QueryMetadataResponse)
 	if rhs := m.Blocks; rhs != nil {
 		tmpContainer := make([]*BlockMeta, len(rhs))
 		for k, v := range rhs {
@@ -161,7 +173,7 @@ func (m *ListBlocksForQueryResponse) CloneVT() *ListBlocksForQueryResponse {
 	return r
 }
 
-func (m *ListBlocksForQueryResponse) CloneMessageVT() proto.Message {
+func (m *QueryMetadataResponse) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
@@ -261,17 +273,17 @@ func (this *BlockMeta) EqualVT(that *BlockMeta) bool {
 	if this.TenantId != that.TenantId {
 		return false
 	}
-	if len(this.TenantServices) != len(that.TenantServices) {
+	if len(this.Datasets) != len(that.Datasets) {
 		return false
 	}
-	for i, vx := range this.TenantServices {
-		vy := that.TenantServices[i]
+	for i, vx := range this.Datasets {
+		vy := that.Datasets[i]
 		if p, q := vx, vy; p != q {
 			if p == nil {
-				p = &TenantService{}
+				p = &Dataset{}
 			}
 			if q == nil {
-				q = &TenantService{}
+				q = &Dataset{}
 			}
 			if !p.EqualVT(q) {
 				return false
@@ -291,7 +303,7 @@ func (this *BlockMeta) EqualMessageVT(thatMsg proto.Message) bool {
 	}
 	return this.EqualVT(that)
 }
-func (this *TenantService) EqualVT(that *TenantService) bool {
+func (this *Dataset) EqualVT(that *Dataset) bool {
 	if this == that {
 		return true
 	} else if this == nil || that == nil {
@@ -330,17 +342,38 @@ func (this *TenantService) EqualVT(that *TenantService) bool {
 			return false
 		}
 	}
+	if len(this.Labels) != len(that.Labels) {
+		return false
+	}
+	for i, vx := range this.Labels {
+		vy := that.Labels[i]
+		if p, q := vx, vy; p != q {
+			if p == nil {
+				p = &v1.Labels{}
+			}
+			if q == nil {
+				q = &v1.Labels{}
+			}
+			if equal, ok := interface{}(p).(interface{ EqualVT(*v1.Labels) bool }); ok {
+				if !equal.EqualVT(q) {
+					return false
+				}
+			} else if !proto.Equal(p, q) {
+				return false
+			}
+		}
+	}
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
-func (this *TenantService) EqualMessageVT(thatMsg proto.Message) bool {
-	that, ok := thatMsg.(*TenantService)
+func (this *Dataset) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Dataset)
 	if !ok {
 		return false
 	}
 	return this.EqualVT(that)
 }
-func (this *ListBlocksForQueryRequest) EqualVT(that *ListBlocksForQueryRequest) bool {
+func (this *QueryMetadataRequest) EqualVT(that *QueryMetadataRequest) bool {
 	if this == that {
 		return true
 	} else if this == nil || that == nil {
@@ -367,14 +400,14 @@ func (this *ListBlocksForQueryRequest) EqualVT(that *ListBlocksForQueryRequest)
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
-func (this *ListBlocksForQueryRequest) EqualMessageVT(thatMsg proto.Message) bool {
-	that, ok := thatMsg.(*ListBlocksForQueryRequest)
+func (this *QueryMetadataRequest) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*QueryMetadataRequest)
 	if !ok {
 		return false
 	}
 	return this.EqualVT(that)
 }
-func (this *ListBlocksForQueryResponse) EqualVT(that *ListBlocksForQueryResponse) bool {
+func (this *QueryMetadataResponse) EqualVT(that *QueryMetadataResponse) bool {
 	if this == that {
 		return true
 	} else if this == nil || that == nil {
@@ -400,8 +433,8 @@ func (this *ListBlocksForQueryResponse) EqualVT(that *ListBlocksForQueryResponse
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
-func (this *ListBlocksForQueryResponse) EqualMessageVT(thatMsg proto.Message) bool {
-	that, ok := thatMsg.(*ListBlocksForQueryResponse)
+func (this *QueryMetadataResponse) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*QueryMetadataResponse)
 	if !ok {
 		return false
 	}
@@ -456,7 +489,7 @@ const _ = grpc.SupportPackageIsVersion7
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type MetastoreServiceClient interface {
 	AddBlock(ctx context.Context, in *AddBlockRequest, opts ...grpc.CallOption) (*AddBlockResponse, error)
-	ListBlocksForQuery(ctx context.Context, in *ListBlocksForQueryRequest, opts ...grpc.CallOption) (*ListBlocksForQueryResponse, error)
+	QueryMetadata(ctx context.Context, in *QueryMetadataRequest, opts ...grpc.CallOption) (*QueryMetadataResponse, error)
 	ReadIndex(ctx context.Context, in *ReadIndexRequest, opts ...grpc.CallOption) (*ReadIndexResponse, error)
 }
 
@@ -477,9 +510,9 @@ func (c *metastoreServiceClient) AddBlock(ctx context.Context, in *AddBlockReque
 	return out, nil
 }
 
-func (c *metastoreServiceClient) ListBlocksForQuery(ctx context.Context, in *ListBlocksForQueryRequest, opts ...grpc.CallOption) (*ListBlocksForQueryResponse, error) {
-	out := new(ListBlocksForQueryResponse)
-	err := c.cc.Invoke(ctx, "/metastore.v1.MetastoreService/ListBlocksForQuery", in, out, opts...)
+func (c *metastoreServiceClient) QueryMetadata(ctx context.Context, in *QueryMetadataRequest, opts ...grpc.CallOption) (*QueryMetadataResponse, error) {
+	out := new(QueryMetadataResponse)
+	err := c.cc.Invoke(ctx, "/metastore.v1.MetastoreService/QueryMetadata", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -500,7 +533,7 @@ func (c *metastoreServiceClient) ReadIndex(ctx context.Context, in *ReadIndexReq
 // for forward compatibility
 type MetastoreServiceServer interface {
 	AddBlock(context.Context, *AddBlockRequest) (*AddBlockResponse, error)
-	ListBlocksForQuery(context.Context, *ListBlocksForQueryRequest) (*ListBlocksForQueryResponse, error)
+	QueryMetadata(context.Context, *QueryMetadataRequest) (*QueryMetadataResponse, error)
 	ReadIndex(context.Context, *ReadIndexRequest) (*ReadIndexResponse, error)
 	mustEmbedUnimplementedMetastoreServiceServer()
 }
@@ -512,8 +545,8 @@ type UnimplementedMetastoreServiceServer struct {
 func (UnimplementedMetastoreServiceServer) AddBlock(context.Context, *AddBlockRequest) (*AddBlockResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method AddBlock not implemented")
 }
-func (UnimplementedMetastoreServiceServer) ListBlocksForQuery(context.Context, *ListBlocksForQueryRequest) (*ListBlocksForQueryResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListBlocksForQuery not implemented")
+func (UnimplementedMetastoreServiceServer) QueryMetadata(context.Context, *QueryMetadataRequest) (*QueryMetadataResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method QueryMetadata not implemented")
 }
 func (UnimplementedMetastoreServiceServer) ReadIndex(context.Context, *ReadIndexRequest) (*ReadIndexResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ReadIndex not implemented")
@@ -549,20 +582,20 @@ func _MetastoreService_AddBlock_Handler(srv interface{}, ctx context.Context, de
 	return interceptor(ctx, in, info, handler)
 }
 
-func _MetastoreService_ListBlocksForQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListBlocksForQueryRequest)
+func _MetastoreService_QueryMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryMetadataRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MetastoreServiceServer).ListBlocksForQuery(ctx, in)
+		return srv.(MetastoreServiceServer).QueryMetadata(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/metastore.v1.MetastoreService/ListBlocksForQuery",
+		FullMethod: "/metastore.v1.MetastoreService/QueryMetadata",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MetastoreServiceServer).ListBlocksForQuery(ctx, req.(*ListBlocksForQueryRequest))
+		return srv.(MetastoreServiceServer).QueryMetadata(ctx, req.(*QueryMetadataRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -597,8 +630,8 @@ var MetastoreService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _MetastoreService_AddBlock_Handler,
 		},
 		{
-			MethodName: "ListBlocksForQuery",
-			Handler:    _MetastoreService_ListBlocksForQuery_Handler,
+			MethodName: "QueryMetadata",
+			Handler:    _MetastoreService_QueryMetadata_Handler,
 		},
 		{
 			MethodName: "ReadIndex",
@@ -720,9 +753,9 @@ func (m *BlockMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x48
 	}
-	if len(m.TenantServices) > 0 {
-		for iNdEx := len(m.TenantServices) - 1; iNdEx >= 0; iNdEx-- {
-			size, err := m.TenantServices[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
+	if len(m.Datasets) > 0 {
+		for iNdEx := len(m.Datasets) - 1; iNdEx >= 0; iNdEx-- {
+			size, err := m.Datasets[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -774,7 +807,7 @@ func (m *BlockMeta) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *TenantService) MarshalVT() (dAtA []byte, err error) {
+func (m *Dataset) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -787,12 +820,12 @@ func (m *TenantService) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *TenantService) MarshalToVT(dAtA []byte) (int, error) {
+func (m *Dataset) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *TenantService) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *Dataset) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -804,6 +837,30 @@ func (m *TenantService) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 		i -= len(m.unknownFields)
 		copy(dAtA[i:], m.unknownFields)
 	}
+	if len(m.Labels) > 0 {
+		for iNdEx := len(m.Labels) - 1; iNdEx >= 0; iNdEx-- {
+			if vtmsg, ok := interface{}(m.Labels[iNdEx]).(interface {
+				MarshalToSizedBufferVT([]byte) (int, error)
+			}); ok {
+				size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
+			} else {
+				encoded, err := proto.Marshal(m.Labels[iNdEx])
+				if err != nil {
+					return 0, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = protohelpers.EncodeVarint(dAtA, i, uint64(len(encoded)))
+			}
+			i--
+			dAtA[i] = 0x42
+		}
+	}
 	if len(m.ProfileTypes) > 0 {
 		for iNdEx := len(m.ProfileTypes) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.ProfileTypes[iNdEx])
@@ -865,7 +922,7 @@ func (m *TenantService) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ListBlocksForQueryRequest) MarshalVT() (dAtA []byte, err error) {
+func (m *QueryMetadataRequest) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -878,12 +935,12 @@ func (m *ListBlocksForQueryRequest) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListBlocksForQueryRequest) MarshalToVT(dAtA []byte) (int, error) {
+func (m *QueryMetadataRequest) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *ListBlocksForQueryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *QueryMetadataRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -924,7 +981,7 @@ func (m *ListBlocksForQueryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }
 
-func (m *ListBlocksForQueryResponse) MarshalVT() (dAtA []byte, err error) {
+func (m *QueryMetadataResponse) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
 	}
@@ -937,12 +994,12 @@ func (m *ListBlocksForQueryResponse) MarshalVT() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ListBlocksForQueryResponse) MarshalToVT(dAtA []byte) (int, error) {
+func (m *QueryMetadataResponse) MarshalToVT(dAtA []byte) (int, error) {
 	size := m.SizeVT()
 	return m.MarshalToSizedBufferVT(dAtA[:size])
 }
 
-func (m *ListBlocksForQueryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+func (m *QueryMetadataResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	if m == nil {
 		return 0, nil
 	}
@@ -1100,8 +1157,8 @@ func (m *BlockMeta) SizeVT() (n int) {
 	if l > 0 {
 		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
 	}
-	if len(m.TenantServices) > 0 {
-		for _, e := range m.TenantServices {
+	if len(m.Datasets) > 0 {
+		for _, e := range m.Datasets {
 			l = e.SizeVT()
 			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
 		}
@@ -1113,7 +1170,7 @@ func (m *BlockMeta) SizeVT() (n int) {
 	return n
 }
 
-func (m *TenantService) SizeVT() (n int) {
+func (m *Dataset) SizeVT() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1149,11 +1206,23 @@ func (m *TenantService) SizeVT() (n int) {
 			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
 		}
 	}
+	if len(m.Labels) > 0 {
+		for _, e := range m.Labels {
+			if size, ok := interface{}(e).(interface {
+				SizeVT() int
+			}); ok {
+				l = size.SizeVT()
+			} else {
+				l = proto.Size(e)
+			}
+			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
+		}
+	}
 	n += len(m.unknownFields)
 	return n
 }
 
-func (m *ListBlocksForQueryRequest) SizeVT() (n int) {
+func (m *QueryMetadataRequest) SizeVT() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1179,7 +1248,7 @@ func (m *ListBlocksForQueryRequest) SizeVT() (n int) {
 	return n
 }
 
-func (m *ListBlocksForQueryResponse) SizeVT() (n int) {
+func (m *QueryMetadataResponse) SizeVT() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1550,7 +1619,7 @@ func (m *BlockMeta) UnmarshalVT(dAtA []byte) error {
 			iNdEx = postIndex
 		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TenantServices", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Datasets", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -1577,8 +1646,8 @@ func (m *BlockMeta) UnmarshalVT(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TenantServices = append(m.TenantServices, &TenantService{})
-			if err := m.TenantServices[len(m.TenantServices)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+			m.Datasets = append(m.Datasets, &Dataset{})
+			if err := m.Datasets[len(m.Datasets)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1623,7 +1692,7 @@ func (m *BlockMeta) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *TenantService) UnmarshalVT(dAtA []byte) error {
+func (m *Dataset) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1646,10 +1715,10 @@ func (m *TenantService) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: TenantService: wiretype end group for non-group")
+			return fmt.Errorf("proto: Dataset: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TenantService: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Dataset: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1881,6 +1950,48 @@ func (m *TenantService) UnmarshalVT(dAtA []byte) error {
 			}
 			m.ProfileTypes = append(m.ProfileTypes, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return protohelpers.ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return protohelpers.ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Labels = append(m.Labels, &v1.Labels{})
+			if unmarshal, ok := interface{}(m.Labels[len(m.Labels)-1]).(interface {
+				UnmarshalVT([]byte) error
+			}); ok {
+				if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+					return err
+				}
+			} else {
+				if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Labels[len(m.Labels)-1]); err != nil {
+					return err
+				}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
@@ -1903,7 +2014,7 @@ func (m *TenantService) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListBlocksForQueryRequest) UnmarshalVT(dAtA []byte) error {
+func (m *QueryMetadataRequest) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1926,10 +2037,10 @@ func (m *ListBlocksForQueryRequest) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListBlocksForQueryRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMetadataRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListBlocksForQueryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -2056,7 +2167,7 @@ func (m *ListBlocksForQueryRequest) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ListBlocksForQueryResponse) UnmarshalVT(dAtA []byte) error {
+func (m *QueryMetadataResponse) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2079,10 +2190,10 @@ func (m *ListBlocksForQueryResponse) UnmarshalVT(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ListBlocksForQueryResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryMetadataResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ListBlocksForQueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
diff --git a/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.go b/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.go
index 8a55af7551..9fd81df27d 100644
--- a/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.go
+++ b/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.go
@@ -36,9 +36,9 @@ const (
 	// MetastoreServiceAddBlockProcedure is the fully-qualified name of the MetastoreService's AddBlock
 	// RPC.
 	MetastoreServiceAddBlockProcedure = "/metastore.v1.MetastoreService/AddBlock"
-	// MetastoreServiceListBlocksForQueryProcedure is the fully-qualified name of the MetastoreService's
-	// ListBlocksForQuery RPC.
-	MetastoreServiceListBlocksForQueryProcedure = "/metastore.v1.MetastoreService/ListBlocksForQuery"
+	// MetastoreServiceQueryMetadataProcedure is the fully-qualified name of the MetastoreService's
+	// QueryMetadata RPC.
+	MetastoreServiceQueryMetadataProcedure = "/metastore.v1.MetastoreService/QueryMetadata"
 	// MetastoreServiceReadIndexProcedure is the fully-qualified name of the MetastoreService's
 	// ReadIndex RPC.
 	MetastoreServiceReadIndexProcedure = "/metastore.v1.MetastoreService/ReadIndex"
@@ -46,16 +46,16 @@ const (
 
 // These variables are the protoreflect.Descriptor objects for the RPCs defined in this package.
 var (
-	metastoreServiceServiceDescriptor                  = v1.File_metastore_v1_metastore_proto.Services().ByName("MetastoreService")
-	metastoreServiceAddBlockMethodDescriptor           = metastoreServiceServiceDescriptor.Methods().ByName("AddBlock")
-	metastoreServiceListBlocksForQueryMethodDescriptor = metastoreServiceServiceDescriptor.Methods().ByName("ListBlocksForQuery")
-	metastoreServiceReadIndexMethodDescriptor          = metastoreServiceServiceDescriptor.Methods().ByName("ReadIndex")
+	metastoreServiceServiceDescriptor             = v1.File_metastore_v1_metastore_proto.Services().ByName("MetastoreService")
+	metastoreServiceAddBlockMethodDescriptor      = metastoreServiceServiceDescriptor.Methods().ByName("AddBlock")
+	metastoreServiceQueryMetadataMethodDescriptor = metastoreServiceServiceDescriptor.Methods().ByName("QueryMetadata")
+	metastoreServiceReadIndexMethodDescriptor     = metastoreServiceServiceDescriptor.Methods().ByName("ReadIndex")
 )
 
 // MetastoreServiceClient is a client for the metastore.v1.MetastoreService service.
 type MetastoreServiceClient interface {
 	AddBlock(context.Context, *connect.Request[v1.AddBlockRequest]) (*connect.Response[v1.AddBlockResponse], error)
-	ListBlocksForQuery(context.Context, *connect.Request[v1.ListBlocksForQueryRequest]) (*connect.Response[v1.ListBlocksForQueryResponse], error)
+	QueryMetadata(context.Context, *connect.Request[v1.QueryMetadataRequest]) (*connect.Response[v1.QueryMetadataResponse], error)
 	ReadIndex(context.Context, *connect.Request[v1.ReadIndexRequest]) (*connect.Response[v1.ReadIndexResponse], error)
 }
 
@@ -75,10 +75,10 @@ func NewMetastoreServiceClient(httpClient connect.HTTPClient, baseURL string, op
 			connect.WithSchema(metastoreServiceAddBlockMethodDescriptor),
 			connect.WithClientOptions(opts...),
 		),
-		listBlocksForQuery: connect.NewClient[v1.ListBlocksForQueryRequest, v1.ListBlocksForQueryResponse](
+		queryMetadata: connect.NewClient[v1.QueryMetadataRequest, v1.QueryMetadataResponse](
 			httpClient,
-			baseURL+MetastoreServiceListBlocksForQueryProcedure,
-			connect.WithSchema(metastoreServiceListBlocksForQueryMethodDescriptor),
+			baseURL+MetastoreServiceQueryMetadataProcedure,
+			connect.WithSchema(metastoreServiceQueryMetadataMethodDescriptor),
 			connect.WithClientOptions(opts...),
 		),
 		readIndex: connect.NewClient[v1.ReadIndexRequest, v1.ReadIndexResponse](
@@ -92,9 +92,9 @@ func NewMetastoreServiceClient(httpClient connect.HTTPClient, baseURL string, op
 
 // metastoreServiceClient implements MetastoreServiceClient.
 type metastoreServiceClient struct {
-	addBlock           *connect.Client[v1.AddBlockRequest, v1.AddBlockResponse]
-	listBlocksForQuery *connect.Client[v1.ListBlocksForQueryRequest, v1.ListBlocksForQueryResponse]
-	readIndex          *connect.Client[v1.ReadIndexRequest, v1.ReadIndexResponse]
+	addBlock      *connect.Client[v1.AddBlockRequest, v1.AddBlockResponse]
+	queryMetadata *connect.Client[v1.QueryMetadataRequest, v1.QueryMetadataResponse]
+	readIndex     *connect.Client[v1.ReadIndexRequest, v1.ReadIndexResponse]
 }
 
 // AddBlock calls metastore.v1.MetastoreService.AddBlock.
@@ -102,9 +102,9 @@ func (c *metastoreServiceClient) AddBlock(ctx context.Context, req *connect.Requ
 	return c.addBlock.CallUnary(ctx, req)
 }
 
-// ListBlocksForQuery calls metastore.v1.MetastoreService.ListBlocksForQuery.
-func (c *metastoreServiceClient) ListBlocksForQuery(ctx context.Context, req *connect.Request[v1.ListBlocksForQueryRequest]) (*connect.Response[v1.ListBlocksForQueryResponse], error) {
-	return c.listBlocksForQuery.CallUnary(ctx, req)
+// QueryMetadata calls metastore.v1.MetastoreService.QueryMetadata.
+func (c *metastoreServiceClient) QueryMetadata(ctx context.Context, req *connect.Request[v1.QueryMetadataRequest]) (*connect.Response[v1.QueryMetadataResponse], error) {
+	return c.queryMetadata.CallUnary(ctx, req)
 }
 
 // ReadIndex calls metastore.v1.MetastoreService.ReadIndex.
@@ -115,7 +115,7 @@ func (c *metastoreServiceClient) ReadIndex(ctx context.Context, req *connect.Req
 // MetastoreServiceHandler is an implementation of the metastore.v1.MetastoreService service.
 type MetastoreServiceHandler interface {
 	AddBlock(context.Context, *connect.Request[v1.AddBlockRequest]) (*connect.Response[v1.AddBlockResponse], error)
-	ListBlocksForQuery(context.Context, *connect.Request[v1.ListBlocksForQueryRequest]) (*connect.Response[v1.ListBlocksForQueryResponse], error)
+	QueryMetadata(context.Context, *connect.Request[v1.QueryMetadataRequest]) (*connect.Response[v1.QueryMetadataResponse], error)
 	ReadIndex(context.Context, *connect.Request[v1.ReadIndexRequest]) (*connect.Response[v1.ReadIndexResponse], error)
 }
 
@@ -131,10 +131,10 @@ func NewMetastoreServiceHandler(svc MetastoreServiceHandler, opts ...connect.Han
 		connect.WithSchema(metastoreServiceAddBlockMethodDescriptor),
 		connect.WithHandlerOptions(opts...),
 	)
-	metastoreServiceListBlocksForQueryHandler := connect.NewUnaryHandler(
-		MetastoreServiceListBlocksForQueryProcedure,
-		svc.ListBlocksForQuery,
-		connect.WithSchema(metastoreServiceListBlocksForQueryMethodDescriptor),
+	metastoreServiceQueryMetadataHandler := connect.NewUnaryHandler(
+		MetastoreServiceQueryMetadataProcedure,
+		svc.QueryMetadata,
+		connect.WithSchema(metastoreServiceQueryMetadataMethodDescriptor),
 		connect.WithHandlerOptions(opts...),
 	)
 	metastoreServiceReadIndexHandler := connect.NewUnaryHandler(
@@ -147,8 +147,8 @@ func NewMetastoreServiceHandler(svc MetastoreServiceHandler, opts ...connect.Han
 		switch r.URL.Path {
 		case MetastoreServiceAddBlockProcedure:
 			metastoreServiceAddBlockHandler.ServeHTTP(w, r)
-		case MetastoreServiceListBlocksForQueryProcedure:
-			metastoreServiceListBlocksForQueryHandler.ServeHTTP(w, r)
+		case MetastoreServiceQueryMetadataProcedure:
+			metastoreServiceQueryMetadataHandler.ServeHTTP(w, r)
 		case MetastoreServiceReadIndexProcedure:
 			metastoreServiceReadIndexHandler.ServeHTTP(w, r)
 		default:
@@ -164,8 +164,8 @@ func (UnimplementedMetastoreServiceHandler) AddBlock(context.Context, *connect.R
 	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("metastore.v1.MetastoreService.AddBlock is not implemented"))
 }
 
-func (UnimplementedMetastoreServiceHandler) ListBlocksForQuery(context.Context, *connect.Request[v1.ListBlocksForQueryRequest]) (*connect.Response[v1.ListBlocksForQueryResponse], error) {
-	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("metastore.v1.MetastoreService.ListBlocksForQuery is not implemented"))
+func (UnimplementedMetastoreServiceHandler) QueryMetadata(context.Context, *connect.Request[v1.QueryMetadataRequest]) (*connect.Response[v1.QueryMetadataResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("metastore.v1.MetastoreService.QueryMetadata is not implemented"))
 }
 
 func (UnimplementedMetastoreServiceHandler) ReadIndex(context.Context, *connect.Request[v1.ReadIndexRequest]) (*connect.Response[v1.ReadIndexResponse], error) {
diff --git a/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.mux.go b/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.mux.go
index 9d0c507a55..bde9d0a43b 100644
--- a/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.mux.go
+++ b/api/gen/proto/go/metastore/v1/metastorev1connect/metastore.connect.mux.go
@@ -24,9 +24,9 @@ func RegisterMetastoreServiceHandler(mux *mux.Router, svc MetastoreServiceHandle
 		svc.AddBlock,
 		opts...,
 	))
-	mux.Handle("/metastore.v1.MetastoreService/ListBlocksForQuery", connect.NewUnaryHandler(
-		"/metastore.v1.MetastoreService/ListBlocksForQuery",
-		svc.ListBlocksForQuery,
+	mux.Handle("/metastore.v1.MetastoreService/QueryMetadata", connect.NewUnaryHandler(
+		"/metastore.v1.MetastoreService/QueryMetadata",
+		svc.QueryMetadata,
 		opts...,
 	))
 	mux.Handle("/metastore.v1.MetastoreService/ReadIndex", connect.NewUnaryHandler(
diff --git a/api/metastore/v1/metastore.proto b/api/metastore/v1/metastore.proto
index db7cbf7276..4574016a37 100644
--- a/api/metastore/v1/metastore.proto
+++ b/api/metastore/v1/metastore.proto
@@ -2,9 +2,11 @@ syntax = "proto3";
 
 package metastore.v1;
 
+import "types/v1/types.proto";
+
 service MetastoreService {
   rpc AddBlock(AddBlockRequest) returns (AddBlockResponse) {}
-  rpc ListBlocksForQuery(ListBlocksForQueryRequest) returns (ListBlocksForQueryResponse) {}
+  rpc QueryMetadata(QueryMetadataRequest) returns (QueryMetadataResponse) {}
   rpc ReadIndex(ReadIndexRequest) returns (ReadIndexResponse) {}
 }
 
@@ -23,14 +25,13 @@ message BlockMeta {
   uint32 compaction_level = 6;
   // Optional. Empty if compaction level is 0.
   string tenant_id = 7;
-  // TODO(kolesnikovae): Partitions with labels?
-  repeated TenantService tenant_services = 8;
+  repeated Dataset datasets = 8;
   uint64 size = 9;
 }
 
-// TenantService object points to the offset in the block at which
-// the tenant service data is located.
-message TenantService {
+message Dataset {
+  repeated types.v1.Labels labels = 8;
+
   string tenant_id = 1;
   string name = 2;
   int64 min_time = 3;
@@ -47,18 +48,20 @@ message TenantService {
   repeated uint64 table_of_contents = 5;
   // Size of the section in bytes.
   uint64 size = 6;
+
+  // TODO: delete
   // Profile types present in the tenant service data.
   repeated string profile_types = 7;
 }
 
-message ListBlocksForQueryRequest {
+message QueryMetadataRequest {
   repeated string tenant_id = 1;
   int64 start_time = 2;
   int64 end_time = 3;
   string query = 4;
 }
 
-message ListBlocksForQueryResponse {
+message QueryMetadataResponse {
   repeated BlockMeta blocks = 1;
 }
 
diff --git a/api/openapiv2/gen/phlare.swagger.json b/api/openapiv2/gen/phlare.swagger.json
index 9331e5dd42..5e3391dede 100644
--- a/api/openapiv2/gen/phlare.swagger.json
+++ b/api/openapiv2/gen/phlare.swagger.json
@@ -656,13 +656,12 @@
           "type": "string",
           "description": "Optional. Empty if compaction level is 0."
         },
-        "tenantServices": {
+        "datasets": {
           "type": "array",
           "items": {
             "type": "object",
-            "$ref": "#/definitions/v1TenantService"
-          },
-          "title": "TODO(kolesnikovae): Partitions with labels?"
+            "$ref": "#/definitions/v1Dataset"
+          }
         },
         "size": {
           "type": "string",
@@ -829,6 +828,52 @@
         }
       }
     },
+    "v1Dataset": {
+      "type": "object",
+      "properties": {
+        "labels": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/v1Labels"
+          }
+        },
+        "tenantId": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "minTime": {
+          "type": "string",
+          "format": "int64"
+        },
+        "maxTime": {
+          "type": "string",
+          "format": "int64"
+        },
+        "tableOfContents": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "format": "uint64"
+          },
+          "description": "Table of contents lists data sections within the tenant\nservice region. The offsets are absolute.\n\nThe interpretation of the table of contents is specific\nto the metadata format version. By default, the sections are:\n - 0: profiles.parquet\n - 1: index.tsdb\n - 2: symbols.symdb"
+        },
+        "size": {
+          "type": "string",
+          "format": "uint64",
+          "description": "Size of the section in bytes."
+        },
+        "profileTypes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "TODO: delete\nProfile types present in the tenant service data."
+        }
+      }
+    },
     "v1Diagnostics": {
       "type": "object",
       "description": "Diagnostic messages, events, statistics, analytics, etc."
@@ -1240,18 +1285,6 @@
         }
       }
     },
-    "v1ListBlocksForQueryResponse": {
-      "type": "object",
-      "properties": {
-        "blocks": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "$ref": "#/definitions/v1BlockMeta"
-          }
-        }
-      }
-    },
     "v1Mapping": {
       "type": "object",
       "properties": {
@@ -1519,6 +1552,18 @@
         }
       }
     },
+    "v1QueryMetadataResponse": {
+      "type": "object",
+      "properties": {
+        "blocks": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/v1BlockMeta"
+          }
+        }
+      }
+    },
     "v1QueryPlan": {
       "type": "object",
       "properties": {
@@ -1925,46 +1970,6 @@
       ],
       "default": "MERGE_FORMAT_UNSPECIFIED"
     },
-    "v1TenantService": {
-      "type": "object",
-      "properties": {
-        "tenantId": {
-          "type": "string"
-        },
-        "name": {
-          "type": "string"
-        },
-        "minTime": {
-          "type": "string",
-          "format": "int64"
-        },
-        "maxTime": {
-          "type": "string",
-          "format": "int64"
-        },
-        "tableOfContents": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "format": "uint64"
-          },
-          "description": "Table of contents lists data sections within the tenant\nservice region. The offsets are absolute.\n\nThe interpretation of the table of contents is specific\nto the metadata format version. By default, the sections are:\n - 0: profiles.parquet\n - 1: index.tsdb\n - 2: symbols.symdb"
-        },
-        "size": {
-          "type": "string",
-          "format": "uint64",
-          "description": "Size of the section in bytes."
-        },
-        "profileTypes": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Profile types present in the tenant service data."
-        }
-      },
-      "description": "TenantService object points to the offset in the block at which\nthe tenant service data is located."
-    },
     "v1TimeSeriesAggregationType": {
       "type": "string",
       "enum": [
diff --git a/docs/sources/configure-server/reference-configuration-parameters/index.md b/docs/sources/configure-server/reference-configuration-parameters/index.md
index 62a9830105..f24d239132 100644
--- a/docs/sources/configure-server/reference-configuration-parameters/index.md
+++ b/docs/sources/configure-server/reference-configuration-parameters/index.md
@@ -37,9 +37,9 @@ brackets indicate that a parameter is optional.
 - `<prefix>`: a CLI flag prefix based on the context (look at the parent configuration block to see which CLI flags prefix should be used)
 - `<relabel_config>`: a [Prometheus relabeling configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config)
 - `<time>`: a timestamp, with available formats:
-  - `2006-01-20` (midnight, local timezone)
-  - `2006-01-20T15:04` (local timezone)
-  - RFC 3339 formats: `2006-01-20T15:04:05Z` (UTC) or `2006-01-20T15:04:05+07:00` (explicit timezone)
+    - `2006-01-20` (midnight, local timezone)
+    - `2006-01-20T15:04` (local timezone)
+    - RFC 3339 formats: `2006-01-20T15:04:05Z` (UTC) or `2006-01-20T15:04:05+07:00` (explicit timezone)
 
 ## Use environment variables in the configuration
 
@@ -2259,4 +2259,3 @@ The `filesystem_storage_backend` block configures the usage of local file system
 ```
 
 ```
-
diff --git a/pkg/experiment/compactor/compaction_worker.go b/pkg/experiment/compactor/compaction_worker.go
index c961d32ced..f046615ac3 100644
--- a/pkg/experiment/compactor/compaction_worker.go
+++ b/pkg/experiment/compactor/compaction_worker.go
@@ -255,7 +255,7 @@ func (w *Worker) startJob(ctx context.Context, job *compactorv1.CompactionJob) *
 				"block_compaction_level", c.CompactionLevel,
 				"block_min_time", c.MinTime,
 				"block_max_time", c.MinTime,
-				"tenant_services", len(c.TenantServices))
+				"datasets", len(c.Datasets))
 		}
 
 		job.Status.Status = compactorv1.CompactionStatus_COMPACTION_STATUS_SUCCESS
diff --git a/pkg/experiment/ingester/segment.go b/pkg/experiment/ingester/segment.go
index 85edccada0..877b06773b 100644
--- a/pkg/experiment/ingester/segment.go
+++ b/pkg/experiment/ingester/segment.go
@@ -252,7 +252,7 @@ func (s *segment) flushBlock(heads []serviceHead) (string, *metastorev1.BlockMet
 		Shard:           uint32(s.shard),
 		CompactionLevel: 0,
 		TenantId:        "",
-		TenantServices:  make([]*metastorev1.TenantService, 0, len(heads)),
+		Datasets:        make([]*metastorev1.Dataset, 0, len(heads)),
 		Size:            0,
 	}
 
@@ -279,7 +279,7 @@ func (s *segment) flushBlock(heads []serviceHead) (string, *metastorev1.BlockMet
 			meta.MaxTime = math.Max(meta.MaxTime, svc.MaxTime)
 		}
 		s.sw.metrics.headSizeBytes.WithLabelValues(s.sshard, e.key.tenant).Observe(float64(svc.Size))
-		meta.TenantServices = append(meta.TenantServices, svc)
+		meta.Datasets = append(meta.Datasets, svc)
 	}
 
 	meta.Size = uint64(w.offset)
@@ -287,7 +287,7 @@ func (s *segment) flushBlock(heads []serviceHead) (string, *metastorev1.BlockMet
 	return blockPath, meta, nil
 }
 
-func concatSegmentHead(sh *shard, e serviceHead, w *writerOffset) (*metastorev1.TenantService, error) {
+func concatSegmentHead(sh *shard, e serviceHead, w *writerOffset) (*metastorev1.Dataset, error) {
 	tenantServiceOffset := w.offset
 	b := e.head.Meta()
 	ptypes := e.head.MustProfileTypeNames()
@@ -311,7 +311,7 @@ func concatSegmentHead(sh *shard, e serviceHead, w *writerOffset) (*metastorev1.
 
 	tenantServiceSize := w.offset - tenantServiceOffset
 
-	svc := &metastorev1.TenantService{
+	svc := &metastorev1.Dataset{
 		TenantId: e.key.tenant,
 		Name:     e.key.service,
 		MinTime:  int64(b.MinTime),
diff --git a/pkg/experiment/ingester/segment_test.go b/pkg/experiment/ingester/segment_test.go
index b3587d68f1..f9fa91c5c0 100644
--- a/pkg/experiment/ingester/segment_test.go
+++ b/pkg/experiment/ingester/segment_test.go
@@ -6,6 +6,22 @@ import (
 	"crypto/rand"
 	"encoding/json"
 	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/oklog/ulid"
+	"github.com/prometheus/client_golang/prometheus"
+	model2 "github.com/prometheus/common/model"
+	"github.com/prometheus/prometheus/util/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+
 	ingestv1 "github.com/grafana/pyroscope/api/gen/proto/go/ingester/v1"
 	metastorev1 "github.com/grafana/pyroscope/api/gen/proto/go/metastore/v1"
 	typesv1 "github.com/grafana/pyroscope/api/gen/proto/go/types/v1"
@@ -16,20 +32,6 @@ import (
 	"github.com/grafana/pyroscope/pkg/phlaredb"
 	"github.com/grafana/pyroscope/pkg/phlaredb/block"
 	pprofth "github.com/grafana/pyroscope/pkg/pprof/testhelper"
-	"github.com/oklog/ulid"
-	"github.com/prometheus/client_golang/prometheus"
-	model2 "github.com/prometheus/common/model"
-	"github.com/prometheus/prometheus/util/testutil"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/grpc"
-	"io"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-	"time"
 )
 
 type metastoreClient struct {
@@ -40,7 +42,7 @@ func (m *metastoreClient) AddBlock(ctx context.Context, in *metastorev1.AddBlock
 	return m.AddBlock_(ctx, in, opts...)
 }
 
-func (m *metastoreClient) ListBlocksForQuery(ctx context.Context, in *metastorev1.ListBlocksForQueryRequest, opts ...grpc.CallOption) (*metastorev1.ListBlocksForQueryResponse, error) {
+func (m *metastoreClient) QueryMetadata(ctx context.Context, in *metastorev1.QueryMetadataRequest, opts ...grpc.CallOption) (*metastorev1.QueryMetadataResponse, error) {
 	panic("implement me")
 }
 
@@ -90,12 +92,12 @@ func TestSegmentIngest(t *testing.T) {
 	assert.NoError(t, err)
 
 	meta := <-blocks
-	assert.Len(t, meta.TenantServices, 1)
+	assert.Len(t, meta.Datasets, 1)
 	assert.Equal(t, uint32(testShard), meta.Shard)
-	assert.Equal(t, testTenant, meta.TenantServices[0].TenantId)
-	assert.Equal(t, testSVCName, meta.TenantServices[0].Name)
+	assert.Equal(t, testTenant, meta.Datasets[0].TenantId)
+	assert.Equal(t, testSVCName, meta.Datasets[0].Name)
 
-	blockQuerier := sw.createBlockFromMeta(meta, meta.TenantServices[0])
+	blockQuerier := sw.createBlockFromMeta(meta, meta.Datasets[0])
 
 	q := blockQuerier.Queriers()
 	err = q.Open(context.Background())
@@ -134,12 +136,12 @@ func TestSegmentIngestDLQ(t *testing.T) {
 	assert.Len(t, metas, 1)
 	meta := metas[0]
 
-	assert.Len(t, meta.TenantServices, 1)
+	assert.Len(t, meta.Datasets, 1)
 	assert.Equal(t, uint32(testShard), meta.Shard)
-	assert.Equal(t, testTenant, meta.TenantServices[0].TenantId)
-	assert.Equal(t, testSVCName, meta.TenantServices[0].Name)
+	assert.Equal(t, testTenant, meta.Datasets[0].TenantId)
+	assert.Equal(t, testSVCName, meta.Datasets[0].Name)
 
-	blockQuerier := sw.createBlockFromMeta(meta, meta.TenantServices[0])
+	blockQuerier := sw.createBlockFromMeta(meta, meta.Datasets[0])
 
 	q := blockQuerier.Queriers()
 	err = q.Open(context.Background())
@@ -211,7 +213,7 @@ func newTestSegmentWriter(t *testing.T) sw {
 	}
 }
 
-func (sw *sw) createBlockFromMeta(meta *metastorev1.BlockMeta, ts *metastorev1.TenantService) *phlaredb.BlockQuerier {
+func (sw *sw) createBlockFromMeta(meta *metastorev1.BlockMeta, ts *metastorev1.Dataset) *phlaredb.BlockQuerier {
 	dir := sw.t.TempDir()
 	blockid, err := ulid.New(uint64(meta.MaxTime), rand.Reader)
 	require.NoError(sw.t, err)
diff --git a/pkg/experiment/metastore/metastore_state_query_metadata.go b/pkg/experiment/metastore/metastore_state_query_metadata.go
new file mode 100644
index 0000000000..64d9d88d7c
--- /dev/null
+++ b/pkg/experiment/metastore/metastore_state_query_metadata.go
@@ -0,0 +1,148 @@
+package metastore
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
+	"golang.org/x/sync/errgroup"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	metastorev1 "github.com/grafana/pyroscope/api/gen/proto/go/metastore/v1"
+	"github.com/grafana/pyroscope/pkg/model"
+)
+
+func (m *Metastore) QueryMetadata(
+	ctx context.Context,
+	request *metastorev1.QueryMetadataRequest,
+) (*metastorev1.QueryMetadataResponse, error) {
+	// TODO(kolesnikovae): ReadIndex
+	return m.state.listBlocksForQuery(ctx, request)
+}
+
+type metadataQuery struct {
+	startTime      int64
+	endTime        int64
+	tenants        map[string]struct{}
+	serviceMatcher *labels.Matcher
+}
+
+func newMetadataQuery(request *metastorev1.QueryMetadataRequest) (*metadataQuery, error) {
+	if len(request.TenantId) == 0 {
+		return nil, fmt.Errorf("tenant_id is required")
+	}
+	q := &metadataQuery{
+		startTime: request.StartTime,
+		endTime:   request.EndTime,
+		tenants:   make(map[string]struct{}, len(request.TenantId)),
+	}
+	for _, tenant := range request.TenantId {
+		q.tenants[tenant] = struct{}{}
+	}
+	selectors, err := parser.ParseMetricSelector(request.Query)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse label selectors: %w", err)
+	}
+	for _, m := range selectors {
+		if m.Name == model.LabelNameServiceName {
+			q.serviceMatcher = m
+			break
+		}
+	}
+	// We could also validate that the service has the profile type
+	// queried, but that's not really necessary: querying an irrelevant
+	// profile type is rather a rare/invalid case.
+	return q, nil
+}
+
+func (q *metadataQuery) matchBlock(b *metastorev1.BlockMeta) bool {
+	return inRange(b.MinTime, b.MaxTime, q.startTime, q.endTime)
+}
+
+func (q *metadataQuery) matchService(s *metastorev1.Dataset) bool {
+	_, ok := q.tenants[s.TenantId]
+	if !ok {
+		return false
+	}
+	if !inRange(s.MinTime, s.MaxTime, q.startTime, q.endTime) {
+		return false
+	}
+	if q.serviceMatcher != nil {
+		return q.serviceMatcher.Matches(s.Name)
+	}
+	return true
+}
+
+func inRange(blockStart, blockEnd, queryStart, queryEnd int64) bool {
+	return blockStart <= queryEnd && blockEnd >= queryStart
+}
+
+func (s *metastoreShard) listBlocksForQuery(q *metadataQuery) map[string]*metastorev1.BlockMeta {
+	s.segmentsMutex.Lock()
+	defer s.segmentsMutex.Unlock()
+	md := make(map[string]*metastorev1.BlockMeta, 32)
+	for _, segment := range s.segments {
+		if !q.matchBlock(segment) {
+			continue
+		}
+		var block *metastorev1.BlockMeta
+		for _, svc := range segment.Datasets {
+			if q.matchService(svc) {
+				if block == nil {
+					block = cloneBlockForQuery(segment)
+					md[segment.Id] = block
+				}
+				block.Datasets = append(block.Datasets, svc)
+			}
+		}
+	}
+	return md
+}
+
+func cloneBlockForQuery(b *metastorev1.BlockMeta) *metastorev1.BlockMeta {
+	datasets := b.Datasets
+	b.Datasets = nil
+	c := b.CloneVT()
+	b.Datasets = datasets
+	c.Datasets = make([]*metastorev1.Dataset, 0, len(b.Datasets))
+	return c
+}
+
+func (m *metastoreState) listBlocksForQuery(
+	ctx context.Context,
+	request *metastorev1.QueryMetadataRequest,
+) (*metastorev1.QueryMetadataResponse, error) {
+	q, err := newMetadataQuery(request)
+	if err != nil {
+		return nil, status.Error(codes.InvalidArgument, err.Error())
+	}
+	var respMutex sync.Mutex
+	var resp metastorev1.QueryMetadataResponse
+	g, ctx := errgroup.WithContext(ctx)
+	m.shardsMutex.Lock()
+	for _, s := range m.shards {
+		s := s
+		g.Go(func() error {
+			blocks := s.listBlocksForQuery(q)
+			respMutex.Lock()
+			for _, b := range blocks {
+				resp.Blocks = append(resp.Blocks, b)
+			}
+			respMutex.Unlock()
+			return nil
+		})
+	}
+	m.shardsMutex.Unlock()
+	if err = g.Wait(); err != nil {
+		return nil, err
+	}
+	slices.SortFunc(resp.Blocks, func(a, b *metastorev1.BlockMeta) int {
+		return strings.Compare(a.Id, b.Id)
+	})
+	return &resp, nil
+}
diff --git a/pkg/experiment/querybackend/block/compaction.go b/pkg/experiment/querybackend/block/compaction.go
index 0c5eb7b043..582215e2d1 100644
--- a/pkg/experiment/querybackend/block/compaction.go
+++ b/pkg/experiment/querybackend/block/compaction.go
@@ -119,22 +119,22 @@ func PlanCompaction(objects Objects) ([]*CompactionPlan, error) {
 
 	m := make(map[string]*CompactionPlan)
 	for _, obj := range objects {
-		for _, s := range obj.meta.TenantServices {
+		for _, s := range obj.meta.Datasets {
 			tm, ok := m[s.TenantId]
 			if !ok {
 				tm = newBlockCompaction(s.TenantId, r.meta.Shard, c)
 				m[s.TenantId] = tm
 			}
-			sm := tm.addTenantService(s)
-			// Bind objects to services.
-			sm.append(NewTenantService(s, obj))
+			sm := tm.addDataset(s)
+			// Bind objects to datasets.
+			sm.append(NewDataset(s, obj))
 		}
 	}
 
 	ordered := make([]*CompactionPlan, 0, len(m))
 	for _, tm := range m {
 		ordered = append(ordered, tm)
-		slices.SortFunc(tm.services, func(a, b *tenantServiceCompaction) int {
+		slices.SortFunc(tm.datasets, func(a, b *datasetCompaction) int {
 			return strings.Compare(a.meta.Name, b.meta.Name)
 		})
 	}
@@ -147,15 +147,15 @@ func PlanCompaction(objects Objects) ([]*CompactionPlan, error) {
 
 type CompactionPlan struct {
 	tenantID   string
-	serviceMap map[string]*tenantServiceCompaction
-	services   []*tenantServiceCompaction
+	datasetMap map[string]*datasetCompaction
+	datasets   []*datasetCompaction
 	meta       *metastorev1.BlockMeta
 }
 
 func newBlockCompaction(tenantID string, shard uint32, compactionLevel uint32) *CompactionPlan {
 	return &CompactionPlan{
 		tenantID:   tenantID,
-		serviceMap: make(map[string]*tenantServiceCompaction),
+		datasetMap: make(map[string]*datasetCompaction),
 		meta: &metastorev1.BlockMeta{
 			FormatVersion: 1,
 			// TODO(kolesnikovae): Make it deterministic?
@@ -163,7 +163,7 @@ func newBlockCompaction(tenantID string, shard uint32, compactionLevel uint32) *
 			TenantId:        tenantID,
 			Shard:           shard,
 			CompactionLevel: compactionLevel,
-			TenantServices:  nil,
+			Datasets:        nil,
 			MinTime:         0,
 			MaxTime:         0,
 			Size:            0,
@@ -180,14 +180,14 @@ func (b *CompactionPlan) Compact(ctx context.Context, dst objstore.Bucket, tmpdi
 	defer func() {
 		err = multierror.New(err, w.Close()).Err()
 	}()
-	// Services are compacted in a strict order.
-	for _, s := range b.services {
+	// Datasets are compacted in a strict order.
+	for _, s := range b.datasets {
 		s.estimate()
 		// TODO(kolesnikovae): Wait until the required resources are available?
 		if err = s.compact(ctx, w); err != nil {
 			return nil, fmt.Errorf("compacting block: %w", err)
 		}
-		b.meta.TenantServices = append(b.meta.TenantServices, s.meta)
+		b.meta.Datasets = append(b.meta.Datasets, s.meta)
 	}
 	if err = w.Flush(ctx); err != nil {
 		return nil, fmt.Errorf("flushing block writer: %w", err)
@@ -196,12 +196,12 @@ func (b *CompactionPlan) Compact(ctx context.Context, dst objstore.Bucket, tmpdi
 	return b.meta, nil
 }
 
-func (b *CompactionPlan) addTenantService(s *metastorev1.TenantService) *tenantServiceCompaction {
-	sm, ok := b.serviceMap[s.Name]
+func (b *CompactionPlan) addDataset(s *metastorev1.Dataset) *datasetCompaction {
+	sm, ok := b.datasetMap[s.Name]
 	if !ok {
-		sm = newTenantServiceCompaction(s.TenantId, s.Name)
-		b.serviceMap[s.Name] = sm
-		b.services = append(b.services, sm)
+		sm = newDatasetCompaction(s.TenantId, s.Name)
+		b.datasetMap[s.Name] = sm
+		b.datasets = append(b.datasets, sm)
 	}
 	if b.meta.MinTime == 0 || s.MinTime < b.meta.MinTime {
 		b.meta.MinTime = s.MinTime
@@ -235,12 +235,12 @@ func (m *compactionEstimates) inMemorySizeTotal() int64 {
 		m.inMemorySizeOutputProfiles
 }
 
-type tenantServiceCompaction struct {
-	meta   *metastorev1.TenantService
+type datasetCompaction struct {
+	meta   *metastorev1.Dataset
 	ptypes map[string]struct{}
 	path   string // Set at open.
 
-	services []*TenantService
+	datasets []*Dataset
 
 	indexRewriter   *indexRewriter
 	symbolsRewriter *symbolsRewriter
@@ -254,10 +254,10 @@ type tenantServiceCompaction struct {
 	flushOnce sync.Once
 }
 
-func newTenantServiceCompaction(tenantID, name string) *tenantServiceCompaction {
-	return &tenantServiceCompaction{
+func newDatasetCompaction(tenantID, name string) *datasetCompaction {
+	return &datasetCompaction{
 		ptypes: make(map[string]struct{}, 10),
-		meta: &metastorev1.TenantService{
+		meta: &metastorev1.Dataset{
 			TenantId: tenantID,
 			Name:     name,
 			// Updated at append.
@@ -271,8 +271,8 @@ func newTenantServiceCompaction(tenantID, name string) *tenantServiceCompaction
 	}
 }
 
-func (m *tenantServiceCompaction) append(s *TenantService) {
-	m.services = append(m.services, s)
+func (m *datasetCompaction) append(s *Dataset) {
+	m.datasets = append(m.datasets, s)
 	if m.meta.MinTime == 0 || s.meta.MinTime < m.meta.MinTime {
 		m.meta.MinTime = s.meta.MinTime
 	}
@@ -284,7 +284,7 @@ func (m *tenantServiceCompaction) append(s *TenantService) {
 	}
 }
 
-func (m *tenantServiceCompaction) compact(ctx context.Context, w *Writer) (err error) {
+func (m *datasetCompaction) compact(ctx context.Context, w *Writer) (err error) {
 	if err = m.open(ctx, w.Dir()); err != nil {
 		return fmt.Errorf("failed to open sections for compaction: %w", err)
 	}
@@ -303,10 +303,10 @@ func (m *tenantServiceCompaction) compact(ctx context.Context, w *Writer) (err e
 // TODO(kolesnikovae):
 //   - Add statistics to the block meta.
 //   - Measure. Ideally, we should track statistics.
-func (m *tenantServiceCompaction) estimate() {
+func (m *datasetCompaction) estimate() {
 	columns := len(schemav1.ProfilesSchema.Columns())
-	// Services are to be opened concurrently.
-	for _, s := range m.services {
+	// Datasets are to be opened concurrently.
+	for _, s := range m.datasets {
 		s1 := s.sectionSize(SectionSymbols)
 		// It's likely that both symbols and tsdb sections will
 		// be heavily deduplicated, so the actual output size will
@@ -350,7 +350,7 @@ func (m *tenantServiceCompaction) estimate() {
 	m.estimates.inMemorySizeOutputProfiles += columnBuffers + pageBuffers
 }
 
-func (m *tenantServiceCompaction) open(ctx context.Context, path string) (err error) {
+func (m *datasetCompaction) open(ctx context.Context, path string) (err error) {
 	m.path = path
 	defer func() {
 		if err != nil {
@@ -371,18 +371,18 @@ func (m *tenantServiceCompaction) open(ctx context.Context, path string) (err er
 	m.symbolsRewriter = newSymbolsRewriter(m.path)
 
 	g, ctx := errgroup.WithContext(ctx)
-	for _, s := range m.services {
+	for _, s := range m.datasets {
 		s := s
 		g.Go(util.RecoverPanic(func() error {
 			if openErr := s.Open(ctx, allSections...); openErr != nil {
-				return fmt.Errorf("opening tenant service (block %s): %w", s.obj.path, openErr)
+				return fmt.Errorf("opening tenant dataset (block %s): %w", s.obj.path, openErr)
 			}
 			return nil
 		}))
 	}
 	if err = g.Wait(); err != nil {
 		merr := multierror.New(err)
-		for _, s := range m.services {
+		for _, s := range m.datasets {
 			merr.Add(s.Close())
 		}
 		return merr.Err()
@@ -391,15 +391,15 @@ func (m *tenantServiceCompaction) open(ctx context.Context, path string) (err er
 	return nil
 }
 
-func (m *tenantServiceCompaction) mergeAndClose(ctx context.Context) (err error) {
+func (m *datasetCompaction) mergeAndClose(ctx context.Context) (err error) {
 	defer func() {
 		err = multierror.New(err, m.close()).Err()
 	}()
 	return m.merge(ctx)
 }
 
-func (m *tenantServiceCompaction) merge(ctx context.Context) (err error) {
-	rows, err := NewMergeRowProfileIterator(m.services)
+func (m *datasetCompaction) merge(ctx context.Context) (err error) {
+	rows, err := NewMergeRowProfileIterator(m.datasets)
 	if err != nil {
 		return err
 	}
@@ -420,7 +420,7 @@ func (m *tenantServiceCompaction) merge(ctx context.Context) (err error) {
 	return rows.Err()
 }
 
-func (m *tenantServiceCompaction) writeRow(r ProfileEntry) (err error) {
+func (m *datasetCompaction) writeRow(r ProfileEntry) (err error) {
 	if err = m.indexRewriter.rewriteRow(r); err != nil {
 		return err
 	}
@@ -430,7 +430,7 @@ func (m *tenantServiceCompaction) writeRow(r ProfileEntry) (err error) {
 	return m.profilesWriter.writeRow(r)
 }
 
-func (m *tenantServiceCompaction) close() (err error) {
+func (m *datasetCompaction) close() (err error) {
 	m.flushOnce.Do(func() {
 		merr := multierror.New()
 		merr.Add(m.symbolsRewriter.Flush())
@@ -442,17 +442,17 @@ func (m *tenantServiceCompaction) close() (err error) {
 		m.symbolsRewriter = nil
 		m.indexRewriter = nil
 		m.profilesWriter = nil
-		// Note that m.services are closed by merge
+		// Note that m.datasets are closed by merge
 		// iterator as they reach the end of the profile
 		// table. We do it here again just in case.
 		// TODO(kolesnikovae): Double check error handling.
-		m.services = nil
+		m.datasets = nil
 		err = merr.Err()
 	})
 	return err
 }
 
-func (m *tenantServiceCompaction) writeTo(w *Writer) (err error) {
+func (m *datasetCompaction) writeTo(w *Writer) (err error) {
 	off := w.Offset()
 	m.meta.TableOfContents, err = w.ReadFromFiles(
 		FileNameProfilesParquet,
@@ -471,7 +471,7 @@ func (m *tenantServiceCompaction) writeTo(w *Writer) (err error) {
 	return nil
 }
 
-func (m *tenantServiceCompaction) cleanup() error {
+func (m *datasetCompaction) cleanup() error {
 	return os.RemoveAll(m.path)
 }
 
@@ -557,7 +557,7 @@ func (rw *indexRewriter) Flush() error {
 
 type symbolsRewriter struct {
 	w       *symdb.SymDB
-	rw      map[*TenantService]*symdb.Rewriter
+	rw      map[*Dataset]*symdb.Rewriter
 	samples uint64
 
 	stacktraces []uint32
@@ -565,7 +565,7 @@ type symbolsRewriter struct {
 
 func newSymbolsRewriter(path string) *symbolsRewriter {
 	return &symbolsRewriter{
-		rw: make(map[*TenantService]*symdb.Rewriter),
+		rw: make(map[*Dataset]*symdb.Rewriter),
 		w: symdb.NewSymDB(symdb.DefaultConfig().
 			WithVersion(symdb.FormatV3).
 			WithDirectory(path)),
@@ -573,7 +573,7 @@ func newSymbolsRewriter(path string) *symbolsRewriter {
 }
 
 func (s *symbolsRewriter) rewriteRow(e ProfileEntry) (err error) {
-	rw := s.rewriterFor(e.TenantService)
+	rw := s.rewriterFor(e.Dataset)
 	e.Row.ForStacktraceIDsValues(func(values []parquet.Value) {
 		s.loadStacktraceIDs(values)
 		if err = rw.Rewrite(e.Row.StacktracePartitionID(), s.stacktraces); err != nil {
@@ -587,7 +587,7 @@ func (s *symbolsRewriter) rewriteRow(e ProfileEntry) (err error) {
 	return err
 }
 
-func (s *symbolsRewriter) rewriterFor(x *TenantService) *symdb.Rewriter {
+func (s *symbolsRewriter) rewriterFor(x *Dataset) *symdb.Rewriter {
 	rw, ok := s.rw[x]
 	if !ok {
 		rw = symdb.NewRewriter(s.w, x.Symbols())
diff --git a/pkg/experiment/querybackend/block/constants.go b/pkg/experiment/querybackend/block/constants.go
index bba95e2164..92b390ce37 100644
--- a/pkg/experiment/querybackend/block/constants.go
+++ b/pkg/experiment/querybackend/block/constants.go
@@ -15,7 +15,7 @@ const (
 
 const (
 	defaultObjectSizeLoadInMemory        = 1 << 20
-	defaultTenantServiceSizeLoadInMemory = 1 << 20
+	defaultTenantDatasetSizeLoadInMemory = 1 << 20
 
 	maxRowsPerRowGroup       = 10 << 10
 	symbolsPrefetchSize      = 32 << 10
diff --git a/pkg/experiment/querybackend/block/object.go b/pkg/experiment/querybackend/block/object.go
index 6900e61f22..738c7ea2da 100644
--- a/pkg/experiment/querybackend/block/object.go
+++ b/pkg/experiment/querybackend/block/object.go
@@ -47,7 +47,7 @@ var (
 	sectionIndices = [...][]int{1: {-1, 0, 1, 2}}
 )
 
-func (sc Section) open(ctx context.Context, s *TenantService) (err error) {
+func (sc Section) open(ctx context.Context, s *Dataset) (err error) {
 	switch sc {
 	case SectionTSDB:
 		return openTSDB(ctx, s)
@@ -146,7 +146,7 @@ func (obj *Object) open(ctx context.Context) (err error) {
 		// and then released, return the error immediately.
 		return obj.err
 	}
-	if len(obj.meta.TenantServices) == 0 {
+	if len(obj.meta.Datasets) == 0 {
 		return nil
 	}
 	// Estimate the size of the sections to process, and load the
diff --git a/pkg/experiment/querybackend/block/section_profiles.go b/pkg/experiment/querybackend/block/section_profiles.go
index ea16ecb5d1..031bcbf78b 100644
--- a/pkg/experiment/querybackend/block/section_profiles.go
+++ b/pkg/experiment/querybackend/block/section_profiles.go
@@ -26,7 +26,7 @@ import (
 	"github.com/grafana/pyroscope/pkg/util/loser"
 )
 
-func openProfileTable(_ context.Context, s *TenantService) (err error) {
+func openProfileTable(_ context.Context, s *Dataset) (err error) {
 	offset := s.sectionOffset(SectionProfiles)
 	size := s.sectionSize(SectionProfiles)
 	if buf := s.inMemoryBuffer(); buf != nil {
@@ -244,7 +244,7 @@ func (f *readerWithFooter) ReadAt(p []byte, off int64) (n int, err error) {
 }
 
 type ProfileEntry struct {
-	TenantService *TenantService
+	Dataset *Dataset
 
 	Timestamp   int64
 	Fingerprint model.Fingerprint
@@ -252,7 +252,7 @@ type ProfileEntry struct {
 	Row         schemav1.ProfileRow
 }
 
-func NewMergeRowProfileIterator(src []*TenantService) (iter.Iterator[ProfileEntry], error) {
+func NewMergeRowProfileIterator(src []*Dataset) (iter.Iterator[ProfileEntry], error) {
 	its := make([]iter.Iterator[ProfileEntry], len(src))
 	for i, s := range src {
 		it, err := NewProfileRowIterator(s)
@@ -314,7 +314,7 @@ func (it *DedupeProfileRowIterator) Next() bool {
 }
 
 type profileRowIterator struct {
-	reader      *TenantService
+	reader      *Dataset
 	index       phlaredb.IndexReader
 	profiles    iter.Iterator[parquet.Row]
 	allPostings index.Postings
@@ -325,7 +325,7 @@ type profileRowIterator struct {
 	chunks           []index.ChunkMeta
 }
 
-func NewProfileRowIterator(s *TenantService) (iter.Iterator[ProfileEntry], error) {
+func NewProfileRowIterator(s *Dataset) (iter.Iterator[ProfileEntry], error) {
 	k, v := index.AllPostingsKey()
 	tsdb := s.Index()
 	allPostings, err := tsdb.Postings(k, nil, v)
@@ -350,7 +350,7 @@ func (p *profileRowIterator) Next() bool {
 	if !p.profiles.Next() {
 		return false
 	}
-	p.currentRow.TenantService = p.reader
+	p.currentRow.Dataset = p.reader
 	p.currentRow.Row = schemav1.ProfileRow(p.profiles.At())
 	seriesIndex := p.currentRow.Row.SeriesIndex()
 	p.currentRow.Timestamp = p.currentRow.Row.TimeNanos()
diff --git a/pkg/experiment/querybackend/block/section_symbols.go b/pkg/experiment/querybackend/block/section_symbols.go
index 0b8701ef2d..e7626c88bb 100644
--- a/pkg/experiment/querybackend/block/section_symbols.go
+++ b/pkg/experiment/querybackend/block/section_symbols.go
@@ -7,7 +7,7 @@ import (
 	"github.com/grafana/pyroscope/pkg/phlaredb/symdb"
 )
 
-func openSymbols(ctx context.Context, s *TenantService) (err error) {
+func openSymbols(ctx context.Context, s *Dataset) (err error) {
 	offset := s.sectionOffset(SectionSymbols)
 	size := s.sectionSize(SectionSymbols)
 	if buf := s.inMemoryBuffer(); buf != nil {
diff --git a/pkg/experiment/querybackend/block/section_tsdb.go b/pkg/experiment/querybackend/block/section_tsdb.go
index cc365a48b2..ac93674014 100644
--- a/pkg/experiment/querybackend/block/section_tsdb.go
+++ b/pkg/experiment/querybackend/block/section_tsdb.go
@@ -9,7 +9,7 @@ import (
 	"github.com/grafana/pyroscope/pkg/util/bufferpool"
 )
 
-func openTSDB(ctx context.Context, s *TenantService) (err error) {
+func openTSDB(ctx context.Context, s *Dataset) (err error) {
 	offset := s.sectionOffset(SectionTSDB)
 	size := s.sectionSize(SectionTSDB)
 	s.tsdb = new(tsdbBuffer)
diff --git a/pkg/experiment/querybackend/block/tenant_service.go b/pkg/experiment/querybackend/block/tenant_service.go
index 333eb2c149..47bfc470a1 100644
--- a/pkg/experiment/querybackend/block/tenant_service.go
+++ b/pkg/experiment/querybackend/block/tenant_service.go
@@ -18,8 +18,8 @@ import (
 	"github.com/grafana/pyroscope/pkg/util/refctr"
 )
 
-type TenantService struct {
-	meta *metastorev1.TenantService
+type Dataset struct {
+	meta *metastorev1.Dataset
 	obj  *Object
 
 	refs refctr.Counter
@@ -33,44 +33,44 @@ type TenantService struct {
 	memSize int
 }
 
-func NewTenantService(meta *metastorev1.TenantService, obj *Object) *TenantService {
-	return &TenantService{
+func NewDataset(meta *metastorev1.Dataset, obj *Object) *Dataset {
+	return &Dataset{
 		meta:    meta,
 		obj:     obj,
-		memSize: defaultTenantServiceSizeLoadInMemory,
+		memSize: defaultTenantDatasetSizeLoadInMemory,
 	}
 }
 
-type TenantServiceOption func(*TenantService)
+type DatasetOption func(*Dataset)
 
-func WithTenantServiceMaxSizeLoadInMemory(size int) TenantServiceOption {
-	return func(s *TenantService) {
+func WithDatasetMaxSizeLoadInMemory(size int) DatasetOption {
+	return func(s *Dataset) {
 		s.memSize = size
 	}
 }
 
-// Open opens the service, initializing the sections specified.
+// Open opens the dataset, initializing the sections specified.
 //
-// Open may be called multiple times concurrently, but the service
-// is only initialized once. While it is possible to open the service
+// Open may be called multiple times concurrently, but the dataset
+// is only initialized once. While it is possible to open the dataset
 // repeatedly after close, the caller must pass the failure reason to
 // the CloseWithError call, preventing further use, if applicable.
-func (s *TenantService) Open(ctx context.Context, sections ...Section) (err error) {
+func (s *Dataset) Open(ctx context.Context, sections ...Section) (err error) {
 	return s.refs.IncErr(func() error {
 		return s.open(ctx, sections...)
 	})
 }
 
-func (s *TenantService) open(ctx context.Context, sections ...Section) (err error) {
+func (s *Dataset) open(ctx context.Context, sections ...Section) (err error) {
 	if s.err != nil {
-		// The tenant service has been already closed with an error.
+		// The tenant dataset has been already closed with an error.
 		return s.err
 	}
 	if err = s.obj.Open(ctx); err != nil {
 		return fmt.Errorf("failed to open object: %w", err)
 	}
 	defer func() {
-		// Close the object here because the tenant service won't be
+		// Close the object here because the tenant dataset won't be
 		// closed if it fails to open.
 		if err != nil {
 			_ = s.closeErr(err)
@@ -96,20 +96,20 @@ func (s *TenantService) open(ctx context.Context, sections ...Section) (err erro
 	return g.Wait()
 }
 
-func (s *TenantService) Close() error { return s.CloseWithError(nil) }
+func (s *Dataset) Close() error { return s.CloseWithError(nil) }
 
-// CloseWithError closes the tenant service and disposes all the resources
+// CloseWithError closes the tenant dataset and disposes all the resources
 // associated with it.
 //
-// Any further attempts to open the service will return the provided error.
-func (s *TenantService) CloseWithError(err error) (closeErr error) {
+// Any further attempts to open the dataset will return the provided error.
+func (s *Dataset) CloseWithError(err error) (closeErr error) {
 	s.refs.Dec(func() {
 		closeErr = s.closeErr(err)
 	})
 	return closeErr
 }
 
-func (s *TenantService) closeErr(err error) error {
+func (s *Dataset) closeErr(err error) error {
 	s.err = err
 	if s.buf != nil {
 		bufferpool.Put(s.buf)
@@ -131,20 +131,20 @@ func (s *TenantService) closeErr(err error) error {
 	return merr.Err()
 }
 
-func (s *TenantService) Meta() *metastorev1.TenantService { return s.meta }
+func (s *Dataset) Meta() *metastorev1.Dataset { return s.meta }
 
-func (s *TenantService) Profiles() *ParquetFile { return s.profiles }
+func (s *Dataset) Profiles() *ParquetFile { return s.profiles }
 
-func (s *TenantService) ProfileRowReader() parquet.RowReader { return s.profiles.RowReader() }
+func (s *Dataset) ProfileRowReader() parquet.RowReader { return s.profiles.RowReader() }
 
-func (s *TenantService) Symbols() symdb.SymbolsReader { return s.symbols }
+func (s *Dataset) Symbols() symdb.SymbolsReader { return s.symbols }
 
-func (s *TenantService) Index() phlaredb.IndexReader { return s.tsdb.index }
+func (s *Dataset) Index() phlaredb.IndexReader { return s.tsdb.index }
 
-// Offset of the tenant service section within the object.
-func (s *TenantService) offset() uint64 { return s.meta.TableOfContents[0] }
+// Offset of the tenant dataset section within the object.
+func (s *Dataset) offset() uint64 { return s.meta.TableOfContents[0] }
 
-func (s *TenantService) sectionIndex(sc Section) int {
+func (s *Dataset) sectionIndex(sc Section) int {
 	var n []int
 	switch s.obj.meta.FormatVersion {
 	default:
@@ -156,7 +156,7 @@ func (s *TenantService) sectionIndex(sc Section) int {
 	return n[sc]
 }
 
-func (s *TenantService) sectionName(sc Section) string {
+func (s *Dataset) sectionName(sc Section) string {
 	var n []string
 	switch s.obj.meta.FormatVersion {
 	default:
@@ -168,11 +168,11 @@ func (s *TenantService) sectionName(sc Section) string {
 	return n[sc]
 }
 
-func (s *TenantService) sectionOffset(sc Section) int64 {
+func (s *Dataset) sectionOffset(sc Section) int64 {
 	return int64(s.meta.TableOfContents[s.sectionIndex(sc)])
 }
 
-func (s *TenantService) sectionSize(sc Section) int64 {
+func (s *Dataset) sectionSize(sc Section) int64 {
 	idx := s.sectionIndex(sc)
 	off := s.meta.TableOfContents[idx]
 	var next uint64
@@ -184,25 +184,25 @@ func (s *TenantService) sectionSize(sc Section) int64 {
 	return int64(next - off)
 }
 
-func (s *TenantService) inMemoryBuffer() []byte {
+func (s *Dataset) inMemoryBuffer() []byte {
 	if s.obj.buf != nil {
 		// If the entire object is loaded into memory,
-		// return the tenant service sub-slice.
+		// return the tenant dataset sub-slice.
 		lo := s.offset()
 		hi := lo + s.meta.Size
 		buf := s.obj.buf.B
 		return buf[lo:hi]
 	}
 	if s.buf != nil {
-		// Otherwise, if the tenant service is loaded into memory
+		// Otherwise, if the tenant dataset is loaded into memory
 		// individually, return the buffer.
 		return s.buf.B
 	}
-	// Otherwise, the tenant service is not loaded into memory.
+	// Otherwise, the tenant dataset is not loaded into memory.
 	return nil
 }
 
-func (s *TenantService) inMemoryBucket(buf []byte) objstore.Bucket {
+func (s *Dataset) inMemoryBucket(buf []byte) objstore.Bucket {
 	bucket := memory.NewInMemBucket()
 	bucket.Set(s.obj.path, buf)
 	return objstore.NewBucket(bucket)
diff --git a/pkg/experiment/querybackend/block/testdata/block-metas.json b/pkg/experiment/querybackend/block/testdata/block-metas.json
index 5d6fc93fdd..9762eaf057 100644
--- a/pkg/experiment/querybackend/block/testdata/block-metas.json
+++ b/pkg/experiment/querybackend/block/testdata/block-metas.json
@@ -5,7 +5,7 @@
       "minTime": "1721060035611",
       "maxTime": "1721060035611",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/query-frontend",
@@ -25,7 +25,7 @@
       "minTime": "1721060023235",
       "maxTime": "1721060023235",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/ingester",
@@ -45,7 +45,7 @@
       "minTime": "1721060010831",
       "maxTime": "1721060010831",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/alloy",
@@ -65,7 +65,7 @@
       "minTime": "1721060025159",
       "maxTime": "1721060025159",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/query-frontend",
@@ -85,7 +85,7 @@
       "minTime": "1721060026913",
       "maxTime": "1721060026913",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/ingester",
@@ -105,7 +105,7 @@
       "minTime": "1721060013534",
       "maxTime": "1721060013534",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/query-frontend",
@@ -125,7 +125,7 @@
       "minTime": "1721060015603",
       "maxTime": "1721060015603",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/ingester",
@@ -145,7 +145,7 @@
       "minTime": "1721060031203",
       "maxTime": "1721060031203",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/ingester",
@@ -165,7 +165,7 @@
       "minTime": "1721060032190",
       "maxTime": "1721060032190",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/ingester",
@@ -185,7 +185,7 @@
       "minTime": "1721060033248",
       "maxTime": "1721060033802",
       "shard": 1,
-      "tenantServices": [
+      "datasets": [
         {
           "tenantId": "anonymous",
           "name": "pyroscope-test/alloy",
diff --git a/pkg/experiment/querybackend/block/writer.go b/pkg/experiment/querybackend/block/writer.go
index dcaf5e309b..ecf29a0168 100644
--- a/pkg/experiment/querybackend/block/writer.go
+++ b/pkg/experiment/querybackend/block/writer.go
@@ -14,7 +14,7 @@ import (
 // TODO(kolesnikovae):
 //  - Avoid staging files where possible.
 //  - If stage files are required, at least avoid
-//    recreating them for each tenant service.
+//    recreating them for each tenant dataset.
 //  - objstore.Bucket should provide object writer.
 
 type Writer struct {
diff --git a/pkg/experiment/querybackend/block_reader.go b/pkg/experiment/querybackend/block_reader.go
index 10500d4e90..29ef4c3c1d 100644
--- a/pkg/experiment/querybackend/block_reader.go
+++ b/pkg/experiment/querybackend/block_reader.go
@@ -22,24 +22,24 @@ import (
 // Block reader reads objects from the object storage. Each block is currently
 // represented by a single object.
 //
-// An object consists of a set of "tenant services" – regions within the block
-// that include data of a specific tenant service. Each such tenant service
-// consists of 3 sections: profile table, TSDB, and symbol database.
+// An object consists of data sets – regions within the block that include some
+// tenant data. Each such dataset consists of 3 sections: profile table, TSDB,
+// and symbol database.
 //
 // A single Invoke request typically spans multiple blocks (objects).
-// Querying an object involves processing multiple tenant services in parallel.
-// Multiple parallel queries can be executed on the same tenant service.
+// Querying an object involves processing multiple datasets in parallel.
+// Multiple parallel queries can be executed on the same tenant datasets.
 //
 // Thus, queries share the same "execution context": the object and a tenant
-// service:
+// dataset.
 //
-// object-a    service-a   query-a
+// object-a    dataset-a   query-a
 //                         query-b
-//             service-b   query-a
+//             dataset-b   query-a
 //                         query-b
-// object-b    service-a   query-a
+// object-b    dataset-a   query-a
 //                         query-b
-//             service-b   query-a
+//             dataset-b   query-a
 //                         query-b
 //
 
@@ -76,7 +76,7 @@ func (b *BlockReader) Invoke(
 	m := newAggregator(req)
 	for _, md := range req.QueryPlan.Blocks {
 		obj := block.NewObject(b.storage, md)
-		for _, meta := range md.TenantServices {
+		for _, meta := range md.Datasets {
 			c := newQueryContext(ctx, b.log, meta, vr, obj)
 			for _, query := range req.Query {
 				q := query
diff --git a/pkg/experiment/querybackend/query.go b/pkg/experiment/querybackend/query.go
index 8ac4d02b1c..3a56b8f064 100644
--- a/pkg/experiment/querybackend/query.go
+++ b/pkg/experiment/querybackend/query.go
@@ -74,17 +74,17 @@ func registerQueryType(
 type queryContext struct {
 	ctx  context.Context
 	log  log.Logger
-	meta *metastorev1.TenantService
+	meta *metastorev1.Dataset
 	req  *request
 	obj  *block.Object
-	svc  *block.TenantService
+	ds   *block.Dataset
 	err  error
 }
 
 func newQueryContext(
 	ctx context.Context,
 	logger log.Logger,
-	meta *metastorev1.TenantService,
+	meta *metastorev1.Dataset,
 	req *request,
 	obj *block.Object,
 ) *queryContext {
@@ -94,7 +94,7 @@ func newQueryContext(
 		req:  req,
 		meta: meta,
 		obj:  obj,
-		svc:  block.NewTenantService(meta, obj),
+		ds:   block.NewDataset(meta, obj),
 	}
 }
 
@@ -119,11 +119,11 @@ func executeQuery(q *queryContext, query *querybackendv1.Query) (r *querybackend
 }
 
 func (q *queryContext) open() error {
-	return q.svc.Open(q.ctx, q.sections()...)
+	return q.ds.Open(q.ctx, q.sections()...)
 }
 
 func (q *queryContext) close(err error) error {
-	return q.svc.CloseWithError(err)
+	return q.ds.CloseWithError(err)
 }
 
 func (q *queryContext) sections() []block.Section {
diff --git a/pkg/experiment/querybackend/query_label_names.go b/pkg/experiment/querybackend/query_label_names.go
index 744b16fc39..995c21ef13 100644
--- a/pkg/experiment/querybackend/query_label_names.go
+++ b/pkg/experiment/querybackend/query_label_names.go
@@ -26,9 +26,9 @@ func queryLabelNames(q *queryContext, query *querybackendv1.Query) (*querybacken
 	var names []string
 	var err error
 	if len(q.req.matchers) == 0 {
-		names, err = q.svc.Index().LabelNames()
+		names, err = q.ds.Index().LabelNames()
 	} else {
-		names, err = labelNamesForMatchers(q.svc.Index(), q.req.matchers)
+		names, err = labelNamesForMatchers(q.ds.Index(), q.req.matchers)
 	}
 	if err != nil {
 		return nil, err
diff --git a/pkg/experiment/querybackend/query_label_values.go b/pkg/experiment/querybackend/query_label_values.go
index 3ab79ae372..5f273092d7 100644
--- a/pkg/experiment/querybackend/query_label_values.go
+++ b/pkg/experiment/querybackend/query_label_values.go
@@ -28,9 +28,9 @@ func queryLabelValues(q *queryContext, query *querybackendv1.Query) (*querybacke
 	var values []string
 	var err error
 	if len(q.req.matchers) == 0 {
-		values, err = q.svc.Index().LabelValues(query.LabelValues.LabelName)
+		values, err = q.ds.Index().LabelValues(query.LabelValues.LabelName)
 	} else {
-		values, err = labelValuesForMatchers(q.svc.Index(), query.LabelValues.LabelName, q.req.matchers)
+		values, err = labelValuesForMatchers(q.ds.Index(), query.LabelValues.LabelName, q.req.matchers)
 	}
 	if err != nil {
 		return nil, err
diff --git a/pkg/experiment/querybackend/query_profile_entry.go b/pkg/experiment/querybackend/query_profile_entry.go
index 6f920f0554..f6b9ef578b 100644
--- a/pkg/experiment/querybackend/query_profile_entry.go
+++ b/pkg/experiment/querybackend/query_profile_entry.go
@@ -14,16 +14,16 @@ import (
 )
 
 func profileEntryIterator(q *queryContext, groupBy ...string) (iter.Iterator[ProfileEntry], error) {
-	series, err := getSeriesLabels(q.svc.Index(), q.req.matchers, groupBy...)
+	series, err := getSeriesLabels(q.ds.Index(), q.req.matchers, groupBy...)
 	if err != nil {
 		return nil, err
 	}
 	results := parquetquery.NewBinaryJoinIterator(0,
-		q.svc.Profiles().Column(q.ctx, "SeriesIndex", parquetquery.NewMapPredicate(series)),
-		q.svc.Profiles().Column(q.ctx, "TimeNanos", parquetquery.NewIntBetweenPredicate(q.req.startTime, q.req.endTime)),
+		q.ds.Profiles().Column(q.ctx, "SeriesIndex", parquetquery.NewMapPredicate(series)),
+		q.ds.Profiles().Column(q.ctx, "TimeNanos", parquetquery.NewIntBetweenPredicate(q.req.startTime, q.req.endTime)),
 	)
 	results = parquetquery.NewBinaryJoinIterator(0, results,
-		q.svc.Profiles().Column(q.ctx, "StacktracePartition", nil),
+		q.ds.Profiles().Column(q.ctx, "StacktracePartition", nil),
 	)
 
 	buf := make([][]parquet.Value, 3)
diff --git a/pkg/experiment/querybackend/query_series_labels.go b/pkg/experiment/querybackend/query_series_labels.go
index 1680f5ad9f..1fa1e2a3a4 100644
--- a/pkg/experiment/querybackend/query_series_labels.go
+++ b/pkg/experiment/querybackend/query_series_labels.go
@@ -24,7 +24,7 @@ func init() {
 }
 
 func querySeriesLabels(q *queryContext, query *querybackendv1.Query) (*querybackendv1.Report, error) {
-	postings, err := getPostings(q.svc.Index(), q.req.matchers...)
+	postings, err := getPostings(q.ds.Index(), q.req.matchers...)
 	if err != nil {
 		return nil, err
 	}
@@ -32,7 +32,7 @@ func querySeriesLabels(q *queryContext, query *querybackendv1.Query) (*queryback
 	var c []index.ChunkMeta
 	l := make(map[uint64]model.Labels)
 	for postings.Next() {
-		fp, _ := q.svc.Index().SeriesBy(postings.At(), &tmp, &c, query.SeriesLabels.LabelNames...)
+		fp, _ := q.ds.Index().SeriesBy(postings.At(), &tmp, &c, query.SeriesLabels.LabelNames...)
 		if _, ok := l[fp]; ok {
 			continue
 		}
diff --git a/pkg/experiment/querybackend/query_time_series.go b/pkg/experiment/querybackend/query_time_series.go
index 568abfddd3..7a09ee6855 100644
--- a/pkg/experiment/querybackend/query_time_series.go
+++ b/pkg/experiment/querybackend/query_time_series.go
@@ -35,12 +35,12 @@ func queryTimeSeries(q *queryContext, query *querybackendv1.Query) (r *queryback
 	}
 	defer runutil.CloseWithErrCapture(&err, entries, "failed to close profile entry iterator")
 
-	column, err := schemav1.ResolveColumnByPath(q.svc.Profiles().Schema(), strings.Split("TotalValue", "."))
+	column, err := schemav1.ResolveColumnByPath(q.ds.Profiles().Schema(), strings.Split("TotalValue", "."))
 	if err != nil {
 		return nil, err
 	}
 
-	rows := parquetquery.NewRepeatedRowIterator(q.ctx, entries, q.svc.Profiles().RowGroups(), column.ColumnIndex)
+	rows := parquetquery.NewRepeatedRowIterator(q.ctx, entries, q.ds.Profiles().RowGroups(), column.ColumnIndex)
 	defer runutil.CloseWithErrCapture(&err, rows, "failed to close column iterator")
 
 	builder := phlaremodel.NewTimeSeriesBuilder(query.TimeSeries.GroupBy...)
diff --git a/pkg/experiment/querybackend/query_tree.go b/pkg/experiment/querybackend/query_tree.go
index 5e988d66c3..b440244342 100644
--- a/pkg/experiment/querybackend/query_tree.go
+++ b/pkg/experiment/querybackend/query_tree.go
@@ -35,16 +35,16 @@ func queryTree(q *queryContext, query *querybackendv1.Query) (*querybackendv1.Re
 	defer runutil.CloseWithErrCapture(&err, entries, "failed to close profile entry iterator")
 
 	var columns v1.SampleColumns
-	if err = columns.Resolve(q.svc.Profiles().Schema()); err != nil {
+	if err = columns.Resolve(q.ds.Profiles().Schema()); err != nil {
 		return nil, err
 	}
 
-	profiles := parquetquery.NewRepeatedRowIterator(q.ctx, entries, q.svc.Profiles().RowGroups(),
+	profiles := parquetquery.NewRepeatedRowIterator(q.ctx, entries, q.ds.Profiles().RowGroups(),
 		columns.StacktraceID.ColumnIndex,
 		columns.Value.ColumnIndex)
 	defer runutil.CloseWithErrCapture(&err, profiles, "failed to close profile stream")
 
-	resolver := symdb.NewResolver(q.ctx, q.svc.Symbols())
+	resolver := symdb.NewResolver(q.ctx, q.ds.Symbols())
 	defer resolver.Release()
 	for profiles.Next() {
 		p := profiles.At()
diff --git a/pkg/experiment/queryfrontend/frontend_meta.go b/pkg/experiment/queryfrontend/frontend_meta.go
index 839b36efb7..8917aa430f 100644
--- a/pkg/experiment/queryfrontend/frontend_meta.go
+++ b/pkg/experiment/queryfrontend/frontend_meta.go
@@ -35,7 +35,7 @@ func ListMetadata(
 		"end", endTime,
 		"query", query,
 	)
-	resp, err := client.ListBlocksForQuery(ctx, &metastorev1.ListBlocksForQueryRequest{
+	resp, err := client.QueryMetadata(ctx, &metastorev1.QueryMetadataRequest{
 		TenantId:  tenants,
 		StartTime: startTime,
 		EndTime:   endTime,
@@ -65,7 +65,7 @@ func printStats(logger log.Logger, blocks []*metastorev1.BlockMeta) {
 			s = &blockMetaStats{level: b.CompactionLevel}
 			m[b.CompactionLevel] = s
 		}
-		for _, x := range b.TenantServices {
+		for _, x := range b.Datasets {
 			s.size += x.Size
 		}
 		s.count++
diff --git a/pkg/experiment/queryfrontend/frontend_profile_types.go b/pkg/experiment/queryfrontend/frontend_profile_types.go
index 32b41a1c2d..da4b760fab 100644
--- a/pkg/experiment/queryfrontend/frontend_profile_types.go
+++ b/pkg/experiment/queryfrontend/frontend_profile_types.go
@@ -75,7 +75,7 @@ func listProfileTypesFromMetadata(
 	}
 	p := newProfileTypesResponseBuilder(len(metas) * 8)
 	for _, m := range metas {
-		for _, s := range m.TenantServices {
+		for _, s := range m.Datasets {
 			p.addServiceProfileTypes(s.Name, s.ProfileTypes...)
 		}
 	}