Use filename where exception was thrown in DumpStackBacktrace

Allows us to turn on exceptions for specific files, rather that
filtering them all as Utils.cpp.

(cherry picked from commit 3590e97)

lib/common/Box.h

@@ -31,7 +31,7 @@
 
 #ifdef SHOW_BACKTRACE_ON_EXCEPTION
 	#include "Utils.h"
-	#define OPTIONAL_DO_BACKTRACE DumpStackBacktrace();
+	#define OPTIONAL_DO_BACKTRACE DumpStackBacktrace(__FILE__);
 #else
 	#define OPTIONAL_DO_BACKTRACE
 #endif

lib/common/Logging.cpp

@@ -284,12 +284,23 @@ bool Logging::ShouldLog(Log::Level default_level, Log::Level message_level,
 	const std::string& file, int line, const std::string& function, const Log::Category& category,
 	const std::string& message)
 {
+	// Based on http://stackoverflow.com/a/40947954/648162 and
+	// http://stackoverflow.com/a/41367919/648162, but since we have to do this at runtime for
+	// each logging call, don't do the strrchr unless we have at least one override configured
+	// (otherwise it's never used, and a waste of CPU):
+	const char* current_file = NULL;
+	if(Logging::sLogLevelOverrideByFileGuards.begin() !=
+		Logging::sLogLevelOverrideByFileGuards.end())
+	{
+		current_file = strrchr(file.c_str(), DIRECTORY_SEPARATOR_ASCHAR) + 1;
+	}
+
 	Log::Level level_filter = default_level;
 	for(std::vector<LogLevelOverrideByFileGuard>::iterator
 		i = Logging::sLogLevelOverrideByFileGuards.begin();
 		i != Logging::sLogLevelOverrideByFileGuards.end(); i++)	
 	{
-		if(i->IsOverridden(message_level, file, line, function, category, message))
+		if(i->IsOverridden(message_level, current_file, line, function, category, message))
 		{
 			level_filter = i->GetNewLevel();
 		}
@@ -745,9 +756,14 @@ int Logging::OptionParser::ProcessOption(signed int option)
 // --------------------------------------------------------------------------
 std::string Logging::OptionParser::GetUsageString()
 {
-	return
+	// Based on http://stackoverflow.com/a/40947954/648162 and
+	// http://stackoverflow.com/a/41367919/648162:
+	const char* current_file = strrchr(__FILE__, DIRECTORY_SEPARATOR_ASCHAR) + 1;
+
+	std::ostringstream buf;
+	buf <<
 	"  -L <file>=<level>  Override log level for specified file, can repeat\n"
-	"             (for example, -L '" __FILE__ "=trace')\n"
+	"             (for example, -L '" << current_file << "=trace')\n"
 	"  -N         Truncate log file at startup and on backup start\n"
 	"  -P         Show process ID (PID) in console output\n"
 	"  -q         Run more quietly, reduce verbosity level by one, can repeat\n"
@@ -758,6 +774,7 @@ std::string Logging::OptionParser::GetUsageString()
 	"  -v         Run more verbosely, increase verbosity level by one, can repeat\n"
 	"  -V         Run at maximum verbosity, log everything to console and system\n"
 	"  -W <level> Set verbosity to error/warning/notice/info/trace/everything\n";
+	return buf.str();
 }
 
 bool HideCategoryGuard::Log(Log::Level level, const std::string& file, int line,

lib/common/Logging.h

@@ -26,7 +26,7 @@
 { \
 	std::ostringstream _box_log_line; \
 	_box_log_line << stuff; \
-	Logging::Log(level, BOX_CURRENT_FILE, __LINE__, __FUNCTION__, \
+	Logging::Log(level, __FILE__, __LINE__, __FUNCTION__, \
 		Logging::UNCATEGORISED, _box_log_line.str()); \
 }
 

lib/common/Utils.cpp

@@ -143,6 +143,12 @@ std::string RemoveSuffix(const std::string& suffix, const std::string& haystack)
 	}
 }
 
+// The backtrace routines are used by DebugMemLeakFinder, so we need to disable memory leak
+// tracking during them, otherwise we could end up with infinite recursion.
+#include "MemLeakFindOff.h"
+
+const Log::Category BACKTRACE("Backtrace");
+
 static std::string demangle(const std::string& mangled_name)
 {
 	std::string demangled_name = mangled_name;
@@ -201,7 +207,7 @@ static std::string demangle(const std::string& mangled_name)
 	return demangled_name;
 }
 
-void DumpStackBacktrace()
+void DumpStackBacktrace(const std::string& filename)
 {
 	const int max_length = 20;
 	void  *array[max_length];
@@ -216,11 +222,18 @@ void DumpStackBacktrace()
 	return;
 #endif
 
-	BOX_TRACE("Obtained " << size << " stack frames.");
-	DumpStackBacktrace(size, array);
+	// Instead of calling BOX_TRACE, we call Logging::Log directly in order to pass filename
+	// as the source file. This allows exception backtraces to be turned on and off by file,
+	// instead of all of them originating in Utils.cpp.
+	std::ostringstream output;
+	output << "Obtained " << size << " stack frames.";
+	Logging::Log(Log::TRACE, filename, 0, // line
+		__FUNCTION__, BACKTRACE, output.str());
+
+	DumpStackBacktrace(filename, size, array);
 }
 
-void DumpStackBacktrace(size_t size, void * const * array)
+void DumpStackBacktrace(const std::string& filename, size_t size, void * const * array)
 {
 #if defined WIN32
 	HANDLE hProcess = GetCurrentProcess();
@@ -277,7 +290,11 @@ void DumpStackBacktrace(size_t size, void * const * array)
 				(void *)diff;
 		}
 
-		BOX_TRACE(output.str());
+		// Instead of calling BOX_TRACE, we call Logging::Log directly in order to pass filename
+		// as the source file. This allows exception backtraces to be turned on and off by file,
+		// instead of all of them originating in Utils.cpp.
+		Logging::Log(Log::TRACE, filename, 0, // line
+			__FUNCTION__, BACKTRACE, output.str());
 	}
 }
 
@@ -307,7 +324,7 @@ bool FileExists(const std::string& rFilename, int64_t *pFileSize,
 		}
 	}
 
-	// is it a file?	
+	// is it a file?
 	if((st.st_mode & S_IFDIR) == 0)
 	{
 		if(TreatLinksAsNotExisting && ((st.st_mode & S_IFLNK) != 0))

lib/common/Utils.h

@@ -23,7 +23,8 @@ bool EndsWith(const std::string& prefix, const std::string& haystack);
 std::string RemovePrefix(const std::string& prefix, const std::string& haystack);
 std::string RemoveSuffix(const std::string& suffix, const std::string& haystack);
 
-void DumpStackBacktrace();
+void DumpStackBacktrace(const std::string& filename);
+void DumpStackBacktrace(const std::string& filename, size_t size, void * const * array);
 
 bool FileExists(const std::string& rFilename, int64_t *pFileSize = 0,
 	bool TreatLinksAsNotExisting = false);

lib/server/SocketStream.cpp

@@ -566,6 +566,6 @@ void SocketStream::CheckForMissingTimeout(int Timeout)
 	if (Timeout == IOStream::TimeOutInfinite)
 	{
 		BOX_WARNING("Network operation started with no timeout!");
-		DumpStackBacktrace();
+		OPTIONAL_DO_BACKTRACE;
 	}
 }