passenger 5.1.7 → 5.1.8

data/src/agent/Core/SpawningKit/SmartSpawner.h

@@ -29,7 +29,7 @@
 #include <Core/SpawningKit/Spawner.h>
 #include <Core/SpawningKit/PipeWatcher.h>
 #include <Constants.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <LveLoggingDecorator.h>
 
 #include <adhoc_lve.h>
@@ -106,7 +106,7 @@ private:
 		if (shouldLoadShellEnvvars(options, preparation)) {
 			command.push_back(preparation.userSwitching.shell);
 			command.push_back(preparation.userSwitching.shell);
-			if (Passenger::getLogLevel() >= LVL_DEBUG3) {
+			if (LoggingKit::getLevel() >= LoggingKit::DEBUG3) {
 				command.push_back("-lxc");
 			} else {
 				command.push_back("-lc");

data/src/agent/Core/SpawningKit/Spawner.h

@@ -710,7 +710,7 @@ protected:
 				if (details.stderrCapturer != NULL) {
 					details.stderrCapturer->appendToBuffer(result);
 				}
-				printAppOutput(details.pid, "stdout", line.data(), line.size());
+				LoggingKit::logAppOutput(details.pid, "stdout", line.data(), line.size());
 			}
 		}
 	}

data/src/agent/Core/UnionStation/Connection.h

@@ -37,7 +37,7 @@
 
 #include <errno.h>
 
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Exceptions.h>
 #include <Utils/IOUtils.h>
 #include <Utils/MessageIO.h>

data/src/agent/Core/UnionStation/Context.h

@@ -37,7 +37,7 @@
 #include <vector>
 #include <stdexcept>
 
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Utils.h>

data/src/agent/Core/UnionStation/Transaction.h

@@ -36,7 +36,7 @@
 #include <cstdio>
 #include <cassert>
 
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Utils/IOUtils.h>

data/src/agent/Shared/ApiServerUtils.h

@@ -64,6 +64,7 @@
 #include <sys/types.h>
 #include <string>
 #include <vector>
+#include <stdexcept>
 #include <cstddef>
 #include <cstring>
 #include <jsoncpp/json.h>
@@ -74,6 +75,8 @@
 #include <DataStructures/StringKeyTable.h>
 #include <ServerKit/Server.h>
 #include <ServerKit/HeaderTable.h>
+#include <LoggingKit/LoggingKit.h>
+#include <LoggingKit/Context.h>
 #include <Utils.h>
 #include <Utils/IOUtils.h>
 #include <Utils/BufferedIO.h>
@@ -763,12 +766,11 @@ apiServerProcessReopenLogs(Server *server, Client *client, Request *req) {
 	if (req->method != HTTP_POST) {
 		apiServerRespondWith405(server, client, req);
 	} else if (authorizeAdminOperation(server, client, req)) {
-		int e;
 		ServerKit::HeaderTable headers;
 		headers.insert(req->pool, "Content-Type", "application/json");
 
-		string logFile = getLogFile();
-		if (logFile.empty()) {
+		ConfigKit::Store config = LoggingKit::context->getConfig();
+		if (!config["target"].isMember("path")) {
 			server->writeSimpleResponse(client, 500, &headers, "{ \"status\": \"error\", "
 				"\"code\": \"NO_LOG_FILE\", "
 				"\"message\": \"" PROGRAM_NAME " was not configured with a log file.\" }\n");
@@ -778,40 +780,56 @@ apiServerProcessReopenLogs(Server *server, Client *client, Request *req) {
 			return;
 		}
 
-		if (!setLogFile(logFile, &e)) {
-			unsigned int bufsize = 1024;
+		LoggingKit::ConfigChangeRequest configReq;
+		vector<ConfigKit::Error> errors;
+		bool ok;
+		try {
+			ok = LoggingKit::context->prepareConfigChange(Json::objectValue,
+				errors, configReq);
+		} catch (const SystemException &e) {
+			unsigned int bufsize = 2048;
 			char *message = (char *) psg_pnalloc(req->pool, bufsize);
 			snprintf(message, bufsize, "{ \"status\": \"error\", "
-				"\"code\": \"LOG_FILE_OPEN_ERROR\", "
-				"\"message\": \"Cannot reopen log file %s: %s (errno=%d)\" }",
-				logFile.c_str(), strerror(e), e);
+				"\"code\": \"OS_ERROR\", "
+				"\"message\": \"Cannot reopen log files: %s\" }",
+				e.what());
+			server->writeSimpleResponse(client, 500, &headers, message);
+			if (!req->ended()) {
+				server->endRequest(&client, &req);
+			}
+			return;
+		} catch (const std::exception &e) {
+			unsigned int bufsize = 2048;
+			char *message = (char *) psg_pnalloc(req->pool, bufsize);
+			snprintf(message, bufsize, "{ \"status\": \"error\", "
+				"\"code\": \"GENERIC_ERROR\", "
+				"\"message\": \"Cannot reopen log files: %s\" }",
+				e.what());
 			server->writeSimpleResponse(client, 500, &headers, message);
 			if (!req->ended()) {
 				server->endRequest(&client, &req);
 			}
 			return;
 		}
-		P_NOTICE("Log file reopened.");
-
-		if (hasFileDescriptorLogFile()) {
-			if (!setFileDescriptorLogFile(getFileDescriptorLogFile(), &e)) {
-				unsigned int bufsize = 1024;
-				char *message = (char *) psg_pnalloc(req->pool, bufsize);
-				snprintf(message, bufsize, "{ \"status\": \"error\", "
-					"\"code\": \"FD_LOG_FILE_OPEN_ERROR\", "
-					"\"message\": \"Cannot reopen file descriptor log file %s: %s (errno=%d)\" }",
-					getFileDescriptorLogFile().c_str(), strerror(e), e);
-				server->writeSimpleResponse(client, 500, &headers, message);
-				if (!req->ended()) {
-					server->endRequest(&client, &req);
-				}
-				return;
+		if (!ok) {
+			unsigned int bufsize = 2048;
+			char *message = (char *) psg_pnalloc(req->pool, bufsize);
+			snprintf(message, bufsize, "{ \"status\": \"error\", "
+				"\"code\": \"CONFIG_VALIDATION_ERROR\", "
+				"\"message\": \"Cannot reopen log files:"
+					" invalid logging system configuration: %s\" }",
+				ConfigKit::toString(errors).c_str());
+			server->writeSimpleResponse(client, 500, &headers, message);
+			if (!req->ended()) {
+				server->endRequest(&client, &req);
 			}
-			P_NOTICE("File descriptor log file reopened.");
+			return;
 		}
 
-		server->writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
+		LoggingKit::context->commitConfigChange(configReq);
+		P_NOTICE("All log file(s) reopened.");
 
+		server->writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
 		if (!req->ended()) {
 			server->endRequest(&client, &req);
 		}
@@ -838,8 +856,36 @@ _apiServerProcessReinheritLogsResponseBody(
 	}
 
 	int fd = readFileDescriptorWithNegotiation(io.getFd(), &req.timeout);
-	setLogFileWithFd(logFilePath, fd);
-	safelyClose(fd);
+	FdGuard guard(fd, __FILE__, __LINE__);
+	P_LOG_FILE_DESCRIPTOR_PURPOSE(fd, "Reinherited log file handle");
+
+	ConfigKit::Store oldConfig = LoggingKit::context->getConfig();
+	Json::Value config;
+	vector<ConfigKit::Error> errors;
+	LoggingKit::ConfigChangeRequest configReq;
+	bool ok;
+
+	config["target"] = oldConfig["target"];
+	config["target"]["fd"] = fd;
+	try {
+		ok = LoggingKit::context->prepareConfigChange(config,
+			errors, configReq);
+	} catch (const std::exception &e) {
+		resp.status = InternalResponse::ERROR_INTERNAL;
+		resp.errorLogs.append("Error reconfiguring logging system: ");
+		resp.errorLogs.append(e.what());
+		return;
+	}
+	if (!ok) {
+		resp.status = InternalResponse::ERROR_INTERNAL;
+		resp.errorLogs.append("Error reconfiguring logging system: ");
+		resp.errorLogs.append(ConfigKit::toString(errors));
+		return;
+	}
+
+	LoggingKit::context->commitConfigChange(configReq);
+	guard.clear();
+	P_NOTICE("All log file(s) reinherited.");
 }
 
 template<typename Server, typename Client, typename Request>

data/src/agent/Shared/Base.cpp

@@ -27,6 +27,7 @@
 	#define _GNU_SOURCE
 #endif
 
+#include <boost/cstdint.hpp>
 #include <oxt/initialize.hpp>
 #include <oxt/system_calls.hpp>
 #include <oxt/backtrace.hpp>
@@ -61,7 +62,8 @@
 #include <Shared/Base.h>
 #include <Constants.h>
 #include <Exceptions.h>
-#include <Logging.h>
+#include <LoggingKit/LoggingKit.h>
+#include <LoggingKit/Context.h>
 #include <ResourceLocator.h>
 #include <Utils.h>
 #include <Utils/SystemTime.h>
@@ -70,6 +72,8 @@
 	#include <ResourceLocator.h>
 #endif
 
+#include <jsoncpp/json.h>
+
 namespace Passenger {
 
 
@@ -246,24 +250,7 @@ appendIntegerAsHex(char *buf, IntegerType value) {
 // Must be async signal safe.
 static char *
 appendPointerAsString(char *buf, void *pointer) {
-	// Use wierd union construction to avoid compiler warnings.
-	if (sizeof(void *) == sizeof(unsigned int)) {
-		union {
-			void *pointer;
-			unsigned int value;
-		} u;
-		u.pointer = pointer;
-		return appendIntegerAsHex(appendText(buf, "0x"), u.value);
-	} else if (sizeof(void *) == sizeof(unsigned long long)) {
-		union {
-			void *pointer;
-			unsigned long long value;
-		} u;
-		u.pointer = pointer;
-		return appendIntegerAsHex(appendText(buf, "0x"), u.value);
-	} else {
-		return appendText(buf, "(pointer size unsupported)");
-	}
+	return appendIntegerAsHex(appendText(buf, "0x"), (boost::uintptr_t) pointer);
 }
 
 static char *
@@ -704,21 +691,21 @@ dumpDiagnostics(AbortHandlerState &state) {
 	end = appendText(end, " ] " PROGRAM_NAME " version: " PASSENGER_VERSION "\n");
 	write_nowarn(STDERR_FILENO, messageBuf, end - messageBuf);
 
-	if (lastAssertionFailure.filename != NULL) {
+	if (LoggingKit::lastAssertionFailure.filename != NULL) {
 		end = messageBuf;
 		end = appendText(end, state.messagePrefix);
 		end = appendText(end, " ] Last assertion failure: (");
-		end = appendText(end, lastAssertionFailure.expression);
+		end = appendText(end, LoggingKit::lastAssertionFailure.expression);
 		end = appendText(end, "), ");
-		if (lastAssertionFailure.function != NULL) {
+		if (LoggingKit::lastAssertionFailure.function != NULL) {
 			end = appendText(end, "function ");
-			end = appendText(end, lastAssertionFailure.function);
+			end = appendText(end, LoggingKit::lastAssertionFailure.function);
 			end = appendText(end, ", ");
 		}
 		end = appendText(end, "file ");
-		end = appendText(end, lastAssertionFailure.filename);
+		end = appendText(end, LoggingKit::lastAssertionFailure.filename);
 		end = appendText(end, ", line ");
-		end = appendULL(end, lastAssertionFailure.line);
+		end = appendULL(end, LoggingKit::lastAssertionFailure.line);
 		end = appendText(end, ".\n");
 		write_nowarn(STDERR_FILENO, messageBuf, end - messageBuf);
 	}
@@ -1031,10 +1018,10 @@ abortHandler(int signo, siginfo_t *info, void *ctx) {
 	__assert_fail(__const char *__assertion, __const char *__file,
 		unsigned int __line, __const char *__function)
 	{
-		lastAssertionFailure.filename = __file;
-		lastAssertionFailure.line = __line;
-		lastAssertionFailure.function = __function;
-		lastAssertionFailure.expression = __assertion;
+		LoggingKit::lastAssertionFailure.filename = __file;
+		LoggingKit::lastAssertionFailure.line = __line;
+		LoggingKit::lastAssertionFailure.function = __function;
+		LoggingKit::lastAssertionFailure.expression = __assertion;
 		fprintf(stderr, "Assertion failed! %s:%u: %s: %s\n", __file, __line, __function, __assertion);
 		fflush(stderr);
 		abort();
@@ -1056,10 +1043,10 @@ abortHandler(int signo, siginfo_t *info, void *ctx) {
 
 	extern "C" void
 	__assert_rtn(const char *func, const char *file, int line, const char *expr) {
-		lastAssertionFailure.filename = file;
-		lastAssertionFailure.line = line;
-		lastAssertionFailure.function = func;
-		lastAssertionFailure.expression = expr;
+		LoggingKit::lastAssertionFailure.filename = file;
+		LoggingKit::lastAssertionFailure.line = line;
+		LoggingKit::lastAssertionFailure.function = func;
+		LoggingKit::lastAssertionFailure.expression = expr;
 		if (func) {
 			fprintf(stderr, "Assertion failed: (%s), function %s, file %s, line %d.\n",
 				expr, func, file, line);
@@ -1470,6 +1457,46 @@ extraArgumentsPassed(int argc, char *argv[], int argStartIndex) {
 		|| (argc == argStartIndex + 1 && !isBlank(argv[argStartIndex]));
 }
 
+static void
+initializeLoggingKit(const char *processName, VariantMap &options) {
+	Json::Value config(Json::objectValue);
+
+	options.setDefaultInt("log_level", DEFAULT_LOG_LEVEL);
+	config["level"] = options.get("log_level");
+
+	if (options.has("log_file")) {
+		config["target"] = options.get("log_file");
+	} else if (options.has("debug_log_file")) {
+		config["target"] = options.get("debug_log_file");
+	}
+
+	if (options.has("file_descriptor_log_file")) {
+		config["file_descriptor_log_target"] =
+			options.get("file_descriptor_log_file");
+	}
+
+	LoggingKit::initialize(config);
+
+	if (options.has("file_descriptor_log_file")) {
+		// This information helps ./dev/parse_file_descriptor_log.
+		FastStringStream<> stream;
+		LoggingKit::_prepareLogEntry(stream, LoggingKit::CRIT, __FILE__, __LINE__);
+		stream << "Starting agent: " << processName << "\n";
+		_writeFileDescriptorLogEntry(LoggingKit::context->getConfigRealization(),
+			stream.data(), stream.size());
+
+		config = LoggingKit::context->getConfig().inspect();
+		P_LOG_FILE_DESCRIPTOR_OPEN4(
+			LoggingKit::context->getConfigRealization()->fileDescriptorLogTargetFd,
+			__FILE__, __LINE__,
+			"file descriptor log file "
+			<< config["file_descriptor_log_target"]["effective_value"]["path"].asString());
+	} else {
+		// This information helps ./dev/parse_file_descriptor_log.
+		P_DEBUG("Starting agent: " << processName);
+	}
+}
+
 VariantMap
 initializeAgent(int argc, char **argv[], const char *processName,
 	OptionParserFunc optionParser, PreinitializationFunc preinit,
@@ -1581,46 +1608,7 @@ initializeAgentOptions(const char *processName, VariantMap &options,
 		preinit(options);
 	}
 
-	options.setDefaultInt("log_level", DEFAULT_LOG_LEVEL);
-	setLogLevel(options.getInt("log_level"));
-	string logFile;
-	if (options.has("log_file")) {
-		logFile = options.get("log_file");
-	} else if (options.has("debug_log_file")) {
-		logFile = options.get("debug_log_file");
-	}
-	if (!logFile.empty()) {
-		try {
-			logFile = absolutizePath(logFile);
-		} catch (const SystemException &e) {
-			P_WARN("Cannot absolutize filename '" << logFile
-				<< "': " << e.what());
-		}
-		setLogFile(logFile);
-	}
-
-	if (options.has("file_descriptor_log_file")) {
-		logFile = options.get("file_descriptor_log_file");
-		try {
-			logFile = absolutizePath(logFile);
-		} catch (const SystemException &e) {
-			P_WARN("Cannot absolutize filename '" << logFile
-				<< "': " << e.what());
-		}
-		setFileDescriptorLogFile(logFile);
-
-		// This information helps dev/parse_file_descriptor_log.
-		FastStringStream<> stream;
-		_prepareLogEntry(stream, __FILE__, __LINE__);
-		stream << "Starting agent: " << processName << "\n";
-		_writeFileDescriptorLogEntry(stream.data(), stream.size());
-
-		P_LOG_FILE_DESCRIPTOR_OPEN4(getFileDescriptorLogFileFd(), __FILE__, __LINE__,
-			"file descriptor log file " << options.get("file_descriptor_log_file"));
-	} else {
-		// This information helps dev/parse_file_descriptor_log.
-		P_DEBUG("Starting agent: " << processName);
-	}
+	initializeLoggingKit(processName, options);
 
 	if (hasEnvOption("PASSENGER_USE_FEEDBACK_FD")) {
 		P_LOG_FILE_DESCRIPTOR_OPEN2(FEEDBACK_FD, "feedback FD");

data/src/agent/UstRouter/ApiServer.h

@@ -27,11 +27,14 @@
 #define _PASSENGER_UST_ROUTER_API_SERVER_H_
 
 #include <string>
+#include <exception>
 #include <jsoncpp/json.h>
 #include <modp_b64.h>
 
 #include <ServerKit/HttpServer.h>
 #include <DataStructures/LString.h>
+#include <LoggingKit/LoggingKit.h>
+#include <LoggingKit/Context.h>
 #include <Exceptions.h>
 #include <StaticString.h>
 #include <Utils/StrIntUtils.h>
@@ -94,19 +97,8 @@ private:
 			}
 
 			HeaderTable headers;
-			Json::Value doc;
-			string logFile = getLogFile();
-			string fileDescriptorLogFile = getFileDescriptorLogFile();
-
+			Json::Value doc = LoggingKit::context->getConfig().inspect();
 			headers.insert(req->pool, "Content-Type", "application/json");
-			doc["log_level"] = getLogLevel();
-			if (!logFile.empty()) {
-				doc["log_file"] = logFile;
-			}
-			if (!fileDescriptorLogFile.empty()) {
-				doc["file_descriptor_log_file"] = fileDescriptorLogFile;
-			}
-
 			writeSimpleResponse(client, 200, &headers, doc.toStyledString());
 			if (!req->ended()) {
 				endRequest(&client, &req);
@@ -125,46 +117,43 @@ private:
 
 	void processConfigBody(Client *client, Request *req) {
 		HeaderTable headers;
-		Json::Value &json = req->jsonBody;
+		LoggingKit::ConfigChangeRequest configReq;
+		const Json::Value &json = req->jsonBody;
+		vector<ConfigKit::Error> errors;
+		bool ok;
 
 		headers.insert(req->pool, "Content-Type", "application/json");
+		headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
 
-		if (json.isMember("log_level")) {
-			setLogLevel(json["log_level"].asInt());
-		}
-		if (json.isMember("log_file")) {
-			string logFile = json["log_file"].asString();
-			try {
-				logFile = absolutizePath(logFile);
-			} catch (const SystemException &e) {
-				unsigned int bufsize = 1024;
-				char *message = (char *) psg_pnalloc(req->pool, bufsize);
-				snprintf(message, bufsize, "{ \"status\": \"error\", "
-					"\"message\": \"Cannot absolutize log file filename: %s\" }",
-					e.what());
-				writeSimpleResponse(client, 500, &headers, message);
-				if (!req->ended()) {
-					endRequest(&client, &req);
-				}
-				return;
+		try {
+			ok = LoggingKit::context->prepareConfigChange(json,
+				errors, configReq);
+		} catch (const std::exception &e) {
+			unsigned int bufsize = 2048;
+			char *message = (char *) psg_pnalloc(req->pool, bufsize);
+			snprintf(message, bufsize, "{ \"status\": \"error\", "
+				"\"message\": \"Error reconfiguring logging system: %s\" }",
+				e.what());
+			writeSimpleResponse(client, 500, &headers, message);
+			if (!req->ended()) {
+				endRequest(&client, &req);
 			}
-
-			int e;
-			if (!setLogFile(logFile, &e)) {
-				unsigned int bufsize = 1024;
-				char *message = (char *) psg_pnalloc(req->pool, bufsize);
-				snprintf(message, bufsize, "{ \"status\": \"error\", "
-					"\"message\": \"Cannot open log file: %s (errno=%d)\" }",
-					strerror(e), e);
-				writeSimpleResponse(client, 500, &headers, message);
-				if (!req->ended()) {
-					endRequest(&client, &req);
-				}
-				return;
+			return;
+		}
+		if (!ok) {
+			unsigned int bufsize = 2048;
+			char *message = (char *) psg_pnalloc(req->pool, bufsize);
+			snprintf(message, bufsize, "{ \"status\": \"error\", "
+				"\"message\": \"Error reconfiguring logging system: %s\" }",
+				ConfigKit::toString(errors).c_str());
+			writeSimpleResponse(client, 500, &headers, message);
+			if (!req->ended()) {
+				endRequest(&client, &req);
 			}
-			P_NOTICE("Log file opened.");
+			return;
 		}
 
+		LoggingKit::context->commitConfigChange(configReq);
 		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
 		if (!req->ended()) {
 			endRequest(&client, &req);