Merge pull request #3175 from elandini84/feature/yarpmanager/error_time_stamp

randaz81 · web-flow · commit 342b52f2b404 · 2025-02-12T10:22:31.000+01:00
Feature: `yarpmanager` log messages time stamp
diff --git a/doc/release/master.md b/doc/release/master.md
@@ -29,7 +29,7 @@ Fixes
 New Features
 ------------
 
-### devices 
+### devices
 
 #### multiplenalogsensorremapper
 
@@ -42,6 +42,10 @@ New Features
 
 * `yarpopencvdisplay` is now able to display a `yarp::sig::LayeredImage`
 
+#### `yarpmanager`
+  * Added time info to `libYARP_manager` logger and to `yarpmanager` GUI.
+  * The time info can be displayed as the current time (obtained from `std::chrono::system_clock::now()`) or as time elapsed since yarpmanager GUI launch
+
 ### Libraries
 
 #### `libYARP_sig`
@@ -62,7 +66,7 @@ New Features
   IMap2D
   INavigation2D
   IOdometry2D
-  
+
 #### `devices`
 
 * Updated all devices which use the interfaces employing the new class `ReturnValue`:
diff --git a/src/guis/yarpmanager/src-manager/clusterWidget.cpp b/src/guis/yarpmanager/src-manager/clusterWidget.cpp
@@ -157,6 +157,7 @@ void ClusterWidget::onRunServer()
 {
     updateServerEntries();
 
+    yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
     std::string cmdRunServer = getSSHCmd(cluster.user, cluster.nsNode, cluster.ssh_options);
     if (ui->checkRos->isChecked())
     {
@@ -169,7 +170,8 @@ void ClusterWidget::onRunServer()
     if (system(cmdRunServer.c_str()) != 0)
     {
         std::string err = "ClusterWidget: failed to run the server on " + cluster.nsNode;
-        logError(QString(err.c_str()));
+        logger->addError(err);
+        reportErrors();
     }
     else
     {
@@ -201,10 +203,13 @@ void ClusterWidget::onStopServer()
 
     cmdStopServer = cmdStopServer + " killall yarpserver &";
 
+    yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
+
     if (system(cmdStopServer.c_str()) != 0)
     {
         std::string err = "ClusterWidget: failed to stop the server on " + cluster.nsNode;
-        logError(QString(err.c_str()));
+        logger->addError(err);
+        reportErrors();
     }
     else
     {
@@ -232,10 +237,12 @@ void ClusterWidget::onKillServer()
 
     cmdKillServer = cmdKillServer + " killall -9 yarpserver &";
 
+    yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
     if (system(cmdKillServer.c_str()) != 0)
     {
         std::string err = "ClusterWidget: failed to kill the server on " + cluster.nsNode;
-        logError(QString(err.c_str()));
+        logger->addError(err);
+        reportErrors();
     }
     else
     {
@@ -284,10 +291,12 @@ void ClusterWidget::onRunSelected()
         {
             cmdRunYarprun.append("'");
         }
+        yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
         if (system(cmdRunYarprun.c_str()) != 0)
         {
             std::string err = "ClusterWidget: failed to run yarprun on " + node.name;
-            logError(QString(err.c_str()));
+            logger->addError(err);
+            reportErrors();
         }
         else
         {
@@ -322,10 +331,12 @@ void ClusterWidget::onStopSelected()
 
         cmdStopYarprun.append(" yarprun --exit --on ").append(portName).append(" &");
 
+        yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
         if (system(cmdStopYarprun.c_str()) != 0)
         {
             std::string err = "ClusterWidget: failed to stop yarprun on " + node.name;
-            logError(QString(err.c_str()));
+            logger->addError(err);
+            reportErrors();
         }
         else
         {
@@ -354,10 +365,12 @@ void ClusterWidget::onKillSelected()
 
         cmdKillYarprun.append(" killall -9 yarprun &");
 
+        yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
         if (system(cmdKillYarprun.c_str()) != 0)
         {
             std::string err = "ClusterWidget: failed to kill yarprun on " + node.name;
-            logError(QString(err.c_str()));
+            logger->addError(err);
+            reportErrors();
         }
         else
         {
@@ -399,10 +412,12 @@ void ClusterWidget::onExecute()
 
     cmdExecute.append(" ").append(command);
 
+    yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
     if (system(cmdExecute.c_str()) != 0)
     {
         std::string err = "ClusterWidget: failed to run "+ command + " on " + node.name;
-        logError(QString(err.c_str()));
+        logger->addError(err);
+        reportErrors();
     }
     else
     {
@@ -594,6 +609,20 @@ void ClusterWidget::updateServerEntries()
     cluster.nsNode = ui->nsNodeComboBox->currentText().simplified().trimmed().toStdString();
 }
 
+void ClusterWidget::reportErrors()
+{
+    yarp::manager::ErrorLogger* logger  = yarp::manager::ErrorLogger::Instance();
+    if (logger->errorCount() || logger->warningCount())
+    {
+        const char* err;
+        while((err=logger->getLastError()))
+        {
+            QString msg = QString("ClusterWidget: %1").arg(err);
+            emit logError(msg);
+        }
+    }
+}
+
 ClusterWidget::~ClusterWidget()
 {
     if (clusLoader)
diff --git a/src/guis/yarpmanager/src-manager/clusterWidget.h b/src/guis/yarpmanager/src-manager/clusterWidget.h
@@ -47,6 +47,7 @@ private slots:
     bool checkNameserver();
     bool checkNode(const std::string& name);
     void updateServerEntries();
+    void reportErrors();
 
 
     Ui::ClusterWidget *ui;
diff --git a/src/guis/yarpmanager/src-manager/main.cpp b/src/guis/yarpmanager/src-manager/main.cpp
@@ -33,6 +33,7 @@ Options:\n\
   --auto_connect        \n\
   --auto_dependency     \n\
   --add_current_dir     add the current dir to the search path\n\
+  --elapsed_time        if present the time stamp for log messages will be relative to the GUI start time\n\
 "
 
 #define DEF_CONFIG_FILE     "ymanager.ini"
@@ -206,6 +207,12 @@ int main(int argc, char *argv[])
         config.put("auto_dependency", "no");
     }
 
+    if(!config.check("elapsed_time"))
+    {
+        yarp::manager::ClockStart& clock = yarp::manager::ClockStart::getInstance();
+        clock.setStartTime("00:00:00");
+    }
+
 #if defined(_WIN32)
     //setup signal handler for windows
 //    signal(SIGINT, onSignal);
diff --git a/src/guis/yarpmanager/src-manager/mainwindow.cpp b/src/guis/yarpmanager/src-manager/mainwindow.cpp
@@ -890,6 +890,8 @@ void MainWindow::onLogWarning(QString msg)
  */
 void MainWindow::onLogMessage(QString msg)
 {
+    ClockStart& clock = ClockStart::getInstance();
+    msg = QString("[time: %1] ").arg(getElapsedTimeString(clock.getStartTime()).c_str()) + msg;
     QString text = QString ("[MSG] %1").arg(msg);
     ui->logWidget->addItem(text);
     ui->logWidget->setCurrentRow(ui->logWidget->count() - 1);
diff --git a/src/libYARP_manager/src/yarp/manager/utility.cpp b/src/libYARP_manager/src/yarp/manager/utility.cpp
@@ -103,12 +103,20 @@ ErrorLogger* ErrorLogger::Instance()
 
 void ErrorLogger::addWarning(const char* szWarning) {
     if (szWarning) {
-        warnings.emplace_back(szWarning);
+        ClockStart& clock = ClockStart::getInstance();
+        std::string elapsedTime = getElapsedTimeString(clock.getStartTime());
+        std::string timeinfo = "[time: " + elapsedTime + "] ";
+        std::string szWarningWithTime = timeinfo + szWarning;
+        warnings.emplace_back(szWarningWithTime);
     }
 }
 
 void ErrorLogger::addWarning(const std::string &str) {
-    warnings.push_back(str);
+    ClockStart& clock = ClockStart::getInstance();
+    std::string elapsedTime = getElapsedTimeString(clock.getStartTime());
+    std::string timeinfo = "[time: " + elapsedTime + "] ";
+    std::string strWithTime = timeinfo + str;
+    warnings.push_back(strWithTime);
 }
 
 void ErrorLogger::addWarning(OSTRINGSTREAM &stream) {
@@ -117,12 +125,20 @@ void ErrorLogger::addWarning(OSTRINGSTREAM &stream) {
 
 void ErrorLogger::addError(const char* szError) {
     if (szError) {
-        errors.emplace_back(szError);
+        ClockStart& clock = ClockStart::getInstance();
+        std::string elapsedTime = getElapsedTimeString(clock.getStartTime());
+        std::string timeinfo = "[time: " + elapsedTime + "] ";
+        std::string szErrorWithTime = timeinfo + szError;
+        errors.emplace_back(szErrorWithTime);
     }
 }
 
 void ErrorLogger::addError(const std::string &str) {
-    errors.push_back(str);
+    ClockStart& clock = ClockStart::getInstance();
+    std::string elapsedTime = getElapsedTimeString(clock.getStartTime());
+    std::string timeinfo = "[time: " + elapsedTime + "] ";
+    std::string strWithTime = timeinfo + str;
+    errors.push_back(strWithTime);
 }
 
 void ErrorLogger::addError(OSTRINGSTREAM &stream) {
@@ -328,6 +344,62 @@ bool yarp::manager::compareString(const char* szFirst, const char* szSecond)
     return false;
 }
 
+std::string yarp::manager::getCurrentTimeString() {
+    auto now = std::chrono::system_clock::now();
+    std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
+
+    std::tm localTime;
+#ifdef _WIN32
+    localtime_s(&localTime, &currentTime); // Windows
+#else
+    localtime_r(&currentTime, &localTime); // POSIX
+#endif
+    std::ostringstream oss;
+    oss << std::put_time(&localTime, "%H:%M:%S");
+    return oss.str();
+}
+
+std::string yarp::manager::getElapsedTimeString(const std::string& startTimeStr) {
+    std::tm startTime{};
+    std::istringstream iss(startTimeStr);
+    iss >> std::get_time(&startTime, "%H:%M:%S");
+    if (iss.fail()) {
+        throw std::invalid_argument("Invalid time format. Expected %H:%M:%S");
+    }
+
+    auto now = std::chrono::system_clock::now();
+    std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
+
+    std::tm localTime;
+#ifdef _WIN32
+    localtime_s(&localTime, &currentTime); // Windows
+#else
+    localtime_r(&currentTime, &localTime); // POSIX
+#endif
+
+    localTime.tm_hour = startTime.tm_hour;
+    localTime.tm_min = startTime.tm_min;
+    localTime.tm_sec = startTime.tm_sec;
+
+    std::time_t startTimestamp = std::mktime(&localTime);
+
+    auto elapsedSeconds = std::difftime(currentTime, startTimestamp);
+    if (elapsedSeconds < 0) {
+        elapsedSeconds += 24 * 60 * 60; // Handle cases where the start time is on the previous day
+    }
+
+    int hours = static_cast<int>(elapsedSeconds) / 3600;
+    int minutes = (static_cast<int>(elapsedSeconds) % 3600) / 60;
+    int seconds = static_cast<int>(elapsedSeconds) % 60;
+
+    std::ostringstream oss;
+    oss << std::setfill('0') << std::setw(2) << hours << ":"
+        << std::setfill('0') << std::setw(2) << minutes << ":"
+        << std::setfill('0') << std::setw(2) << seconds;
+
+    return oss.str();
+}
+
 void yarp::manager::trimString(std::string& str)
 {
     std::string::size_type pos = str.find_last_not_of(' ');
diff --git a/src/libYARP_manager/src/yarp/manager/utility.h b/src/libYARP_manager/src/yarp/manager/utility.h
@@ -13,6 +13,8 @@
 #include <cstring>
 #include <iostream>
 #include <sstream>
+#include <chrono>
+#include <iomanip>
 
 #include <yarp/manager/ymm-types.h>
 
@@ -78,8 +80,65 @@ class ErrorLogger
     std::vector<std::string> warnings;
 };
 
+/**
+ * Singleton class For storing execution start time
+ */
+class ClockStart {
+public:
+    static ClockStart& getInstance() {
+        static ClockStart instance;
+        return instance;
+    }
+
+    ClockStart(const ClockStart&) = delete;
+    ClockStart& operator=(const ClockStart&) = delete;
+
+    /**
+     * @brief Get the starting time as a string in HH:MM:SS format
+     * @return the starting time as a string
+     */
+    std::string getStartTime() const {
+        std::ostringstream oss;
+        oss << std::put_time(&startTimeStruct, "%H:%M:%S");
+        return oss.str();
+    }
+
+    /**
+     * @brief Set the starting time from a string in HH:MM:SS format
+     * @param startTimeStr the starting time as a string
+     */
+    void setStartTime(std::string startTimeStr) {
+        std::istringstream iss(startTimeStr);
+        std::tm tm = {};
+        if (iss >> std::get_time(&tm, "%H:%M:%S")) {
+            startTimeStruct = tm;
+        }
+    }
+
+private:
+    std::chrono::system_clock::time_point startTime;
+    std::tm startTimeStruct;
+
+    /**
+     * @brief Private constructor to initialize the start time
+     * @details The start time is initialized to the current time
+     */
+    ClockStart() {
+        startTime = std::chrono::system_clock::now();
+        std::time_t startTimeT = std::chrono::system_clock::to_time_t(startTime);
+
+#ifdef _WIN32
+        localtime_s(&startTimeStruct, &startTimeT);
+#else
+        localtime_r(&startTimeT, &startTimeStruct);
+#endif
+    }
+};
+
 
 bool compareString(const char* szFirst, const char* szSecond);
+std::string getCurrentTimeString();
+std::string getElapsedTimeString(const std::string& startTimeStr);
 void trimString(std::string& str);
 OS strToOS(const char* szOS);
 
diff --git a/src/yarpmanager-console/ymanager.cpp b/src/yarpmanager-console/ymanager.cpp
@@ -97,6 +97,7 @@ Options:\n\
   --silent                Do not print the status messages (should be used with --application)\n\
   --exit                  Immediately exit after executing the commands (should be used with --application)\n\
   --from <conf>           Configuration file name\n\
+  --elapsed_time          if present the time stamp for log messages will be relative to the GUI start time\n\
   --version               Show current version\n\
   --help                  Show help\n"
 
@@ -152,6 +153,13 @@ YConsoleManager::YConsoleManager(int argc, char* argv[]) : Manager()
         return;
     }
 
+    // I the option elapsed_time is not set, set the start time to 00:00:00 (For error and warning logging)
+    if(!config.check("elapsed_time"))
+    {
+        yarp::manager::ClockStart& clock = yarp::manager::ClockStart::getInstance();
+        clock.setStartTime("00:00:00");
+    }
+
     /**
      *  preparing default options
      */

Original file line number	Diff line number	Diff line change
`@@ -157,6 +157,7 @@ void ClusterWidget::onRunServer()`
`157`	`157`	`{`
`158`	`158`	`updateServerEntries();`
`159`	`159`
	`160`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`160`	`161`	`std::string cmdRunServer = getSSHCmd(cluster.user, cluster.nsNode, cluster.ssh_options);`
`161`	`162`	`if (ui->checkRos->isChecked())`
`162`	`163`	`{`
`@@ -169,7 +170,8 @@ void ClusterWidget::onRunServer()`
`169`	`170`	`if (system(cmdRunServer.c_str()) != 0)`
`170`	`171`	`{`
`171`	`172`	`std::string err = "ClusterWidget: failed to run the server on " + cluster.nsNode;`
`172`		`- logError(QString(err.c_str()));`
	`173`	`+ logger->addError(err);`
	`174`	`+ reportErrors();`
`173`	`175`	`}`
`174`	`176`	`else`
`175`	`177`	`{`
`@@ -201,10 +203,13 @@ void ClusterWidget::onStopServer()`
`201`	`203`
`202`	`204`	`cmdStopServer = cmdStopServer + " killall yarpserver &";`
`203`	`205`
	`206`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
	`207`	`+`
`204`	`208`	`if (system(cmdStopServer.c_str()) != 0)`
`205`	`209`	`{`
`206`	`210`	`std::string err = "ClusterWidget: failed to stop the server on " + cluster.nsNode;`
`207`		`- logError(QString(err.c_str()));`
	`211`	`+ logger->addError(err);`
	`212`	`+ reportErrors();`
`208`	`213`	`}`
`209`	`214`	`else`
`210`	`215`	`{`
`@@ -232,10 +237,12 @@ void ClusterWidget::onKillServer()`
`232`	`237`
`233`	`238`	`cmdKillServer = cmdKillServer + " killall -9 yarpserver &";`
`234`	`239`
	`240`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`235`	`241`	`if (system(cmdKillServer.c_str()) != 0)`
`236`	`242`	`{`
`237`	`243`	`std::string err = "ClusterWidget: failed to kill the server on " + cluster.nsNode;`
`238`		`- logError(QString(err.c_str()));`
	`244`	`+ logger->addError(err);`
	`245`	`+ reportErrors();`
`239`	`246`	`}`
`240`	`247`	`else`
`241`	`248`	`{`
`@@ -284,10 +291,12 @@ void ClusterWidget::onRunSelected()`
`284`	`291`	`{`
`285`	`292`	`cmdRunYarprun.append("'");`
`286`	`293`	`}`
	`294`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`287`	`295`	`if (system(cmdRunYarprun.c_str()) != 0)`
`288`	`296`	`{`
`289`	`297`	`std::string err = "ClusterWidget: failed to run yarprun on " + node.name;`
`290`		`- logError(QString(err.c_str()));`
	`298`	`+ logger->addError(err);`
	`299`	`+ reportErrors();`
`291`	`300`	`}`
`292`	`301`	`else`
`293`	`302`	`{`
`@@ -322,10 +331,12 @@ void ClusterWidget::onStopSelected()`
`322`	`331`
`323`	`332`	`cmdStopYarprun.append(" yarprun --exit --on ").append(portName).append(" &");`
`324`	`333`
	`334`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`325`	`335`	`if (system(cmdStopYarprun.c_str()) != 0)`
`326`	`336`	`{`
`327`	`337`	`std::string err = "ClusterWidget: failed to stop yarprun on " + node.name;`
`328`		`- logError(QString(err.c_str()));`
	`338`	`+ logger->addError(err);`
	`339`	`+ reportErrors();`
`329`	`340`	`}`
`330`	`341`	`else`
`331`	`342`	`{`
`@@ -354,10 +365,12 @@ void ClusterWidget::onKillSelected()`
`354`	`365`
`355`	`366`	`cmdKillYarprun.append(" killall -9 yarprun &");`
`356`	`367`
	`368`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`357`	`369`	`if (system(cmdKillYarprun.c_str()) != 0)`
`358`	`370`	`{`
`359`	`371`	`std::string err = "ClusterWidget: failed to kill yarprun on " + node.name;`
`360`		`- logError(QString(err.c_str()));`
	`372`	`+ logger->addError(err);`
	`373`	`+ reportErrors();`
`361`	`374`	`}`
`362`	`375`	`else`
`363`	`376`	`{`
`@@ -399,10 +412,12 @@ void ClusterWidget::onExecute()`
`399`	`412`
`400`	`413`	`cmdExecute.append(" ").append(command);`
`401`	`414`
	`415`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
`402`	`416`	`if (system(cmdExecute.c_str()) != 0)`
`403`	`417`	`{`
`404`	`418`	`std::string err = "ClusterWidget: failed to run "+ command + " on " + node.name;`
`405`		`- logError(QString(err.c_str()));`
	`419`	`+ logger->addError(err);`
	`420`	`+ reportErrors();`
`406`	`421`	`}`
`407`	`422`	`else`
`408`	`423`	`{`
`@@ -594,6 +609,20 @@ void ClusterWidget::updateServerEntries()`
`594`	`609`	`cluster.nsNode = ui->nsNodeComboBox->currentText().simplified().trimmed().toStdString();`
`595`	`610`	`}`
`596`	`611`
	`612`	`+void ClusterWidget::reportErrors()`
	`613`	`+{`
	`614`	`+ yarp::manager::ErrorLogger* logger = yarp::manager::ErrorLogger::Instance();`
	`615`	`+ if (logger->errorCount() \|\| logger->warningCount())`
	`616`	`+ {`
	`617`	`+ const char* err;`
	`618`	`+ while((err=logger->getLastError()))`
	`619`	`+ {`
	`620`	`+ QString msg = QString("ClusterWidget: %1").arg(err);`
	`621`	`+ emit logError(msg);`
	`622`	`+ }`
	`623`	`+ }`
	`624`	`+}`
	`625`	`+`
`597`	`626`	`ClusterWidget::~ClusterWidget()`
`598`	`627`	`{`
`599`	`628`	`if (clusLoader)`
Original file line number	Diff line number	Diff line change
`@@ -890,6 +890,8 @@ void MainWindow::onLogWarning(QString msg)`
`890`	`890`	`*/`
`891`	`891`	`void MainWindow::onLogMessage(QString msg)`
`892`	`892`	`{`
	`893`	`+ ClockStart& clock = ClockStart::getInstance();`
	`894`	`+ msg = QString("[time: %1] ").arg(getElapsedTimeString(clock.getStartTime()).c_str()) + msg;`
`893`	`895`	`QString text = QString ("[MSG] %1").arg(msg);`
`894`	`896`	`ui->logWidget->addItem(text);`
`895`	`897`	`ui->logWidget->setCurrentRow(ui->logWidget->count() - 1);`