wd_newrelic_rpm 3.3.4.1

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,251 @@
+module NewRelic
+  module Agent
+    # This class collects errors from the parent application, storing
+    # them until they are harvested and transmitted to the server
+    class ErrorCollector
+      include NewRelic::CollectionHelper
+
+      # Defined the methods that need to be stubbed out when the
+      # agent is disabled
+      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
+      attr_reader :config_enabled
+      
+      # Returns a new error collector
+      def initialize
+        @errors = []
+        # lookup of exception class names to ignore.  Hash for fast access
+        @ignore = {}
+
+        config = NewRelic::Control.instance.fetch('error_collector', {})
+
+        @enabled = @config_enabled = config.fetch('enabled', true)
+        @capture_source = config.fetch('capture_source', true)
+
+        ignore_errors = config.fetch('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
+      # wrap the block in a lambda so return statements don't result in a
+      # LocalJump exception.
+      def ignore_error_filter(&block)
+        if block
+          self.class.class_eval { define_method(:ignore_filter_proc, &block) }
+          @ignore_filter = method(:ignore_filter_proc)
+        else
+          @ignore_filter
+        end
+      end
+
+      # errors is an array of Exception Class Names
+      #
+      def ignore(errors)
+        errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
+      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 !error_is_ignored?(exception)
+              increment_error_count!
+              return exception.nil? # exit early if the exception is nil
+            end
+          end
+          # 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
+          }
+        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
+            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)
+          {
+            :request_params => normalize_params(request_params_from_opts(options)),
+            :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
+        def exception_info(exception)
+          {
+            :file_name => sense_method(exception, 'file_name'),
+            :line_number => sense_method(exception, 'line_number'),
+            :source => extract_source(exception),
+            :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)
+          over_limit = (@errors.length >= MAX_ERROR_QUEUE_LENGTH)
+          log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
+          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)
+          end
+        end
+      end
+
+      include NoticeError
+
+      # Notice the error with the given available options:
+      #
+      # * <tt>:uri</tt> => The request path, minus any request params or query string.
+      # * <tt>:referer</tt> => The URI of the referer
+      # * <tt>:metric</tt> => The metric name associated with the transaction
+      # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+      # * <tt>:custom_params</tt> => Custom parameters
+      #
+      # If anything is left over, it's added to custom params
+      # If exception is nil, the error count is bumped and no traced error is recorded
+      def notice_error(exception, options={})
+        return if should_exit_notice_error?(exception)
+        action_path     = fetch_from_options(options, :metric, (NewRelic::Agent.instance.stats_engine.scope_name || ''))
+        exception_options = error_params_from_options(options).merge(exception_info(exception))
+        add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
+        exception
+      rescue => e
+        log.error("Error capturing an error, yodawg. #{e}")
+      end
+
+      # Get the errors currently queued up.  Unsent errors are left
+      # over from a previous unsuccessful attempt to send them to the server.
+      def harvest_errors(unsent_errors)
+        @lock.synchronize do
+          errors = @errors
+          @errors = []
+
+          if unsent_errors && !unsent_errors.empty?
+            errors = unsent_errors + errors
+          end
+
+          errors
+        end
+      end
+
+      private
+      def log
+        NewRelic::Agent.logger
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation.rb

@@ -0,0 +1,9 @@
+require 'new_relic/agent'
+module NewRelic
+  module Agent
+    # stub module that contains instrumentation defined in the
+    # instrumentation directory
+    module Instrumentation
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+DependencyDetection.defer do
+  @name = :active_merchant
+  
+  depends_on do
+    defined?(ActiveMerchant) && defined?(ActiveMerchant::Billing) &&
+      defined?(ActiveMerchant::Billing::Gateway) &&
+      ActiveMerchant::Billing::Gateway.respond_to?(:implementations)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActiveMerchant instrumentation'
+  end
+  
+  executes do
+    ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
+      gateway.class_eval do
+        implemented_methods = public_instance_methods(false)
+        gateway_name = self.name.split('::').last
+        [:authorize, :purchase, :credit, :void, :capture, :recurring].each do |operation|
+          if implemented_methods.include?(operation.to_s)
+            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}", :scoped_metric_only => true
+            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
+            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecord
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          end
+        end
+                
+        def log_with_newrelic_instrumentation(*args, &block)
+          if !NewRelic::Agent.is_execution_traced?
+            return log_without_newrelic_instrumentation(*args, &block)
+          end
+          
+          sql, name, binds = args
+          metric = metric_for_name(name) || metric_for_sql(sql)
+          
+          if !metric
+            log_without_newrelic_instrumentation(*args, &block)
+          else
+            metrics = [metric, remote_service_metric].compact
+            metrics += rollup_metrics_for(metric)
+            self.class.trace_execution_scoped(metrics) do
+              t0 = Time.now
+              begin
+                log_without_newrelic_instrumentation(*args, &block)
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
+                                                         @config, elapsed_time)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
+                                                         @config, elapsed_time)
+              end
+            end
+          end
+        end
+        
+        def remote_service_metric
+          if @config && @config[:adapter]
+            type = @config[:adapter].sub(/\d*/, '')
+            host = @config[:host] || 'localhost'
+            "RemoteService/sql/#{type}/#{host}"
+          end                      
+        end
+        
+        def metric_for_name(name)
+          if name && (parts = name.split " ") && parts.size == 2
+            model = parts.first
+            operation = parts.last.downcase
+            op_name = case operation
+                          when 'load', 'count', 'exists' then 'find'
+                          when 'indexes', 'columns' then nil # fall back to DirectSQL
+                          when 'destroy', 'find', 'save', 'create' then operation
+                          when 'update' then 'save'
+                          else
+                            if model == 'Join'
+                              operation
+                            end
+                          end
+            "ActiveRecord/#{model}/#{op_name}" if op_name
+          end
+        end
+
+        def metric_for_sql(sql)
+          metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+          if metric.nil?
+            if sql =~ /^(select|update|insert|delete|show)/i
+              # Could not determine the model/operation so let's find a better
+              # metric.  If it doesn't match the regex, it's probably a show
+              # command or some DDL which we'll ignore.
+              metric = "Database/SQL/#{$1.downcase}"
+            else
+              metric = "Database/SQL/other"
+            end
+          end
+          metric
+        end
+        
+        def rollup_metrics_for(metric)
+          metrics = ["ActiveRecord/all"]
+          metrics << "ActiveRecord/#{$1}" if metric =~ /ActiveRecord\/\w+\/(\w+)/
+          metrics
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :active_record
+  
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['skip_ar_instrumentation']
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActiveRecord instrumentation'
+  end
+  
+  executes do
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      Rails.configuration.after_initialize do
+        insert_instrumentation
+      end
+    else
+      insert_instrumentation
+    end
+  end
+
+  def insert_instrumentation
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::NewRelic::Agent::Instrumentation::ActiveRecord
+    end
+    
+    ActiveRecord::Base.class_eval do
+      class << self
+        add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
+                          :metric => false)
+        add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
+                          :metric => false)
+      end
+    end          
+  end
+end

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

@@ -0,0 +1,68 @@
+module NewRelic
+  module Instrumentation
+    module ActsAsSolrInstrumentation
+      module ParserMethodsInstrumentation
+        def parse_query_with_newrelic(*args)
+          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+            t0 = Time.now
+            begin
+              parse_query_without_newrelic(*args)
+            ensure
+              NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :acts_as_solr
+  
+  depends_on do
+    defined?(ActsAsSolr)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::ParserMethods)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::ClassMethods)
+  end
+
+  depends_on do
+    defined?(ActsAsSolr::CommonMethods)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActsAsSolr instrumentation'
+  end
+  
+  executes do
+    ActsAsSolr::ParserMethods.module_eval do
+      include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
+      alias :parse_query_without_newrelic :parse_query
+      alias :parse_query :parse_query_with_newrelic
+    end
+  end
+
+  executes do
+    ActsAsSolr::ClassMethods.module_eval do
+      %w[find_by_solr find_id_by_solr multi_solr_search count_by_solr].each do |method|
+        add_method_tracer method, 'SolrClient/ActsAsSolr/query'
+      end
+      add_method_tracer :rebuild_solr_index, 'SolrClient/ActsAsSolr/index'
+    end
+  end
+
+  executes do
+    ActsAsSolr::CommonMethods.module_eval do
+      add_method_tracer :solr_add, 'SolrClient/ActsAsSolr/add'
+      add_method_tracer :solr_delete, 'SolrClient/ActsAsSolr/delete'
+      add_method_tracer :solr_commit, 'SolrClient/ActsAsSolr/commit'
+      add_method_tracer :solr_optimize, 'SolrClient/ActsAsSolr/optimize'
+    end
+  end
+end