revert multi-cid store (#475)

1 files changed, 90 insertions, 196 deletions

diff --git a/src/zenserver/cache/httpstructuredcache.cpp b/src/zenserver/cache/httpstructuredcache.cpp
index 19ac3a216..68f1c602e 100644
--- a/src/zenserver/cache/httpstructuredcache.cpp
+++ b/src/zenserver/cache/httpstructuredcache.cpp
@@ -85,7 +85,7 @@ namespace {
 //////////////////////////////////////////////////////////////////////////
 
 HttpStructuredCacheService::HttpStructuredCacheService(ZenCacheStore&		   InCacheStore,
-													   GetCidStoreFunc&&	   GetCidStore,
+													   CidStore&			   InCidStore,
 													   HttpStatsService&	   StatsService,
 													   HttpStatusService&	   StatusService,
 													   UpstreamCache&		   UpstreamCache,
@@ -95,10 +95,11 @@ HttpStructuredCacheService::HttpStructuredCacheService(ZenCacheStore&		   InCach
 , m_CacheStore(InCacheStore)
 , m_StatsService(StatsService)
 , m_StatusService(StatusService)
+, m_CidStore(InCidStore)
 , m_UpstreamCache(UpstreamCache)
 , m_DiskWriteBlocker(InDiskWriteBlocker)
 , m_OpenProcessCache(InOpenProcessCache)
-, m_RpcHandler(m_Log, m_CacheStats, UpstreamCache, InCacheStore, std::move(GetCidStore), InDiskWriteBlocker)
+, m_RpcHandler(m_Log, m_CacheStats, UpstreamCache, InCacheStore, InCidStore, InDiskWriteBlocker)
 {
 	m_StatsService.RegisterHandler("z$", *this);
 	m_StatusService.RegisterHandler("z$", *this);
@@ -224,9 +225,6 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 		for (const auto& NamespaceIt : ValueDetails.Namespaces)
 		{
 			const std::string& Namespace = NamespaceIt.first;
-
-			CidStore& ChunkStore = m_RpcHandler.GetCidStore(Namespace);
-
 			for (const auto& BucketIt : NamespaceIt.second.Buckets)
 			{
 				const std::string& Bucket = BucketIt.first;
@@ -236,7 +234,7 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 					{
 						for (const IoHash& Hash : ValueIt.second.Attachments)
 						{
-							IoBuffer Payload = ChunkStore.FindChunkByCid(Hash);
+							IoBuffer Payload = m_CidStore.FindChunkByCid(Hash);
 							CSVWriter << "\r\n"
 									  << Namespace << "," << Bucket << "," << ValueIt.first.ToHexString() << ", " << Hash.ToHexString()
 									  << ", " << gsl::narrow<uint64_t>(Payload.GetSize());
@@ -254,7 +252,7 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 						size_t AttachmentsSize = 0;
 						for (const IoHash& Hash : ValueIt.second.Attachments)
 						{
-							IoBuffer Payload = ChunkStore.FindChunkByCid(Hash);
+							IoBuffer Payload = m_CidStore.FindChunkByCid(Hash);
 							AttachmentsSize += Payload.GetSize();
 						}
 						CSVWriter << ", " << gsl::narrow<uint64_t>(AttachmentsSize);
@@ -276,9 +274,6 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 			for (const auto& NamespaceIt : ValueDetails.Namespaces)
 			{
 				const std::string& Namespace = NamespaceIt.first;
-
-				CidStore& ChunkStore = m_RpcHandler.GetCidStore(Namespace);
-
 				Cbo.BeginObject();
 				{
 					Cbo.AddString("name", Namespace);
@@ -321,7 +316,7 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 															{
 																Cbo.BeginObject();
 																Cbo.AddHash("cid", Hash);
-																IoBuffer Payload = ChunkStore.FindChunkByCid(Hash);
+																IoBuffer Payload = m_CidStore.FindChunkByCid(Hash);
 																Cbo.AddInteger("size", gsl::narrow<uint64_t>(Payload.GetSize()));
 																Cbo.EndObject();
 															}
@@ -335,7 +330,7 @@ HttpStructuredCacheService::HandleDetailsRequest(HttpServerRequest& Request)
 														size_t AttachmentsSize = 0;
 														for (const IoHash& Hash : ValueIt.second.Attachments)
 														{
-															IoBuffer Payload = ChunkStore.FindChunkByCid(Hash);
+															IoBuffer Payload = m_CidStore.FindChunkByCid(Hash);
 															AttachmentsSize += Payload.GetSize();
 														}
 														Cbo.AddInteger("attachmentssize", gsl::narrow<uint64_t>(AttachmentsSize));
@@ -610,8 +605,6 @@ HttpStructuredCacheService::HandleCacheNamespaceRequest(HttpServerRequest& Reque
 
 				ResponseWriter.AddInteger("EntryCount", Info->DiskLayerInfo.EntryCount);
 
-				CidStore& ChunkStore = m_RpcHandler.GetCidStore(NamespaceName);
-
 				if (auto Buckets = HttpServerRequest::Decode(Request.GetQueryParams().GetValue("bucketsizes")); !Buckets.empty())
 				{
 					ResponseWriter.BeginObject("BucketSizes");
@@ -670,7 +663,7 @@ HttpStructuredCacheService::HandleCacheNamespaceRequest(HttpServerRequest& Reque
 
 					uint64_t AttachmentsSize = 0;
 
-					ChunkStore.IterateChunks(
+					m_CidStore.IterateChunks(
 						AllAttachments,
 						[&](size_t Index, const IoBuffer& Payload) {
 							ZEN_UNUSED(Index);
@@ -738,8 +731,6 @@ HttpStructuredCacheService::HandleCacheBucketRequest(HttpServerRequest& Request,
 
 				ResponseWriter.AddInteger("DiskEntryCount", Info->DiskLayerInfo.EntryCount);
 
-				CidStore& ChunkStore = m_RpcHandler.GetCidStore(NamespaceName);
-
 				if (auto GetBucketSize = Request.GetQueryParams().GetValue("bucketsize"); GetBucketSize == "true")
 				{
 					CacheContentStats ContentStats;
@@ -766,7 +757,7 @@ HttpStructuredCacheService::HandleCacheBucketRequest(HttpServerRequest& Request,
 
 						WorkerThreadPool& WorkerPool = GetMediumWorkerPool(EWorkloadType::Background);
 
-						ChunkStore.IterateChunks(
+						m_CidStore.IterateChunks(
 							ContentStats.Attachments,
 							[&](size_t Index, const IoBuffer& Payload) {
 								ZEN_UNUSED(Index);
@@ -841,8 +832,6 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 	CacheRequestContext RequestContext = {.SessionId = Request.SessionId(), .RequestId = Request.RequestId()};
 	Stopwatch			Timer;
 
-	CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
 	if (EnumHasAllFlags(PolicyFromUrl, CachePolicy::QueryLocal) &&
 		m_CacheStore.Get(RequestContext, Ref.Namespace, Ref.BucketSegment, Ref.HashKey, ClientResultValue))
 	{
@@ -857,17 +846,17 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 				uint32_t  MissingCount = 0;
 
 				CbObjectView CacheRecord(ClientResultValue.Value.Data());
-				CacheRecord.IterateAttachments([this, &ChunkStore, &MissingCount, &Package, SkipData](CbFieldView AttachmentHash) {
+				CacheRecord.IterateAttachments([this, &MissingCount, &Package, SkipData](CbFieldView AttachmentHash) {
 					if (SkipData)
 					{
-						if (!ChunkStore.ContainsChunk(AttachmentHash.AsHash()))
+						if (!m_CidStore.ContainsChunk(AttachmentHash.AsHash()))
 						{
 							MissingCount++;
 						}
 					}
 					else
 					{
-						if (IoBuffer Chunk = ChunkStore.FindChunkByCid(AttachmentHash.AsHash()))
+						if (IoBuffer Chunk = m_CidStore.FindChunkByCid(AttachmentHash.AsHash()))
 						{
 							CompressedBuffer Compressed = CompressedBuffer::FromCompressedNoValidate(std::move(Chunk));
 							if (Compressed)
@@ -967,8 +956,6 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 		{
 			Success = true;
 
-			CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
 			ClientResultValue.Value = UpstreamResult.Value;
 			ClientResultValue.Value.SetContentType(AcceptType);
 
@@ -1019,7 +1006,6 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 					CacheRecord.IterateAttachments([this,
 													&Package,
 													&Ref,
-													&ChunkStore,
 													&WriteAttachmentBuffers,
 													&WriteRawHashes,
 													&ReferencedAttachments,
@@ -1054,12 +1040,12 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 						{
 							if (SkipData)
 							{
-								if (ChunkStore.ContainsChunk(Hash))
+								if (m_CidStore.ContainsChunk(Hash))
 								{
 									Count.Valid++;
 								}
 							}
-							else if (IoBuffer Chunk = ChunkStore.FindChunkByCid(Hash))
+							else if (IoBuffer Chunk = m_CidStore.FindChunkByCid(Hash))
 							{
 								CompressedBuffer Compressed = CompressedBuffer::FromCompressedNoValidate(std::move(Chunk));
 								if (Compressed)
@@ -1101,7 +1087,7 @@ HttpStructuredCacheService::HandleGetCacheRecord(HttpServerRequest& Request, con
 								if (!WriteAttachmentBuffers.empty())
 								{
 									std::vector<CidStore::InsertResult> InsertResults =
-										ChunkStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
+										m_CidStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
 									for (const CidStore::InsertResult& Result : InsertResults)
 									{
 										if (Result.New)
@@ -1268,10 +1254,7 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 
 		if (HasUpstream && EnumHasAllFlags(PolicyFromUrl, CachePolicy::StoreRemote))
 		{
-			CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-			m_UpstreamCache.EnqueueUpstream(
-				{.Type = ContentType, .Namespace = Ref.Namespace, .Key = {Ref.BucketSegment, Ref.HashKey}},
-				[ChunkStore = &ChunkStore](const IoHash& ValueHash) { return ChunkStore->FindChunkByCid(ValueHash); });
+			m_UpstreamCache.EnqueueUpstream({.Type = ContentType, .Namespace = Ref.Namespace, .Key = {Ref.BucketSegment, Ref.HashKey}});
 		}
 
 		ZEN_DEBUG("PUTCACHERECORD - '{}/{}/{}' {} '{}' in {}",
@@ -1305,18 +1288,15 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 		std::vector<IoHash> ReferencedAttachments;
 		int32_t				TotalCount = 0;
 
-		CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
-		CacheRecord.IterateAttachments(
-			[this, &ChunkStore, &TotalCount, &ValidAttachments, &ReferencedAttachments](CbFieldView AttachmentHash) {
-				const IoHash Hash = AttachmentHash.AsHash();
-				ReferencedAttachments.push_back(Hash);
-				if (ChunkStore.ContainsChunk(Hash))
-				{
-					ValidAttachments.emplace_back(Hash);
-				}
-				TotalCount++;
-			});
+		CacheRecord.IterateAttachments([this, &TotalCount, &ValidAttachments, &ReferencedAttachments](CbFieldView AttachmentHash) {
+			const IoHash Hash = AttachmentHash.AsHash();
+			ReferencedAttachments.push_back(Hash);
+			if (m_CidStore.ContainsChunk(Hash))
+			{
+				ValidAttachments.emplace_back(Hash);
+			}
+			TotalCount++;
+		});
 
 		const bool Overwrite = !EnumHasAllFlags(PolicyFromUrl, CachePolicy::QueryLocal);
 
@@ -1350,12 +1330,10 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 		CachePolicy Policy = PolicyFromUrl;
 		if (HasUpstream && EnumHasAllFlags(Policy, CachePolicy::StoreRemote) && !IsPartialRecord)
 		{
-			m_UpstreamCache.EnqueueUpstream(
-				{.Type			  = ZenContentType::kCbObject,
-				 .Namespace		  = Ref.Namespace,
-				 .Key			  = {Ref.BucketSegment, Ref.HashKey},
-				 .ValueContentIds = std::move(ValidAttachments)},
-				[ChunkStore = &ChunkStore](const IoHash& ValueHash) { return ChunkStore->FindChunkByCid(ValueHash); });
+			m_UpstreamCache.EnqueueUpstream({.Type			  = ZenContentType::kCbObject,
+											 .Namespace		  = Ref.Namespace,
+											 .Key			  = {Ref.BucketSegment, Ref.HashKey},
+											 .ValueContentIds = std::move(ValidAttachments)});
 		}
 
 		Request.WriteResponse(HttpResponseCode::Created);
@@ -1388,46 +1366,38 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 		WriteAttachmentBuffers.reserve(NumAttachments);
 		WriteRawHashes.reserve(NumAttachments);
 
-		CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
-		CacheRecord.IterateAttachments([this,
-										&Ref,
-										&Package,
-										&ChunkStore,
-										&WriteAttachmentBuffers,
-										&WriteRawHashes,
-										&ValidAttachments,
-										&ReferencedAttachments,
-										&Count](CbFieldView HashView) {
-			const IoHash Hash = HashView.AsHash();
-			ReferencedAttachments.push_back(Hash);
-			if (const CbAttachment* Attachment = Package.FindAttachment(Hash))
-			{
-				if (Attachment->IsCompressedBinary())
+		CacheRecord.IterateAttachments(
+			[this, &Ref, &Package, &WriteAttachmentBuffers, &WriteRawHashes, &ValidAttachments, &ReferencedAttachments, &Count](
+				CbFieldView HashView) {
+				const IoHash Hash = HashView.AsHash();
+				ReferencedAttachments.push_back(Hash);
+				if (const CbAttachment* Attachment = Package.FindAttachment(Hash))
 				{
-					WriteAttachmentBuffers.emplace_back(Attachment->AsCompressedBinary().GetCompressed().Flatten().AsIoBuffer());
-					WriteRawHashes.push_back(Hash);
-					ValidAttachments.emplace_back(Hash);
-					Count.Valid++;
+					if (Attachment->IsCompressedBinary())
+					{
+						WriteAttachmentBuffers.emplace_back(Attachment->AsCompressedBinary().GetCompressed().Flatten().AsIoBuffer());
+						WriteRawHashes.push_back(Hash);
+						ValidAttachments.emplace_back(Hash);
+						Count.Valid++;
+					}
+					else
+					{
+						ZEN_WARN("PUTCACHERECORD - '{}/{}/{}' '{}' FAILED, attachment '{}' is not compressed",
+								 Ref.Namespace,
+								 Ref.BucketSegment,
+								 Ref.HashKey,
+								 ToString(HttpContentType::kCbPackage),
+								 Hash);
+						Count.Invalid++;
+					}
 				}
-				else
+				else if (m_CidStore.ContainsChunk(Hash))
 				{
-					ZEN_WARN("PUTCACHERECORD - '{}/{}/{}' '{}' FAILED, attachment '{}' is not compressed",
-							 Ref.Namespace,
-							 Ref.BucketSegment,
-							 Ref.HashKey,
-							 ToString(HttpContentType::kCbPackage),
-							 Hash);
-					Count.Invalid++;
+					ValidAttachments.emplace_back(Hash);
+					Count.Valid++;
 				}
-			}
-			else if (ChunkStore.ContainsChunk(Hash))
-			{
-				ValidAttachments.emplace_back(Hash);
-				Count.Valid++;
-			}
-			Count.Total++;
-		});
+				Count.Total++;
+			});
 
 		if (Count.Invalid > 0)
 		{
@@ -1451,7 +1421,7 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 
 		if (!WriteAttachmentBuffers.empty())
 		{
-			std::vector<CidStore::InsertResult> InsertResults = ChunkStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
+			std::vector<CidStore::InsertResult> InsertResults = m_CidStore.AddChunks(WriteAttachmentBuffers, WriteRawHashes);
 			for (const CidStore::InsertResult& InsertResult : InsertResults)
 			{
 				if (InsertResult.New)
@@ -1478,12 +1448,10 @@ HttpStructuredCacheService::HandlePutCacheRecord(HttpServerRequest& Request, con
 
 		if (HasUpstream && EnumHasAllFlags(Policy, CachePolicy::StoreRemote) && !IsPartialRecord)
 		{
-			m_UpstreamCache.EnqueueUpstream(
-				{.Type			  = ZenContentType::kCbPackage,
-				 .Namespace		  = Ref.Namespace,
-				 .Key			  = {Ref.BucketSegment, Ref.HashKey},
-				 .ValueContentIds = std::move(ValidAttachments)},
-				[ChunkStore = &ChunkStore](const IoHash& ValueHash) { return ChunkStore->FindChunkByCid(ValueHash); });
+			m_UpstreamCache.EnqueueUpstream({.Type			  = ZenContentType::kCbPackage,
+											 .Namespace		  = Ref.Namespace,
+											 .Key			  = {Ref.BucketSegment, Ref.HashKey},
+											 .ValueContentIds = std::move(ValidAttachments)});
 		}
 
 		Request.WriteResponse(HttpResponseCode::Created);
@@ -1517,9 +1485,7 @@ HttpStructuredCacheService::HandleGetCacheChunk(HttpServerRequest& Request, cons
 {
 	Stopwatch Timer;
 
-	CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
-	IoBuffer					Value  = ChunkStore.FindChunkByCid(Ref.ValueContentId);
+	IoBuffer					Value  = m_CidStore.FindChunkByCid(Ref.ValueContentId);
 	const UpstreamEndpointInfo* Source = nullptr;
 	CachePolicy					Policy = PolicyFromUrl;
 
@@ -1541,7 +1507,7 @@ HttpStructuredCacheService::HandleGetCacheChunk(HttpServerRequest& Request, cons
 					{
 						if (AreDiskWritesAllowed())
 						{
-							ChunkStore.AddChunk(UpstreamResult.Value, RawHash);
+							m_CidStore.AddChunk(UpstreamResult.Value, RawHash);
 						}
 						Source = UpstreamResult.Source;
 					}
@@ -1635,9 +1601,7 @@ HttpStructuredCacheService::HandlePutCacheChunk(HttpServerRequest& Request, cons
 									 "ValueContentId does not match attachment hash"sv);
 	}
 
-	CidStore& ChunkStore = m_RpcHandler.GetCidStore(Ref.Namespace);
-
-	CidStore::InsertResult Result = ChunkStore.AddChunk(Body, RawHash);
+	CidStore::InsertResult Result = m_CidStore.AddChunk(Body, RawHash);
 
 	ZEN_DEBUG("PUTCACHECHUNK - '{}/{}/{}/{}' {} '{}' ({}) in {}",
 			  Ref.Namespace,
@@ -1852,51 +1816,16 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 
 	EmitSnapshot("requests", m_HttpRequests, Cbo);
 
-	const uint64_t HitCount			= m_CacheStats.HitCount;
-	const uint64_t UpstreamHitCount = m_CacheStats.UpstreamHitCount;
-	const uint64_t MissCount		= m_CacheStats.MissCount;
-	const uint64_t WriteCount		= m_CacheStats.WriteCount;
-	const uint64_t BadRequestCount	= m_CacheStats.BadRequestCount;
-
-	uint64_t	 TotalChunkHitCount	  = 0;
-	uint64_t	 TotalChunkMissCount  = 0;
-	uint64_t	 TotalChunkWriteCount = 0;
-	CidStoreSize TotalCidSize;
-
-	tsl::robin_map<CidStore*, std::string> UniqueStores;
-	{
-		std::vector<std::string> NamespaceNames = m_CacheStore.GetNamespaces();
-
-		for (const std::string& NamespaceName : NamespaceNames)
-		{
-			CidStore* Store = &m_RpcHandler.GetCidStore(NamespaceName);
-			if (auto It = UniqueStores.find(Store); It == UniqueStores.end())
-			{
-				UniqueStores.insert_or_assign(Store, NamespaceName);
-			}
-			else
-			{
-				UniqueStores.insert_or_assign(Store, std::string{});
-			}
-		}
-
-		for (auto It : UniqueStores)
-		{
-			CidStore* ChunkStore = It.first;
-
-			CidStoreStats StoreStats = ChunkStore->Stats();
-			CidStoreSize  StoreSize	 = ChunkStore->TotalSize();
-
-			TotalChunkHitCount += StoreStats.HitCount;
-			TotalChunkMissCount += StoreStats.MissCount;
-			TotalChunkWriteCount += StoreStats.WriteCount;
-
-			TotalCidSize.TinySize += StoreSize.TinySize;
-			TotalCidSize.SmallSize += StoreSize.SmallSize;
-			TotalCidSize.LargeSize += StoreSize.LargeSize;
-			TotalCidSize.TotalSize += StoreSize.TotalSize;
-		}
-	}
+	const uint64_t		 HitCount		  = m_CacheStats.HitCount;
+	const uint64_t		 UpstreamHitCount = m_CacheStats.UpstreamHitCount;
+	const uint64_t		 MissCount		  = m_CacheStats.MissCount;
+	const uint64_t		 WriteCount		  = m_CacheStats.WriteCount;
+	const uint64_t		 BadRequestCount  = m_CacheStats.BadRequestCount;
+	struct CidStoreStats StoreStats		  = m_CidStore.Stats();
+	const uint64_t		 ChunkHitCount	  = StoreStats.HitCount;
+	const uint64_t		 ChunkMissCount	  = StoreStats.MissCount;
+	const uint64_t		 ChunkWriteCount  = StoreStats.WriteCount;
+	const uint64_t		 TotalCount		  = HitCount + MissCount;
 
 	const uint64_t RpcRequests			  = m_CacheStats.RpcRequests;
 	const uint64_t RpcRecordRequests	  = m_CacheStats.RpcRecordRequests;
@@ -1906,11 +1835,17 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 	const uint64_t RpcChunkRequests		  = m_CacheStats.RpcChunkRequests;
 	const uint64_t RpcChunkBatchRequests  = m_CacheStats.RpcChunkBatchRequests;
 
+	const CidStoreSize	 CidSize   = m_CidStore.TotalSize();
 	const CacheStoreSize CacheSize = m_CacheStore.TotalSize();
 
 	bool ShowCidStoreStats	 = Request.GetQueryParams().GetValue("cidstorestats") == "true";
 	bool ShowCacheStoreStats = Request.GetQueryParams().GetValue("cachestorestats") == "true";
 
+	CidStoreStats CidStoreStats = {};
+	if (ShowCidStoreStats)
+	{
+		CidStoreStats = m_CidStore.Stats();
+	}
 	ZenCacheStore::CacheStoreStats CacheStoreStats = {};
 	if (ShowCacheStoreStats)
 	{
@@ -1945,7 +1880,6 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 		Cbo.EndObject();
 
 		Cbo << "hits" << HitCount << "misses" << MissCount << "writes" << WriteCount;
-		const uint64_t TotalCount = HitCount + MissCount;
 		Cbo << "hit_ratio" << (TotalCount > 0 ? (double(HitCount) / double(TotalCount)) : 0.0);
 
 		if (m_UpstreamCache.IsActive())
@@ -1956,9 +1890,7 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 			Cbo << "upstream_ratio" << (HitCount > 0 ? (double(UpstreamHitCount) / double(HitCount)) : 0.0);
 		}
 
-		Cbo << "cidhits" << TotalChunkHitCount << "cidmisses" << TotalChunkMissCount << "cidwrites" << TotalChunkWriteCount;
-		const uint64_t TotalChunkCount = TotalChunkHitCount + TotalChunkMissCount;
-		Cbo << "cidhit_ratio" << (TotalChunkHitCount ? (double(TotalChunkCount) / double(TotalChunkHitCount)) : 0.0);
+		Cbo << "cidhits" << ChunkHitCount << "cidmisses" << ChunkMissCount << "cidwrites" << ChunkWriteCount;
 
 		if (ShowCacheStoreStats)
 		{
@@ -2067,58 +1999,20 @@ HttpStructuredCacheService::HandleStatsRequest(HttpServerRequest& Request)
 	{
 		Cbo.BeginObject("size");
 		{
-			Cbo << "tiny" << TotalCidSize.TinySize;
-			Cbo << "small" << TotalCidSize.SmallSize;
-			Cbo << "large" << TotalCidSize.LargeSize;
-			Cbo << "total" << TotalCidSize.TotalSize;
+			Cbo << "tiny" << CidSize.TinySize;
+			Cbo << "small" << CidSize.SmallSize;
+			Cbo << "large" << CidSize.LargeSize;
+			Cbo << "total" << CidSize.TotalSize;
 		}
 		Cbo.EndObject();
 
 		if (ShowCidStoreStats)
 		{
 			Cbo.BeginObject("store");
-
-			auto OutputStats = [&](CidStore& ChunkStore) {
-				CidStoreStats StoreStats = ChunkStore.Stats();
-				Cbo << "hits" << StoreStats.HitCount << "misses" << StoreStats.MissCount << "writes" << StoreStats.WriteCount;
-				const uint64_t Count = StoreStats.HitCount + StoreStats.MissCount;
-				Cbo << "hit_ratio" << (Count ? (double(StoreStats.HitCount) / double(Count)) : 0.0);
-				EmitSnapshot("read", StoreStats.FindChunkOps, Cbo);
-				EmitSnapshot("write", StoreStats.AddChunkOps, Cbo);
-			};
-
-			if (UniqueStores.size() > 1)
-			{
-				Cbo.BeginArray("namespaces");
-				for (auto It : UniqueStores)
-				{
-					CidStore*		   ChunkStore	  = It.first;
-					const std::string& Namespace	  = It.second;
-					CidStoreSize	   ChunkStoreSize = ChunkStore->TotalSize();
-					Cbo.BeginObject();
-					{
-						Cbo << "namespace" << Namespace;
-						Cbo.BeginObject("stats");
-						OutputStats(*ChunkStore);
-						Cbo.EndObject();
-
-						Cbo.BeginObject("size");
-						{
-							Cbo << "tiny" << ChunkStoreSize.TinySize;
-							Cbo << "small" << ChunkStoreSize.SmallSize;
-							Cbo << "large" << ChunkStoreSize.LargeSize;
-							Cbo << "total" << ChunkStoreSize.TotalSize;
-						}
-						Cbo.EndObject();
-					}
-					Cbo.EndObject();
-				}
-				Cbo.EndArray();	 // namespaces
-			}
-			else if (UniqueStores.size() != 0)
-			{
-				OutputStats(*UniqueStores.begin()->first);
-			}
+			Cbo << "hits" << CidStoreStats.HitCount << "misses" << CidStoreStats.MissCount << "writes" << CidStoreStats.WriteCount;
+			EmitSnapshot("read", CidStoreStats.FindChunkOps, Cbo);
+			EmitSnapshot("write", CidStoreStats.AddChunkOps, Cbo);
+			//		EmitSnapshot("exists", CidStoreStats.ContainChunkOps, Cbo);
 			Cbo.EndObject();
 		}
 	}