passenger 4.0.42 → 4.0.43

data/ext/common/agents/Base.cpp

@@ -438,7 +438,7 @@ dumpFileDescriptorInfoWithLsof(AbortHandlerState &state, void *userData) {
 	end = appendULL(end, state.pid);
 	*end = '\0';
 
-	closeAllFileDescriptors(2);
+	closeAllFileDescriptors(2, true);
 
 	execlp("lsof", "lsof", "-p", state.messageBuf, "-nP", (const char * const) 0);
 
@@ -457,7 +457,7 @@ dumpFileDescriptorInfoWithLs(AbortHandlerState &state, char *end) {
 
 	pid = asyncFork();
 	if (pid == 0) {
-		closeAllFileDescriptors(2);
+		closeAllFileDescriptors(2, true);
 		// The '-v' is for natural sorting on Linux. On BSD -v means something else but it's harmless.
 		execlp("ls", "ls", "-lv", state.messageBuf, (const char * const) 0);
 		_exit(1);
@@ -517,7 +517,7 @@ dumpWithCrashWatch(AbortHandlerState &state) {
 	
 	pid_t child = asyncFork();
 	if (child == 0) {
-		closeAllFileDescriptors(2);
+		closeAllFileDescriptors(2, true);
 		execlp("crash-watch", "crash-watch", "--dump", pidStr, (char * const) 0);
 		if (errno == ENOENT) {
 			safePrintErr("Crash-watch is not installed. Please install it with 'gem install crash-watch' "
@@ -583,7 +583,7 @@ dumpWithCrashWatch(AbortHandlerState &state) {
 
 				close(p[1]);
 				dup2(p[0], STDIN_FILENO);
-				closeAllFileDescriptors(2);
+				closeAllFileDescriptors(2, true);
 				
 				char *command = end;
 				end = appendText(end, "exec ");
@@ -664,7 +664,7 @@ dumpDiagnostics(AbortHandlerState &state) {
 	// Dump human-readable time string and string.
 	pid = asyncFork();
 	if (pid == 0) {
-		closeAllFileDescriptors(2);
+		closeAllFileDescriptors(2, true);
 		execlp("date", "date", (const char * const) 0);
 		_exit(1);
 	} else if (pid == -1) {
@@ -676,7 +676,7 @@ dumpDiagnostics(AbortHandlerState &state) {
 	// Dump system uname.
 	pid = asyncFork();
 	if (pid == 0) {
-		closeAllFileDescriptors(2);
+		closeAllFileDescriptors(2, true);
 		execlp("uname", "uname", "-mprsv", (const char * const) 0);
 		_exit(1);
 	} else if (pid == -1) {
@@ -688,7 +688,7 @@ dumpDiagnostics(AbortHandlerState &state) {
 	// Dump ulimit.
 	pid = asyncFork();
 	if (pid == 0) {
-		closeAllFileDescriptors(2);
+		closeAllFileDescriptors(2, true);
 		execlp("ulimit", "ulimit", "-a", (const char * const) 0);
 		// On Linux 'ulimit' is a shell builtin, not a command.
 		execlp("/bin/sh", "/bin/sh", "-c", "ulimit -a", (const char * const) 0);
@@ -929,7 +929,7 @@ abortHandler(int signo, siginfo_t *info, void *ctx) {
 
 		child = asyncFork();
 		if (child == 0) {
-			closeAllFileDescriptors(2);
+			closeAllFileDescriptors(2, true);
 			#ifdef __APPLE__
 				execlp("osascript", "osascript", "-e", "beep 2", (const char * const) 0);
 				safePrintErr("Cannot execute 'osascript' command\n");

data/ext/common/agents/HelperAgent/Main.cpp

@@ -53,6 +53,7 @@
 #include <agents/HelperAgent/RequestHandler.h>
 #include <agents/HelperAgent/RequestHandler.cpp>
 #include <agents/HelperAgent/AgentOptions.h>
+#include <agents/HelperAgent/SystemMetricsTool.cpp>
 
 #include <agents/Base.h>
 #include <Constants.h>
@@ -63,7 +64,7 @@
 #include <ResourceLocator.h>
 #include <BackgroundEventLoop.cpp>
 #include <ServerInstanceDir.h>
-#include <UnionStation.h>
+#include <UnionStation/Core.h>
 #include <Exceptions.h>
 #include <MultiLibeio.cpp>
 #include <Utils.h>
@@ -261,7 +262,7 @@ private:
 	FileDescriptor requestSocket;
 	ServerInstanceDir serverInstanceDir;
 	ServerInstanceDir::GenerationPtr generation;
-	UnionStation::LoggerFactoryPtr loggerFactory;
+	UnionStation::CorePtr unionStationCore;
 	RandomGeneratorPtr randomGenerator;
 	SpawnerFactoryPtr spawnerFactory;
 	PoolPtr pool;
@@ -459,11 +460,11 @@ public:
 		}
 		
 		UPDATE_TRACE_POINT();
-		loggerFactory = boost::make_shared<UnionStation::LoggerFactory>(options.loggingAgentAddress,
+		unionStationCore = boost::make_shared<UnionStation::Core>(options.loggingAgentAddress,
 			"logging", options.loggingAgentPassword);
-		spawnerFactory = boost::make_shared<SpawnerFactory>(poolLoop.safe,
-			resourceLocator, generation, boost::make_shared<SpawnerConfig>(randomGenerator));
-		pool = boost::make_shared<Pool>(spawnerFactory, loggerFactory,
+		spawnerFactory = boost::make_shared<SpawnerFactory>(resourceLocator,
+			generation, boost::make_shared<SpawnerConfig>(randomGenerator));
+		pool = boost::make_shared<Pool>(spawnerFactory, unionStationCore,
 			randomGenerator, &options);
 		pool->initialize();
 		pool->setMax(options.maxPoolSize);
@@ -620,6 +621,11 @@ public:
 int
 main(int argc, char *argv[]) {
 	TRACE_POINT();
+
+	if (argc > 1 && strcmp(argv[1], "system-metrics") == 0) {
+		return SystemMetricsTool::main(argc, argv);
+	}
+
 	AgentOptionsPtr options;
 	try {
 		options = boost::make_shared<AgentOptions>(

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -133,7 +133,9 @@
 #include <EventedBufferedInput.h>
 #include <MessageReadersWriters.h>
 #include <Constants.h>
-#include <UnionStation.h>
+#include <UnionStation/Core.h>
+#include <UnionStation/Transaction.h>
+#include <UnionStation/ScopeLog.h>
 #include <ApplicationPool2/Pool.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/IOUtils.h>
@@ -528,16 +530,16 @@ public:
 	}
 
 	bool useUnionStation() const {
-		return options.logger != NULL;
+		return options.transaction != NULL;
 	}
 
-	UnionStation::LoggerPtr getLogger() const {
-		return options.logger;
+	UnionStation::TransactionPtr getUnionStationTransaction() const {
+		return options.transaction;
 	}
 
 	void beginScopeLog(UnionStation::ScopeLog **scopeLog, const char *name) {
-		if (options.logger != NULL) {
-			*scopeLog = new UnionStation::ScopeLog(options.logger, name);
+		if (options.transaction != NULL) {
+			*scopeLog = new UnionStation::ScopeLog(options.transaction, name);
 		}
 	}
 
@@ -550,7 +552,7 @@ public:
 	}
 
 	void logMessage(const StaticString &message) {
-		options.logger->message(message);
+		options.transaction->message(message);
 	}
 
 	void verifyInvariants() const {
@@ -617,16 +619,13 @@ public:
 
 private:
 	friend class Client;
-	typedef UnionStation::LoggerFactory LoggerFactory;
-	typedef UnionStation::LoggerFactoryPtr LoggerFactoryPtr;
-	typedef UnionStation::LoggerPtr LoggerPtr;
 
 	const SafeLibevPtr libev;
 	FileDescriptor requestSocket;
 	PoolPtr pool;
 	const AgentOptions &options;
 	const ResourceLocator resourceLocator;
-	LoggerFactoryPtr loggerFactory;
+	UnionStation::CorePtr unionStationCore;
 	ev::io requestSocketWatcher;
 	ev::timer resumeSocketWatcherTimer;
 	HashMap<int, ClientPtr> clients;
@@ -1933,9 +1932,9 @@ private:
 				return;
 			}
 
-			client->options.logger = loggerFactory->newTransaction(
+			client->options.transaction = unionStationCore->newTransaction(
 				options.getAppGroupName(), "requests", key, filters);
-			if (!client->options.logger->isNull()) {
+			if (!client->options.transaction->isNull()) {
 				client->options.analytics = true;
 				client->options.unionStationKey = key;
 			}
@@ -2327,7 +2326,7 @@ private:
 
 			if (client->options.analytics) {
 				data.push_back(makeStaticStringWithNull("PASSENGER_TXN_ID"));
-				data.push_back(makeStaticStringWithNull(client->options.logger->getTxnId()));
+				data.push_back(makeStaticStringWithNull(client->options.transaction->getTxnId()));
 			}
 
 			uint32_t dataSize = 0;
@@ -2402,7 +2401,7 @@ private:
 
 			if (client->options.analytics) {
 				data.append("Passenger-Txn-Id: ");
-				data.append(client->options.logger->getTxnId());
+				data.append(client->options.transaction->getTxnId());
 				data.append("\r\n");
 			}
 
@@ -2614,7 +2613,7 @@ public:
 	{
 		accept4Available = true;
 		connectPasswordTimeout = 15000;
-		loggerFactory = pool->loggerFactory;
+		unionStationCore = pool->unionStationCore;
 
 		requestSocketWatcher.set(_requestSocket, ev::READ);
 		requestSocketWatcher.set(_libev->getLoop());

data/ext/common/agents/HelperAgent/SystemMetricsTool.cpp

@@ -0,0 +1,199 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#include <iostream>
+#include <string>
+#include <unistd.h>
+#include <cstdio>
+#include <cstring>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/SystemMetricsCollector.h>
+
+namespace SystemMetricsTool {
+
+using namespace std;
+using namespace Passenger;
+
+struct Options {
+	bool xml;
+	SystemMetrics::XmlOptions xmlOptions;
+	SystemMetrics::DescriptionOptions descOptions;
+	int interval;
+	bool stdin;
+	bool exitOnUnexpectedError;
+	bool help;
+
+	Options() {
+		xml = false;
+		descOptions.colors = isatty(1);
+		interval = -1;
+		stdin = false;
+		exitOnUnexpectedError = true;
+		help = false;
+	}
+};
+
+static bool
+isFlag(const char *arg, char shortFlagName, const char *longFlagName) {
+	return strcmp(arg, longFlagName) == 0
+		|| (shortFlagName != '\0' && arg[0] == '-'
+			&& arg[1] == shortFlagName && arg[2] == '\0');
+}
+
+static void
+usage() {
+	printf("Usage: passenger-config system-metrics [OPTIONS]\n");
+	printf("Displays various metrics about the system.\n");
+	printf("\n");
+	printf("Options:\n");
+	printf("        --xml              Output in XML format\n");
+	printf("        --no-general       Do not display general metrics\n");
+	printf("        --no-cpu           Do not display CPU metrics\n");
+	printf("        --no-memory        Do not display memory metrics\n");
+	printf("        --force-colors     Display colors even if stdout is not a TTY\n");
+	printf("    -w  --watch INTERVAL   Reprint metrics every INTERVAL seconds\n");
+	printf("        --stdin            Reprint metrics every time a newline is received on\n");
+	printf("                           stdin, until EOF. Mutually exclusive with --watch\n");
+	printf("        --no-exit-on-unexpected-error   Normally, if an unexpected error is\n");
+	printf("                           encountered while collecting system metrics, this\n");
+	printf("                           program will exit with an error code. This option\n");
+	printf("                           suppresses that\n");
+	printf("    -h, --help             Show this help\n");
+}
+
+static Options
+parseOptions(int argc, char *argv[]) {
+	Options options;
+	int i = 2;
+
+	while (i < argc) {
+		if (isFlag(argv[i], '\0', "--xml")) {
+			options.xml = true;
+			i++;
+		} else if (isFlag(argv[i], '\0', "--no-general")) {
+			options.xmlOptions.general = false;
+			options.descOptions.general = false;
+			i++;
+		} else if (isFlag(argv[i], '\0', "--no-cpu")) {
+			options.xmlOptions.cpu = false;
+			options.descOptions.cpu = false;
+			i++;
+		} else if (isFlag(argv[i], '\0', "--no-memory")) {
+			options.xmlOptions.memory = false;
+			options.descOptions.memory = false;
+			i++;
+		} else if (isFlag(argv[i], '\0', "--force-colors")) {
+			options.descOptions.colors = true;
+			i++;
+		} else if (isFlag(argv[i], 'w', "--watch")) {
+			if (argc >= i + 2) {
+				options.interval = atoi(argv[i + 1]);
+				i += 2;
+			} else {
+				fprintf(stderr, "ERROR: extra argument required for --watch\n");
+				usage();
+				exit(1);
+			}
+		} else if (isFlag(argv[i], '\0', "--stdin")) {
+			options.stdin = true;
+			i++;
+		} else if (isFlag(argv[i], '\0', "--no-exit-on-unexpected-error")) {
+			options.exitOnUnexpectedError = false;
+			i++;
+		} else if (isFlag(argv[i], 'h', "--help")) {
+			options.help = true;
+			i++;
+		} else {
+			fprintf(stderr, "ERROR: unrecognized argument %s\n", argv[i]);
+			usage();
+			exit(1);
+		}
+	}
+	if (options.interval != -1 && options.stdin) {
+		fprintf(stderr, "ERROR: --watch and --stdin are mutually exclusive.\n");
+		exit(1);
+	}
+	return options;
+}
+
+static bool
+waitForNextLine() {
+	char buf[1024];
+	return fgets(buf, sizeof(buf), stdin) != NULL;
+}
+
+static void
+perform(const Options &options, SystemMetricsCollector &collector, SystemMetrics &metrics) {
+	try {
+		collector.collect(metrics);
+		if (options.xml) {
+			cout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+			metrics.toXml(cout, options.xmlOptions);
+			cout << endl;
+		} else {
+			metrics.toDescription(cout, options.descOptions);
+		}
+	} catch (const RuntimeException &e) {
+		fprintf(stderr, "An error occurred while collecting system metrics: %s\n", e.what());
+		if (options.exitOnUnexpectedError) {
+			exit(1);
+		}
+	}
+}
+
+static int
+main(int argc, char *argv[]) {
+	Options options = parseOptions(argc, argv);
+	if (options.help) {
+		usage();
+		return 0;
+	}
+
+	SystemMetricsCollector collector;
+	SystemMetrics metrics;
+
+	if (options.descOptions.cpu) {
+		collector.collect(metrics);
+		// We have to measure system metrics within an interval
+		// in order to determine the CPU usage.
+		usleep(50000);
+	}
+
+	if (options.stdin) {
+		while (waitForNextLine()) {
+			perform(options, collector, metrics);
+		}
+	} else {
+		do {
+			perform(options, collector, metrics);
+			if (options.interval != -1) {
+				sleep(options.interval);
+			}
+		} while (options.interval != -1);
+	}
+	return 0;
+}
+
+} // namespace SystemMetricsTool

data/ext/common/agents/LoggingAgent/LoggingServer.h

@@ -534,7 +534,8 @@ private:
 	}
 	
 	bool supportedCategory(const StaticString &category) const {
-		return category == "requests" || category == "processes" || category == "exceptions";
+		return category == "requests" || category == "processes"
+			|| category == "exceptions" || category == "system_metrics";
 	}
 	
 	LogSinkPtr openLogFile() {

data/ext/common/agents/SpawnPreparer.cpp

@@ -41,6 +41,8 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <string>
+#include <sstream>
+#include <Utils/SystemMetricsCollector.h>
 #include <Utils/Base64.h>
 
 using namespace std;
@@ -148,42 +150,28 @@ dumpInformation() {
 		fclose(f);
 	}
 
-	f = fopen((dir + "/ulimit").c_str(), "w");
-	if (f != NULL) {
-		pid_t pid = fork();
-		if (pid == 0) {
-			dup2(fileno(f), 1);
-			execlp("ulimit", "ulimit", "-a", (char *) 0);
-			_exit(1);
-		} else if (pid == -1) {
-			int e = errno;
-			fprintf(stderr, "Error: cannot fork a new process: %s (errno=%d)\n",
-				strerror(e), e);
-		} else {
-			waitpid(pid, NULL, 0);
-		}
-		fclose(f);
+	SystemMetrics metrics;
+	bool collected = false;
+	try {
+		SystemMetricsCollector collector;
+		collector.collect(metrics);
+		usleep(50000); // Correct collect CPU metrics.
+		collector.collect(metrics);
+		collected = true;
+	} catch (const RuntimeException &e) {
+		fprintf(stderr, "Warning: %s\n", e.what());
 	}
-
-	#ifdef __linux__
-		// TODO: call helper-scripts/system-memory-stats.py
-		f = fopen((dir + "/sysmemory").c_str(), "w");
+	if (collected) {
+		f = fopen((dir + "/system_metrics").c_str(), "w");
 		if (f != NULL) {
-			pid_t pid = fork();
-			if (pid == 0) {
-				dup2(fileno(f), 1);
-				execlp("free", "free", "-m", (char *) 0);
-				_exit(1);
-			} else if (pid == -1) {
-				int e = errno;
-				fprintf(stderr, "Error: cannot fork a new process: %s (errno=%d)\n",
-					strerror(e), e);
-			} else {
-				waitpid(pid, NULL, 0);
-			}
+			stringstream stream;
+			metrics.toDescription(stream);
+			string info = stream.str();
+
+			fwrite(info.data(), 1, info.size(), f);
 			fclose(f);
 		}
-	#endif
+	}
 }
 
 // Usage: SpawnPreparer <working directory> <envvars> <executable> <exec args...>