wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/control/class_methods.rb

@@ -8,7 +8,13 @@ module NewRelic
       def instance(create=true)
         @instance ||= create && new_instance
       end
-      
+
+      # clear out memoized Control and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+
       # Access the LocalEnvironment singleton, lazy initialized
       def local_env
         @local_env ||= NewRelic::LocalEnvironment.new
@@ -16,10 +22,10 @@ module NewRelic
 
       # Create the concrete class for environment specific behavior
       def new_instance
-        if local_env.framework == :test
+        if Agent.config[:framework] == :test
           load_test_framework
         else
-          load_framework_class(local_env.framework).new(local_env)
+          load_framework_class(Agent.config[:framework]).new(local_env)
         end
       end
 
@@ -29,7 +35,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 +56,3 @@ module NewRelic
     extend ClassMethods
   end
 end
-

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,34 +17,36 @@ module NewRelic
             super
           end
         end
-        def logger
-          ::RAILS_DEFAULT_LOGGER
+
+        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.
+            ::NewRelic::Agent.logger.info("New Relic Agent not running.")
           else
-            log! "Starting the New Relic Agent."
-            install_developer_mode rails_config if developer_mode?
+            ::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
         end
@@ -52,13 +54,13 @@ 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
-            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
 
@@ -74,35 +76,17 @@ 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)
+            ::NewRelic::Agent.logger.warn("Developer mode not available for Rails versions prior to 2.2")
           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
-          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
           @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
         end
@@ -114,7 +98,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 +137,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
@@ -12,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
@@ -26,25 +27,18 @@ module NewRelic
           end
         end
 
-        def logger
-          ::Rails.logger
-        end
-
-
-        def log!(msg, level=:info)
-          if should_log?
-            logger.send(level, msg)
-          else
-            super
-          end
-        rescue => e
+        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)
+              add_error_collector_middleware
+            end
+          end
         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
@@ -59,7 +53,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
@@ -67,8 +61,19 @@ 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
+        
+        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/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,35 +2,14 @@ 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'] || Dir['.']
-        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
+          @root ||= ENV['APP_ROOT'] || '.'
         end
 
         def init_config(options={})

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,41 +44,32 @@ module NewRelic
       # init_config({}) which is called one or more times.
       #
       def init_plugin(options={})
-        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']
+        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)
+
+        ::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)
 
-        # 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
-          @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
         Module.send :include, NewRelic::Agent::MethodTracer::InstanceMethods
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
-        if agent_enabled? && !NewRelic::Agent.instance.started?
-          setup_log unless logger_override
+        if Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
           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
@@ -88,29 +79,25 @@ 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
+        Agent.config[:framework]
+      end
+
+      def framework
+        Agent.config[:framework]
+      end
+
+      # for backward compatibility with the old config interface
+      def [](key)
+        NewRelic::Agent.config[key.to_sym]
+      end
+
+      def settings
+        NewRelic::Agent.config.reported_config
       end
-      alias framework app
-      
-      def to_s #:nodoc:
-        "Control[#{self.app}]"
+
+      def dispatcher
+        NewRelic::Agent.config[:dispatcher]
       end
 
       protected
@@ -118,12 +105,12 @@ module NewRelic
       # 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
@@ -131,39 +118,14 @@ 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
+
+
+      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
+        @config_file_path = config_file_override || Agent.config[:config_path]
       end
-      
-      def load_newrelic_yml(path, binding)
-        YAML.load(ERB.new(File.read(path)).result(binding))
-      end
-      
+
       def root
         '.'
       end