sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/agent/database.rb

@@ -0,0 +1,254 @@
+require 'singleton'
+
+module NewRelic
+  # columns for a mysql explain plan
+  MYSQL_EXPLAIN_COLUMNS = [
+                           "Id",
+                           "Select Type",
+                           "Table",
+                           "Type",
+                           "Possible Keys",
+                           "Key",
+                           "Key Length",
+                           "Ref",
+                           "Rows",
+                           "Extra"
+                          ].freeze
+
+  module Agent
+    module Database
+      extend self
+
+      def obfuscate_sql(sql)
+        Obfuscator.instance.obfuscator.call(sql)
+      end
+
+      def set_sql_obfuscator(type, &block)
+        Obfuscator.instance.set_sql_obfuscator(type, &block)
+      end
+
+      def record_sql_method
+        case Agent.config[:'transaction_tracer.record_sql'].to_s
+        when 'off'
+          :off
+        when 'none'
+          :off
+        when 'false'
+          :off
+        when 'raw'
+          :raw
+        else
+          :obfuscated
+        end
+      end
+
+      def get_connection(config)
+        ConnectionManager.instance.get_connection(config)
+      end
+
+      def close_connections
+        ConnectionManager.instance.close_connections
+      end
+
+      # Perform this in the runtime environment of a managed
+      # application, to explain the sql statement executed within a
+      # segment of a transaction sample. Returns an array of
+      # explanations (which is an array rows consisting of an array of
+      # strings for each column returned by the the explain query)
+      # Note this happens only for statements whose execution time
+      # exceeds a threshold (e.g. 500ms) and only within the slowest
+      # transaction in a report period, selected for shipment to New
+      # Relic
+      def explain_sql(sql, connection_config)
+        return nil unless sql && connection_config
+        statement = sql.split(";\n")[0] # only explain the first
+        explain_plan = explain_statement(statement, connection_config)
+        return explain_plan || []
+      end
+
+      def explain_statement(statement, config)
+        return unless is_select?(statement)
+
+        if statement[-3,3] == '...'
+          NewRelic::Agent.logger.debug('Unable to collect explain plan for truncated query.')
+          return
+        end
+
+        if parameterized?(statement)
+          NewRelic::Agent.logger.debug('Unable to collect explain plan for parameterized query.')
+          return
+        end
+
+        handle_exception_in_explain do
+          connection = get_connection(config)
+          plan = nil
+          if connection
+            plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
+          end
+          return plan
+        end
+      end
+
+      def process_resultset(items)
+        # The resultset type varies for different drivers.  Only thing you can count on is
+        # that it implements each.  Also: can't use select_rows because the native postgres
+        # driver doesn't know that method.
+
+        headers = []
+        values = []
+        if items.respond_to?(:each_hash)
+          items.each_hash do |row|
+            headers = row.keys
+            values << headers.map{|h| row[h] }
+          end
+        elsif items.respond_to?(:each)
+          items.each do |row|
+            if row.kind_of?(Hash)
+              headers = row.keys
+              values << headers.map{|h| row[h] }
+            else
+              values << row
+            end
+          end
+        else
+          values = [items]
+        end
+
+        headers = nil if headers.empty?
+        [headers, values]
+      end
+
+      def handle_exception_in_explain
+        yield
+      rescue => e
+        begin
+          # guarantees no throw from explain_sql
+          ::NewRelic::Agent.logger.error("Error getting query plan:", e)
+        rescue
+          # double exception. throw up your hands
+        end
+      end
+
+      def is_select?(statement)
+        # split the string into at most two segments on the
+        # system-defined field separator character
+        first_word, rest_of_statement = statement.split($;, 2)
+        (first_word.upcase == 'SELECT')
+      end
+
+      def parameterized?(statement)
+        Obfuscator.instance.obfuscate_single_quote_literals(statement) =~ /\$\d+/
+      end
+
+      class ConnectionManager
+        include Singleton
+
+        # Returns a cached connection for a given ActiveRecord
+        # configuration - these are stored or reopened as needed, and if
+        # we cannot get one, we ignore it and move on without explaining
+        # the sql
+        def get_connection(config)
+          @connections ||= {}
+
+          connection = @connections[config]
+
+          return connection if connection
+
+          begin
+            connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
+            @connections[config] = connection
+          rescue => e
+            ::NewRelic::Agent.logger.error("Caught exception trying to get connection to DB for explain. Control: #{config}", e)
+            nil
+          end
+        end
+
+        # Closes all the connections in the internal connection cache
+        def close_connections
+          @connections ||= {}
+          @connections.values.each do |connection|
+            begin
+              connection.disconnect!
+            rescue
+            end
+          end
+
+          @connections = {}
+        end
+      end
+
+      class Obfuscator
+        include Singleton
+
+        attr_reader :obfuscator
+
+        def initialize
+          reset
+        end
+
+        def reset
+          @obfuscator = method(:default_sql_obfuscator)
+        end
+
+        # Sets the sql obfuscator used to clean up sql when sending it
+        # to the server. Possible types are:
+        #
+        # :before => sets the block to run before the existing
+        # obfuscators
+        #
+        # :after => sets the block to run after the existing
+        # obfuscator(s)
+        #
+        # :replace => removes the current obfuscator and replaces it
+        # with the provided block
+        def set_sql_obfuscator(type, &block)
+          if type == :before
+            @obfuscator = NewRelic::ChainedCall.new(block, @obfuscator)
+          elsif type == :after
+            @obfuscator = NewRelic::ChainedCall.new(@obfuscator, block)
+          elsif type == :replace
+            @obfuscator = block
+          else
+            fail "unknown sql_obfuscator type #{type}"
+          end
+        end
+
+        def default_sql_obfuscator(sql)
+          if sql[-3,3] == '...'
+            return "Query too large (over 16k characters) to safely obfuscate"
+          end
+
+          stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
+          adapter = stmt.adapter
+          obfuscated = remove_escaped_quotes(stmt)
+          obfuscated = obfuscate_single_quote_literals(obfuscated)
+          if !(adapter.to_s =~ /postgres/ || adapter.to_s =~ /sqlite/)
+            obfuscated = obfuscate_double_quote_literals(obfuscated)
+          end
+          obfuscated = obfuscate_numeric_literals(obfuscated)
+          obfuscated.to_s # return back to a regular String
+        end
+
+        def remove_escaped_quotes(sql)
+          sql.gsub(/\\"/, '').gsub(/\\'/, '')
+        end
+
+        def obfuscate_single_quote_literals(sql)
+          sql.gsub(/'(?:[^']|'')*'/, '?')
+        end
+
+        def obfuscate_double_quote_literals(sql)
+          sql.gsub(/"(?:[^"]|"")*"/, '?')
+        end
+
+        def obfuscate_numeric_literals(sql)
+          sql.gsub(/\b\d+\b/, "?")
+        end
+      end
+
+      class Statement < String
+        attr_accessor :adapter
+      end
+    end
+  end
+end

data/lib/new_relic/agent/error_collector.rb

@@ -0,0 +1,266 @@
+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 :errors
+
+      # Returns a new error collector
+      def initialize
+        @errors = []
+        @seen_error_ids = []
+
+        # lookup of exception class names to ignore.  Hash for fast access
+        @ignore = {}
+        @capture_source = Agent.config[:'error_collector.capture_source']
+
+        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
+        @lock = Mutex.new
+
+        Agent.config.register_callback(:'error_collector.enabled') do |config_enabled|
+          ::NewRelic::Agent.logger.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)
+      end
+
+      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
+      # 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 do |error|
+          @ignore[error] = true
+          ::NewRelic::Agent.logger.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
+        # 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
+        # Be sure not to double-count same exception. This clears per harvest.
+        def increment_error_count!(exception)
+          return if @seen_error_ids.include?(exception.object_id)
+          @seen_error_ids << exception.object_id
+
+          NewRelic::Agent.get_stats("Errors/all").increment_count
+
+          txn_info = NewRelic::Agent::TransactionInfo.get
+          if (txn_info.transaction_name_set?)
+            NewRelic::Agent.get_stats("Errors/#{txn_info.transaction_name}").increment_count
+          end
+        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!(exception)
+              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 => 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 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)
+          {
+            :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)
+          ::NewRelic::Agent.logger.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
+            if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
+              @errors << noticed_error
+            end
+          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)
+        NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
+        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
+        ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", 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 = []
+
+          # Only expect to re-see errors on same request, so clear on harvest
+          @seen_error_ids = []
+
+          if unsent_errors && !unsent_errors.empty?
+            errors = unsent_errors + errors
+          end
+
+          errors
+        end
+      end
+    end
+  end
+end