newrelic_rpm 3.4.1 → 3.4.2.beta1

data/lib/new_relic/agent/configuration/defaults.rb

@@ -0,0 +1,75 @@
+module NewRelic
+  module Agent
+    module Configuration
+      DEFAULTS = {
+        :config_path => File.join('config', 'newrelic.yml'),
+
+        :app_name   => Proc.new { NewRelic::Control.instance.env },
+        :dispatcher => Proc.new { NewRelic::Control.instance.local_env.dispatcher },
+
+        :enabled         => true,
+        :monitor_mode    => Proc.new { self[:enabled] },
+        :agent_enabled   => Proc.new do
+          self[:enabled] &&
+          (self[:developer_mode] || self[:monitor_mode] || self[:monitor_daemons]) &&
+          !!NewRelic::Control.instance.local_env.dispatcher
+        end,
+        :developer_mode  => Proc.new { self[:developer] },
+        :developer       => false,
+        :apdex_t         => 0.5,
+        :monitor_daemons => false,
+        :multi_homed     => false,
+        :high_security   => false,
+
+        :host                  => 'collector.newrelic.com',
+        :api_host              => 'rpm.newrelic.com',
+        :port                  => Proc.new { self[:ssl] ? 443 : 80 },
+        :api_port              => Proc.new { self[:port] },
+        :ssl                   => false,
+        :verify_certificate    => false,
+        :sync_startup          => false,
+        :send_data_on_exit     => true,
+        :post_size_limit       => 2 * 1024 * 1024, # 2 megs
+        :timeout               => 2 * 60,          # 2 minutes
+        :force_send            => false,
+        :send_environment_info => true,
+
+        :log_file_name => 'newrelic_agent.log',
+        :log_file_path => 'log/',
+        :log_level     => 'info',
+
+        :disable_samplers                     => false,
+        :disable_resque                       => false,
+        :disable_dj                           => false,
+        :disable_view_instrumentation         => false,
+        :disable_backtrace_cleanup            => false,
+        :skip_ar_instrumentation              => false,
+        :disable_activerecord_instrumentation => Proc.new { self[:skip_ar_instrumentation] },
+        :disable_memcache_instrumentation     => false,
+        :disable_mobile_headers               => true,
+
+        :capture_memcache_keys => false,
+        :textmate              => false,
+
+        :'transaction_tracer.enabled'               => true,
+        :'transaction_tracer.transaction_threshold' => Proc.new { self[:apdex_t] * 4 },
+        :'transaction_tracer.stack_trace_threshold' => 0.5,
+        :'transaction_tracer.explain_threshold'     => 0.5,
+        :'transaction_tracer.explain_enabled'       => true,
+        :'transaction_tracer.record_sql'            => 'obfuscated',
+        :'transaction_tracer.limit_segments'        => 4000,
+        :'transaction_tracer.random_sample'         => false,
+
+        :'slow_sql.enabled'               => Proc.new { self[:'transaction_tracer.enabled'] },
+        :'slow_sql.stack_trace_threshold' => Proc.new { self[:'transaction_tracer.stack_trace_threshold'] },
+        :'slow_sql.explain_threshold'     => Proc.new { self[:'transaction_tracer.explain_threshold'] },
+        :'slow_sql.explain_enabled'       => Proc.new { self[:'transaction_tracer.explain_enabled'] },
+        :'slow_sql.record_sql'            => Proc.new { self[:'transaction_tracer.record_sql'] },
+
+        :'error_collector.enabled'        => true,
+        :'error_collector.capture_source' => true,
+        :'error_collector.ignore_errors'  => 'ActionController::RoutingError'
+      }.freeze
+    end
+  end
+end

data/lib/new_relic/agent/configuration/environment_source.rb

@@ -0,0 +1,42 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class EnvironmentSource < DottedHash
+        def initialize
+          string_map = {
+            'NRCONFIG'              => :config_path,
+            'NEW_RELIC_LICENSE_KEY' => :license_key,
+            'NEWRELIC_LICENSE_KEY'  => :license_key,
+            'NEW_RELIC_APP_NAME'    => :app_name,
+            'NEWRELIC_APP_NAME'     => :app_name,
+            'NEW_RELIC_DISPATCHER'  => :dispatcher,
+            'NEWRELIC_DISPATCHER'   => :dispatcher,
+            'NEW_RELIC_FRAMEWORK'   => :framework,
+            'NEWRELIC_FRAMEWORK'    => :framework
+          }.each do |key, val|
+            self[val] = ENV[key] if ENV[key]
+          end
+
+          boolean_map = {
+            'NEWRELIC_ENABLE' => :agent_enabled
+          }.each do |key, val|
+            if ENV[key].to_s =~ /false|off|no/i
+              self[val] = false
+            elsif ENV[key] != nil
+              self[val] = true
+            end
+          end
+
+          if ENV['NEW_RELIC_LOG']
+            if ENV['NEW_RELIC_LOG'].upcase == 'STDOUT'
+              self[:log_file_path] = self[:log_file_name] = 'STDOUT'
+            else
+              self[:log_file_path] = File.dirname(ENV['NEW_RELIC_LOG'])
+              self[:log_file_name] = File.basename(ENV['NEW_RELIC_LOG'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/manager.rb

@@ -0,0 +1,100 @@
+require 'forwardable'
+require 'new_relic/agent/configuration/defaults'
+require 'new_relic/agent/configuration/yaml_source'
+require 'new_relic/agent/configuration/server_source'
+require 'new_relic/agent/configuration/environment_source'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class Manager
+        extend Forwardable
+        def_delegators :@cache, :[], :has_key?
+        attr_reader :config_stack # mainly for testing
+
+        def initialize
+          @config_stack = [ EnvironmentSource.new, DEFAULTS ]
+          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+
+          # letting Control handle this for now
+#           yaml_config = YamlSource.new("#{NewRelic::Control.instance.root}/#{self['config_path']}",
+#                                        NewRelic::Control.instance.env)
+#           apply_config(yaml_config, 1) if yaml_config
+        end
+
+        def apply_config(source, level=0)
+          @config_stack.insert(level, source.freeze)
+          expire_cache
+        end
+
+        def remove_config(source=nil)
+          if block_given?
+            @config_stack.delete_if {|c| yield c }
+          else
+            @config_stack.delete(source)
+          end
+          expire_cache
+        end
+
+        def source(key)
+          @config_stack.each do |config|
+            if config.respond_to?(key.to_sym) || config.has_key?(key.to_sym)
+              return config
+            end
+          end
+        end
+
+        def fetch(key)
+          @config_stack.each do |config|
+            next unless config
+            accessor = key.to_sym
+            if config.respond_to?(accessor)
+              return config.send(accessor)
+            elsif config.has_key?(accessor)
+              if config[accessor].respond_to?(:call)
+                return instance_eval(&config[accessor])
+              else
+                return config[accessor]
+              end
+            end
+          end
+          nil
+        end
+
+        def flattened_config
+          @config_stack.reverse.inject({}) do |flat,layer|
+            thawed_layer = layer.dup
+            thawed_layer.each do |k,v|
+              begin
+                thawed_layer[k] = instance_eval(&v) if v.respond_to?(:call)
+              rescue => e
+                NewRelic::Control.instance.log.debug("#{e.class.name} : #{e.message} - when calling Proc for config key #{k}")
+                thawed_layer[k] = nil
+              end
+              thawed_layer.delete(:config)
+            end
+            flat.merge(thawed_layer)
+          end
+        end
+
+        def exclude_rails_config(hash, key)
+          if defined?(::Rails::Configuration) &&
+              hash[key].kind_of?(::Rails::Configuration)
+            hash.delete(key)
+          end
+        end
+
+        def app_names
+          case self[:app_name]
+          when Array then self[:app_name]
+          when String then self[:app_name].split(';')
+          end
+        end
+
+        def expire_cache
+          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/server_source.rb

@@ -0,0 +1,24 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class ServerSource < DottedHash
+        def initialize(hash)
+          string_map = [
+             ['collect_traces', 'transaction_tracer.enabled'],
+             ['collect_traces', 'slow_sql.enabled'],
+             ['collect_errors', 'error_collector.enabled']
+          ].each do |pair|
+            hash[pair[1]] = hash[pair[0]] if hash[pair[0]] != nil
+          end
+
+          if hash['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            hash.delete('transaction_tracer.transaction_threshold')
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/yaml_source.rb

@@ -0,0 +1,61 @@
+require 'new_relic/agent/configuration'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class YamlSource < DottedHash
+        attr_accessor :file_path
+
+        def initialize(path, env)
+          config = {}
+          begin
+            @file_path = File.expand_path(path)
+            if !File.exists?(@file_path)
+              NewRelic::Control.instance.log.error("Unable to load configuration from #{path}")
+              return
+            end
+
+            file = File.read(@file_path)
+
+            # Next two are for populating the newrelic.yml via erb binding, necessary
+            # when using the default newrelic.yml file
+            generated_for_user = ''
+            license_key = ''
+
+            erb = ERB.new(file).result(binding)
+            config = merge!(YAML.load(erb)[env] || {})
+          rescue ScriptError, StandardError => e
+            NewRelic::Control.instance.log.warn("Unable to read configuration file: #{e}")
+          end
+
+          if config['transaction_tracer'] &&
+              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            config['transaction_tracer'].delete('transaction_threshold')
+          end
+
+          booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+
+          super(config)
+        end
+
+        protected
+
+        def booleanify_values(config, *keys)
+          # auto means defer ro default
+          keys.each do |option|
+            if config[option] == 'auto'
+              config.delete(option)
+            elsif !config[option].nil? && !is_boolean?(config[option])
+              config[option] = !!(config[option] =~ /yes|on|true/i)
+            end
+          end
+        end
+
+        def is_boolean?(value)
+          value == !!value
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration.rb

@@ -0,0 +1,48 @@
+require 'new_relic/agent/configuration/manager'
+
+module NewRelic
+  module Agent
+    module Configuration
+      def self.manager
+        @@manager ||= Manager.new
+      end
+
+      # This can be mixed in with minimal impact to provide easy
+      # access to the config manager
+      module Instance
+        def config
+          Configuration.manager
+        end
+      end
+
+      class DottedHash < ::Hash
+        def initialize(hash)
+          self.merge!(dot_flattened(hash))
+          keys.each do |key|
+            self[(key.to_sym rescue key) || key] = delete(key)
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name}:#{object_id} #{super}>"
+        end
+
+        protected
+        # turns {'a' => {'b' => 'c'}} into {'a.b' => 'c'}
+        def dot_flattened(nested_hash, names=[], result={})
+          nested_hash.each do |key, val|
+            next if val == nil
+            if val.respond_to?(:has_key?)
+              dot_flattened(val, names + [key], result)
+            else
+              result[(names + [key]).join('.')] = val
+            end
+          end
+          result
+        end
+      end
+
+      class ManualSource < DottedHash; end
+    end
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -25,23 +25,16 @@ module NewRelic
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
 
-        config = NewRelic::Control.instance.fetch('error_collector', {})
+        @enabled = @config_enabled = Agent.config[:'error_collector.enabled']
+        @capture_source = Agent.config[:'error_collector.capture_source']
 
-        @enabled = @config_enabled = config.fetch('enabled', true)
-        @capture_source = config.fetch('capture_source', true)
-
-        ignore_errors = config.fetch('ignore_errors', "")
+        ignore_errors = Agent.config[:'error_collector.ignore_errors']
         ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
         ignore_errors.each { |error| error.strip! }
         ignore(ignore_errors)
         @lock = Mutex.new
       end
-      
-      # Helper method to get the NewRelic::Control.instance
-      def control
-        NewRelic::Control.instance
-      end
-      
+
       # Returns the error filter proc that is used to check if an
       # error should be reported. When given a block, resets the
       # filter to the provided block.  The define_method() is used to
@@ -59,7 +52,10 @@ module NewRelic
       # errors is an array of Exception Class Names
       #
       def ignore(errors)
-        errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
+        errors.each do |error|
+          @ignore[error] = true
+          log.debug("Ignoring errors of type '#{error}'")
+        end
       end
       
       # This module was extracted from the notice_error method - it is
@@ -118,7 +114,7 @@ module NewRelic
           {
             :request_uri => fetch_from_options(options, :uri, ''),
             :request_referer => fetch_from_options(options, :referer, ''),
-            :rails_root => control.root
+            :rails_root => NewRelic::Control.instance.root
           }
         end
         
@@ -133,7 +129,7 @@ module NewRelic
         # returns nil
         def request_params_from_opts(options)
           value = options.delete(:request_params)
-          if control.capture_params
+          if Agent.config[:capture_params]
             value
           else
             nil

data/lib/new_relic/agent/instrumentation/active_record.rb

@@ -100,11 +100,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['skip_ar_instrumentation']
-  end
-
-  depends_on do
-    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+    !NewRelic::Agent.config[:disable_activerecord_instrumentation]
   end
   
   executes do

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -26,6 +26,7 @@ module NewRelic
         module ClassMethodsShim # :nodoc:
           def newrelic_ignore(*args); end
           def newrelic_ignore_apdex(*args); end
+          def newrelic_ignore_enduser(*args); end
         end
 
         module Shim # :nodoc:
@@ -51,6 +52,10 @@ module NewRelic
             newrelic_ignore_aspect('ignore_apdex', specifiers)
           end
 
+          def newrelic_ignore_enduser(specifiers={})
+            newrelic_ignore_aspect('ignore_enduser', specifiers)
+          end
+
           def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
             if specifiers.empty?
               self.newrelic_write_attr property, true
@@ -249,8 +254,9 @@ module NewRelic
               return perform_action_without_newrelic_trace(*args)
             end
           end
-
-          return perform_action_with_newrelic_profile(args, &block) if NewRelic::Control.instance.profiling?
+          
+          control = NewRelic::Control.instance
+          return perform_action_with_newrelic_profile(args, &block) if control.profiling?
 
           frame_data = _push_metric_frame(block_given? ? args : [])
           begin
@@ -258,11 +264,16 @@ module NewRelic
               frame_data.start_transaction
               begin
                 NewRelic::Agent::BusyCalculator.dispatcher_start frame_data.start
-                if block_given?
+                result = if block_given?
                   yield
                 else
                   perform_action_without_newrelic_trace(*args)
                 end
+                if defined?(request) && request && defined?(response) &&
+                    response && !Agent.config[:disable_mobile_headers]
+                  NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
+                end
+                result
               rescue => e
                 frame_data.notice_error(e)
                 raise
@@ -273,8 +284,9 @@ module NewRelic
             # Look for a metric frame in the thread local and process it.
             # Clear the thread local when finished to ensure it only gets called once.
             frame_data.record_apdex unless ignore_apdex?
-
             frame_data.pop
+            
+            NewRelic::Agent::TransactionInfo.get.ignore_end_user = true if ignore_enduser?
           end
         end
 
@@ -316,6 +328,10 @@ module NewRelic
         def ignore_apdex?
           _is_filtered?('ignore_apdex')
         end
+        
+        def ignore_enduser?
+          _is_filtered?('ignore_enduser')
+        end
 
         private