passenger 4.0.42 → 4.0.43

data/doc/users_guide_snippets/troubleshooting/default.txt

@@ -118,3 +118,45 @@ cd /path-to-your-app
 passenger start --temp-dir=$HOME/tmp
 ---------------------------------------
 endif::[]
+
+=== I get "command not found" when running a Phusion Passenger command through sudo
+
+**Symptoms**::
+	Phusion Passenger commands can be found as a normal user, but not when run through sudo:
++
+-------------------------
+$ passenger-status
+...some output, but no "command not found" error...
+$ passenger-install-apache2-module
+...some output, but no "command not found" error...
+$ sudo passenger-status
+sudo: passenger-status: command not found
+$ sudo passenger-install-apache2-module
+sudo: passenger-install-apache2-module: command not found
+-------------------------
+
+**Cause**::
+	The operating system looks up commands using <<the_path_env_var,the PATH environment variable>>. However, sudo resets all environment variables to a default value, dictated by sudo. If Phusion Passenger was installed to a location that is not in the default sudo PATH value, then sudo will not be able to find the Phusion Passenger commands.
++
+In addition, if you installed Phusion Passenger using a Ruby interpreter that was installed through RVM, then you **must** use rvmsudo instead of sudo. As a rule, when you're an RVM user, always use rvmsudo instead of sudo.
+
+**Solution**::
+	Execute the command using its full path. You can use `which` as a normal user to lookup the full path:
++
+---------------------------------------
+$ which passenger-status
+/somewhere/bin/passenger-status
+---------------------------------------
++
+Next, run full path of the command using either sudo or rvmsudo:
++
+---------------------------------------
+$ sudo /somewhere/bin/passenger-status
+
+# -OR, if you're using RVM:-
+
+$ rvmsudo /somewhere/bin/passenger-status
+---------------------------------------
+
+**Recommended reading**::
+	When using sudo, you will probably run into similar "command not found" issues in the future, with components other than Phusion Passenger. We **strongly recommend** you to <<about_environment_variables,learn about environment variables>> so that you know what to do in the future.

data/ext/common/ApplicationPool2/Common.h

@@ -29,6 +29,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
 #include <oxt/tracable_exception.hpp>
+#include <RandomGenerator.h>
 #include <ApplicationPool2/Options.h>
 #include <Utils/StringMap.h>
 

data/ext/common/ApplicationPool2/DirectSpawner.h

@@ -40,8 +40,6 @@ using namespace oxt;
 
 class DirectSpawner: public Spawner {
 private:
-	SafeLibevPtr libev;
-	
 	static int startBackgroundThread(void *(*mainFunction)(void *), void *arg) {
 		// Using raw pthread API because we don't want to register such
 		// trivial threads on the oxt::thread list.
@@ -146,12 +144,10 @@ private:
 	}
 	
 public:
-	DirectSpawner(const SafeLibevPtr &_libev,
-		const ResourceLocator &_resourceLocator,
+	DirectSpawner(const ResourceLocator &_resourceLocator,
 		const ServerInstanceDir::GenerationPtr &_generation,
 		const SpawnerConfigPtr &_config = SpawnerConfigPtr())
-		: Spawner(_resourceLocator),
-		  libev(_libev)
+		: Spawner(_resourceLocator)
 	{
 		generation = _generation;
 		if (_config == NULL) {
@@ -218,7 +214,6 @@ public:
 			
 			NegotiationDetails details;
 			details.preparation = &preparation;
-			details.libev = libev;
 			details.stderrCapturer =
 				make_shared<BackgroundIOCapturer>(
 					errorPipe.first,

data/ext/common/ApplicationPool2/DummySpawner.h

@@ -63,7 +63,7 @@ public:
 		
 		boost::lock_guard<boost::mutex> l(lock);
 		count++;
-		ProcessPtr process = boost::make_shared<Process>(SafeLibevPtr(),
+		ProcessPtr process = boost::make_shared<Process>(
 			(pid_t) count, "gupid-" + toString(count),
 			toString(count),
 			adminSocket.second, FileDescriptor(), sockets,

data/ext/common/ApplicationPool2/Group.h

@@ -425,7 +425,9 @@ public:
 			&& (newOptions.maxRequestQueueSize == 0
 			    || getWaitlist.size() < newOptions.maxRequestQueueSize)))
 		{
-			getWaitlist.push_back(GetWaiter(newOptions.copyAndPersist().clearLogger(), callback));
+			getWaitlist.push_back(GetWaiter(
+				newOptions.copyAndPersist().detachFromUnionStationTransaction(),
+				callback));
 			return true;
 		} else {
 			P_WARN("Request queue is full. Returning an error");
@@ -900,7 +902,7 @@ public:
 		}
 		
 		if (OXT_UNLIKELY(newOptions.noop)) {
-			ProcessPtr process = boost::make_shared<Process>(SafeLibevPtr(),
+			ProcessPtr process = boost::make_shared<Process>(
 				0, string(), string(),
 				FileDescriptor(), FileDescriptor(),
 				SocketListPtr(), 0, 0);

data/ext/common/ApplicationPool2/Options.h

@@ -31,7 +31,8 @@
 #include <boost/shared_array.hpp>
 #include <ApplicationPool2/AppTypes.h>
 #include <Account.h>
-#include <UnionStation.h>
+#include <UnionStation/Core.h>
+#include <UnionStation/Transaction.h>
 #include <Constants.h>
 #include <ResourceLocator.h>
 #include <StaticString.h>
@@ -361,10 +362,11 @@ public:
 	StaticString uri;
 	
 	/**
-	 * A Union Station logger object to log things to. May be the null pointer,
-	 * in which case Union Station logging is disabled for this request.
+	 * The Union Station log transaction that this request belongs to.
+	 * May be the null pointer, in which case Union Station logging is
+	 * disabled for this request.
 	 */
-	UnionStation::LoggerPtr logger;
+	UnionStation::TransactionPtr transaction;
 
 	/**
 	 * A sticky session ID for routing to a specific process.
@@ -529,11 +531,11 @@ public:
 		uri      = StaticString();
 		stickySessionId = 0;
 		noop     = false;
-		return clearLogger();
+		return detachFromUnionStationTransaction();
 	}
 
-	Options &clearLogger() {
-		logger.reset();
+	Options &detachFromUnionStationTransaction() {
+		transaction.reset();
 		return *this;
 	}
 

data/ext/common/ApplicationPool2/Pool.h

@@ -47,7 +47,8 @@
 #include <ApplicationPool2/Session.h>
 #include <ApplicationPool2/SpawnerFactory.h>
 #include <ApplicationPool2/Options.h>
-#include <UnionStation.h>
+#include <UnionStation/Core.h>
+#include <UnionStation/Transaction.h>
 #include <Logging.h>
 #include <Exceptions.h>
 #include <RandomGenerator.h>
@@ -58,6 +59,7 @@
 #include <Utils/MessagePassing.h>
 #include <Utils/VariantMap.h>
 #include <Utils/ProcessMetricsCollector.h>
+#include <Utils/SystemMetricsCollector.h>
 
 namespace Passenger {
 namespace ApplicationPool2 {
@@ -88,9 +90,6 @@ public:
 public:
 	friend class SuperGroup;
 	friend class Group;
-	typedef UnionStation::LoggerFactory LoggerFactory;
-	typedef UnionStation::LoggerFactoryPtr LoggerFactoryPtr;
-	typedef UnionStation::LoggerPtr LoggerPtr;
 
 	struct DebugSupport {
 		/** Mailbox for the unit tests to receive messages on. */
@@ -126,8 +125,10 @@ public:
 	typedef boost::shared_ptr<DebugSupport> DebugSupportPtr;
 
 	SpawnerFactoryPtr spawnerFactory;
-	LoggerFactoryPtr loggerFactory;
+	UnionStation::CorePtr unionStationCore;
 	RandomGeneratorPtr randomGenerator;
+	SystemMetricsCollector systemMetricsCollector;
+	SystemMetrics systemMetrics;
 
 	mutable boost::mutex syncher;
 	unsigned int max;
@@ -730,14 +731,13 @@ public:
 		return sleepTime;
 	}
 
-	struct ProcessAnalyticsLogEntry {
+	struct UnionStationLogEntry {
 		string groupName;
+		const char *category;
 		string key;
-		stringstream data;
+		string data;
 	};
 
-	typedef boost::shared_ptr<ProcessAnalyticsLogEntry> ProcessAnalyticsLogEntryPtr;
-
 	static void collectAnalytics(PoolPtr self) {
 		TRACE_POINT();
 		syscalls::usleep(3000000);
@@ -780,6 +780,43 @@ public:
 		}
 	}
 
+	void prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntries,
+		const GroupPtr &group) const
+	{
+		if (group->options.analytics && unionStationCore != NULL) {
+			logEntries.push_back(UnionStationLogEntry());
+			UnionStationLogEntry &entry = logEntries.back();
+			stringstream stream;
+
+			stream << "Group: <group>";
+			group->inspectXml(stream, false);
+			stream << "</group>";
+
+			entry.groupName = group->name;
+			entry.category  = "processes";
+			entry.key       = group->options.unionStationKey;
+			entry.data      = stream.str();
+		}
+	}
+
+	void prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntries,
+		const GroupPtr &group) const
+	{
+		if (group->options.analytics && unionStationCore != NULL) {
+			logEntries.push_back(UnionStationLogEntry());
+			UnionStationLogEntry &entry = logEntries.back();
+			stringstream stream;
+
+			stream << "System metrics: ";
+			systemMetrics.toXml(stream);
+
+			entry.groupName = group->name;
+			entry.category  = "system_metrics";
+			entry.key       = group->options.unionStationKey;
+			entry.data      = stream.str();
+		}
+	}
+
 	unsigned long long realCollectAnalytics() {
 		TRACE_POINT();
 		this_thread::disable_interruption di;
@@ -813,20 +850,27 @@ public:
 			}
 		}
 		
-		ProcessMetricMap allMetrics;
+		// Collect process metrics and system and store them in the
+		// data structures. Later, we log them to Union Station.
+		ProcessMetricMap processMetrics;
 		try {
-			// Now collect the process metrics and store them in the
-			// data structures, and log the state into the analytics logs.
 			UPDATE_TRACE_POINT();
-			allMetrics = ProcessMetricsCollector().collect(pids);
-		} catch (const ProcessMetricsCollector::ParseException &) {
+			processMetrics = ProcessMetricsCollector().collect(pids);
+		} catch (const ParseException &) {
 			P_WARN("Unable to collect process metrics: cannot parse 'ps' output.");
 			goto end;
 		}
+		try {
+			UPDATE_TRACE_POINT();
+			systemMetricsCollector.collect(systemMetrics);
+		} catch (const RuntimeException &e) {
+			P_WARN("Unable to collect system metrics: " << e.what());
+			goto end;
+		}
 
 		{
 			UPDATE_TRACE_POINT();
-			vector<ProcessAnalyticsLogEntryPtr> logEntries;
+			vector<UnionStationLogEntry> logEntries;
 			vector<ProcessPtr> processesToDetach;
 			vector<Callback> actions;
 			ScopedLock l(syncher);
@@ -840,22 +884,11 @@ public:
 				for (g_it = superGroup->groups.begin(); g_it != g_end; g_it++) {
 					const GroupPtr &group = *g_it;
 
-					updateProcessMetrics(group->enabledProcesses, allMetrics, processesToDetach);
-					updateProcessMetrics(group->disablingProcesses, allMetrics, processesToDetach);
-					updateProcessMetrics(group->disabledProcesses, allMetrics, processesToDetach);
-
-					// Log to Union Station.
-					if (group->options.analytics && loggerFactory != NULL) {
-						ProcessAnalyticsLogEntryPtr entry = boost::make_shared<ProcessAnalyticsLogEntry>();
-						stringstream &xml = entry->data;
-
-						entry->groupName = group->name;
-						entry->key = group->options.unionStationKey;
-						xml << "Group: <group>";
-						group->inspectXml(xml, false);
-						xml << "</group>";
-						logEntries.push_back(entry);
-					}
+					updateProcessMetrics(group->enabledProcesses, processMetrics, processesToDetach);
+					updateProcessMetrics(group->disablingProcesses, processMetrics, processesToDetach);
+					updateProcessMetrics(group->disabledProcesses, processMetrics, processesToDetach);
+					prepareUnionStationProcessStateLogs(logEntries, group);
+					prepareUnionStationSystemMetricsLogs(logEntries, group);
 				}
 			}
 
@@ -869,11 +902,14 @@ public:
 			l.unlock();
 			UPDATE_TRACE_POINT();
 			while (!logEntries.empty()) {
-				ProcessAnalyticsLogEntryPtr entry = logEntries.back();
+				UnionStationLogEntry &entry = logEntries.back();
+				UnionStation::TransactionPtr transaction =
+					unionStationCore->newTransaction(
+						entry.groupName,
+						entry.category,
+						entry.key);
+				transaction->message(entry.data);
 				logEntries.pop_back();
-				LoggerPtr logger = loggerFactory->newTransaction(entry->groupName,
-					"processes", entry->key);
-				logger->message(entry->data.str());
 			}
 
 			UPDATE_TRACE_POINT();
@@ -923,19 +959,25 @@ public:
 	
 public:
 	Pool(const SpawnerFactoryPtr &spawnerFactory,
-		const LoggerFactoryPtr &loggerFactory = LoggerFactoryPtr(),
+		const UnionStation::CorePtr &unionStationCore = UnionStation::CorePtr(),
 		const RandomGeneratorPtr &randomGenerator = RandomGeneratorPtr(),
 		const VariantMap *agentsOptions = NULL)
 	{
 		this->spawnerFactory = spawnerFactory;
-		this->loggerFactory = loggerFactory;
+		this->unionStationCore = unionStationCore;
 		if (randomGenerator != NULL) {
 			this->randomGenerator = randomGenerator;
 		} else {
 			this->randomGenerator = boost::make_shared<RandomGenerator>();
 		}
 		this->agentsOptions = agentsOptions;
-		
+
+		try {
+			systemMetricsCollector.collect(systemMetrics);
+		} catch (const RuntimeException &e) {
+			P_WARN("Unable to collect system metrics: " << e.what());
+		}
+
 		lifeStatus  = ALIVE;
 		max         = 6;
 		maxIdleTime = 60 * 1000000;
@@ -1075,7 +1117,7 @@ public:
 				 */
 				P_DEBUG("Could not free a process; putting request to top-level getWaitlist");
 				getWaitlist.push_back(GetWaiter(
-					options.copyAndPersist().clearLogger(),
+					options.copyAndPersist().detachFromUnionStationTransaction(),
 					callback));
 			} else {
 				/* Now that a process has been trashed we can create
@@ -1538,8 +1580,9 @@ public:
 		ProcessList::const_iterator p_it;
 
 		result << "<?xml version=\"1.0\" encoding=\"iso8859-1\" ?>\n";
-		result << "<info version=\"2\">";
+		result << "<info version=\"3\">";
 		
+		result << "<passenger_version>" << PASSENGER_VERSION << "</passenger_version>";
 		result << "<process_count>" << getProcessCount(false) << "</process_count>";
 		result << "<max>" << max << "</max>";
 		result << "<capacity_used>" << capacityUsed(false) << "</capacity_used>";

data/ext/common/ApplicationPool2/Process.h

@@ -41,7 +41,6 @@
 #include <ApplicationPool2/PipeWatcher.h>
 #include <Constants.h>
 #include <FileDescriptor.h>
-#include <SafeLibev.h>
 #include <Logging.h>
 #include <Utils/PriorityQueue.h>
 #include <Utils/SystemTime.h>
@@ -209,8 +208,6 @@ public:
 	 * written to again. Reading is thread-safe.
 	 *************************************************************/
 	
-	/** The libev event loop to use. */
-	SafeLibev * const libev;
 	/** Process PID. */
 	pid_t pid;
 	/** An ID that uniquely identifies this Process in the Group, for
@@ -323,8 +320,7 @@ public:
 	/** Collected by Pool::collectAnalytics(). */
 	ProcessMetrics metrics;
 	
-	Process(const SafeLibevPtr _libev,
-		pid_t _pid,
+	Process(pid_t _pid,
 		const string &_gupid,
 		const string &_connectPassword,
 		const FileDescriptor &_adminSocket,
@@ -338,7 +334,6 @@ public:
 		unsigned long long _spawnStartTime,
 		const SpawnerConfigPtr &_config = SpawnerConfigPtr())
 		: pqHandle(NULL),
-		  libev(_libev.get()),
 		  pid(_pid),
 		  stickySessionId(0),
 		  gupid(_gupid),
@@ -646,6 +641,7 @@ public:
 		stream << "<spawn_start_time>" << spawnStartTime << "</spawn_start_time>";
 		stream << "<spawn_end_time>" << spawnEndTime << "</spawn_end_time>";
 		stream << "<last_used>" << lastUsed << "</last_used>";
+		stream << "<last_used_desc>" << distanceOfTimeInWords(lastUsed / 1000000).c_str() << " ago</last_used_desc>";
 		stream << "<uptime>" << uptime() << "</uptime>";
 		if (!codeRevision.empty()) {
 			stream << "<code_revision>" << codeRevision << "</code_revision>";

data/ext/common/ApplicationPool2/README.md

@@ -54,43 +54,3 @@ The `Pool` class's `get` method is the main interface into the ApplicationPool2
 subsystem. When an HTTP request comes in, call `Pool::get()` with the
 appropriate arguments, and it will automatically spawn a process for you when
 needed, open a session with that process and give you the session object.
-
-
-## Threading notes
-
-ApplicationPool2 depends on an event loop for handling timers and I/O. The I/O
-that it handles is not the request/response I/O with application processes, but
-things like forwarding the processes' stderr output to our stderr. In order not
-to block the event loop with long-running operations, it uses a lot of
-background threads. ApplicationPool2 is designed to be entirely thread-safe.
-That said, if one's not careful, one may cause deadlocks, so read this section
-carefully.
-
-* Many Spawner methods are blocking because they wait for a subprocess to do
-  something (initializing, shutting down, etc). The process may output I/O
-  which is supposed to be handled by the main loop. If the event loop is blocked
-  on waiting for the process, and the process is blocked on a write() to the I/O
-  channel, then we have a deadlock. Therefore Spawner methods (including the
-  Spawner destructor) must always be called outside the event loop thread, and
-  the event loop must be available while the Spawner is doing its work. The only
-  exceptions are Spawner methods which are explicitly documented as not
-  depending on the event loop.
-
-  Pool must only call Spawner methods from background threads. There's still a
-  caveat though: Pool's destructor waits for all background threads to finish.
-  Therefore one must not destroy Pool from the event loop. Instead, I recommend
-  running the event loop in a separate thread, destroy Pool from the main
-  thread, and stop the event loop after Pool is destroyed.
-
-  Calling other Pool methods from the event loop is ok. Calling SpawnerFactory
-  from the event loop is ok.
-
-* Many classes contain libev watchers and unregisters them in their destructor.
-  In order for this unregistration to succeed, one of the following conditions
-  must hold:
-  1. The destructor is called from the event loop.
-  2. The destructor is not called from the event loop, but the event loop is
-     still running.
-
-  Therefore I recommend that you destroy all ApplicationPool2-related objects
-  before stopping the event loop thread.