add structured JSON logging

Signed-off-by: darkexplosiveqwx <101737077+darkexplosiveqwx@users.noreply.github.com>

Author: darkexplosiveqwx

src/api/config.c

@@ -128,6 +128,8 @@ cJSON *addJSONConfValue(const enum conf_type conf_type, union conf_value *val)
 			return cJSON_CreateStringReference(get_temp_unit_str(val->temp_unit));
 		case CONF_ENUM_BLOCKING_EDNS_MODE:
 			return cJSON_CreateStringReference(get_edns_mode_str(val->edns_mode));
+		case CONF_ENUM_LOG_DESTINATION:
+			return cJSON_CreateStringReference(get_log_destination_str(val->log_destination));
 		case CONF_STRUCT_IN_ADDR:
 		{
 			// Special case 0.0.0.0 -> return empty string
@@ -391,6 +393,19 @@ static const char *getJSONvalue(struct conf_item *conf_item, cJSON *elem, struct
 			log_web_debug(DEBUG_CONFIG, "%s = %d", conf_item->k, conf_item->v.edns_mode);
 			break;
 		}
+		case CONF_ENUM_LOG_DESTINATION:
+		{
+			// Check type
+			if(!cJSON_IsString(elem))
+				return "not of type string";
+			const int log_dest = get_log_destination_val(elem->valuestring);
+			if(log_dest == -1)
+				return "invalid option";
+			// Set item
+			conf_item->v.log_destination = log_dest;
+			log_web_debug(DEBUG_CONFIG, "%s = %d", conf_item->k, conf_item->v.log_destination);
+			break;
+		}
 		case CONF_ENUM_PRIVACY_LEVEL:
 		{
 			// Check type

src/args.c

@@ -1716,6 +1716,16 @@ void suggest_complete(const int argc, char *argv[])
 							}
 							break;
 
+						case CONF_ENUM_LOG_DESTINATION:
+							// Provide matching suggestions
+							for(size_t j = 0; j < LOG_DEST_MAX; j++)
+							{
+								const char *dest = get_log_destination_str(j);
+								if(strStartsWithIgnoreCase(dest, last_word) || strlen(last_word) == 0)
+									puts(dest);
+							}
+							break;
+
 						case CONF_ENUM_PRIVACY_LEVEL:
 							// This enum is in reality a numeric value
 							printf("%d\n", (int)conf_item->d.privacy_level);

src/config/cli.c

@@ -311,6 +311,21 @@ static bool readStringValue(struct conf_item *conf_item, const char *value, stru
 			}
 			break;
 		}
+		case CONF_ENUM_LOG_DESTINATION:
+		{
+			const int dest = get_log_destination_val(value);
+			if(dest != -1)
+				conf_item->v.log_destination = dest;
+			else
+			{
+				char *allowed = NULL;
+				CONFIG_ITEM_ARRAY(conf_item->a, allowed);
+				log_err("Config setting %s is invalid, allowed options are: %s", conf_item->k, allowed);
+				free(allowed);
+				return false;
+			}
+			break;
+		}
 		case CONF_STRUCT_IN_ADDR:
 		{
 			struct in_addr addr4 = { 0 };

src/config/config.c

@@ -283,6 +283,7 @@ void duplicate_config(struct config *dst, struct config *src)
 			case CONF_ENUM_WEB_THEME:
 			case CONF_ENUM_TEMP_UNIT:
 			case CONF_ENUM_BLOCKING_EDNS_MODE:
+			case CONF_ENUM_LOG_DESTINATION:
 			case CONF_STRUCT_IN_ADDR:
 			case CONF_STRUCT_IN6_ADDR:
 			case CONF_ALL_DEBUG_BOOL:
@@ -321,6 +322,7 @@ bool compare_config_item(const enum conf_type t, const union conf_value *val1, c
 		case CONF_ENUM_WEB_THEME:
 		case CONF_ENUM_TEMP_UNIT:
 		case CONF_ENUM_BLOCKING_EDNS_MODE:
+		case CONF_ENUM_LOG_DESTINATION:
 		case CONF_STRUCT_IN_ADDR:
 		case CONF_STRUCT_IN6_ADDR:
 		case CONF_ALL_DEBUG_BOOL:
@@ -377,6 +379,7 @@ void free_config(struct config *conf, const bool terminating)
 			case CONF_ENUM_WEB_THEME:
 			case CONF_ENUM_TEMP_UNIT:
 			case CONF_ENUM_BLOCKING_EDNS_MODE:
+			case CONF_ENUM_LOG_DESTINATION:
 			case CONF_STRUCT_IN_ADDR:
 			case CONF_STRUCT_IN6_ADDR:
 			case CONF_ALL_DEBUG_BOOL:
@@ -1362,7 +1365,7 @@ void initConfig(struct config *conf)
 	conf->files.pcap.c = validate_filepath_empty;
 
 	// sub-struct files.log
-	// conf->files.log.ftl is set in a separate function (getLogFilePath)
+	// conf->files.log.ftl and conf->files.log.destination is set in a separate function (getLogFilePath)
 
 	conf->files.log.dnsmasq.k = "files.log.dnsmasq";
 	conf->files.log.dnsmasq.h = "The log file used by the embedded dnsmasq DNS server";
@@ -1964,6 +1967,20 @@ static bool getLogFilePathENV(void)
 	return true;
 }
 
+static bool getLogDestinationENV(void)
+{
+	const char *val = getenv(FTLCONF_PREFIX "files_log_destination");
+	if(val == NULL || *val == '\0')
+		return false;
+
+	const int dest = get_log_destination_val(val);
+	if(dest == -1)
+		return false;
+
+	config.files.log.destination.v.log_destination = dest;
+	return true;
+}
+
 bool getLogFilePath(bool try_read)
 {
 	// Initialize memory
@@ -1979,9 +1996,38 @@ bool getLogFilePath(bool try_read)
 	config.files.log.ftl.c = validate_filepath;
 	config.files.log.ftl.f = FLAG_FTL_LOG;
 
-	// Try sources in priority order: ENV > TOML > legacy
-	if(try_read && !getLogFilePathENV() && !getLogFilePathTOML())
-		return getLogFilePathLegacy(&config, NULL);
+	// Initialize log destination
+	config.files.log.destination.k = "files.log.destination";
+	config.files.log.destination.h = "Where to write FTL, webserver and dnsmasq log output";
+	{
+		struct enum_options log_destination[] =
+		{
+			{ "FILE", "Write logs to the configured log files" },
+			{ "JSON", "Write logs as structured JSON to stdout" }
+		};
+		CONFIG_ADD_ENUM_OPTIONS(config.files.log.destination.a, log_destination);
+	}
+	config.files.log.destination.t = CONF_ENUM_LOG_DESTINATION;
+	config.files.log.destination.f = FLAG_READ_ONLY;
+	config.files.log.destination.d.log_destination = LOG_DEST_FILE;
+	config.files.log.destination.c = validate_stub;
+
+	// Read log file path: ENV > TOML > legacy
+	// ENV is always checked so it works during early init (try_read=false).
+	// When try_read is true, TOML and legacy are also checked. Since ENV
+	// runs last, it takes precedence over TOML and legacy if set.
+	if(try_read)
+	{
+		if(!getLogFilePathTOML())
+			getLogFilePathLegacy(&config, NULL);
+	}
+	getLogFilePathENV();
+
+	// Read log destination: ENV > TOML
+	// Same priority logic: ENV runs last and wins if set.
+	if(try_read)
+		getLogDestinationTOML();
+	getLogDestinationENV();
 
 	return true;
 }
@@ -2033,6 +2079,7 @@ const char * __attribute__ ((const)) get_conf_type_str(const enum conf_type type
 		case CONF_ENUM_WEB_THEME:
 		case CONF_ENUM_TEMP_UNIT:
 		case CONF_ENUM_BLOCKING_EDNS_MODE:
+		case CONF_ENUM_LOG_DESTINATION:
 			return "enum (string)";
 		case CONF_ENUM_PRIVACY_LEVEL:
 			return "enum (unsigned integer)";

src/config/config.h

@@ -67,6 +67,7 @@ union conf_value {
 	enum web_theme web_theme;                   // enum web_theme value
 	enum temp_unit temp_unit;                   // enum temp_unit value
 	enum edns_mode edns_mode;                   // enum edns_mode value
+	enum log_destination log_destination;       // enum log_destination value
 	struct in_addr in_addr;                     // struct in_addr value
 	struct in6_addr in6_addr;                   // struct in6_addr value
 	cJSON *json;                                // cJSON * value
@@ -90,6 +91,7 @@ enum conf_type {
 	CONF_ENUM_LISTENING_MODE,
 	CONF_ENUM_WEB_THEME,
 	CONF_ENUM_BLOCKING_EDNS_MODE,
+	CONF_ENUM_LOG_DESTINATION,
 	CONF_ENUM_TEMP_UNIT,
 	CONF_STRUCT_IN_ADDR,
 	CONF_STRUCT_IN6_ADDR,
@@ -310,6 +312,7 @@ struct config {
 			struct conf_item ftl;
 			struct conf_item dnsmasq;
 			struct conf_item webserver;
+			struct conf_item destination;
 		} log;
 	} files;
 

src/config/env.c

@@ -528,6 +528,20 @@ bool __attribute__((nonnull(1,2,3))) readEnvValue(struct conf_item *conf_item, s
 			}
 			break;
 		}
+		case CONF_ENUM_LOG_DESTINATION:
+		{
+			const int dest = get_log_destination_val(envvar);
+			if(dest != -1)
+			{
+				conf_item->v.log_destination = dest;
+				item->valid = true;
+			}
+			else
+			{
+				invalid_enum_item(envvar, conf_item, item);
+			}
+			break;
+		}
 		case CONF_ENUM_PRIVACY_LEVEL:
 		{
 			int val = 0;

src/config/toml_helper.c

@@ -366,6 +366,9 @@ void writeTOMLvalue(FILE * fp, const int indent, const enum conf_type t, union c
 		case CONF_ENUM_BLOCKING_EDNS_MODE:
 			printTOMLstring(fp, get_edns_mode_str(v->edns_mode), toml);
 			break;
+		case CONF_ENUM_LOG_DESTINATION:
+			printTOMLstring(fp, get_log_destination_str(v->log_destination), toml);
+			break;
 		case CONF_STRUCT_IN_ADDR:
 		{
 			// Special case: 0.0.0.0 -> return empty string
@@ -658,6 +661,21 @@ void readTOMLvalue(struct conf_item *conf_item, const char* key, toml_datum_t to
 				log_debug(DEBUG_CONFIG, "%s DOES NOT EXIST or is not a valid string", conf_item->k);
 			break;
 		}
+		case CONF_ENUM_LOG_DESTINATION:
+		{
+			toml_datum_t val = toml_table_find(toml, key);
+			if(val.type == TOML_STRING)
+			{
+				const int dest = get_log_destination_val(val.u.s);
+				if(dest != -1)
+					conf_item->v.log_destination = dest;
+				else
+					log_warn("Config setting %s is invalid, allowed options are: %s", conf_item->k, conf_item->h);
+			}
+			else
+				log_debug(DEBUG_CONFIG, "%s DOES NOT EXIST or is not a valid string", conf_item->k);
+			break;
+		}
 		case CONF_ENUM_PRIVACY_LEVEL:
 		{
 			const toml_datum_t val = toml_table_find(toml, key);

src/config/toml_reader.c

@@ -12,6 +12,7 @@
 #include "toml_reader.h"
 #include "config/setupVars.h"
 #include "log.h"
+#include "datastructure.h"
 // getprio(), setprio()
 #include <sys/resource.h>
 // argv_dnsmasq
@@ -348,6 +349,49 @@ bool getLogFilePathTOML(void)
 	return true;
 }
 
+bool getLogDestinationTOML(void)
+{
+	log_debug(DEBUG_CONFIG, "Reading TOML config file: log destination");
+
+	toml_result_t conf = { 0 };
+
+	if(!parseTOML(&conf, 0))
+		return false;
+
+	toml_datum_t files = toml_table_find(conf.toptab, "files");
+	if(files.type != TOML_TABLE)
+	{
+		log_debug(DEBUG_CONFIG, "files DOES NOT EXIST or is not a table");
+		toml_free(conf);
+		return false;
+	}
+
+	toml_datum_t log = toml_table_find(files, "log");
+	if(log.type != TOML_TABLE)
+	{
+		log_debug(DEBUG_CONFIG, "files.log DOES NOT EXIST or is not a table");
+		toml_free(conf);
+		return false;
+	}
+
+	toml_datum_t destination = toml_table_find(log, "destination");
+	if(destination.type != TOML_STRING)
+	{
+		log_debug(DEBUG_CONFIG, "files.log.destination DOES NOT EXIST or is not an enum");
+		toml_free(conf);
+		return false;
+	}
+
+	const int dest = get_log_destination_val(destination.u.s);
+	if(dest != -1)
+		config.files.log.destination.v.log_destination = dest;
+	else
+		log_warn("Config setting %s is invalid, allowed options are: %s", "files.log.destination", "FILE, JSON");
+
+	toml_free(conf);
+	return true;
+}
+
 static void reportDebugFlags(void)
 {
 	// Print debug settings

src/config/toml_reader.h

@@ -17,5 +17,6 @@ bool readFTLtoml(struct config *oldconf, struct config *newconf,
                  toml_datum_t toml, const bool verbose, bool *restart,
                  const unsigned int version, const bool teleporter);
 bool getLogFilePathTOML(void);
+bool getLogDestinationTOML(void);
 
 #endif //TOML_READER_H

src/datastructure.c

@@ -1507,6 +1507,31 @@ int __attribute__ ((pure)) get_listeningMode_val(const char *listeningMode)
 	return -1;
 }
 
+const char * __attribute__ ((const)) get_log_destination_str(const enum log_destination dest)
+{
+	switch(dest)
+	{
+		case LOG_DEST_FILE:
+			return "FILE";
+		case LOG_DEST_JSON:
+			return "JSON";
+		case LOG_DEST_MAX:
+		default:
+			return NULL;
+	}
+}
+
+int __attribute__ ((pure)) get_log_destination_val(const char *dest)
+{
+	if(strcasecmp(dest, "FILE") == 0)
+		return LOG_DEST_FILE;
+	else if(strcasecmp(dest, "JSON") == 0)
+		return LOG_DEST_JSON;
+
+	// Invalid value
+	return -1;
+}
+
 const char * __attribute__ ((const)) get_temp_unit_str(const enum temp_unit temp_unit)
 {
 	switch(temp_unit)