5 files changed, 97 insertions, 66 deletions

diff --git a/src/zencore/include/zencore/memory/memorytrace.h b/src/zencore/include/zencore/memory/memorytrace.h
index d1ab1f914..6be7adb89 100644
--- a/src/zencore/include/zencore/memory/memorytrace.h
+++ b/src/zencore/include/zencore/memory/memorytrace.h
@@ -94,7 +94,7 @@ ENUM_CLASS_FLAGS(EMemoryTraceInit);
 UE_TRACE_CHANNEL_EXTERN(MemAllocChannel);
 
 ////////////////////////////////////////////////////////////////////////////////
-class FMalloc* MemoryTrace_Create(class FMalloc* InMalloc);
+class FMalloc* MemoryTrace_Create(class FMalloc* InMalloc, const TraceOptions& Options);
 void		   MemoryTrace_Initialize();
 void		   MemoryTrace_Shutdown();
 
diff --git a/src/zencore/include/zencore/trace.h b/src/zencore/include/zencore/trace.h
index 2ca2b7c81..99a565151 100644
--- a/src/zencore/include/zencore/trace.h
+++ b/src/zencore/include/zencore/trace.h
@@ -21,19 +21,21 @@ ZEN_THIRD_PARTY_INCLUDES_END
 
 namespace zen {
 
-enum class TraceType
+struct TraceOptions
 {
-	File,
-	Network,
-	None
+	std::string Host;
+	std::string File;
+	std::string Channels;
 };
 
 void TraceInit(std::string_view ProgramName);
 void TraceShutdown();
 bool IsTracing();
-void TraceStart(std::string_view ProgramName, const char* HostOrPath, TraceType Type);
 bool TraceStop();
 
+bool GetTraceOptionsFromCommandline(TraceOptions& OutOptions);
+void TraceConfigure(const TraceOptions& Options);
+
 }
 
 #else
diff --git a/src/zencore/memory/memory.cpp b/src/zencore/memory/memory.cpp
index f236796ad..ae1b9abce 100644
--- a/src/zencore/memory/memory.cpp
+++ b/src/zencore/memory/memory.cpp
@@ -87,14 +87,19 @@ InitGMalloc()
 		}
 	};
 
-	constexpr std::string_view MallocOption = "--malloc="sv;
+	constexpr std::string_view MallocOption = "--malloc"sv;
 
 	std::function<void(const std::string_view&)> ProcessArg = [&](const std::string_view& Arg) {
 		if (Arg.starts_with(MallocOption))
 		{
-			const std::string_view OptionArgs = Arg.substr(MallocOption.size());
+			std::string_view::value_type DelimChar = Arg[MallocOption.length()];
 
-			IterateCommaSeparatedValue(OptionArgs, ProcessMallocArg);
+			if (DelimChar == ' ' || DelimChar == '=')
+			{
+				const std::string_view OptionArgs = Arg.substr(MallocOption.size() + 1);
+
+				IterateCommaSeparatedValue(OptionArgs, ProcessMallocArg);
+			}
 		}
 	};
 
diff --git a/src/zencore/memtrack/memorytrace.cpp b/src/zencore/memtrack/memorytrace.cpp
index e4ae8148e..8f723866d 100644
--- a/src/zencore/memtrack/memorytrace.cpp
+++ b/src/zencore/memtrack/memorytrace.cpp
@@ -294,7 +294,7 @@ static FUndestructed<FTraceMalloc> GTraceMalloc;
 
 ////////////////////////////////////////////////////////////////////////////////
 static EMemoryTraceInit
-MemoryTrace_ShouldEnable()
+MemoryTrace_ShouldEnable(const TraceOptions& Options)
 {
 	EMemoryTraceInit Mode = EMemoryTraceInit::Disabled;
 
@@ -328,19 +328,7 @@ MemoryTrace_ShouldEnable()
 		}
 	};
 
-	constexpr std::string_view TraceOption = "--trace="sv;
-
-	std::function<void(const std::string_view&)> ProcessArg = [&](const std::string_view& Arg) {
-		if (Arg.starts_with(TraceOption))
-		{
-			const std::string_view OptionArgs = Arg.substr(TraceOption.size());
-
-			IterateCommaSeparatedValue(OptionArgs, ProcessTraceArg);
-		}
-	};
-
-	IterateCommandlineArgs(ProcessArg);
-
+	IterateCommaSeparatedValue(Options.Channels, ProcessTraceArg);
 	return Mode;
 }
 
@@ -388,17 +376,17 @@ MemoryTrace_CreateInternal(FMalloc* InMalloc, EMemoryTraceInit Mode)
 
 ////////////////////////////////////////////////////////////////////////////////
 FMalloc*
-MemoryTrace_CreateInternal(FMalloc* InMalloc)
+MemoryTrace_CreateInternal(FMalloc* InMalloc, const TraceOptions& Options)
 {
-	const EMemoryTraceInit Mode = MemoryTrace_ShouldEnable();
+	const EMemoryTraceInit Mode = MemoryTrace_ShouldEnable(Options);
 	return MemoryTrace_CreateInternal(InMalloc, Mode);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 FMalloc*
-MemoryTrace_Create(FMalloc* InMalloc)
+MemoryTrace_Create(FMalloc* InMalloc, const TraceOptions& Options)
 {
-	FMalloc* OutMalloc = MemoryTrace_CreateInternal(InMalloc);
+	FMalloc* OutMalloc = MemoryTrace_CreateInternal(InMalloc, Options);
 
 	if (OutMalloc != InMalloc)
 	{
diff --git a/src/zencore/trace.cpp b/src/zencore/trace.cpp
index ef7cbf596..fe8fb9a5d 100644
--- a/src/zencore/trace.cpp
+++ b/src/zencore/trace.cpp
@@ -11,19 +11,18 @@
 #	define TRACE_IMPLEMENT 1
 #	include <zencore/trace.h>
 
+#	include <zencore/memory/fmalloc.h>
 #	include <zencore/memory/memorytrace.h>
 
 namespace zen {
 
 void
-TraceConfigure()
+TraceConfigure(const TraceOptions& Options)
 {
 	// Configure channels based on command line options
 
 	using namespace std::literals;
 
-	constexpr std::string_view TraceOption = "--trace="sv;
-
 	std::function<void(const std::string_view&)> ProcessChannelList;
 
 	auto ProcessTraceArg = [&](const std::string_view& Arg) {
@@ -63,25 +62,32 @@ TraceConfigure()
 
 	ProcessChannelList = [&](const std::string_view& OptionArgs) { IterateCommaSeparatedValue(OptionArgs, ProcessTraceArg); };
 
-	bool TraceOptionPresent = false;
-
-	std::function<void(const std::string_view&)> ProcessArg = [&](const std::string_view& Arg) {
-		if (Arg.starts_with(TraceOption))
-		{
-			const std::string_view OptionArgs = Arg.substr(TraceOption.size());
-
-			TraceOptionPresent = true;
-
-			ProcessChannelList(OptionArgs);
-		}
-	};
+	if (Options.Channels.empty())
+	{
+		ProcessTraceArg("default"sv);
+	}
+	else
+	{
+		ProcessChannelList(Options.Channels);
+	}
 
-	IterateCommandlineArgs(ProcessArg);
+	if (Options.Host.size())
+	{
+		trace::SendTo(Options.Host.c_str());
+	}
+	else if (Options.File.size())
+	{
+		trace::WriteTo(Options.File.c_str());
+	}
 
-	if (!TraceOptionPresent)
+#	if ZEN_WITH_MEMTRACK
+	FMalloc* TraceMalloc = MemoryTrace_Create(GMalloc, Options);
+	if (TraceMalloc != GMalloc)
 	{
-		ProcessTraceArg("default"sv);
+		GMalloc = TraceMalloc;
+		MemoryTrace_Initialize();
 	}
+#	endif
 }
 
 void
@@ -122,8 +128,6 @@ TraceInit(std::string_view ProgramName)
 		trace::Update();
 		TraceShutdown();
 	});
-
-	TraceConfigure();
 }
 
 void
@@ -139,25 +143,6 @@ IsTracing()
 	return trace::IsTracing();
 }
 
-void
-TraceStart(std::string_view ProgramName, const char* HostOrPath, TraceType Type)
-{
-	TraceInit(ProgramName);
-	switch (Type)
-	{
-		case TraceType::Network:
-			trace::SendTo(HostOrPath);
-			break;
-
-		case TraceType::File:
-			trace::WriteTo(HostOrPath);
-			break;
-
-		case TraceType::None:
-			break;
-	}
-}
-
 bool
 TraceStop()
 {
@@ -168,6 +153,57 @@ TraceStop()
 	return false;
 }
 
+bool
+GetTraceOptionsFromCommandline(TraceOptions& OutOptions)
+{
+	bool HasOptions = false;
+
+#	if ZEN_WITH_TRACE
+	using namespace std::literals;
+
+	auto MatchesArg = [](std::string_view Option, std::string_view Arg) -> std::optional<std::string_view> {
+		if (Arg.starts_with(Option))
+		{
+			std::string_view::value_type DelimChar = Arg[Option.length()];
+			if (DelimChar == ' ' || DelimChar == '=')
+			{
+				return Arg.substr(Option.size() + 1);
+			}
+		}
+		return {};
+	};
+
+	constexpr std::string_view TraceOption	   = "--trace"sv;
+	constexpr std::string_view TraceHostOption = "--tracehost"sv;
+	constexpr std::string_view TraceFileOption = "--tracefile"sv;
+
+	std::function<void(const std::string_view&)> ProcessArg = [&](const std::string_view& Arg) {
+		if (auto Host = MatchesArg(TraceHostOption, Arg); Host.has_value())
+		{
+			OutOptions.Host = Host.value();
+			HasOptions		= true;
+		}
+		else if (auto File = MatchesArg(TraceFileOption, Arg); File.has_value())
+		{
+			OutOptions.File = File.value();
+			HasOptions		= true;
+		}
+		else if (auto Channels = MatchesArg(TraceOption, Arg); Channels.has_value())
+		{
+			if (!OutOptions.Channels.empty())
+			{
+				OutOptions.Channels = ","sv;
+			}
+			OutOptions.Channels += Channels.value();
+			HasOptions = true;
+		}
+	};
+
+	IterateCommandlineArgs(ProcessArg);
+#	endif	// ZEN_WITH_TRACE
+	return HasOptions;
+}
+
 }  // namespace zen
 
 #endif	// ZEN_WITH_TRACE