HistorySvc.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 "HistorySvc.h"
 
#include <functional>
 
#include <GaudiKernel/HistoryObj.h>
#include <GaudiKernel/IVersHistoryObj.h>
 
#include <GaudiKernel/AlgToolHistory.h>
#include <GaudiKernel/AlgorithmHistory.h>
#include <GaudiKernel/DataHistory.h>
#include <GaudiKernel/JobHistory.h>
#include <GaudiKernel/ServiceHistory.h>
 
#include <GaudiKernel/ISvcLocator.h>
 
#include <Gaudi/Algorithm.h>
#include <GaudiKernel/AlgTool.h>
#include <GaudiKernel/Bootstrap.h>
#include <GaudiKernel/IAlgManager.h>
#include <GaudiKernel/IAlgTool.h>
#include <GaudiKernel/IAlgorithm.h>
#include <GaudiKernel/IAppMgrUI.h>
#include <GaudiKernel/IIncidentSvc.h>
#include <GaudiKernel/IService.h>
#include <GaudiKernel/IToolSvc.h>
#include <GaudiKernel/ServiceHandle.h>
#include <GaudiKernel/System.h>
 
#include <GaudiKernel/IAlgContextSvc.h>
 
#include <boost/algorithm/string/predicate.hpp>
namespace ba = boost::algorithm;
 
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
 
#define ON_DEBUG if ( msgLevel( MSG::DEBUG ) )
#define ON_VERBOSE if ( msgLevel( MSG::VERBOSE ) )
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
DECLARE_COMPONENT( HistorySvc )
 
using namespace std;
 
//
//
 
namespace {
  template <typename MAP, typename SET>
  inline void map_to_set( const MAP& m, SET& s ) {
    std::transform( std::begin( m ), std::end( m ), std::inserter( s, s.begin() ),
                    std::mem_fn( &MAP::value_type::second ) );
  }
} // namespace
 
struct DHH {
  CLID        id;
  std::string key;
 
  DHH( const CLID& i, std::string k ) : id( i ), key( std::move( k ) ) {}
 
  bool operator<( DHH const& rhs ) const {
    if ( id != rhs.id ) {
      return ( id < rhs.id );
    } else {
      return ( key < rhs.key );
    }
  }
};
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::reinitialize() {
 
  clearState();
  m_state = Gaudi::StateMachine::OFFLINE;
  return initialize();
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
namespace {
  constexpr struct clear_t {
    template <typename T1, typename T2>
    void operator()( std::pair<const T1* const, T2*>& p ) {
      const_cast<T1*>( p.first )->release();
      delete p.second;
    }
  } clear_{};
  template <typename M>
  void clear( M& m ) {
    std::for_each( std::begin( m ), std::end( m ), clear_ );
    m.clear();
  }
} // namespace
void HistorySvc::clearState() {
  clear( m_algmap );
 
  m_ialgtools.clear();
  clear( m_algtoolmap );
 
  clear( m_svcmap );
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::initialize() {
 
  StatusCode status = Service::initialize();
  if ( status.isFailure() ) {
    ON_DEBUG
    debug() << "Failed to initialize the base class (Service)" << endmsg;
    return status;
  }
 
  ON_DEBUG
  debug() << "Initializing HistorySvc" << endmsg;
 
  if ( !m_activate ) return StatusCode::SUCCESS;
 
  if ( p_algCtxSvc.retrieve().isFailure() ) {
    error() << "unable to get the AlgContextSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  auto incidentSvc = service<IIncidentSvc>( "IncidentSvc", true );
  if ( !incidentSvc ) {
    error() << "unable to get the IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // create a weak dependency on the ToolSvc, so that it doesn't get deleted
  // before we're done with it in finalize
  m_toolSvc = serviceLocator()->service( "ToolSvc" );
  if ( !m_toolSvc ) {
    error() << "could not retrieve the ToolSvc handle !" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // add listener to be triggered by first BeginEvent with low priority
  // so it gets called first
  const bool rethrow = false;
  const bool oneShot = true; // make the listener called only once
  incidentSvc->addListener( this, IncidentType::BeginEvent, std::numeric_limits<long>::min(), rethrow, oneShot );
 
  m_outputFileTypeXML = ba::iends_with( m_outputFile.value(), ".xml" );
  ON_DEBUG if ( m_outputFileTypeXML ) { debug() << "output format is XML" << endmsg; }
 
  m_isInitialized = true;
 
  return StatusCode::SUCCESS;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::captureState() {
 
  if ( !m_jobHistory ) {
    m_jobHistory = std::make_unique<JobHistory>();
 
    bool foundAppMgr( false );
    for ( const auto& item : serviceLocator()->getOptsSvc().items() ) {
      m_jobHistory->addProperty( get<0>( item ), get<1>( item ) );
      foundAppMgr |= get<0>( item ).compare( 0, 15, "ApplicationMgr." ) == 0;
    }
 
    if ( !foundAppMgr ) {
      auto ap = service<IProperty>( "ApplicationMgr" );
      if ( !ap ) {
        error() << "could not get the ApplicationMgr" << endmsg;
      } else {
        for ( auto prop : ap->getProperties() ) {
          m_jobHistory->addProperty( "ApplicationMgr." + prop->name(), prop->toString() );
        }
      }
    }
  }

 
  auto algMgr = Gaudi::svcLocator()->as<IAlgManager>();
  if ( !algMgr ) {
    error() << "Could not get AlgManager" << endmsg;
    return StatusCode::FAILURE;
  }
 
  size_t count = 0;
  for ( auto ialg : algMgr->getAlgorithms() ) {
    Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*>( ialg );
    if ( !alg ) {
      warning() << "Algorithm " << ialg->name() << " does not inherit from Gaudi::Algorithm. Not registering it."
                << endmsg;
    } else {
      ++count;
      registerAlg( *alg ).ignore();
    }
  }
 
  info() << "Registered " << count << " Algorithms" << endmsg;

 
  m_isInitialized = true;
  for ( auto algtool : m_ialgtools ) {
    ( const_cast<IAlgTool*>( algtool ) )->addRef();
    registerAlgTool( *algtool ).ignore();
  }
 
  info() << "Registered " << m_algtoolmap.size() << " AlgTools" << endmsg;

 
  for ( auto svc : Gaudi::svcLocator()->getServices() ) {
    svc->addRef();
    registerSvc( *svc ).ignore();
  }
 
  info() << "Registered " << Gaudi::svcLocator()->getServices().size() << " Services" << endmsg;
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::stop() {
 
  if ( !m_activate ) return StatusCode::SUCCESS;
 
  if ( m_dump ) { listProperties().ignore(); }
 
  if ( !m_outputFile.empty() ) {
    std::ofstream ofs( m_outputFile );
    if ( !ofs ) {
      error() << "Unable to open output file \"m_outputFile\"" << endmsg;
    } else {
      //      dumpProperties(ofs);
      dumpState( ofs );
    }
  }
 
  clearState();
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::finalize() {
 
  ON_VERBOSE
  verbose() << "HistorySvc::finalize()" << endmsg;
 
  clearState();
 
  StatusCode status = Service::finalize();
 
  if ( status.isSuccess() ) info() << "Service finalised successfully" << endmsg;
 
  return status;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::registerAlg( const Gaudi::Algorithm& alg ) {
 
  JobHistory* job = getJobHistory();
  if ( m_algmap.find( &alg ) != m_algmap.end() ) {
    warning() << "Algorithm " << alg.name() << " already registered with HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }
 
  ( const_cast<Gaudi::Algorithm*>( &alg ) )->addRef();
 
  m_algmap[&alg] = new AlgorithmHistory( alg, job );
 
  ON_DEBUG {
    auto& log = debug();
    log << "Registering algorithm: ";
    log.setColor( MSG::CYAN );
    log << alg.name() << endmsg;
    log.resetColor();
  }
 
  return StatusCode::SUCCESS;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::listProperties( const Gaudi::Algorithm& alg ) const {
 
  info() << "Dumping properties for " << alg.name() << endl;
 
  AlgorithmHistory* hist = getAlgHistory( alg );
 
  if ( !hist ) { return StatusCode::FAILURE; }
 
  info() << alg.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpProperties( const Gaudi::Algorithm& alg, std::ofstream& ofs ) const {
 
  AlgorithmHistory* hist = getAlgHistory( alg );
 
  if ( !hist ) { return; }
 
  for ( auto prop : hist->properties() ) { ofs << alg.name() << "  " << dumpProp( prop ) << std::endl; }
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
AlgorithmHistory* HistorySvc::getAlgHistory( const Gaudi::Algorithm& alg ) const {
 
  auto itr = m_algmap.find( &alg );
  if ( itr == m_algmap.end() ) {
    warning() << "Algorithm " << alg.name() << " not registered" << endmsg;
    return nullptr;
  }
  return itr->second;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::getAlgHistory( std::set<AlgorithmHistory*>& algs ) const { map_to_set( m_algmap, algs ); }
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
StatusCode HistorySvc::registerJob() { return StatusCode::SUCCESS; }
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::listProperties() const {
 
  auto& log = info();
 
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all Algorithms (" << m_algmap.size() << ")" << endmsg;
 
  for ( auto& alg : m_algmap ) { listProperties( *alg.first ).ignore(); }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all AlgTools (" << m_algtoolmap.size() << ")" << endmsg;
 
  for ( auto& algtool : m_algtoolmap ) {
    ON_DEBUG
    debug() << " --> " << algtool.second->algtool_name() << endmsg;
    listProperties( *algtool.first ).ignore();
  }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for all Services (" << m_svcmap.size() << ")" << endmsg;
 
  for ( auto& svc : m_svcmap ) { listProperties( *svc.first ).ignore(); }
 
  log << MSG::INFO;
  log.setColor( MSG::CYAN );
  log << "Dumping properties for Job";
  log.resetColor();
 
  log << std::endl << *m_jobHistory << endmsg;
 
  return StatusCode::SUCCESS;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpProperties( std::ofstream& ofs ) const {
 
  ofs << "GLOBAL" << std::endl;
  for ( const auto& prop : m_jobHistory->propertyPairs() ) {
    ofs << prop.first << "  " << dumpProp( prop.second.get() ) << std::endl;
  }
 
  ofs << std::endl << "SERVICES" << std::endl;
  for ( const auto& s : m_svcmap ) dumpProperties( *s.first, ofs );
 
  ofs << std::endl << "ALGORITHMS" << std::endl;
  for ( const auto& alg : m_algmap ) dumpProperties( *alg.first, ofs );
 
  ofs << std::endl << "ALGTOOLS" << std::endl;
  for ( const auto& tool : m_algtoolmap ) dumpProperties( *tool.first, ofs );
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
JobHistory* HistorySvc::getJobHistory() const { return m_jobHistory.get(); }
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
IAlgorithm* HistorySvc::getCurrentIAlg() const {
  if ( p_algCtxSvc.isSet() ) return p_algCtxSvc->currentAlg();
  warning() << "trying to create DataHistoryObj before "
            << "HistorySvc has been initialized" << endmsg;
  return nullptr;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
DataHistory* HistorySvc::createDataHistoryObj( const CLID& id, const std::string& key,
                                               const std::string& /* storeName */ ) {
 
  if ( !m_activate ) return nullptr;
 
  AlgorithmHistory* algHist = nullptr;
 
  IAlgorithm* ialg = getCurrentIAlg();
  if ( !ialg ) {
    ON_DEBUG
    debug() << "Could not discover current Algorithm:" << endl
            << "          object CLID: " << id << "  key: \"" << key << "\"" << endmsg;
    algHist = nullptr;
  } else {
    Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*>( ialg );
    if ( alg ) {
      algHist = getAlgHistory( *alg );
    } else {
      warning() << "Could not extract concrete Algorithm:" << endl
                << "          object CLID: " << id << "  key: \"" << key << "\"" << endmsg;
      algHist = nullptr;
    }
  }
  return new DataHistory( id, key, algHist );
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
StatusCode HistorySvc::registerDataHistory( const CLID& id, const std::string& key, const std::string& storeName ) {
 
  DHH dhh( id, key );
 
  auto boundaries = m_datMap.equal_range( dhh );
  auto match      = boundaries.second;
 
  if ( boundaries.first != boundaries.second ) {
    // there is something in the map, let's look for the specific entry
 
    std::string algName;
    IAlgorithm* ialg = getCurrentIAlg();
    if ( ialg ) {
      algName = ialg->name();
    } else {
      algName = "UNKNOWN";
    }
 
    match = std::find_if( boundaries.first, boundaries.second,
                          [&algName]( decltype( boundaries )::first_type::reference p ) -> bool {
                            return p.second->algorithmHistory()->algorithm_name() == algName;
                          } );
  }
 
  if ( match == boundaries.second ) { // not found, crete the entry
    DataHistory* dh = createDataHistoryObj( id, key, storeName );
    m_datMap.insert( pair<DHH, DataHistory*>( dhh, dh ) );
  }
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
DataHistory* HistorySvc::getDataHistory( const CLID& id, const std::string& key,
                                         const std::string& /*storeName*/ ) const {
 
  DHH dhh( id, key );
 
  auto mitr = m_datMap.equal_range( dhh );
  return ( mitr.first != mitr.second ) ? mitr.first->second : nullptr;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int HistorySvc::getDataHistory( const CLID& id, const std::string& key, const std::string& /*storeName*/,
                                std::list<DataHistory*>& dhlist ) const {
 
  DHH dhh( id, key );
 
  int n( 0 );
 
  auto mitr = m_datMap.equal_range( dhh );
  for ( auto itr = mitr.first; itr != mitr.second; ++itr ) {
    dhlist.push_back( itr->second );
    ++n;
  }
  return n;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::registerSvc( const IService& svc ) {
 
  if ( svc.name() == "HistoryStore" ) { return StatusCode::SUCCESS; }
 
  JobHistory*     job  = getJobHistory();
  const IService* psvc = &svc;
  auto            itr  = m_svcmap.find( psvc );
  if ( itr == m_svcmap.end() ) {
 
    ON_DEBUG {
      auto& log = debug();
      log << "Registering Service: ";
      log.setColor( MSG::CYAN );
      log << svc.name() << endmsg;
      log.resetColor();
    }
 
    m_svcmap[psvc] = new ServiceHistory( &svc, job );
 
    ( const_cast<IService*>( psvc ) )->addRef();
  }
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
ServiceHistory* HistorySvc::getServiceHistory( const IService& svc ) const {
 
  const IService* psvc = &svc;
  auto            itr  = m_svcmap.find( psvc );
  if ( itr != m_svcmap.end() ) return itr->second;
 
  warning() << "Service " << svc.name() << " not registered" << endmsg;
  return nullptr;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::getServiceHistory( std::set<ServiceHistory*>& svcs ) const { map_to_set( m_svcmap, svcs ); }
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::listProperties( const IService& svc ) const {
 
  info() << "Dumping properties for " << svc.name() << endl;
 
  ServiceHistory* hist = getServiceHistory( svc );
 
  if ( !hist ) return StatusCode::FAILURE;
 
  info() << svc.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpProperties( const IService& svc, std::ofstream& ofs ) const {
 
  ServiceHistory* hist = getServiceHistory( svc );
 
  if ( !hist ) return;
 
  for ( auto& prop : hist->properties() ) { ofs << svc.name() << "  " << dumpProp( prop ) << std::endl; }
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::registerAlgTool( const IAlgTool& ialg ) {
 
  if ( !m_isInitialized ) {
    if ( !p_algCtxSvc.isSet() ) {
      if ( p_algCtxSvc.retrieve().isFailure() ) {
        error() << "unable to get the AlgContextSvc" << endmsg;
        return StatusCode::FAILURE;
      }
    }
    m_ialgtools.insert( &ialg );
    return StatusCode::SUCCESS;
  }
 
  const AlgTool* alg = dynamic_cast<const AlgTool*>( &ialg );
  if ( !alg ) {
    error() << "Could not dcast IAlgTool \"" << ialg.name() << "\" to an AlgTool" << endmsg;
    return StatusCode::FAILURE;
  }
 
  if ( m_algtoolmap.find( alg ) != m_algtoolmap.end() ) {
    warning() << "AlgTool " << ialg.name() << " already registered in HistorySvc" << endmsg;
    return StatusCode::SUCCESS;
  }
 
  const JobHistory* job = getJobHistory();
  m_algtoolmap[alg]     = new AlgToolHistory( *alg, job );
 
  ON_DEBUG {
    auto& log = debug();
    log << "Registering algtool: ";
    log.setColor( MSG::CYAN );
    log << alg->name() << endmsg;
    log.resetColor();
  }
 
  return StatusCode::SUCCESS;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
StatusCode HistorySvc::listProperties( const IAlgTool& alg ) const {
 
  info() << "Dumping properties for " << alg.name() << endl;
 
  AlgToolHistory* hist = getAlgToolHistory( alg );
 
  if ( !hist ) return StatusCode::FAILURE;
 
  info() << alg.name() << " --> " << endl << *hist << endmsg;
 
  return StatusCode::SUCCESS;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpProperties( const IAlgTool& alg, std::ofstream& ofs ) const {
 
  AlgToolHistory* hist = getAlgToolHistory( alg );
 
  if ( !hist ) return;
 
  for ( auto& prop : hist->properties() ) { ofs << alg.name() << "  " << dumpProp( prop ) << std::endl; }
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
AlgToolHistory* HistorySvc::getAlgToolHistory( const IAlgTool& alg ) const {
 
  const AlgTool* palg = dynamic_cast<const AlgTool*>( &alg );
  auto           itr  = m_algtoolmap.find( palg );
  if ( itr == m_algtoolmap.end() ) {
    warning() << "AlgTool " << alg.name() << " not registered" << endmsg;
    return nullptr;
  }
  return itr->second;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::getAlgToolHistory( std::set<AlgToolHistory*>& algs ) const { map_to_set( m_algtoolmap, algs ); }
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::handle( const Incident& incident ) {
 
  if ( incident.type() == IncidentType::BeginEvent ) {
    if ( captureState().isFailure() ) {
      warning() << "Error capturing state." << endl << "Will try again at next BeginEvent incident" << endmsg;
    }
  }
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
std::string HistorySvc::dumpProp( const Gaudi::Details::PropertyBase* prop, bool isXML, int ind ) const {
  std::ostringstream ost;
  if ( isXML ) {
    while ( ind > 0 ) {
      ost << " ";
      ind--;
    }
    ost << "<PROPERTY name=\"" << prop->name() << "\" value=\"" << HistoryObj::convert_string( prop->toString() )
        << "\" documentation=\"" << HistoryObj::convert_string( prop->documentation() ) << "\">";
  } else {
    prop->fillStream( ost );
  }
  return ost.str();
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpState( std::ofstream& ofs ) const {
 
  if ( m_outputFileTypeXML ) {
    // xml header
    ofs << "<?xml version=\"1.0\" ?> " << std::endl;
    ofs << "<!--Test-xml-->" << std::endl;
    ofs << "<SETUP>" << std::endl;
    ofs << "  <GLOBAL>" << std::endl;
  } else {
    ofs << "GLOBAL" << std::endl;
  }
 
  std::string client_currently_open = "start";
  for ( auto& item : m_jobHistory->propertyPairs() ) {
    // client is the name of the component of the current property
    const auto& client = item.first;
    const auto& prp    = item.second;
 
    if ( m_outputFileTypeXML ) {
 
      if ( client != client_currently_open ) {
        if ( client_currently_open != "start" ) ofs << "    </COMPONENT>" << endl;
        ofs << "    <COMPONENT name=\"" << client << "\" class=\"undefined\">" << std::endl;
      }
    } else {
      ofs << client << "  ";
    }
 
    ofs << dumpProp( prp.get(), m_outputFileTypeXML, 6 ) << endl;
 
    client_currently_open = client;
 
    if ( m_outputFileTypeXML ) ofs << "    </COMPONENT>" << endl;
  }
 
  if ( m_outputFileTypeXML ) {
    ofs << "</GLOBAL>" << endl << "<SERVICES>" << endl;
  } else {
    ofs << "SERVICES" << std::endl;
  }
 
  // helper to dump monitored components sorted by name
  auto sortedDump = [&ofs, this]( const auto& map ) {
    std::map<std::string, const INamedInterface*> sorted;
    for ( const auto& item : map ) sorted[item.first->name()] = item.first;
    for ( const auto& item : sorted ) dumpState( item.second, ofs );
  };
 
  sortedDump( m_svcmap );
 
  if ( m_outputFileTypeXML ) {
    ofs << "</SERVICES>" << endl << "<ALGORITHMS> " << endl;
  } else {
    ofs << "ALGORITHMS" << std::endl;
  }
 
  sortedDump( m_algmap );
 
  if ( m_outputFileTypeXML ) {
    ofs << "</ALGORITHMS>" << endl << "<ALGTOOLS> " << endl;
  } else {
    ofs << "ALGTOOLS" << std::endl;
  }
 
  sortedDump( m_algtoolmap );
 
  if ( m_outputFileTypeXML ) { ofs << "</ALGTOOLS>" << endl << "</SETUP>" << endl; }
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
void HistorySvc::dumpState( const INamedInterface* in, std::ofstream& ofs ) const {
 
  HistoryObj*      hist  = nullptr;
  IVersHistoryObj* vhist = nullptr;
 
  const IService*         is = nullptr;
  const Gaudi::Algorithm* ia = nullptr;
  const IAlgTool*         it = nullptr;
  if ( ( is = dynamic_cast<const IService*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is Service" << endmsg;
    ServiceHistory* o = getServiceHistory( *is );
    hist              = dynamic_cast<HistoryObj*>( o );
    vhist             = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( ( ia = dynamic_cast<const Gaudi::Algorithm*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is Alg" << endmsg;
    AlgorithmHistory* o = getAlgHistory( *ia );
    hist                = dynamic_cast<HistoryObj*>( o );
    vhist               = dynamic_cast<IVersHistoryObj*>( o );
  } else if ( ( it = dynamic_cast<const IAlgTool*>( in ) ) != nullptr ) {
    ON_VERBOSE
    verbose() << in->name() << " is AlgTool" << endmsg;
    AlgToolHistory* o = getAlgToolHistory( *it );
    hist              = dynamic_cast<HistoryObj*>( o );
    vhist             = dynamic_cast<IVersHistoryObj*>( o );
  } else {
    error() << "Could not dcast interface to accepted History Obj type for " << in->name() << endmsg;
    return;
  }
 
  if ( !hist || !vhist ) {
    error() << "Could not dcast recognized object to HistoryObj or IVersHistoryObj. This should never happen."
            << endmsg;
    return;
  }
 
  if ( m_outputFileTypeXML ) {
    hist->dump( ofs, true );
  } else {
    ofs << ">> " << vhist->name() << endl << *hist << endl;
  }
}