[QC-681] Use dpl infologger

Framework/include/QualityControl/QcInfoLogger.h

@@ -40,50 +40,64 @@ namespace o2::quality_control::core
 ///           ILOG(Info, Ops) << "Test message with severity Info and level Ops, see InfoLoggerMacros.hxx" << ENDM;
 ///
 /// \author Barthelemy von Haller
-class QcInfoLogger : public AliceO2::InfoLogger::InfoLogger
+class QcInfoLogger
 {
-
  public:
-  static QcInfoLogger& GetInstance()
+  static AliceO2::InfoLogger::InfoLogger& GetInfoLogger()
   {
-    // Guaranteed to be destroyed. Instantiated on first use
-    static QcInfoLogger foo;
-    return foo;
+    return *instance;
   }
 
-  void setFacility(const std::string& facility);
-  void setDetector(const std::string& detector);
-  void setRun(int run);
-  void setPartition(std::string& partitionName);
-  void init(const std::string& facility,
-            bool discardDebug = false,
-            int discardFromLevel = 21 /* Discard Trace */,
-            AliceO2::InfoLogger::InfoLoggerContext* dplContext = nullptr,
-            int run = -1,
-            std::string partitionName = "");
-  void init(const std::string& facility,
-            const boost::property_tree::ptree& config,
-            AliceO2::InfoLogger::InfoLoggerContext* dplContext = nullptr,
-            int run = -1,
-            std::string partitionName = "");
-
- private:
-  QcInfoLogger();
-  ~QcInfoLogger() override = default;
-
-  // Disallow copying
+  // disable non-static
+  QcInfoLogger() = delete;
+  ~QcInfoLogger() = delete;
   QcInfoLogger& operator=(const QcInfoLogger&) = delete;
   QcInfoLogger(const QcInfoLogger&) = delete;
 
-  // remember the contexts
-  std::shared_ptr<AliceO2::InfoLogger::InfoLoggerContext> mContext = nullptr;
-  AliceO2::InfoLogger::InfoLoggerContext* mDplContext = nullptr;
+  static void setFacility(const std::string& facility);
+  static void setDetector(const std::string& detector);
+  static void setRun(int run);
+  static void setPartition(const std::string& partitionName);
+  static void init(const std::string& facility,
+                   bool discardDebug = false,
+                   int discardFromLevel = 21 /* Discard Trace */,
+                   AliceO2::InfoLogger::InfoLogger* dplInfoLogger = nullptr,
+                   AliceO2::InfoLogger::InfoLoggerContext* dplContext = nullptr,
+                   int run = -1,
+                   std::string partitionName = "");
+  static void init(const std::string& facility,
+                   const boost::property_tree::ptree& config,
+                   AliceO2::InfoLogger::InfoLogger* dplInfoLogger = nullptr,
+                   AliceO2::InfoLogger::InfoLoggerContext* dplContext = nullptr,
+                   int run = -1,
+                   std::string partitionName = "");
+
+  // build a default infologger
+  static class _init
+  {
+   public:
+    _init()
+    {
+      std::cout << "BUILDING INSTANCE OF IL" << std::endl;
+      instance = new AliceO2::InfoLogger::InfoLogger();
+      mContext = new AliceO2::InfoLogger::InfoLoggerContext();
+      mContext->setField(infoContext::FieldName::Facility, "QC");
+      mContext->setField(infoContext::FieldName::System, "QC");
+      instance->setContext(*mContext);
+    }
+  } _initializer;
+
+ private:
+  // raw pointers because we don't want to take ownership of dpl pointers and destroy them.
+  // if we keep the default infologger it will any ways be valid till the end of the process.
+  static AliceO2::InfoLogger::InfoLogger* instance;
+  static AliceO2::InfoLogger::InfoLoggerContext* mContext;
 };
 
 } // namespace o2::quality_control::core
 
 // Define shortcuts to our instance using macros.
-#define ILOG_INST o2::quality_control::core::QcInfoLogger::GetInstance()
+#define ILOG_INST o2::quality_control::core::QcInfoLogger::GetInfoLogger()
 #define ILOGI ILOG_INST << AliceO2::InfoLogger::InfoLogger::Info
 #define ILOGW ILOG_INST << AliceO2::InfoLogger::InfoLogger::Warning
 #define ILOGE ILOG_INST << AliceO2::InfoLogger::InfoLogger::Error

Framework/src/AggregatorRunner.cxx

@@ -91,15 +91,17 @@ std::string AggregatorRunner::createAggregatorRunnerName()
 void AggregatorRunner::init(framework::InitContext& iCtx)
 {
   InfoLoggerContext* ilContext = nullptr;
+  AliceO2::InfoLogger::InfoLogger* il = nullptr;
   try {
     ilContext = &iCtx.services().get<AliceO2::InfoLogger::InfoLoggerContext>();
+    il = &iCtx.services().get<AliceO2::InfoLogger::InfoLogger>();
   } catch (const RuntimeErrorRef& err) {
-    ILOG(Error) << "Could not find the DPL InfoLogger Context." << ENDM;
+    ILOG(Error) << "Could not find the DPL InfoLogger." << ENDM;
   }
 
   try {
-    ILOG_INST.init("aggregator", mRunnerConfig.infologgerFilterDiscardDebug, mRunnerConfig.infologgerDiscardLevel, ilContext);
-    ILOG_INST.setDetector(AggregatorRunner::getDetectorName(mAggregators));
+    QcInfoLogger::init("aggregator", mRunnerConfig.infologgerFilterDiscardDebug, mRunnerConfig.infologgerDiscardLevel, il, ilContext);
+    QcInfoLogger::setDetector(AggregatorRunner::getDetectorName(mAggregators));
     initDatabase();
     initMonitoring();
     initServiceDiscovery();
@@ -323,8 +325,8 @@ void AggregatorRunner::start(const ServiceRegistry& services)
   mActivity.mPassName = computePassName(mRunnerConfig.fallbackPassName);
   mActivity.mProvenance = computeProvenance(mRunnerConfig.fallbackProvenance);
   string partitionName = computePartitionName(services);
-  ILOG_INST.setRun(mActivity.mId);
-  ILOG_INST.setPartition(partitionName);
+  QcInfoLogger::setRun(mActivity.mId);
+  QcInfoLogger::setPartition(partitionName);
   ILOG(Info, Ops) << "Starting run " << mActivity.mId << ":"
                   << "\n   - period: " << mActivity.mPeriodName << "\n   - pass type: " << mActivity.mPassName << "\n   - provenance: " << mActivity.mProvenance << ENDM;
 }

Framework/src/CheckRunner.cxx

@@ -162,18 +162,21 @@ CheckRunner::~CheckRunner()
 void CheckRunner::init(framework::InitContext& iCtx)
 {
   InfoLoggerContext* ilContext = nullptr;
+  AliceO2::InfoLogger::InfoLogger* il = nullptr;
   try {
     ilContext = &iCtx.services().get<AliceO2::InfoLogger::InfoLoggerContext>();
+    il = &iCtx.services().get<AliceO2::InfoLogger::InfoLogger>();
   } catch (const RuntimeErrorRef& err) {
-    ILOG(Error) << "Could not find the DPL InfoLogger Context." << ENDM;
+    ILOG(Error) << "Could not find the DPL InfoLogger." << ENDM;
   }
 
   try {
-    ILOG_INST.init(createCheckRunnerFacility(mDeviceName),
-                   mConfig.infologgerFilterDiscardDebug,
-                   mConfig.infologgerDiscardLevel,
-                   ilContext);
-    ILOG_INST.setDetector(CheckRunner::getDetectorName(mChecks));
+    QcInfoLogger::init(createCheckRunnerFacility(mDeviceName),
+                       mConfig.infologgerFilterDiscardDebug,
+                       mConfig.infologgerDiscardLevel,
+                       il,
+                       ilContext);
+    QcInfoLogger::setDetector(CheckRunner::getDetectorName(mChecks));
     initDatabase();
     initMonitoring();
     initServiceDiscovery();
@@ -422,8 +425,8 @@ void CheckRunner::start(const ServiceRegistry& services)
   mActivity.mPassName = computePassName(mConfig.fallbackPassName);
   mActivity.mProvenance = computeProvenance(mConfig.fallbackProvenance);
   string partitionName = computePartitionName(services);
-  ILOG_INST.setRun(mActivity.mId);
-  ILOG_INST.setPartition(partitionName);
+  QcInfoLogger::setRun(mActivity.mId);
+  QcInfoLogger::setPartition(partitionName);
   ILOG(Info, Ops) << "Starting run " << mActivity.mId << ":"
                   << "\n   - period: " << mActivity.mPeriodName << "\n   - pass type: " << mActivity.mPassName << "\n   - provenance: " << mActivity.mProvenance << ENDM;
   mTimerTotalDurationActivity.reset();

Framework/src/DatabaseFactory.cxx

@@ -36,7 +36,7 @@ namespace o2::quality_control::repository
 std::unique_ptr<DatabaseInterface> DatabaseFactory::create(std::string name)
 {
   if (name == "MySql") {
-    QcInfoLogger::GetInstance() << "MySQL backend selected" << QcInfoLogger::endm;
+    ILOG(Info, Support) << "MySQL backend selected" << ENDM;
 #ifdef _WITH_MYSQL
     return std::make_unique<MySqlDatabase>();
 #else
@@ -45,10 +45,10 @@ std::unique_ptr<DatabaseInterface> DatabaseFactory::create(std::string name)
 #endif
   } else if (name == "CCDB") {
     // TODO check if CCDB installed
-    QcInfoLogger::GetInstance() << "CCDB backend selected" << QcInfoLogger::endm;
+    ILOG(Info, Support) << "CCDB backend selected" << ENDM;
     return std::make_unique<CcdbDatabase>();
   } else if (name == "Dummy") {
-    QcInfoLogger::GetInstance() << "Dummy backend selected, MonitorObjects will not be stored nor retrieved" << QcInfoLogger::endm;
+    ILOG(Info, Support) << "Dummy backend selected, MonitorObjects will not be stored nor retrieved" << ENDM;
     return std::make_unique<DummyDatabase>();
   } else {
     BOOST_THROW_EXCEPTION(FatalException() << errinfo_details("No database named " + name));

Framework/src/PostProcessingDevice.cxx

@@ -38,7 +38,7 @@ PostProcessingDevice::PostProcessingDevice(const PostProcessingRunnerConfig& run
     mDeviceName(createPostProcessingIdString() + "-" + runnerConfig.taskName),
     mRunnerConfig(runnerConfig)
 {
-  ILOG_INST.setFacility("PostProcessing");
+  core::QcInfoLogger::setFacility("PostProcessing");
 }
 
 void PostProcessingDevice::init(framework::InitContext& ctx)

Framework/src/PostProcessingRunner.cxx

@@ -61,7 +61,7 @@ void PostProcessingRunner::init(const PostProcessingRunnerConfig& runnerConfig,
   mRunnerConfig = runnerConfig;
   mTaskConfig = taskConfig;
 
-  ILOG_INST.init("post/" + mName, runnerConfig.infologgerFilterDiscardDebug, runnerConfig.infologgerDiscardLevel);
+  QcInfoLogger::init("post/" + mName, runnerConfig.infologgerFilterDiscardDebug, runnerConfig.infologgerDiscardLevel);
   ILOG(Info, Support) << "Initializing PostProcessingRunner" << ENDM;
 
   // configuration of the database

Framework/src/QcInfoLogger.cxx

@@ -20,64 +20,54 @@
 namespace o2::quality_control::core
 {
 
-QcInfoLogger::QcInfoLogger()
-{
-  mContext = std::make_shared<AliceO2::InfoLogger::InfoLoggerContext>();
-  mContext->setField(infoContext::FieldName::Facility, "QC");
-  mContext->setField(infoContext::FieldName::System, "QC");
-  this->setContext(*mContext);
-}
+AliceO2::InfoLogger::InfoLogger* QcInfoLogger::instance;
+AliceO2::InfoLogger::InfoLoggerContext* QcInfoLogger::mContext;
+QcInfoLogger::_init QcInfoLogger::_initializer;
 
 void QcInfoLogger::setFacility(const std::string& facility)
 {
   mContext->setField(infoContext::FieldName::Facility, facility);
   mContext->setField(infoContext::FieldName::System, "QC");
-  if (mDplContext) {
-    mDplContext->setField(infoContext::FieldName::System, "QC");
-    mDplContext->setField(infoContext::FieldName::Facility, facility);
-  }
-  this->setContext(*mContext);
+  instance->setContext(*mContext);
   ILOG(Debug, Support) << "Facility set to " << facility << ENDM;
 }
 
 void QcInfoLogger::setDetector(const std::string& detector)
 {
   mContext->setField(infoContext::FieldName::Detector, detector);
-  if (mDplContext) {
-    mDplContext->setField(infoContext::FieldName::Detector, detector);
-  }
-  this->setContext(*mContext);
+  instance->setContext(*mContext);
   ILOG(Debug, Support) << "Detector set to " << detector << ENDM;
 }
 
 void QcInfoLogger::setRun(int run)
 {
   if (run > 0) {
     mContext->setField(infoContext::FieldName::Run, std::to_string(run));
-    if (mDplContext) {
-      mDplContext->setField(infoContext::FieldName::Run, std::to_string(run));
-    }
   }
-  this->setContext(*mContext);
+  instance->setContext(*mContext);
   ILOG(Debug, Support) << "IL: Run set to " << run << ENDM;
 }
 
-void QcInfoLogger::setPartition(std::string& partitionName)
+void QcInfoLogger::setPartition(const std::string& partitionName)
 {
   mContext->setField(infoContext::FieldName::Partition, partitionName);
-  if (mDplContext) {
-    mDplContext->setField(infoContext::FieldName::Partition, partitionName);
-  }
-  this->setContext(*mContext);
+  instance->setContext(*mContext);
   ILOG(Debug, Support) << "IL: Partition set to " << partitionName << ENDM;
 }
 
-void QcInfoLogger::init(const std::string& facility, bool discardDebug, int discardFromLevel,
+void QcInfoLogger::init(const std::string& facility,
+                        bool discardDebug,
+                        int discardFromLevel,
+                        AliceO2::InfoLogger::InfoLogger* dplInfoLogger,
                         AliceO2::InfoLogger::InfoLoggerContext* dplContext,
                         int run,
                         std::string partitionName)
 {
-  mDplContext = dplContext;
+  if (dplInfoLogger && dplContext) {
+    // we ignore the small memory leak that might occur if we are replacing the default InfoLogger
+    instance = dplInfoLogger;
+    mContext = dplContext;
+  }
   setFacility(facility);
   setRun(run);
   setPartition(partitionName);
@@ -91,15 +81,17 @@ void QcInfoLogger::init(const std::string& facility, bool discardDebug, int disc
   ILOG(Debug, Support) << "   Discard from level ? " << discardFromLevel << ENDM;
 }
 
-void QcInfoLogger::init(const std::string& facility, const boost::property_tree::ptree& config,
+void QcInfoLogger::init(const std::string& facility,
+                        const boost::property_tree::ptree& config,
+                        AliceO2::InfoLogger::InfoLogger* dplInfoLogger,
                         AliceO2::InfoLogger::InfoLoggerContext* dplContext,
                         int run,
                         std::string partitionName)
 {
   std::string discardDebugStr = config.get<std::string>("qc.config.infologger.filterDiscardDebug", "false");
   bool discardDebug = discardDebugStr == "true" ? 1 : 0;
   int discardLevel = config.get<int>("qc.config.infologger.filterDiscardLevel", 21 /* Discard Trace */);
-  init(facility, discardDebug, discardLevel, dplContext, run, partitionName);
+  init(facility, discardDebug, discardLevel, dplInfoLogger, dplContext, run, partitionName);
 }
 
 } // namespace o2::quality_control::core

Framework/src/RepositoryBenchmark.cxx

@@ -117,7 +117,7 @@ void RepositoryBenchmark::InitTask()
   }
 
   if (mDeletionMode) {
-    QcInfoLogger::GetInstance() << "Deletion mode..." << infologger::endm;
+    ILOG(Info, Support) << "Deletion mode..." << infologger::endm;
     emptyDatabase();
   }
 
@@ -170,16 +170,16 @@ bool RepositoryBenchmark::ConditionalRun()
   // determine how long we should wait till next iteration in order to have 1 sec between storage
   auto duration2 = duration_cast<microseconds>(t2 - t1);
   auto remaining = duration_cast<microseconds>(std::chrono::seconds(1) - duration2);
-  //  QcInfoLogger::GetInstance() << "Remaining duration : " << remaining.count() << " us" << infologger::endm;
+  //  ILOG(Info, Support) <<"Remaining duration : " << remaining.count() << " us" << infologger::endm;
   if (remaining.count() < 0) {
-    QcInfoLogger::GetInstance() << "Remaining duration is negative, we don't sleep " << infologger::endm;
+    ILOG(Info, Support) << "Remaining duration is negative, we don't sleep " << infologger::endm;
   } else {
     this_thread::sleep_for(chrono::microseconds(remaining));
   }
 
   if (mMaxIterations > 0 && ++mNumIterations >= mMaxIterations) {
-    QcInfoLogger::GetInstance() << "Configured maximum number of iterations reached. Leaving RUNNING state."
-                                << infologger::endm;
+    ILOG(Info, Support) << "Configured maximum number of iterations reached. Leaving RUNNING state."
+                        << infologger::endm;
     return false;
   }
 

Framework/src/TaskRunner.cxx

@@ -62,15 +62,18 @@ TaskRunner::TaskRunner(const TaskRunnerConfig& config)
 void TaskRunner::init(InitContext& iCtx)
 {
   AliceO2::InfoLogger::InfoLoggerContext* ilContext = nullptr;
+  AliceO2::InfoLogger::InfoLogger* il = nullptr;
   try {
     ilContext = &iCtx.services().get<AliceO2::InfoLogger::InfoLoggerContext>();
+    il = &iCtx.services().get<AliceO2::InfoLogger::InfoLogger>();
   } catch (const RuntimeErrorRef& err) {
-    ILOG(Error, Devel) << "Could not find the DPL InfoLogger Context." << ENDM;
+    ILOG(Error, Devel) << "Could not find the DPL InfoLogger" << ENDM;
   }
-  ILOG_INST.init("task/" + mTaskConfig.taskName,
-                 mTaskConfig.infologgerFilterDiscardDebug,
-                 mTaskConfig.infologgerDiscardLevel,
-                 ilContext);
+  QcInfoLogger::init("task/" + mTaskConfig.taskName,
+                     mTaskConfig.infologgerFilterDiscardDebug,
+                     mTaskConfig.infologgerDiscardLevel,
+                     il,
+                     ilContext);
 
   ILOG(Info, Support) << "Initializing TaskRunner" << ENDM;
   try {
@@ -226,9 +229,9 @@ void TaskRunner::endOfStream(framework::EndOfStreamContext& eosContext)
 void TaskRunner::start(const ServiceRegistry& services)
 {
   mRunNumber = o2::quality_control::core::computeRunNumber(services, mTaskConfig.fallbackRunNumber);
-  ILOG_INST.setRun(mRunNumber);
+  QcInfoLogger::setRun(mRunNumber);
   string partitionName = computePartitionName(services);
-  ILOG_INST.setPartition(partitionName);
+  QcInfoLogger::setPartition(partitionName);
 
   try {
     startOfActivity();
@@ -309,7 +312,7 @@ void TaskRunner::loadTaskConfig() // todo consider renaming
 {
   ILOG(Info, Support) << "Loading configuration" << ENDM;
 
-  ILOG_INST.setDetector(mTaskConfig.detectorName);
+  QcInfoLogger::setDetector(mTaskConfig.detectorName);
 
   ILOG(Info, Support) << "Configuration loaded : " << ENDM;
   ILOG(Info, Support) << ">> Task name : " << mTaskConfig.taskName << ENDM;

Framework/src/runAdvanced.cxx

@@ -84,7 +84,7 @@ using namespace o2::configuration;
 
 WorkflowSpec defineDataProcessing(ConfigContext const& config)
 {
-  ILOG_INST.setFacility("runAdvanced");
+  QcInfoLogger::setFacility("runAdvanced");
 
   bool noQC = config.options().get<bool>("no-qc");
   bool noDebug = config.options().get<bool>("no-debug-output");