MAINT-5011: Catch unhandled exceptions in LLCoros coroutines.

Wrap coroutine call in try/catch in top-level coroutine wrapper function
LLCoros::toplevel(). Distinguish exception classes derived from
LLContinueError (log and continue) from all others (crash with LL_ERRS).

Enhance CRASH_ON_UNHANDLED_EXCEPTIONS() and LOG_UNHANDLED_EXCEPTIONS() macros
to accept a context string to supplement the log message. This lets us replace
many places that called boost::current_exception_diagnostic_information() with
LOG_UNHANDLED_EXCEPTIONS() instead, since the explicit calls were mostly to
log supplemental information.

Provide supplemental information (coroutine name, function parameters) for
some of the previous LOG_UNHANDLED_EXCEPTIONS() calls. This information
duplicates LL_DEBUGS() information at the top of these functions, but in a
typical log file we wouldn't see the LL_DEBUGS() message.

Eliminate a few catch (std::exception e) clauses: the information we get from
boost::current_exception_diagnostic_information() in a catch (...) clause
makes it unnecessary to distinguish.

In a few cases, add a final 'throw;' to a catch (...) clause: having logged
the local context info, propagate the exception to be caught by higher-level
try/catch.

In a couple places, couldn't resist reconciling indentation within a
particular function: tabs where the rest of the function uses tabs, spaces
where the rest of the function uses spaces.

In LLLogin::Impl::loginCoro(), eliminate some confusing comments about an
array of rewritten URIs that date back to a long-deleted implementation.

1 files changed, 14 insertions, 7 deletions

diff --git a/indra/llcommon/llexception.cpp b/indra/llcommon/llexception.cpp
index 9a6dfee3f1..791b115a8c 100644
--- a/indra/llcommon/llexception.cpp
+++ b/indra/llcommon/llexception.cpp
@@ -24,25 +24,32 @@
 namespace {
 // used by crash_on_unhandled_exception_() and log_unhandled_exception_()
 void log_unhandled_exception_(LLError::ELevel level,
-                              const char* file, int line, const char* pretty_function)
+                              const char* file, int line, const char* pretty_function,
+                              const std::string& context)
 {
     // log same message but allow caller-specified severity level
     // lllog() is the macro underlying LL_ERRS(), LL_WARNS() et al.
     lllog(level, false) << file << "(" << line << "): Unhandled exception caught in "
-                        << pretty_function
-                        << ":\n" << boost::current_exception_diagnostic_information() << LL_ENDL;
+                        << pretty_function;
+    if (! context.empty())
+    {
+        LL_CONT << ": " << context;
+    }
+    LL_CONT << ":\n" << boost::current_exception_diagnostic_information() << LL_ENDL;
 }
 }
 
-void crash_on_unhandled_exception_(const char* file, int line, const char* pretty_function)
+void crash_on_unhandled_exception_(const char* file, int line, const char* pretty_function,
+                                   const std::string& context)
 {
     // LL_ERRS() terminates and propagates message into crash dump.
-    log_unhandled_exception_(LLError::LEVEL_ERROR, file, line, pretty_function);
+    log_unhandled_exception_(LLError::LEVEL_ERROR, file, line, pretty_function, context);
 }
 
-void log_unhandled_exception_(const char* file, int line, const char* pretty_function)
+void log_unhandled_exception_(const char* file, int line, const char* pretty_function,
+                              const std::string& context)
 {
     // Use LL_WARNS() because we seriously do not expect this to happen
     // routinely, but we DO expect to return from this function.
-    log_unhandled_exception_(LLError::LEVEL_WARN, file, line, pretty_function);
+    log_unhandled_exception_(LLError::LEVEL_WARN, file, line, pretty_function, context);
 }