Merge pull request #30 from sy-c/master

stdout/stderr process capture

Author: sy-c

CMakeLists.txt

@@ -118,6 +118,7 @@ set(INFOLOGGER_LIB_OBJECTS
   $<TARGET_OBJECTS:objInfoLoggerClient>
   $<TARGET_OBJECTS:objCommonConfiguration>
   $<TARGET_OBJECTS:objCommonSimpleLog>
+  $<TARGET_OBJECTS:objCommonLineBuffer>
 )
 
 # shared library
@@ -137,6 +138,7 @@ target_link_libraries(InfoLogger
   PUBLIC
 #  AliceO2::Common
   Boost::boost
+  pthread
 )
 install(TARGETS InfoLogger
   EXPORT InfoLoggerTargets
@@ -188,13 +190,13 @@ target_include_directories(libInfoLogger-static
   ${INFOLOGGER_INCLUDE_DIRS_PUBLIC}
 )
 add_dependencies(libInfoLogger-static Common-standalone)
+target_link_libraries(libInfoLogger-static pthread)
 
 
 # executable: log (command line tool to inject log messages)
 add_executable(
   log
-  src/log.cxx
-  $<TARGET_OBJECTS:objCommonLineBuffer>
+  src/log.cxx  
 )
 target_link_libraries(
   log

doc/README.md

@@ -178,6 +178,10 @@ The InfoLogger library allows to inject messages directly from programs, as show
  
  * Some example calls are available in [the source code](/test/testInfoLogger.cxx)
  
+ * There is the possibility to easily redirect FairLogger messages (see InfoLoggerFMQ.hxx) and process stdout/stderr to infologger (see InfoLogger.hxx setStandardRedirection())
+   without changing the code from where they are issued. Although practical to get all output in InfoLogger, the messages captured this way are injected with a reduced number of tags,
+   so it is recommended to use the native InfoLogger API to inject messages whenever possible.
+ 
  * The tags associated to a message consist of the following fields (which may be left undefined):
    * Severity: the kind of message, one of: Info (default), Error, Fatal, Warning, Debug
    * Level: the relative visibility of the message and associated target audience to whom is addressed the message: from 1 (important, visible to all) to 99 (low-level debug message, for experts only).

doc/releaseNotes.md

@@ -19,3 +19,6 @@ This file describes the main feature changes for each InfoLogger released versio
 - node.js binding updated for Mac.
 - Compatibility with mysql v8.
 - Code cleanup (Warnings, clang-format, copyright).
+
+## next version
+- added process stdout/stderr capture and redirection to infologger

include/InfoLogger/InfoLogger.hxx

@@ -196,6 +196,12 @@ class InfoLogger
   // all context fields will be set to default unless an explicit context argument is given for each message.
   int unsetContext();
 
+  /// Turn on/off stdout/stderr redirection
+  /// true -> turn ON. Stdout/Stderr are redirected to internal pipes and a dedicated thread captures the stream and redirects to this instance of infologger (with corresponding severity).
+  /// false -> turn OFF (if it was ON). Stdout/Stderr are redirected to previous outputs, and capture thread is stopped.
+  /// Return 0 on success, or an error code otherwise
+  int setStandardRedirection(bool state);
+
   // todo: common handling of error codes in O2?
   // 0-9999: "shared" -> can be reused accross modules
   // 99.9999: 2-digit 'error namespace' + local error id

src/InfoLogger.cxx

@@ -27,8 +27,12 @@
 #include <sys/types.h>
 #include <pwd.h>
 #include <ctype.h>
+#include <thread>
+#include <memory>
+#include <functional>
 
 #include "InfoLoggerMessageHelper.h"
+#include "Common/LineBuffer.h"
 
 #define InfoLoggerMagicNumber (int)0xABABAC00
 
@@ -261,6 +265,9 @@ class InfoLogger::Impl
   /// \return         0 on success, an error code otherwise (but never throw exceptions)..
   int logV(const InfoLoggerMessageOption& options, const InfoLoggerContext& context, const char* message, va_list ap) __attribute__((format(printf, 4, 0)));
 
+  // main loop of collecting thread, reading incoming messages from a pipe and redirecting to infoLogger
+  void redirectThreadLoop();
+
  protected:
   int magicTag;                                 //< A static tag used for handle validity cross-check
   int numberOfMessages;                         //< number of messages received by this object
@@ -275,6 +282,14 @@ class InfoLogger::Impl
 
   InfoLoggerClient* client; //< entity to communicate with local infoLoggerD
   SimpleLog stdLog;         //< object to output messages to stdout/file
+
+  bool isRedirecting = false;                  // state of stdout/stderr redirection
+  int fdStdout = -1;                           // initial stdout file descriptor, if redirection active
+  int fdStderr = -1;                           // initial stderr file descriptor, if redirection active
+  int pipeStdout[2];                           // a pipe to redirect stdout to collecting thread
+  int pipeStderr[2];                           // a pipe to redirect stderr to collecting thread
+  std::unique_ptr<std::thread> redirectThread; // the thread handling the redirection
+  bool redirectThreadShutdown;                 // flag to ask the thread to stop
 };
 
 void InfoLogger::Impl::refreshDefaultMsg()
@@ -726,6 +741,96 @@ int InfoLogger::setMessageOption(const char* fieldName, const char* fieldValue,
 // required with some compilers to avoid linking errors
 constexpr InfoLogger::InfoLoggerMessageOption InfoLogger::undefinedMessageOption;
 
+void InfoLogger::Impl::redirectThreadLoop()
+{
+  LineBuffer lbStdout; // buffer for input lines
+  LineBuffer lbStderr; // buffer for input lines
+  std::string msg;
+  bool isActive = 0;
+  while (!redirectThreadShutdown) {
+    isActive = 0;
+    lbStdout.appendFromFileDescriptor(pipeStdout[0], 0);
+    for (;;) {
+      if (lbStdout.getNextLine(msg)) {
+        // no line left
+        break;
+      }
+      isActive = 1;
+      pushMessage(InfoLogger::Severity::Info, msg.c_str());
+    }
+    lbStderr.appendFromFileDescriptor(pipeStderr[0], 0);
+    for (;;) {
+      if (lbStderr.getNextLine(msg)) {
+        // no line left
+        break;
+      }
+      isActive = 1;
+      pushMessage(InfoLogger::Severity::Error, msg.c_str());
+    }
+
+    if (!isActive) {
+      usleep(50000);
+    }
+  }
+  //  fprintf(fp,"thread stopped\n");
+  //  fclose(fp);
+}
+
+int InfoLogger::setStandardRedirection(bool state)
+{
+  if (state == mPimpl->isRedirecting) {
+    // we are already in the requested redirection state
+    return -1;
+  }
+
+  if (state) {
+    // turn ON redirection
+
+    // create a pipe
+    if (pipe(mPimpl->pipeStdout) != 0) {
+      return -1;
+    }
+    if (pipe(mPimpl->pipeStderr) != 0) {
+      return -1;
+    }
+
+    // save current stdout/stderr
+    mPimpl->fdStdout = dup(STDOUT_FILENO);
+    dup2(mPimpl->pipeStdout[1], STDOUT_FILENO);
+    mPimpl->fdStderr = dup(STDERR_FILENO);
+    dup2(mPimpl->pipeStderr[1], STDERR_FILENO);
+
+    mPimpl->stdLog.setFileDescriptors(mPimpl->fdStdout, mPimpl->fdStderr);
+
+    // create collecting thread
+    mPimpl->redirectThreadShutdown = 0;
+    std::function<void(void)> l = std::bind(&InfoLogger::Impl::redirectThreadLoop, mPimpl.get());
+    mPimpl->redirectThread = std::make_unique<std::thread>(l);
+
+  } else {
+    // turn OFF redirection
+
+    // stop collecting thread
+    mPimpl->redirectThreadShutdown = 1;
+    mPimpl->redirectThread->join();
+    mPimpl->redirectThread = nullptr;
+
+    mPimpl->stdLog.setFileDescriptors(STDOUT_FILENO, STDERR_FILENO);
+
+    dup2(mPimpl->fdStdout, STDOUT_FILENO);
+    close(mPimpl->fdStdout);
+    close(mPimpl->pipeStdout[0]);
+    close(mPimpl->pipeStdout[1]);
+    dup2(mPimpl->fdStderr, STDERR_FILENO);
+    close(mPimpl->fdStderr);
+    close(mPimpl->pipeStderr[0]);
+    close(mPimpl->pipeStderr[1]);
+  }
+
+  mPimpl->isRedirecting = state;
+  return 0;
+}
+
 // end of namespace
 } // namespace InfoLogger
 } // namespace AliceO2

test/testInfoLogger.cxx

@@ -22,6 +22,15 @@ int main()
 {
   InfoLogger theLog;
 
+  theLog.log("infoLogger message test");
+  printf("Message on stdout (initial stdout)\n");
+  theLog.setStandardRedirection(1);
+  printf("Message on stdout (redirection enabled)\n");
+  fprintf(stderr, "Message on stderr (redirection enabled)\n");
+  usleep(100000);
+  theLog.setStandardRedirection(0);
+  printf("Message on stdout (redirection stopped)\n");
+
   theLog.log("infoLogger message test");
   theLog.log(InfoLogger::Severity::Info, "infoLogger INFO message test");
   theLog.log(InfoLogger::Severity::Warning, "infoLogger WARNING message test");