ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/lib/new_relic/agent/error_collector.rb

@@ -10,38 +10,43 @@ module NewRelic
       module Shim #:nodoc:
         def notice_error(*args); end
       end
-      
+
       # Maximum possible length of the queue - defaults to 20, may be
       # made configurable in the future. This is a tradeoff between
       # memory and data retention
       MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
 
-      attr_accessor :enabled, :errors
-      attr_reader :config_enabled
-      
+      attr_accessor :errors
+
       # Returns a new error collector
       def initialize
         @errors = []
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
+        @capture_source = Agent.config[:'error_collector.capture_source']
 
-        config = NewRelic::Control.instance.fetch('error_collector', {})
-
-        @enabled = @config_enabled = config.fetch('enabled', true)
-        @capture_source = config.fetch('capture_source', true)
+        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
+        @lock = Mutex.new
 
-        ignore_errors = config.fetch('ignore_errors', "")
+        Agent.config.register_callback(:'error_collector.enabled') do |config_enabled|
+          log.debug "Errors will #{config_enabled ? '' : 'not '}be sent to the New Relic service."
+        end
+        Agent.config.register_callback(:'error_collector.ignore_errors') do |ignore_errors|
+          initialize_ignored_errors(ignore_errors)
+        end
+      end
+      
+      def initialize_ignored_errors(ignore_errors)
+        @ignore.clear
         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
+
+      def enabled?
+        Agent.config[:'error_collector.enabled']
       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,45 +64,43 @@ 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
       # internally tested and can be refactored without major issues.
       module NoticeError
-        # Whether the error collector is disabled or not
-        def disabled?
-          !@enabled
-        end
-        
         # Checks the provided error against the error filter, if there
         # is an error filter
         def filtered_by_error_filter?(error)
           return unless @ignore_filter
           !@ignore_filter.call(error)
         end
-        
+
         # Checks the array of error names and the error filter against
         # the provided error
         def filtered_error?(error)
           @ignore[error.class.name] || filtered_by_error_filter?(error)
         end
-        
+
         # an error is ignored if it is nil or if it is filtered
         def error_is_ignored?(error)
           error && filtered_error?(error)
         end
-        
+
         # Increments a statistic that tracks total error rate
         def increment_error_count!
           NewRelic::Agent.get_stats("Errors/all").increment_count
         end
-        
+
         # whether we should return early from the notice_error process
         # - based on whether the error is ignored or the error
         # collector is disabled
         def should_exit_notice_error?(exception)
-          if @enabled
+          if enabled?
             if !error_is_ignored?(exception)
               increment_error_count!
               return exception.nil? # exit early if the exception is nil
@@ -106,40 +109,40 @@ module NewRelic
           # disabled or an ignored error, per above
           true
         end
-        
+
         # acts just like Hash#fetch, but deletes the key from the hash
         def fetch_from_options(options, key, default=nil)
           options.delete(key) || default
         end
-        
+
         # returns some basic option defaults pulled from the provided
         # options hash
         def uri_ref_and_root(options)
           {
             :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
-        
+
         # If anything else is left over, we treat it like a custom param
         def custom_params_from_opts(options)
           # If anything else is left over, treat it like a custom param:
           fetch_from_options(options, :custom_params, {}).merge(options)
         end
-        
+
         # takes the request parameters out of the options hash, and
         # returns them if we are capturing parameters, otherwise
         # 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
           end
         end
-        
+
         # normalizes the request and custom parameters before attaching
         # them to the error. See NewRelic::CollectionHelper#normalize_params
         def normalized_request_and_custom_params(options)
@@ -148,32 +151,32 @@ module NewRelic
             :custom_params  => normalize_params(custom_params_from_opts(options))
           }
         end
-        
+
         # Merges together many of the options into something that can
         # actually be attached to the error
         def error_params_from_options(options)
           uri_ref_and_root(options).merge(normalized_request_and_custom_params(options))
         end
-        
+
         # calls a method on an object, if it responds to it - used for
         # detection and soft fail-safe. Returns nil if the method does
         # not exist
         def sense_method(object, method)
           object.send(method) if object.respond_to?(method)
         end
-        
+
         # extracts source from the exception, if the exception supports
         # that method
         def extract_source(exception)
           sense_method(exception, 'source_extract') if @capture_source
         end
-        
+
         # extracts a stack trace from the exception for debugging purposes
         def extract_stack_trace(exception)
           actual_exception = sense_method(exception, 'original_exception') || exception
           sense_method(actual_exception, 'backtrace') || '<no stack trace>'
         end
-        
+
         # extracts a bunch of information from the exception to include
         # in the noticed error - some may or may not be available, but
         # we try to include all of it
@@ -185,7 +188,7 @@ module NewRelic
             :stack_trace => extract_stack_trace(exception)
           }
         end
-        
+
         # checks the size of the error queue to make sure we are under
         # the maximum limit, and logs a warning if we are over the limit.
         def over_queue_limit?(message)
@@ -194,13 +197,14 @@ module NewRelic
           over_limit
         end
 
-        
         # Synchronizes adding an error to the error queue, and checks if
         # the error queue is too long - if so, we drop the error on the
         # floor after logging a warning.
         def add_to_error_queue(noticed_error)
           @lock.synchronize do
-            @errors << noticed_error unless over_queue_limit?(noticed_error.message)
+            if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
+              @errors << noticed_error
+            end
           end
         end
       end
@@ -224,7 +228,7 @@ module NewRelic
         add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
         exception
       rescue => e
-        log.error("Error capturing an error, yodawg. #{e}")
+        log.error("Error capturing an error #{e}")
       end
 
       # Get the errors currently queued up.  Unsent errors are left

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
@@ -139,6 +144,7 @@ module NewRelic
               options_arg << %Q[:#{key} => #{valuestr}]
             end
             traced_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+            visibility = NewRelic::Helper.instance_method_visibility self, method
 
             class_eval <<-EOC
               def #{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}(*args, &block)
@@ -147,8 +153,12 @@ module NewRelic
                  end
               end
             EOC
-            alias_method "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}", method.to_s
-            alias_method method.to_s, "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
+            without_method_name = "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"
+            with_method_name = "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
+            alias_method without_method_name, method.to_s
+            alias_method method.to_s, with_method_name
+            send visibility, method
+            send visibility, with_method_name
             NewRelic::Control.instance.log.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
           end
         end
@@ -244,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
@@ -253,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
@@ -268,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
 
@@ -311,6 +328,10 @@ module NewRelic
         def ignore_apdex?
           _is_filtered?('ignore_apdex')
         end
+        
+        def ignore_enduser?
+          _is_filtered?('ignore_enduser')
+        end
 
         private
 

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

@@ -180,14 +180,6 @@ module NewRelic
   module Agent
     module Instrumentation
       module DataMapperInstrumentation
-
-        def self.included(klass)
-          klass.class_eval do
-            alias_method :log_without_newrelic_instrumentation, :log
-            alias_method :log, :log_with_newrelic_instrumentation
-          end
-        end
-
         # Unlike in AR, log is called in DM after the query actually ran,
         # complete with metrics.  Since DO has already calculated the
         # duration, there's nothing more to measure, so just record and log.
@@ -195,7 +187,7 @@ module NewRelic
         # We rely on the assumption that all possible entry points have been
         # hooked with tracers, ensuring that notice_sql attaches this SQL to
         # the proper call scope.
-        def log_with_newrelic_instrumentation(msg)
+        def log(msg)
           return unless NewRelic::Agent.is_execution_traced?
           return unless operation = case NewRelic::Helper.correctly_encoded(msg.query)
                                     when /^\s*select/i          then 'find'
@@ -216,7 +208,7 @@ module NewRelic
             NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
           end
         ensure
-          log_without_newrelic_instrumentation(msg)
+          super
         end
 
       end # DataMapperInstrumentation

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

@@ -4,7 +4,7 @@ DependencyDetection.defer do
   @name = :delayed_job
   
   depends_on do
-    !NewRelic::Control.instance['disable_dj']
+    !NewRelic::Agent.config[:disable_dj]
   end
 
   depends_on do

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

@@ -32,7 +32,7 @@ module NewRelic
          end      
         end
         def memcache_key_snippet(method_name)
-          return "" unless NewRelic::Control.instance['capture_memcache_keys']
+          return "" unless NewRelic::Agent.config[:capture_memcache_keys]
           "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
         end
       end
@@ -44,7 +44,7 @@ DependencyDetection.defer do
   @name = :memcache
   
   depends_on do
-    !NewRelic::Control.instance['disable_memcache_instrumentation']
+    !NewRelic::Agent.config[:disable_memcache_instrumentation]
   end
 
   depends_on do

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

@@ -27,21 +27,11 @@ module NewRelic
         attr_accessor :request
 
 
-        @@check_server_connection = false
-        def self.check_server_connection=(value)
-          @@check_server_connection = value
-        end
         # Return the currently active metric frame, or nil.  Call with +true+
         # to create a new metric frame if one is not already on the thread.
         def self.current(create_if_empty=nil)
           f = Thread.current[:newrelic_metric_frame]
           return f if f || !create_if_empty
-
-          # Reconnect to the server if necessary.  This is only done
-          # for old versions of passenger that don't implement an explicit after_fork
-          # event.
-          agent.after_fork(:keep_retrying => false) if @@check_server_connection
-
           Thread.current[:newrelic_metric_frame] = new
         end
 
@@ -64,8 +54,8 @@ module NewRelic
         if defined? JRuby
           begin
             require 'java'
-            include_class 'java.lang.management.ManagementFactory'
-            include_class 'com.sun.management.OperatingSystemMXBean'
+            java_import 'java.lang.management.ManagementFactory'
+            java_import 'com.sun.management.OperatingSystemMXBean'
             @@java_classes_loaded = true
           rescue => e
           end
@@ -263,7 +253,7 @@ module NewRelic
         end
         
         def queue_time
-          apdex_start - start
+          start - apdex_start
         end
 
         def add_custom_parameters(p)
@@ -320,7 +310,7 @@ module NewRelic
         # the apdex should be recorded as a failure regardless of duration.
         def self.update_apdex(stat, duration, failed)
           duration = duration.to_f
-          apdex_t = NewRelic::Control.instance.apdex_t
+          apdex_t = Agent.config[:apdex_t]
           case
           when failed
             stat.record_apdex_f

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

@@ -1,19 +1,19 @@
 DependencyDetection.defer do
   @name = :passenger
-  
+
   depends_on do
-    defined?(PhusionPassenger)
+    defined?(::PhusionPassenger)
   end
 
   executes do
     NewRelic::Agent.logger.debug "Installing Passenger event hooks."
 
-    PhusionPassenger.on_event(:stopping_worker_process) do
+    ::PhusionPassenger.on_event(:stopping_worker_process) do
       NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
       NewRelic::Agent.instance.shutdown
     end
 
-    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
       # We want to reset the stats from the stats engine in case any carried
       # over into the spawned process.  Don't clear them in case any were
       # cached.  We do this even in conservative spawning.
@@ -21,17 +21,3 @@ DependencyDetection.defer do
     end
   end
 end
-
-DependencyDetection.defer do
-  depends_on do
-    defined?(::Passenger) && defined?(::Passenger::AbstractServer) || defined?(::IN_PHUSION_PASSENGER)
-  end
-
-  executes do
-    ## We're on an older version of passenger
-    ## FIXME: This warning is printing on current version of passenger
-    # NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
-
-    NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
-  end
-end