wd_newrelic_rpm 3.3.4.1

data/lib/new_relic/control/profiling.rb

@@ -0,0 +1,25 @@
+module NewRelic
+  class Control
+    module Profiling
+
+      # A flag used in dev mode to indicate if profiling is available
+      def profiling?
+        @profiling
+      end
+
+      def profiling_available?
+        @profiling_available ||=
+          begin
+            require 'ruby-prof'
+            true
+          rescue LoadError; end
+      end
+      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+      # loaded a true value is ignored.
+      def profiling=(val)
+        @profiling = profiling_available? && val && defined?(RubyProf)
+      end
+    end
+    include Profiling
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,114 @@
+module NewRelic
+  class Control
+
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+    
+    # Contains methods that deal with connecting to the server
+    module ServerMethods
+      
+      def server
+        @remote_server ||= server_from_host(nil)
+      end
+      
+      # the server we should contact for api requests, like uploading
+      # deployments and the like
+      def api_server
+        api_host = self['api_host'] || 'rpm.newrelic.com'
+        @api_server ||=
+          NewRelic::Control::Server.new \
+        api_host,
+        (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
+        nil
+      end
+      
+      # a new instances of the proxy server - this passes through if
+      # there is no proxy, otherwise it has proxy configuration
+      # information pulled from the config file
+      def proxy_server
+        @proxy_server ||=
+          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+      end
+      
+      # turns a hostname into an ip address and returns a
+      # NewRelic::Control::Server that contains the configuration info
+      def server_from_host(hostname=nil)
+        host = hostname || self['host'] || 'collector.newrelic.com'
+
+        # if the host is not an IP address, turn it into one
+        NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host)
+      end
+
+      # Check to see if we need to look up the IP address
+      # If it's an IP address already, we pass it through.
+      # If it's nil, or localhost, we don't bother.
+      # Otherwise, use `resolve_ip_address` to find one
+      def convert_to_ip_address(host)
+        # here we leave it as a host name since the cert verification
+        # needs it in host form
+        return host if verify_certificate?
+        return nil if host.nil? || host.downcase == "localhost"
+        ip = resolve_ip_address(host)
+        log.info "Resolved #{host} to #{ip}"
+        ip
+      end
+
+      # Look up the ip address of the host using the pure ruby lookup
+      # to prevent blocking.  If that fails, fall back to the regular
+      # IPSocket library.  Return nil if we can't find the host ip
+      # address and don't have a good default.
+      def resolve_ip_address(host)
+        Resolv.getaddress(host)
+      rescue => e
+        log.warn("DNS Error caching IP address: #{e}")
+        log.debug(e.backtrace.join("\n   "))
+        begin
+          log.info("Trying native DNS lookup since Resolv failed")
+          IPSocket.getaddress(host)
+        rescue => e
+          log.error("Could not look up server address: #{e}")
+          nil
+        end
+      end
+      
+      # The path to the certificate file used to verify the SSL
+      # connection if verify_peer is enabled
+      def cert_file_path
+        File.expand_path(File.join(newrelic_root, 'cert', 'cacert.pem'))
+      end
+
+      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+      # Default is the collector but for api calls you need to pass api_server
+      #
+      # Experimental support for SSL verification:
+      # swap 'VERIFY_NONE' for 'VERIFY_PEER' line to try it out
+      # If verification fails, uncomment the 'http.ca_file' line
+      # and it will use the included certificate.
+      def http_connection(host = nil)
+        host ||= server
+        # Proxy returns regular HTTP if @proxy_host is nil (the default)
+        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
+                                      proxy_server.user, proxy_server.password)
+        http = http_class.new(host.ip || host.name, host.port)
+        log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
+        if use_ssl?
+          http.use_ssl = true
+          if verify_certificate?
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = cert_file_path
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+        http
+      end
+    end
+
+    include ServerMethods
+  end
+end
+

data/lib/new_relic/data_serialization.rb

@@ -0,0 +1,151 @@
+require 'fileutils'
+require 'new_relic/language_support'
+
+module NewRelic
+  # Handles serialization of data to disk, to save on contacting the
+  # server. Lowers both server and client overhead, if the disk is not overloaded
+  class DataSerialization
+    include NewRelic::LanguageSupport::DataSerialization
+    
+    module ClassMethods
+      # Check whether the store is too large, too old, or the
+      # pid file is too old. If so, we should send the data
+      # right away. If not, we presumably store it for later sending
+      # (handled elsewhere)
+      def should_send_data?
+        NewRelic::Control.instance.disable_serialization? || store_too_large? ||
+          store_too_old? || pid_too_old? ||
+          NewRelic::LanguageSupport.using_version?('1.8.6')
+      rescue => e
+        NewRelic::Control.instance.disable_serialization = true
+        NewRelic::Control.instance.log.warn("Disabling serialization: #{e.message}")
+        true
+      end
+
+      # A combined locked read/write from the store file - reduces
+      # contention by not acquiring the lock and file handle twice
+      def read_and_write_to_file
+        with_locked_store do |f|
+          result = (yield get_data_from_file(f))
+          f.rewind
+          f.truncate(0)
+          write_contents_nonblockingly(f, dump(result)) if result
+        end
+      rescue Errno::ENOENT => e
+        NewRelic::Control.instance.log.warn(e.message)
+      end
+      
+      # touches the age file that determines whether we should send
+      # data now or not
+      def update_last_sent!
+        FileUtils.touch(pid_file_path)
+      end
+      
+      def pid_too_old?
+        return true unless File.exists?(pid_file_path)
+        age = (Time.now.to_i - File.mtime(pid_file_path).to_i)
+        NewRelic::Control.instance.log.debug("Pid was #{age} seconds old, sending data") if age > 60
+        age > 60
+      end
+      
+      def store_too_old?
+        return true unless File.exists?(file_path)
+        age = (Time.now.to_i - File.mtime(file_path).to_i)
+        NewRelic::Control.instance.log.debug("Store was #{age} seconds old, sending data") if age > 60
+        age > 50
+      end      
+    
+      def store_too_large?
+        return true unless File.exists?(file_path)
+        size = File.size(file_path) > max_size
+        NewRelic::Control.instance.log.debug("Store was oversize, sending data") if size
+        size
+      end
+      
+      private
+      
+      def open_arguments
+        if defined?(Encoding)
+          [file_path, File::RDWR | File::CREAT, {:internal_encoding => nil}]
+        else
+          [file_path, File::RDWR | File::CREAT]
+        end
+      end
+      
+      def with_locked_store
+        File.open(*open_arguments) do |f|
+          f.flock(File::LOCK_EX)
+          begin
+            yield(f)
+          ensure
+            f.flock(File::LOCK_UN)
+          end
+        end
+      rescue => e
+        NewRelic::Control.instance.log.error("Error serializing data to disk: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.split("\n"))
+        # re-raise so that serialization will be disabled higher up the stack
+        raise e
+      end
+
+      def get_data_from_file(f)
+        data = read_until_eof_error(f)
+        result = load(data)
+        f.truncate(0)
+        result
+      end
+
+      def write_contents_nonblockingly(f, string)
+        result = 0
+        while (result < string.length)
+          result += f.write_nonblock(string)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select(nil, [f])
+        retry
+      end
+
+      def read_until_eof_error(f)
+        accumulator = ""
+        while(true)
+          accumulator << f.read_nonblock(10_000)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select([f])
+        retry
+      rescue EOFError
+        accumulator
+      end
+      
+      def max_size
+        10_000
+      end
+
+      def dump(object)
+        Marshal.dump(object.clone)
+      end
+      
+      def load(dump)
+        if dump.respond_to?(:size) && dump.size == 0
+          NewRelic::Control.instance.log.debug("Spool file empty.")
+          return nil
+        end
+        Marshal.load(dump)
+      rescue ArgumentError, TypeError => e
+        NewRelic::Control.instance.log.error("Error loading data from newrelic_agent_store.db: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.inspect)
+        nil
+      end
+            
+      def file_path
+        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.db"
+      end
+
+      def pid_file_path
+        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.pid"
+      end
+    end
+    extend ClassMethods
+  end
+end
+

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,51 @@
+require 'dependency_detection'
+# This installs some code to manually start the agent when a delayed
+# job worker starts.  It's not really instrumentation.  It's more like
+# a hook from DJ to the Ruby Agent so it gets loaded at the time the
+# Ruby Agent initializes, which must be before the DJ worker
+# initializes.  Loaded from control.rb
+module NewRelic
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end
+
+DependencyDetection.defer do
+  @name = :delayed_job_injection
+  
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
+  end
+  
+  executes do
+    if NewRelic::Agent.respond_to?(:logger)
+      NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation hooks'
+    end
+  end
+  
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_new_relic(*args)
+        initialize_without_new_relic(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+        say "New Relic Ruby Agent Monitoring DJ worker #{dispatcher_instance_id}"
+        NewRelic::DelayedJobInjection.worker_name = worker_name
+        NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+      end
+
+      alias initialize_without_new_relic initialize
+      alias initialize initialize_with_new_relic
+    end
+  end
+end
+
+# If Rails is defined, this gets called in an after_initialize hook
+# see NewRelic::Control::Frameworks::Rails#init_config
+unless defined?(Rails)
+  DependencyDetection.detect!
+end

data/lib/new_relic/language_support.rb

@@ -0,0 +1,73 @@
+module NewRelic::LanguageSupport
+  extend self
+  
+  module DataSerialization
+    def self.included(base)
+      # need to disable GC during marshal load in 1.8.7
+      if NewRelic::LanguageSupport.using_version?('1.8.7') &&
+          !NewRelic::LanguageSupport.using_engine?('jruby') &&
+          !NewRelic::LanguageSupport.using_engine?('rbx')
+        base.class_eval do
+          def self.load(*args)
+            if defined?(::GC) && ::GC.respond_to?(:disable)
+              ::GC.disable
+              val = super
+              ::GC.enable
+              val
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module Control
+    def self.included(base)
+      # need to use syck rather than psych when possible
+      if defined?(::YAML::ENGINE)
+        if !NewRelic::LanguageSupport.using_engine?('jruby') &&
+            (NewRelic::LanguageSupport.using_version?('1.9.1') ||
+             NewRelic::LanguageSupport.using_version?('1.9.2'))
+          base.class_eval do
+            def load_newrelic_yml(*args)
+              yamler = ::YAML::ENGINE.yamler
+              ::YAML::ENGINE.yamler = 'syck'
+              val = super
+              ::YAML::ENGINE.yamler = yamler
+              val
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module SynchronizedHash
+    def self.included(base)
+      # need to lock iteration of stats hash in 1.9.x
+      if NewRelic::LanguageSupport.using_version?('1.9') ||
+          NewRelic::LanguageSupport.using_engine?('jruby')
+        base.class_eval do
+          def each(*args, &block)
+            @lock.synchronize { super }
+          end
+        end
+      end
+    end
+  end
+  
+  def using_engine?(engine)
+    if defined?(::RUBY_ENGINE)
+      ::RUBY_ENGINE == engine
+    else
+      engine == 'ruby'
+    end
+  end
+  
+  def using_version?(version)
+    numbers = version.split('.')
+    numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
+  end
+end

data/lib/new_relic/local_environment.rb

@@ -0,0 +1,428 @@
+require 'set'
+require 'new_relic/version'
+
+module NewRelic
+  # An instance of LocalEnvironment is responsible for determining
+  # three things:
+  #
+  # * Framework - :rails, :rails3, :merb, :ruby, :external, :test
+  # * Dispatcher - A supported dispatcher, or nil (:mongrel, :thin, :passenger, :webrick, etc)
+  # * Dispatcher Instance ID, which distinguishes agents on a single host from each other
+  #
+  # If the environment can't be determined, it will be set to
+  # nil and dispatcher_instance_id will have nil.
+  #
+  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
+  class LocalEnvironment
+    
+    # mongrel, thin, webrick, or possibly nil
+    attr_accessor :dispatcher
+    # used to distinguish instances of a dispatcher from each other, may be nil
+    attr_writer :dispatcher_instance_id
+    # rails, rails3, merb, external, ruby, test, etc
+    attr_accessor :framework
+    # The number of cpus, if detected, or nil - many platforms do not
+    # support this :(
+    attr_reader :processors 
+    alias environment dispatcher
+
+    def initialize
+      # Extend self with any any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new framworks and dispatchers.
+      NewRelic::LocalEnvironment.constants.each do | const |
+        mod = NewRelic::LocalEnvironment.const_get const
+        self.extend mod if mod.instance_of? Module
+      end
+
+      discover_framework
+      discover_dispatcher
+      @dispatcher = nil if @dispatcher == :none
+      @gems = Set.new
+      @plugins = Set.new
+      @config = Hash.new
+    end
+
+    # Add the given key/value pair to the app environment
+    # settings.  Must pass either a value or a block.  Block
+    # is called to get the value and any raised errors are
+    # silently ignored.
+    def append_environment_value(name, value = nil)
+      value = yield if block_given?
+      @config[name] = value if value
+    rescue
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+    
+    # yields to the block and appends the returned value to the list
+    # of gems - this catches errors that might be raised in the block
+    def append_gem_list
+      @gems += yield
+    rescue => e
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+    
+    # yields to the block and appends the returned value to the list
+    # of plugins - this catches errors that might be raised in the block
+    def append_plugin_list
+      @plugins += yield
+    rescue
+      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      raise if @framework == :test
+    end
+    
+    # An instance id pulled from either @dispatcher_instance_id or by
+    # splitting out the first part of the running file
+    def dispatcher_instance_id
+      if @dispatcher_instance_id.nil?
+        if @dispatcher.nil?
+          @dispatcher_instance_id = File.basename($0).split(".").first
+        end
+      end
+      @dispatcher_instance_id
+    end
+    
+    # Interrogates some common ruby constants for useful information
+    # about what kind of ruby environment the agent is running in
+    def gather_ruby_info
+      append_environment_value('Ruby version'){ RUBY_VERSION }
+      append_environment_value('Ruby description'){ RUBY_DESCRIPTION } if defined? ::RUBY_DESCRIPTION
+      append_environment_value('Ruby platform') { RUBY_PLATFORM }
+      append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
+      # room here for other ruby implementations, when.
+      if defined? ::JRUBY_VERSION
+        gather_jruby_info
+      end
+    end
+    
+    # like gather_ruby_info but for the special case of JRuby
+    def gather_jruby_info
+      append_environment_value('JRuby version') { JRUBY_VERSION }
+      append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
+    end
+
+    # See what the number of cpus is, works only on some linux variants
+    def gather_cpu_info(proc_file='/proc/cpuinfo')
+      return unless File.readable? proc_file
+      @processors = append_environment_value('Processors') do
+        cpuinfo = ''
+        File.open(proc_file) do |f|
+          loop do
+            begin
+              cpuinfo << f.read_nonblock(4096).strip
+            rescue EOFError
+              break
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+              cpuinfo = ''
+              break # don't select file handle, just give up
+            end
+          end
+        end
+        processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
+
+        if processors == 0
+          processors = 1 # assume there is at least one processor
+          NewRelic::Agent.logger.warn("Cannot determine the number of processors in #{proc_file}")
+        end
+        processors
+      end
+    end
+    
+    # Grabs the architecture string from either `uname -p` or the env
+    # variable PROCESSOR_ARCHITECTURE
+    def gather_architecture_info
+      append_environment_value('Arch') { `uname -p` } ||
+        append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
+    end
+    
+    # gathers OS info from either `uname -v`, `uname -s`, or the OS
+    # env variable
+    def gather_os_info
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+        append_environment_value('OS') { ENV['OS'] }
+    end
+    
+    # Gathers the architecture and cpu info
+    def gather_system_info
+      gather_architecture_info
+      gather_cpu_info
+    end
+    
+    # Looks for a capistrano file indicating the current revision
+    def gather_revision_info
+      rev_file = File.join(NewRelic::Control.instance.root, "REVISION")
+      if File.readable?(rev_file) && File.size(rev_file) < 64
+        append_environment_value('Revision') do
+          File.open(rev_file) { | file | file.readline.strip }
+        end
+      end
+    end
+    
+    # The name of the AR database adapter for the current environment and
+    # the current schema version
+    def gather_ar_adapter_info
+      
+      append_environment_value 'Database adapter' do
+        if defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.respond_to?(:configurations)
+          config = ActiveRecord::Base.configurations[NewRelic::Control.instance.env]
+          if config
+            config['adapter']
+          end
+        end
+      end
+    end
+    
+    # Datamapper version
+    def gather_dm_adapter_info
+      append_environment_value 'DataMapper version' do
+        require 'dm-core/version'
+        DataMapper::VERSION
+      end
+    end
+    
+    # sensing for which adapter is defined, then appends the relevant
+    # config information
+    def gather_db_info
+      # room here for more database adapters, when.
+      if defined? ::ActiveRecord
+        gather_ar_adapter_info
+      end
+      if defined? ::DataMapper
+        gather_dm_adapter_info
+      end
+    end
+
+    # Collect base statistics about the environment and record them for
+    # comparison and change detection.
+    def gather_environment_info
+      append_environment_value 'Framework', @framework.to_s
+      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
+      append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
+      append_environment_value('Environment') { NewRelic::Control.instance.env }
+
+      # miscellaneous other helpful debugging information
+      gather_ruby_info
+      gather_system_info
+      gather_revision_info
+      gather_db_info
+    end
+
+    # Take a snapshot of the environment information for this application
+    # Returns an associative array
+    def snapshot
+      i = @config.to_a
+      i << [ 'Plugin List', @plugins.to_a] if not @plugins.empty?
+      i << [ 'Gems', @gems.to_a] if not @gems.empty?
+      i
+    end
+    
+    # it's a working jruby if it has the runtime method, and object
+    # space is enabled
+    def working_jruby?
+      !(defined?(::JRuby) && JRuby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
+    end
+    
+    # Runs through all the objects in ObjectSpace to find the first one that
+    # match the provided class
+    def find_class_in_object_space(klass)
+      ObjectSpace.each_object(klass) do |x|
+        return x
+      end
+      return nil
+    end
+    
+    # Sets the @mongrel instance variable if we can find a Mongrel::HttpServer
+    def mongrel
+      return @mongrel if @mongrel
+      if defined?(::Mongrel) && defined?(::Mongrel::HttpServer) && working_jruby?
+        @mongrel = find_class_in_object_space(::Mongrel::HttpServer)
+      end
+      @mongrel
+    end
+    
+    private
+
+    # Although you can override the framework with NEWRELIC_DISPATCHER this
+    # is not advisable since it implies certain api's being available.
+    def discover_dispatcher
+      @dispatcher ||= ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
+      @dispatcher ||= ENV['NEW_RELIC_DISPATCHER'] && ENV['NEW_RELIC_DISPATCHER'].to_sym
+      dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
+      while dispatchers.any? && @dispatcher.nil?
+        send 'check_for_'+(dispatchers.shift)
+      end
+    end
+
+    def discover_framework
+      # Although you can override the framework with NEWRELIC_FRAMEWORK this
+      # is not advisable since it implies certain api's being available.
+      #
+      # Note that the odd defined? sequence is necessary to work around a bug in an older version
+      # of JRuby.
+      @framework ||= case
+                     when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
+                     when ENV['NEW_RELIC_FRAMEWORK'] then ENV['NEW_RELIC_FRAMEWORK'].to_sym
+                     when defined?(::NewRelic::TEST) then :test
+                     when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
+                     when defined?(::Rails) then check_rails_version
+                     when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+                     when defined?(::NewRelic::IA) then :external
+                     else :ruby
+                     end
+    end
+
+    def check_rails_version
+      if Rails::VERSION::MAJOR < 3
+        :rails
+      else
+        :rails3
+      end
+    end
+
+    def check_for_torquebox
+      return unless defined?(::JRuby) &&
+         ( org.torquebox::TorqueBox rescue nil)
+      @dispatcher = :torquebox
+    end
+
+    def check_for_glassfish
+      return unless defined?(::JRuby) &&
+        (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+          defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
+         (jruby_rack? && defined?(::GlassFish::Server)))
+      @dispatcher = :glassfish
+    end
+
+    def check_for_trinidad
+      return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+      @dispatcher = :trinidad
+    end
+
+    def jruby_rack?
+      ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+       defined?(org::jruby::rack::DefaultRackApplicationFactory))
+    end
+
+    def check_for_webrick
+      return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      @dispatcher = :webrick
+      if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch)
+        # OPTIONS is set by script/server
+        @dispatcher_instance_id = OPTIONS.fetch(:port)
+      end
+      @dispatcher_instance_id = default_port unless @dispatcher_instance_id
+    end
+
+    def check_for_fastcgi
+      return unless defined?(::FCGI)
+      @dispatcher = :fastcgi
+    end
+
+    # this case covers starting by mongrel_rails
+    def check_for_mongrel
+      return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+      @dispatcher = :mongrel
+
+      # Get the port from the server if it's started
+
+      if mongrel && mongrel.respond_to?(:port)
+        @dispatcher_instance_id = mongrel.port.to_s
+      end
+
+      # Get the port from the configurator if one was created
+      if @dispatcher_instance_id.nil? && defined?(::Mongrel::Configurator)
+        ObjectSpace.each_object(Mongrel::Configurator) do |mongrel|
+          @dispatcher_instance_id = mongrel.defaults[:port] && mongrel.defaults[:port].to_s
+        end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
+      end
+
+      # Still can't find the port.  Let's look at ARGV to fall back
+      @dispatcher_instance_id = default_port if @dispatcher_instance_id.nil?
+    end
+
+    def check_for_unicorn
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        v = find_class_in_object_space(::Unicorn::HttpServer)
+        @dispatcher = :unicorn if v 
+      end
+    end
+
+    def check_for_sinatra
+      return unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+
+      begin
+        version = ::Sinatra::VERSION
+      rescue
+        $stderr.puts("Error determining Sinatra version")
+      end
+
+      if ::NewRelic::VersionNumber.new('0.9.2') > version
+        $stderr.puts("Your Sinatra version is #{version}, we highly recommend upgrading to >=0.9.2")
+      end
+
+      @dispatcher = :sinatra
+    end
+
+    def check_for_thin
+      if defined?(::Thin) && defined?(::Thin::Server)
+        # This case covers the thin web dispatcher
+        # Same issue as above- we assume only one instance per process
+        ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+          @dispatcher = :thin
+          backend = thin_dispatcher.backend
+          # We need a way to uniquely identify and distinguish agents.  The port
+          # works for this.  When using sockets, use the socket file name.
+          if backend.respond_to? :port
+            @dispatcher_instance_id = backend.port
+          elsif backend.respond_to? :socket
+            @dispatcher_instance_id = backend.socket
+          else
+            raise "Unknown thin backend: #{backend}"
+          end
+        end # each thin instance
+      end
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
+        @dispatcher = :thin
+        @dispatcher_instance_id = default_port
+      end
+    end
+
+    def check_for_litespeed
+      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
+        @dispatcher = :litespeed
+      end
+    end
+
+    def check_for_passenger
+      if (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
+        @dispatcher = :passenger
+      end
+    end
+
+
+    def default_port
+      require 'optparse'
+      # If nothing else is found, use the 3000 default
+      default_port = 3000
+      OptionParser.new do |opts|
+        opts.on("-p", "--port=port", String) { | p | default_port = p }
+        opts.parse(ARGV.clone) rescue nil
+      end
+      default_port
+    end
+
+    public
+    # outputs a human-readable description
+    def to_s
+      s = "LocalEnvironment["
+      s << @framework.to_s
+      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
+      s << "]"
+    end
+
+  end
+end