passenger_dudemeister 3.0.1

data/lib/phusion_passenger/rails3_extensions/init.rb

@@ -0,0 +1,207 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2010 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.
+
+require 'phusion_passenger/constants'
+require 'digest/md5'
+
+module PhusionPassenger
+
+module Rails3Extensions
+	def self.init!(options)
+		if !AnalyticsLogging.install!(options)
+			# Remove code to save memory.
+			PhusionPassenger::Rails3Extensions.send(:remove_const, :AnalyticsLogging)
+			PhusionPassenger.send(:remove_const, :Rails3Extensions)
+		end
+	end
+end
+
+module Rails3Extensions
+class AnalyticsLogging < ActiveSupport::LogSubscriber
+	def self.install!(options)
+		analytics_logger = options["analytics_logger"]
+		return false if !analytics_logger || !options["analytics"]
+		
+		# If the Ruby interpreter supports GC statistics then turn it on
+		# so that the info can be logged.
+		GC.enable_stats if GC.respond_to?(:enable_stats)
+		
+		subscriber = self.new
+		AnalyticsLogging.attach_to(:action_controller, subscriber)
+		AnalyticsLogging.attach_to(:active_record, subscriber)
+		if defined?(ActiveSupport::Cache::Store)
+			ActiveSupport::Cache::Store.instrument = true
+			AnalyticsLogging.attach_to(:active_support, subscriber)
+		end
+		
+		if defined?(ActionDispatch::ShowExceptions)
+			Rails.application.middleware.insert_after(
+				ActionDispatch::ShowExceptions,
+				ExceptionLogger, analytics_logger)
+		end
+		
+		if defined?(ActionController::Base)
+			ActionController::Base.class_eval do
+				include ACExtension
+			end
+		end
+		
+		if defined?(ActiveSupport::Benchmarkable)
+			ActiveSupport::Benchmarkable.class_eval do
+				include ASBenchmarkableExtension
+				alias_method_chain :benchmark, :passenger
+			end
+		end
+		
+		return true
+	end
+	
+	def process_action(event)
+		log = Thread.current[PASSENGER_ANALYTICS_WEB_LOG]
+		if log
+			view_runtime = event.payload[:view_runtime]
+			log.message("View rendering time: #{(view_runtime * 1000).to_i}") if view_runtime
+		end
+	end
+	
+	def sql(event)
+		log = Thread.current[PASSENGER_ANALYTICS_WEB_LOG]
+		if log
+			name = event.payload[:name]
+			sql = event.payload[:sql]
+			digest = Digest::MD5.hexdigest("#{name}\0#{sql}\0#{rand}")
+			log.measured_time_points("DB BENCHMARK: #{digest}",
+				event.time, event.end, "#{name}\n#{sql}")
+		end
+	end
+	
+	def cache_read(event)
+		if event.payload[:hit]
+			PhusionPassenger.log_cache_hit(nil, event.payload[:key])
+		else
+			PhusionPassenger.log_cache_miss(nil, event.payload[:key])
+		end
+	end
+	
+	def cache_fetch_hit(event)
+		PhusionPassenger.log_cache_hit(nil, event.payload[:key])
+	end
+	
+	def cache_generate(event)
+		PhusionPassenger.log_cache_miss(nil, event.payload[:key],
+			event.duration * 1000)
+	end
+	
+	class ExceptionLogger
+		def initialize(app, analytics_logger)
+			@app = app
+			@analytics_logger = analytics_logger
+		end
+		
+		def call(env)
+			@app.call(env)
+		rescue Exception => e
+			log_analytics_exception(env, e) if env[PASSENGER_TXN_ID]
+			raise e
+		end
+	
+	private
+		def log_analytics_exception(env, exception)
+			log = @analytics_logger.new_transaction(
+				env[PASSENGER_GROUP_NAME],
+				:exceptions,
+				env[PASSENGER_UNION_STATION_KEY])
+			begin
+				request = ActionDispatch::Request.new(env)
+				controller = request.parameters['controller'].humanize + "Controller"
+				action = request.parameters['action']
+				
+				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", "")
+				if action
+					controller_action = "#{controller}##{action}"
+				else
+					controller_action = controller
+				end
+				
+				log.message("Request transaction ID: #{request_txn_id}")
+				log.message("Message: #{message}")
+				log.message("Class: #{exception.class.name}")
+				log.message("Backtrace: #{backtrace_string}")
+				log.message("Controller action: #{controller_action}")
+			ensure
+				log.close
+			end
+		end
+	end
+	
+	module ACExtension
+		def process_action(action, *args)
+			log = request.env[PASSENGER_ANALYTICS_WEB_LOG]
+			if log
+				log.message("Controller action: #{self.class.name}##{action_name}")
+				log.measure("framework request processing") do
+					super
+				end
+			else
+				super
+			end
+		end
+		
+		def render(*args)
+			log = request.env[PASSENGER_ANALYTICS_WEB_LOG]
+			if log
+				log.measure("view rendering") do
+					super
+				end
+			else
+				super
+			end
+		end
+	end
+	
+	module ASBenchmarkableExtension
+		def benchmark_with_passenger(message = "Benchmarking", *args)
+			log = Thread.current[PASSENGER_ANALYTICS_WEB_LOG]
+			if log
+				log.measure("BENCHMARK: #{message}") do
+					benchmark_without_passenger(message, *args) do
+						yield
+					end
+				end
+			else
+				benchmark_without_passenger(message, *args) do
+					yield
+				end
+			end
+		end
+	end
+end # class AnalyticsLogging
+end # module Rails3Extensions
+
+end # module PhusionPassenger

data/lib/phusion_passenger/simple_benchmarking.rb

@@ -0,0 +1,52 @@
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2010 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.
+
+class Object # :nodoc:
+	@@benchmark_results = {}
+
+	def b!(name)
+		time1 = Time.now
+		begin
+			yield
+		ensure
+			time2 = Time.now
+			@@benchmark_results[name] = 0 unless @@benchmark_results.has_key?(name)
+			@@benchmark_results[name] += time2 - time1
+		end 
+	end
+
+	def benchmark_report(main = nil)
+		total = 0
+		if main.nil?
+			@@benchmark_results.each_value do |time|
+				total += time
+			end
+		else
+			total = @@benchmark_results[main]
+		end
+		@@benchmark_results.each_pair do |name, time|
+			printf "%-12s: %.4f (%.2f%%)\n", name, time, time / total * 100
+		end
+		printf "-- Total: %.4f\n", total
+	end
+end

data/lib/phusion_passenger/spawn_manager.rb

@@ -0,0 +1,359 @@
+# encoding: binary
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2010 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.
+
+require 'phusion_passenger'
+require 'phusion_passenger/abstract_server'
+require 'phusion_passenger/abstract_server_collection'
+require 'phusion_passenger/constants'
+require 'phusion_passenger/utils'
+
+# Define a constant with a name that's unlikely to clash with anything the
+# application defines, so that they can detect whether they're running under
+# Phusion Passenger.
+IN_PHUSION_PASSENGER = true
+
+module PhusionPassenger
+
+# The spawn manager is capable of spawning Ruby on Rails or Rack application
+# instances. It acts like a simple fascade for the rest of the spawn manager
+# system.
+#
+# *Note*: SpawnManager may only be started synchronously with
+# AbstractServer#start_synchronously. Starting asynchronously has not been
+# tested. Don't forget to call cleanup after the server's main loop has
+# finished.
+#
+# == Ruby on Rails optimizations
+#
+# Spawning a Ruby on Rails application is usually slow. But SpawnManager
+# will preload and cache Ruby on Rails frameworks, as well as application
+# code, so subsequent spawns will be very fast.
+#
+# Internally, SpawnManager uses ClassicRails::FrameworkSpawner to preload and cache
+# Ruby on Rails frameworks. ClassicRails::FrameworkSpawner, in turn, uses
+# ClassicRails::ApplicationSpawner to preload and cache application code.
+#
+# In case you're wondering why the namespace is "ClassicRails" and not "Rails":
+# it's to work around an obscure bug in ActiveSupport's Dispatcher.
+class SpawnManager < AbstractServer
+	include Utils
+	
+	def initialize(options = {})
+		super("", "")
+		@options = options
+		@spawners = AbstractServerCollection.new
+		define_message_handler(:spawn_application, :handle_spawn_application)
+		define_message_handler(:reload, :handle_reload)
+		define_signal_handler('SIGHUP', :reload)
+		
+		# Start garbage collector in order to free up some existing
+		# heap slots. This prevents the heap from growing unnecessarily
+		# during the startup phase.
+		GC.start
+		if GC.copy_on_write_friendly?
+			# Preload libraries for copy-on-write semantics.
+			require 'base64'
+			require 'phusion_passenger/app_process'
+			require 'phusion_passenger/classic_rails/framework_spawner'
+			require 'phusion_passenger/classic_rails/application_spawner'
+			require 'phusion_passenger/rack/application_spawner'
+			require 'phusion_passenger/html_template'
+			require 'phusion_passenger/platform_info'
+			require 'phusion_passenger/exceptions'
+		end
+	end
+	
+	# Spawns an application with the given spawn options. When successful, an
+	# AppProcess object will be returned, which represents the spawned application
+	# process.
+	#
+	# Most options are explained in PoolOptions.h.
+	#
+	# Mandatory options:
+	# - 'app_root'
+	#
+	# Optional options:
+	# - 'app_type'
+	# - 'environment'
+	# - 'spawn_method'
+	# - 'user',
+	# - 'group'
+	# - 'default_user'
+	# - 'default_group'
+	# - 'framework_spawner_timeout'
+	# - 'app_spawner_timeout'
+	# - 'environment_variables': Environment variables which should be passed
+	#   to the spawned application process. This is NULL-seperated string of
+	#   key-value pairs, encoded in base64. The last byte in the unencoded
+	#   data must be a NULL.
+	# - 'base_uri'
+	# - 'print_exceptions'
+	#
+	# <b>Exceptions:</b>
+	# - InvalidPath: +app_root+ doesn't appear to be a valid Ruby on Rails application root.
+	# - VersionNotFound: The Ruby on Rails framework version that the given application requires
+	#   is not installed.
+	# - AbstractServer::ServerError: One of the server processes exited unexpectedly.
+	# - FrameworkInitError: The Ruby on Rails framework that the application requires could not be loaded.
+	# - AppInitError: The application raised an exception or called exit() during startup.
+	def spawn_application(options)
+		if !options["app_root"]
+			raise ArgumentError, "The 'app_root' option must be given."
+		end
+		options = sanitize_spawn_options(options)
+		
+		case options["app_type"]
+		when "rails"
+			if !defined?(ClassicRails::FrameworkSpawner)
+				require 'phusion_passenger/classic_rails/framework_spawner'
+				require 'phusion_passenger/classic_rails/application_spawner'
+			end
+			return spawn_rails_application(options)
+		when "rack"
+			if !defined?(Rack::ApplicationSpawner)
+				require 'phusion_passenger/rack/application_spawner'
+			end
+			return spawn_rack_application(options)
+		when "wsgi"
+			if !defined?(WSGI::ApplicationSpawner)
+				require 'phusion_passenger/wsgi/application_spawner'
+			end
+			return WSGI::ApplicationSpawner.spawn_application(options)
+		else
+			raise ArgumentError, "Unknown 'app_type' value '#{options["app_type"]}'."
+		end
+	end
+	
+	# Remove the cached application instances at the given group name.
+	# If nil is specified as group name, then all cached application
+	# instances will be removed, no matter the group name.
+	#
+	# <b>Long description:</b>
+	# Application code might be cached in memory. But once it a while, it will
+	# be necessary to reload the code for an application, such as after
+	# deploying a new version of the application. This method makes sure that
+	# any cached application code is removed, so that the next time an
+	# application instance is spawned, the application code will be freshly
+	# loaded into memory.
+	#
+	# Raises AbstractServer::SpawnError if something went wrong.
+	def reload(app_group_name = nil)
+		@spawners.synchronize do
+			if app_group_name
+				# Stop and delete associated ApplicationSpawner.
+				@spawners.delete("app:#{app_group_name}")
+				# Propagate reload command to associated FrameworkSpawner.
+				@spawners.each do |spawner|
+					if spawner.respond_to?(:reload)
+						spawner.reload(app_group_name)
+					end
+				end
+			else
+				# Stop and delete all spawners.
+				@spawners.clear
+			end
+		end
+	end
+	
+	# Cleanup resources. Should be called when this SpawnManager is no longer needed.
+	def cleanup
+		@spawners.cleanup
+	end
+
+private
+	def spawn_rails_application(options)
+		app_root       = options["app_root"]
+		app_group_name = options["app_group_name"]
+		spawn_method   = options["spawn_method"]
+		spawner        = nil
+		create_spawner = nil
+		key            = nil
+		
+		case spawn_method
+		when nil, "", "smart", "smart-lv2"
+			if spawn_method != "smart-lv2"
+				framework_version = AppProcess.detect_framework_version(app_root)
+			end
+			if framework_version.nil? || framework_version == :vendor
+				key = "app:#{app_group_name}"
+				create_spawner = proc do
+					ClassicRails::ApplicationSpawner.new(@options.merge(options))
+				end
+				spawner_timeout = options["app_spawner_timeout"]
+			else
+				key = "version:#{framework_version}"
+				create_spawner = proc do
+					options["framework_version"] = framework_version
+					ClassicRails::FrameworkSpawner.new(@options.merge(options))
+				end
+				spawner_timeout = options["framework_spawner_timeout"]
+			end
+			
+			@spawners.synchronize do
+				spawner = @spawners.lookup_or_add(key) do
+					spawner = create_spawner.call
+					if spawner_timeout != -1
+						spawner.max_idle_time = spawner_timeout
+					end
+					spawner.start
+					spawner
+				end
+				begin
+					return spawner.spawn_application(options)
+				rescue AbstractServer::ServerError
+					@spawners.delete(key)
+					raise
+				end
+			end
+		else
+			return ClassicRails::ApplicationSpawner.spawn_application(
+				@options.merge(options))
+		end
+	end
+	
+	def spawn_rack_application(options)
+		app_group_name = options["app_group_name"]
+		spawn_method   = options["spawn_method"]
+		spawner        = nil
+		create_spawner = nil
+		key            = nil
+		
+		case spawn_method
+		when nil, "", "smart", "smart-lv2"
+			@spawners.synchronize do
+				key = "app:#{app_group_name}"
+				spawner = @spawners.lookup_or_add(key) do
+					spawner_timeout = options["app_spawner_timeout"]
+					spawner = Rack::ApplicationSpawner.new(
+						@options.merge(options))
+					if spawner_timeout != -1
+						spawner.max_idle_time = spawner_timeout
+					end
+					spawner.start
+					spawner
+				end
+				begin
+					return spawner.spawn_application(options)
+				rescue AbstractServer::ServerError
+					@spawners.delete(key)
+					raise
+				end
+			end
+		else
+			return Rack::ApplicationSpawner.spawn_application(
+				@options.merge(options))
+		end
+	end
+	
+	def handle_spawn_application(client, *options)
+		options     = sanitize_spawn_options(Hash[*options])
+		app_process = nil
+		app_root    = options["app_root"]
+		app_type    = options["app_type"]
+		begin
+			app_process = spawn_application(options)
+		rescue AbstractServer::ServerError => e
+			send_error_page(client, 'general_error', :error => e)
+		rescue VersionNotFound => e
+			send_error_page(client, 'version_not_found', :error => e, :app_root => app_root)
+		rescue AppInitError => e
+			if database_error?(e)
+				send_error_page(client, 'database_error', :error => e,
+					:app_root => app_root, :app_name => app_name(app_type),
+					:app_type => app_type)
+			elsif load_error?(e)
+				# A source file failed to load, maybe because of a
+				# missing gem. If that's the case then the sysadmin
+				# will install probably the gem. So we clear RubyGems's
+				# cache so that it can detect new gems.
+				Gem.clear_paths
+				send_error_page(client, 'load_error', :error => e, :app_root => app_root,
+					:app_name => app_name(app_type))
+			elsif e.child_exception.is_a?(SystemExit)
+				send_error_page(client, 'app_exited_during_initialization', :error => e,
+					:app_root => app_root, :app_name => app_name(app_type))
+			else
+				send_error_page(client, 'app_init_error', :error => e,
+					:app_root => app_root, :app_name => app_name(app_type))
+			end
+		rescue FrameworkInitError => e
+			send_error_page(client, 'framework_init_error', :error => e)
+		end
+		if app_process
+			begin
+				client.write('ok')
+				app_process.write_to_channel(client)
+			rescue Errno::EPIPE
+				# The Apache module may be interrupted during a spawn command,
+				# in which case it will close the connection. We ignore this error.
+			ensure
+				app_process.close
+			end
+		end
+	end
+	
+	def handle_reload(client, app_group_name)
+		reload(app_group_name)
+	end
+	
+	def send_error_page(channel, template_name, options = {})
+		require 'phusion_passenger/html_template' unless defined?(HTMLTemplate)
+		if !defined?(PlatformInfo)
+			require 'phusion_passenger/platform_info'
+			require 'phusion_passenger/platform_info/ruby'
+		end
+		options["enterprisey"] = File.exist?("#{SOURCE_ROOT}/enterprisey.txt") ||
+			File.exist?("/etc/passenger_enterprisey.txt")
+		data = HTMLTemplate.new(template_name, options).result
+		channel.write('error_page')
+		channel.write_scalar(data)
+	end
+	
+	def database_error?(e)
+		return ( defined?(Mysql::Error) && e.child_exception.is_a?(Mysql::Error) ) ||
+		       ( e.child_exception.is_a?(UnknownError) &&
+		           (
+		               e.child_exception.real_class_name =~ /^ActiveRecord/ ||
+		               e.child_exception.real_class_name =~ /^Mysql::/
+		           )
+		       )
+	end
+	
+	def load_error?(e)
+		return e.child_exception.is_a?(LoadError) || (
+		           e.child_exception.is_a?(UnknownError) &&
+		           e.child_exception.real_class_name == "MissingSourceFile"
+		)
+	end
+	
+	def app_name(app_type)
+		if app_type == "rails"
+			return "Ruby on Rails"
+		else
+			return "Ruby (Rack)"
+		end
+	end
+end
+
+end # module PhusionPassenger