MessageSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Property.h>
#include <GaudiKernel/IMessageSvc.h>
#include <GaudiKernel/Message.h>
#include <GaudiKernel/Service.h>
#include <GaudiKernel/StatusCode.h>
 
#include <iosfwd>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
class ISvcLocator;
 
//
// ClassName:   MessageSvc
//
// Description: The MessageSvc service implements the IMessageSvc interface and provides the
//              basic messaging needed by batch oriented applications.
//
// Author:      Iain Last
//
class MessageSvc : public extends<Service, IMessageSvc, IInactiveMessageCounter> {
public:
  typedef std::pair<std::string, std::ostream*>   NamedStream;
  typedef std::multimap<int, NamedStream>         StreamMap;
  typedef std::multimap<StatusCode, Message>      MessageMap;
  typedef std::map<std::string, int, std::less<>> ThresholdMap;
 
  // Default constructor.
  MessageSvc( const std::string& name, ISvcLocator* svcloc );
 
  // Implementation of IService::reinitialize()
  StatusCode reinitialize() override;
  // Implementation of IService::initialize()
  StatusCode initialize() override;
  // Implementation of IService::finalize()
  StatusCode finalize() override;
 
  // Implementation of IMessageSvc::reportMessage()
  void reportMessage( const Message& message ) override;
 
  // Implementation of IMessageSvc::reportMessage()
  void reportMessage( const Message& msg, int outputLevel ) override;
 
  // Implementation of IMessageSvc::reportMessage()
  void reportMessage( const StatusCode& code, std::string_view source = "" ) override;
 
  // Implementation of IMessageSvc::reportMessage()
  void reportMessage( std::string source, int type, std::string message ) override;
 
  // Implementation of IMessageSvc::insertMessage()
  void insertMessage( const StatusCode& code, Message message ) override;
 
  // Implementation of IMessageSvc::eraseMessage()
  void eraseMessage() override;
 
  // Implementation of IMessageSvc::eraseMessage()
  void eraseMessage( const StatusCode& code ) override;
 
  // Implementation of IMessageSvc::eraseMessage()
  void eraseMessage( const StatusCode& code, const Message& message ) override;
 
  // Implementation of IMessageSvc::insertStream()
  void insertStream( int message_type, std::string name, std::ostream* stream ) override;
 
  // Implementation of IMessageSvc::eraseStream()
  void eraseStream() override;
 
  // Implementation of IMessageSvc::eraseStream()
  void eraseStream( int message_type ) override;
 
  // Implementation of IMessageSvc::eraseStream()
  void eraseStream( int message_type, std::ostream* stream ) override;
 
  // Implementation of IMessageSvc::eraseStream()
  void eraseStream( std::ostream* stream ) override;
 
  // Implementation of IMessageSvc::desaultStream()
  std::ostream* defaultStream() const override { return m_defaultStream; }
 
  // Implementation of IMessageSvc::setDefaultStream()
  void setDefaultStream( std::ostream* stream ) override {
    auto lock       = std::scoped_lock{ m_reportMutex };
    m_defaultStream = stream;
  }
 
  // Implementation of IMessageSvc::ouputLevel()
  int outputLevel() const override;
 
  // Implementation of IMessageSvc::ouputLevel()
  int outputLevel( std::string_view source ) const override;
 
  // Implementation of IMessageSvc::setOuputLevel()
  void setOutputLevel( int new_level ) override;
 
  // Implementation of IMessageSvc::setOuputLevel()
  void setOutputLevel( std::string_view source, int new_level ) override;
 
  // Implementation of IMessageSvc::useColor()
  bool useColor() const override { return m_color; }
 
  // Implementation of IMessageSvc::getLogColor()
  std::string getLogColor( int logLevel ) const override;
 
  // Implementation of IMessageSvc::messageCount()
  int messageCount( MSG::Level logLevel ) const override;
 
  // Implementation of IInactiveMessageCounter::incrInactiveCount()
  void incrInactiveCount( MSG::Level level, std::string_view src ) override;
 
  // Override setPropertyRepr to serialize property writes with m_reportMutex,
  // preventing data races between property updates and concurrent
  // i_reportMessage calls.
  StatusCode setPropertyRepr( const std::string& n, const std::string& r ) override;
 
protected:
  virtual void i_reportMessage( const Message& msg, int outputLevel );

  virtual void i_reportMessage( const StatusCode& code, std::string_view source );
 
  bool         m_suppress{ false };
  std::string  m_defaultFormat{ Message::getDefaultFormat() };
  virtual void i_onSuppressChanged( bool v ) { m_suppress = v; }
  virtual void i_onDefaultFormatChanged( const std::string& v ) { m_defaultFormat = v; }
 
private:
  mutable std::recursive_mutex m_reportMutex;
 
  Gaudi::Property<std::string> m_defaultFormatProp{
      this, "Format", Message::getDefaultFormat(),
      [this]( auto& ) { i_onDefaultFormatChanged( m_defaultFormatProp.value() ); }, "" };
  Gaudi::Property<std::string>  m_defaultTimeFormat{ this, "timeFormat", Message::getDefaultTimeFormat(), "" };
  Gaudi::Property<bool>         m_stats{ this, "showStats", false, "" };
  Gaudi::Property<unsigned int> m_statLevel{ this, "statLevel", 0, "" };
 
  std::array<Gaudi::Property<std::vector<std::string>>, MSG::NUM_LEVELS> m_thresholdProp{ { { /*ignored*/ },
                                                                                            { this, "setVerbose" },
                                                                                            { this, "setDebug" },
                                                                                            { this, "setInfo" },
                                                                                            { this, "setWarning" },
                                                                                            { this, "setError" },
                                                                                            { this, "setFatal" },
                                                                                            { this, "setAlways" } } };
 
  Gaudi::Property<bool> m_color{ this, "useColors", false, "" };
 
  std::array<Gaudi::Property<std::vector<std::string>>, MSG::NUM_LEVELS> m_logColors{ { { /*ignored*/ },
                                                                                        { this, "verboseColorCode" },
                                                                                        { this, "debugColorCode" },
                                                                                        { this, "infoColorCode" },
                                                                                        { this, "warningColorCode" },
                                                                                        { this, "errorColorCode" },
                                                                                        { this, "fatalColorCode" },
                                                                                        { this, "alwaysColorCode" } } };
 
  std::array<Gaudi::Property<int>, MSG::NUM_LEVELS> m_msgLimit{ { { this, "defaultLimit", 500 },
                                                                  { this, "verboseLimit", 500 },
                                                                  { this, "debugLimit", 500 },
                                                                  { this, "infoLimit", 500 },
                                                                  { this, "warningLimit", 500 },
                                                                  { this, "errorLimit", 500 },
                                                                  { this, "fatalLimit", 500 },
                                                                  { this, "alwaysLimit", 0 } } };
 
  Gaudi::Property<bool> m_suppressProp{ this, "enableSuppression", false,
                                        [this]( auto& ) { i_onSuppressChanged( m_suppressProp.value() ); }, "" };
  Gaudi::Property<bool> m_inactCount{ this, "countInactive", false, &MessageSvc::setupInactCount, "" };
 
  Gaudi::Property<std::vector<std::string>> m_tracedInactiveSources{
      this,
      "tracedInactiveSources",
      {},
      "for each message source specified,  print a stack trace for the unprotected and unseen messages" };
 
  Gaudi::Property<std::map<std::string, std::string, std::less<>>> m_loggedStreamsName{
      this, "loggedStreams", {}, "MessageStream sources we want to dump into a logfile" };
 
  std::ostream* m_defaultStream = &std::cout; 
  Message       m_defaultMessage;             
  StreamMap     m_streamMap;                  
  MessageMap    m_messageMap;                 
  ThresholdMap  m_thresholdMap;               
 
  std::string m_logColorCodes[MSG::NUM_LEVELS];

  struct MsgAry final {
    std::array<int, MSG::NUM_LEVELS> msg = { { 0 } };
    MsgAry() = default;
  };
 
  std::map<std::string, MsgAry, std::less<>> m_sourceMap, m_inactiveMap;
 
  std::array<int, MSG::NUM_LEVELS> m_msgCount;
 
  std::map<std::string, std::shared_ptr<std::ostream>, std::less<>> m_loggedStreams;
 
  void setupColors( Gaudi::Details::PropertyBase& prop );
  void setupLimits( Gaudi::Details::PropertyBase& prop );
  void setupThreshold( Gaudi::Details::PropertyBase& prop );
  void setupInactCount( Gaudi::Details::PropertyBase& prop );
 
  void setupLogStreams();

  mutable std::recursive_mutex m_messageMapMutex;

  mutable std::recursive_mutex m_thresholdMapMutex;
};