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.

9 files changed, 272 insertions, 8 deletions

diff --git a/src/zenhttp/servers/httpasio.cpp b/src/zenhttp/servers/httpasio.cpp
index cddbe1ae2..c2a823430 100644
--- a/src/zenhttp/servers/httpasio.cpp
+++ b/src/zenhttp/servers/httpasio.cpp
@@ -5,6 +5,7 @@
 
 #include <zencore/except.h>
 #include <zencore/logging.h>
+#include <zencore/memory/llm.h>
 #include <zencore/thread.h>
 #include <zencore/trace.h>
 #include <zenhttp/httpserver.h>
@@ -32,6 +33,18 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #	define ZEN_TRACE_VERBOSE(fmtstr, ...)
 #endif
 
+namespace zen {
+
+const FLLMTag&
+GetHttpasioTag()
+{
+	static FLLMTag _("httpasio");
+
+	return _;
+}
+
+}  // namespace zen
+
 namespace zen::asio_http {
 
 using namespace std::literals;
@@ -125,6 +138,8 @@ public:
 
 	void InitializeForPayload(uint16_t ResponseCode, std::span<IoBuffer> BlobList)
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		ZEN_TRACE_CPU("asio::InitializeForPayload");
 
 		m_ResponseCode			  = ResponseCode;
@@ -173,8 +188,8 @@ public:
 		}
 		m_ContentLength = LocalDataSize;
 
-		auto Headers	 = GetHeaders();
-		m_AsioBuffers[0] = asio::const_buffer(Headers.data(), Headers.size());
+		std::string_view Headers = GetHeaders();
+		m_AsioBuffers[0]		 = asio::const_buffer(Headers.data(), Headers.size());
 	}
 
 	uint16_t ResponseCode() const { return m_ResponseCode; }
@@ -184,6 +199,8 @@ public:
 
 	std::string_view GetHeaders()
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
 				  << "Content-Type: " << MapContentTypeToString(m_ContentType) << "\r\n"
 				  << "Content-Length: " << ContentLength() << "\r\n"sv;
@@ -298,6 +315,8 @@ HttpServerConnection::TerminateConnection()
 void
 HttpServerConnection::EnqueueRead()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if ((m_RequestState == RequestState::kInitialRead) || (m_RequestState == RequestState::kReadingMore))
 	{
 		m_RequestState = RequestState::kReadingMore;
@@ -318,6 +337,8 @@ HttpServerConnection::EnqueueRead()
 void
 HttpServerConnection::OnDataReceived(const asio::error_code& Ec, [[maybe_unused]] std::size_t ByteCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (Ec)
 	{
 		switch (m_RequestState)
@@ -369,6 +390,8 @@ HttpServerConnection::OnDataReceived(const asio::error_code& Ec, [[maybe_unused]
 void
 HttpServerConnection::OnResponseDataSent(const asio::error_code& Ec, [[maybe_unused]] std::size_t ByteCount, bool Pop)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (Ec)
 	{
 		ZEN_WARN("on data sent ERROR, connection: {}, reason: '{}'", m_ConnectionId, Ec.message());
@@ -402,6 +425,8 @@ HttpServerConnection::OnResponseDataSent(const asio::error_code& Ec, [[maybe_unu
 void
 HttpServerConnection::CloseConnection()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (m_RequestState == RequestState::kDone || m_RequestState == RequestState::kTerminated)
 	{
 		return;
@@ -425,6 +450,8 @@ HttpServerConnection::CloseConnection()
 void
 HttpServerConnection::HandleRequest()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (!m_RequestData.IsKeepAlive())
 	{
 		m_RequestState = RequestState::kWritingFinal;
@@ -525,11 +552,11 @@ HttpServerConnection::HandleRequest()
 				Response->SuppressPayload();
 			}
 
-			auto ResponseBuffers = Response->AsioBuffers();
+			const std::vector<asio::const_buffer>& ResponseBuffers = Response->AsioBuffers();
 
 			uint64_t ResponseLength = 0;
 
-			for (auto& Buffer : ResponseBuffers)
+			for (const asio::const_buffer& Buffer : ResponseBuffers)
 			{
 				ResponseLength += Buffer.size();
 			}
@@ -728,6 +755,8 @@ struct HttpAcceptor
 
 	void Start()
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		ZEN_ASSERT(!m_IsStopped);
 		InitAcceptInternal(m_Acceptor);
 		if (m_UseAlternateProtocolAcceptor)
@@ -878,6 +907,8 @@ HttpAsioServerRequest::ReadPayload()
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	m_Response.reset(new HttpResponse(HttpContentType::kBinary));
@@ -889,6 +920,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::span<IoBuffer> Blobs)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	m_Response.reset(new HttpResponse(ContentType));
@@ -898,6 +931,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentT
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::u8string_view ResponseString)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 	m_Response.reset(new HttpResponse(ContentType));
 
@@ -910,6 +945,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentT
 void
 HttpAsioServerRequest::WriteResponseAsync(std::function<void(HttpServerRequest&)>&& ContinuationHandler)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	// Not one bit async, innit
@@ -941,6 +978,8 @@ HttpAsioServerImpl::Initialize(std::filesystem::path DataDir)
 int
 HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(ThreadCount > 0);
 
 	ZEN_INFO("starting asio http with {} service threads", ThreadCount);
@@ -960,6 +999,8 @@ HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 	for (int i = 0; i < ThreadCount; ++i)
 	{
 		m_ThreadPool.emplace_back([this, Index = i + 1] {
+			ZEN_MEMSCOPE(GetHttpasioTag());
+
 			SetCurrentThreadName(fmt::format("asio_io_{}", Index));
 
 			try
@@ -985,6 +1026,8 @@ HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 void
 HttpAsioServerImpl::Stop()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (m_Acceptor)
 	{
 		m_Acceptor->StopAccepting();
@@ -1004,6 +1047,8 @@ HttpAsioServerImpl::Stop()
 void
 HttpAsioServerImpl::RegisterService(const char* InUrlPath, HttpService& Service)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	std::string_view UrlPath(InUrlPath);
 	Service.SetUriPrefixLength(UrlPath.size());
 	if (!UrlPath.empty() && UrlPath.back() == '/')
@@ -1018,6 +1063,8 @@ HttpAsioServerImpl::RegisterService(const char* InUrlPath, HttpService& Service)
 HttpService*
 HttpAsioServerImpl::RouteRequest(std::string_view Url)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	RwLock::SharedLockScope _(m_Lock);
 
 	HttpService*		   CandidateService	  = nullptr;
@@ -1163,6 +1210,8 @@ HttpAsioServer::RequestExit()
 Ref<HttpServer>
 CreateHttpAsioServer(bool ForceLoopback, unsigned int ThreadCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	return Ref<HttpServer>{new HttpAsioServer(ForceLoopback, ThreadCount)};
 }
 
diff --git a/src/zenhttp/servers/httpplugin.cpp b/src/zenhttp/servers/httpplugin.cpp
index 9c2110476..b55d80af8 100644
--- a/src/zenhttp/servers/httpplugin.cpp
+++ b/src/zenhttp/servers/httpplugin.cpp
@@ -12,6 +12,7 @@
 #	include <zencore/filesystem.h>
 #	include <zencore/fmtutils.h>
 #	include <zencore/logging.h>
+#	include <zencore/memory/llm.h>
 #	include <zencore/scopeguard.h>
 #	include <zencore/session.h>
 #	include <zencore/thread.h>
@@ -34,6 +35,14 @@ struct HttpPluginResponse;
 
 using namespace std::literals;
 
+const FLLMTag&
+GetHttppluginTag()
+{
+	static FLLMTag _("httpplugin");
+
+	return _;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 struct HttpPluginConnectionHandler : public TransportServerConnection, public HttpRequestParserCallbacks, RefCounted
@@ -183,6 +192,7 @@ private:
 void
 HttpPluginResponse::InitializeForPayload(uint16_t ResponseCode, std::span<IoBuffer> BlobList)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	ZEN_TRACE_CPU("http_plugin::InitializeForPayload");
 
 	m_ResponseCode			  = ResponseCode;
@@ -224,6 +234,8 @@ HttpPluginResponse::InitializeForPayload(uint16_t ResponseCode, std::span<IoBuff
 std::string_view
 HttpPluginResponse::GetHeaders()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	if (m_Headers.Size() == 0)
 	{
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
@@ -258,6 +270,8 @@ HttpPluginConnectionHandler::~HttpPluginConnectionHandler()
 void
 HttpPluginConnectionHandler::Initialize(TransportConnection* Transport, HttpPluginServerImpl& Server, uint32_t ConnectionId)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	m_TransportConnection = Transport;
 	m_Server			  = &Server;
 	m_ConnectionId		  = ConnectionId;
@@ -290,6 +304,8 @@ HttpPluginConnectionHandler::Release() const
 void
 HttpPluginConnectionHandler::OnBytesRead(const void* Buffer, size_t AvailableBytes)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	ZEN_ASSERT(m_Server);
 
 	ZEN_LOG_TRACE(m_Server->m_RequestLog, "connection #{} OnBytesRead: {}", m_ConnectionId, AvailableBytes);
@@ -317,6 +333,8 @@ HttpPluginConnectionHandler::OnBytesRead(const void* Buffer, size_t AvailableByt
 void
 HttpPluginConnectionHandler::HandleRequest()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	ZEN_ASSERT(m_Server);
 
 	const uint32_t RequestNumber = m_RequestCounter.fetch_add(1);
@@ -516,6 +534,7 @@ HttpPluginConnectionHandler::HandleRequest()
 void
 HttpPluginConnectionHandler::TerminateConnection()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	ZEN_ASSERT(m_TransportConnection);
 	m_TransportConnection->CloseConnection();
 }
@@ -526,6 +545,8 @@ HttpPluginServerRequest::HttpPluginServerRequest(HttpRequestParser& Request, Htt
 : m_Request(Request)
 , m_PayloadBuffer(std::move(PayloadBuffer))
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	const int PrefixLength = Service.UriPrefixLength();
 
 	std::string_view Uri = Request.Url();
@@ -606,6 +627,7 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(HttpContentType::kBinary));
 	std::array<IoBuffer, 0> Empty;
@@ -617,6 +639,7 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::span<IoBuffer> Blobs)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(ContentType));
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Blobs);
@@ -626,6 +649,8 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::u8string_view ResponseString)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	m_Response.reset(new HttpPluginResponse(ContentType));
 
 	IoBuffer				MessageBuffer(IoBuffer::Wrap, ResponseString.data(), ResponseString.size());
@@ -638,6 +663,7 @@ void
 HttpPluginServerRequest::WriteResponseAsync(std::function<void(HttpServerRequest&)>&& ContinuationHandler)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	// Not one bit async, innit
 	ContinuationHandler(*this);
@@ -662,6 +688,7 @@ HttpPluginServerImpl::~HttpPluginServerImpl()
 TransportServerConnection*
 HttpPluginServerImpl::CreateConnectionHandler(TransportConnection* Connection)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	HttpPluginConnectionHandler* Handler{new HttpPluginConnectionHandler()};
 	const uint32_t				 ConnectionId = m_ConnectionIdCounter.fetch_add(1);
 	Handler->Initialize(Connection, *this, ConnectionId);
@@ -671,6 +698,7 @@ HttpPluginServerImpl::CreateConnectionHandler(TransportConnection* Connection)
 int
 HttpPluginServerImpl::Initialize(int BasePort, std::filesystem::path DataDir)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	m_RequestTracer.Initialize(DataDir);
 
 	try
@@ -705,6 +733,8 @@ HttpPluginServerImpl::Close()
 	if (!m_IsInitialized)
 		return;
 
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	try
 	{
 		RwLock::ExclusiveLockScope _(m_Lock);
@@ -736,6 +766,8 @@ HttpPluginServerImpl::Close()
 void
 HttpPluginServerImpl::Run(bool IsInteractive)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	const bool TestMode = !IsInteractive;
 
 	int WaitTimeout = -1;
@@ -786,6 +818,8 @@ HttpPluginServerImpl::RequestExit()
 void
 HttpPluginServerImpl::AddPlugin(Ref<TransportPlugin> Plugin)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::ExclusiveLockScope _(m_Lock);
 	m_Plugins.emplace_back(std::move(Plugin));
 }
@@ -793,6 +827,8 @@ HttpPluginServerImpl::AddPlugin(Ref<TransportPlugin> Plugin)
 void
 HttpPluginServerImpl::RemovePlugin(Ref<TransportPlugin> Plugin)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::ExclusiveLockScope _(m_Lock);
 	auto					   It = std::find(begin(m_Plugins), end(m_Plugins), Plugin);
 	if (It != m_Plugins.end())
@@ -804,6 +840,8 @@ HttpPluginServerImpl::RemovePlugin(Ref<TransportPlugin> Plugin)
 void
 HttpPluginServerImpl::RegisterService(HttpService& Service)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	std::string_view UrlPath(Service.BaseUri());
 	Service.SetUriPrefixLength(UrlPath.size());
 
@@ -819,6 +857,8 @@ HttpPluginServerImpl::RegisterService(HttpService& Service)
 HttpService*
 HttpPluginServerImpl::RouteRequest(std::string_view Url)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::SharedLockScope _(m_Lock);
 
 	HttpService*		   CandidateService	  = nullptr;
@@ -845,6 +885,7 @@ struct HttpPluginServerImpl;
 Ref<HttpPluginServer>
 CreateHttpPluginServer()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	return Ref<HttpPluginServer>(new HttpPluginServerImpl);
 }
 
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; };
 
diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index 9534d93f5..50588b8c0 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -741,6 +741,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 					std::pair<std::string, GcReferencerStats>* Stats = &Result.ReferencerStats[Index];
 					WorkLeft.AddCount(1);
 					PreCachePhaseThreadPool.ScheduleWork([this, &Ctx, &WorkLeft, Owner, Stats, &StoreCompactorsLock, &StoreCompactors]() {
+						ZEN_MEMSCOPE(GetGcTag());
+
 						auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 						try
 						{
@@ -810,6 +812,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 						WorkLeft.AddCount(1);
 						PreCachePhaseThreadPool.ScheduleWork(
 							[this, &Ctx, ReferenceStore, Stats, Index, &WorkLeft, &ReferencePrunersLock, &ReferencePruners]() {
+								ZEN_MEMSCOPE(GetGcTag());
+
 								auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 								try
 								{
@@ -883,6 +887,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 								WorkLeft.AddCount(1);
 								PreCachePhaseThreadPool.ScheduleWork(
 									[this, &Ctx, &WorkLeft, Referencer, Index, Stats, &ReferenceCheckersLock, &ReferenceCheckers]() {
+										ZEN_MEMSCOPE(GetGcTag());
+
 										auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 										// The Referencer will create a reference checker that guarantees that the references do not change
 										// as long as it lives
@@ -965,6 +971,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 																  ReferemcerStats,
 																  &ReferenceValidatorsLock,
 																  &ReferenceValidators]() {
+								ZEN_MEMSCOPE(GetGcTag());
+
 								auto							   _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 								std::vector<GcReferenceValidator*> Validators;
 								try
@@ -1038,6 +1046,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 							std::pair<std::string, GcReferencerStats>* Stats   = &Result.ReferencerStats[Index];
 							WorkLeft.AddCount(1);
 							PreCachePhaseThreadPool.ScheduleWork([this, &Ctx, Checker, Index, Stats, &WorkLeft]() {
+								ZEN_MEMSCOPE(GetGcTag());
+
 								auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 								try
 								{
@@ -1123,6 +1133,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 									std::pair<std::string, GcReferencerStats>* Stats   = &Result.ReferencerStats[Index];
 									WorkLeft.AddCount(1);
 									LockedPhaseThreadPool.ScheduleWork([this, &Ctx, Checker, Index, Stats, &WorkLeft]() {
+										ZEN_MEMSCOPE(GetGcTag());
+
 										auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 										try
 										{
@@ -1197,6 +1209,8 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 							WorkLeft.AddCount(1);
 							LockedPhaseThreadPool.ScheduleWork(
 								[this, &Ctx, Pruner, Stats, &WorkLeft, &GetUnusedReferences, &StoreCompactorsLock, &StoreCompactors]() {
+									ZEN_MEMSCOPE(GetGcTag());
+
 									auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 									// Go through all the ReferenceCheckers to see if the list of Cids the collector selected are
 									// referenced or not.
@@ -2331,6 +2345,8 @@ GcScheduler::CollectGarbage(const GcClock::TimePoint& CacheExpireTime,
 							bool					  EnableValidation,
 							bool					  SilenceErrors)
 {
+	ZEN_MEMSCOPE(GetGcTag());
+
 	ZEN_TRACE_CPU("GcScheduler::CollectGarbage");
 
 	try
diff --git a/src/zenutil/include/zenutil/logging/fullformatter.h b/src/zenutil/include/zenutil/logging/fullformatter.h
index 64010ac1e..07ad408fa 100644
--- a/src/zenutil/include/zenutil/logging/fullformatter.h
+++ b/src/zenutil/include/zenutil/logging/fullformatter.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <zencore/memory/llm.h>
 #include <zencore/zencore.h>
 
 #include <string_view>
@@ -26,10 +27,17 @@ public:
 
 	full_formatter(std::string_view LogId) : m_LogId(LogId), m_LinePrefix(128, ' '), m_UseFullDate(true) {}
 
-	virtual std::unique_ptr<formatter> clone() const override { return std::make_unique<full_formatter>(m_LogId, m_Epoch); }
+	virtual std::unique_ptr<formatter> clone() const override
+	{
+		ZEN_MEMSCOPE(ELLMTag::Logging);
+		// Note: this does not properly clone m_UseFullDate
+		return std::make_unique<full_formatter>(m_LogId, m_Epoch);
+	}
 
 	virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& OutBuffer) override
 	{
+		ZEN_MEMSCOPE(ELLMTag::Logging);
+
 		// Note that the sink is responsible for ensuring there is only ever a
 		// single caller in here
 
diff --git a/src/zenutil/include/zenutil/logging/jsonformatter.h b/src/zenutil/include/zenutil/logging/jsonformatter.h
index 40fdb94e2..3f660e421 100644
--- a/src/zenutil/include/zenutil/logging/jsonformatter.h
+++ b/src/zenutil/include/zenutil/logging/jsonformatter.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <zencore/memory/llm.h>
 #include <zencore/zencore.h>
 
 #include <string_view>
@@ -23,6 +24,8 @@ public:
 
 	virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& dest) override
 	{
+		ZEN_MEMSCOPE(ELLMTag::Logging);
+
 		using std::chrono::duration_cast;
 		using std::chrono::milliseconds;
 		using std::chrono::seconds;
diff --git a/src/zenutil/include/zenutil/logging/rotatingfilesink.h b/src/zenutil/include/zenutil/logging/rotatingfilesink.h
index e01b86cb7..3eb9021dd 100644
--- a/src/zenutil/include/zenutil/logging/rotatingfilesink.h
+++ b/src/zenutil/include/zenutil/logging/rotatingfilesink.h
@@ -26,6 +26,8 @@ public:
 	, m_MaxFiles(MaxFiles)
 	{
 		ZEN_MEMSCOPE(ELLMTag::Logging);
+
+		ZEN_MEMSCOPE(ELLMTag::Logging);
 		std::error_code Ec;
 		if (RotateOnOpen)
 		{
diff --git a/src/zenutil/include/zenutil/logging/testformatter.h b/src/zenutil/include/zenutil/logging/testformatter.h
index bdeb287be..0b0c191fb 100644
--- a/src/zenutil/include/zenutil/logging/testformatter.h
+++ b/src/zenutil/include/zenutil/logging/testformatter.h
@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <zencore/memory/llm.h>
+
 #include <spdlog/spdlog.h>
 
 namespace zen::logging {
@@ -13,12 +15,18 @@ public:
 	{
 	}
 
-	virtual std::unique_ptr<formatter> clone() const override { return std::make_unique<full_test_formatter>(m_LogId, m_Epoch); }
+	virtual std::unique_ptr<formatter> clone() const override
+	{
+		ZEN_MEMSCOPE(ELLMTag::Logging);
+		return std::make_unique<full_test_formatter>(m_LogId, m_Epoch);
+	}
 
 	static constexpr bool UseDate = false;
 
 	virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& dest) override
 	{
+		ZEN_MEMSCOPE(ELLMTag::Logging);
+
 		using namespace std::literals;
 
 		if constexpr (UseDate)