newrelic_rpm 3.5.4.35.beta → 3.5.5.38

data/lib/new_relic/control/frameworks/merb.rb

@@ -11,12 +11,6 @@ module NewRelic
           ::Merb.root
         end
 
-        def to_stdout(msg)
-          Merb.logger.info("NewRelic ~ " + msg)
-        rescue => e
-          STDOUT.puts "NewRelic ~ " + msg
-        end
-
         def init_config options={}
           ::Merb::Plugins.add_rakefiles File.join(newrelic_root,"lib/tasks/all.rb")
 

data/lib/new_relic/control/frameworks/rails.rb

@@ -17,9 +17,6 @@ module NewRelic
             super
           end
         end
-        def logger
-          ::RAILS_DEFAULT_LOGGER
-        end
 
         def rails_config
           if defined?(::Rails) && ::Rails.respond_to?(:configuration)
@@ -46,9 +43,9 @@ module NewRelic
           if !Agent.config[:agent_enabled]
             # Might not be running if it does not think mongrel, thin, passenger, etc
             # is running, if it thinks it's a rake task, or if the agent_enabled is false.
-            log!("New Relic Agent not running.", :debug)
+            ::NewRelic::Agent.logger.info("New Relic Agent not running.")
           else
-            log! "Starting the New Relic Agent."
+            ::NewRelic::Agent.logger.info("Starting the New Relic Agent.")
             install_developer_mode rails_config if Agent.config[:developer_mode]
             install_browser_monitoring(rails_config)
           end
@@ -61,9 +58,9 @@ module NewRelic
           begin
             require 'new_relic/rack/browser_monitoring'
             config.middleware.use NewRelic::Rack::BrowserMonitoring
-            log!("Installed New Relic Browser Monitoring middleware", :info)
+            ::NewRelic::Agent.logger.debug("Installed New Relic Browser Monitoring middleware")
           rescue => e
-            log!("Error installing New Relic Browser Monitoring middleware: #{e.inspect}", :error)
+            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware: #{e.inspect}")
           end
         end
 
@@ -79,33 +76,15 @@ module NewRelic
               # a webserver process
               if @local_env.dispatcher_instance_id
                 port = @local_env.dispatcher_instance_id.to_s =~ /^\d+/ ? ":#{local_env.dispatcher_instance_id}" : ":port"
-                log!("NewRelic Agent Developer Mode enabled.")
-                log!("To view performance information, go to http://localhost#{port}/newrelic")
+                ::NewRelic::Agent.logger.debug("NewRelic Agent Developer Mode enabled.")
+                ::NewRelic::Agent.logger.debug("To view performance information, go to http://localhost#{port}/newrelic")
               end
             rescue => e
-              log!("Error installing New Relic Developer Mode: #{e.inspect}", :error)
+              ::NewRelic::Agent.logger.warn("Error installing New Relic Developer Mode: #{e.inspect}")
             end
           elsif rails_config
-            log!("Developer mode not available for Rails versions prior to 2.2", :warn)
-          end
-        end
-
-        def log!(msg, level=:info)
-          if should_log?
-            logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
-            logger.send(level, msg)
-          else
-            super
+            ::NewRelic::Agent.logger.warn("Developer mode not available for Rails versions prior to 2.2")
           end
-        rescue => e
-          super
-        end
-
-        def to_stdout(message)
-          logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
-          logger.info(message)
-        rescue => e
-          super
         end
 
         def rails_version

data/lib/new_relic/control/frameworks/rails3.rb

@@ -13,7 +13,7 @@ module NewRelic
         def env
           @env ||= ::Rails.env.to_s
         end
-        
+
         # Rails can return an empty string from this method, causing
         # the agent not to start even when it is properly in a rails 3
         # application, so we test the value to make sure it actually
@@ -27,34 +27,18 @@ module NewRelic
           end
         end
 
-        def logger
-          ::Rails.logger
-        end
-
         def init_config(options={})
           super
           if Agent.config[:agent_enabled] && Agent.config[:'error_collector.enabled']
             if !rails_config.middleware.respond_to?(:include?) ||
                 !rails_config.middleware.include?(NewRelic::Rack::ErrorCollector)
-              rails_config.middleware.use NewRelic::Rack::ErrorCollector
+              add_error_collector_middleware
             end
           end
         end
 
-        def log!(msg, level=:info)
-          if should_log?
-            logger.send(level, msg)
-          else
-            super
-          end
-        rescue => e
-          super
-        end
-
-        def to_stdout(msg)
-          logger.info(msg)
-        rescue
-          super
+        def add_error_collector_middleware
+          rails_config.middleware.use NewRelic::Rack::ErrorCollector
         end
 
         def vendor_root
@@ -77,6 +61,10 @@ module NewRelic
           local_env.append_gem_list do
             bundler_gem_list
           end
+          append_plugin_list
+        end
+
+        def append_plugin_list
           local_env.append_plugin_list { ::Rails.configuration.plugins.to_a }
         end
         

data/lib/new_relic/control/frameworks/rails4.rb

@@ -0,0 +1,23 @@
+require 'new_relic/control/frameworks/rails3'
+require 'new_relic/rack/error_collector'
+module NewRelic
+  class Control
+    module Frameworks
+      class Rails4 < NewRelic::Control::Frameworks::Rails3
+        def rails_gem_list
+          Bundler.rubygems.all_specs.map do |gem|
+            "#{gem.name} (#{gem.version})"
+          end
+        end
+
+        def add_error_collector_middleware
+          # rails_config.middleware.use NewRelic::Rack::ErrorCollector
+        end
+
+        def append_plugin_list
+          # Rails 4 does not allow plugins
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/ruby.rb

@@ -2,36 +2,15 @@ module NewRelic
   class Control
     module Frameworks
       # A control used when no framework is detected - the default.
-      # Looks for a newrelic.yml file in several locations including
-      # ./, ./config, $HOME/.newrelic and $HOME/.  It loads the
-      # settings from the newrelic.yml section based on the value of
-      # RUBY_ENV or RAILS_ENV.
       class Ruby < NewRelic::Control
 
         def env
           @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
         end
+
         def root
           @root ||= ENV['APP_ROOT'] || '.'
         end
-        # Check a sequence of file locations for newrelic.yml
-        def config_file
-          files = []
-          files << File.join(root,"config","newrelic.yml")
-          files << File.join(root,"newrelic.yml")
-          if ENV["HOME"]
-            files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
-            files << File.join(ENV["HOME"], "newrelic.yml")
-          end
-          files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
-          files.each do |file|
-            return File.expand_path(file) if File.exists? file
-          end
-          return File.expand_path(files.first)
-        end
-        def to_stdout(msg)
-          STDOUT.puts msg
-        end
 
         def init_config(options={})
         end

data/lib/new_relic/control/instance_methods.rb

@@ -1,4 +1,5 @@
 require 'new_relic/language_support'
+require 'new_relic/agent/agent_logger'
 
 module NewRelic
   class Control
@@ -19,7 +20,6 @@ module NewRelic
       # machine-dependent information useful in debugging
       attr_reader :local_env
 
-
       # Initialize the plugin/gem and start the agent.  This does the
       # necessary configuration based on the framework environment and
       # determines whether or not to start the agent.  If the agent is
@@ -44,34 +44,19 @@ module NewRelic
       # init_config({}) which is called one or more times.
       #
       def init_plugin(options={})
-        begin
-          path = @newrelic_file || Agent.config[:config_path]
-          yaml = Agent::Configuration::YamlSource.new(path, env)
-          Agent.config.replace_or_add_config(yaml, 1)
-        rescue ScriptError, StandardError => e
-          # Why do we need to do this?
-          new_err = e.class.new("Error reading newrelic.yml file: #{e}")
-          new_err.set_backtrace(e.backtrace)
-          raise new_err
-        end
+        yaml = Agent::Configuration::YamlSource.new(@config_file_path, options[:env] || env)
+        Agent.config.replace_or_add_config(yaml, 1)
 
         Agent.config.replace_or_add_config(Agent::Configuration::ManualSource.new(options), 1)
-        options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
-        options['app_name'] ||= ENV['NEW_RELIC_APP_NAME'] if ENV['NEW_RELIC_APP_NAME']
+
+        ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(Agent.config, root, options.delete(:log))
 
         # Merge the stringified options into the config as overrides:
-        logger_override = options.delete(:log)
         environment_name = options.delete(:env) and self.env = environment_name
-        dispatcher = options.delete(:dispatcher) and @local_env.dispatcher = dispatcher
         dispatcher_instance_id = options.delete(:dispatcher_instance_id) and @local_env.dispatcher_instance_id = dispatcher_instance_id
 
         NewRelic::Agent::PipeChannelManager.listener.start if options.delete(:start_channel_listener)
 
-        if logger_override
-          @log = logger_override
-          # Try to grab the log filename
-          @log_file = @log.instance_eval { @logdev.filename rescue nil }
-        end
         # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
         # methods in the module methods.
         Module.send :include, NewRelic::Agent::MethodTracer::ClassMethods
@@ -79,10 +64,9 @@ module NewRelic
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
         if Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
-          setup_log unless logger_override
           start_agent
           install_instrumentation
-          load_samplers unless Agent.config['disable_samplers']
+          load_samplers unless Agent.config[:disable_samplers]
           local_env.gather_environment_info
           append_environment_info
         elsif !Agent.config[:agent_enabled]
@@ -95,14 +79,12 @@ module NewRelic
         NewRelic::Agent.agent.start
       end
 
-      # Asks the LocalEnvironment instance which framework should be loaded
       def app
-        @local_env.framework
+        Agent.config[:framework]
       end
-      alias framework app
 
-      def to_s #:nodoc:
-        "Control[#{self.app}]"
+      def framework
+        Agent.config[:framework]
       end
 
       # for backward compatibility with the old config interface
@@ -111,7 +93,7 @@ module NewRelic
       end
 
       def settings
-        NewRelic::Agent.config.flattened_config
+        NewRelic::Agent.config.reported_config
       end
 
       def dispatcher
@@ -137,15 +119,11 @@ module NewRelic
         end
       end
 
-      # path to the config file, defaults to the "#{root}/config/newrelic.yml"
-      def config_file
-        File.expand_path(File.join(root,"config","newrelic.yml"))
-      end
 
-      def initialize local_env, config_file_override=nil
+      def initialize(local_env, config_file_override=nil)
         @local_env = local_env
         @instrumentation_files = []
-        @newrelic_file = config_file_override || config_file
+        @config_file_path = config_file_override || Agent.config[:config_path]
       end
 
       def root

data/lib/new_relic/control/instrumentation.rb

@@ -9,17 +9,12 @@ module NewRelic
       # This requires the files within a rescue block, so that any
       # errors within instrumentation files do not affect the overall
       # agent or application in which it runs.
-      #
-      # Logs at debug level for each file loaded, and logs errors in
-      # file loading at error level
       def load_instrumentation_files pattern
         Dir.glob(pattern) do |file|
           begin
-            log.debug "Processing instrumentation file '#{file}'"
             require file.to_s
           rescue => e
-            log.error "Error loading instrumentation file '#{file}': #{e}"
-            log.debug e.backtrace.join("\n")
+            ::NewRelic::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
           end
         end
       end
@@ -60,19 +55,19 @@ module NewRelic
         agent = NewRelic::Agent.instance
         NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
           begin
-            log.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+            ::NewRelic::Agent.logger.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
             sampler = subclass.new
             if subclass.use_harvest_sampler?
               agent.stats_engine.add_harvest_sampler sampler
-              log.debug "Registered #{subclass.name} for harvest time sampling"
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for harvest time sampling"
             else
               agent.stats_engine.add_sampler sampler
-              log.debug "Registered #{subclass.name} for periodic sampling"
+              ::NewRelic::Agent.logger.debug "Registered #{subclass.name} for periodic sampling"
             end
           rescue NewRelic::Agent::Sampler::Unsupported => e
-            log.info "#{subclass} sampler not available: #{e}"
+            ::NewRelic::Agent.logger.info "#{subclass} sampler not available: #{e}"
           rescue => e
-            log.error "Error registering sampler: #{e}, #{e.backtrace.join("\n")}"
+            ::NewRelic::Agent.logger.error "Error registering sampler:", e
           end
         end
       end
@@ -92,7 +87,7 @@ module NewRelic
         File.join(instrumentation_path, app.to_s, '*.rb')
         @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
         DependencyDetection.detect!
-        log.debug "Finished instrumentation"
+        ::NewRelic::Agent.logger.info "Finished instrumentation"
       end
     end
     include Instrumentation

data/lib/new_relic/control/server_methods.rb

@@ -52,9 +52,7 @@ module NewRelic
         return nil if host.nil? || host.downcase == "localhost"
         ip = resolve_ip_address(host)
 
-        # FIXME: commented out to squelch STDOUT output for RUBY-839
-        # should bring it back when logging / startup is fixed
-        # log.info "Resolved #{host} to #{ip}"
+        ::NewRelic::Agent.logger.debug "Resolved #{host} to #{ip}"
         ip
       end
 
@@ -65,13 +63,12 @@ module NewRelic
       def resolve_ip_address(host)
         Resolv.getaddress(host)
       rescue => e
-        log.warn("DNS Error caching IP address: #{e}")
-        log.debug(e.backtrace.join("\n   "))
+        ::NewRelic::Agent.logger.warn("DNS Error caching IP address:", e)
         begin
-          log.info("Trying native DNS lookup since Resolv failed")
+          ::NewRelic::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
           IPSocket.getaddress(host)
         rescue => e
-          log.error("Could not look up server address: #{e}")
+          ::NewRelic::Agent.logger.error("Could not look up server address: #{e}")
           nil
         end
       end
@@ -95,7 +92,7 @@ module NewRelic
         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}")
+        ::NewRelic::Agent.logger.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
         if Agent.config[:ssl]
           http.use_ssl = true
           if Agent.config[:verify_certificate]

data/lib/new_relic/delayed_job_injection.rb

@@ -20,7 +20,7 @@ DependencyDetection.defer do
   
   executes do
     if NewRelic::Agent.respond_to?(:logger)
-      NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation hooks'
+      ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation hooks'
     end
   end
   

data/lib/new_relic/local_environment.rb

@@ -5,7 +5,6 @@ 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
   #
@@ -15,15 +14,16 @@ module NewRelic
   # 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
+    def discovered_dispatcher
+      discover_dispatcher unless @discovered_dispatcher
+      @discovered_dispatcher
+    end
+
     # 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
@@ -33,9 +33,7 @@ module NewRelic
         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
@@ -48,9 +46,8 @@ module NewRelic
     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
+    rescue => e
+      Agent.logger.error e
     end
     
     # yields to the block and appends the returned value to the list
@@ -58,24 +55,22 @@ module NewRelic
     def append_gem_list
       @gems += yield
     rescue => e
-      # puts "#{e}\n  #{e.backtrace.join("\n  ")}"
-      raise if @framework == :test
+      Agent.logger.error e
     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
+    rescue => e
+      Agent.logger.error e
     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?
+        if @discovered_dispatcher.nil?
           @dispatcher_instance_id = File.basename($0).split(".").first
         end
       end
@@ -122,7 +117,7 @@ module NewRelic
 
         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}")
+          ::NewRelic::Agent.logger.warn("Cannot determine the number of processors in #{proc_file}")
         end
         processors
       end
@@ -197,8 +192,8 @@ module NewRelic
     # 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 'Framework', Agent.config[:framework].to_s
+      append_environment_value 'Dispatcher', Agent.config[:dispatcher].to_s if Agent.config[:dispatcher]
       append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
       append_environment_value('Environment') { NewRelic::Control.instance.env }
 
@@ -244,47 +239,19 @@ module NewRelic
     
     private
 
-    # Although you can override the framework with NEWRELIC_DISPATCHER this
+    # Although you can override the dispatcher 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?
+      while dispatchers.any? && @discovered_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
+      @discovered_dispatcher = :torquebox
     end
 
     def check_for_glassfish
@@ -292,12 +259,12 @@ module NewRelic
         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
           defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
          (jruby_rack? && defined?(::GlassFish::Server)))
-      @dispatcher = :glassfish
+      @discovered_dispatcher = :glassfish
     end
 
     def check_for_trinidad
       return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
-      @dispatcher = :trinidad
+      @discovered_dispatcher = :trinidad
     end
 
     def jruby_rack?
@@ -307,7 +274,7 @@ module NewRelic
 
     def check_for_webrick
       return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
-      @dispatcher = :webrick
+      @discovered_dispatcher = :webrick
       if defined?(::OPTIONS) && OPTIONS.respond_to?(:fetch)
         # OPTIONS is set by script/server
         @dispatcher_instance_id = OPTIONS.fetch(:port)
@@ -317,13 +284,13 @@ module NewRelic
 
     def check_for_fastcgi
       return unless defined?(::FCGI)
-      @dispatcher = :fastcgi
+      @discovered_dispatcher = :fastcgi
     end
 
     # this case covers starting by mongrel_rails
     def check_for_mongrel
       return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
-      @dispatcher = :mongrel
+      @discovered_dispatcher = :mongrel
 
       # Get the port from the server if it's started
 
@@ -345,7 +312,7 @@ module NewRelic
     def check_for_unicorn
       if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
         v = find_class_in_object_space(::Unicorn::HttpServer)
-        @dispatcher = :unicorn if v 
+        @discovered_dispatcher = :unicorn if v 
       end
     end
 
@@ -362,7 +329,7 @@ module NewRelic
         $stderr.puts("Your Sinatra version is #{version}, we highly recommend upgrading to >=0.9.2")
       end
 
-      @dispatcher = :sinatra
+      @discovered_dispatcher = :sinatra
     end
 
     def check_for_thin
@@ -370,7 +337,7 @@ module NewRelic
         # 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
+          @discovered_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.
@@ -383,21 +350,21 @@ module NewRelic
           end
         end # each thin instance
       end
-      if defined?(::Thin) && defined?(::Thin::VERSION) && !@dispatcher
-        @dispatcher = :thin
+      if defined?(::Thin) && defined?(::Thin::VERSION) && !@discovered_dispatcher
+        @discovered_dispatcher = :thin
         @dispatcher_instance_id = default_port
       end
     end
 
     def check_for_litespeed
       if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
-        @dispatcher = :litespeed
+        @discovered_dispatcher = :litespeed
       end
     end
 
     def check_for_passenger
       if defined?(::PhusionPassenger)
-        @dispatcher = :passenger
+        @discovered_dispatcher = :passenger
       end
     end
 
@@ -417,8 +384,7 @@ module NewRelic
     # outputs a human-readable description
     def to_s
       s = "LocalEnvironment["
-      s << @framework.to_s
-      s << ";dispatcher=#{@dispatcher}" if @dispatcher
+      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
       s << ";instance=#{@dispatcher_instance_id}" if @dispatcher_instance_id
       s << "]"
     end