Added db stats in trace metadata

src/libs/core/impl/TraceLogger.cpp

@@ -69,6 +69,15 @@ namespace lms::core::tracing
             _freeBuffers.push_back(&buffer);
 
         LMS_LOG(UTILS, INFO, "TraceLogger: using " << _buffers.size() << " buffers. Buffer size = " << std::to_string(BufferSize) << ", entry size = " << sizeof(CompleteEventEntry) << ", entry count per buffer = " << Buffer::CompleteEventCount);
+
+        setMetadata("cpu_count", std::to_string(std::thread::hardware_concurrency()));
+        setMetadata("build_type", 
+#ifndef NDEBUG
+        "debug"
+#else
+        "release"
+#endif
+        );
     }
 
     bool TraceLogger::isLevelActive(Level level) const
@@ -203,15 +212,16 @@ namespace lms::core::tracing
 
         os << std::endl;
         os << "\t]," << std::endl;
-        os << "\t\"meta_registered_arg_count\" : " << getRegisteredArgCount() << ", " << std::endl;
-        os << "\t\"meta_cpu_count\" : " << std::thread::hardware_concurrency() << ", " << std::endl;
-        os << "\t\"meta_build_type\" : ";
-#ifndef NDEBUG
-        os << "\"debug\"";
-#else
-        os << "\"release\"";
-#endif
-        os << std::endl;
+        {
+            std::scoped_lock lock{ _metadataMutex };
+            for (const auto& [metadata, value] : _metadata)
+            {
+                os << "\t\"meta_" << metadata << "\": \"";
+                stringUtils::writeJsonEscapedString(os, value);
+                os << "\"," << std::endl;
+            }
+        }
+        os << "\t\"meta_registered_arg_count\" : " << getRegisteredArgCount() << std::endl;
         os << "}" << std::endl;
     }
 
@@ -262,6 +272,12 @@ namespace lms::core::tracing
         }
     }
 
+    void TraceLogger::setMetadata(std::string_view metadata, std::string_view value)
+    {
+        const std::scoped_lock lock{ _metadataMutex };
+        _metadata[std::string{ metadata }] = value;
+    }
+
     std::size_t TraceLogger::getRegisteredArgCount() const
     {
         const std::shared_lock lock{ _argMutex };

src/libs/core/impl/TraceLogger.hpp

@@ -21,6 +21,7 @@
 
 #include <array>
 #include <deque>
+#include <map>
 #include <mutex>
 #include <shared_mutex>
 #include <thread>
@@ -44,6 +45,8 @@ namespace lms::core::tracing
         void dumpCurrentBuffer(std::ostream& os) override;
         void setThreadName(std::thread::id id, std::string_view threadName) override;
         ArgHashType registerArg(LiteralString argType, std::string_view argValue) override;
+        void setMetadata(std::string_view metadata, std::string_view value) override;
+
         std::size_t getRegisteredArgCount() const;
 
         static ArgHashType computeArgHash(LiteralString type, std::string_view value);
@@ -92,6 +95,9 @@ namespace lms::core::tracing
         std::mutex _threadNameMutex;
         std::unordered_map<std::thread::id, std::string> _threadNames;
 
+        std::mutex _metadataMutex;
+        std::map<std::string, std::string> _metadata;
+
         std::mutex _mutex;
         std::deque<Buffer*> _freeBuffers;
 

src/libs/core/include/core/ITraceLogger.hpp

@@ -79,6 +79,7 @@ namespace lms::core::tracing
         virtual void write(const CompleteEvent& entry) = 0;
         virtual void dumpCurrentBuffer(std::ostream& os) = 0;
         virtual void setThreadName(std::thread::id id, std::string_view threadName) = 0;
+        virtual void setMetadata(std::string_view metadata, std::string_view value) = 0;
 
         virtual ArgHashType registerArg(LiteralString argType, std::string_view argValue) = 0;
     };

src/libs/database/impl/Session.cpp

@@ -200,6 +200,27 @@ namespace lms::db
         }
     }
 
+    void Session::refreshTracingLoggerStats()
+    {
+        auto* traceLogger{ core::Service<core::tracing::ITraceLogger>::get() };
+        if (!traceLogger)
+            return;
+
+        auto& dbSession{ _db.getTLSSession() };
+        auto transaction{ dbSession.createReadTransaction() };
+
+        traceLogger->setMetadata("db_artist_count", std::to_string(db::Artist::getCount(dbSession)));
+        traceLogger->setMetadata("db_cluster_count", std::to_string(db::Cluster::getCount(dbSession)));
+        traceLogger->setMetadata("db_cluster_type_count", std::to_string(db::ClusterType::getCount(dbSession)));
+        traceLogger->setMetadata("db_starred_artist_count", std::to_string(db::StarredArtist::getCount(dbSession)));
+        traceLogger->setMetadata("db_starred_release_count", std::to_string(db::StarredRelease::getCount(dbSession)));
+        traceLogger->setMetadata("db_starred_track_count", std::to_string(db::StarredTrack::getCount(dbSession)));
+        traceLogger->setMetadata("db_track_bookmark_count", std::to_string(db::TrackBookmark::getCount(dbSession)));
+        traceLogger->setMetadata("db_listen_count", std::to_string(db::Listen::getCount(dbSession)));
+        traceLogger->setMetadata("db_release_count", std::to_string(db::Release::getCount(dbSession)));
+        traceLogger->setMetadata("db_track_count", std::to_string(db::Track::getCount(dbSession)));
+    }
+
     void Session::analyze()
     {
         LMS_SCOPED_TRACE_DETAILED("Database", "Analyze");

src/libs/database/include/database/Session.hpp

@@ -88,6 +88,7 @@ namespace lms::db
         void optimize();
 
         void prepareTables(); // need to run only once at startup
+        void refreshTracingLoggerStats();
 
         // returning a ptr here to ease further wrapping using operator->
         Wt::Dbo::Session* getDboSession() { return &_session; }

src/lms/main.cpp

@@ -286,6 +286,7 @@ namespace lms
                 // force optimize in case scanner aborted during a large import:
                 // queries may be too slow to even be able to relaunch a scan sing the web interface
                 session.analyze();
+                database.getTLSSession().refreshTracingLoggerStats();
             }
 
             ui::LmsApplicationManager appManager;
@@ -320,6 +321,7 @@ namespace lms
                     // Flush cover cache even if no changes:
                     // covers may be external files that changed and we don't keep track of them for now (but we should)
                     coverService->flushCache();
+                    database.getTLSSession().refreshTracingLoggerStats();
                 });
 
             core::Service<feedback::IFeedbackService> feedbackService{ feedback::createFeedbackService(ioContext, database) };