ErrorHandling.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef INITIALIZATION_ERROR_LOGGER_HPP
#define INITIALIZATION_ERROR_LOGGER_HPP
 
#include "common/DataTypes.hpp"
#include "common/format/Format.hpp"
#include "common/format/StringUtilities.hpp"
#include <mutex>
 
namespace geos
{
 
struct ErrorContext
{
 
  enum class Attribute
  {
    InputFile,
    InputLine,
    DataPath,
    DetectionLoc,
    Signal,
  };
 
  string m_formattedContext;
 
  map< Attribute, std::string > m_attributes;
 
  integer m_priority = 0;
 
  ErrorContext( string formattedContext, map< Attribute, std::string > attributes ):
    m_formattedContext( formattedContext ),
    m_attributes( attributes ) {};
 
  ErrorContext( string formattedContext, map< Attribute, std::string > attributes, integer priority ):
    m_formattedContext( formattedContext ),
    m_attributes( attributes ),
    m_priority( priority ) {};
 
  ErrorContext & setPriority( integer priority )
  { m_priority = priority; return *this; }
 
  static std::string attributeToString( Attribute attribute );
 
};
 
enum class MsgType
{
  Error,
  ExternalError,
  Warning,
  Exception,
  Undefined
};
 
struct DiagnosticMsg
{
  MsgType m_type = MsgType::Undefined;
  std::string m_msg;
  std::string m_cause;
  std::set< int > m_ranksInfo;
  std::string m_file;
  integer m_line = 0;
  std::vector< ErrorContext > m_contextsInfo;
  std::vector< std::string > m_sourceCallStack;
  bool m_isValidStackTrace = false;
};
 
class DiagnosticMsgBuilder
{
public:
 
  static DiagnosticMsgBuilder init( DiagnosticMsg & msg,
                                    MsgType msgType,
                                    std::string_view msgContent,
                                    integer rank );
 
  static DiagnosticMsgBuilder modify( DiagnosticMsg & errorMsg );
 
  DiagnosticMsgBuilder & addToMsg( std::exception const & e, bool toEnd  = false );
 
  DiagnosticMsgBuilder & addToMsg( std::string_view msg, bool toEnd = false );
 
  template< typename ... Args >
  DiagnosticMsgBuilder & addContextInfo( Args && ... args )
  {
    ( this->addContextInfoImpl( ErrorContext( args ) ), ... );
    return *this;
  }
 
  DiagnosticMsgBuilder & addDetectionLocation( string_view detectionLocation );
 
  DiagnosticMsgBuilder & addSignal( integer sig, bool toEnd = false );
 
  DiagnosticMsgBuilder & setCodeLocation( std::string_view msgFile, integer msgLine );
 
  DiagnosticMsgBuilder & setType( MsgType msgType );
 
  DiagnosticMsgBuilder & setCause( std::string_view cause );
 
  DiagnosticMsgBuilder & addRank( integer rank );
 
  DiagnosticMsgBuilder & addCallStackInfo( std::string_view stacktrace );
 
  DiagnosticMsg & getDiagnosticMsg();
 
private:
 
  DiagnosticMsgBuilder( DiagnosticMsg & msg ):
    m_errorMsg( msg ){}
 
  DiagnosticMsgBuilder & addContextInfoImpl( ErrorContext && ctxInfo );
 
  DiagnosticMsg & m_errorMsg;
};
 
class ErrorLogger
{
 
public:
 
  GEOS_HOST static ErrorLogger & global();
 
  void createFile();
 
  void enableFileOutput( bool value )
  { m_writeYaml = value; }
 
  bool isOutputFileEnabled() const
  { return m_writeYaml; }
 
  void setOutputFilename( std::string_view filename )
  { m_filename = filename; }
 
  std::string_view getOutputFilename()
  { return m_filename; }
 
  static std::string toString( MsgType type );
 
  std::ostream const & getErrorStream() const
  { return m_stream; }
 
  DiagnosticMsg const & getCurrentExceptionMsg() const
  { return m_getCurrentExceptionMsg;}
 
  DiagnosticMsgBuilder initCurrentExceptionMessage( MsgType msgType,
                                                    std::string_view msgContent,
                                                    integer rank );
 
  DiagnosticMsgBuilder modifyCurrentExceptionMessage()
  { return DiagnosticMsgBuilder::modify( m_getCurrentExceptionMsg ); }
 
  void flushCurrentExceptionMessage();
 
  void flushErrorMsg( DiagnosticMsg & errMsg );
 
  static void formatMsgForLog( DiagnosticMsg const & errMsg, std::ostream & os );
 
  void writeToLogStream( DiagnosticMsg & errMsg );
 
private:
 
  DiagnosticMsg m_getCurrentExceptionMsg;
  bool m_writeYaml = false;
  std::string_view m_filename = "errors.yaml";
  std::ostream & m_stream = std::cout;
  std::mutex m_errorHandlerAsciiMutex;
  std::mutex m_errorHandlerYamlMutex;
 
  void writeToYamlStream( DiagnosticMsg & errMsg );
 
  void streamMultilineYamlAttribute( std::string_view msg, std::ofstream & yamlFile,
                                     std::string_view indent );
};
 
 
 
} /* namespace geos */
 
#endif