more memory tagging and fixes (#263)

This change adds more instrumentation for memory tracking, so that as little as possible comes through as Unknown in Insights analysis.

2 files changed, 139 insertions, 2 deletions

diff --git a/src/zenserver/projectstore/httpprojectstore.cpp b/src/zenserver/projectstore/httpprojectstore.cpp
index 09f4c7ee2..eb6407e1f 100644
--- a/src/zenserver/projectstore/httpprojectstore.cpp
+++ b/src/zenserver/projectstore/httpprojectstore.cpp
@@ -22,9 +22,9 @@ namespace zen {
 const FLLMTag&
 GetProjectHttpTag()
 {
-	static FLLMTag CacheHttpTag("http", FLLMTag("project"));
+	static FLLMTag _("http", FLLMTag("project"));
 
-	return CacheHttpTag;
+	return _;
 }
 
 void
@@ -241,6 +241,8 @@ HttpProjectService::HttpProjectService(CidStore& Store, ProjectStore* Projects,
 , m_StatsService(StatsService)
 , m_AuthMgr(AuthMgr)
 {
+	ZEN_MEMSCOPE(GetProjectHttpTag());
+
 	using namespace std::literals;
 
 	m_StatsService.RegisterHandler("prj", *this);
diff --git a/src/zenserver/projectstore/projectstore.cpp b/src/zenserver/projectstore/projectstore.cpp
index ef2c2e4ab..d39d78cb9 100644
--- a/src/zenserver/projectstore/projectstore.cpp
+++ b/src/zenserver/projectstore/projectstore.cpp
@@ -11,6 +11,7 @@
 #include <zencore/fmtutils.h>
 #include <zencore/jobqueue.h>
 #include <zencore/logging.h>
+#include <zencore/memory/llm.h>
 #include <zencore/scopeguard.h>
 #include <zencore/stream.h>
 #include <zencore/timer.h>
@@ -43,6 +44,14 @@ ZEN_THIRD_PARTY_INCLUDES_END
 
 namespace zen {
 
+const FLLMTag&
+GetProjectstoreTag()
+{
+	static FLLMTag _("store", FLLMTag("project"));
+
+	return _;
+}
+
 namespace {
 	bool PrepareDirectoryDelete(const std::filesystem::path& Dir, std::filesystem::path& OutDeleteDir)
 	{
@@ -141,6 +150,8 @@ namespace {
 											  size_t					   MaxChunkEmbedSize,
 											  const std::filesystem::path& TempFilePath)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
+
 		using namespace std::literals;
 
 		std::shared_ptr<RemoteProjectStore> RemoteStore;
@@ -509,6 +520,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	void Open(bool IsCreate)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::Open");
 
 		if (IsCreate)
@@ -540,6 +552,8 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	IoBuffer GetOpBuffer(BasicFileBuffer& OpBlobsBuffer, const OplogEntry& LogEntry) const
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
+
 		const uint64_t	 OpFileOffset = LogEntry.OpCoreOffset * m_OpsAlign;
 		const MemoryView OpBufferView = OpBlobsBuffer.MakeView(LogEntry.OpCoreSize, OpFileOffset);
 		if (OpBufferView.GetSize() == LogEntry.OpCoreSize)
@@ -570,6 +584,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 		bool																											   RetainLSNs,
 		bool																											   DryRun)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::Compact");
 
 		ZEN_INFO("oplog '{}/{}': compacting at '{}'",
@@ -743,6 +758,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	void ReplayLog(std::function<void(CbObjectView, const OplogEntry&)>&& Handler, uint64_t SkipEntryCount = 0)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::ReplayLog");
 
 		if (m_Oplog.GetLogCount() == SkipEntryCount)
@@ -883,6 +899,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	void ReplayLogEntries(const std::span<OplogEntryAddress> Entries, std::function<void(CbObjectView)>&& Handler)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::ReplayLogEntries");
 
 		BasicFileBuffer OpBlobsBuffer(m_OpBlobs, 65536);
@@ -904,6 +921,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	CbObject GetOp(const OplogEntryAddress& Entry)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::GetOp");
 
 		IoBuffer OpBuffer(Entry.Size);
@@ -923,6 +941,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	static OplogStorage::AppendOpData GetAppendOpData(const CbObjectView& Core)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		using namespace std::literals;
 
 		AppendOpData OpData;
@@ -940,6 +959,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	OplogEntry AppendOp(const AppendOpData& OpData)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::AppendOp");
 
 		uint64_t WriteSize = OpData.Buffer.GetSize();
@@ -971,6 +991,7 @@ struct ProjectStore::OplogStorage : public RefCounted
 
 	std::vector<OplogEntry> AppendOps(std::span<const AppendOpData> Ops)
 	{
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 		ZEN_TRACE_CPU("Store::OplogStorage::AppendOps");
 
 		size_t									   OpCount = Ops.size();
@@ -1070,6 +1091,8 @@ ProjectStore::Oplog::Oplog(std::string_view				Id,
 , m_MetaValid(false)
 , m_PendingPrepOpAttachmentsRetainEnd(GcClock::Now())
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 
 	m_Storage		 = new OplogStorage(this, m_BasePath);
@@ -1103,6 +1126,8 @@ ProjectStore::Oplog::~Oplog()
 void
 ProjectStore::Oplog::Flush()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	ZEN_TRACE_CPU("Oplog::Flush");
 
 	RwLock::SharedLockScope Lock(m_OplogLock);
@@ -1126,6 +1151,8 @@ ProjectStore::Oplog::Flush()
 void
 ProjectStore::Oplog::ScrubStorage(ScrubContext& Ctx)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	std::vector<Oid> BadEntryKeys;
 
 	using namespace std::literals;
@@ -1201,6 +1228,8 @@ ProjectStore::Oplog::ScrubStorage(ScrubContext& Ctx)
 uint64_t
 ProjectStore::Oplog::TotalSize(const std::filesystem::path& BasePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 
 	uint64_t			  Size			= OplogStorage::OpsSize(BasePath);
@@ -1244,6 +1273,8 @@ ProjectStore::Oplog::ResetState()
 bool
 ProjectStore::Oplog::PrepareForDelete(std::filesystem::path& OutRemoveDirectory)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	RwLock::ExclusiveLockScope _(m_OplogLock);
 	m_UpdateCaptureRefCounter = 0;
 	m_CapturedLSNs.reset();
@@ -1280,6 +1311,8 @@ ProjectStore::Oplog::Exists() const
 void
 ProjectStore::Oplog::Read()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 	ZEN_TRACE_CPU("Oplog::Read");
 	ZEN_LOG_SCOPE("Oplog::Read '{}'", m_OplogId);
@@ -1346,6 +1379,8 @@ ProjectStore::Oplog::Read()
 void
 ProjectStore::Oplog::Write()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 
 	BinaryWriter Mem;
@@ -1376,6 +1411,8 @@ ProjectStore::Oplog::Update(const std::filesystem::path& MarkerPath)
 bool
 ProjectStore::Oplog::Reset()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	std::filesystem::path MovedDir;
 
 	{
@@ -1411,6 +1448,7 @@ ProjectStore::Oplog::Reset()
 std::optional<CbObject>
 ProjectStore::Oplog::ReadStateFile(const std::filesystem::path& BasePath, std::function<LoggerRef()>&& Log)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Oplog::ReadStateFile");
 	using namespace std::literals;
 
@@ -1440,6 +1478,8 @@ ProjectStore::Oplog::ReadStateFile(const std::filesystem::path& BasePath, std::f
 ProjectStore::Oplog::ValidationResult
 ProjectStore::Oplog::Validate(std::atomic_bool& IsCancelledFlag, WorkerThreadPool* OptionalWorkerPool)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 
 	ValidationResult Result;
@@ -1530,6 +1570,8 @@ ProjectStore::Oplog::Validate(std::atomic_bool& IsCancelledFlag, WorkerThreadPoo
 		{
 			WorkLatch.AddCount(1);
 			OptionalWorkerPool->ScheduleWork([&, Index = OpIndex]() {
+				ZEN_MEMSCOPE(GetProjectstoreTag());
+
 				auto _ = MakeGuard([&WorkLatch] { WorkLatch.CountDown(); });
 				ValidateOne(Index);
 			});
@@ -1558,6 +1600,7 @@ ProjectStore::Oplog::Validate(std::atomic_bool& IsCancelledFlag, WorkerThreadPoo
 void
 ProjectStore::Oplog::WriteIndexSnapshot()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Oplog::WriteIndexSnapshot");
 
 	ZEN_DEBUG("oplog '{}/{}': write store snapshot at '{}'", m_OuterProject->Identifier, m_OplogId, m_BasePath);
@@ -1763,6 +1806,7 @@ ProjectStore::Oplog::WriteIndexSnapshot()
 void
 ProjectStore::Oplog::ReadIndexSnapshot()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Oplog::ReadIndexSnapshot");
 
 	std::filesystem::path IndexPath = m_BasePath / "ops.zidx";
@@ -1948,6 +1992,8 @@ ProjectStore::Oplog::GetUnusedSpacePercent() const
 uint32_t
 ProjectStore::Oplog::GetUnusedSpacePercentLocked() const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	const uint64_t ActualBlobsSize = m_Storage->OpBlobsSize();
 	if (ActualBlobsSize == 0)
 	{
@@ -1986,6 +2032,8 @@ ProjectStore::Oplog::Compact(bool DryRun, bool RetainLSNs, std::string_view LogP
 void
 ProjectStore::Oplog::Compact(RwLock::ExclusiveLockScope&, bool DryRun, bool RetainLSNs, std::string_view LogPrefix)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	Stopwatch Timer;
 
 	std::vector<uint32_t> LSNs;
@@ -2057,6 +2105,8 @@ ProjectStore::Oplog::IterateChunks(std::span<Oid>																	  ChunkIds,
 								   WorkerThreadPool*																  OptionalWorkerPool,
 								   uint64_t																			  LargeSizeLimit)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	std::vector<size_t>				   CidChunkIndexes;
 	std::vector<IoHash>				   CidChunkHashes;
 	std::vector<size_t>				   FileChunkIndexes;
@@ -2237,6 +2287,8 @@ ProjectStore::Oplog::FindChunk(const Oid& ChunkId, uint64_t* OptOutModificationT
 std::vector<ProjectStore::Oplog::ChunkInfo>
 ProjectStore::Oplog::GetAllChunksInfo()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	// First just capture all the chunk ids
 
 	std::vector<ChunkInfo> InfoArray;
@@ -2325,6 +2377,7 @@ CreateSpanFromPaging(std::vector<ContainerElement>& Container, const ProjectStor
 void
 ProjectStore::Oplog::IterateOplogLocked(std::function<void(CbObjectView)>&& Handler, const Paging& EntryPaging)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Oplog::IterateOplogLocked");
 	if (!m_Storage)
 	{
@@ -2355,6 +2408,7 @@ static constexpr uint32_t OplogMetaDataExpectedMagic = 0x6f'74'6d'62;  // 'omta'
 void
 ProjectStore::Oplog::GetAttachmentsLocked(std::vector<IoHash>& OutAttachments, bool StoreMetaDataOnDisk)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Oplog::GetAttachmentsLocked");
 	if (!m_Storage)
 	{
@@ -2448,6 +2502,7 @@ ProjectStore::Oplog::IterateOplogWithKey(std::function<void(uint32_t, const Oid&
 void
 ProjectStore::Oplog::IterateOplogWithKey(std::function<void(uint32_t, const Oid&, CbObjectView)>&& Handler, const Paging& EntryPaging)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::SharedLockScope _(m_OplogLock);
 	if (!m_Storage)
 	{
@@ -2573,6 +2628,8 @@ ProjectStore::Oplog::AddChunkMappings(const std::unordered_map<Oid, IoHash, Oid:
 void
 ProjectStore::Oplog::CaptureAddedAttachments(std::span<const IoHash> AttachmentHashes)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	m_OplogLock.WithExclusiveLock([this, AttachmentHashes]() {
 		if (m_CapturedAttachments)
 		{
@@ -2585,6 +2642,8 @@ ProjectStore::Oplog::CaptureAddedAttachments(std::span<const IoHash> AttachmentH
 void
 ProjectStore::Oplog::EnableUpdateCapture()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	m_OplogLock.WithExclusiveLock([&]() {
 		if (m_UpdateCaptureRefCounter == 0)
 		{
@@ -2605,6 +2664,8 @@ ProjectStore::Oplog::EnableUpdateCapture()
 void
 ProjectStore::Oplog::DisableUpdateCapture()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	m_OplogLock.WithExclusiveLock([&]() {
 		ZEN_ASSERT(m_CapturedLSNs);
 		ZEN_ASSERT(m_CapturedAttachments);
@@ -2621,6 +2682,8 @@ ProjectStore::Oplog::DisableUpdateCapture()
 void
 ProjectStore::Oplog::IterateCapturedLSNsLocked(std::function<bool(const CbObjectView& UpdateOp)>&& Callback)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	if (m_CapturedLSNs)
 	{
 		if (!m_Storage)
@@ -2640,6 +2703,8 @@ ProjectStore::Oplog::IterateCapturedLSNsLocked(std::function<bool(const CbObject
 std::vector<IoHash>
 ProjectStore::Oplog::GetCapturedAttachmentsLocked()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	if (m_CapturedAttachments)
 	{
 		return *m_CapturedAttachments;
@@ -2650,6 +2715,8 @@ ProjectStore::Oplog::GetCapturedAttachmentsLocked()
 std::vector<IoHash>
 ProjectStore::Oplog::CheckPendingChunkReferences(std::span<const IoHash> ChunkHashes, const GcClock::Duration& RetainTime)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	m_OplogLock.WithExclusiveLock([&]() {
 		GcClock::TimePoint Now = GcClock::Now();
 		if (m_PendingPrepOpAttachmentsRetainEnd < Now)
@@ -2680,6 +2747,8 @@ ProjectStore::Oplog::CheckPendingChunkReferences(std::span<const IoHash> ChunkHa
 void
 ProjectStore::Oplog::RemovePendingChunkReferences(std::span<const IoHash> ChunkHashes)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	m_OplogLock.WithExclusiveLock([&]() {
 		GcClock::TimePoint Now = GcClock::Now();
 		if (m_PendingPrepOpAttachmentsRetainEnd < Now)
@@ -2699,6 +2768,8 @@ ProjectStore::Oplog::RemovePendingChunkReferences(std::span<const IoHash> ChunkH
 std::vector<IoHash>
 ProjectStore::Oplog::GetPendingChunkReferencesLocked()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	std::vector<IoHash> Result;
 	Result.reserve(m_PendingPrepOpAttachments.size());
 	Result.insert(Result.end(), m_PendingPrepOpAttachments.begin(), m_PendingPrepOpAttachments.end());
@@ -2748,6 +2819,7 @@ ProjectStore::Oplog::AddMetaMapping(const RwLock::ExclusiveLockScope&, const Oid
 ProjectStore::Oplog::OplogEntryMapping
 ProjectStore::Oplog::GetMapping(CbObjectView Core)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	using namespace std::literals;
 
 	OplogEntryMapping Result;
@@ -2856,6 +2928,7 @@ ProjectStore::Oplog::RegisterOplogEntry(RwLock::ExclusiveLockScope& OplogLock,
 										const OplogEntryMapping&	OpMapping,
 										const OplogEntry&			OpEntry)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	// For now we're assuming the update is all in-memory so we can hold an exclusive lock without causing
 	// too many problems. Longer term we'll probably want to ensure we can do concurrent updates however
 
@@ -2885,6 +2958,7 @@ ProjectStore::Oplog::RegisterOplogEntry(RwLock::ExclusiveLockScope& OplogLock,
 uint32_t
 ProjectStore::Oplog::AppendNewOplogEntry(CbPackage OpPackage)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Oplog::AppendNewOplogEntry");
 
 	const CbObject& Core	= OpPackage.GetObject();
@@ -2942,6 +3016,7 @@ ProjectStore::Oplog::AppendNewOplogEntry(CbPackage OpPackage)
 RefPtr<ProjectStore::OplogStorage>
 ProjectStore::Oplog::GetStorage()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RefPtr<OplogStorage> Storage;
 	{
 		RwLock::SharedLockScope _(m_OplogLock);
@@ -2953,6 +3028,7 @@ ProjectStore::Oplog::GetStorage()
 uint32_t
 ProjectStore::Oplog::AppendNewOplogEntry(CbObjectView Core)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Oplog::AppendNewOplogEntry");
 
 	using namespace std::literals;
@@ -2982,6 +3058,7 @@ ProjectStore::Oplog::AppendNewOplogEntry(CbObjectView Core)
 std::vector<uint32_t>
 ProjectStore::Oplog::AppendNewOplogEntries(std::span<CbObjectView> Cores)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Oplog::AppendNewOplogEntries");
 
 	using namespace std::literals;
@@ -3058,6 +3135,7 @@ ProjectStore::Project::Exists(const std::filesystem::path& BasePath)
 void
 ProjectStore::Project::Read()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Project::Read");
 
 	using namespace std::literals;
@@ -3093,6 +3171,7 @@ ProjectStore::Project::Read()
 void
 ProjectStore::Project::Write()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Project::Write");
 
 	using namespace std::literals;
@@ -3120,6 +3199,7 @@ ProjectStore::Project::Write()
 void
 ProjectStore::Project::ReadAccessTimes()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	using namespace std::literals;
 
 	std::filesystem::path ProjectAccessTimesFilePath = m_OplogStoragePath / "AccessTimes.zcb"sv;
@@ -3181,6 +3261,7 @@ ProjectStore::Project::ReadAccessTimes()
 void
 ProjectStore::Project::WriteAccessTimes()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	using namespace std::literals;
 
 	CbObjectWriter Writer(32 + (m_LastAccessTimes.size() * 16));
@@ -3237,6 +3318,7 @@ ProjectStore::Project::BasePathForOplog(std::string_view OplogId) const
 ProjectStore::Oplog*
 ProjectStore::Project::NewOplog(std::string_view OplogId, const std::filesystem::path& MarkerPath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::ExclusiveLockScope _(m_ProjectLock);
 
 	std::filesystem::path OplogBasePath = BasePathForOplog(OplogId);
@@ -3274,6 +3356,7 @@ ProjectStore::Project::NewOplog(std::string_view OplogId, const std::filesystem:
 ProjectStore::Oplog*
 ProjectStore::Project::OpenOplog(std::string_view OplogId, bool AllowCompact, bool VerifyPathOnDisk)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::OpenOplog");
 
 	std::filesystem::path OplogBasePath = BasePathForOplog(OplogId);
@@ -3340,6 +3423,7 @@ ProjectStore::Project::OpenOplog(std::string_view OplogId, bool AllowCompact, bo
 void
 ProjectStore::Oplog::CompactIfUnusedExceeds(bool DryRun, uint32_t CompactUnusedThreshold, std::string_view LogPrefix)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::ExclusiveLockScope OplogLock(m_OplogLock);
 	if (!m_Storage)
 	{
@@ -3359,6 +3443,7 @@ ProjectStore::Oplog::CompactIfUnusedExceeds(bool DryRun, uint32_t CompactUnusedT
 bool
 ProjectStore::Project::RemoveOplog(std::string_view OplogId, std::filesystem::path& OutDeletePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	{
 		RwLock::ExclusiveLockScope _(m_ProjectLock);
 
@@ -3392,6 +3477,7 @@ ProjectStore::Project::RemoveOplog(std::string_view OplogId, std::filesystem::pa
 bool
 ProjectStore::Project::DeleteOplog(std::string_view OplogId)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	std::filesystem::path DeletePath;
 	if (!RemoveOplog(OplogId, DeletePath))
 	{
@@ -3413,6 +3499,7 @@ ProjectStore::Project::DeleteOplog(std::string_view OplogId)
 std::vector<std::string>
 ProjectStore::Project::ScanForOplogs() const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::SharedLockScope _(m_ProjectLock);
 
 	std::vector<std::string> Oplogs;
@@ -3436,6 +3523,7 @@ ProjectStore::Project::ScanForOplogs() const
 void
 ProjectStore::Project::IterateOplogs(std::function<void(const RwLock::SharedLockScope&, const Oplog&)>&& Fn) const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::SharedLockScope Lock(m_ProjectLock);
 
 	for (auto& Kv : m_Oplogs)
@@ -3447,6 +3535,7 @@ ProjectStore::Project::IterateOplogs(std::function<void(const RwLock::SharedLock
 void
 ProjectStore::Project::IterateOplogs(std::function<void(const RwLock::SharedLockScope&, Oplog&)>&& Fn)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::SharedLockScope Lock(m_ProjectLock);
 
 	for (auto& Kv : m_Oplogs)
@@ -3458,6 +3547,7 @@ ProjectStore::Project::IterateOplogs(std::function<void(const RwLock::SharedLock
 void
 ProjectStore::Project::Flush()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Project::Flush");
 
 	// We only need to flush oplogs that we have already loaded
@@ -3468,6 +3558,7 @@ ProjectStore::Project::Flush()
 void
 ProjectStore::Project::ScrubStorage(ScrubContext& Ctx)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	// Scrubbing needs to check all existing oplogs
 	std::vector<std::string> OpLogs = ScanForOplogs();
 	for (const std::string& OpLogId : OpLogs)
@@ -3485,6 +3576,7 @@ ProjectStore::Project::ScrubStorage(ScrubContext& Ctx)
 uint64_t
 ProjectStore::Project::TotalSize(const std::filesystem::path& BasePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	using namespace std::literals;
 
 	uint64_t			  Size				  = 0;
@@ -3505,6 +3597,7 @@ ProjectStore::Project::TotalSize(const std::filesystem::path& BasePath)
 uint64_t
 ProjectStore::Project::TotalSize() const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	uint64_t Result = TotalSize(m_OplogStoragePath);
 	{
 		std::vector<std::string> OpLogs = ScanForOplogs();
@@ -3520,6 +3613,7 @@ ProjectStore::Project::TotalSize() const
 bool
 ProjectStore::Project::PrepareForDelete(std::filesystem::path& OutDeletePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::ExclusiveLockScope _(m_ProjectLock);
 
 	for (auto& It : m_Oplogs)
@@ -3542,6 +3636,7 @@ ProjectStore::Project::PrepareForDelete(std::filesystem::path& OutDeletePath)
 void
 ProjectStore::Project::EnableUpdateCapture()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	m_ProjectLock.WithExclusiveLock([&]() {
 		if (m_UpdateCaptureRefCounter == 0)
 		{
@@ -3559,6 +3654,7 @@ ProjectStore::Project::EnableUpdateCapture()
 void
 ProjectStore::Project::DisableUpdateCapture()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	m_ProjectLock.WithExclusiveLock([&]() {
 		ZEN_ASSERT(m_CapturedOplogs);
 		ZEN_ASSERT(m_UpdateCaptureRefCounter > 0);
@@ -3573,6 +3669,7 @@ ProjectStore::Project::DisableUpdateCapture()
 std::vector<std::string>
 ProjectStore::Project::GetCapturedOplogsLocked()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	if (m_CapturedOplogs)
 	{
 		return *m_CapturedOplogs;
@@ -3583,6 +3680,7 @@ ProjectStore::Project::GetCapturedOplogsLocked()
 std::vector<RwLock::SharedLockScope>
 ProjectStore::Project::GetGcReferencerLocks()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	std::vector<RwLock::SharedLockScope> Locks;
 	Locks.emplace_back(RwLock::SharedLockScope(m_ProjectLock));
 	Locks.reserve(1 + m_Oplogs.size());
@@ -3598,6 +3696,7 @@ ProjectStore::Project::IsExpired(const std::string&			  EntryName,
 								 const std::filesystem::path& MarkerPath,
 								 const GcClock::TimePoint	  ExpireTime) const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	if (!MarkerPath.empty())
 	{
 		std::error_code Ec;
@@ -3661,6 +3760,8 @@ ProjectStore::Project::IsOplogTouchedSince(const GcClock::TimePoint TouchTime, s
 bool
 ProjectStore::Project::IsExpired(const GcClock::TimePoint ExpireTime, std::string_view OplogId) const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	using namespace std::literals;
 
 	{
@@ -3683,6 +3784,8 @@ ProjectStore::Project::IsExpired(const GcClock::TimePoint ExpireTime, std::strin
 void
 ProjectStore::Project::TouchProject()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	RwLock::ExclusiveLockScope _(m_LastAccessTimesLock);
 	m_LastAccessTimes.insert_or_assign(std::string(), GcClock::TickCount());
 }
@@ -3690,7 +3793,9 @@ ProjectStore::Project::TouchProject()
 void
 ProjectStore::Project::TouchOplog(std::string_view Oplog)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_ASSERT(!Oplog.empty());
+
 	RwLock::ExclusiveLockScope _(m_LastAccessTimesLock);
 	m_LastAccessTimes.insert_or_assign(std::string(Oplog), GcClock::TickCount());
 }
@@ -3747,6 +3852,7 @@ ProjectStore::BasePathForProject(std::string_view ProjectId)
 void
 ProjectStore::DiscoverProjects()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	if (!std::filesystem::exists(m_ProjectBasePath))
 	{
 		return;
@@ -3780,6 +3886,7 @@ ProjectStore::IterateProjects(std::function<void(Project& Prj)>&& Fn)
 void
 ProjectStore::Flush()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Flush");
 
 	ZEN_INFO("flushing project store at '{}'", m_ProjectBasePath);
@@ -3820,6 +3927,7 @@ ProjectStore::Flush()
 void
 ProjectStore::ScrubStorage(ScrubContext& Ctx)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_INFO("scrubbing '{}'", m_ProjectBasePath);
 
 	DiscoverProjects();
@@ -3847,6 +3955,7 @@ ProjectStore::ScrubStorage(ScrubContext& Ctx)
 GcStorageSize
 ProjectStore::StorageSize() const
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::StorageSize");
 
 	using namespace std::literals;
@@ -3880,6 +3989,7 @@ ProjectStore::StorageSize() const
 Ref<ProjectStore::Project>
 ProjectStore::OpenProject(std::string_view ProjectId)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::OpenProject");
 
 	{
@@ -3930,6 +4040,7 @@ ProjectStore::NewProject(const std::filesystem::path& BasePath,
 						 const std::filesystem::path& ProjectRootDir,
 						 const std::filesystem::path& ProjectFilePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::NewProject");
 
 	RwLock::ExclusiveLockScope _(m_ProjectsLock);
@@ -3961,6 +4072,7 @@ ProjectStore::UpdateProject(std::string_view			 ProjectId,
 							const std::filesystem::path& ProjectRootDir,
 							const std::filesystem::path& ProjectFilePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::UpdateProject");
 
 	RwLock::ExclusiveLockScope ProjectsLock(m_ProjectsLock);
@@ -3987,6 +4099,7 @@ ProjectStore::UpdateProject(std::string_view			 ProjectId,
 bool
 ProjectStore::RemoveProject(std::string_view ProjectId, std::filesystem::path& OutDeletePath)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	RwLock::ExclusiveLockScope ProjectsLock(m_ProjectsLock);
 
 	auto ProjIt = m_Projects.find(std::string{ProjectId});
@@ -4009,6 +4122,7 @@ ProjectStore::RemoveProject(std::string_view ProjectId, std::filesystem::path& O
 bool
 ProjectStore::DeleteProject(std::string_view ProjectId)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::DeleteProject");
 
 	ZEN_INFO("project '{}': deleting", ProjectId);
@@ -4040,6 +4154,7 @@ ProjectStore::Exists(std::string_view ProjectId)
 CbArray
 ProjectStore::GetProjectsList()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::GetProjectsList");
 
 	using namespace std::literals;
@@ -4068,6 +4183,7 @@ ProjectStore::GetProjectFiles(const std::string_view				 ProjectId,
 							  const std::unordered_set<std::string>& WantedFieldNames,
 							  CbObject&								 OutPayload)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::GetProjectFiles");
 
 	using namespace std::literals;
@@ -4231,6 +4347,7 @@ ProjectStore::GetProjectChunkInfos(const std::string_view				  ProjectId,
 								   const std::unordered_set<std::string>& WantedFieldNames,
 								   CbObject&							  OutPayload)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("ProjectStore::GetProjectChunkInfos");
 
 	using namespace std::literals;
@@ -4397,6 +4514,7 @@ ProjectStore::GetChunkInfo(const std::string_view ProjectId,
 						   const std::string_view ChunkId,
 						   CbObject&			  OutPayload)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	using namespace std::literals;
 
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
@@ -4458,6 +4576,7 @@ ProjectStore::GetChunkRange(const std::string_view ProjectId,
 							ZenContentType&		   OutContentType,
 							uint64_t*			   OptionalInOutModificationTag)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	if (ChunkId.size() != 2 * sizeof(Oid::OidBits))
 	{
 		return {HttpResponseCode::BadRequest, fmt::format("Chunk request for invalid chunk id '{}/{}'/'{}'", ProjectId, OplogId, ChunkId)};
@@ -4478,6 +4597,7 @@ ExtractRange(IoBuffer&&		  Chunk,
 			 IoHash&		  OutRawHash,
 			 uint64_t&		  OutRawSize)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	OutContentType = Chunk.GetContentType();
 
 	if (OutContentType == ZenContentType::kCompressedBinary)
@@ -4591,6 +4711,7 @@ ProjectStore::GetChunkRange(const std::string_view ProjectId,
 							ZenContentType&		   OutContentType,
 							uint64_t*			   OptionalInOutModificationTag)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
 	if (!Project)
 	{
@@ -4636,6 +4757,7 @@ ProjectStore::GetChunk(const std::string_view ProjectId,
 					   IoBuffer&			  OutChunk,
 					   uint64_t*			  OptionalInOutModificationTag)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
 	if (!Project)
 	{
@@ -4693,6 +4815,7 @@ ProjectStore::PutChunk(const std::string_view ProjectId,
 					   ZenContentType		  ContentType,
 					   IoBuffer&&			  Chunk)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
 	if (!Project)
 	{
@@ -4737,6 +4860,7 @@ ProjectStore::GetChunks(const std::string_view ProjectId,
 						const CbObject&		   RequestObject,
 						CbPackage&			   OutResponsePackage)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::GetChunks");
 
 	using namespace std::literals;
@@ -5082,6 +5206,7 @@ ProjectStore::GetChunks(const std::string_view ProjectId,
 std::pair<HttpResponseCode, std::string>
 ProjectStore::WriteOplog(const std::string_view ProjectId, const std::string_view OplogId, IoBuffer&& Payload, CbObject& OutResponse)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::WriteOplog");
 
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
@@ -5167,6 +5292,7 @@ ProjectStore::ReadOplog(const std::string_view				  ProjectId,
 						const HttpServerRequest::QueryParams& Params,
 						CbObject&							  OutResponse)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::ReadOplog");
 
 	Ref<ProjectStore::Project> Project = OpenProject(ProjectId);
@@ -5237,6 +5363,7 @@ ProjectStore::Rpc(HttpServerRequest&	 HttpReq,
 				  IoBuffer&&			 Payload,
 				  AuthMgr&				 AuthManager)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Rpc");
 
 	using namespace std::literals;
@@ -5602,6 +5729,7 @@ ProjectStore::Rpc(HttpServerRequest&	 HttpReq,
 std::pair<HttpResponseCode, std::string>
 ProjectStore::Export(Ref<ProjectStore::Project> Project, ProjectStore::Oplog& Oplog, CbObjectView&& Params, AuthMgr& AuthManager)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Export");
 
 	using namespace std::literals;
@@ -5666,6 +5794,7 @@ ProjectStore::Export(Ref<ProjectStore::Project> Project, ProjectStore::Oplog& Op
 std::pair<HttpResponseCode, std::string>
 ProjectStore::Import(ProjectStore::Project& Project, ProjectStore::Oplog& Oplog, CbObjectView&& Params, AuthMgr& AuthManager)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	ZEN_TRACE_CPU("Store::Import");
 
 	using namespace std::literals;
@@ -5712,6 +5841,7 @@ ProjectStore::AreDiskWritesAllowed() const
 void
 ProjectStore::EnableUpdateCapture()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	m_ProjectsLock.WithExclusiveLock([&]() {
 		if (m_UpdateCaptureRefCounter == 0)
 		{
@@ -5743,6 +5873,7 @@ ProjectStore::DisableUpdateCapture()
 std::vector<std::string>
 ProjectStore::GetCapturedProjectsLocked()
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 	if (m_CapturedProjects)
 	{
 		return *m_CapturedProjects;
@@ -5753,6 +5884,8 @@ ProjectStore::GetCapturedProjectsLocked()
 std::string
 ProjectStore::GetGcName(GcCtx&)
 {
+	ZEN_MEMSCOPE(GetProjectstoreTag());
+
 	return fmt::format("projectstore: '{}'", m_ProjectBasePath.string());
 }
 
@@ -5773,6 +5906,7 @@ public:
 	virtual void CompactStore(GcCtx& Ctx, GcCompactStoreStats& Stats, const std::function<uint64_t()>&) override
 	{
 		ZEN_TRACE_CPU("Store::CompactStore");
+		ZEN_MEMSCOPE(GetProjectstoreTag());
 
 		auto Log = [&Ctx]() { return Ctx.Logger; };
 
@@ -5897,6 +6031,7 @@ GcStoreCompactor*
 ProjectStore::RemoveExpiredData(GcCtx& Ctx, GcStats& Stats)
 {
 	ZEN_TRACE_CPU("Store::RemoveExpiredData");
+	ZEN_MEMSCOPE(GetProjectstoreTag());
 
 	auto Log = [&Ctx]() { return Ctx.Logger; };