Added log file metadata header, fixed timestamps, fixed exception handler on Windows, refactoring

deathkiller · deathkiller · commit 25aebeea7d1f · 2025-08-21T11:30:12.000+02:00
diff --git a/Sources/Jazz2/LevelHandler.cpp b/Sources/Jazz2/LevelHandler.cpp
@@ -401,7 +401,7 @@ namespace Jazz2
 
 		_levelDisplayName = std::move(descriptor.DisplayName);
 
-		LOGI("Level \"{}\" – \"{}.j2l\" loaded", _levelDisplayName, _levelName);
+		LOGI("Level \"{}\" (from \"{}.j2l\") loaded", _levelDisplayName, _levelName);
 
 		if (!_levelDisplayName.empty()) {
 			theApplication().GetGfxDevice().setWindowTitle(String(NCINE_APP_NAME " - " + _levelDisplayName));
diff --git a/Sources/Jazz2/Multiplayer/MpLevelHandler.cpp b/Sources/Jazz2/Multiplayer/MpLevelHandler.cpp
@@ -2345,7 +2345,7 @@ namespace Jazz2::Multiplayer
 			}
 			SendMessage(peer, UI::MessageLevel::Confirm, { infoBuffer, length });
 
-			auto uptimeSecs = (DateTime::Now().ToUnixMilliseconds() / 1000) - (std::int64_t)serverConfig.StartUnixTimestamp;
+			auto uptimeSecs = (DateTime::UtcNow().ToUnixMilliseconds() / 1000) - (std::int64_t)serverConfig.StartUnixTimestamp;
 			auto hours = (std::int32_t)(uptimeSecs / 3600);
 			auto minutes = (std::int32_t)(uptimeSecs % 3600) / 60;
 			auto seconds = (std::int32_t)(uptimeSecs % 60);
diff --git a/Sources/Jazz2/Multiplayer/NetworkManager.cpp b/Sources/Jazz2/Multiplayer/NetworkManager.cpp
@@ -63,7 +63,7 @@ namespace Jazz2::Multiplayer
 		std::memcpy(&_serverConfig->UniqueServerID[0], &PreferencesCache::UniqueServerID[0], arraySize(_serverConfig->UniqueServerID) - sizeof(std::uint16_t));
 		std::memcpy(&_serverConfig->UniqueServerID[_serverConfig->UniqueServerID.size() - sizeof(std::uint16_t)], &serverPort, sizeof(std::uint16_t));
 
-		_serverConfig->StartUnixTimestamp = DateTime::Now().ToUnixMilliseconds() / 1000;
+		_serverConfig->StartUnixTimestamp = DateTime::UtcNow().ToUnixMilliseconds() / 1000;
 		bool result = NetworkManagerBase::CreateServer(handler, serverPort);
 
 		if (result && !_serverConfig->IsPrivate) {
diff --git a/Sources/Jazz2/PreferencesCache.cpp b/Sources/Jazz2/PreferencesCache.cpp
@@ -599,45 +599,6 @@ namespace Jazz2
 		return fs::GetDirectoryName(_configPath);
 	}
 
-	template<class Iterator>
-	static std::string ToBase64Url(const Iterator begin, const Iterator end)
-	{
-		static const StaticArray<64, char> chars {
-			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'
-		};
-
-		std::string result;
-		std::size_t c = 0;
-		StaticArray<3, std::uint8_t> charArray;
-
-		for (auto i = begin; i != end; ++i) {
-			charArray[c++] = static_cast<std::uint8_t>(*i);
-			if (c == 3) {
-				result += chars[static_cast<std::uint8_t>((charArray[0] & 0xFC) >> 2)];
-				result += chars[static_cast<std::uint8_t>(((charArray[0] & 0x03) << 4) + ((charArray[1] & 0xF0) >> 4))];
-				result += chars[static_cast<std::uint8_t>(((charArray[1] & 0x0F) << 2) + ((charArray[2] & 0xC0) >> 6))];
-				result += chars[static_cast<std::uint8_t>(charArray[2] & 0x3f)];
-				c = 0;
-			}
-		}
-
-		if (c != 0) {
-			result += chars[static_cast<std::uint8_t>((charArray[0] & 0xFC) >> 2)];
-			if (c == 1) {
-				result += chars[static_cast<std::uint8_t>((charArray[0] & 0x03) << 4)];
-			} else { // c == 2
-				result += chars[static_cast<std::uint8_t>(((charArray[0] & 0x03) << 4) + ((charArray[1] & 0xF0) >> 4))];
-				result += chars[static_cast<std::uint8_t>((charArray[1] & 0x0F) << 2)];
-			}
-		}
-
-		return result;
-	}
-
 	String PreferencesCache::GetDeviceID()
 	{
 #if defined(DEATH_TARGET_X86)
@@ -814,7 +775,7 @@ namespace Jazz2
 #else
 		static const char DeviceDesc[] = "||||"; std::int32_t DeviceDescLength = sizeof(DeviceDesc) - 1;
 #endif
-		return ToBase64Url(DeviceDesc, DeviceDesc + DeviceDescLength);
+		return toBase64Url(DeviceDesc, DeviceDesc + DeviceDescLength);
 	}
 
 	String PreferencesCache::GetEffectivePlayerName()
diff --git a/Sources/Jazz2/Scripting/JJ2PlusDefinitions.cpp b/Sources/Jazz2/Scripting/JJ2PlusDefinitions.cpp
@@ -2207,11 +2207,11 @@ namespace Jazz2::Scripting
 	}
 	std::uint64_t unixTimeSec() {
 		noop();
-		return Containers::DateTime::Now().ToUnixMilliseconds();
+		return Containers::DateTime::UtcNow().ToUnixMilliseconds();
 	}
 	std::uint64_t unixTimeMs() {
 		noop();
-		return Containers::DateTime::Now().ToUnixMilliseconds() / 1000;
+		return Containers::DateTime::UtcNow().ToUnixMilliseconds() / 1000;
 	}
 
 	bool jjRegexIsValid(const String& expression) {
diff --git a/Sources/Shared/Base/Format.cpp b/Sources/Shared/Base/Format.cpp
@@ -423,7 +423,7 @@ namespace Death { namespace Implementation {
 			for (std::size_t formatOffset = 0; formatOffset != format.size(); ) {
 				// Placeholder begin (or escaped {)
 				if (format[formatOffset] == '{') {
-					if (formatOffset + 1 < format.size() && format[formatOffset+1] == '{') {
+					if (formatOffset + 1 < format.size() && format[formatOffset + 1] == '{') {
 						writer(format.slice(formatOffset, formatOffset + 1));
 						formatOffset += 2;
 						continue;
@@ -442,7 +442,7 @@ namespace Death { namespace Implementation {
 
 				// Placeholder end (or escaped })
 				if (format[formatOffset] == '}') {
-					if (!inPlaceholder && formatOffset + 1 < format.size() && format[formatOffset+1] == '}') {
+					if (!inPlaceholder && formatOffset + 1 < format.size() && format[formatOffset + 1] == '}') {
 						writer(format.slice(formatOffset, formatOffset + 1));
 						formatOffset += 2;
 						continue;
diff --git a/Sources/Shared/Containers/DateTime.cpp b/Sources/Shared/Containers/DateTime.cpp
@@ -49,7 +49,7 @@ namespace Death { namespace Containers {
 		static bool IsLeapYear(std::int32_t year) noexcept
 		{
 			if (year == -1) {
-				year = DateTime::Now().GetYear();
+				year = DateTime::UtcNow().GetYear();
 			}
 
 			return (year % 4 == 0 && ((year % 100) != 0 || (year % 400) == 0));
@@ -857,7 +857,7 @@ namespace Death { namespace Containers {
 			if (result.IsValid()) {
 				tm = result.Partitioned();
 			} else {
-				tm = DateTime::Now().ResetTime().Partitioned();
+				tm = DateTime::UtcNow().ResetTime().Partitioned();
 			}
 
 			if (haveMon) {
@@ -1034,29 +1034,16 @@ namespace Death { namespace Containers {
 		_dayOfWeek = (Implementation::GetTruncatedJDN(Day, Month, Year) + 2) % 7;
 	}
 
-	DateTime DateTime::Now() noexcept
-	{
-#if defined(DEATH_TARGET_WINDOWS)
-		SYSTEMTIME st;
-		::GetLocalTime(&st);
-		return DateTime(st);
-#else
-		time_t t = time(nullptr);
-		return DateTime(t);
-#endif
-	}
-
 	DateTime DateTime::UtcNow() noexcept
 	{
 #if defined(DEATH_TARGET_WINDOWS)
-		SYSTEMTIME st;
-		::GetSystemTime(&st);
-		return DateTime(st);
+		FILETIME ft;
+		::GetSystemTimeAsFileTime(&ft);
+		return DateTime(ft);
 #else
-		time_t t = time(nullptr);
-		DateTime dt = DateTime(t);
-		dt.AdjustToTimezone(UTC);
-		return dt;
+		struct timeval tp{};
+		gettimeofday(&tp, nullptr);
+		return DateTime::FromUnixMilliseconds((tp.tv_sec * 1000) + (tp.tv_usec / 1000));
 #endif
 	}
 
diff --git a/Sources/Shared/Containers/DateTime.h b/Sources/Shared/Containers/DateTime.h
@@ -131,8 +131,6 @@ namespace Death { namespace Containers {
 			std::int32_t _dayOfWeek;
 		};
 
-		/** @brief Returns @ref DateTime that is set to the current date and time on this computer, expressed as the local time */
-		static DateTime Now() noexcept;
 		/** @brief Returns @ref DateTime that is set to the current date and time on this computer, expressed as the UTC time */
 		static DateTime UtcNow() noexcept;
 
diff --git a/Sources/Shared/Core/Backward.h b/Sources/Shared/Core/Backward.h
@@ -3815,10 +3815,11 @@ namespace Death { namespace Backward {
 
 		/** @brief Prints standard prologue of the text log file */
 		void PrintFilePrologue(IO::Stream* s) {
-			auto p = Containers::DateTime::Now().Partitioned();
+			auto p = Containers::DateTime::UtcNow().Partitioned();
 
 			char buffer[64];
-			std::int32_t length = snprintf(buffer, sizeof(buffer), "%02u:%02u:%02u.%03u [F] ", p.Hour, p.Minute, p.Second, p.Millisecond);
+			std::int32_t length = (std::int32_t)formatInto(buffer, "{:.2}:{:.2}:{:.2}.{:.3} [F] ",
+				p.Hour, p.Minute, p.Second, p.Millisecond);
 			if (length > 0) {
 				s->Write(buffer, length);
 			}
@@ -4518,6 +4519,17 @@ namespace Death { namespace Backward {
 			auto* _this = GetSingleton();
 			auto& context = _this->_context;
 
+			{
+				std::unique_lock<std::mutex> lk(_this->_lock);
+				if (_this->_status >= HandlerStatus::Crashed) {
+					// Crash handler was already called, wait until it finishes
+					while (_this->_status == HandlerStatus::Crashed) {
+						::Sleep(10);
+					}
+					return;
+				}
+			}
+
 			if (info == nullptr) {
 #	if (defined(_M_IX86) || defined(__i386__)) && defined(DEATH_TARGET_MSVC)
 				// RtlCaptureContext() doesn't work on i386
@@ -4548,6 +4560,13 @@ namespace Death { namespace Backward {
 
 			{
 				std::unique_lock<std::mutex> lk(_this->_lock);
+				if (_this->_status >= HandlerStatus::Crashed) {
+					// Crash handler was already called, wait until it finishes
+					while (_this->_status == HandlerStatus::Crashed) {
+						::Sleep(10);
+					}
+					return;
+				}
 				_this->_status = HandlerStatus::Crashed;
 			}
 
diff --git a/Sources/Shared/Core/Logger.cpp b/Sources/Shared/Core/Logger.cpp
@@ -709,7 +709,7 @@ namespace Death { namespace Trace {
 
 		for (ThreadContext* tc : _activeThreadContextsCache) {
 			TransitEvent const* te = tc->_transitEventBuffer.front();
-			if (te && (minTs > te->Timestamp)) {
+			if (te != nullptr && minTs > te->Timestamp) {
 				minTs = te->Timestamp;
 				threadContext = tc;
 			}
diff --git a/Sources/Shared/IO/WebRequest.cpp b/Sources/Shared/IO/WebRequest.cpp
@@ -403,12 +403,8 @@ namespace Death { namespace IO {
 			return Result::Unauthorized(resp->GetStatusText());
 		} else if (status >= 400) {
 			char errorMessage[64];
-#if defined(DEATH_TARGET_WINDOWS) && !defined(DEATH_TARGET_MINGW)
-			::sprintf_s(errorMessage, "Error %i (%s)", status, resp->GetStatusText().data());
-#else
-			::snprintf(errorMessage, sizeof(errorMessage), "Error %i (%s)", status, resp->GetStatusText().data());
-#endif
-			return Result::Error(errorMessage);
+			std::size_t length = formatInto(errorMessage, "Error {} ({})", status, resp->GetStatusText());
+			return Result::Error({ errorMessage, length });
 		} else {
 			return Result::Ok(WebRequest::State::Completed);
 		}
@@ -777,12 +773,8 @@ namespace Death { namespace IO {
 			std::uint64_t hash = Environment::QueryUnbiasedInterruptTime() * 11400714819323198485ULL;
 			for (std::int32_t i = 0; i < 10; i++) {
 				char fileName[64];
-#if defined(DEATH_TARGET_WINDOWS) && !defined(DEATH_TARGET_MINGW)
-				::sprintf_s(fileName, "Dx-%08x-%08x", std::uint32_t((hash >> 32) & 0xffffffff), std::uint32_t(hash & 0xffffffff));
-#else
-				::snprintf(fileName, sizeof(fileName), "Dx-%08x-%08x", std::uint32_t((hash >> 32) & 0xffffffff), std::uint32_t(hash & 0xffffffff));
-#endif
-				_file = std::make_unique<FileStream>(FileSystem::CombinePath(tempDir, fileName), FileAccess::Write);
+				std::size_t length = formatInto(fileName, "Dx-{:.8x}-{:.8x}", std::uint32_t((hash >> 32) & 0xffffffff), std::uint32_t(hash & 0xffffffff));
+				_file = std::make_unique<FileStream>(FileSystem::CombinePath(tempDir, { fileName, length }), FileAccess::Write);
 				if (_file->IsValid()) {
 					break;
 				}
@@ -2021,12 +2013,8 @@ namespace Death { namespace IO {
 	WebRequest::Result WebRequestWinHTTP::Fail(StringView operation, DWORD errorCode)
 	{
 		char message[256];
-#if defined(DEATH_TARGET_WINDOWS) && !defined(DEATH_TARGET_MINGW)
-		::sprintf_s(message, "%s failed with error %08x%s", String::nullTerminatedView(operation).data(), errorCode, __GetWin32ErrorSuffix(errorCode));
-#else
-		::snprintf(message, sizeof(message), "%s failed with error %08x%s", String::nullTerminatedView(operation).data(), errorCode, __GetWin32ErrorSuffix(errorCode));
-#endif
-		return Result::Error(message);
+		std::size_t length = formatInto(message, "{} failed with error {:.8x}{}", operation, errorCode, __GetWin32ErrorSuffix(errorCode));
+		return Result::Error({ message, length });
 	}
 
 	WebRequest::Result WebRequestWinHTTP::Execute()
@@ -2549,7 +2537,7 @@ namespace Death { namespace IO {
 		{
 			CURLcode res = curl_easy_setopt(handle, option, value);
 			if (res != CURLE_OK) {
-				LOGW("curl_easy_setopt({}, {}) failed: {}", std::int32_t(option), std::size_t(value), curl_easy_strerror(res));
+				LOGW("curl_easy_setopt({}, {}) failed: {}", std::int32_t(option), std::uintptr_t(value), curl_easy_strerror(res));
 			}
 		}
 
diff --git a/Sources/nCine/Application.cpp b/Sources/nCine/Application.cpp
@@ -95,6 +95,7 @@ using namespace Death::IO;
 
 #if defined(DEATH_TRACE)
 
+#include <IO/MemoryStream.h>
 #if defined(DEATH_TARGET_WINDOWS)
 #	include <Environment.h>
 #	include <Utf8.h>
@@ -407,6 +408,46 @@ static void OnHandleInterruptSignal(int sig)
 }
 #endif
 
+static void AppendLogFileHeader(Stream& s)
+{
+	// Write TraceDigger metadata header
+
+#if defined(DEATH_TARGET_WINDOWS)
+	std::uint32_t processId = (std::uint32_t)::GetCurrentProcessId();
+	wchar_t hostNameW[128]; DWORD hostNameWLength = (DWORD)arraySize(hostNameW);
+	if (!::GetComputerNameW(hostNameW, &hostNameWLength)) {
+		hostNameWLength = 0;
+	}
+	char hostName[128];
+	std::int32_t hostNameLength = Utf8::FromUtf16(hostName, hostNameW, hostNameWLength);
+#else
+	std::uint32_t processId = (std::uint32_t)::getpid();
+	char hostName[128] {}; std::int32_t hostNameLength = 0;
+	if (::gethostname(hostName, arraySize(DeviceDesc)) == 0) {
+		hostName[arraySize(hostName) - 1] = '\0';
+		hostNameLength = std::strlen(DeviceDesc);
+	}
+#endif
+
+	char buffer[256];
+	MemoryStream ms(buffer, sizeof(buffer));
+	ms.WriteVariableUint32(0); // Flags
+	ms.WriteVariableInt64(DateTime::UtcNow().ToUnixMilliseconds());
+	ms.WriteVariableUint32(processId);
+	auto executablePath = fs::GetExecutablePath();
+	auto executableFileName = fs::GetFileName(executablePath);
+	ms.WriteVariableUint32((std::uint32_t)executableFileName.size());
+	ms.Write(executableFileName.data(), (std::int64_t)executableFileName.size());
+	ms.WriteVariableUint32((std::uint32_t)hostNameLength);
+	ms.Write(hostName, (std::int64_t)hostNameLength);
+	auto metadataBase64 = nCine::toBase64Url(buffer, buffer + (std::size_t)ms.GetPosition());
+
+	constexpr StringView FileHeader = "#! /usr/bin/tracedigger :"_s;
+	s.Write(FileHeader.data(), (std::int64_t)FileHeader.size());
+	s.Write(metadataBase64.data(), (std::int64_t)metadataBase64.size());
+	s.Write("\n", 1);
+}
+
 template<std::int32_t N>
 static DEATH_ALWAYS_INLINE void AppendPart(char* dest, std::int32_t& length, const char(&newPart)[N])
 {
@@ -424,8 +465,8 @@ static void AppendDateTime(char* dest, std::int32_t& length, std::uint64_t times
 	auto dt = DateTime::FromUnixMilliseconds(timestamp / 1000000ULL);
 	auto p = dt.Partitioned();
 
-	length += snprintf(dest + length, MaxLogEntryLength - length - 1,
-		"%02u:%02u:%02u.%03u", p.Hour, p.Minute, p.Second, p.Millisecond);
+	length += (std::int32_t)formatInto({ dest + length, (std::size_t)(MaxLogEntryLength - length - 1) },
+		"{:.2}:{:.2}:{:.2}.{:.3}", p.Hour, p.Minute, p.Second, p.Millisecond);
 }
 
 static void AppendLevel(char* dest, std::int32_t& length, TraceLevel level, StringView threadId)
@@ -444,7 +485,8 @@ static void AppendLevel(char* dest, std::int32_t& length, TraceLevel level, Stri
 		default:					levelIdentifier = 'D'; break;
 	}
 
-	std::int32_t partLength = snprintf(dest + length, MaxLogEntryLength - length - 1, !threadId.empty() ? "[%c]%s}" : "[%c]", levelIdentifier, threadId.data());
+	std::int32_t partLength = (std::int32_t)formatInto({ dest + length, (std::size_t)(MaxLogEntryLength - length - 1) },
+		!threadId.empty() ? "[{:c}]{}}}" : "[{:c}]", levelIdentifier, threadId);
 	length += partLength;
 
 	while (partLength < 10) {
@@ -1421,7 +1463,8 @@ namespace nCine
 
 #if defined(DEATH_TRACE) && !defined(DEATH_TARGET_EMSCRIPTEN)
 		__logFile = fs::Open(targetPath, FileAccess::Write);
-		if (*__logFile) {
+		if (__logFile->IsValid()) {
+			AppendLogFileHeader(*__logFile);
 #	if defined(WITH_BACKWARD)
 			// Try to save crash info to log file
 			__eh.Destination = __logFile.get();
diff --git a/Sources/nCine/Audio/ALAudioDevice.cpp b/Sources/nCine/Audio/ALAudioDevice.cpp
@@ -139,7 +139,8 @@ namespace nCine
 					LOGI("Resampler: {} ({})", resamplerName, defaultResampler);
 
 					StringUtils::lowercaseInPlace(resamplerName);
-					if (resamplerName != "linear"_s) {
+					// "Linear" is default in v1.22.2, "Cubic" is default in v1.23.1 and "Cubic Spline" in v1.24.2
+					if (resamplerName != "linear"_s && !resamplerName.hasPrefix("cubic"_s)) {
 						defaultResamplerOverriden = true;
 					}
 				}
diff --git a/Sources/nCine/Base/Algorithms.h b/Sources/nCine/Base/Algorithms.h

Original file line number	Diff line number	Diff line change
`@@ -2345,7 +2345,7 @@ namespace Jazz2::Multiplayer`
`2345`	`2345`	`}`
`2346`	`2346`	`SendMessage(peer, UI::MessageLevel::Confirm, { infoBuffer, length });`
`2347`	`2347`
`2348`		`- auto uptimeSecs = (DateTime::Now().ToUnixMilliseconds() / 1000) - (std::int64_t)serverConfig.StartUnixTimestamp;`
	`2348`	`+ auto uptimeSecs = (DateTime::UtcNow().ToUnixMilliseconds() / 1000) - (std::int64_t)serverConfig.StartUnixTimestamp;`
`2349`	`2349`	`auto hours = (std::int32_t)(uptimeSecs / 3600);`
`2350`	`2350`	`auto minutes = (std::int32_t)(uptimeSecs % 3600) / 60;`
`2351`	`2351`	`auto seconds = (std::int32_t)(uptimeSecs % 60);`
Original file line number	Diff line number	Diff line change
`@@ -2207,11 +2207,11 @@ namespace Jazz2::Scripting`
`2207`	`2207`	`}`
`2208`	`2208`	`std::uint64_t unixTimeSec() {`
`2209`	`2209`	`noop();`
`2210`		`- return Containers::DateTime::Now().ToUnixMilliseconds();`
	`2210`	`+ return Containers::DateTime::UtcNow().ToUnixMilliseconds();`
`2211`	`2211`	`}`
`2212`	`2212`	`std::uint64_t unixTimeMs() {`
`2213`	`2213`	`noop();`
`2214`		`- return Containers::DateTime::Now().ToUnixMilliseconds() / 1000;`
	`2214`	`+ return Containers::DateTime::UtcNow().ToUnixMilliseconds() / 1000;`
`2215`	`2215`	`}`
`2216`	`2216`
`2217`	`2217`	`bool jjRegexIsValid(const String& expression) {`
Original file line number	Diff line number	Diff line change
`@@ -709,7 +709,7 @@ namespace Death { namespace Trace {`
`709`	`709`
`710`	`710`	`for (ThreadContext* tc : _activeThreadContextsCache) {`
`711`	`711`	`TransitEvent const* te = tc->_transitEventBuffer.front();`
`712`		`- if (te && (minTs > te->Timestamp)) {`
	`712`	`+ if (te != nullptr && minTs > te->Timestamp) {`
`713`	`713`	`minTs = te->Timestamp;`
`714`	`714`	`threadContext = tc;`
`715`	`715`	`}`