newrelic_rpm 3.4.1 → 3.4.2.beta1

data/lib/new_relic/agent.rb

@@ -90,6 +90,7 @@ module NewRelic
     require 'new_relic/agent/database'
     require 'new_relic/agent/pipe_channel_manager'
     require 'new_relic/agent/transaction_info'
+    require 'new_relic/agent/configuration'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -100,7 +101,9 @@ module NewRelic
     require 'set'
     require 'thread'
     require 'resolv'
-
+    
+    extend NewRelic::Agent::Configuration::Instance
+    
     # An exception that is thrown by the server if the agent license is invalid.
     class LicenseException < StandardError; end
 

data/lib/new_relic/collection_helper.rb

@@ -33,7 +33,7 @@ module NewRelic
   # Return nil if there is no backtrace
 
   def strip_nr_from_backtrace(backtrace)
-    if backtrace && !NewRelic::Control.instance.disable_backtrace_cleanup?
+    if backtrace && !Agent.config[:disable_backtrace_cleanup]
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
       backtrace = backtrace.map &:to_s

data/lib/new_relic/commands/deployments.rb

@@ -29,7 +29,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
     @description ||= @leftover && @leftover.join(" ")
     @user ||= ENV['USER']
     config.env = @environment if @environment
-    @appname ||= config.app_names[0] || config.env || 'development'
+    @appname ||= NewRelic::Agent.config.app_names[0] || config.env || 'development'
   end
 
   # Run the Deployment upload in New Relic via Active Resource.
@@ -52,8 +52,10 @@ class NewRelic::Command::Deployments < NewRelic::Command
 
       uri = "/deployments.xml"
 
-      raise "license_key was not set in newrelic.yml for #{config.env}" if config['license_key'].nil?
-      request = Net::HTTP::Post.new(uri, {'x-license-key' => config['license_key']})
+      if NewRelic::Agent.config[:license_key].nil?
+        raise "license_key was not set in newrelic.yml for #{config.env}"
+      end
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => NewRelic::Agent.config[:license_key]})
       request.content_type = "application/octet-stream"
 
       request.set_form_data(create_params)

data/lib/new_relic/control/class_methods.rb

@@ -8,7 +8,7 @@ module NewRelic
       def instance(create=true)
         @instance ||= create && new_instance
       end
-      
+
       # Access the LocalEnvironment singleton, lazy initialized
       def local_env
         @local_env ||= NewRelic::LocalEnvironment.new
@@ -29,7 +29,7 @@ module NewRelic
         require "config/test_control"
         NewRelic::Control::Frameworks::Test.new(local_env, config)
       end
-      
+
       # Loads the specified framework class from the
       # NewRelic::Control::Frameworks module
       def load_framework_class(framework)
@@ -50,4 +50,3 @@ module NewRelic
     extend ClassMethods
   end
 end
-

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

@@ -22,29 +22,29 @@ module NewRelic
         end
 
         # In versions of Rails prior to 2.0, the rails config was only available to
-        # the init.rb, so it had to be passed on from there.  This is a best effort to 
+        # the init.rb, so it had to be passed on from there.  This is a best effort to
         # find a config and use that.
         def init_config(options={})
           rails_config = options[:config]
           if !rails_config && defined?(::Rails) && ::Rails.respond_to?(:configuration)
             rails_config = ::Rails.configuration
           end
-          # Install the dependency detection, 
+          # Install the dependency detection,
           if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
             rails_config.after_initialize do
               # This will insure we load all the instrumentation as late as possible.  If the agent
-              # is not enabled, it will load a limited amount of instrumentation.  See 
+              # is not enabled, it will load a limited amount of instrumentation.  See
               # delayed_job_injection.rb
               DependencyDetection.detect!
             end
-          end          
-          if !agent_enabled?
+          end
+          if !Agent.config[:agent_enabled]
             # Might not be running if it does not think mongrel, thin, passenger, etc
             # is running, if it things it's a rake task, or if the agent_enabled is false.
             log! "New Relic Agent not running."
           else
             log! "Starting the New Relic Agent."
-            install_developer_mode rails_config if developer_mode?
+            install_developer_mode rails_config if Agent.config[:developer_mode]
             install_browser_monitoring(rails_config)
           end
         end
@@ -52,7 +52,7 @@ module NewRelic
         def install_browser_monitoring(config)
           return if @browser_monitoring_installed
           @browser_monitoring_installed = true
-          return if config.nil? || !config.respond_to?(:middleware) || ! browser_monitoring_auto_instrument?
+          return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
           begin
             require 'new_relic/rack/browser_monitoring'
             config.middleware.use NewRelic::Rack::BrowserMonitoring
@@ -114,7 +114,7 @@ module NewRelic
         end
 
         def rails_gem_list
-          ::Rails.configuration.gems.map do | gem |
+          ::Rails.configuration.gems.map do |gem|
             version = (gem.respond_to?(:version) && gem.version) ||
               (gem.specification.respond_to?(:version) && gem.specification.version)
             gem.name + (version ? "(#{version})" : "")

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

@@ -12,7 +12,7 @@ module NewRelic
           @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
         end
         def root
-          @root ||= ENV['APP_ROOT'] || Dir['.']
+          @root ||= ENV['APP_ROOT'] || '.'
         end
         # Check a sequence of file locations for newrelic.yml
         def config_file
@@ -24,7 +24,7 @@ module NewRelic
             files << File.join(ENV["HOME"], "newrelic.yml")
           end
           files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
-          files.each do | file |
+          files.each do |file|
             return File.expand_path(file) if File.exists? file
           end
           return File.expand_path(files.first)

data/lib/new_relic/control/instance_methods.rb

@@ -44,6 +44,7 @@ module NewRelic
       # init_config({}) which is called one or more times.
       #
       def init_plugin(options={})
+        Agent.config.apply_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']
 
@@ -52,15 +53,9 @@ module NewRelic
         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)
 
-        # Clear out the settings, if they've already been loaded.  It may be that
-        # between calling init_plugin the first time and the second time, the env
-        # has been overridden
-        @settings = nil
-        settings
-        merge_options(options)
         if logger_override
           @log = logger_override
           # Try to grab the log filename
@@ -72,14 +67,14 @@ module NewRelic
         Module.send :include, NewRelic::Agent::MethodTracer::InstanceMethods
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
-        if agent_enabled? && !NewRelic::Agent.instance.started?
+        if Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
           setup_log unless logger_override
           start_agent
           install_instrumentation
-          load_samplers unless self['disable_samplers']
+          load_samplers unless Agent.config['disable_samplers']
           local_env.gather_environment_info
           append_environment_info
-        elsif !agent_enabled?
+        elsif !Agent.config[:agent_enabled]
           install_shim
         end
       end
@@ -89,42 +84,40 @@ module NewRelic
         NewRelic::Agent.agent.start
       end
 
-      # True if dev mode or monitor mode are enabled, and we are running
-      # inside a valid dispatcher like mongrel or passenger.  Can be overridden
-      # by NEWRELIC_ENABLE env variable, monitor_daemons config option when true, or
-      # agent_enabled config option when true or false.
-      def agent_enabled?
-        return false if !developer_mode? && !monitor_mode?
-        return self['agent_enabled'].to_s =~ /true|on|yes/i if !self['agent_enabled'].nil? && self['agent_enabled'] != 'auto'
-        return false if ENV['NEWRELIC_ENABLE'].to_s =~ /false|off|no/i
-        return true if self['monitor_daemons'].to_s =~ /true|on|yes/i
-        return true if ENV['NEWRELIC_ENABLE'].to_s =~ /true|on|yes/i
-        # When in 'auto' mode the agent is enabled if there is a known
-        # dispatcher running
-        return true if @local_env.dispatcher != nil
-      end
-      
       # Asks the LocalEnvironment instance which framework should be loaded
       def app
         @local_env.framework
       end
       alias framework app
-      
+
       def to_s #:nodoc:
         "Control[#{self.app}]"
       end
 
+      # for backward compatibility with the old config interface
+      def [](key)
+        NewRelic::Agent.config[key.to_sym]
+      end
+
+      def settings
+        NewRelic::Agent.config.flattened_config
+      end
+
+      def dispatcher
+        NewRelic::Agent.config[:dispatcher]
+      end
+
       protected
 
       # Append framework specific environment information for uploading to
       # the server for change detection.  Override in subclasses
       def append_environment_info; end
-      
+
       # Asks bundler to tell us which gemspecs are loaded in the
       # current process
       def bundler_gem_list
         if defined?(Bundler) && Bundler.instance_eval do @load end
-          Bundler.load.specs.map do | spec |
+          Bundler.load.specs.map do |spec|
             version = (spec.respond_to?(:version) && spec.version)
             spec.name + (version ? "(#{version})" : "")
           end
@@ -132,12 +125,12 @@ 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
-      
+
       # initializes the control instance with a local environment and
       # an optional config file override. Checks for the config file
       # and loads it.
@@ -160,11 +153,12 @@ module NewRelic
         new_err.set_backtrace(e.backtrace)
         raise new_err
       end
-      
+
       def load_newrelic_yml(path, binding)
+        Agent.config.apply_config(Agent::Configuration::YamlSource.new(path, env), 1)
         YAML.load(ERB.new(File.read(path)).result(binding))
       end
-      
+
       def root
         '.'
       end

data/lib/new_relic/control/logging_methods.rb

@@ -32,7 +32,7 @@ module NewRelic
       # true if the agent has settings, and the agent is enabled,
       # otherwise false
       def should_log?
-        @settings && agent_enabled?
+        @settings && Agent.config[:agent_enabled]
       end
 
       # set the log level as specified in the config file
@@ -41,7 +41,7 @@ module NewRelic
       #error, and fatal
       # Defaults to info
       def set_log_level!(logger)
-        case fetch("log_level","info").downcase
+        case Agent.config[:log_level].downcase
           when "debug" then logger.level = Logger::DEBUG
           when "info" then logger.level = Logger::INFO
           when "warn" then logger.level = Logger::WARN
@@ -68,7 +68,7 @@ module NewRelic
         if log_to_stdout?
           @log = Logger.new(STDOUT) 
         else
-          @log_file = "#{log_path}/#{log_file_name}"
+          @log_file = "#{log_path}/#{Agent.config[:log_file_name]}"
           @log = Logger.new(@log_file) rescue nil
           @log ||= Logger.new(STDOUT) # failsafe to STDOUT
         end
@@ -99,11 +99,7 @@ module NewRelic
         if log_to_stdout?
           @log_path = nil
         else
-          if ENV['NEW_RELIC_LOG']
-            log_path_setting = File.dirname(ENV['NEW_RELIC_LOG'])
-          else
-            log_path_setting = fetch('log_file_path', 'log')
-          end
+          log_path_setting = Agent.config[:log_file_path]
           @log_path = find_or_create_file_path(log_path_setting)
           log!("Error creating log directory #{log_path_setting}, using standard out for logging.", :warn) unless @log_path
         end
@@ -121,21 +117,7 @@ module NewRelic
       end
 
       def log_to_stdout?
-        return true if @stdout
-        destination = ENV['NEW_RELIC_LOG'] || fetch('log_file_path', 'log')
-        if destination.upcase == 'STDOUT'
-          @stdout = true
-        end
-      end
-        
-      # Retrieves the log file's name from the config file option
-      #'log_file_name', defaulting to 'newrelic_agent.log'
-      def log_file_name
-        if ENV['NEW_RELIC_LOG']
-          File.basename(ENV['NEW_RELIC_LOG'])
-        else
-          fetch('log_file_name', 'newrelic_agent.log')
-        end
+        Agent.config['log_file_path'].upcase == 'STDOUT'
       end
     end
     include LoggingMethods

data/lib/new_relic/control/server_methods.rb

@@ -18,34 +18,27 @@ module NewRelic
       # 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
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], 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'])
+        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
+                                                             Agent.config[:proxy_port],
+                                                             Agent.config[:proxy_user],
+                                                             Agent.config[: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'
+        host = hostname || Agent.config[:host]
 
         # 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))
+        NewRelic::Control::Server.new(host, Agent.config[:port],
+                                      convert_to_ip_address(host))
       end
 
       # Check to see if we need to look up the IP address
@@ -55,7 +48,7 @@ module NewRelic
       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 host if Agent.config[:ssl] && Agent.config[:verify_certificate]
         return nil if host.nil? || host.downcase == "localhost"
         ip = resolve_ip_address(host)
 
@@ -103,9 +96,9 @@ module NewRelic
                                       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?
+        if Agent.config[:ssl]
           http.use_ssl = true
-          if verify_certificate?
+          if Agent.config[:verify_certificate]
             http.verify_mode = OpenSSL::SSL::VERIFY_PEER
             http.ca_file = cert_file_path
           else

data/lib/new_relic/control.rb

@@ -12,7 +12,6 @@ require 'logger'
 require 'new_relic/control/frameworks'
 require 'new_relic/control/profiling'
 require 'new_relic/control/logging_methods'
-require 'new_relic/control/configuration'
 require 'new_relic/control/server_methods'
 require 'new_relic/control/instrumentation'
 require 'new_relic/control/class_methods'

data/lib/new_relic/delayed_job_injection.rb

@@ -15,7 +15,7 @@ DependencyDetection.defer do
   @name = :delayed_job_injection
   
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
   end
   
   executes do

data/lib/new_relic/language_support.rb

@@ -82,6 +82,14 @@ module NewRelic::LanguageSupport
     end
   end
   
+  def with_cautious_gc
+    if broken_gc?
+      with_disabled_gc { yield }
+    else
+      yield
+    end
+  end
+
   def using_version?(version)
     numbers = version.split('.')
     numbers == ::RUBY_VERSION.split('.')[0, numbers.size]

data/lib/new_relic/noticed_error.rb

@@ -20,7 +20,7 @@ class NewRelic::NoticedError
     self.message = self.message[0..4095] if self.message.length > 4096
     
     # obfuscate error message if necessary
-    if NewRelic::Control.instance.fetch('high_security', false)
+    if NewRelic::Agent.config[:high_security]
       self.message = NewRelic::Agent::Database.obfuscate_sql(self.message)
     end