chore(userspace,unit_tests): properly report all schema validation warnings from yaml_helper::validate_node().

FedeDP · FedeDP · commit 6630176bbe98 · 2024-09-10T11:36:56.000+02:00
`-V` option will print all warnings, while normal run will only print foremost warning.

Signed-off-by: Federico Di Pierro &lt;nierro92@gmail.com&gt;
diff --git a/unit_tests/falco/test_configuration_schema.cpp b/unit_tests/falco/test_configuration_schema.cpp
@@ -111,14 +111,14 @@ TEST(Configuration, schema_yaml_helper_validator)
 	EXPECT_NO_THROW(conf.load_from_string(sample_yaml));
 
 	// We pass a string variable but not a schema
-	std::string validation;
+	std::vector<std::string> validation;
 	EXPECT_NO_THROW(conf.load_from_string(sample_yaml, nlohmann::json{}, &validation));
-	EXPECT_EQ(validation, yaml_helper::validation_none);
+	EXPECT_EQ(validation[0], yaml_helper::validation_none);
 
 	// We pass a schema but not a string storage for the validation; no validation takes place
 	EXPECT_NO_THROW(conf.load_from_string(sample_yaml, falco_config.m_config_schema, nullptr));
 
 	// We pass everything
 	EXPECT_NO_THROW(conf.load_from_string(sample_yaml, falco_config.m_config_schema, &validation));
-	EXPECT_EQ(validation, yaml_helper::validation_ok);
+	EXPECT_EQ(validation[0], yaml_helper::validation_ok);
 }
diff --git a/userspace/engine/rule_loader.cpp b/userspace/engine/rule_loader.cpp
@@ -283,8 +283,7 @@ std::string rule_loader::context::snippet(const falco::load_result::rules_conten
 
 rule_loader::result::result(const std::string &name)
 	: name(name),
-	  success(true),
-	  schema_validation_str(yaml_helper::validation_none)
+	  success(true)
 {
 }
 
@@ -300,7 +299,11 @@ bool rule_loader::result::has_warnings()
 
 std::string rule_loader::result::schema_validation()
 {
-	return schema_validation_str;
+	if (schema_validation_status.empty())
+	{
+		return yaml_helper::validation_none;
+	}
+	return schema_validation_status[0];
 }
 
 void rule_loader::result::add_error(load_result::error_code ec, const std::string& msg, const context& ctx)
@@ -318,9 +321,9 @@ void rule_loader::result::add_warning(load_result::warning_code wc, const std::s
 	warnings.push_back(warn);
 }
 
-void rule_loader::result::set_schema_validation_status(const std::string& status)
+void rule_loader::result::set_schema_validation_status(const std::vector<std::string>& status)
 {
-	schema_validation_str = status;
+	schema_validation_status = status;
 }
 
 const std::string& rule_loader::result::as_string(bool verbose, const rules_contents_t& contents)
@@ -364,9 +367,28 @@ const std::string& rule_loader::result::as_summary_string()
 	}
 
 	// Only print schema validation info if any validation was requested
-	if (schema_validation_str != yaml_helper::validation_none)
+	if (!schema_validation_status.empty())
 	{
-		os << " | schema validation: " << schema_validation_str;
+		bool schema_valid = schema_validation() == yaml_helper::validation_ok;
+		// Only print info when there are validation warnings
+		if (!schema_valid)
+		{
+			os << std::endl;
+
+			os << schema_validation_status.size() << " schema warnings: [";
+			bool first = true;
+			for(auto& status : schema_validation_status)
+			{
+				if(!first)
+				{
+					os << " ";
+				}
+				first = false;
+
+				os << status;
+			}
+			os << "]";
+		}
 	}
 
 	if(!errors.empty())
@@ -442,9 +464,28 @@ const std::string& rule_loader::result::as_verbose_string(const rules_contents_t
 	}
 
 	// Only print schema validation info if any validation was requested
-	if (schema_validation_str != yaml_helper::validation_none)
+	if (!schema_validation_status.empty())
 	{
-		os << " | schema validation: " << schema_validation_str;
+		bool schema_valid = schema_validation() == yaml_helper::validation_ok;
+		// Only print info when there are validation warnings
+		if (!schema_valid)
+		{
+			os << std::endl;
+
+			os << schema_validation_status.size() << " schema warnings: [";
+			bool first = true;
+			for(auto& status : schema_validation_status)
+			{
+				if(!first)
+				{
+					os << " ";
+				}
+				first = false;
+
+				os << status;
+			}
+			os << "]";
+		}
 	}
 
 	if (!errors.empty())
@@ -507,14 +548,17 @@ const nlohmann::json& rule_loader::result::as_json(const rules_contents_t& conte
 	j["successful"] = success;
 
 	// Only print schema validation info if any validation was requested
-	if (schema_validation_str != yaml_helper::validation_none)
+	if (!schema_validation_status.empty())
 	{
-		bool schema_valid = schema_validation_str == yaml_helper::validation_ok;
+		bool schema_valid = schema_validation() == yaml_helper::validation_ok;
 		j["schema_valid"] = schema_valid;
 		j["schema_warnings"] = nlohmann::json::array();
 		if (!schema_valid)
 		{
-			j["schema_warnings"].push_back(schema_validation_str);
+			for (const auto &schema_warning : schema_validation_status)
+			{
+				j["schema_warnings"].push_back(schema_warning);
+			}
 		}
 	}
 
diff --git a/userspace/engine/rule_loader.h b/userspace/engine/rule_loader.h
@@ -248,15 +248,15 @@ namespace rule_loader
 				 const std::string& msg,
 				 const context& ctx);
 
-		void set_schema_validation_status(const std::string& status);
+		void set_schema_validation_status(const std::vector<std::string>& status);
 		std::string schema_validation();
 	protected:
 
 		const std::string& as_summary_string();
 		const std::string& as_verbose_string(const falco::load_result::rules_contents_t& contents);
 		std::string name;
 		bool success;
-		std::string schema_validation_str;
+		std::vector<std::string> schema_validation_status;
 
 		std::vector<error> errors;
 		std::vector<warning> warnings;
diff --git a/userspace/engine/rule_loader_reader.cpp b/userspace/engine/rule_loader_reader.cpp
@@ -788,11 +788,11 @@ bool rule_loader::reader::read(rule_loader::configuration& cfg, collector& colle
 {
 	std::vector<YAML::Node> docs;
 	yaml_helper reader;
-	std::string schema_validation;
+	std::vector<std::string> schema_warnings;
 	rule_loader::context ctx(cfg.name);
 	try
 	{
-		docs = reader.loadall_from_string(cfg.content, schema, &schema_validation);
+		docs = reader.loadall_from_string(cfg.content, schema, &schema_warnings);
 	}
 	catch (YAML::ParserException& e)
 	{
@@ -810,7 +810,7 @@ bool rule_loader::reader::read(rule_loader::configuration& cfg, collector& colle
 		cfg.res->add_error(falco::load_result::LOAD_ERR_YAML_PARSE, "unknown YAML parsing error", ctx);
 		return false;
 	}
-	cfg.res->set_schema_validation_status(schema_validation);
+	cfg.res->set_schema_validation_status(schema_warnings);
 	for (auto doc = docs.begin(); doc != docs.end(); doc++)
 	{
 		if (doc->IsDefined() && !doc->IsNull())
diff --git a/userspace/engine/yaml_helper.h b/userspace/engine/yaml_helper.h
@@ -90,27 +90,23 @@ class yaml_helper
 	* Load all the YAML document represented by the input string.
 	* Since this is used by rule loader, does not process env vars.
 	*/
-	std::vector<YAML::Node> loadall_from_string(const std::string& input, const nlohmann::json& schema={}, std::string *validation=nullptr)
+	std::vector<YAML::Node> loadall_from_string(const std::string& input, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)
 	{
 		auto nodes = YAML::LoadAll(input);
-		if (validation)
+		if (schema_warnings)
 		{
+			schema_warnings->clear();
 			if(!schema.empty())
 			{
 				// Validate each node.
-				for (const auto& node : nodes)
+				for(const auto& node : nodes)
 				{
-					*validation = validate_node(node, schema);
-					if (*validation != validation_ok)
-					{
-						// Return first error
-						break;
-					}
+					validate_node(node, schema, schema_warnings);
 				}
 			}
 			else
 			{
-				*validation = validation_none;
+				schema_warnings->push_back(validation_none);
 			}
 		}
 		return nodes;
@@ -119,35 +115,36 @@ class yaml_helper
 	/**
 	* Load the YAML document represented by the input string.
 	*/
-	void load_from_string(const std::string& input, const nlohmann::json& schema={}, std::string *validation=nullptr)
+	void load_from_string(const std::string& input, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)
 	{
 		m_root = YAML::Load(input);
 		pre_process_env_vars(m_root);
 
-		if (validation)
+		if (schema_warnings)
 		{
+			schema_warnings->clear();
 			if(!schema.empty())
 			{
-				*validation = validate_node(m_root, schema);
+				validate_node(m_root, schema, schema_warnings);
 			}
 			else
 			{
-				*validation = validation_none;
+				schema_warnings->push_back(validation_none);
 			}
 		}
 	}
 
 	/**
 	* Load the YAML document from the given file path.
 	*/
-	void load_from_file(const std::string& path, const nlohmann::json& schema={}, std::string *validation=nullptr)
+	void load_from_file(const std::string& path, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)
 	{
-		m_root = load_from_file_int(path, schema, validation);
+		m_root = load_from_file_int(path, schema, schema_warnings);
 	}
 
-	void include_config_file(const std::string& include_file_path, const nlohmann::json& schema={}, std::string *validation=nullptr)
+	void include_config_file(const std::string& include_file_path, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)
 	{
-		auto loaded_nodes = load_from_file_int(include_file_path, schema, validation);
+		auto loaded_nodes = load_from_file_int(include_file_path, schema, schema_warnings);
 		for(auto n : loaded_nodes)
 		{
 			/*
@@ -243,26 +240,27 @@ class yaml_helper
 private:
 	YAML::Node m_root;
 
-	YAML::Node load_from_file_int(const std::string& path, const nlohmann::json& schema={}, std::string *validation=nullptr)
+	YAML::Node load_from_file_int(const std::string& path, const nlohmann::json& schema, std::vector<std::string> *schema_warnings)
 	{
 		auto root = YAML::LoadFile(path);
 		pre_process_env_vars(root);
 
-		if (validation)
+		if (schema_warnings)
 		{
+			schema_warnings->clear();
 			if(!schema.empty())
 			{
-				*validation = validate_node(root, schema);
+				validate_node(root, schema, schema_warnings);
 			}
 			else
 			{
-				*validation = validation_none;
+				schema_warnings->push_back(validation_none);
 			}
 		}
 		return root;
 	}
 
-	std::string validate_node(const YAML::Node &node, const nlohmann::json& schema={})
+	void validate_node(const YAML::Node &node, const nlohmann::json& schema, std::vector<std::string> *schema_warnings)
 	{
 		// Validate the yaml against our json schema
 		valijson::Schema schemaDef;
@@ -277,16 +275,18 @@ class yaml_helper
 		{
 			valijson::ValidationResults::Error error;
 			// report only the top-most error
-			if (validationResults.popError(error))
+			while (validationResults.popError(error))
 			{
-				return std::string(validation_failed + " for ")
+				schema_warnings->push_back(std::string(validation_failed + " for ")
 				       + std::accumulate(error.context.begin(), error.context.end(), std::string(""))
 				       + ": "
-				       + error.description;
+				       + error.description);
 			}
-			return validation_failed;
 		}
-		return validation_ok;
+		else
+		{
+			schema_warnings->push_back(validation_ok);
+		}
 	}
 
 	/*
diff --git a/userspace/falco/configuration.cpp b/userspace/falco/configuration.cpp
@@ -93,12 +93,13 @@ falco_configuration::falco_configuration():
 config_loaded_res falco_configuration::init_from_content(const std::string& config_content, const std::vector<std::string>& cmdline_options, const std::string& filename)
 {
 	config_loaded_res res;
-	std::string validation_status;
+	std::vector<std::string> validation_status;
 
 	m_config.load_from_string(config_content, m_config_schema, &validation_status);
 	init_cmdline_options(cmdline_options);
 
-	res[filename] = validation_status;
+	// Only report top most schema validation status
+	res[filename] = validation_status[0];
 
 	load_yaml(filename);
 	return res;
@@ -107,7 +108,7 @@ config_loaded_res falco_configuration::init_from_content(const std::string& conf
 config_loaded_res falco_configuration::init_from_file(const std::string& conf_filename, const std::vector<std::string> &cmdline_options)
 {
 	config_loaded_res res;
-	std::string validation_status;
+	std::vector<std::string> validation_status;
 	try
 	{
 		m_config.load_from_file(conf_filename, m_config_schema, &validation_status);
@@ -119,7 +120,8 @@ config_loaded_res falco_configuration::init_from_file(const std::string& conf_fi
 	}
 	init_cmdline_options(cmdline_options);
 
-	res[conf_filename] = validation_status;
+	// Only report top most schema validation status
+	res[conf_filename] = validation_status[0];
 
 	merge_config_files(conf_filename, res);
 	load_yaml(conf_filename);
@@ -138,7 +140,7 @@ std::string falco_configuration::dump()
 // filenames and folders specified in config (minus the skipped ones).
 void falco_configuration::merge_config_files(const std::string& config_name, config_loaded_res &res)
 {
-	std::string validation_status;
+	std::vector<std::string> validation_status;
 	m_loaded_configs_filenames.push_back(config_name);
 	const auto ppath = std::filesystem::path(config_name);
 	// Parse files to be included
@@ -161,7 +163,8 @@ void falco_configuration::merge_config_files(const std::string& config_name, con
 		{
 			m_loaded_configs_filenames.push_back(include_file);
 			m_config.include_config_file(include_file_path.string(), m_config_schema, &validation_status);
-			res[include_file_path.string()] = validation_status;
+			// Only report top most schema validation status
+			res[include_file_path.string()] = validation_status[0];
 		}
 		else if (std::filesystem::is_directory(include_file_path))
 		{
@@ -180,7 +183,8 @@ void falco_configuration::merge_config_files(const std::string& config_name, con
 			for (const auto &f : v)
 			{
 				m_config.include_config_file(f, m_config_schema, &validation_status);
-				res[f] = validation_status;
+				// Only report top most schema validation status
+				res[f] = validation_status[0];
 			}
 		}
 	}

Original file line number	Diff line number	Diff line change
`@@ -788,11 +788,11 @@ bool rule_loader::reader::read(rule_loader::configuration& cfg, collector& colle`
`788`	`788`	`{`
`789`	`789`	`std::vector<YAML::Node> docs;`
`790`	`790`	`yaml_helper reader;`
`791`		`- std::string schema_validation;`
	`791`	`+ std::vector<std::string> schema_warnings;`
`792`	`792`	`rule_loader::context ctx(cfg.name);`
`793`	`793`	`try`
`794`	`794`	`{`
`795`		`- docs = reader.loadall_from_string(cfg.content, schema, &schema_validation);`
	`795`	`+ docs = reader.loadall_from_string(cfg.content, schema, &schema_warnings);`
`796`	`796`	`}`
`797`	`797`	`catch (YAML::ParserException& e)`
`798`	`798`	`{`
`@@ -810,7 +810,7 @@ bool rule_loader::reader::read(rule_loader::configuration& cfg, collector& colle`
`810`	`810`	`cfg.res->add_error(falco::load_result::LOAD_ERR_YAML_PARSE, "unknown YAML parsing error", ctx);`
`811`	`811`	`return false;`
`812`	`812`	`}`
`813`		`- cfg.res->set_schema_validation_status(schema_validation);`
	`813`	`+ cfg.res->set_schema_validation_status(schema_warnings);`
`814`	`814`	`for (auto doc = docs.begin(); doc != docs.end(); doc++)`
`815`	`815`	`{`
`816`	`816`	`if (doc->IsDefined() && !doc->IsNull())`
Original file line number	Diff line number	Diff line change
`@@ -90,27 +90,23 @@ class yaml_helper`
`90`	`90`	`* Load all the YAML document represented by the input string.`
`91`	`91`	`* Since this is used by rule loader, does not process env vars.`
`92`	`92`	`*/`
`93`		`- std::vector<YAML::Node> loadall_from_string(const std::string& input, const nlohmann::json& schema={}, std::string *validation=nullptr)`
	`93`	`+ std::vector<YAML::Node> loadall_from_string(const std::string& input, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)`
`94`	`94`	`{`
`95`	`95`	`auto nodes = YAML::LoadAll(input);`
`96`		`- if (validation)`
	`96`	`+ if (schema_warnings)`
`97`	`97`	`{`
	`98`	`+ schema_warnings->clear();`
`98`	`99`	`if(!schema.empty())`
`99`	`100`	`{`
`100`	`101`	`// Validate each node.`
`101`		`- for (const auto& node : nodes)`
	`102`	`+ for(const auto& node : nodes)`
`102`	`103`	`{`
`103`		`- *validation = validate_node(node, schema);`
`104`		`- if (*validation != validation_ok)`
`105`		`- {`
`106`		`- // Return first error`
`107`		`- break;`
`108`		`- }`
	`104`	`+ validate_node(node, schema, schema_warnings);`
`109`	`105`	`}`
`110`	`106`	`}`
`111`	`107`	`else`
`112`	`108`	`{`
`113`		`- *validation = validation_none;`
	`109`	`+ schema_warnings->push_back(validation_none);`
`114`	`110`	`}`
`115`	`111`	`}`
`116`	`112`	`return nodes;`
`@@ -119,35 +115,36 @@ class yaml_helper`
`119`	`115`	`/**`
`120`	`116`	`* Load the YAML document represented by the input string.`
`121`	`117`	`*/`
`122`		`- void load_from_string(const std::string& input, const nlohmann::json& schema={}, std::string *validation=nullptr)`
	`118`	`+ void load_from_string(const std::string& input, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)`
`123`	`119`	`{`
`124`	`120`	`m_root = YAML::Load(input);`
`125`	`121`	`pre_process_env_vars(m_root);`
`126`	`122`
`127`		`- if (validation)`
	`123`	`+ if (schema_warnings)`
`128`	`124`	`{`
	`125`	`+ schema_warnings->clear();`
`129`	`126`	`if(!schema.empty())`
`130`	`127`	`{`
`131`		`- *validation = validate_node(m_root, schema);`
	`128`	`+ validate_node(m_root, schema, schema_warnings);`
`132`	`129`	`}`
`133`	`130`	`else`
`134`	`131`	`{`
`135`		`- *validation = validation_none;`
	`132`	`+ schema_warnings->push_back(validation_none);`
`136`	`133`	`}`
`137`	`134`	`}`
`138`	`135`	`}`
`139`	`136`
`140`	`137`	`/**`
`141`	`138`	`* Load the YAML document from the given file path.`
`142`	`139`	`*/`
`143`		`- void load_from_file(const std::string& path, const nlohmann::json& schema={}, std::string *validation=nullptr)`
	`140`	`+ void load_from_file(const std::string& path, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)`
`144`	`141`	`{`
`145`		`- m_root = load_from_file_int(path, schema, validation);`
	`142`	`+ m_root = load_from_file_int(path, schema, schema_warnings);`
`146`	`143`	`}`
`147`	`144`
`148`		`- void include_config_file(const std::string& include_file_path, const nlohmann::json& schema={}, std::string *validation=nullptr)`
	`145`	`+ void include_config_file(const std::string& include_file_path, const nlohmann::json& schema={}, std::vector<std::string> *schema_warnings=nullptr)`
`149`	`146`	`{`
`150`		`- auto loaded_nodes = load_from_file_int(include_file_path, schema, validation);`
	`147`	`+ auto loaded_nodes = load_from_file_int(include_file_path, schema, schema_warnings);`
`151`	`148`	`for(auto n : loaded_nodes)`
`152`	`149`	`{`
`153`	`150`	`/*`
`@@ -243,26 +240,27 @@ class yaml_helper`
`243`	`240`	`private:`
`244`	`241`	`YAML::Node m_root;`
`245`	`242`
`246`		`- YAML::Node load_from_file_int(const std::string& path, const nlohmann::json& schema={}, std::string *validation=nullptr)`
	`243`	`+ YAML::Node load_from_file_int(const std::string& path, const nlohmann::json& schema, std::vector<std::string> *schema_warnings)`
`247`	`244`	`{`
`248`	`245`	`auto root = YAML::LoadFile(path);`
`249`	`246`	`pre_process_env_vars(root);`
`250`	`247`
`251`		`- if (validation)`
	`248`	`+ if (schema_warnings)`
`252`	`249`	`{`
	`250`	`+ schema_warnings->clear();`
`253`	`251`	`if(!schema.empty())`
`254`	`252`	`{`
`255`		`- *validation = validate_node(root, schema);`
	`253`	`+ validate_node(root, schema, schema_warnings);`
`256`	`254`	`}`
`257`	`255`	`else`
`258`	`256`	`{`
`259`		`- *validation = validation_none;`
	`257`	`+ schema_warnings->push_back(validation_none);`
`260`	`258`	`}`
`261`	`259`	`}`
`262`	`260`	`return root;`
`263`	`261`	`}`
`264`	`262`
`265`		`- std::string validate_node(const YAML::Node &node, const nlohmann::json& schema={})`
	`263`	`+ void validate_node(const YAML::Node &node, const nlohmann::json& schema, std::vector<std::string> *schema_warnings)`
`266`	`264`	`{`
`267`	`265`	`// Validate the yaml against our json schema`
`268`	`266`	`valijson::Schema schemaDef;`
`@@ -277,16 +275,18 @@ class yaml_helper`
`277`	`275`	`{`
`278`	`276`	`valijson::ValidationResults::Error error;`
`279`	`277`	`// report only the top-most error`
`280`		`- if (validationResults.popError(error))`
	`278`	`+ while (validationResults.popError(error))`
`281`	`279`	`{`
`282`		`- return std::string(validation_failed + " for ")`
	`280`	`+ schema_warnings->push_back(std::string(validation_failed + " for ")`
`283`	`281`	`+ std::accumulate(error.context.begin(), error.context.end(), std::string(""))`
`284`	`282`	`+ ": "`
`285`		`- + error.description;`
	`283`	`+ + error.description);`
`286`	`284`	`}`
`287`		`- return validation_failed;`
`288`	`285`	`}`
`289`		`- return validation_ok;`
	`286`	`+ else`
	`287`	`+ {`
	`288`	`+ schema_warnings->push_back(validation_ok);`
	`289`	`+ }`
`290`	`290`	`}`
`291`	`291`
`292`	`292`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -93,12 +93,13 @@ falco_configuration::falco_configuration():`
`93`	`93`	`config_loaded_res falco_configuration::init_from_content(const std::string& config_content, const std::vector<std::string>& cmdline_options, const std::string& filename)`
`94`	`94`	`{`
`95`	`95`	`config_loaded_res res;`
`96`		`- std::string validation_status;`
	`96`	`+ std::vector<std::string> validation_status;`
`97`	`97`
`98`	`98`	`m_config.load_from_string(config_content, m_config_schema, &validation_status);`
`99`	`99`	`init_cmdline_options(cmdline_options);`
`100`	`100`
`101`		`- res[filename] = validation_status;`
	`101`	`+ // Only report top most schema validation status`
	`102`	`+ res[filename] = validation_status[0];`
`102`	`103`
`103`	`104`	`load_yaml(filename);`
`104`	`105`	`return res;`
`@@ -107,7 +108,7 @@ config_loaded_res falco_configuration::init_from_content(const std::string& conf`
`107`	`108`	`config_loaded_res falco_configuration::init_from_file(const std::string& conf_filename, const std::vector<std::string> &cmdline_options)`
`108`	`109`	`{`
`109`	`110`	`config_loaded_res res;`
`110`		`- std::string validation_status;`
	`111`	`+ std::vector<std::string> validation_status;`
`111`	`112`	`try`
`112`	`113`	`{`
`113`	`114`	`m_config.load_from_file(conf_filename, m_config_schema, &validation_status);`
`@@ -119,7 +120,8 @@ config_loaded_res falco_configuration::init_from_file(const std::string& conf_fi`
`119`	`120`	`}`
`120`	`121`	`init_cmdline_options(cmdline_options);`
`121`	`122`
`122`		`- res[conf_filename] = validation_status;`
	`123`	`+ // Only report top most schema validation status`
	`124`	`+ res[conf_filename] = validation_status[0];`
`123`	`125`
`124`	`126`	`merge_config_files(conf_filename, res);`
`125`	`127`	`load_yaml(conf_filename);`
`@@ -138,7 +140,7 @@ std::string falco_configuration::dump()`
`138`	`140`	`// filenames and folders specified in config (minus the skipped ones).`
`139`	`141`	`void falco_configuration::merge_config_files(const std::string& config_name, config_loaded_res &res)`
`140`	`142`	`{`
`141`		`- std::string validation_status;`
	`143`	`+ std::vector<std::string> validation_status;`
`142`	`144`	`m_loaded_configs_filenames.push_back(config_name);`
`143`	`145`	`const auto ppath = std::filesystem::path(config_name);`
`144`	`146`	`// Parse files to be included`
`@@ -161,7 +163,8 @@ void falco_configuration::merge_config_files(const std::string& config_name, con`
`161`	`163`	`{`
`162`	`164`	`m_loaded_configs_filenames.push_back(include_file);`
`163`	`165`	`m_config.include_config_file(include_file_path.string(), m_config_schema, &validation_status);`
`164`		`- res[include_file_path.string()] = validation_status;`
	`166`	`+ // Only report top most schema validation status`
	`167`	`+ res[include_file_path.string()] = validation_status[0];`
`165`	`168`	`}`
`166`	`169`	`else if (std::filesystem::is_directory(include_file_path))`
`167`	`170`	`{`
`@@ -180,7 +183,8 @@ void falco_configuration::merge_config_files(const std::string& config_name, con`
`180`	`183`	`for (const auto &f : v)`
`181`	`184`	`{`
`182`	`185`	`m_config.include_config_file(f, m_config_schema, &validation_status);`
`183`		`- res[f] = validation_status;`
	`186`	`+ // Only report top most schema validation status`
	`187`	`+ res[f] = validation_status[0];`
`184`	`188`	`}`
`185`	`189`	`}`
`186`	`190`	`}`