passenger 4.0.45 → 4.0.46

data/lib/phusion_passenger/rack/thread_handler_extension.rb

@@ -80,6 +80,7 @@ module ThreadHandlerExtension
 					# otherwise maliciously crafted responses can crash the app,
 					# forcing it to be respawned, and thereby effectively DoSing it.
 					print_exception("Rack application object", e)
+					PhusionPassenger.log_request_exception(env, e)
 				end
 				return false
 			end

data/lib/phusion_passenger/request_handler.rb

@@ -92,7 +92,7 @@ class RequestHandler
 			"app_group_name",
 			"connect_password",
 			"detach_key",
-			"analytics_logger",
+			"union_station_core",
 			"pool_account_username"
 		)
 
@@ -400,7 +400,7 @@ private
 			:app              => @app,
 			:app_group_name   => @app_group_name,
 			:connect_password => @connect_password,
-			:analytics_logger => @analytics_logger
+			:union_station_core => @union_station_core
 		}
 		main_socket_options = common_options.merge(
 			:server_socket => @main_socket,

data/lib/phusion_passenger/request_handler/thread_handler.rb

@@ -68,7 +68,7 @@ class ThreadHandler
 		@app_group_name    = Utils.require_option(options, :app_group_name)
 		Utils.install_options_as_ivars(self, options,
 			:app,
-			:analytics_logger,
+			:union_station_core,
 			:connect_password
 		)
 
@@ -166,8 +166,8 @@ private
 				print_exception("Passenger RequestHandler's client socket", e)
 			end
 		else
-			if @analytics_logger && headers && headers[PASSENGER_TXN_ID]
-				log_analytics_exception(headers, e)
+			if headers
+				PhusionPassenger.log_request_exception(headers, e)
 			end
 			raise e if should_reraise_error?(e)
 		end
@@ -276,64 +276,69 @@ private
 #	end
 
 	def prepare_request(connection, headers)
-		if @analytics_logger && headers[PASSENGER_TXN_ID]
+		if @union_station_core && headers[PASSENGER_TXN_ID]
 			txn_id = headers[PASSENGER_TXN_ID]
 			union_station_key = headers[PASSENGER_UNION_STATION_KEY]
-			log = @analytics_logger.continue_transaction(txn_id,
+			transaction = @union_station_core.continue_transaction(txn_id,
 				@app_group_name,
 				:requests, union_station_key)
-			headers[PASSENGER_ANALYTICS_WEB_LOG] = log
-			Thread.current[PASSENGER_ANALYTICS_WEB_LOG] = log
+			headers[UNION_STATION_REQUEST_TRANSACTION] = transaction
+			headers[UNION_STATION_CORE] = @union_station_core
+			headers[PASSENGER_APP_GROUP_NAME] = @app_group_name
+			Thread.current[UNION_STATION_REQUEST_TRANSACTION] = transaction
+			Thread.current[UNION_STATION_CORE] = @union_station_core
 			Thread.current[PASSENGER_TXN_ID] = txn_id
 			Thread.current[PASSENGER_UNION_STATION_KEY] = union_station_key
 			if OBJECT_SPACE_SUPPORTS_LIVE_OBJECTS
-				log.message("Initial objects on heap: #{ObjectSpace.live_objects}")
+				transaction.message("Initial objects on heap: #{ObjectSpace.live_objects}")
 			end
 			if OBJECT_SPACE_SUPPORTS_ALLOCATED_OBJECTS
-				log.message("Initial objects allocated so far: #{ObjectSpace.allocated_objects}")
+				transaction.message("Initial objects allocated so far: #{ObjectSpace.allocated_objects}")
 			elsif OBJECT_SPACE_SUPPORTS_COUNT_OBJECTS
 				count = ObjectSpace.count_objects
-				log.message("Initial objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
+				transaction.message("Initial objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
 			end
 			if GC_SUPPORTS_TIME
-				log.message("Initial GC time: #{GC.time}")
+				transaction.message("Initial GC time: #{GC.time}")
 			end
-			log.begin_measure("app request handler processing")
+			transaction.begin_measure("app request handler processing")
 		end
 		
 		#################
 	end
 	
 	def finalize_request(connection, headers, has_error)
-		log = headers[PASSENGER_ANALYTICS_WEB_LOG]
-		if log && !log.closed?
+		transaction = headers[UNION_STATION_REQUEST_TRANSACTION]
+		Thread.current[UNION_STATION_CORE] = nil
+		Thread.current[UNION_STATION_REQUEST_TRANSACTION] = nil
+
+		if transaction && !transaction.closed?
 			exception_occurred = false
 			begin
-				log.end_measure("app request handler processing", has_error)
+				transaction.end_measure("app request handler processing", has_error)
 				if OBJECT_SPACE_SUPPORTS_LIVE_OBJECTS
-					log.message("Final objects on heap: #{ObjectSpace.live_objects}")
+					transaction.message("Final objects on heap: #{ObjectSpace.live_objects}")
 				end
 				if OBJECT_SPACE_SUPPORTS_ALLOCATED_OBJECTS
-					log.message("Final objects allocated so far: #{ObjectSpace.allocated_objects}")
+					transaction.message("Final objects allocated so far: #{ObjectSpace.allocated_objects}")
 				elsif OBJECT_SPACE_SUPPORTS_COUNT_OBJECTS
 					count = ObjectSpace.count_objects
-					log.message("Final objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
+					transaction.message("Final objects allocated so far: #{count[:TOTAL] - count[:FREE]}")
 				end
 				if GC_SUPPORTS_TIME
-					log.message("Final GC time: #{GC.time}")
+					transaction.message("Final GC time: #{GC.time}")
 				end
 				if GC_SUPPORTS_CLEAR_STATS
 					# Clear statistics to void integer wraps.
 					GC.clear_stats
 				end
-				Thread.current[PASSENGER_ANALYTICS_WEB_LOG] = nil
 			rescue Exception
 				# Maybe this exception was raised while communicating
 				# with the logging agent. If that is the case then
-				# log.close may also raise an exception, but we're only
+				# transaction.close may also raise an exception, but we're only
 				# interested in the original exception. So if this
 				# situation occurs we must ignore any exceptions raised
-				# by log.close.
+				# by transaction.close.
 				exception_occurred = true
 				raise
 			ensure
@@ -343,7 +348,7 @@ private
 				# the helper agent may close the transaction before this
 				# process's openTransaction command is processed.
 				begin
-					log.close
+					transaction.close
 				rescue
 					raise if !exception_occurred
 				end
@@ -352,29 +357,6 @@ private
 		
 		#################
 	end
-	
-	def log_analytics_exception(env, exception)
-		log = @analytics_logger.new_transaction(
-			@app_group_name,
-			:exceptions,
-			env[PASSENGER_UNION_STATION_KEY])
-		begin
-			request_txn_id = env[PASSENGER_TXN_ID]
-			message = exception.message
-			message = exception.to_s if message.empty?
-			message = [message].pack('m')
-			message.gsub!("\n", "")
-			backtrace_string = [exception.backtrace.join("\n")].pack('m')
-			backtrace_string.gsub!("\n", "")
-
-			log.message("Request transaction ID: #{request_txn_id}")
-			log.message("Message: #{message}")
-			log.message("Class: #{exception.class.name}")
-			log.message("Backtrace: #{backtrace_string}")
-		ensure
-			log.close
-		end
-	end
 
 	def should_reraise_error?(e)
 		# Stubable by unit tests.

data/lib/phusion_passenger/standalone/command.rb

@@ -22,6 +22,7 @@
 #  THE SOFTWARE.
 require 'optparse'
 PhusionPassenger.require_passenger_lib 'constants'
+PhusionPassenger.require_passenger_lib 'utils'
 PhusionPassenger.require_passenger_lib 'standalone/utils'
 
 module PhusionPassenger
@@ -91,6 +92,10 @@ private
 	def require_erb
 		require 'erb' unless defined?(ERB)
 	end
+
+	def require_etc
+		require 'etc' unless defined?(Etc)
+	end
 	
 	def require_optparse
 		require 'optparse' unless defined?(OptionParser)
@@ -105,9 +110,11 @@ private
 	end
 	
 	def parse_options!(command_name, description = nil)
+		require_etc
 		help = false
 		
-		global_config_file = File.join(ENV['HOME'], USER_NAMESPACE_DIRNAME, "standalone", "config")
+		home_dir = PhusionPassenger::Utils.home_dir
+		global_config_file = File.join(home_dir, USER_NAMESPACE_DIRNAME, "standalone", "config")
 		if File.exist?(global_config_file)
 			PhusionPassenger.require_passenger_lib 'standalone/config_file' unless defined?(ConfigFile)
 			global_options = ConfigFile.new(:global_config, global_config_file).options

data/lib/phusion_passenger/standalone/main.rb

@@ -30,7 +30,6 @@ class Main
 		['start',   'StartCommand'],
 		['stop',    'StopCommand'],
 		['status',  'StatusCommand'],
-		['package-runtime', 'PackageRuntimeCommand'],
 		['version', 'VersionCommand'],
 		['help',    'HelpCommand']
 	]

data/lib/phusion_passenger/standalone/start_command.rb

@@ -217,6 +217,10 @@ private
 				wrap_desc("Turn off friendly error pages")) do
 				@options[:friendly_error_pages] = false
 			end
+			opts.on("--load-shell-envvars",
+				wrap_desc("Load shell startup files before loading application")) do
+				@options[:load_shell_envvars] = true
+			end
 
 			opts.separator ""
 			opts.separator "Process management options:"

data/lib/phusion_passenger/union_station/connection.rb

@@ -0,0 +1,67 @@
+#  Phusion Passenger - https://www.phusionpassenger.com/
+#  Copyright (c) 2010-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.
+
+PhusionPassenger.require_passenger_lib 'message_channel'
+
+module PhusionPassenger
+module UnionStation
+
+class Connection
+	attr_reader :mutex
+	attr_accessor :channel
+
+	def initialize(io)
+		@mutex = Mutex.new
+		@refcount = 1
+		@channel = MessageChannel.new(io) if io
+	end
+
+	def connected?
+		return !!@channel
+	end
+
+	def disconnect
+		@channel.close if @channel
+		@channel = nil
+	end
+
+	def ref
+		@refcount += 1
+	end
+
+	def unref
+		@refcount -= 1
+		if @refcount == 0
+			disconnect
+		end
+	end
+
+	def synchronize
+		@mutex.synchronize do
+			yield
+		end
+	end
+end
+
+end # module UnionStation
+end # module PhusionPassenger

data/lib/phusion_passenger/{analytics_logger.rb → union_station/core.rb}

@@ -22,154 +22,23 @@
 #  THE SOFTWARE.
 
 require 'thread'
+PhusionPassenger.require_passenger_lib 'union_station/connection'
+PhusionPassenger.require_passenger_lib 'union_station/transaction'
 PhusionPassenger.require_passenger_lib 'utils'
-PhusionPassenger.require_passenger_lib 'utils/native_support_utils'
+PhusionPassenger.require_passenger_lib 'utils/lock'
 PhusionPassenger.require_passenger_lib 'debug_logging'
-PhusionPassenger.require_passenger_lib 'message_channel'
 
 module PhusionPassenger
+module UnionStation
 
-class AnalyticsLogger
+class Core
 	RETRY_SLEEP = 0.2
 	NETWORK_ERRORS = [Errno::EPIPE, Errno::ECONNREFUSED, Errno::ECONNRESET,
 		Errno::EHOSTUNREACH, Errno::ENETDOWN, Errno::ENETUNREACH, Errno::ETIMEDOUT]
-	
+
 	include Utils
-	
-	class Log
-		attr_reader :txn_id
-		
-		def initialize(connection = nil, txn_id = nil)
-			if connection
-				@connection = connection
-				@txn_id = txn_id
-				connection.ref
-			end
-		end
-		
-		def null?
-			return !@connection || !@connection.connected?
-		end
-		
-		def message(text)
-			if !@connection
-				timestamp_string = AnalyticsLogger.timestamp_string
-				DebugLogging.trace(3, "[Union Station log to null] #{@txn_id} #{timestamp_string} #{text}")
-				return
-			end
-			@connection.synchronize do
-				return if !@connection.connected?
-				begin
-					timestamp_string = AnalyticsLogger.timestamp_string
-					DebugLogging.trace(3, "[Union Station log] #{@txn_id} #{timestamp_string} #{text}")
-					@connection.channel.write("log", @txn_id, timestamp_string)
-					@connection.channel.write_scalar(text)
-				rescue SystemCallError, IOError => e
-					@connection.disconnect
-					DebugLogging.warn("Error communicating with the logging agent: #{e.message}")
-				rescue Exception => e
-					@connection.disconnect
-					raise e
-				end
-			end
-		end
-		
-		def begin_measure(name, extra_info = nil)
-			if extra_info
-				extra_info_base64 = [extra_info].pack("m")
-				extra_info_base64.gsub!("\n", "")
-				extra_info_base64.strip!
-			else
-				extra_info_base64 = nil
-			end
-			times = Utils::NativeSupportUtils.process_times
-			message "BEGIN: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)}) #{extra_info_base64}"
-		end
-		
-		def end_measure(name, error_encountered = false)
-			times = Utils::NativeSupportUtils.process_times
-			if error_encountered
-				message "FAIL: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
-			else
-				message "END: #{name} (#{current_timestamp.to_s(36)},#{times.utime.to_s(36)},#{times.stime.to_s(36)})"
-			end
-		end
-		
-		def measure(name, extra_info = nil)
-			begin_measure(name, extra_info)
-			begin
-				yield
-			rescue Exception
-				error = true
-				is_closed = closed?
-				raise
-			ensure
-				end_measure(name, error) if !is_closed
-			end
-		end
-		
-		def measured_time_points(name, begin_time, end_time, extra_info = nil)
-			if extra_info
-				extra_info_base64 = [extra_info].pack("m")
-				extra_info_base64.gsub!("\n", "")
-				extra_info_base64.strip!
-			else
-				extra_info_base64 = nil
-			end
-			begin_timestamp = begin_time.to_i * 1_000_000 + begin_time.usec
-			end_timestamp = end_time.to_i * 1_000_000 + end_time.usec
-			message "BEGIN: #{name} (#{begin_timestamp.to_s(36)}) #{extra_info_base64}"
-			message "END: #{name} (#{end_timestamp.to_s(36)})"
-		end
-		
-		def close(flush_to_disk = false)
-			@connection.synchronize do
-				return if !@connection.connected?
-				begin
-					# We need an ACK here. See thread_handler.rb finalize_request.
-					@connection.channel.write("closeTransaction", @txn_id,
-						AnalyticsLogger.timestamp_string, true)
-					result = @connection.channel.read
-					if result != ["ok"]
-						raise "Expected logging agent to respond with 'ok', but got #{result.inspect} instead"
-					end
-					if flush_to_disk
-						@connection.channel.write("flush")
-						result = @connection.channel.read
-						if result != ["ok"]
-							raise "Invalid logging agent response #{result.inspect} to the 'flush' command"
-						end
-					end
-				rescue SystemCallError, IOError => e
-					@connection.disconnect
-					DebugLogging.warn("Error communicating with the logging agent: #{e.message}")
-				rescue Exception => e
-					@connection.disconnect
-					raise e
-				ensure
-					@connection.unref
-					@connection = nil
-				end
-			end if @connection
-		end
-		
-		def closed?
-			if @connection
-				@connection.synchronize do
-					return !@connection.connected?
-				end
-			else
-				return nil
-			end
-		end
-	
-	private
-		def current_timestamp
-			time = AnalyticsLogger.current_time
-			return time.to_i * 1_000_000 + time.usec
-		end
-	end
-	
+	include DebugLogging
+
 	def self.new_from_options(options)
 		if options["analytics"] && options["logging_agent_address"]
 			return new(options["logging_agent_address"],
@@ -180,10 +49,10 @@ class AnalyticsLogger
 			return nil
 		end
 	end
-	
+
 	attr_accessor :max_connect_tries
 	attr_accessor :reconnect_timeout
-	
+
 	def initialize(logging_agent_address, username, password, node_name)
 		@server_address = logging_agent_address
 		@username = username
@@ -194,11 +63,11 @@ class AnalyticsLogger
 			@node_name = `hostname`.strip
 		end
 		@random_dev = File.open("/dev/urandom")
-		
+
 		# This mutex protects the following instance variables, but
 		# not the contents of @connection.
 		@mutex = Mutex.new
-		
+
 		@connection = Connection.new(nil)
 		if @server_address && local_socket_address?(@server_address)
 			@max_connect_tries = 10
@@ -208,7 +77,7 @@ class AnalyticsLogger
 		@reconnect_timeout = 1
 		@next_reconnect_time = Time.utc(1980, 1, 1)
 	end
-	
+
 	def clear_connection
 		@mutex.synchronize do
 			@connection.synchronize do
@@ -218,7 +87,7 @@ class AnalyticsLogger
 			end
 		end
 	end
-	
+
 	def close
 		@mutex.synchronize do
 			@connection.synchronize do
@@ -228,43 +97,43 @@ class AnalyticsLogger
 			end
 		end
 	end
-	
+
 	def new_transaction(group_name, category = :requests, union_station_key = "-")
 		if !@server_address
-			return Log.new
+			return Transaction.new
 		elsif !group_name || group_name.empty?
 			raise ArgumentError, "Group name may not be empty"
 		end
-		
-		txn_id = (AnalyticsLogger.current_time.to_i / 60).to_s(36)
+
+		txn_id = (Core.current_time.to_i / 60).to_s(36)
 		txn_id << "-#{random_token(11)}"
-		
-		Lock.new(@mutex).synchronize do |lock|
+
+		Utils::Lock.new(@mutex).synchronize do |lock|
 			if current_time < @next_reconnect_time
-				return Log.new
+				return Transaction.new
 			end
-			
-			Lock.new(@connection.mutex).synchronize do |connection_lock|
+
+			Utils::Lock.new(@connection.mutex).synchronize do |connection_lock|
 				if !@connection.connected?
 					begin
 						connect
 						connection_lock.reset(@connection.mutex)
 					rescue SystemCallError, IOError
 						@connection.disconnect
-						DebugLogging.warn("Cannot connect to the logging agent at #{@server_address}; " +
+						warn("Cannot connect to the logging agent at #{@server_address}; " +
 							"retrying in #{@reconnect_timeout} second(s).")
 						@next_reconnect_time = current_time + @reconnect_timeout
-						return Log.new
+						return Transaction.new
 					rescue Exception => e
 						@connection.disconnect
 						raise e
 					end
 				end
-				
+
 				begin
 					@connection.channel.write("openTransaction",
 						txn_id, group_name, "", category,
-						AnalyticsLogger.timestamp_string,
+						Core.timestamp_string,
 						union_station_key,
 						true,
 						true)
@@ -272,14 +141,14 @@ class AnalyticsLogger
 					if result != ["ok"]
 						raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
 					end
-					return Log.new(@connection, txn_id)
+					return Transaction.new(@connection, txn_id)
 				rescue SystemCallError, IOError
 					@connection.disconnect
-					DebugLogging.warn("The logging agent at #{@server_address}" <<
+					warn("The logging agent at #{@server_address}" <<
 						" closed the connection; will reconnect in " <<
 						"#{@reconnect_timeout} second(s).")
 					@next_reconnect_time = current_time + @reconnect_timeout
-					return Log.new
+					return Transaction.new
 				rescue Exception => e
 					@connection.disconnect
 					raise e
@@ -287,50 +156,50 @@ class AnalyticsLogger
 			end
 		end
 	end
-	
+
 	def continue_transaction(txn_id, group_name, category = :requests, union_station_key = "-")
 		if !@server_address
-			return Log.new
+			return Transaction.new
 		elsif !txn_id || txn_id.empty?
 			raise ArgumentError, "Transaction ID may not be empty"
 		end
-		
-		Lock.new(@mutex).synchronize do |lock|
+
+		Utils::Lock.new(@mutex).synchronize do |lock|
 			if current_time < @next_reconnect_time
-				return Log.new
+				return Transaction.new
 			end
-			
-			Lock.new(@connection.mutex).synchronize do |connection_lock|
+
+			Utils::Lock.new(@connection.mutex).synchronize do |connection_lock|
 				if !@connection.connected?
 					begin
 						connect
 						connection_lock.reset(@connection.mutex)
 					rescue SystemCallError, IOError
 						@connection.disconnect
-						DebugLogging.warn("Cannot connect to the logging agent at #{@server_address}; " +
+						warn("Cannot connect to the logging agent at #{@server_address}; " +
 							"retrying in #{@reconnect_timeout} second(s).")
 						@next_reconnect_time = current_time + @reconnect_timeout
-						return Log.new
+						return Transaction.new
 					rescue Exception => e
 						@connection.disconnect
 						raise e
 					end
 				end
-				
+
 				begin
 					@connection.channel.write("openTransaction",
 						txn_id, group_name, "", category,
-						AnalyticsLogger.timestamp_string,
+						Core.timestamp_string,
 						union_station_key,
 						true)
-					return Log.new(@connection, txn_id)
+					return Transaction.new(@connection, txn_id)
 				rescue SystemCallError, IOError
 					@connection.disconnect
-					DebugLogging.warn("The logging agent at #{@server_address}" <<
+					warn("The logging agent at #{@server_address}" <<
 						" closed the connection; will reconnect in " <<
 						"#{@reconnect_timeout} second(s).")
 					@next_reconnect_time = current_time + @reconnect_timeout
-					return Log.new
+					return Transaction.new
 				rescue Exception => e
 					@connection.disconnect
 					raise e
@@ -345,82 +214,11 @@ private
 		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
 		'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
-	
-	class Lock
-		def initialize(mutex)
-			@mutex = mutex
-			@locked = false
-		end
-		
-		def reset(mutex, lock_now = true)
-			unlock if @locked
-			@mutex = mutex
-			lock if lock_now
-		end
-		
-		def synchronize
-			lock if !@locked
-			begin
-				yield(self)
-			ensure
-				unlock if @locked
-			end
-		end
-		
-		def lock
-			raise if @locked
-			@mutex.lock
-			@locked = true
-		end
-		
-		def unlock
-			raise if !@locked
-			@mutex.unlock
-			@locked = false
-		end
-	end
-	
-	class Connection
-		attr_reader :mutex
-		attr_accessor :channel
-		
-		def initialize(io)
-			@mutex = Mutex.new
-			@refcount = 1
-			@channel = MessageChannel.new(io) if io
-		end
-		
-		def connected?
-			return !!@channel
-		end
-		
-		def disconnect
-			@channel.close if @channel
-			@channel = nil
-		end
-		
-		def ref
-			@refcount += 1
-		end
-		
-		def unref
-			@refcount -= 1
-			if @refcount == 0
-				disconnect
-			end
-		end
-		
-		def synchronize
-			@mutex.synchronize do
-				yield
-			end
-		end
-	end
-	
+
 	def connect
 		socket  = connect_to_server(@server_address)
 		channel = MessageChannel.new(socket)
-		
+
 		result = channel.read
 		if result.nil?
 			raise EOFError
@@ -429,17 +227,17 @@ private
 		elsif result[1] != "1"
 			raise IOError, "Unsupported logging agent protocol version #{result[1]}"
 		end
-		
+
 		channel.write_scalar(@username)
 		channel.write_scalar(@password)
-		
+
 		result = channel.read
 		if result.nil?
 			raise EOFError
 		elsif result[0] != "ok"
 			raise SecurityError, result[0]
 		end
-		
+
 		channel.write("init", @node_name)
 		args = channel.read
 		if !args
@@ -451,14 +249,14 @@ private
 		elsif args[0] != "ok"
 			raise IOError, "Logging agent returned an invalid reply for the 'init' command"
 		end
-		
+
 		@connection.unref
 		@connection = Connection.new(socket)
 	rescue Exception => e
 		socket.close if socket && !socket.closed?
 		raise e
 	end
-	
+
 	def random_token(length)
 		token = ""
 		@random_dev.read(length).each_byte do |c|
@@ -466,19 +264,20 @@ private
 		end
 		return token
 	end
-	
+
 	def current_time
 		return self.class.current_time
 	end
-	
+
 	def self.current_time
 		return Time.now
 	end
-	
+
 	def self.timestamp_string(time = current_time)
 		timestamp = time.to_i * 1_000_000 + time.usec
 		return timestamp.to_s(36)
 	end
 end
 
+end # module UnionStation
 end # module PhusionPassenger