passenger 5.0.21 → 5.0.22

data/src/agent/Core/{RequestHandler → Controller}/AppResponse.h

@@ -40,6 +40,7 @@
 #include <DataStructures/LString.h>
 
 namespace Passenger {
+namespace Core {
 
 
 class HttpHeaderParser;
@@ -226,6 +227,7 @@ public:
 };
 
 
+} // namespace Core
 } // namespace Passenger
 
 #endif /* _PASSENGER_APP_RESPONSE_H_ */

data/src/agent/Core/{RequestHandler → Controller}/BufferBody.cpp

@@ -23,13 +23,31 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
+
+/*************************************************************************
+ *
+ * Implements Core::Controller methods pertaining buffering the request
+ * body.
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
 
-// This file is included inside the RequestHandler class.
 
-private:
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
+
 
 void
-beginBufferingBody(Client *client, Request *req) {
+Controller::beginBufferingBody(Client *client, Request *req) {
 	TRACE_POINT();
 	req->state = Request::BUFFERING_REQUEST_BODY;
 	req->bodyChannel.start();
@@ -38,8 +56,8 @@ beginBufferingBody(Client *client, Request *req) {
 	req->beginStopwatchLog(&req->stopwatchLogs.bufferingRequestBody, "buffering request body");
 }
 
-Channel::Result
-whenBufferingBody_onRequestBody(Client *client, Request *req,
+ServerKit::Channel::Result
+Controller::whenBufferingBody_onRequestBody(Client *client, Request *req,
 	const MemoryKit::mbuf &buffer, int errcode)
 {
 	TRACE_POINT();
@@ -97,3 +115,7 @@ whenBufferingBody_onRequestBody(Client *client, Request *req,
 		return Channel::Result(0, true);
 	}
 }
+
+
+} // namespace Core
+} // namespace Passenger

data/src/agent/Core/{RequestHandler → Controller}/CheckoutSession.cpp

@@ -23,17 +23,35 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
 
-// This file is included inside the RequestHandler class.
+/*************************************************************************
+ *
+ * Implements Core::Controller methods pertaining selecting an application
+ * process to handle the current request.
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
 
-private:
 
 void
-checkoutSession(Client *client, Request *req) {
+Controller::checkoutSession(Client *client, Request *req) {
 	GetCallback callback;
 	Options &options = req->options;
 
-	RH_BENCHMARK_POINT(client, req, BM_BEFORE_CHECKOUT);
+	CC_BENCHMARK_POINT(client, req, BM_BEFORE_CHECKOUT);
 	SKC_TRACE(client, 2, "Checking out session: appRoot=" << options.appRoot);
 	req->state = Request::CHECKING_OUT_SESSION;
 	req->beginStopwatchLog(&req->stopwatchLogs.getFromPool, "get from pool");
@@ -49,11 +67,11 @@ checkoutSession(Client *client, Request *req) {
 	options.currentTime = (unsigned long long) (ev_now(getLoop()) * 1000000);
 
 	refRequest(req, __FILE__, __LINE__);
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		req->timeBeforeAccessingApplicationPool = ev_now(getLoop());
 	#endif
 	appPool->asyncGet(options, callback);
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		if (!req->timedAppPoolGet) {
 			req->timedAppPoolGet = true;
 			ev_now_update(getLoop());
@@ -63,35 +81,35 @@ checkoutSession(Client *client, Request *req) {
 	#endif
 }
 
-static void
-sessionCheckedOut(const SessionPtr &session, const ExceptionPtr &e,
+void
+Controller::sessionCheckedOut(const SessionPtr &session, const ExceptionPtr &e,
 	void *userData)
 {
 	Request *req = static_cast<Request *>(userData);
 	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
 
 	if (self->getContext()->libev->onEventLoopThread()) {
 		self->sessionCheckedOutFromEventLoopThread(client, req, session, e);
 		self->unrefRequest(req, __FILE__, __LINE__);
 	} else {
 		self->getContext()->libev->runLater(
-			boost::bind(&RequestHandler::sessionCheckedOutFromAnotherThread,
+			boost::bind(&Controller::sessionCheckedOutFromAnotherThread,
 				self, client, req, session, e));
 	}
 }
 
 void
-sessionCheckedOutFromAnotherThread(Client *client, Request *req,
+Controller::sessionCheckedOutFromAnotherThread(Client *client, Request *req,
 	SessionPtr session, ExceptionPtr e)
 {
-	SKC_LOG_EVENT(RequestHandler, client, "sessionCheckedOutFromAnotherThread");
+	SKC_LOG_EVENT(Controller, client, "sessionCheckedOutFromAnotherThread");
 	sessionCheckedOutFromEventLoopThread(client, req, session, e);
 	unrefRequest(req, __FILE__, __LINE__);
 }
 
 void
-sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
+Controller::sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
 	const SessionPtr &session, const ExceptionPtr &e)
 {
 	if (req->ended()) {
@@ -99,9 +117,9 @@ sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
 	}
 
 	TRACE_POINT();
-	RH_BENCHMARK_POINT(client, req, BM_AFTER_CHECKOUT);
+	CC_BENCHMARK_POINT(client, req, BM_AFTER_CHECKOUT);
 
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		if (!req->timedAppPoolGet) {
 			req->timedAppPoolGet = true;
 			ev_now_update(getLoop());
@@ -126,7 +144,7 @@ sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
 }
 
 void
-maybeSend100Continue(Client *client, Request *req) {
+Controller::maybeSend100Continue(Client *client, Request *req) {
 	int httpVersion = req->httpMajor * 1000 + req->httpMinor * 10;
 	if (httpVersion >= 1010 && req->hasBody() && !req->strip100ContinueHeader) {
 		// Apps with the "session" protocol don't respond with 100-Continue,
@@ -150,7 +168,7 @@ maybeSend100Continue(Client *client, Request *req) {
 }
 
 void
-initiateSession(Client *client, Request *req) {
+Controller::initiateSession(Client *client, Request *req) {
 	TRACE_POINT();
 	req->sessionCheckoutTry++;
 	try {
@@ -189,12 +207,12 @@ initiateSession(Client *client, Request *req) {
 	sendHeaderToApp(client, req);
 }
 
-static void
-checkoutSessionLater(Request *req) {
+void
+Controller::checkoutSessionLater(Request *req) {
 	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(
-		RequestHandler::getServerFromClient(client));
-	SKC_LOG_EVENT_FROM_STATIC(self, RequestHandler, client, "checkoutSessionLater");
+	Controller *self = static_cast<Controller *>(
+		Controller::getServerFromClient(client));
+	SKC_LOG_EVENT_FROM_STATIC(self, Controller, client, "checkoutSessionLater");
 
 	if (!req->ended()) {
 		self->checkoutSession(client, req);
@@ -203,7 +221,9 @@ checkoutSessionLater(Request *req) {
 }
 
 void
-reportSessionCheckoutError(Client *client, Request *req, const ExceptionPtr &e) {
+Controller::reportSessionCheckoutError(Client *client, Request *req,
+	const ExceptionPtr &e)
+{
 	TRACE_POINT();
 	{
 		boost::shared_ptr<RequestQueueFullException> e2 =
@@ -224,9 +244,12 @@ reportSessionCheckoutError(Client *client, Request *req, const ExceptionPtr &e)
 }
 
 void
-writeRequestQueueFullExceptionErrorResponse(Client *client, Request *req, const boost::shared_ptr<RequestQueueFullException> &e) {
+Controller::writeRequestQueueFullExceptionErrorResponse(Client *client, Request *req,
+	const boost::shared_ptr<RequestQueueFullException> &e)
+{
 	TRACE_POINT();
-	const LString *value = req->secureHeaders.lookup("!~PASSENGER_REQUEST_QUEUE_OVERFLOW_STATUS_CODE");
+	const LString *value = req->secureHeaders.lookup(
+		"!~PASSENGER_REQUEST_QUEUE_OVERFLOW_STATUS_CODE");
 	int requestQueueOverflowStatusCode = 503;
 	if (value != NULL && value->size > 0) {
 		value = psg_lstr_make_contiguous(value, req->pool);
@@ -234,7 +257,8 @@ writeRequestQueueFullExceptionErrorResponse(Client *client, Request *req, const
 			StaticString(value->start->data, value->size));
 	}
 
-	SKC_WARN(client, "Returning HTTP " << requestQueueOverflowStatusCode << " due to: " << e->what());
+	SKC_WARN(client, "Returning HTTP " << requestQueueOverflowStatusCode <<
+		" due to: " << e->what());
 
 	endRequestWithSimpleResponse(&client, &req,
 		"<h1>This website is under heavy load</h1>"
@@ -244,7 +268,7 @@ writeRequestQueueFullExceptionErrorResponse(Client *client, Request *req, const
 }
 
 void
-writeSpawnExceptionErrorResponse(Client *client, Request *req,
+Controller::writeSpawnExceptionErrorResponse(Client *client, Request *req,
 	const boost::shared_ptr<SpawnException> &e)
 {
 	TRACE_POINT();
@@ -255,7 +279,7 @@ writeSpawnExceptionErrorResponse(Client *client, Request *req,
 }
 
 void
-writeOtherExceptionErrorResponse(Client *client, Request *req, const ExceptionPtr &e) {
+Controller::writeOtherExceptionErrorResponse(Client *client, Request *req, const ExceptionPtr &e) {
 	TRACE_POINT();
 	string typeName;
 	#ifdef CXX_ABI_API_AVAILABLE
@@ -304,8 +328,8 @@ writeOtherExceptionErrorResponse(Client *client, Request *req, const ExceptionPt
  * `message` will be copied and doesn't need to outlive the request.
  */
 void
-endRequestWithErrorResponse(Client **c, Request **r, const StaticString &message,
-	const SpawnException *e = NULL)
+Controller::endRequestWithErrorResponse(Client **c, Request **r, const StaticString &message,
+	const SpawnException *e)
 {
 	TRACE_POINT();
 	Client *client = *c;
@@ -335,7 +359,7 @@ endRequestWithErrorResponse(Client **c, Request **r, const StaticString &message
 }
 
 bool
-friendlyErrorPagesEnabled(Request *req) {
+Controller::friendlyErrorPagesEnabled(Request *req) {
 	bool defaultValue;
 	string defaultStr = agentsOptions->get("friendly_error_pages");
 	if (defaultStr == "auto") {
@@ -348,3 +372,9 @@ friendlyErrorPagesEnabled(Request *req) {
 }
 
 /***************/
+
+/***************/
+
+
+} // namespace Core
+} // namespace Passenger

data/src/agent/Core/{RequestHandler → Controller}/Client.h

@@ -29,9 +29,10 @@
 #include <ev++.h>
 #include <ostream>
 #include <ServerKit/HttpClient.h>
-#include <Core/RequestHandler/Request.h>
+#include <Core/Controller/Request.h>
 
 namespace Passenger {
+namespace Core {
 
 using namespace std;
 using namespace boost;
@@ -48,10 +49,12 @@ public:
 		SERVER_KIT_BASE_HTTP_CLIENT_INIT();
 	}
 
-	DEFINE_SERVER_KIT_BASE_HTTP_CLIENT_FOOTER(Client, Request);
+	DEFINE_SERVER_KIT_BASE_HTTP_CLIENT_FOOTER(Passenger::Core::Client,
+		Passenger::Core::Request);
 };
 
 
+} // namespace Client
 } // namespace Passenger
 
 #endif /* _PASSENGER_REQUEST_HANDLER_CLIENT_H_ */

data/src/agent/Core/{RequestHandler → Controller}/ForwardResponse.cpp

@@ -23,25 +23,45 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
 
-// This file is included inside the RequestHandler class.
-// It handles app --> client data forwarding.
+/*************************************************************************
+ *
+ * Implements Core::Controller methods pertaining sending application
+ * response data to the client. This happens in parallel to the process
+ * of sending request data to the application.
+ *
+ *************************************************************************/
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
 
-private:
 
-static Channel::Result
-_onAppSourceData(Channel *_channel, const MemoryKit::mbuf &buffer, int errcode) {
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
+
+
+ServerKit::Channel::Result
+Controller::_onAppSourceData(Channel *_channel, const MemoryKit::mbuf &buffer, int errcode) {
 	FdSourceChannel *channel = reinterpret_cast<FdSourceChannel *>(_channel);
 	Request *req = static_cast<Request *>(static_cast<
 		ServerKit::BaseHttpRequest *>(channel->getHooks()->userData));
 	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
 	return self->onAppSourceData(client, req, buffer, errcode);
 }
 
-Channel::Result
-onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int errcode) {
-	SKC_LOG_EVENT(RequestHandler, client, "onAppSourceData");
+ServerKit::Channel::Result
+Controller::onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer,
+	int errcode)
+{
+	SKC_LOG_EVENT(Controller, client, "onAppSourceData");
 	AppResponse *resp = &req->appResponse;
 
 	switch (resp->httpState) {
@@ -292,13 +312,13 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 }
 
 void
-onAppResponseBegin(Client *client, Request *req) {
+Controller::onAppResponseBegin(Client *client, Request *req) {
 	TRACE_POINT();
 	AppResponse *resp = &req->appResponse;
 	ssize_t bytesWritten;
 	bool oobw;
 
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		req->timeOnRequestHeaderSent = ev_now(getLoop());
 		reportLargeTimeDiff(client,
 			"Headers sent until response begun",
@@ -375,7 +395,8 @@ onAppResponseBegin(Client *client, Request *req) {
 	}
 }
 
-void prepareAppResponseCaching(Client *client, Request *req) {
+void
+Controller::prepareAppResponseCaching(Client *client, Request *req) {
 	if (turboCaching.isEnabled() && !req->cacheKey.empty()) {
 		TRACE_POINT();
 		AppResponse *resp = &req->appResponse;
@@ -408,7 +429,7 @@ void prepareAppResponseCaching(Client *client, Request *req) {
 }
 
 void
-onAppResponse100Continue(Client *client, Request *req) {
+Controller::onAppResponse100Continue(Client *client, Request *req) {
 	TRACE_POINT();
 	if (!req->strip100ContinueHeader) {
 		UPDATE_TRACE_POINT();
@@ -445,7 +466,7 @@ onAppResponse100Continue(Client *client, Request *req) {
  * In this case, this method always returns true.
  */
 bool
-constructHeaderBuffersForResponse(Request *req, struct iovec *buffers,
+Controller::constructHeaderBuffersForResponse(Request *req, struct iovec *buffers,
 	unsigned int maxbuffers, unsigned int & restrict_ref nbuffers,
 	unsigned int & restrict_ref dataSize,
 	unsigned int & restrict_ref nCacheableBuffers)
@@ -768,7 +789,7 @@ constructHeaderBuffersForResponse(Request *req, struct iovec *buffers,
 }
 
 unsigned int
-constructDateHeaderBuffersForResponse(char *dateStr, unsigned int bufsize) {
+Controller::constructDateHeaderBuffersForResponse(char *dateStr, unsigned int bufsize) {
 	char *pos = dateStr;
 	const char *end = dateStr + bufsize - 1;
 	time_t the_time = (time_t) ev_now(getContext()->libev->getLoop());
@@ -781,7 +802,9 @@ constructDateHeaderBuffersForResponse(char *dateStr, unsigned int bufsize) {
 }
 
 bool
-sendResponseHeaderWithWritev(Client *client, Request *req, ssize_t &bytesWritten) {
+Controller::sendResponseHeaderWithWritev(Client *client, Request *req,
+	ssize_t &bytesWritten)
+{
 	TRACE_POINT();
 
 	if (OXT_UNLIKELY(benchmarkMode == BM_RESPONSE_BEGIN)) {
@@ -816,7 +839,9 @@ sendResponseHeaderWithWritev(Client *client, Request *req, ssize_t &bytesWritten
 }
 
 void
-sendResponseHeaderWithBuffering(Client *client, Request *req, unsigned int offset) {
+Controller::sendResponseHeaderWithBuffering(Client *client, Request *req,
+	unsigned int offset)
+{
 	struct iovec *buffers;
 	unsigned int nbuffers, dataSize, nCacheableBuffers;
 	bool ok;
@@ -852,7 +877,7 @@ sendResponseHeaderWithBuffering(Client *client, Request *req, unsigned int offse
 }
 
 void
-logResponseHeaders(Client *client, Request *req, struct iovec *buffers,
+Controller::logResponseHeaders(Client *client, Request *req, struct iovec *buffers,
 	unsigned int nbuffers, unsigned int dataSize)
 {
 	if (OXT_UNLIKELY(getLogLevel() >= LVL_DEBUG3)) {
@@ -869,12 +894,28 @@ logResponseHeaders(Client *client, Request *req, struct iovec *buffers,
 		} else {
 			req->logMessage("Status: " + toString(req->appResponse.statusCode));
 		}
+
+		if (req->appResponse.statusCode >= 500 && req->appResponse.statusCode <= 599) {
+			// Log the request headers like Request headers: { header1: values1-concatenated, header2: values2-concatenated } (single line)
+			// Concatenation was already done by HeaderTable.h:insert (using a comma ',' for joining, or a semicolon ';' for Cookie headers
+			ServerKit::HeaderTable::Iterator it(req->headers);
+			Json::Value json;
+			while (*it != NULL) {
+				const LString *hdr = psg_lstr_make_contiguous(&it->header->key, req->pool);
+				const LString *val = psg_lstr_make_contiguous(&it->header->val, req->pool);
+				// Due to the above mentioned concatenation, header keys are unique and we don't need to worry
+				// about encountering multiple of the same key, so we can just assign.
+				json[std::string(hdr->start->data, hdr->size)] = std::string(val->start->data, val->size);
+				it.next();
+			}
+			req->logMessage("Request headers: " + stringifyJson(json));
+		}
 	}
 }
 
 void
-markHeaderBuffersForTurboCaching(Client *client, Request *req, struct iovec *buffers,
-	unsigned int nbuffers)
+Controller::markHeaderBuffersForTurboCaching(Client *client, Request *req,
+	struct iovec *buffers, unsigned int nbuffers)
 {
 	if (turboCaching.isEnabled() && !req->cacheKey.empty()) {
 		unsigned int totalSize = 0;
@@ -897,22 +938,23 @@ markHeaderBuffersForTurboCaching(Client *client, Request *req, struct iovec *buf
 	}
 }
 
-static ServerKit::HttpHeaderParser<AppResponse, ServerKit::HttpParseResponse>
-createAppResponseHeaderParser(ServerKit::Context *ctx, Request *req) {
+ServerKit::HttpHeaderParser<AppResponse, ServerKit::HttpParseResponse>
+Controller::createAppResponseHeaderParser(ServerKit::Context *ctx, Request *req) {
 	return ServerKit::HttpHeaderParser<AppResponse, ServerKit::HttpParseResponse>(
 		ctx, req->appResponse.parserState.headerParser,
 		&req->appResponse, req->pool, req->method);
 }
 
-static ServerKit::HttpChunkedBodyParser
-createAppResponseChunkedBodyParser(Request *req) {
+ServerKit::HttpChunkedBodyParser
+Controller::createAppResponseChunkedBodyParser(Request *req) {
 	return ServerKit::HttpChunkedBodyParser(
 		&req->appResponse.parserState.chunkedBodyParser,
 		formatAppResponseChunkedBodyParserLoggingPrefix,
 		req);
 }
 
-static unsigned int formatAppResponseChunkedBodyParserLoggingPrefix(char *buf,
+unsigned int
+Controller::formatAppResponseChunkedBodyParserLoggingPrefix(char *buf,
 	unsigned int bufsize, void *userData)
 {
 	Request *req = static_cast<Request *>(userData);
@@ -921,13 +963,16 @@ static unsigned int formatAppResponseChunkedBodyParserLoggingPrefix(char *buf,
 		static_cast<Client *>(req->client)->number);
 }
 
-void prepareAppResponseChunkedBodyParsing(Client *client, Request *req) {
+void
+Controller::prepareAppResponseChunkedBodyParsing(Client *client, Request *req) {
 	P_ASSERT_EQ(req->appResponse.bodyType, AppResponse::RBT_CHUNKED);
 	createAppResponseChunkedBodyParser(req).initialize();
 }
 
 void
-writeResponseAndMarkForTurboCaching(Client *client, Request *req, const MemoryKit::mbuf &buffer) {
+Controller::writeResponseAndMarkForTurboCaching(Client *client, Request *req,
+	const MemoryKit::mbuf &buffer)
+{
 	if (OXT_LIKELY(benchmarkMode != BM_RESPONSE_BEGIN)) {
 		writeResponse(client, buffer);
 	}
@@ -935,7 +980,9 @@ writeResponseAndMarkForTurboCaching(Client *client, Request *req, const MemoryKi
 }
 
 void
-markResponsePartForTurboCaching(Client *client, Request *req, const MemoryKit::mbuf &buffer) {
+Controller::markResponsePartForTurboCaching(Client *client, Request *req,
+	const MemoryKit::mbuf &buffer)
+{
 	if (!req->ended() && turboCaching.isEnabled() && !req->cacheKey.empty()) {
 		unsigned int totalSize = req->appResponse.bodyCacheBuffer.size + buffer.size();
 		if (totalSize > ResponseCache<Request>::MAX_BODY_SIZE) {
@@ -954,7 +1001,7 @@ markResponsePartForTurboCaching(Client *client, Request *req, const MemoryKit::m
 }
 
 void
-maybeThrottleAppSource(Client *client, Request *req) {
+Controller::maybeThrottleAppSource(Client *client, Request *req) {
 	if (!req->ended()) {
 		assert(client->output.getBuffersFlushedCallback() == NULL);
 		assert(client->output.getDataFlushedCallback() == getClientOutputDataFlushedCallback());
@@ -975,20 +1022,20 @@ maybeThrottleAppSource(Client *client, Request *req) {
 	}
 }
 
-static void
-_outputBuffersFlushed(FileBufferedChannel *_channel) {
+void
+Controller::_outputBuffersFlushed(FileBufferedChannel *_channel) {
 	FileBufferedFdSinkChannel *channel = reinterpret_cast<FileBufferedFdSinkChannel *>(_channel);
 	Client *client = static_cast<Client *>(static_cast<
 		ServerKit::BaseClient *>(channel->getHooks()->userData));
 	Request *req = static_cast<Request *>(client->currentRequest);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
 	if (client->connected() && req != NULL) {
 		self->outputBuffersFlushed(client, req);
 	}
 }
 
 void
-outputBuffersFlushed(Client *client, Request *req) {
+Controller::outputBuffersFlushed(Client *client, Request *req) {
 	if (!req->ended()) {
 		assert(!req->appSource.isStarted());
 		SKC_TRACE(client, 2, "Buffered response data has been written to disk. Resuming application socket");
@@ -997,13 +1044,13 @@ outputBuffersFlushed(Client *client, Request *req) {
 	}
 }
 
-static void
-_outputDataFlushed(FileBufferedChannel *_channel) {
+void
+Controller::_outputDataFlushed(FileBufferedChannel *_channel) {
 	FileBufferedFdSinkChannel *channel = reinterpret_cast<FileBufferedFdSinkChannel *>(_channel);
 	Client *client = static_cast<Client *>(static_cast<
 		ServerKit::BaseClient *>(channel->getHooks()->userData));
 	Request *req = static_cast<Request *>(client->currentRequest);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
 
 	getClientOutputDataFlushedCallback()(_channel);
 	if (client->connected() && req != NULL) {
@@ -1012,7 +1059,7 @@ _outputDataFlushed(FileBufferedChannel *_channel) {
 }
 
 void
-outputDataFlushed(Client *client, Request *req) {
+Controller::outputDataFlushed(Client *client, Request *req) {
 	if (!req->ended()) {
 		assert(!req->appSource.isStarted());
 		SKC_TRACE(client, 2, "The client is ready to receive more data. Resuming application socket");
@@ -1022,7 +1069,7 @@ outputDataFlushed(Client *client, Request *req) {
 }
 
 void
-handleAppResponseBodyEnd(Client *client, Request *req) {
+Controller::handleAppResponseBodyEnd(Client *client, Request *req) {
 	keepAliveAppConnection(client, req);
 	storeAppResponseInTurboCache(client, req);
 	finalizeUnionStationWithSuccess(client, req);
@@ -1030,12 +1077,12 @@ handleAppResponseBodyEnd(Client *client, Request *req) {
 }
 
 OXT_FORCE_INLINE void
-keepAliveAppConnection(Client *client, Request *req) {
+Controller::keepAliveAppConnection(Client *client, Request *req) {
 	req->session->close(true, req->appResponse.wantKeepAlive);
 }
 
 void
-storeAppResponseInTurboCache(Client *client, Request *req) {
+Controller::storeAppResponseInTurboCache(Client *client, Request *req) {
 	if (turboCaching.isEnabled() && !req->cacheKey.empty()) {
 		TRACE_POINT();
 		AppResponse *resp = &req->appResponse;
@@ -1072,7 +1119,11 @@ storeAppResponseInTurboCache(Client *client, Request *req) {
 }
 
 void
-finalizeUnionStationWithSuccess(Client *client, Request *req) {
-	req->endStopwatchLog(&req->stopwatchLogs.requestProcessing, true);
+Controller::finalizeUnionStationWithSuccess(Client *client, Request *req) {
 	req->endStopwatchLog(&req->stopwatchLogs.requestProxying, true);
+	req->endStopwatchLog(&req->stopwatchLogs.requestProcessing, true);
 }
+
+
+} // namespace Core
+} // namespace Passenger