refactor: Centralize error output

src/coreComponents/codingUtilities/Parsing.hpp

@@ -91,7 +91,7 @@ char const * parseBuffer( char const * first,
  * @param issep function that returns true if given character is a value separator
  * @return @p last if the entire buffer has been processed, or pointer to
  *         the start of the unprocessed part if a parsing error occurred
- * @throws std::runtime_error if file IO or parsing error occurred
+ * @throws geos::RuntimeError if file IO or parsing error occurred
  */
 template< typename CONTAINER, typename SEPFUNC >
 void parseFile( string const & filename,
@@ -134,13 +134,13 @@ void parseFile( string const & filename,
       GEOS_THROW( GEOS_FMT( "Unable to parse value in file {} at position {}: {}...",
                             filename, static_cast< std::streamoff >( inputStream.tellg() ) - left,
                             string( ptr, std::min( left, std::ptrdiff_t{32} ) ) ),
-                  std::runtime_error );
+                  geos::RuntimeError );
     }
   }
 
   GEOS_THROW_IF( inputStream.fail() && !inputStream.eof(),
                  GEOS_FMT( "Error while reading file {}: {}", filename, std::strerror( errno ) ),
-                 std::runtime_error );
+                 geos::RuntimeError );
 }
 
 } // namespace geos

src/coreComponents/codingUtilities/tests/testParsing.cpp

@@ -140,7 +140,7 @@ class ParsingTest : public ::testing::TestWithParam< T >
 
     geos::stdVector< T > vec;
     auto const issep_invalid = []( char const c ){ return c == '|'; };
-    EXPECT_THROW( geos::parseFile( fname, vec, issep_invalid ), std::runtime_error );
+    EXPECT_THROW( geos::parseFile( fname, vec, issep_invalid ), geos::RuntimeError );
 
     std::remove( fname.c_str() );
   }

src/coreComponents/common/CMakeLists.txt

@@ -38,6 +38,7 @@ set( common_headers
      GEOS_RAJA_Interface.hpp
      GeosxMacros.hpp
      MemoryInfos.hpp
+     logger/GeosExceptions.hpp
      logger/Logger.hpp
      logger/ErrorHandling.hpp
      logger/ExternalErrorHandler.hpp

src/coreComponents/common/Path.cpp

@@ -140,7 +140,7 @@ void makeDirectory( std::string const & path )
 {
   constexpr mode_t mode = 0770; // user and group rwx permissions
   int const err = mkdir( path.c_str(), mode );
-  GEOS_THROW_IF( err && ( errno != EEXIST ), "Failed to create directory: " << path, std::runtime_error );
+  GEOS_THROW_IF( err && ( errno != EEXIST ), "Failed to create directory: " << path, geos::RuntimeError );
 }
 
 void makeDirsForPath( std::string const & path )

src/coreComponents/common/format/table/TableLayout.hpp

@@ -20,10 +20,8 @@
 #ifndef GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP
 #define GEOS_COMMON_FORMAT_TABLE_TABLELAYOUT_HPP
 
-#include "common/DataTypes.hpp"
 #include "TableTypes.hpp"
 #include <variant>
-#include "common/logger/Logger.hpp"
 
 
 namespace geos

src/coreComponents/common/format/table/TableTypes.hpp

@@ -23,6 +23,8 @@
 #ifndef GEOS_COMMON_FORMAT_TABLETYPES_HPP
 #define GEOS_COMMON_FORMAT_TABLETYPES_HPP
 
+#include "common/DataTypes.hpp"
+
 namespace geos
 {
 

src/coreComponents/common/initializeEnvironment.cpp

@@ -92,22 +92,16 @@ void setupLogger()
     {
       std::string const stackHistory = LvArray::system::stackTrace( true );
 
-      GEOS_LOG( GEOS_FMT( "***** ERROR\n"
-                          "***** LOCATION: (external error, detected {})\n"
-                          "{}\n{}",
-                          detectionLocation, errorMsg, stackHistory ) );
-      if( ErrorLogger::global().isOutputFileEnabled() )
-      {
-        ErrorLogger::ErrorMsg error;
-        error.setType( ErrorLogger::MsgType::Error );
-        error.addToMsg( errorMsg );
-        error.addRank( ::geos::logger::internal::g_rank );
-        error.addCallStackInfo( stackHistory );
-        error.addContextInfo(
-          ErrorContext{ { { ErrorContext::Attribute::DetectionLoc, string( detectionLocation ) } } } );
-
-        ErrorLogger::global().flushErrorMsg( error );
-      }
+      ErrorLogger::ErrorMsg error;
+      error.setType( ErrorLogger::MsgType::Error );
+      error.addToMsg( errorMsg );
+      error.addRank( ::geos::logger::internal::g_rank );
+      error.addCallStackInfo( stackHistory );
+      error.addContextInfo(
+        ErrorContext{ { { ErrorContext::Attribute::DetectionLoc, string( detectionLocation ) } },
+          string( detectionLocation ) } );
+
+      ErrorLogger::global().flushErrorMsg( error );
 
       // we do not terminate the program as 1. the error could be non-fatal, 2. there may be more messages to output.
     } );
@@ -124,26 +118,18 @@ void setupLogger()
 
       // error message output
       std::string const stackHistory = LvArray::system::stackTrace( true );
+
       ErrorLogger::ErrorMsg error;
       error.addSignalToMsg( signal );
+      error.setType( ErrorLogger::MsgType::Error );
+      error.addRank( ::geos::logger::internal::g_rank );
+      error.addCallStackInfo( stackHistory );
+      error.addContextInfo(
+        ErrorContext{ { { ErrorContext::Attribute::Signal, std::to_string( signal ) } }, "", 1 },
+        ErrorContext{ { { ErrorContext::Attribute::DetectionLoc, string( "signal handler" ) } }, "", 0 } );
 
-      GEOS_LOG( GEOS_FMT( "***** ERROR\n"
-                          "***** SIGNAL: {}\n"
-                          "***** LOCATION: (external error, captured by signal handler)\n"
-                          "{}\n{}",
-                          signal, error.m_msg, stackHistory ) );
+      ErrorLogger::global().flushErrorMsg( error );
 
-      if( ErrorLogger::global().isOutputFileEnabled() )
-      {
-        error.setType( ErrorLogger::MsgType::Error );
-        error.addRank( ::geos::logger::internal::g_rank );
-        error.addCallStackInfo( stackHistory );
-        error.addContextInfo(
-          ErrorContext{ { { ErrorContext::Attribute::Signal, std::to_string( signal ) } }, 1 },
-          ErrorContext{ { { ErrorContext::Attribute::DetectionLoc, string( "signal handler" ) } }, 0 } );
-
-        ErrorLogger::global().flushErrorMsg( error );
-      }
 
       // call program termination
       LvArray::system::callErrorHandler();

src/coreComponents/common/logger/ErrorHandling.cpp

@@ -41,6 +41,61 @@ static constexpr std::string_view g_level3Next =  "        ";
 
 ErrorLogger g_errorLogger{};
 
+/**
+ * @brief Retrieve all informations from the ErrorMsg and format and write into a stream.
+ * @param errMsg Class containing all the error/warning information
+ * @param oss The output stream to write the content to.
+ */
+void ErrorLogger::writeToAscii( ErrorLogger::ErrorMsg const & errMsg, std::ostream & oss )
+{
+  /// HEADER
+  oss << "***** " << ErrorLogger::toString( errMsg.m_type ) << "\n";
+  if( !errMsg.m_signal.empty())
+  {
+    oss<< "***** SIGNAL: "<< errMsg.m_signal <<"\n";
+  }
+  oss << "***** LOCATION: " << errMsg.m_file<< " l." << errMsg.m_line << "\n";
+  oss << "***** " << errMsg.m_cause  << "\n";
+  oss << "***** Rank " << stringutilities::join( errMsg.m_ranksInfo, ", " ) << "\n";
+
+  std::vector< ErrorLogger::ErrorContext > const contextsInfo = errMsg.m_contextsInfo;
+  /// ERROR CONTEXT
+  if( contextsInfo.empty())
+  {
+    oss << "***** Message :\n";
+    oss << errMsg.m_msg << "\n";
+  }
+  else
+  {
+    if( contextsInfo.size() >= 1 )
+    {
+
+      oss << "***** Message from "   << contextsInfo.front().m_dataDisplayString<< ":\n";
+      oss << errMsg.m_msg << "\n";
+    }
+
+    if( contextsInfo.size() > 1 )
+    {
+      oss << "***** Additional contexts:\n";
+      for( size_t i = 1; i< contextsInfo.size(); i++ )
+      {
+        oss << "***** - "  << contextsInfo[i].m_dataDisplayString << "\n";
+      }
+    }
+
+  }
+  ///STACKTRACE
+  if( errMsg.m_sourceCallStack.size() > 0 )
+  {
+    oss << "\n** StackTrace of "<< errMsg.m_sourceCallStack.size() << " frames **\n";
+    for( size_t i = 0; i < errMsg.m_sourceCallStack.size(); i++ )
+    {
+      oss << GEOS_FMT( "Frame {}: {}\n", i, errMsg.m_sourceCallStack[i] );
+    }
+    oss << "=====\n";
+  }
+}
+
 ErrorLogger & ErrorLogger::global()
 { return g_errorLogger; }
 
@@ -228,10 +283,10 @@ void ErrorLogger::streamMultilineYamlAttribute( std::string_view msg, std::ofstr
   }
 }
 
-void ErrorLogger::flushErrorMsg( ErrorLogger::ErrorMsg & errorMsg )
+void ErrorLogger::writeToYaml( ErrorMsg & errorMsg )
 {
   std::ofstream yamlFile( std::string( m_filename ), std::ios::app );
-  if( yamlFile.is_open() && isOutputFileEnabled() )
+  if( yamlFile.is_open() )
   {
     // General errors info (type, rank on which the error occured)
     yamlFile << g_level1Start << "type: " << ErrorLogger::toString( errorMsg.m_type ) << "\n";
@@ -291,12 +346,20 @@ void ErrorLogger::flushErrorMsg( ErrorLogger::ErrorMsg & errorMsg )
     yamlFile << "\n";
     yamlFile.flush();
     errorMsg = ErrorMsg();
-    GEOS_LOG_RANK( GEOS_FMT( "The error file {} has been appended.\n", m_filename ) );
+    GEOS_LOG_RANK( GEOS_FMT( "The error file {} has been appended.", m_filename ) );
   }
   else
   {
-    GEOS_LOG_RANK( GEOS_FMT( "Unable to open error file for writing.\n- Error file: {}\n- Error file enabled = {}.\n",
-                             m_filename, isOutputFileEnabled() ) );
+    GEOS_LOG_RANK( GEOS_FMT( "Unable to open error file for writing.\n- Error file: {}\n", m_filename ) );
+  }
+}
+
+void ErrorLogger::flushErrorMsg( ErrorMsg & errorMsg )
+{
+  writeToAscii( errorMsg, getErrorStream() );
+  if( isOutputFileEnabled() )
+  {
+    writeToYaml( errorMsg );
   }
 }
 

src/coreComponents/common/logger/ErrorHandling.hpp

@@ -21,6 +21,8 @@
 #define INITIALIZATION_ERROR_LOGGER_HPP
 
 #include "common/DataTypes.hpp"
+#include "common/format/Format.hpp"
+#include "common/format/StringUtilities.hpp"
 
 namespace geos
 {
@@ -33,13 +35,15 @@ class ErrorLogger
 {
 
 public:
+
   /**
    * @enum MsgType
    * Enum listing the different types of possible errors
    */
   enum class MsgType
   {
     Error,
+    ExternalError,
     Warning,
     Exception,
     Undefined
@@ -75,6 +79,9 @@ class ErrorLogger
     /// The key is a field of the Attribute enumeration and is converted to a string for writing in the YAML
     map< Attribute, std::string > m_attributes;
 
+    /// String containing the target object name followed by the the file and line declaring it.
+    string m_dataDisplayString;
+
     /**
      * @brief Priority level assigned to an error context.
      * @details Used to prioritize contextes (higher values = more relevant). Default is 0.
@@ -105,6 +112,8 @@ class ErrorLogger
   {
     /// the error type (Warning, Error or Exception)
     MsgType m_type = ErrorLogger::MsgType::Undefined;
+    /// The signal received and formatted
+    std::string m_signal;
     /// the error message that can be completed
     std::string m_msg;
     /// the cause of the error (erroneous condition, failed assertion...) if identified (optional)
@@ -230,6 +239,13 @@ class ErrorLogger
     bool m_isValidStackTrace = false;
   };
 
+  /**
+   * @brief Format all information in ErrorMsg and write it to the specified output stream
+   * @param errMsg The struct containing the error/warning object
+   * @param oss The output stream
+   */
+  static void writeToAscii( ErrorLogger::ErrorMsg const & errMsg, std::ostream & oss );
+
   /**
    * @return Global instance of the ErrorLogger class used for error/warning reporting.
    * @details This global instance is used across the codebase to log errors, warnings, and exceptions,
@@ -239,12 +255,6 @@ class ErrorLogger
    */
   GEOS_HOST static ErrorLogger & global();
 
-  /**
-   * @return true if the YAML file output is enabled
-   */
-  bool isOutputFileEnabled() const
-  { return m_writeYaml; }
-
   /**
    * @brief Enable the YAML file output, which is false by default
    * @param value A value of true enable the file writing
@@ -268,9 +278,8 @@ class ErrorLogger
 
   /**
    * @brief Gives acces to the error message that is currently being constructed,
-   *        potencially at various application layers
-   *        Use flushErrorMsg() when the message is fully constructed and you want it to be output
-   * @return Reference to the current instance for method chaining.
+   *        potencially at various application layers (Typically for exceptions)
+   * @return Reference to the current error message instance;
    */
   ErrorMsg & currentErrorMsg()
   { return m_currentErrorMsg; }
@@ -293,15 +302,43 @@ class ErrorLogger
    *        and reset the errorMsg instance to its initial state
    * @param errorMsg a constant reference to the error
    */
+  void writeToYaml( ErrorMsg & errorMsg );
+
+  /**
+   * @brief Write all the information retrieved about the error/warning message into the output stream specified and
+   * optionnaly into a yaml file
+   * @param errorMsg a constant reference to the ErrorMsg
+   */
   void flushErrorMsg( ErrorMsg & errorMsg );
 
+  /**
+   * @return Return the const general log stream
+   */
+  std::ostream const & getErrorStream() const
+  { return m_stream; }
+
+  /**
+   * @return Return the reference general log stream
+   */
+  std::ostream & getErrorStream()
+  { return m_stream; }
+
 private:
   /// The error constructed via exceptions
   ErrorMsg m_currentErrorMsg;
   /// Indicate whether the write to YAML command line option is enabled
   bool m_writeYaml = false;
   /// YAML file name
   std::string_view m_filename = "errors.yaml";
+  /// The stream used for the log output. By default used std::cout
+  std::ostream & m_stream = std::cout;
+
+
+  /**
+   * @return true if the YAML file output is enabled
+   */
+  bool isOutputFileEnabled() const
+  { return m_writeYaml; }
 
   /**
    * @brief Write the error message in the YAML file regarding indentation and line break