MessageSvcSink.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 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.                                             *
\***********************************************************************************/
 
#include <Gaudi/BaseSink.h>
#include <Gaudi/MonitoringHub.h>
#include <GaudiKernel/MsgStream.h>
 
#include <boost/algorithm/string.hpp>
 
#include <fmt/core.h>
#include <fmt/format.h>
 
#include <map>
#include <sstream>
#include <string_view>
 
namespace {
 
  static const auto registry = std::map<std::string_view, std::string_view>{
      { "counter", "{0:nEntries|10d}" },   // all unknown counters, and default
      { "histogram", "{0:nEntries|10d}" }, // all histograms
      { "counter:AveragingCounter", "{0:nEntries|10d} |{0:sum|11.7g} |{0:mean|#11.5g}" },
      { "counter:SigmaCounter", "{0:nEntries|10d} |{0:sum|11.7g} |{0:mean|#11.5g} |{0:standard_deviation|#11.5g}" },
      { "counter:StatCounter", "{0:nEntries|10d} |{0:sum|11.7g} |{0:mean|#11.5g} |{0:standard_deviation|#11.5g} "
                               "|{0:min|#12.5g} |{0:max|#12.5g}" },
      { "counter:BinomialCounter",
        "{0:nEntries|10d} |{0:nTrueEntries|11d} |({0:efficiency|#9.7p} +- {0:efficiencyErr|-#8.7p})%" },
  };
 
  // Helper to fix custom formatting of nlohmann::json version 3.10.5
  // See https://gitlab.cern.ch/gaudi/Gaudi/-/issues/220
  struct json_fmt_arg {
    json_fmt_arg( const nlohmann::json& j ) : payload{ j } {}
    const nlohmann::json& payload;
  };
} // namespace
 
template <>
class fmt::formatter<json_fmt_arg> {
public:
  template <typename ParseContext>
  constexpr auto parse( ParseContext& ctx ) {
    auto fmt_begin = ctx.begin();
    auto fmt_end   = std::find( fmt_begin, ctx.end(), '}' );
    if ( fmt_begin == fmt_end ) {
      // we are dealing with {}, only make sure currentFormat is empty
      currentFormat = "";
    } else {
      // non empty format, let's split name from format
      auto fmt_colon = std::find( fmt_begin, fmt_end, '|' );
      currentName    = std::string( fmt_begin, fmt_colon - fmt_begin );
      currentFormat  = std::string( fmt_colon + 1, fmt_end - fmt_colon - 1 );
    }
    return fmt_end;
  }
  template <typename FormatContext>
  auto format( const json_fmt_arg& json_arg, FormatContext& ctx ) const {
    const auto& j = json_arg.payload;
    if ( currentFormat.size() == 0 ) {
      // dealing with {} format, let's find entry for our type in registry
      const auto type = j.at( "type" ).get<std::string>();
      // first looking for the entry, then we drop on ":abc" suffix at a time and try again
      std::string_view type_key{ type };
      // look for the full entry
      auto entry = registry.find( type_key );
      // we check if we have type separators before entering the loop
      auto sep = type_key.rfind( ':' );
      while ( sep != type_key.npos && entry == registry.end() ) {
        // not found, remove the trailing ":abc" section
        type_key.remove_suffix( type_key.size() - sep );
        // check if we have another chunk to strip
        sep = type_key.rfind( ':' );
        // see if the shorter key works
        entry = registry.find( type_key );
      }
      // if still not found, we use the basic "counter"
      if ( entry == registry.end() ) entry = registry.find( "counter" );
      assert( entry != registry.end() );
      // print the json string according to format found
      // This actually will call this formatter again a number of times
      return fmt::format_to( ctx.out(), fmt::runtime( entry->second ), json_arg );
    } else {
      // dealing with a {:name|fmt} format
      auto actualFormat = "{:" + currentFormat + '}';
      switch ( currentFormat.back() ) {
      case 'd':
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ),
                               j.at( currentName ).template get<unsigned int>() );
      case 'g':
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ), j.at( currentName ).template get<double>() );
      case 'p':
        actualFormat[actualFormat.size() - 2] = 'g';
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ),
                               j.at( currentName ).template get<double>() * 100 );
      default:
        return fmt::format_to( ctx.out(), "Unknown counter format : {}", currentFormat );
      }
    }
  }
 
private:
  std::string currentFormat;
  std::string currentName;
};
 
namespace {
 
  void printCounter( std::ostringstream& log, std::string_view id, const nlohmann::json& j ) {
    const auto type = j.at( "type" ).get<std::string>();
    // for backward compatibility, we need to deal with statentity in a special way
    // this block should be dropped when StatEntities are gone
    if ( type == "statentity" ) {
      using boost::algorithm::icontains;
      bool isBinomial = icontains( id, "eff" ) || icontains( id, "acc" ) || icontains( id, "filt" ) ||
                        icontains( id, "fltr" ) || icontains( id, "pass" );
      auto nj    = j;
      nj["type"] = isBinomial ? "counter:BinomialCounter" : "counter:StatCounter";
      return printCounter( log, id, nj );
    }
    // binomial counters are slightly different ('*' character)
    // fmt::runtime is required when compiling with GCC 11 but
    // can be dropped when GCC 11 is no longer supported
    log << fmt::format( fmt::runtime( " |{}{:48}|{} |" ),
                        ( std::string_view{ type }.substr( 0, 23 ) == "counter:BinomialCounter" ? '*' : ' ' ),
                        fmt::format( fmt::runtime( "\"{}\"" ), id ), json_fmt_arg{ j } );
  }
 
} // namespace
 
namespace Gaudi::Monitoring {
 
  struct MessageSvcSink : BaseSink {
    MessageSvcSink( std::string name, ISvcLocator* svcloc ) : BaseSink( name, svcloc ) {
      // only deal with counters, statentity and histograms
      setProperty( "TypesToSave", std::vector<std::string>{ "counter:.*", "statentity", "histogram:.*" } )
          .orThrow( "Unable to set typesToSaveProperty", "Histograming::Sink::Base" );
    }
    void flush( bool ) override;
  };
 
  DECLARE_COMPONENT( MessageSvcSink )
} // namespace Gaudi::Monitoring
 
void Gaudi::Monitoring::MessageSvcSink::flush( bool ) {
  std::string        curAlgo = "";
  std::ostringstream curLog;
  unsigned int       nbNonEmptyEntities = 0;
  auto               dumpAlgoCounters   = [&]() {
    // Yes, so print header, dump log and reset counters
    if ( nbNonEmptyEntities > 0 ) {
      MsgStream log{ msgSvc(), curAlgo };
      log << MSG::INFO << "Number of counters : " << nbNonEmptyEntities << "\n"
          << " |    Counter                                      |     #     |   "
          << " sum     | mean/eff^* | rms/err^*  |     min     |     max     |";
      log << curLog.str() << endmsg;
    }
  };
  applyToAllSortedEntities( [&]( std::string const& algo, std::string const& entity, nlohmann::json const& j ) {
    // Did we change to new component ?
    if ( algo != curAlgo ) {
      dumpAlgoCounters();
      curAlgo            = algo;
      nbNonEmptyEntities = 0;
      curLog             = std::ostringstream{};
    }
    // is current counter empty ?
    if ( !j.at( "empty" ).template get<bool>() ) {
      ++nbNonEmptyEntities;
      curLog << "\n";
      printCounter( curLog, entity, j );
    }
  } );
  // last component
  dumpAlgoCounters();
}