passenger 4.0.42 → 4.0.43

data/ext/common/Utils/StrIntUtils.cpp

@@ -439,6 +439,12 @@ distanceOfTimeInWords(time_t fromTime, time_t toTime) {
 		time_t minutes = seconds / 60;
 		if (minutes >= 60) {
 			time_t hours = minutes / 60;
+			if (hours >= 24) {
+				time_t days = hours / 24;
+				hours = hours % 24;
+				result << days << "d ";
+			}
+
 			minutes = minutes % 60;
 			result << hours << "h ";
 		}

data/ext/common/Utils/StringScanning.h

@@ -0,0 +1,277 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013-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.
+ */
+#ifndef _PASSENGER_STRING_SCANNING_H_
+#define _PASSENGER_STRING_SCANNING_H_
+
+#include <cstring>
+#include <cstdlib>
+#include <string>
+#include <StaticString.h>
+
+
+/**
+ * Utility functions for scanning strings. Given a pointer to string data,
+ * these functions can read or skip parts of it and advance the pointer.
+ * Especially useful for parsing the output of command line tools.
+ *
+ *     const char *data = "hello world 1234";
+ *
+ *     readNextWord(&data);       // => "hello"
+ *     printf("%s\n", data);      // => " world 1234"
+ *
+ *     readNextWord(&data);       // => "world"
+ *     printf("%s\n", data);      // => " 1234"
+ *
+ *     readNextWordAsInt(&data);  // => 1234
+ *     printf("%s\n", data);      // => ""
+ *
+ *     readNextWord(&data);       // => ParseException,
+ *                                //    because end has been reached
+ */
+
+
+namespace Passenger {
+
+using namespace std;
+
+struct ParseException {};
+
+inline void
+_skipLeadingWhitespaces(const char **data) {
+	while (**data == ' ') {
+		(*data)++;
+	}
+}
+
+/**
+ * Scan the given data for the first word that appears on the first line.
+ * Leading whitespaces (but not newlines) are ignored. If a word is found
+ * then the word is returned and the data pointer is moved to the end of
+ * the word.
+ * 
+ * If the first line only contains whitespaces, or if the first line is empty,
+ * then a ParseException is thrown.
+ *
+ * @post result.size() > 0
+ */
+inline StaticString
+readNextWord(const char **data) {
+	_skipLeadingWhitespaces(data);
+	if (**data == '\n' || **data == '\0') {
+		throw ParseException();
+	}
+	
+	// Find end of word and extract the word.
+	const char *endOfWord = *data;
+	while (*endOfWord != ' ' && *endOfWord != '\n' && *endOfWord != '\0') {
+		endOfWord++;
+	}
+	StaticString result(*data, endOfWord - *data);
+	
+	// Move data pointer to the end of this word.
+	*data = endOfWord;
+	return result;
+}
+
+inline long long
+_processNextWordAsLongLong(const StaticString &word, char *nullTerminatedWord) {
+	memcpy(nullTerminatedWord, word.c_str(), word.size());
+	nullTerminatedWord[word.size()] = '\0';
+	if (*nullTerminatedWord == '\0') {
+		throw ParseException();
+	} else {
+		return atoll(nullTerminatedWord);
+	}
+}
+
+/**
+ * Scan the given data for the first word that appears on the first line.
+ * Leading whitespaces (but not newlines) are ignored. If a word is found
+ * then the word is parsed as a 'long long' number and returned, and the
+ * data pointer is moved to the end of the word.
+ *
+ * If the first line only contains whitespaces, or if the first line is empty,
+ * then a ParseException is thrown.
+ */
+inline long long
+readNextWordAsLongLong(const char **data) {
+	StaticString word = readNextWord(data);
+	if (word.size() < 50) {
+		char nullTerminatedWord[50];
+		return _processNextWordAsLongLong(word, nullTerminatedWord);
+	} else {
+		string nullTerminatedWord(word.size() + 1, '\0');
+		return _processNextWordAsLongLong(word, &nullTerminatedWord[0]);
+	}
+}
+
+inline int
+_processNextWordAsInt(const StaticString &word, char *nullTerminatedWord) {
+	memcpy(nullTerminatedWord, word.c_str(), word.size());
+	nullTerminatedWord[word.size()] = '\0';
+	if (*nullTerminatedWord == '\0') {
+		throw ParseException();
+	} else {
+		return atoi(nullTerminatedWord);
+	}
+}
+
+/**
+ * Scan the given data for the first word that appears on the first line.
+ * Leading whitespaces (but not newlines) are ignored. If a word is found
+ * then the word is parsed as an 'int' number and returned, and the
+ * data pointer is moved to the end of the word.
+ *
+ * If the first line only contains whitespaces, or if the first line is empty,
+ * then a ParseException is thrown.
+ */
+inline int
+readNextWordAsInt(const char **data) {
+	StaticString word = readNextWord(data);
+	if (word.size() < 50) {
+		char nullTerminatedWord[50];
+		return _processNextWordAsInt(word, nullTerminatedWord);
+	} else {
+		string nullTerminatedWord(word.size() + 1, '\0');
+		return _processNextWordAsInt(word, &nullTerminatedWord[0]);
+	}
+}
+
+inline double
+_processNextWordAsDouble(const StaticString &word, char *nullTerminatedWord) {
+	memcpy(nullTerminatedWord, word.c_str(), word.size());
+	nullTerminatedWord[word.size()] = '\0';
+	if (*nullTerminatedWord == '\0') {
+		throw ParseException();
+	} else {
+		return atof(nullTerminatedWord);
+	}
+}
+
+/**
+ * Scan the given data for the first word that appears on the first line.
+ * Leading whitespaces (but not newlines) are ignored. If a word is found
+ * then the word is parsed as an 'double' number and returned, and the
+ * data pointer is moved to the end of the word.
+ *
+ * If the first line only contains whitespaces, or if the first line is empty,
+ * then a ParseException is thrown.
+ */
+inline double
+readNextWordAsDouble(const char **data) {
+	StaticString word = readNextWord(data);
+	if (word.size() < 50) {
+		char nullTerminatedWord[50];
+		return _processNextWordAsDouble(word, nullTerminatedWord);
+	} else {
+		string nullTerminatedWord(word.size() + 1, '\0');
+		return _processNextWordAsDouble(word, &nullTerminatedWord[0]);
+	}
+}
+
+/**
+ * Return the first line in the given data, excluding leading and trailing
+ * whitespaces, and excluding newline. If the first line only contains
+ * whitespaces or if the first line is empty, then the empty string is
+ * returned.
+ *
+ * If the data does not contain a newline, then a ParseException is thrown.
+ */
+inline string
+readRestOfLine(const char *data) {
+	_skipLeadingWhitespaces(&data);
+	// Rest of line is allowed to be empty.
+	if (*data == '\n' || *data == '\0') {
+		return "";
+	}
+	
+	// Look for newline character. From there, scan back until we've
+	// found a non-whitespace character.
+	const char *endOfLine = strchr(data, '\n');
+	if (endOfLine == NULL) {
+		throw ParseException();
+	}
+	while (*(endOfLine - 1) == ' ') {
+		endOfLine--;
+	}
+	
+	return string(data, endOfLine - data);
+}
+
+inline bool
+skipToNextLine(const char **data) {
+	const char *pos = strchr(*data, '\n');
+	if (pos != NULL) {
+		pos++;
+		*data = pos;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+/**
+ * Extract the first sentence from the first line in the data, where the end
+ * of the sentence is dictated by the `terminator` argument.
+ * Leading whitespaces (but not newlines) are ignored. The sentence is returned
+ * and the data pointer is moved to 1 character past the terminator.
+ *
+ * The terminator may not be '\n' or '\0'.
+ *
+ * A ParseException is thrown if one of the following conditions are encountered:
+ *
+ *  * The first line only contains whitespaces.
+ *  * The first line is empty.
+ *  * The read sentence is empty.
+ *  * The terminator character is not found.
+ *
+ * @post result.size() > 0
+ */
+inline StaticString
+readNextSentence(const char **data, char terminator) {
+	_skipLeadingWhitespaces(data);
+	if (**data == '\n' || **data == '\0' || **data == terminator) {
+		throw ParseException();
+	}
+
+	// Find end of sentence and extract the sentence.
+	const char *endOfSentence = *data;
+	do {
+		endOfSentence++;
+	} while (*endOfSentence != terminator && *endOfSentence != '\n' && *endOfSentence != '\0');
+
+	if (*endOfSentence == terminator) {
+		StaticString result(*data, endOfSentence - *data);
+		// Move data pointer 1 character past the terminator.
+		*data = endOfSentence + 1;
+		return result;
+	} else {
+		throw ParseException();
+	}
+}
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_STRING_SCANNING_H_ */

data/ext/common/Utils/SystemMetricsCollector.h

@@ -0,0 +1,1460 @@
+/*
+ *  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.
+ */
+#ifndef _PASSENGER_SYSTEM_METRICS_COLLECTOR_H_
+#define _PASSENGER_SYSTEM_METRICS_COLLECTOR_H_
+
+#include <boost/cstdint.hpp>
+#include <boost/thread.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <ostream>
+#include <iomanip>
+#include <algorithm>
+#include <limits>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include <cstdlib>
+#include <climits>
+#include <cmath>
+#include <ctime>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#ifdef __linux__
+	#include <sys/sysinfo.h>
+	#include <Exceptions.h>
+	#include <Utils/StringScanning.h>
+	#include <Utils/SpeedMeter.h>
+	#include <Utils/IOUtils.h>
+#endif
+#ifdef __APPLE__
+	#include <mach/mach.h>
+	#include <sys/sysctl.h>
+	#include <sys/time.h>
+#endif
+#ifdef __FreeBSD__
+	#include <sys/param.h>
+	#include <sys/pcpu.h>
+	#include <sys/sysctl.h>
+	#include <sys/resource.h>
+	#include <vm/vm_param.h>
+#endif
+#include <unistd.h>
+#include <stdlib.h>
+#include <Constants.h>
+#include <StaticString.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/SystemTime.h>
+#include <Utils/AnsiColorConstants.h>
+
+/*
+ * Useful resources
+ *
+ * OS X:
+ * http://www.opensource.apple.com/source/system_cmds/system_cmds-496/iostat.tproj/iostat.c
+ * https://github.com/max-horvath/htop-osx
+ * https://github.com/malkia/busybox-osx/blob/master/procps/iostat.c
+ *
+ * Linux:
+ * http://procps.cvs.sourceforge.net/viewvc/procps/procps/
+ * https://github.com/sysstat/sysstat/blob/master/mpstat.c
+ * http://www.thomas-krenn.com/en/wiki/Linux_Performance_Measurements_using_vmstat
+ * http://man7.org/linux/man-pages/man5/proc.5.html
+ *
+ * FreeBSD:
+ * https://github.com/freebsd/freebsd/blob/master/usr.bin/vmstat/vmstat.c
+ * https://github.com/freebsd/freebsd/blob/master/sbin/swapon/swapon.c
+ * http://stuff.mit.edu/afs/sipb/project/freebsd/head/contrib/top/machine.h
+ */
+
+namespace Passenger {
+
+using namespace boost;
+using namespace std;
+
+class SystemMetricsCollector;
+
+/** All memory sizes are in KB. */
+class SystemMetrics {
+public:
+	struct DescriptionOptions {
+		bool general;
+		bool cpu;
+		bool memory;
+		bool colors;
+
+		DescriptionOptions()
+			: general(true),
+			  cpu(true),
+			  memory(true),
+			  colors(false)
+			{ }
+	};
+
+	struct XmlOptions {
+		bool general;
+		bool cpu;
+		bool memory;
+
+		XmlOptions()
+			: general(true),
+			  cpu(true),
+			  memory(true)
+			{ }
+	};
+
+private:
+	friend class SystemMetricsCollector;
+
+	#ifdef __linux__
+		SpeedMeter<unsigned long long, 8, 1000000, 60 * 1000000, 1000000> forkRateSpeedMeter;
+		SpeedMeter<size_t, 8, 1000000, 60 * 1000000, 1000000> swapInSpeedMeter, swapOutSpeedMeter;
+	#endif
+
+	double divideTotalCpuUsageByNCpus(double total) const {
+		if (ncpus() == 0) {
+			return -1;
+		} else {
+			total /= ncpus();
+			if (total > 100) {
+				return 100;
+			} else {
+				return total;
+			}
+		}
+	}
+
+	void outputHeader(ostream &stream, const DescriptionOptions &options,
+		const char *label) const
+	{
+		if (options.colors) {
+			stream << ANSI_COLOR_BLUE_BG ANSI_COLOR_BOLD ANSI_COLOR_YELLOW;
+		}
+		stream << "------------- " << label << " -------------";
+		if (options.colors) {
+			stream << ANSI_COLOR_RESET;
+		}
+		stream << endl;
+	}
+
+	string formatWidth(const string &str, int width) const {
+		char buf[128];
+		snprintf(buf, sizeof(buf), "%*s", width, str.c_str());
+		return buf;
+	}
+
+	string maybeColorAfterThreshold(const DescriptionOptions &options, const string &str,
+		double value, double threshold) const
+	{
+		if (value >= threshold && options.colors) {
+			return string(ANSI_COLOR_BOLD) + str + ANSI_COLOR_RESET;
+		} else {
+			return str;
+		}
+	}
+
+	string formatPercent(const DescriptionOptions &options, double percent,
+		int precision, int width, double threshold) const
+	{
+		string result;
+
+		if (percent == -2) {
+			if (options.colors) {
+				return string(ANSI_COLOR_DGRAY)
+					+ formatWidth("unsupported by OS", width)
+					+ ANSI_COLOR_RESET;
+			} else {
+				return formatWidth("unsupported by OS", width);
+			}
+		} else if (percent == -1) {
+			if (options.colors) {
+				return string(ANSI_COLOR_RED)
+					+ formatWidth("?", width)
+					+ ANSI_COLOR_RESET;
+			} else {
+				return formatWidth("?", width);
+			}
+		} else {
+			char buf[64];
+			snprintf(buf, sizeof(buf), "%.*f%%", precision, percent);
+			return maybeColorAfterThreshold(options, formatWidth(buf, width),
+				percent, threshold);
+		}
+	}
+
+	string formatPercent0(const DescriptionOptions &options, double percent,
+		int width = -1, double threshold = numeric_limits<double>::infinity()) const
+	{
+		return formatPercent(options, percent, 0, width, threshold);
+	}
+
+	string formatPercent2(const DescriptionOptions &options, double percent,
+		int width = -1, double threshold = -10) const
+	{
+		return formatPercent(options, percent, 2, width, threshold);
+	}
+
+	string kbToMb(ssize_t size) const {
+		if (size < 0) {
+			return "?";
+		} else {
+			char buf[32];
+			snprintf(buf, sizeof(buf), "%lld", (long long) size / 1024);
+			return buf;
+		}
+	}
+
+public:
+	class CpuUsage {
+	private:
+		friend class SystemMetricsCollector;
+
+		unsigned long long lastUserTicks;
+		unsigned long long lastNiceTicks;
+		unsigned long long lastSystemTicks;
+		unsigned long long lastIoWaitTicks;
+		unsigned long long lastIdleTicks;
+		unsigned long long lastStealTicks;
+
+		/** Current usage statistics for this CPU.
+		 *
+		 * userUsage, niceUsage, systemUsage and idleUsage are fractions
+		 * of user + nice + system + idle.
+		 * 
+		 * ioWaitUsage is a fraction of user + nice + system + idle + iowait.
+		 *
+		 * stealUsage is a fraction of user + nice + system + idle + steal.
+		 *
+		 * All fractions range from 0 (unutilized) to SHRT_MAX (fully utilized).
+		 * Use the *Pct() methods to convert them to percentages.
+		 * 
+		 * Each statistic can individually be -1 if an error occurred while querying
+		 * it, or -2 if the OS doesn't support it.
+		 */
+		short userUsage, niceUsage, systemUsage;
+		short ioWaitUsage, idleUsage, stealUsage;
+
+		double fracToPercentage(short usage) const {
+			if (usage < 0) {
+				return usage;
+			} else {
+				return (double) usage / SHRT_MAX * 100.0;
+			}
+		}
+
+	public:
+		CpuUsage()
+			: lastUserTicks(0),
+			  lastNiceTicks(0),
+			  lastSystemTicks(0),
+			  lastIoWaitTicks(0),
+			  lastIdleTicks(0),
+			  lastStealTicks(0),
+			  userUsage(-1),
+			  niceUsage(-1),
+			  systemUsage(-1),
+			  ioWaitUsage(-1),
+			  idleUsage(-1),
+			  stealUsage(-1)
+			{ }
+
+		/** These methods return the usage statistics as percentages (0..100) */
+
+		double userPct() const {
+			return fracToPercentage(userUsage);
+		}
+
+		double nicePct() const {
+			return fracToPercentage(niceUsage);
+		}
+
+		double systemPct() const {
+			return fracToPercentage(systemUsage);
+		}
+
+		double ioWaitPct() const {
+			return fracToPercentage(ioWaitUsage);
+		}
+
+		double idlePct() const {
+			return fracToPercentage(idleUsage);
+		}
+
+		double stealPct() const {
+			return fracToPercentage(stealUsage);
+		}
+
+		/** Returns this CPU's usage as a percentage (0..100),
+		 * or -1 if it cannot be determined.
+		 */
+		double usage() const {
+			if (userUsage < 0 || niceUsage < 0 || systemUsage < 0) {
+				return -1;
+			} else {
+				return userPct() + nicePct() + systemPct();
+			}
+		}
+	};
+
+	/** Per-core CPU usage. This collection is empty if the number of cores
+	 * cannot be queried.
+	 */
+	vector<CpuUsage> cpuUsages;
+
+	/** Total system physical RAM. -1 if this information cannot be queried. */
+	ssize_t ramTotal;
+	/** Amount of RAM used. Does not include kernel caches and buffers. -1
+	 * if this information cannot be queried.
+	 */
+	ssize_t ramUsed;
+	/** Total system swap space, or -1 if this information cannot be queried. */
+	ssize_t swapTotal;
+	/** Amount of swap space used, or -1 if this information cannot be queried. */
+	ssize_t swapUsed;
+
+	/** Load averages for the past 1, 5 and 15 minutes. Can each individually be -1
+	 * if that particular statistic cannot be queried.
+	 */
+	double loadAverage1;
+	double loadAverage5;
+	double loadAverage15;
+
+	/** Time at which the system booted. -1 if this information cannot be queried. */
+	time_t boottime;
+
+	/** Speed at which processes are created per second.
+	 * NaN if it's not yet known (because too few samples have been taken so far).
+	 * -1 if there was an error querying this information.
+	 * -2 if the OS does not support this metric.
+	 */
+	double forkRate;
+	/** Speed at which the OS swaps in and swaps out data, in KB/sec.
+	 * NaN if it's not yet known (because too few samples have been taken so far).
+	 * -1 if there was an error querying this information.
+	 * -2 if the OS does not support this metric.
+	 */
+	double swapInRate, swapOutRate;
+
+	/** Kernel version number, or the empty string if this information cannot be queried. */
+	string kernelVersion;
+
+	SystemMetrics()
+		:
+		  #ifdef __linux__
+		      forkRateSpeedMeter(),
+		      swapInSpeedMeter(),
+		      swapOutSpeedMeter(),
+		  #endif
+		  ramTotal(-1),
+		  ramUsed(-1),
+		  swapTotal(-1),
+		  swapUsed(-1),
+		  loadAverage1(-1),
+		  loadAverage5(-1),
+		  loadAverage15(-1),
+		  boottime(-1),
+		  forkRate(-2),
+		  swapInRate(-2),
+		  swapOutRate(-2)
+		{ }
+
+	unsigned int ncpus() const {
+		return cpuUsages.size();
+	}
+
+	/** The following methods calculate the current average system CPU usage
+	 * statistics. Ranges from 0 (no cores are being used) to 100 (all cores
+	 * at full utilization). Return -1 if the information cannot be queried.
+	 */
+
+	double avgUserCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->userPct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgNiceCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->nicePct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgSystemCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->systemPct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgIoWaitCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->ioWaitPct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgIdleCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->idlePct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgStealCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->stealPct();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	double avgCpuUsage() const {
+		BOOST_AUTO(it, cpuUsages.begin());
+		BOOST_AUTO(end, cpuUsages.end());
+		double total = 0;
+
+		for (; it != end; it++) {
+			double val = it->usage();
+			if (val < 0) {
+				return val;
+			} else {
+				total += val;
+			}
+		}
+		return divideTotalCpuUsageByNCpus(total);
+	}
+
+	ssize_t ramFree() const {
+		if (ramTotal == -1 || ramUsed == -1) {
+			return -1;
+		} else {
+			return ramTotal - ramUsed;
+		}
+	}
+
+	ssize_t swapFree() const {
+		if (swapTotal == -1 || swapUsed == -1) {
+			return -1;
+		} else {
+			return swapTotal - swapUsed;
+		}
+	}
+
+	void toDescription(ostream &stream, const DescriptionOptions &options = DescriptionOptions()) const {
+		char buf[1024];
+		stream << std::right << std::setfill(' ');
+
+		if (options.general) {
+			outputHeader(stream, options, "General");
+			stream << "Kernel version    : " << kernelVersion << endl;
+			stream << "Uptime            : " << distanceOfTimeInWords(boottime) << endl;
+
+			stream << "Load averages     : ";
+			stream << formatPercent2(options, loadAverage1, 5, 2);
+			stream << ", ";
+			stream << formatPercent2(options, loadAverage5, 5, 2);
+			stream << ", ";
+			stream << formatPercent2(options, loadAverage15, 5, 2);
+			stream << endl;
+
+			if (forkRate != -2) {
+				stream << "Fork rate         : ";
+				if (std::isnan(forkRate) || forkRate < 0) {
+					if (options.colors) {
+						stream << ANSI_COLOR_DGRAY;
+					}
+					stream << "unknown";
+					if (options.colors) {
+						stream << ANSI_COLOR_RESET;
+					}
+				} else {
+					char buf[32];
+
+					snprintf(buf, sizeof(buf), "%.1f", forkRate);
+					stream << buf << "/sec";
+				}
+				stream << endl;
+			}
+
+			stream << endl;
+		}
+
+		if (options.cpu) {
+			double tmp;
+
+			outputHeader(stream, options, "CPU");
+			if (ncpus() == 0) {
+				stream << "Number of CPUs    : unknown" << endl;
+			} else {
+				snprintf(buf, sizeof(buf), "%4u", ncpus());
+				stream << "Number of CPUs    : " << buf << endl;
+				stream << "Average CPU usage : ";
+				stream << formatPercent0(options, avgCpuUsage(), 4, 95);
+				stream << "  -- ";
+				stream << formatPercent0(options, avgUserCpuUsage(), 4, 95);
+				stream << " user, ";
+				stream << formatPercent0(options, avgNiceCpuUsage(), 4, 95);
+				stream << " nice, ";
+				stream << formatPercent0(options, avgSystemCpuUsage(), 4, 95);
+				stream << " system, ";
+				stream << formatPercent0(options, avgIdleCpuUsage(), 4);
+				stream << " idle" << endl;
+			}
+
+			for (unsigned i = 0; i < ncpus(); i++) {
+				snprintf(buf, sizeof(buf),
+					"  CPU %-2u          : ",
+					i + 1);
+				stream << buf;
+				stream << formatPercent0(options, cpuUsages[i].usage(), 4, 95);
+				stream << "  -- ";
+				stream << formatPercent0(options, cpuUsages[i].userPct(), 4, 95);
+				stream << " user, ";
+				stream << formatPercent0(options, cpuUsages[i].nicePct(), 4, 95);
+				stream << " nice, ";
+				stream << formatPercent0(options, cpuUsages[i].systemPct(), 4, 95);
+				stream << " system, ";
+				stream << formatPercent0(options, cpuUsages[i].idlePct(), 4);
+				stream << " idle" << endl;
+			}
+
+			// For the two average metrics below, if a metric is unsupported by the OS (-2)
+			// then that implies that it's unsupported for all individual CPUs, so we
+			// don't bother printing CPU-specific metrics.
+			// But if an average metric is merely errored (-1), then it's still
+			// possible that we succeeded in querying the metric for a specific CPU.
+
+			tmp = avgIoWaitCpuUsage();
+			if (tmp != -2) {
+				stream << "I/O pressure      : ";
+				stream << formatPercent0(options, avgIoWaitCpuUsage(), 4, 95);
+				stream << endl;
+				for (unsigned i = 0; i < ncpus(); i++) {
+					snprintf(buf, sizeof(buf),
+						"  CPU %-2u          : %s",
+						i + 1,
+						formatPercent0(options, cpuUsages[i].ioWaitPct(), 4, 95).c_str());
+					stream << buf << endl;
+				}
+			}
+
+			tmp = avgStealCpuUsage();
+			if (tmp != -2) {
+				stream << "Interference from other VMs: ";
+				stream << formatPercent0(options, tmp, 4, 20);
+				stream << endl;
+				for (unsigned i = 0; i < ncpus(); i++) {
+					snprintf(buf, sizeof(buf),
+						"  CPU %-2u                   : %s",
+						i + 1,
+						formatPercent0(options, cpuUsages[i].stealPct(), 4, 35).c_str());
+					stream << buf << endl;
+				}
+			}
+
+			stream << endl;
+		}
+
+		if (options.memory) {
+			double ramUsedPct = ramUsed / (double) ramTotal * 100;
+			double swapUsedPct = swapUsed / (double) swapTotal * 100;
+			outputHeader(stream, options, "Memory");
+			stream << "RAM total         : " << formatWidth(kbToMb(ramTotal), 6) << " MB" << endl;
+			stream << "RAM used          : " << formatWidth(kbToMb(ramUsed), 6) << " MB ("
+				<< formatPercent0(options, ramUsedPct, 1, 90) << ")" << endl;
+			stream << "RAM free          : " << formatWidth(kbToMb(ramFree()), 6) << " MB" << endl;
+			stream << "Swap total        : " << formatWidth(kbToMb(swapTotal), 6) << " MB" << endl;
+			stream << "Swap used         : " << formatWidth(kbToMb(swapUsed), 6) << " MB ("
+				<< formatPercent0(options, swapUsedPct, 1, 90) << ")" << endl;
+			stream << "Swap free         : " << formatWidth(kbToMb(swapFree()), 6) << " MB" << endl;
+
+			if (swapInRate != -2) {
+				stream << "Swap in           : ";
+				if (std::isnan(swapInRate) || swapInRate < 0) {
+					if (options.colors) {
+						stream << ANSI_COLOR_DGRAY;
+					}
+					stream << "unknown";
+					if (options.colors) {
+						stream << ANSI_COLOR_RESET;
+					}
+				} else {
+					char buf[32];
+
+					snprintf(buf, sizeof(buf), "%.1f", swapInRate / 1024);
+					stream << maybeColorAfterThreshold(options, buf, swapInRate / 1024, 2);
+					stream << " MB/sec";
+				}
+				stream << endl;
+			}
+
+			if (swapOutRate != -2) {
+				stream << "Swap out          : ";
+				if (std::isnan(swapOutRate) || swapOutRate < 0) {
+					if (options.colors) {
+						stream << ANSI_COLOR_DGRAY;
+					}
+					stream << "unknown";
+					if (options.colors) {
+						stream << ANSI_COLOR_RESET;
+					}
+				} else {
+					char buf[32];
+
+					snprintf(buf, sizeof(buf), "%.1f", swapOutRate / 1024);
+					stream << maybeColorAfterThreshold(options, buf, swapOutRate / 1024, 2);
+					stream << " MB/sec";
+				}
+				stream << endl;
+			}
+
+			stream << endl;
+		}
+	}
+
+	void toXml(ostream &stream, const XmlOptions &options = XmlOptions()) const {
+		time_t timestamp = SystemTime::get();
+		stream << std::fixed << std::setprecision(2);
+		stream << "<system_metrics version=\"1.0\">";
+
+		if (options.general) {
+			stream << "<general>";
+			stream << "<current_time>";
+				stream << "<localtime>" << strip(std::ctime(&timestamp)) << "</localtime>";
+				stream << "<timestamp>" << timestamp << "</timestamp>";
+			stream << "</current_time>";
+			stream << "<passenger_version>" PASSENGER_VERSION "</passenger_version>";
+			stream << "<kernel_version>" << kernelVersion << "</kernel_version>";
+			stream << "<boottime>";
+				stream << "<localtime>" << strip(std::ctime(&boottime)) << "</localtime>";
+				stream << "<timestamp>" << boottime << "</timestamp>";
+			stream << "</boottime>";
+			stream << "<uptime>";
+				stream << "<seconds>" << timestamp - boottime << "</seconds>";
+				stream << "<description>" << distanceOfTimeInWords(boottime) << "</description>";
+			stream << "</uptime>";
+			stream << "<load_averages>";
+				stream << "<one>" << loadAverage1 << "</one>";
+				stream << "<five>" << loadAverage5 << "</five>";
+				stream << "<fifteen>" << loadAverage15 << "</fifteen>";
+			stream << "</load_averages>";
+			stream << "<fork_rate>" << forkRate << "</fork_rate>";
+			stream << "</general>";
+		}
+
+		if (options.cpu) {
+			stream << "<cpu_metrics>";
+			stream << "<ncpus>" << (int) ncpus() << "</ncpus>";
+			if (ncpus() != 0) {
+				stream << "<average>";
+					stream << "<usage>" << avgCpuUsage() << "</usage>";
+					stream << "<user>" << avgUserCpuUsage() << "</user>";
+					stream << "<nice>" << avgNiceCpuUsage() << "</nice>";
+					stream << "<system>" << avgSystemCpuUsage() << "</system>";
+					stream << "<iowait>" << avgIoWaitCpuUsage() << "</iowait>";
+					stream << "<idle>" << avgIdleCpuUsage() << "</idle>";
+					stream << "<steal>" << avgStealCpuUsage() << "</steal>";
+				stream << "</average>";
+			}
+			stream << "<cpus>";
+			for (unsigned i = 0; i < ncpus(); i++) {
+				const CpuUsage &cpuUsage = cpuUsages[i];
+				stream << "<cpu>";
+				stream << "<number>" << i + 1 << "</number>";
+				stream << "<usage>" << cpuUsage.usage() << "</usage>";
+				stream << "<user>" << cpuUsage.userPct() << "</user>";
+				stream << "<nice>" << cpuUsage.nicePct() << "</nice>";
+				stream << "<system>" << cpuUsage.systemPct() << "</system>";
+				stream << "<io_wait>" << cpuUsage.ioWaitPct() << "</io_wait>";
+				stream << "<idle>" << cpuUsage.idlePct() << "</idle>";
+				stream << "<steal>" << cpuUsage.stealPct() << "</steal>";
+				stream << "</cpu>";
+			}
+			stream << "</cpus>";
+			stream << "</cpu_metrics>";
+		}
+
+		if (options.memory) {
+			stream << "<memory_metrics>";
+			stream << "<ram_total>" << ramTotal << "</ram_total>";
+			stream << "<ram_used>" << ramUsed << "</ram_used>";
+			stream << "<ram_free>" << ramFree() << "</ram_free>";
+			stream << "<swap_total>" << swapTotal << "</swap_total>";
+			stream << "<swap_used>" << swapUsed << "</swap_used>";
+			stream << "<swap_free>" << swapFree() << "</swap_free>";
+			stream << "<swap_in_rate>" << swapInRate << "</swap_in_rate>";
+			stream << "<swap_out_rate>" << swapOutRate << "</swap_out_rate>";
+			stream << "</memory_metrics>";
+		}
+
+		stream << "</system_metrics>";
+	}
+};
+
+/**
+ * Utility class for collection system metrics, such as system CPU usage,
+ * amount of memory available and free, etc.
+ *
+ *     SystemMetrics metrics;
+ *     SystemMetricsCollector collector;
+ *
+ *     collector.collect(metrics);  // => metrics are now available
+ *     sleep(1);
+ *     collector.collect(metrics);  // => metrics have been updated
+ *
+ * Note that to measure the CPU usage, you must collect metrics at least
+ * twice, using the same metrics object, within a time interval that's
+ * longer than 10 ms. That's because on most systems, the CPU usage is
+ * measured by comparing the number of CPU ticks that have passed at the
+ * beginning and end of a time interval. The metrics object remembers the
+ * number of CPU ticks that was queried last time.
+ */
+class SystemMetricsCollector {
+private:
+	#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+		int pageSize;
+
+		void queryLoadAvg(SystemMetrics &metrics) const {
+			double avg[3];
+			int ret;
+
+			ret = getloadavg(avg, 3);
+			if (ret >= 1) {
+				metrics.loadAverage1 = avg[0];
+			}
+			if (ret >= 2) {
+				metrics.loadAverage5 = avg[1];
+			}
+			if (ret >= 3) {
+				metrics.loadAverage15 = avg[2];
+			}
+		}
+
+		void failReadingCpuUsages(SystemMetrics &metrics) const {
+			vector<SystemMetrics::CpuUsage>::iterator it, end = metrics.cpuUsages.end();
+
+			for (it = metrics.cpuUsages.begin(); it != end; it++) {
+				it->userUsage = -1;
+				it->niceUsage = -1;
+				it->systemUsage = -1;
+				it->idleUsage = -1;
+				#if defined(__linux__)
+					it->ioWaitUsage = -1;
+					it->stealUsage  = -1;
+				#else
+					it->ioWaitUsage = -2;
+					it->stealUsage  = -2;
+				#endif
+			}
+		}
+
+		short fracToShort(double x) const {
+			return x * SHRT_MAX;
+		}
+
+		void updateCpuMetrics(SystemMetrics::CpuUsage &cpuUsage, long long user, long long nice,
+			long long sys, long long iowait, long long idle, long long steal) const
+		{
+			unsigned long long userDiff, niceDiff, systemDiff, ioWaitDiff,
+				idleDiff, stealDiff;
+			double totalCalculationTicks, totalTicks;
+
+			userDiff   = (unsigned long long) user - cpuUsage.lastUserTicks;
+			niceDiff   = (unsigned long long) nice - cpuUsage.lastNiceTicks;
+			systemDiff = (unsigned long long) sys  - cpuUsage.lastSystemTicks;
+			if (iowait >= 0) {
+				ioWaitDiff = (unsigned long long) iowait - cpuUsage.lastIoWaitTicks;
+			}
+			idleDiff   = (unsigned long long) idle - cpuUsage.lastIdleTicks;
+			if (steal >= 0) {
+				stealDiff  = (unsigned long long) steal - cpuUsage.lastStealTicks;
+			}
+
+			totalCalculationTicks = userDiff;
+			totalCalculationTicks += niceDiff;
+			totalCalculationTicks += systemDiff;
+			totalCalculationTicks += idleDiff;
+			if (totalCalculationTicks == 0) {
+				// If the CPU didn't tick, treat it as 100% idle.
+				cpuUsage.userUsage   = 0;
+				cpuUsage.niceUsage   = 0;
+				cpuUsage.systemUsage = 0;
+				cpuUsage.idleUsage   = fracToShort(1);
+			} else {
+				cpuUsage.userUsage   = fracToShort(userDiff / totalCalculationTicks);
+				cpuUsage.niceUsage   = fracToShort(niceDiff / totalCalculationTicks);
+				cpuUsage.systemUsage = fracToShort(systemDiff / totalCalculationTicks);
+				cpuUsage.idleUsage   = fracToShort(idleDiff / totalCalculationTicks);
+			}
+
+			if (iowait >= 0) {
+				totalTicks = totalCalculationTicks + ioWaitDiff;
+				if (totalTicks == 0) {
+					cpuUsage.ioWaitUsage = 0;
+				} else {
+					cpuUsage.ioWaitUsage = fracToShort(ioWaitDiff / totalTicks);
+				}
+			} else {
+				cpuUsage.ioWaitUsage = iowait; // Assign error code.
+			}
+			if (steal >= 0) {
+				totalTicks = totalCalculationTicks + stealDiff;
+				if (totalTicks == 0) {
+					cpuUsage.stealUsage = 0;
+				} else {
+					cpuUsage.stealUsage = fracToShort(stealDiff / totalTicks);
+				}
+			} else {
+				cpuUsage.stealUsage = steal; // Assign error code.
+			}
+
+			cpuUsage.lastUserTicks   = user;
+			cpuUsage.lastNiceTicks   = nice;
+			cpuUsage.lastSystemTicks = sys;
+			if (iowait >= 0) {
+				cpuUsage.lastIoWaitTicks = iowait;
+			}
+			cpuUsage.lastIdleTicks   = idle;
+			if (steal >= 0) {
+				cpuUsage.lastStealTicks  = steal;
+			}
+		}
+	#endif
+
+	#ifdef __linux__
+		void readNextWordAndAssertEqual(const char **data, const StaticString &expected) const {
+			if (readNextWord(data) != expected) {
+				throw ParseException();
+			}
+		}
+
+		void queryMemInfo(SystemMetrics &metrics) const {
+			string contents;
+			bool hasContents = false;
+			try {
+				contents = readAll("/proc/meminfo");
+				hasContents = true;
+			} catch (const SystemException &) {
+			}
+			if (hasContents) {
+				try {
+					parseMemInfo(metrics, contents);
+				} catch (const ParseException &) {
+					throw RuntimeException("Cannot parse information in /proc/meminfo");
+				}
+			} else {
+				metrics.ramTotal = metrics.ramUsed = -1;
+				metrics.swapTotal = metrics.swapUsed = -1;
+			}
+		}
+
+		void parseMemInfo(SystemMetrics &metrics, const string &data) const {
+			const char *start = data.c_str();
+			long long memTotal = -1, memFree = -1, buffers = -1, cached = -1;
+			long long swapTotal = -1, swapFree = -1;
+
+			while (start != NULL) {
+				StaticString name = readNextWord(&start);
+				long long value = readNextWordAsLongLong(&start);
+				if (!skipToNextLine(&start) || *start == '\0') {
+					start = NULL;
+				}
+
+				if (name == "MemTotal:") {
+					memTotal = value;
+				} else if (name == "MemFree:") {
+					memFree = value;
+				} else if (name == "Buffers:") {
+					buffers = value;
+				} else if (name == "Cached:") {
+					cached = value;
+				} else if (name == "SwapTotal:") {
+					swapTotal = value;
+				} else if (name == "SwapFree:") {
+					swapFree = value;
+				}
+			}
+
+			if (memTotal != -1) {
+				metrics.ramTotal = memTotal;
+				if (memFree != -1) {
+					metrics.ramUsed = memTotal - memFree;
+					if (buffers != -1) {
+						metrics.ramUsed -= buffers;
+					}
+					if (cached != -1) {
+						metrics.ramUsed -= cached;
+					}
+				} else {
+					metrics.ramUsed = -1;
+				}
+			} else {
+				metrics.ramTotal = metrics.ramUsed = -1;
+			}
+			if (swapTotal != -1) {
+				metrics.swapTotal = swapTotal;
+				if (swapFree != -1) {
+					metrics.swapUsed = swapTotal - swapFree;
+				} else {
+					metrics.swapUsed = -1;
+				}
+			} else {
+				metrics.swapTotal = metrics.swapUsed = -1;
+			}
+		}
+
+		void queryProcStat(SystemMetrics &metrics) const {
+			string contents;
+			bool hasContents = false;
+			try {
+				contents = readAll("/proc/stat");
+				hasContents = true;
+			} catch (const SystemException &) {
+			}
+			if (hasContents) {
+				try {
+					parseProcStat(metrics, contents);
+				} catch (const ParseException &) {
+					throw RuntimeException("Cannot parse information in /proc/stat");
+				}
+			} else {
+				failReadingCpuUsages(metrics);
+			}
+		}
+
+		void parseProcStat(SystemMetrics &metrics, const string &data) const {
+			const char *start = data.c_str();
+			unsigned long long forkCount = 0;
+
+			while (start != NULL) {
+				if (*start == '\n') {
+					// Empty line. Skip to next line.
+					start++;
+					continue;
+				}
+
+				StaticString name = readNextWord(&start);
+
+				if (name.size() > 3 && startsWith(name, "cpu")) {
+					const char *numStart = name.data() + 3;
+					unsigned long num = strtoul(numStart, NULL, 10);
+
+					long long user = readNextWordAsLongLong(&start);
+					long long nice = readNextWordAsLongLong(&start);
+					long long sys  = readNextWordAsLongLong(&start);
+					long long idle = readNextWordAsLongLong(&start);
+					long long iowait = readNextWordAsLongLong(&start);
+					readNextWordAsLongLong(&start); // irq
+					readNextWordAsLongLong(&start); // softirq
+					long long steal;
+					try {
+						steal = readNextWordAsLongLong(&start);
+					} catch (const ParseException &) {
+						// Not supported on Linux < 2.6.11
+						steal = -2;
+					}
+
+					if (num + 1 > metrics.cpuUsages.size()) {
+						metrics.cpuUsages.resize(num + 1);
+					}
+					updateCpuMetrics(
+						metrics.cpuUsages[num],
+						user,
+						nice,
+						sys,
+						iowait,
+						idle,
+						steal);
+				} else if (name == "processes") {
+					forkCount = (long long) readNextWordAsLongLong(&start);
+				}
+
+				if (!skipToNextLine(&start) || *start == '\0') {
+					start = NULL;
+				}
+			}
+
+			if (forkCount == 0) {
+				metrics.forkRate = -1;
+			} else {
+				metrics.forkRateSpeedMeter.addSample(forkCount);
+				metrics.forkRate = metrics.forkRateSpeedMeter.currentSpeed();
+			}
+		}
+
+		void queryProcVmstat(SystemMetrics &metrics) const {
+			string contents;
+			bool hasContents = false;
+			try {
+				contents = readAll("/proc/vmstat");
+				hasContents = true;
+			} catch (const SystemException &) {
+			}
+			if (hasContents) {
+				try {
+					parseProcVmstat(metrics, contents);
+				} catch (const ParseException &) {
+					throw RuntimeException("Cannot parse information in /proc/vmstat");
+				}
+			} else {
+				failReadingCpuUsages(metrics);
+			}
+		}
+
+		void parseProcVmstat(SystemMetrics &metrics, const string &data) const {
+			const char *start = data.c_str();
+			long long pswpin = -1, pswpout = -1;
+
+			while (start != NULL) {
+				StaticString name = readNextWord(&start);
+				long long value = readNextWordAsLongLong(&start);
+
+				if (!skipToNextLine(&start) || *start == '\0') {
+					start = NULL;
+				}
+
+				if (name == "pswpin") {
+					pswpin = value;
+				} else if (name == "pswpout") {
+					pswpout = value;
+				}
+			}
+
+			if (pswpin == -1 || pswpout == -1) {
+				metrics.swapInRate = -1;
+				metrics.swapOutRate = -1;
+			} else {
+				metrics.swapInSpeedMeter.addSample(pswpin * pageSize / 1024);
+				metrics.swapOutSpeedMeter.addSample(pswpout * pageSize / 1024);
+				metrics.swapInRate  = metrics.swapInSpeedMeter.currentSpeed();
+				metrics.swapOutRate = metrics.swapOutSpeedMeter.currentSpeed();
+			}
+		}
+
+		void queryBoottimeFromSysinfo(SystemMetrics &metrics) const {
+			if (metrics.boottime == -1) {
+				struct sysinfo info;
+
+				if (sysinfo(&info) != -1) {
+					metrics.boottime = (long long) SystemTime::get() - (long long) info.uptime;
+				}
+			}
+		}
+	#endif
+
+	#ifdef __APPLE__
+		mach_port_t hostPort;
+
+		void collectOSX(SystemMetrics &metrics) const {
+			kern_return_t status;
+			mach_msg_type_number_t count;
+			host_basic_info_data_t hostInfo;
+			vm_statistics64_data_t vmStat;
+			struct xsw_usage swap;
+			size_t bufSize = sizeof(swap);
+			int mib[2] = { CTL_VM, VM_SWAPUSAGE };
+			unsigned int cpuCount;
+			processor_cpu_load_info_t cpuLoads;
+
+			// Query total RAM.
+			count = HOST_BASIC_INFO_COUNT;
+			status = host_info(hostPort, HOST_BASIC_INFO, (host_info_t) &hostInfo,
+				&count);
+			if (status == KERN_SUCCESS) {
+				metrics.ramTotal = hostInfo.max_mem / 1024;
+			} else {
+				metrics.ramTotal = -1;
+			}
+
+			// Query system memory usage.
+			// We regard memory usage as the sum of active, wired and compressed memory.
+			// Active + wired is shown as "App memory" in Activity Monitor.
+			count = HOST_VM_INFO64_COUNT;
+			status = host_statistics64(hostPort, HOST_VM_INFO64, (host_info64_t) &vmStat,
+				&count);
+			if (status == KERN_SUCCESS) {
+				metrics.ramUsed = ((ssize_t) vmStat.active_count + vmStat.wire_count +
+					vmStat.compressor_page_count) * pageSize / 1024;
+			} else {
+				metrics.ramUsed = -1;
+			}
+
+			// Query swap.
+			if (sysctl(mib, 2, &swap, &bufSize, NULL, 0) == 0) {
+				metrics.swapTotal = swap.xsu_total / 1024;
+				metrics.swapUsed = swap.xsu_used / 1024;
+			} else {
+				metrics.swapTotal = metrics.swapUsed = -1;
+			}
+
+			// Query CPU usages.
+			status = host_processor_info(hostPort, PROCESSOR_CPU_LOAD_INFO,
+            	&cpuCount, (processor_info_array_t *) &cpuLoads, &count);
+			if (status == KERN_SUCCESS) {
+				if ((unsigned int) metrics.cpuUsages.size() != cpuCount) {
+					metrics.cpuUsages.resize(cpuCount);
+				}
+				for (unsigned int i = 0; i < cpuCount; i++) {
+					unsigned int *cpuTicks = cpuLoads[i].cpu_ticks;
+					updateCpuMetrics(
+						metrics.cpuUsages[i],
+						cpuTicks[CPU_STATE_USER],
+						cpuTicks[CPU_STATE_NICE],
+						cpuTicks[CPU_STATE_SYSTEM],
+						-2, /* OS X does not support iowait */
+						cpuTicks[CPU_STATE_IDLE],
+						-2  /* OS X does not support steal */);
+				}
+			} else {
+				failReadingCpuUsages(metrics);
+			}
+		}
+	#endif
+
+	#ifdef __FreeBSD__
+		int kern_smp_maxcpus[3];
+		int kern_cp_times[2];
+		int vm_active_count[4];
+		int vm_wire_count[4];
+
+		template<typename IntegerType>
+		bool querySysctl(int mib1, int mib2, IntegerType &result) const {
+			int mib[2] = { mib1, mib2 };
+			IntegerType val;
+			size_t len = sizeof(IntegerType);
+			if (sysctl(mib, 2, &val, &len, NULL, 0) == 0) {
+				if (len == sizeof(IntegerType)) {
+					result = val;
+					return true;
+				} else {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
+
+		template<typename IntegerType>
+		bool querySysctlMib(int mib[], size_t mibsize, IntegerType &result) const {
+			IntegerType val;
+			size_t len = sizeof(IntegerType);
+			if (mib[0] == -1) {
+				return false;
+			} else if (sysctl(mib, mibsize / sizeof(int), &val, &len, NULL, 0) == 0) {
+				if (len == sizeof(IntegerType)) {
+					result = val;
+					return true;
+				} else {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
+
+		void collectFreeBSD(SystemMetrics &metrics) const {
+			size_t len;
+			size_t val_size_t;
+			unsigned int val1_uint, val2_uint;
+			int vm_active_count[sizeof(this->vm_active_count) / sizeof(int)];
+			int vm_wire_count[sizeof(this->vm_wire_count) / sizeof(int)];
+
+			// Query active CPU count.
+			if (!queryCpuUsage(metrics)) {
+				failReadingCpuUsages(metrics);
+			}
+
+			// Query memory.
+			memcpy(vm_active_count, this->vm_active_count, sizeof(vm_active_count));
+			memcpy(vm_wire_count, this->vm_wire_count, sizeof(vm_wire_count));
+			if (metrics.ramTotal < 0) {
+				if (querySysctl<size_t>(CTL_HW, HW_PHYSMEM, val_size_t)) {
+					metrics.ramTotal = val_size_t / 1024;
+				} else {
+					metrics.ramTotal = -1;
+				}
+			}
+			if (metrics.ramTotal >= 0
+			 && querySysctlMib<unsigned int>(vm_active_count, sizeof(vm_active_count), val1_uint)
+			 && querySysctlMib<unsigned int>(vm_wire_count, sizeof(vm_wire_count), val2_uint))
+			{
+				metrics.ramUsed = ((long long) val1_uint + val2_uint) * pageSize / 1024;
+			} else {
+				metrics.ramUsed  = -1;
+			}
+
+			// Query swap.
+			int mib[17];
+			size_t mibsize = 16;
+			if (sysctlnametomib("vm.swap_info", mib, &mibsize) == 0) {
+				long long total = 0, used = 0;
+
+				for (int n = 0; ; n++) {
+					struct xswdev xsw;
+
+					mib[mibsize] = n;
+					len = sizeof(xsw);
+					if (sysctl(mib, mibsize + 1, &xsw, &len, NULL, 0) == -1) {
+						break;
+					}
+					if (xsw.xsw_version != XSWDEV_VERSION) {
+						metrics.swapTotal = -1;
+						metrics.swapUsed  = -1;
+						break;
+					}
+
+					total += (long long) xsw.xsw_nblks * pageSize;
+					used  += (long long) xsw.xsw_used  * pageSize;
+				}
+
+				metrics.swapTotal = total / 1024;
+				metrics.swapUsed  = used / 1024;
+			} else {
+				metrics.swapTotal = -1;
+				metrics.swapUsed  = -1;
+			}
+		}
+
+		bool cpuStatesAreEmpty(const long *states) const {
+			for (int i = 0; i < CPUSTATES; i++) {
+				if (states[i] != 0) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		bool queryCpuUsage(SystemMetrics &metrics) const {
+			int kern_smp_maxcpus[sizeof(this->kern_smp_maxcpus) / sizeof(int)];
+			int kern_cp_times[sizeof(this->kern_cp_times) / sizeof(int)];
+			long *times = NULL;
+			int maxcpus;
+			size_t size;
+			unsigned int i, j;
+
+			// Preparation.
+			memcpy(kern_smp_maxcpus, this->kern_smp_maxcpus, sizeof(kern_smp_maxcpus));
+			memcpy(kern_cp_times, this->kern_cp_times, sizeof(kern_cp_times));
+			if (kern_smp_maxcpus[0] == -1 || kern_cp_times[0] == -1) {
+				goto error;
+			}
+
+			// Query maximum number of supported CPUs.
+			if (!querySysctlMib<int>(kern_smp_maxcpus, sizeof(kern_smp_maxcpus),
+				maxcpus))
+			{
+				goto error;
+			}
+
+			// Query CPU times.
+			size = sizeof(long) * maxcpus * CPUSTATES;
+			times = (long *) malloc(size);
+			if (times == NULL) {
+				goto error;
+			}
+			if (sysctl(kern_cp_times, sizeof(kern_cp_times) / sizeof(int),
+				times, &size, NULL, 0) == -1)
+			{
+				goto error;
+			}
+
+			i = j = 0;
+			while (i < size / CPUSTATES / sizeof(long)) {
+				if (!cpuStatesAreEmpty(&times[i * CPUSTATES])) {
+					if (metrics.cpuUsages.size() < j + 1) {
+						metrics.cpuUsages.resize(j + 1);
+					}
+					updateCpuMetrics(
+						metrics.cpuUsages[j],
+						times[i * CPUSTATES + CP_USER],
+						times[i * CPUSTATES + CP_NICE],
+						times[i * CPUSTATES + CP_SYS],
+						-2, /* FreeBSD does not support iowait */
+						times[i * CPUSTATES + CP_IDLE],
+						-2 /* FreeBSD does not support steal */);
+					j++;
+				}
+				i++;
+			}
+
+			if (metrics.cpuUsages.size() != j) {
+				metrics.cpuUsages.resize(j);
+			}
+
+			return true;
+
+			error:
+			if (times != NULL) {
+				free(times);
+			}
+			return false;
+		}
+	#endif
+
+	#if defined(__APPLE__) || defined(__FreeBSD__)
+		void queryBoottimeFromSysctl(SystemMetrics &metrics) const {
+			if (metrics.boottime == -1) {
+				struct timeval boottime;
+				size_t len = sizeof(boottime);
+				int mib[2] = { CTL_KERN, KERN_BOOTTIME };
+
+				if (sysctl(mib, 2, &boottime, &len, NULL, 0) == 0) {
+					metrics.boottime = boottime.tv_sec;
+				} else {
+					metrics.boottime = -1;
+				}
+			}
+		}
+	#endif
+
+	void queryOsRelease(SystemMetrics &metrics) const {
+		struct utsname name;
+
+		if (metrics.kernelVersion.empty() && uname(&name) == 0) {
+			metrics.kernelVersion = name.release;
+		}
+	}
+
+public:
+	SystemMetricsCollector() {
+		#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+			pageSize = getpagesize();
+		#endif
+		#if defined(__APPLE__)
+			hostPort = mach_host_self();
+		#endif
+		#if defined(__FreeBSD__)
+			size_t len;
+
+			len = sizeof(kern_smp_maxcpus) / sizeof(int);
+			if (sysctlnametomib("kern.smp.maxcpus", kern_smp_maxcpus, &len) == -1) {
+				kern_smp_maxcpus[0] = -1;
+			}
+
+			len = sizeof(kern_cp_times) / sizeof(int);
+			if (sysctlnametomib("kern.cp_times", kern_cp_times, &len) == -1) {
+				kern_cp_times[0] = -1;
+			}
+
+			len = sizeof(vm_active_count) / sizeof(int);
+			if (sysctlnametomib("vm.stats.vm.v_active_count", vm_active_count, &len) == -1) {
+				vm_active_count[0] = -1;
+			}
+
+			len = sizeof(vm_wire_count) / sizeof(int);
+			if (sysctlnametomib("vm.stats.vm.v_wire_count", vm_wire_count, &len) == -1) {
+				vm_wire_count[0] = -1;
+			}
+		#endif
+	}
+
+	/**
+	 * If some information cannot be queried, then this method does not
+	 * throw an exception. Instead, that particular metric in the metrics
+	 * object is just not updated. However if something really unexpected
+	 * goes wrong (such as when a command did not return the output it's
+	 * supposed to return, so that we're unable to parse the output) then
+	 * a RuntimeException is thrown.
+	 *
+	 * @throws RuntimeException
+	 */
+	void collect(SystemMetrics &metrics) const {
+		#if defined(__linux__)
+			queryMemInfo(metrics);
+			queryProcStat(metrics);
+			queryProcVmstat(metrics);
+			queryBoottimeFromSysinfo(metrics);
+			queryLoadAvg(metrics);
+		#elif defined(__APPLE__)
+			collectOSX(metrics);
+			queryBoottimeFromSysctl(metrics);
+			queryLoadAvg(metrics);
+		#elif defined(__FreeBSD__)
+			collectFreeBSD(metrics);
+			queryBoottimeFromSysctl(metrics);
+			queryLoadAvg(metrics);
+		#endif
+		queryOsRelease(metrics);
+	}
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_SYSTEM_METRICS_COLLECTOR_H_ */