Improve CLI/logging behavior: show usage on no args, add configurable log levels, and silence tests by default

Author: JusticeRage

include/cli.h

@@ -13,10 +13,13 @@ struct Options
     bool version = false;
     bool recursive = false;
     bool hashes = false;
+    bool quiet = false;
     bool output_set = false;
     bool extract_set = false;
+    bool log_level_set = false;
     std::string output;
     std::string extract;
+    std::string log_level;
     std::vector<std::string> dump;
     std::vector<std::string> plugins;
     std::vector<std::string> pe;

include/manacommons/color.h

@@ -40,6 +40,7 @@ namespace utils
 {
 
 enum Color { RED, GREEN, YELLOW, RESET };
+enum class LogLevel { OFF = 0, ERROR = 1, WARNING = 2, INFO = 3, DEBUG = 4 };
 
 /**
  *	@brief	Set the font in the terminal to the specified color.
@@ -67,8 +68,48 @@ DECLSPEC_MANACOMMONS std::ostream& print_colored_text(const std::string& text,
 													  const std::string& prefix = "",
 													  const std::string& suffix = "");
 
-#define PRINT_ERROR utils::print_colored_text("!", utils::RED, std::cerr, "[", "] Error: ")
-#define PRINT_WARNING utils::print_colored_text("*", utils::YELLOW, std::cerr, "[", "] Warning: ")
+/**
+ *	@brief	Set the global logging level.
+ */
+DECLSPEC_MANACOMMONS void set_log_level(LogLevel level);
+
+/**
+ *	@brief	Retrieve the global logging level.
+ */
+DECLSPEC_MANACOMMONS LogLevel get_log_level();
+
+/**
+ *	@brief	Returns whether a message with the given level should be emitted.
+ */
+DECLSPEC_MANACOMMONS bool should_log(LogLevel level);
+
+/**
+ *	@brief	Parse a logging level from text.
+ *
+ *	Accepted values are: off, error, warning, info, debug.
+ */
+DECLSPEC_MANACOMMONS bool parse_log_level(const std::string& value, LogLevel& level);
+
+/**
+ *	@brief	Set log level from text.
+ *
+ *	@return	Whether parsing succeeded.
+ */
+DECLSPEC_MANACOMMONS bool set_log_level_from_string(const std::string& value);
+
+/**
+ *	@brief	Convert log level to text.
+ */
+DECLSPEC_MANACOMMONS const char* log_level_to_string(LogLevel level);
+
+/**
+ *	@brief	Streams used by logging macros.
+ */
+DECLSPEC_MANACOMMONS std::ostream& error_stream();
+DECLSPEC_MANACOMMONS std::ostream& warning_stream();
+
+#define PRINT_ERROR utils::error_stream()
+#define PRINT_WARNING utils::warning_stream()
 
 
 #define LOG_CAP 100

manacommons/color.cpp

@@ -17,9 +17,44 @@
 
 #include "manacommons/color.h"
 
+#include <algorithm>
+#include <atomic>
+#include <cctype>
+
 namespace utils
 {
 
+namespace {
+
+class NullBuffer : public std::streambuf
+{
+public:
+	int overflow(int c) override { return c; }
+};
+
+std::ostream& null_stream()
+{
+	static NullBuffer buffer;
+	static std::ostream sink(&buffer);
+	return sink;
+}
+
+std::atomic<LogLevel>& global_log_level()
+{
+	static std::atomic<LogLevel> level(LogLevel::WARNING);
+	return level;
+}
+
+std::string lowercase(std::string value)
+{
+	std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) {
+		return static_cast<char>(std::tolower(c));
+	});
+	return value;
+}
+
+} // namespace
+
 #ifdef _WIN32
 
 void set_color(Color c)
@@ -108,8 +143,98 @@ std::ostream& print_colored_text(const std::string& text,
 	return sink << suffix;
 }
 
+void set_log_level(LogLevel level)
+{
+	global_log_level().store(level, std::memory_order_relaxed);
+}
+
+LogLevel get_log_level()
+{
+	return global_log_level().load(std::memory_order_relaxed);
+}
+
+bool should_log(LogLevel level)
+{
+	return static_cast<int>(get_log_level()) >= static_cast<int>(level);
+}
+
+bool parse_log_level(const std::string& value, LogLevel& level)
+{
+	const std::string normalized = lowercase(value);
+	if (normalized == "off") {
+		level = LogLevel::OFF;
+		return true;
+	}
+	if (normalized == "error") {
+		level = LogLevel::ERROR;
+		return true;
+	}
+	if (normalized == "warning") {
+		level = LogLevel::WARNING;
+		return true;
+	}
+	if (normalized == "info") {
+		level = LogLevel::INFO;
+		return true;
+	}
+	if (normalized == "debug") {
+		level = LogLevel::DEBUG;
+		return true;
+	}
+	return false;
+}
+
+bool set_log_level_from_string(const std::string& value)
+{
+	LogLevel level;
+	if (!parse_log_level(value, level)) {
+		return false;
+	}
+	set_log_level(level);
+	return true;
+}
+
+const char* log_level_to_string(LogLevel level)
+{
+	switch (level)
+	{
+	case LogLevel::OFF:
+		return "off";
+	case LogLevel::ERROR:
+		return "error";
+	case LogLevel::WARNING:
+		return "warning";
+	case LogLevel::INFO:
+		return "info";
+	case LogLevel::DEBUG:
+		return "debug";
+	default:
+		return "warning";
+	}
+}
+
+std::ostream& error_stream()
+{
+	if (!should_log(LogLevel::ERROR)) {
+		return null_stream();
+	}
+	return print_colored_text("!", RED, std::cerr, "[", "] Error: ");
+}
+
+std::ostream& warning_stream()
+{
+	if (!should_log(LogLevel::WARNING)) {
+		return null_stream();
+	}
+	return print_colored_text("*", YELLOW, std::cerr, "[", "] Warning: ");
+}
+
 bool is_log_cap_reached()
 {
+	if (!should_log(LogLevel::WARNING)) {
+		return true;
+	}
+
 	static unsigned int log_count = 0;
 	if (++log_count < LOG_CAP) {
 		return false;

src/cli.cpp

@@ -43,7 +43,7 @@ std::vector<std::string> reorder_args_for_cli11(int argc, char** argv)
     positionals.reserve(static_cast<size_t>(argc));
 
     auto is_long_with_value = [](const std::string& name) {
-        return name == "--output" || name == "--dump" || name == "--extract" || name == "--plugins";
+        return name == "--output" || name == "--dump" || name == "--extract" || name == "--plugins" || name == "--log-level";
     };
 
     bool end_of_options = false;
@@ -131,6 +131,7 @@ bool parse_args(Options& opts, int argc, char**argv, const HelpPrinter& help_pri
         ->required()
         ->type_name("FILE");
     app.add_flag("-r,--recursive", opts.recursive, "Scan all files in a directory (subdirectories will be ignored).");
+    app.add_flag("-q,--quiet", opts.quiet, "Only display errors.");
     auto* output_opt = app.add_option("-o,--output", opts.output, "The output format. May be 'raw' (default) or 'json'.");
     auto* dump_opt = app.add_option("-d,--dump", opts.dump,
         "Dump PE information. Available choices are any combination of: "
@@ -146,6 +147,18 @@ bool parse_args(Options& opts, int argc, char**argv, const HelpPrinter& help_pri
         "Analyze the binary with additional plugins. (may slow down the analysis!)");
     plugins_opt->expected(1);
     plugins_opt->multi_option_policy(CLI::MultiOptionPolicy::TakeAll);
+    auto* log_level_opt = app.add_option("--log-level", opts.log_level,
+        "Set log verbosity. Accepted values: off, error, warning, info, debug.");
+
+    if (argc <= 1)
+    {
+        if (help_printer) {
+            help_printer(app, argv[0]);
+        } else {
+            print_help_default(app, argv[0]);
+        }
+        return false;
+    }
 
     try
     {
@@ -175,9 +188,23 @@ bool parse_args(Options& opts, int argc, char**argv, const HelpPrinter& help_pri
 
     opts.output_set = output_opt->count() > 0;
     opts.extract_set = extract_opt->count() > 0;
+    opts.log_level_set = log_level_opt->count() > 0;
     opts.dump = split_comma_values(opts.dump);
     opts.plugins = split_comma_values(opts.plugins);
 
+    if (opts.quiet && !opts.log_level_set) {
+        opts.log_level = "error";
+        opts.log_level_set = true;
+    }
+    if (opts.log_level_set) {
+        utils::LogLevel level = utils::LogLevel::WARNING;
+        if (!utils::parse_log_level(opts.log_level, level)) {
+            PRINT_ERROR << "Invalid log level \"" << opts.log_level
+                        << "\". Expected one of: off, error, warning, info, debug." << std::endl;
+            return false;
+        }
+    }
+
     if (opts.version)
     {
         std::stringstream ss;

src/main.cpp

@@ -23,6 +23,7 @@
 #include <set>
 #include <sstream>
 #include <utility>
+#include <optional>
 
 #include <filesystem>
 
@@ -54,6 +55,44 @@
 
 namespace bfs = std::filesystem;
 
+namespace {
+
+void apply_early_log_level_from_argv(int argc, char** argv)
+{
+	std::optional<utils::LogLevel> selected;
+	for (int i = 1; i < argc; ++i)
+	{
+		const std::string arg = argv[i];
+		if (arg == "-q" || arg == "--quiet")
+		{
+			selected = utils::LogLevel::ERROR;
+			continue;
+		}
+
+		std::string value;
+		if (arg.rfind("--log-level=", 0) == 0) {
+			value = arg.substr(std::string("--log-level=").size());
+		}
+		else if (arg == "--log-level" && i + 1 < argc) {
+			value = argv[++i];
+		}
+
+		if (!value.empty())
+		{
+			utils::LogLevel level = utils::LogLevel::WARNING;
+			if (utils::parse_log_level(value, level)) {
+				selected = level;
+			}
+		}
+	}
+
+	if (selected) {
+		utils::set_log_level(*selected);
+	}
+}
+
+} // namespace
+
 /**
  *	@brief	Prints the help message of the program.
  *
@@ -476,19 +515,23 @@ int main(int argc, char** argv)
 	std::vector<std::string> selected_plugins, selected_categories;
 
 	mana::paths::initialize(argv[0]);
+	apply_early_log_level_from_argv(argc, argv);
 	const bfs::path config_dir(mana::paths::config_dir());
 	const bfs::path plugin_dir(mana::paths::plugin_dir());
 
 	// Initialize Yara and load plugins.
 	yara::Yara::initialize();
 	plugin::PluginManager::get_instance().load_all(plugin_dir.string());
 
-	// Load the configuration
-	config conf = parse_config((config_dir / "manalyze.conf").string());
-
 	if (!parse_args(opts, argc, argv, print_help, validate_args)) {
 		return -1;
 	}
+	if (opts.log_level_set) {
+		utils::set_log_level_from_string(opts.log_level);
+	}
+
+	// Load the configuration
+	config conf = parse_config((config_dir / "manalyze.conf").string());
 
 	// Get all the paths now and make them absolute before changing the working directory
 	std::set<std::string> targets = get_input_files(opts);