ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

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

@@ -11,7 +11,7 @@ require 'rexml/document'
 require 'new_relic/control' unless defined? NewRelic::Control
 
 class NewRelic::Command::Deployments < NewRelic::Command
-  attr_reader :config
+  attr_reader :control
   def self.command; "deployments"; end
 
   # Initialize the deployment uploader with command line args.
@@ -24,12 +24,18 @@ class NewRelic::Command::Deployments < NewRelic::Command
   # Will throw CommandFailed exception if there's any error.
   #
   def initialize command_line_args
-    @config = NewRelic::Control.instance
+    @control = NewRelic::Control.instance
     super(command_line_args)
     @description ||= @leftover && @leftover.join(" ")
     @user ||= ENV['USER']
-    config.env = @environment if @environment
-    @appname ||= config.app_names[0] || config.env || 'development'
+    control.env = @environment if @environment
+    load_yaml_from_env(control.env)
+    @appname ||= NewRelic::Agent.config.app_names[0] || control.env || 'development'
+  end
+
+  def load_yaml_from_env(env)
+    yaml = NewRelic::Agent::Configuration::YamlSource.new(NewRelic::Agent.config[:config_path], env)
+    NewRelic::Agent.config.replace_or_add_config(yaml, 1)
   end
 
   # Run the Deployment upload in New Relic via Active Resource.
@@ -48,12 +54,15 @@ class NewRelic::Command::Deployments < NewRelic::Command
       }.each do |k, v|
         create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
       end
-      http = config.http_connection(config.api_server)
+      http = control.http_connection(control.api_server)
 
       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? ||
+          NewRelic::Agent.config[:license_key].empty?
+        raise "license_key was not set in newrelic.yml for #{control.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)
@@ -68,12 +77,12 @@ class NewRelic::Command::Deployments < NewRelic::Command
       end
     rescue SystemCallError, SocketError => e
       # These include Errno connection errors
-      err_string = "Transient error attempting to connect to #{config.api_server} (#{e})"
+      err_string = "Transient error attempting to connect to #{control.api_server} (#{e})"
       raise NewRelic::Command::CommandFailure.new(err_string)
     rescue NewRelic::Command::CommandFailure
       raise
     rescue => e
-      err "Unexpected error attempting to connect to #{config.api_server}"
+      err "Unexpected error attempting to connect to #{control.api_server}"
       info "#{e}: #{e.backtrace.join("\n   ")}"
       raise NewRelic::Command::CommandFailure.new(e.to_s)
     end
@@ -89,7 +98,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
              "Default is app_name setting in newrelic.yml") { | e | @appname = e }
       o.on("-e", "--environment=name", String,
                "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
-               "currently: #{config.env}") { | e | @environment = e }
+               "currently: #{control.env}") { | e | @environment = e }
       o.on("-u", "--user=USER", String,
              "Specify the user deploying, for information only",
              "Default: #{@user || '<none>'}") { | u | @user = u }

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/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

@@ -21,30 +21,35 @@ module NewRelic
           ::RAILS_DEFAULT_LOGGER
         end
 
+        def rails_config
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            ::Rails.configuration
+          else
+            @config
+          end
+        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, 
+          @config = options[:config]
+          # 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."
+            # is running, if it thinks it's a rake task, or if the agent_enabled is false.
+            log!("New Relic Agent not running.", :debug)
           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 +57,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 +119,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})" : "")
@@ -153,11 +158,12 @@ module NewRelic
         def install_shim
           super
           require 'new_relic/agent/instrumentation/controller_instrumentation'
-          ::ActionController::Base.class_eval {
-            include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
-          }
+          if ActiveSupport.respond_to?(:on_load) # rails 3+
+            ActiveSupport.on_load(:action_controller) { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          else
+            ActionController::Base.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+          end
         end
-
       end
     end
   end

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

@@ -1,4 +1,5 @@
 require 'new_relic/control/frameworks/rails'
+require 'new_relic/rack/error_collector'
 module NewRelic
   class Control
     module Frameworks
@@ -30,6 +31,15 @@ module NewRelic
           ::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
+            end
+          end
+        end
 
         def log!(msg, level=:info)
           if should_log?
@@ -59,7 +69,7 @@ module NewRelic
 
         # Collect the Rails::Info into an associative array as well as the list of plugins
         def append_environment_info
-          local_env.append_environment_value('Rails version'){ version }
+          local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
           local_env.append_environment_value('Rails threadsafe') do
             true == ::Rails.configuration.action_controller.allow_concurrency
           end
@@ -69,6 +79,13 @@ module NewRelic
           end
           local_env.append_plugin_list { ::Rails.configuration.plugins.to_a }
         end
+        
+        def install_shim
+          super
+          ActiveSupport.on_load(:action_controller) do
+            include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+          end
+        end
       end
     end
   end

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,18 @@ 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
+
+        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']
 
@@ -52,15 +64,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 +78,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 +95,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,39 +136,18 @@ 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.
+
       def initialize local_env, config_file_override=nil
         @local_env = local_env
         @instrumentation_files = []
-        newrelic_file = config_file_override || config_file
-        # Next two are for populating the newrelic.yml via erb binding, necessary
-        # when using the default newrelic.yml file
-        generated_for_user = ''
-        license_key=''
-        if !File.exists?(newrelic_file)
-          puts "Cannot find or read #{newrelic_file}"
-          @yaml = {}
-        else
-          @yaml = load_newrelic_yml(newrelic_file, binding)
-        end
-      rescue ScriptError, StandardError => e
-        new_err = e.class.new("Error reading newrelic.yml file: #{e}")
-        new_err.set_backtrace(e.backtrace)
-        raise new_err
+        @newrelic_file = config_file_override || config_file
       end
-      
-      def load_newrelic_yml(path, binding)
-        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