sentry config (#430)

- Feature: Added `--sentry-environment` to `zen` and `zenserver`
- Feature: Added `--sentry-debug` to `zen` and `zenserver`
- Feature: Added environment variable parsing for the following options:
  - `UE_ZEN_SENTRY_ENABLED`: `--no-sentry` (inverted)
  - `UE_ZEN_SENTRY_DEBUG`: `--sentry-debug`
  - `UE_ZEN_SENTRY_ALLOWPERSONALINFO`: `--sentry-allow-personal-info`
  - `UE_ZEN_SENTRY_DSN`: `--sentry-dsn`
  - `UE_ZEN_SENTRY_ENVIRONMENT`: `--sentry-environment`

10 files changed, 319 insertions, 56 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a0ade5cc6..5fb47e756 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,12 @@
 ##
+- Feature: Added `--sentry-environment` to `zen` and `zenserver`
+- Feature: Added `--sentry-debug` to `zen` and `zenserver`
+- Feature: Added environment variable parsing for the following options:
+  - `UE_ZEN_SENTRY_ENABLED`: `--no-sentry` (inverted)
+  - `UE_ZEN_SENTRY_DEBUG`: `--sentry-debug`
+  - `UE_ZEN_SENTRY_ALLOWPERSONALINFO`: `--sentry-allow-personal-info`
+  - `UE_ZEN_SENTRY_DSN`: `--sentry-dsn`
+  - `UE_ZEN_SENTRY_ENVIRONMENT`: `--sentry-environment`
 - Bugfix: Don't require `--namespace` option when using `zen list-namespaces` command
 - Bugfix: Crash in upload of blobs to Cloud DDC due to buffer range error
 
diff --git a/src/zen/zen.cpp b/src/zen/zen.cpp
index e84e258b8..76a866204 100644
--- a/src/zen/zen.cpp
+++ b/src/zen/zen.cpp
@@ -37,6 +37,7 @@
 #include <zencore/trace.h>
 #include <zencore/windows.h>
 #include <zenhttp/httpcommon.h>
+#include <zenutil/environmentoptions.h>
 #include <zenutil/logging.h>
 #include <zenutil/zenserverprocess.h>
 
@@ -872,18 +873,22 @@ main(int argc, char** argv)
 #endif	// ZEN_WITH_TRACE
 
 #if ZEN_USE_SENTRY
-	bool		NoSentry	   = false;
-	bool		SentryAllowPII = false;
-	std::string SentryDsn;
+
+	SentryIntegration::Config SentryConfig;
+
+	bool NoSentry = false;
+
 	Options
 		.add_option("sentry", "", "no-sentry", "Disable Sentry crash handler", cxxopts::value<bool>(NoSentry)->default_value("false"), "");
 	Options.add_option("sentry",
 					   "",
 					   "sentry-allow-personal-info",
 					   "Allow personally identifiable information in sentry crash reports",
-					   cxxopts::value<bool>(SentryAllowPII)->default_value("false"),
+					   cxxopts::value<bool>(SentryConfig.AllowPII)->default_value("false"),
 					   "");
-	Options.add_option("sentry", "", "sentry-dsn", "Sentry DSN to send events to", cxxopts::value<std::string>(SentryDsn), "");
+	Options.add_option("sentry", "", "sentry-dsn", "Sentry DSN to send events to", cxxopts::value<std::string>(SentryConfig.Dsn), "");
+	Options.add_option("sentry", "", "sentry-environment", "Sentry environment", cxxopts::value<std::string>(SentryConfig.Environment), "");
+	Options.add_options()("sentry-debug", "Enable debug mode for Sentry", cxxopts::value<bool>(SentryConfig.Debug)->default_value("false"));
 #endif
 
 	Options.parse_positional({"command"});
@@ -928,6 +933,27 @@ main(int argc, char** argv)
 		}
 
 #if ZEN_USE_SENTRY
+
+		{
+			EnvironmentOptions EnvOptions;
+
+			EnvOptions.AddOption("UE_ZEN_SENTRY_DSN"sv, SentryConfig.Dsn, "sentry-dsn"sv);
+			EnvOptions.AddOption("UE_ZEN_SENTRY_ALLOWPERSONALINFO"sv, SentryConfig.AllowPII, "sentry-allow-personal-info"sv);
+			EnvOptions.AddOption("UE_ZEN_SENTRY_ENVIRONMENT"sv, SentryConfig.Environment, "sentry-environment"sv);
+
+			bool EnvEnableSentry = !NoSentry;
+			EnvOptions.AddOption("UE_ZEN_SENTRY_ENABLED"sv, EnvEnableSentry, "no-sentry"sv);
+
+			EnvOptions.AddOption("UE_ZEN_SENTRY_DEBUG"sv, SentryConfig.Debug, "sentry-debug"sv);
+
+			EnvOptions.Parse(ParseResult);
+
+			if (EnvEnableSentry != !NoSentry)
+			{
+				NoSentry = !EnvEnableSentry;
+			}
+		}
+
 		SentryIntegration Sentry;
 
 		if (NoSentry == false)
@@ -945,7 +971,9 @@ main(int argc, char** argv)
 				SB.Append(argv[i]);
 			}
 
-			Sentry.Initialize(SentryDatabasePath, {}, SentryDsn, SentryAllowPII, SB.ToString());
+			SentryConfig.DatabasePath = SentryDatabasePath;
+
+			Sentry.Initialize(SentryConfig, SB.ToString());
 
 			SentryIntegration::ClearCaches();
 		}
diff --git a/src/zencore/include/zencore/sentryintegration.h b/src/zencore/include/zencore/sentryintegration.h
index d14c1c275..faf1238b7 100644
--- a/src/zencore/include/zencore/sentryintegration.h
+++ b/src/zencore/include/zencore/sentryintegration.h
@@ -31,11 +31,17 @@ public:
 	SentryIntegration();
 	~SentryIntegration();
 
-	void		Initialize(std::string		  SentryDatabasePath,
-						   std::string		  SentryAttachmentsPath,
-						   std::string		  SentryDsn,
-						   bool				  AllowPII,
-						   const std::string& CommandLine);
+	struct Config
+	{
+		std::string DatabasePath;
+		std::string AttachmentsPath;
+		std::string Dsn;
+		std::string Environment;
+		bool		AllowPII = false;
+		bool		Debug	 = false;
+	};
+
+	void		Initialize(const Config& Conf, const std::string& CommandLine);
 	void		LogStartupInformation();
 	static void ClearCaches();
 
diff --git a/src/zencore/sentryintegration.cpp b/src/zencore/sentryintegration.cpp
index 520d5162e..118c4158a 100644
--- a/src/zencore/sentryintegration.cpp
+++ b/src/zencore/sentryintegration.cpp
@@ -196,22 +196,23 @@ SentryIntegration::~SentryIntegration()
 }
 
 void
-SentryIntegration::Initialize(std::string		 SentryDatabasePath,
-							  std::string		 SentryAttachmentsPath,
-							  std::string		 SentryDsn,
-							  bool				 AllowPII,
-							  const std::string& CommandLine)
+SentryIntegration::Initialize(const Config& Conf, const std::string& CommandLine)
 {
-	m_AllowPII = AllowPII;
+	m_AllowPII = Conf.AllowPII;
 
+	std::string SentryDatabasePath = Conf.DatabasePath;
 	if (SentryDatabasePath.starts_with("\\\\?\\"))
 	{
 		SentryDatabasePath = SentryDatabasePath.substr(4);
 	}
 	sentry_options_t* SentryOptions = sentry_options_new();
-	sentry_options_set_dsn(SentryOptions, SentryDsn.empty() ? sentry::DefaultDsn.c_str() : SentryDsn.c_str());
+
+	sentry_options_set_dsn(SentryOptions, Conf.Dsn.empty() ? sentry::DefaultDsn.c_str() : Conf.Dsn.c_str());
 	sentry_options_set_database_path(SentryOptions, SentryDatabasePath.c_str());
 	sentry_options_set_logger(SentryOptions, SentryLogFunction, this);
+	sentry_options_set_environment(SentryOptions, Conf.Environment.empty() ? "production" : Conf.Environment.c_str());
+
+	std::string SentryAttachmentsPath = Conf.AttachmentsPath;
 	if (!SentryAttachmentsPath.empty())
 	{
 		if (SentryAttachmentsPath.starts_with("\\\\?\\"))
@@ -222,7 +223,10 @@ SentryIntegration::Initialize(std::string		 SentryDatabasePath,
 	}
 	sentry_options_set_release(SentryOptions, ZEN_CFG_VERSION);
 
-	// sentry_options_set_debug(SentryOptions, 1);
+	if (Conf.Debug)
+	{
+		sentry_options_set_debug(SentryOptions, 1);
+	}
 
 	m_SentryErrorCode = sentry_init(SentryOptions);
 
diff --git a/src/zenserver/config.cpp b/src/zenserver/config.cpp
index 055376b5c..1f9ae5fb6 100644
--- a/src/zenserver/config.cpp
+++ b/src/zenserver/config.cpp
@@ -16,6 +16,7 @@
 #include <zencore/string.h>
 #include <zenhttp/zenhttp.h>
 #include <zenutil/commandlineoptions.h>
+#include <zenutil/environmentoptions.h>
 
 ZEN_THIRD_PARTY_INCLUDES_START
 #include <fmt/format.h>
@@ -429,6 +430,29 @@ MakeOption(std::vector<std::pair<std::string, ZenStructuredCacheBucketConfig>>&
 };
 
 void
+ParseEnvVariables(ZenServerOptions& ServerOptions, const cxxopts::ParseResult& CmdLineResult)
+{
+	using namespace std::literals;
+
+	EnvironmentOptions Options;
+	Options.AddOption("UE_ZEN_SENTRY_ALLOWPERSONALINFO"sv, ServerOptions.SentryConfig.AllowPII, "sentry-allow-personal-info"sv);
+	Options.AddOption("UE_ZEN_SENTRY_DSN"sv, ServerOptions.SentryConfig.Dsn, "sentry-dsn"sv);
+	Options.AddOption("UE_ZEN_SENTRY_ENVIRONMENT"sv, ServerOptions.SentryConfig.Environment, "sentry-environment"sv);
+
+	bool EnvEnableSentry = !ServerOptions.SentryConfig.Disable;
+	Options.AddOption("UE_ZEN_SENTRY_ENABLED"sv, EnvEnableSentry, "no-sentry"sv);
+
+	Options.AddOption("UE_ZEN_SENTRY_DEBUG"sv, ServerOptions.SentryConfig.Debug, "sentry-debug"sv);
+
+	Options.Parse(CmdLineResult);
+
+	if (EnvEnableSentry != !ServerOptions.SentryConfig.Disable)
+	{
+		ServerOptions.SentryConfig.Disable = !EnvEnableSentry;
+	}
+}
+
+void
 ParseConfigFile(const std::filesystem::path& Path,
 				ZenServerOptions&			 ServerOptions,
 				const cxxopts::ParseResult&	 CmdLineResult,
@@ -441,9 +465,11 @@ ParseConfigFile(const std::filesystem::path& Path,
 	////// server
 	LuaOptions.AddOption("server.dedicated"sv, ServerOptions.IsDedicated, "dedicated"sv);
 	LuaOptions.AddOption("server.logid"sv, ServerOptions.LogId, "log-id"sv);
-	LuaOptions.AddOption("server.sentry.disable"sv, ServerOptions.NoSentry, "no-sentry"sv);
-	LuaOptions.AddOption("server.sentry.allowpersonalinfo"sv, ServerOptions.SentryAllowPII, "sentry-allow-personal-info"sv);
-	LuaOptions.AddOption("server.sentry.dsn"sv, ServerOptions.SentryDsn, "sentry-dsn"sv);
+	LuaOptions.AddOption("server.sentry.disable"sv, ServerOptions.SentryConfig.Disable, "no-sentry"sv);
+	LuaOptions.AddOption("server.sentry.allowpersonalinfo"sv, ServerOptions.SentryConfig.AllowPII, "sentry-allow-personal-info"sv);
+	LuaOptions.AddOption("server.sentry.dsn"sv, ServerOptions.SentryConfig.Dsn, "sentry-dsn"sv);
+	LuaOptions.AddOption("server.sentry.environment"sv, ServerOptions.SentryConfig.Environment, "sentry-environment"sv);
+	LuaOptions.AddOption("server.sentry.debug"sv, ServerOptions.SentryConfig.Debug, "sentry-debug"sv);
 	LuaOptions.AddOption("server.systemrootdir"sv, ServerOptions.SystemRootDir, "system-dir"sv);
 	LuaOptions.AddOption("server.datadir"sv, ServerOptions.DataDir, "data-dir"sv);
 	LuaOptions.AddOption("server.contentdir"sv, ServerOptions.ContentDir, "content-dir"sv);
@@ -759,11 +785,15 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 	options.add_options()("write-config", "Path to output Lua config file", cxxopts::value<std::string>(OutputConfigFile));
 	options.add_options()("no-sentry",
 						  "Disable Sentry crash handler",
-						  cxxopts::value<bool>(ServerOptions.NoSentry)->default_value("false"));
+						  cxxopts::value<bool>(ServerOptions.SentryConfig.Disable)->default_value("false"));
 	options.add_options()("sentry-allow-personal-info",
 						  "Allow personally identifiable information in sentry crash reports",
-						  cxxopts::value<bool>(ServerOptions.SentryAllowPII)->default_value("false"));
-	options.add_options()("sentry-dsn", "Sentry DSN to send events to", cxxopts::value<std::string>(ServerOptions.SentryDsn));
+						  cxxopts::value<bool>(ServerOptions.SentryConfig.AllowPII)->default_value("false"));
+	options.add_options()("sentry-dsn", "Sentry DSN to send events to", cxxopts::value<std::string>(ServerOptions.SentryConfig.Dsn));
+	options.add_options()("sentry-environment", "Sentry environment", cxxopts::value<std::string>(ServerOptions.SentryConfig.Environment));
+	options.add_options()("sentry-debug",
+						  "Enable debug mode for Sentry",
+						  cxxopts::value<bool>(ServerOptions.SentryConfig.Debug)->default_value("false"));
 	options.add_options()("detach",
 						  "Indicate whether zenserver should detach from parent process group",
 						  cxxopts::value<bool>(ServerOptions.Detach)->default_value("true"));
@@ -1336,6 +1366,8 @@ ParseCliOptions(int argc, char* argv[], ZenServerOptions& ServerOptions)
 
 		ServerOptions.ObjectStoreConfig = ParseBucketConfigs(BucketConfigs);
 
+		ParseEnvVariables(ServerOptions, Result);
+
 		if (!ServerOptions.ConfigFile.empty())
 		{
 			ParseConfigFile(ServerOptions.ConfigFile, ServerOptions, Result, OutputConfigFile);
diff --git a/src/zenserver/config.h b/src/zenserver/config.h
index 1a1793b8d..9753e3ae2 100644
--- a/src/zenserver/config.h
+++ b/src/zenserver/config.h
@@ -157,6 +157,15 @@ struct ZenWorkspacesConfig
 	bool AllowConfigurationChanges = false;
 };
 
+struct ZenSentryConfig
+{
+	bool		Disable	 = false;
+	bool		AllowPII = false;  // Allow personally identifiable information in sentry crash reports
+	std::string Dsn;
+	std::string Environment;
+	bool		Debug = false;	// Enable debug mode for Sentry
+};
+
 struct ZenServerOptions
 {
 	ZenUpstreamCacheConfig	 UpstreamCacheConfig;
@@ -169,31 +178,29 @@ struct ZenServerOptions
 	ZenBuildStoreConfig		 BuildStoreConfig;
 	ZenStatsConfig			 StatsConfig;
 	ZenWorkspacesConfig		 WorksSpacesConfig;
-	std::filesystem::path	 SystemRootDir;				// System root directory (used for machine level config)
-	std::filesystem::path	 DataDir;					// Root directory for state (used for testing)
-	std::filesystem::path	 ContentDir;				// Root directory for serving frontend content (experimental)
-	std::filesystem::path	 AbsLogFile;				// Absolute path to main log file
-	std::filesystem::path	 ConfigFile;				// Path to Lua config file
-	std::filesystem::path	 PluginsConfigFile;			// Path to plugins config file
-	std::filesystem::path	 BaseSnapshotDir;			// Path to server state snapshot (will be copied into data dir on start)
-	std::string				 ChildId;					// Id assigned by parent process (used for lifetime management)
-	std::string				 LogId;						// Id for tagging log output
-	std::string				 EncryptionKey;				// 256 bit AES encryption key
-	std::string				 EncryptionIV;				// 128 bit AES initialization vector
-	int						 BasePort		  = 8558;	// Service listen port (used for both UDP and TCP)
-	int						 OwnerPid		  = 0;		// Parent process id (zero for standalone)
-	bool					 InstallService	  = false;	// Flag used to initiate service install (temporary)
-	bool					 UninstallService = false;	// Flag used to initiate service uninstall (temporary)
-	bool					 IsDebug		  = false;
-	bool					 IsCleanStart	  = false;	// Indicates whether all state should be wiped on startup or not
-	bool					 IsPowerCycle	  = false;	// When true, the process shuts down immediately after initialization
-	bool					 IsTest			  = false;
-	bool					 IsDedicated	  = false;	// Indicates a dedicated/shared instance, with larger resource requirements
-	bool					 ShouldCrash	  = false;	// Option for testing crash handling
-	bool					 IsFirstRun		  = false;
-	bool					 NoSentry		  = false;
-	bool					 SentryAllowPII	  = false;	// Allow personally identifiable information in sentry crash reports
-	std::string				 SentryDsn;
+	ZenSentryConfig			 SentryConfig;
+	std::filesystem::path	 SystemRootDir;				  // System root directory (used for machine level config)
+	std::filesystem::path	 DataDir;					  // Root directory for state (used for testing)
+	std::filesystem::path	 ContentDir;				  // Root directory for serving frontend content (experimental)
+	std::filesystem::path	 AbsLogFile;				  // Absolute path to main log file
+	std::filesystem::path	 ConfigFile;				  // Path to Lua config file
+	std::filesystem::path	 PluginsConfigFile;			  // Path to plugins config file
+	std::filesystem::path	 BaseSnapshotDir;			  // Path to server state snapshot (will be copied into data dir on start)
+	std::string				 ChildId;					  // Id assigned by parent process (used for lifetime management)
+	std::string				 LogId;						  // Id for tagging log output
+	std::string				 EncryptionKey;				  // 256 bit AES encryption key
+	std::string				 EncryptionIV;				  // 128 bit AES initialization vector
+	int						 BasePort			= 8558;	  // Service listen port (used for both UDP and TCP)
+	int						 OwnerPid			= 0;	  // Parent process id (zero for standalone)
+	bool					 InstallService		= false;  // Flag used to initiate service install (temporary)
+	bool					 UninstallService	= false;  // Flag used to initiate service uninstall (temporary)
+	bool					 IsDebug			= false;
+	bool					 IsCleanStart		= false;  // Indicates whether all state should be wiped on startup or not
+	bool					 IsPowerCycle		= false;  // When true, the process shuts down immediately after initialization
+	bool					 IsTest				= false;
+	bool					 IsDedicated		= false;  // Indicates a dedicated/shared instance, with larger resource requirements
+	bool					 ShouldCrash		= false;  // Option for testing crash handling
+	bool					 IsFirstRun			= false;
 	bool					 Detach				= true;	 // Whether zenserver should detach from existing process group (Mac/Linux)
 	bool					 ObjectStoreEnabled = false;
 	bool					 NoConsoleOutput	= false;  // Control default use of stdout for diagnostics
diff --git a/src/zenserver/main.cpp b/src/zenserver/main.cpp
index 868126533..b0d945814 100644
--- a/src/zenserver/main.cpp
+++ b/src/zenserver/main.cpp
@@ -96,15 +96,17 @@ ZenEntryPoint::Run()
 #if ZEN_USE_SENTRY
 	SentryIntegration Sentry;
 
-	if (m_ServerOptions.NoSentry == false)
+	if (m_ServerOptions.SentryConfig.Disable == false)
 	{
 		std::string SentryDatabasePath	 = (m_ServerOptions.DataDir / ".sentry-native").string();
 		std::string SentryAttachmentPath = m_ServerOptions.AbsLogFile.string();
 
-		Sentry.Initialize(SentryDatabasePath,
-						  SentryAttachmentPath,
-						  m_ServerOptions.SentryDsn,
-						  m_ServerOptions.SentryAllowPII,
+		Sentry.Initialize({.DatabasePath	= SentryDatabasePath,
+						   .AttachmentsPath = SentryAttachmentPath,
+						   .Dsn				= m_ServerOptions.SentryConfig.Dsn,
+						   .Environment		= m_ServerOptions.SentryConfig.Environment,
+						   .AllowPII		= m_ServerOptions.SentryConfig.AllowPII,
+						   .Debug			= m_ServerOptions.SentryConfig.Debug},
 						  m_ServerOptions.CommandLine);
 	}
 #endif
diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index 1ad94ed63..27ec4c690 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -137,7 +137,7 @@ ZenServer::Initialize(const ZenServerOptions& ServerOptions, ZenServerState::Zen
 		return -1;
 	}
 
-	m_UseSentry				 = ServerOptions.NoSentry == false;
+	m_UseSentry				 = ServerOptions.SentryConfig.Disable == false;
 	m_ServerEntry			 = ServerEntry;
 	m_DebugOptionForcedCrash = ServerOptions.ShouldCrash;
 	m_IsPowerCycle			 = ServerOptions.IsPowerCycle;
diff --git a/src/zenutil/environmentoptions.cpp b/src/zenutil/environmentoptions.cpp
new file mode 100644
index 000000000..1b7ce8029
--- /dev/null
+++ b/src/zenutil/environmentoptions.cpp
@@ -0,0 +1,84 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zenutil/environmentoptions.h>
+
+#include <zencore/filesystem.h>
+
+namespace zen {
+
+EnvironmentOptions::StringOption::StringOption(std::string& Value) : RefValue(Value)
+{
+}
+void
+EnvironmentOptions::StringOption::Parse(std::string_view Value)
+{
+	RefValue = std::string(Value);
+}
+
+EnvironmentOptions::FilePathOption::FilePathOption(std::filesystem::path& Value) : RefValue(Value)
+{
+}
+void
+EnvironmentOptions::FilePathOption::Parse(std::string_view Value)
+{
+	RefValue = MakeSafeAbsolutePath(Value);
+}
+
+EnvironmentOptions::BoolOption::BoolOption(bool& Value) : RefValue(Value)
+{
+}
+void
+EnvironmentOptions::BoolOption::Parse(std::string_view Value)
+{
+	const std::string Lower = ToLower(Value);
+	if (Lower == "true" || Lower == "y" || Lower == "yes")
+	{
+		RefValue = true;
+	}
+	else if (Lower == "false" || Lower == "n" || Lower == "no")
+	{
+		RefValue = false;
+	}
+}
+
+std::shared_ptr<EnvironmentOptions::OptionValue>
+EnvironmentOptions::MakeOption(std::string& Value)
+{
+	return std::make_shared<StringOption>(Value);
+}
+
+std::shared_ptr<EnvironmentOptions::OptionValue>
+EnvironmentOptions::MakeOption(std::filesystem::path& Value)
+{
+	return std::make_shared<FilePathOption>(Value);
+}
+
+std::shared_ptr<EnvironmentOptions::OptionValue>
+EnvironmentOptions::MakeOption(bool& Value)
+{
+	return std::make_shared<BoolOption>(Value);
+}
+
+EnvironmentOptions::EnvironmentOptions()
+{
+}
+
+void
+EnvironmentOptions::Parse(const cxxopts::ParseResult& CmdLineResult)
+{
+	for (auto& It : OptionMap)
+	{
+		std::string_view EnvName = It.first;
+		const Option&	 Opt	 = It.second;
+		if (CmdLineResult.count(Opt.CommandLineOptionName) == 0)
+		{
+			std::string EnvValue = GetEnvVariable(It.first);
+			if (!EnvValue.empty())
+			{
+				Opt.Value->Parse(EnvValue);
+			}
+		}
+	}
+}
+
+}  // namespace zen
diff --git a/src/zenutil/include/zenutil/environmentoptions.h b/src/zenutil/include/zenutil/environmentoptions.h
new file mode 100644
index 000000000..7418608e4
--- /dev/null
+++ b/src/zenutil/include/zenutil/environmentoptions.h
@@ -0,0 +1,92 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <zencore/string.h>
+#include <zenutil/commandlineoptions.h>
+
+namespace zen {
+
+class EnvironmentOptions
+{
+public:
+	class OptionValue
+	{
+	public:
+		virtual void Parse(std::string_view Value) = 0;
+
+		virtual ~OptionValue() {}
+	};
+
+	class StringOption : public OptionValue
+	{
+	public:
+		explicit StringOption(std::string& Value);
+		virtual void Parse(std::string_view Value) override;
+		std::string& RefValue;
+	};
+
+	class FilePathOption : public OptionValue
+	{
+	public:
+		explicit FilePathOption(std::filesystem::path& Value);
+		virtual void		   Parse(std::string_view Value) override;
+		std::filesystem::path& RefValue;
+	};
+
+	class BoolOption : public OptionValue
+	{
+	public:
+		explicit BoolOption(bool& Value);
+		virtual void Parse(std::string_view Value);
+		bool&		 RefValue;
+	};
+
+	template<Integral T>
+	class NumberOption : public OptionValue
+	{
+	public:
+		explicit NumberOption(T& Value) : RefValue(Value) {}
+		virtual void Parse(std::string_view Value) override
+		{
+			if (std::optional<T> OptionalValue = ParseInt<T>(Value); OptionalValue.has_value())
+			{
+				RefValue = OptionalValue.value();
+			}
+		}
+		T& RefValue;
+	};
+
+	struct Option
+	{
+		std::string					 CommandLineOptionName;
+		std::shared_ptr<OptionValue> Value;
+	};
+
+	std::shared_ptr<OptionValue> MakeOption(std::string& Value);
+	std::shared_ptr<OptionValue> MakeOption(std::filesystem::path& Value);
+
+	template<Integral T>
+	std::shared_ptr<OptionValue> MakeOption(T& Value)
+	{
+		return std::make_shared<NumberOption<T>>(Value);
+	};
+
+	std::shared_ptr<OptionValue> MakeOption(bool& Value);
+
+	template<typename T>
+	void AddOption(std::string_view EnvName, T& Value, std::string_view CommandLineOptionName = "")
+	{
+		OptionMap.insert_or_assign(std::string(EnvName),
+								   Option{.CommandLineOptionName = std::string(CommandLineOptionName), .Value = MakeOption(Value)});
+	};
+
+	EnvironmentOptions();
+
+	void Parse(const cxxopts::ParseResult& CmdLineResult);
+
+private:
+	std::unordered_map<std::string, Option> OptionMap;
+};
+
+}  // namespace zen