newrelic_rpm 3.12.0.288 → 3.12.1.298

data/lib/new_relic/agent/database/postgres_explain_obfuscator.rb

@@ -2,7 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'new_relic/agent/database'
 require 'new_relic/agent/database/obfuscation_helpers'
 
 module NewRelic

data/lib/new_relic/agent/datastores/metric_helper.rb

@@ -44,10 +44,12 @@ module NewRelic
           end
         end
 
-        def self.metrics_for(product, operation, collection = nil)
+        def self.metrics_for(product, operation, collection = nil, generic_product = nil)
           if overrides = overridden_operation_and_collection
-            operation  = overrides[0] || operation
-            collection = overrides[1] || collection
+            if should_override?(overrides, product, generic_product)
+              operation  = overrides[0] || operation
+              collection = overrides[1] || collection
+            end
           end
 
           suffix = all_suffix
@@ -80,6 +82,16 @@ module NewRelic
           txn ? txn.instrumentation_state[:datastore_override] : nil
         end
 
+        # If the override declared a product affiliation, abide by that
+        # ActiveRecord has database-specific product names, so we recognize
+        # it by the generic_product it passes.
+        def self.should_override?(overrides, product, generic_product)
+          override_product = overrides[2]
+
+          override_product.nil? ||
+            override_product == product ||
+            override_product == generic_product
+        end
       end
     end
   end

data/lib/new_relic/agent/error_collector.rb

@@ -9,16 +9,11 @@ module NewRelic
     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
+      EXCEPTION_TAG_IVAR = :'@__nr_seen_exception' unless defined? EXCEPTION_TAG_IVAR
 
       attr_accessor :errors
 
@@ -113,14 +108,30 @@ module NewRelic
         false
       end
 
-      def seen?(txn, exception)
-        error_ids = txn.nil? ? [] : txn.noticed_error_ids
-        error_ids.include?(exception.object_id)
+      # Calling instance_variable_set on a wrapped Java object in JRuby will
+      # generate a warning unless that object's class has already been marked
+      # as persistent, so we skip tagging of exception objects that are actually
+      # wrapped Java objects on JRuby.
+      #
+      # See https://github.com/jruby/jruby/wiki/Persistence
+      #
+      def exception_is_java_object?(exception)
+        NewRelic::LanguageSupport.jruby? && exception.respond_to?(:java_class)
       end
 
-      def tag_as_seen(state, exception)
-        txn = state.current_transaction
-        txn.noticed_error_ids << exception.object_id if txn
+      def exception_tagged?(exception)
+        return false if exception_is_java_object?(exception)
+        exception.instance_variable_get(EXCEPTION_TAG_IVAR)
+      end
+
+      def tag_exception(exception)
+        return if exception_is_java_object?(exception)
+        return if exception.frozen?
+        begin
+          exception.instance_variable_set(EXCEPTION_TAG_IVAR, true)
+        rescue => e
+          NewRelic::Agent.logger.warn("Failed to tag exception: #{exception}: ", e)
+        end
       end
 
       def blamed_metric_name(txn, options)
@@ -158,11 +169,11 @@ module NewRelic
         end
       end
 
-      def skip_notice_error?(state, exception)
+      def skip_notice_error?(exception)
         disabled? ||
           error_is_ignored?(exception) ||
           exception.nil? ||
-          seen?(state.current_transaction, exception)
+          exception_tagged?(exception)
       end
 
       # calls a method on an object, if it responds to it - used for
@@ -198,13 +209,12 @@ module NewRelic
       end
 
       # See NewRelic::Agent.notice_error for options and commentary
-
       def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
-        state = ::NewRelic::Agent::TransactionState.tl_get
+        return if skip_notice_error?(exception)
 
-        return if skip_notice_error?(state, exception)
+        tag_exception(exception)
 
-        tag_as_seen(state, exception)
+        state = ::NewRelic::Agent::TransactionState.tl_get
         increment_error_count!(state, exception, options)
         add_to_error_queue(create_noticed_error(exception, options))
 

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

@@ -17,6 +17,10 @@ module NewRelic
         end
 
         def self.insert_instrumentation
+          if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
+            ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_writer_methods
+          end
+
           ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
             include ::NewRelic::Agent::Instrumentation::ActiveRecord
           end
@@ -58,10 +62,10 @@ module NewRelic
 
               NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
                                                     @config, elapsed_time,
-                                                    state, &EXPLAINER)
+                                                    state, EXPLAINER)
               NewRelic::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
                                                     @config, elapsed_time,
-                                                    state, &EXPLAINER)
+                                                    state, EXPLAINER)
             end
           end
         end
@@ -88,6 +92,8 @@ DependencyDetection.defer do
   end
 
   executes do
+    require 'new_relic/agent/instrumentation/active_record_helper'
+
     if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
       ActiveSupport.on_load(:active_record) do
         ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation

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

@@ -24,5 +24,6 @@ DependencyDetection.defer do
   executes do
     ActiveSupport::Notifications.subscribe('sql.active_record',
       NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
+    ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_writer_methods
   end
 end

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

@@ -11,6 +11,53 @@ module NewRelic
       module ActiveRecordHelper
         module_function
 
+        # Used by both the AR 3.x and 4.x instrumentation
+        def instrument_writer_methods
+          ::ActiveRecord::Base.class_eval do
+            alias_method :save_without_newrelic, :save
+
+            def save(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic(*args, &blk)
+              end
+            end
+
+            alias_method :save_without_newrelic!, :save!
+
+            def save!(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic!(*args, &blk)
+              end
+            end
+          end
+
+          ::ActiveRecord::Relation.class_eval do
+            alias_method :update_all_without_newrelic, :update_all
+
+            def update_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                update_all_without_newrelic(*args, &blk)
+              end
+            end
+
+            alias_method :delete_all_without_newrelic, :delete_all
+
+            def delete_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                delete_all_without_newrelic(*args, &blk)
+              end
+            end
+
+            alias_method :destroy_all_without_newrelic, :destroy_all
+
+            def destroy_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                destroy_all_without_newrelic(*args, &blk)
+              end
+            end
+          end
+        end
+
         ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
         OTHER         = "other".freeze unless defined?(OTHER)
 
@@ -22,7 +69,8 @@ module NewRelic
 
           NewRelic::Agent::Datastores::MetricHelper.metrics_for(product,
                                                                 operation,
-                                                                model)
+                                                                model,
+                                                                ACTIVE_RECORD)
         end
 
         # @deprecated

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

@@ -59,12 +59,12 @@ module NewRelic
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, &@explainer)
+                        state, @explainer)
 
           NewRelic::Agent.instance.sql_sampler \
             .notice_sql(event.payload[:sql], metric, config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, &@explainer)
+                        state, @explainer)
 
           # exit transaction trace node
           stack.pop_frame(state, frame, metric, event.end)

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

@@ -79,6 +79,15 @@ module NewRelic
             elsif ! (Hash === specifiers)
               ::NewRelic::Agent.logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
             else
+              # symbolize the incoming values
+              specifiers = specifiers.inject({}) do |memo, (key, values)|
+                if values.is_a?(Array)
+                  memo[key] = values.map(&:to_sym)
+                else
+                  memo[key] = values.to_sym
+                end
+                memo
+              end
               self.newrelic_write_attr property, specifiers
             end
           end

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

@@ -76,7 +76,7 @@ DependencyDetection.defer do
         true
       end
     rescue => e
-      ::NewRelic::Agent.logger.info("Could not determine if third party newrelic-grape gem is installed")
+      ::NewRelic::Agent.logger.info("Could not determine if third party newrelic-grape gem is installed", e)
       true
     end
   end

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

@@ -14,6 +14,14 @@ DependencyDetection.defer do
     ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
   end
 
+  executes do
+    if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
+      ::NewRelic::Agent.logger.info 'Requiring resolv-replace'
+      require 'resolv'
+      require 'resolv-replace'
+    end
+  end
+
   executes do
     module Resque
       module Plugins
@@ -62,26 +70,6 @@ DependencyDetection.defer do
     end
 
     if NewRelic::LanguageSupport.can_fork?
-      # Resque::Worker#fork isn't around in Resque 2.x
-      if NewRelic::VersionNumber.new(::Resque::VERSION) < NewRelic::VersionNumber.new("2.0.0")
-        ::Resque::Worker.class_eval do
-          if NewRelic::Agent.config[:'resque.use_harvest_lock']
-            ::NewRelic::Agent.logger.info 'Installing Resque harvest/fork synchronization'
-            def fork_with_newrelic(*args, &block)
-              NewRelic::Agent.instance.synchronize_with_harvest do
-                fork_without_newrelic(*args, &block)
-
-                # Reached in parent, not expected in the child since Resque
-                # uses the block form of fork
-              end
-            end
-
-            alias_method :fork_without_newrelic, :fork
-            alias_method :fork, :fork_with_newrelic
-          end
-        end
-      end
-
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,
                                      :sync_startup => true,

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

@@ -3,8 +3,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'newrelic_rpm'
-
 DependencyDetection.defer do
   @name = :sequel
 

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

@@ -61,6 +61,12 @@ DependencyDetection.defer do
       config.server_middleware do |chain|
         chain.add NewRelic::SidekiqInstrumentation
       end
+
+      if config.respond_to?(:error_handlers)
+        config.error_handlers << Proc.new do |error, *_|
+          NewRelic::Agent.notice_error(error)
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/log_once.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module LogOnce
+      NUM_LOG_ONCE_KEYS = 1000
+
+      def log_once(level, key, *msgs)
+        @already_logged_lock.synchronize do
+          return if @already_logged.include?(key)
+
+          if @already_logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+            # The reason for preventing too many keys in `logged` is for
+            # memory concerns.
+            # The reason for checking the type of the key is that we always want
+            # to allow symbols to log, since there are very few of them.
+            # The assumption here is that you would NEVER pass dynamically-created
+            # symbols, because you would never create symbols dynamically in the
+            # first place, as that would already be a memory leak in most Rubies,
+            # even if we didn't hang on to them all here.
+            return
+          end
+
+          @already_logged[key] = true
+        end
+
+        self.send(level, *msgs)
+      end
+
+      def clear_already_logged
+        @already_logged_lock.synchronize do
+          @already_logged = {}
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/memory_logger.rb

@@ -4,10 +4,17 @@
 
 # Base class for startup logging and testing in multiverse
 
+require 'new_relic/agent/log_once'
+
 module NewRelic
   module Agent
     class MemoryLogger
+      include LogOnce
+
       def initialize
+        @already_logged_lock = Mutex.new
+        clear_already_logged
+
         @messages = []
       end
 
@@ -15,7 +22,7 @@ module NewRelic
         true
       end
 
-      attr_accessor :messages, :level
+      attr_accessor :messages, :level, :log_formatter
 
       def fatal(*msgs, &blk)
         messages << [:fatal, msgs, blk]

data/lib/new_relic/agent/method_tracer.rb

@@ -2,7 +2,11 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'new_relic/control'
+# This file may be independently required to set up method tracing prior to
+# the full agent loading. In those cases, we do need at least this require to
+# bootstrap things.
+require 'new_relic/control' unless defined?(NewRelic::Control)
+
 require 'new_relic/agent/method_tracer_helpers'
 
 module NewRelic

data/lib/new_relic/agent/new_relic_service.rb

@@ -181,10 +181,6 @@ module NewRelic
           :item_count => data.size)
       end
 
-      def utilization_data(data)
-        invoke_remote(:utilization_data, data)
-      end
-
       # We do not compress if content is smaller than 64kb.  There are
       # problems with bugs in Ruby in some versions that expose us
       # to a risk of segfaults if we compress aggressively.
@@ -303,18 +299,21 @@ module NewRelic
         end
       end
 
-      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
       def create_http_connection
-        proxy_server = control.proxy_server
-        # Proxy returns regular HTTP if @proxy_host is nil (the default)
-        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
-                                      proxy_server.user, proxy_server.password)
-
-        if proxy_server.name
-          ::NewRelic::Agent.logger.debug("Using proxy server #{proxy_server.name}:#{proxy_server.port}")
+        if Agent.config[:proxy_host]
+          ::NewRelic::Agent.logger.debug("Using proxy server #{Agent.config[:proxy_host]}:#{Agent.config[:proxy_port]}")
+
+          proxy = Net::HTTP::Proxy(
+            Agent.config[:proxy_host],
+            Agent.config[:proxy_port],
+            Agent.config[:proxy_user],
+            Agent.config[:proxy_pass]
+          )
+          conn = proxy.new(@collector.name, @collector.port)
+        else
+          conn = Net::HTTP.new(@collector.name, @collector.port)
         end
 
-        conn = http_class.new((@collector.ip || @collector.name), @collector.port)
         setup_connection_for_ssl(conn) if Agent.config[:ssl]
         setup_connection_timeouts(conn)
 
@@ -332,7 +331,7 @@ module NewRelic
       # connection if verify_peer is enabled
       def cert_file_path
         if path_override = NewRelic::Agent.config[:ca_bundle_path]
-          NewRelic::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exists? path_override
+          NewRelic::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exist? path_override
           path_override
         else
           File.expand_path(File.join(control.newrelic_root, 'cert', 'cacert.pem'))