newrelic_rpm 3.10.0.279 → 3.11.0.283

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

@@ -2,6 +2,8 @@
 # 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/deprecator'
+
 module NewRelic
   module Agent
     module Instrumentation
@@ -17,11 +19,18 @@ module NewRelic
 
         # @deprecated
         def self.recording_web_transaction?
+          NewRelic::Agent::Deprecator.deprecate(
+            "NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?",
+            "NewRelic::Agent::Transaction.recording_web_transaction?")
+
           Transaction.recording_web_transaction?
         end
 
         # @deprecated
         def self.abort_transaction!
+          NewRelic::Agent::Deprecator.deprecate(
+            "NewRelic::Agent::Instrumentation::MetricFrame.abort_transaction!",
+            "NewRelic::Agent::Transaction.abort_transaction!")
           Transaction.abort_transaction!
         end
       end

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

@@ -15,6 +15,9 @@ module NewRelic
       class MiddlewareProxy
         include MiddlewareTracing
 
+        ANONYMOUS_CLASS   = "AnonymousClass".freeze unless defined?(ANONYMOUS_CLASS)
+        OBJECT_CLASS_NAME = "Object".freeze unless defined?(OBJECT_CLASS_NAME)
+
         # This class is used to wrap classes that are passed to
         # Rack::Builder#use without synchronously instantiating those classes.
         # A MiddlewareProxy::Generator responds to new, like a Class would, and
@@ -84,12 +87,22 @@ module NewRelic
         # to a singleton instance of the the subclass. We need to ensure that we
         # capture the correct name in both cases.
         def determine_class_name
+          clazz = class_for_target
+
+          name = clazz.name
+          name = clazz.superclass.name if name.nil? || name == ""
+          name = ANONYMOUS_CLASS       if name.nil? || name == OBJECT_CLASS_NAME
+          name
+        end
+
+        def class_for_target
           if @target.is_a?(Class)
-            @target.name
+            @target
           else
-            @target.class.name
+            @target.class
           end
         end
+
       end
     end
   end

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

@@ -20,7 +20,7 @@ DependencyDetection.defer do
   end
 
   def install_mongo_instrumentation
-    require 'new_relic/agent/datastores/mongo/metric_generator'
+    require 'new_relic/agent/datastores/mongo/metric_translator'
     require 'new_relic/agent/datastores/mongo/statement_formatter'
 
     hook_instrument_methods
@@ -39,19 +39,6 @@ DependencyDetection.defer do
     target_class.class_eval do
       include NewRelic::Agent::MethodTracer
 
-      def new_relic_instance_metric_builder
-        Proc.new do
-          if @pool
-            host, port = @pool.host, @pool.port
-          elsif @connection && (primary = @connection.primary)
-            host, port = primary[0], primary[1]
-          end
-
-          database_name = @db.name if @db
-          NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for(host, port, database_name)
-        end
-      end
-
       # It's key that this method eats all exceptions, as it rests between the
       # Mongo operation the user called and us returning them the data. Be safe!
       def new_relic_notice_statement(t0, payload, name)
@@ -65,13 +52,13 @@ DependencyDetection.defer do
 
       def new_relic_generate_metrics(operation, payload = nil)
         payload ||= { :collection => self.name, :database => self.db.name }
-        NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(operation, payload)
+        NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(operation, payload)
       end
 
       def instrument_with_new_relic_trace(name, payload = {}, &block)
         metrics = new_relic_generate_metrics(name, payload)
 
-        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
+        trace_execution_scoped(metrics) do
           t0 = Time.now
 
           result = NewRelic::Agent.disable_all_tracing do
@@ -92,7 +79,7 @@ DependencyDetection.defer do
     ::Mongo::Collection.class_eval do
       def save_with_new_relic_trace(doc, opts = {}, &block)
         metrics = new_relic_generate_metrics(:save)
-        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
+        trace_execution_scoped(metrics) do
           t0 = Time.now
 
           result = NewRelic::Agent.disable_all_tracing do
@@ -113,7 +100,7 @@ DependencyDetection.defer do
     ::Mongo::Collection.class_eval do
       def ensure_index_with_new_relic_trace(spec, opts = {}, &block)
         metrics = new_relic_generate_metrics(:ensureIndex)
-        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
+        trace_execution_scoped(metrics) do
           t0 = Time.now
 
           result = NewRelic::Agent.disable_all_tracing do

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

@@ -0,0 +1,36 @@
+# 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 Instrumentation
+      module SequelHelper
+        extend self
+
+        # Fallback if the product cannot be determined
+        DEFAULT_PRODUCT_NAME = "Sequel".freeze
+
+        # A Sequel adapter is called an "adapter_scheme" and can be accessed from
+        # the database:
+        #
+        #   DB.adapter_scheme
+        PRODUCT_NAMES = {
+          :ibmdb => "IBMDB2",
+          :firebird => "Firebird",
+          :informix => "Informix",
+          :jdbc => "JDBC",
+          :mysql => "MySQL",
+          :mysql2 => "MySQL",
+          :oracle => "Oracle",
+          :postgres => "Postgres",
+          :sqlite => "SQLite"
+        }.freeze
+
+        def product_name_from_adapter(adapter)
+          PRODUCT_NAMES.fetch(adapter, DEFAULT_PRODUCT_NAME)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -301,6 +301,10 @@ module NewRelic
         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}")
+        end
+
         conn = http_class.new((@collector.ip || @collector.name), @collector.port)
         setup_connection_for_ssl(conn) if Agent.config[:ssl]
         setup_connection_timeouts(conn)

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -150,14 +150,6 @@ module NewRelic
           stats
         end
 
-        # Returns a stat if one exists, otherwise returns nil.
-        def lookup_stats(metric_name, scope_name = '')
-          spec = NewRelic::MetricSpec.new(metric_name, scope_name)
-          with_stats_lock do
-            @stats_hash.has_key?(spec) ? @stats_hash[spec] : nil
-          end
-        end
-
         # Helper for recording a straight value into the count
         def tl_record_supportability_metric_count(metric, value)
           real_name = "Supportability/#{metric}"
@@ -233,16 +225,9 @@ module NewRelic
           NewRelic::Agent::BusyCalculator.reset
         end
 
-        # Returns all of the metric names of all the stats in the engine.
         # For use by test code only.
-        def metrics
-          with_stats_lock do
-            @stats_hash.keys.map { |spec| spec.to_s }
-          end
-        end
-
-        def metric_specs
-          with_stats_lock { @stats_hash.keys }
+        def to_h
+          with_stats_lock { Hash[@stats_hash] }
         end
       end
     end

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -9,7 +9,14 @@ module NewRelic
         ALL_TRANSACTIONS = "**ALL**".freeze
 
         def self.is_supported?
-          RUBY_VERSION >= "1.9.2"
+          RUBY_VERSION >= "1.9.2" && !is_resque?
+        end
+
+        # Because of Resque's forking, we don't poll thread backtraces for it.
+        # To accomplish that would require starting a new backtracing thread in
+        # each forked worker, and merging profiles across the pipe channel.
+        def self.is_resque?
+          NewRelic::Agent.config[:dispatcher] == :resque
         end
 
         attr_reader :worker_loop, :buffer, :effective_polling_period,
@@ -45,6 +52,11 @@ module NewRelic
         end
 
         def subscribe(transaction_name, command_arguments={})
+          if self.class.is_resque?
+            NewRelic::Agent.logger.info("Backtracing threads on Resque is not supported, so not subscribing transaction '#{transaction_name}'")
+            return
+          end
+
           if !self.class.is_supported?
             NewRelic::Agent.logger.debug("Backtracing not supported, so not subscribing transaction '#{transaction_name}'")
             return
@@ -104,10 +116,11 @@ module NewRelic
           start    = payload[:start_timestamp]
           duration = payload[:duration]
           thread   = payload[:thread] || Thread.current
+          bucket   = payload[:bucket]
           @lock.synchronize do
             backtraces = @buffer.delete(thread)
             if backtraces && @profiles.has_key?(name)
-              aggregate_backtraces(backtraces, name, start, duration, thread)
+              aggregate_backtraces(backtraces, name, start, duration, bucket, thread)
             end
           end
         end
@@ -115,11 +128,11 @@ module NewRelic
         # Internals
 
         # This method is expected to be called with @lock held.
-        def aggregate_backtraces(backtraces, name, start, duration, thread)
+        def aggregate_backtraces(backtraces, name, start, duration, bucket, thread)
           end_time = start + duration
           backtraces.each do |(timestamp, backtrace)|
             if timestamp >= start && timestamp < end_time
-              @profiles[name].aggregate(backtrace, :request, thread)
+              @profiles[name].aggregate(backtrace, bucket, thread)
             end
           end
         end
@@ -169,7 +182,7 @@ module NewRelic
 
         # This method is expected to be called with @lock held.
         def should_buffer?(bucket)
-          bucket == :request && @profiles.keys.any? { |k| k != ALL_TRANSACTIONS }
+          allowed_bucket?(bucket) && watching_for_transaction?
         end
 
         # This method is expected to be called with @lock held.
@@ -180,6 +193,16 @@ module NewRelic
           )
         end
 
+        # This method is expected to be called with @lock held
+        def watching_for_transaction?
+          @profiles.size > 1 ||
+          (@profiles.size == 1 && @profiles[ALL_TRANSACTIONS].nil?)
+        end
+
+        def allowed_bucket?(bucket)
+          bucket == :request || bucket == :background
+        end
+
         MAX_BUFFER_LENGTH = 500
 
         # This method is expected to be called with @lock held.

data/lib/new_relic/agent/transaction.rb

@@ -56,10 +56,6 @@ module NewRelic
       # as a Rack::Request or an ActionController::AbstractRequest.
       attr_accessor :request
 
-      # This is the name of the model currently assigned to database
-      # measurements, overriding the default.
-      attr_reader :database_metric_name
-
       attr_reader :guid,
                   :metrics,
                   :gc_start_snapshot,
@@ -302,6 +298,24 @@ module NewRelic
         @ignore_enduser = false
       end
 
+      # This transaction-local hash may be used as temprory storage by
+      # instrumentation that needs to pass data from one instrumentation point
+      # to another.
+      #
+      # For example, if both A and B are instrumented, and A calls B
+      # but some piece of state needed by the instrumentation at B is only
+      # available at A, the instrumentation at A may write into the hash, call
+      # through, and then remove the key afterwards, allowing the
+      # instrumentation at B to read the value in between.
+      #
+      # Keys should be symbols, and care should be taken to not generate key
+      # names dynamically, and to ensure that keys are removed upon return from
+      # the method that creates them.
+      #
+      def instrumentation_state
+        @instrumentation_state ||= {}
+      end
+
       def noticed_error_ids
         @noticed_error_ids ||= []
       end
@@ -534,6 +548,7 @@ module NewRelic
         duration = end_time.to_f - start_time.to_f
         payload = {
           :name             => @frozen_name,
+          :bucket           => recording_web_transaction? ? :request : :background,
           :start_timestamp  => start_time.to_f,
           :duration         => duration,
           :metrics          => @metrics,
@@ -613,9 +628,14 @@ module NewRelic
       APDEX_F = 'F'.freeze
 
       def append_apdex_perf_zone(duration, payload)
-        return unless recording_web_transaction?
+        if recording_web_transaction?
+          bucket = apdex_bucket(duration, apdex_t)
+        elsif background_apdex_t = transaction_specific_apdex_t
+          bucket = apdex_bucket(duration, background_apdex_t)
+        end
+
+        return unless bucket
 
-        bucket = apdex_bucket(duration)
         bucket_str = case bucket
         when :apdex_s then APDEX_S
         when :apdex_t then APDEX_T
@@ -708,32 +728,54 @@ module NewRelic
         end
       end
 
-      APDEX_METRIC = 'Apdex'.freeze
+      APDEX_ALL_METRIC   = 'ApdexAll'.freeze
+
+      APDEX_METRIC       = 'Apdex'.freeze
+      APDEX_OTHER_METRIC = 'ApdexOther'.freeze
+
+      APDEX_TXN_METRIC_PREFIX       = 'Apdex/'.freeze
+      APDEX_OTHER_TXN_METRIC_PREFIX = 'ApdexOther/Transaction/'.freeze
 
       def had_error?
-        !notable_exceptions.empty?
+        @exceptions.each do |exception, _|
+          return true unless NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
+        end
+        false
       end
 
-      def apdex_bucket(duration)
-        self.class.apdex_bucket(duration, had_error?, apdex_t)
+      def apdex_bucket(duration, current_apdex_t)
+        self.class.apdex_bucket(duration, had_error?, current_apdex_t)
       end
 
       def record_apdex(state, end_time=Time.now)
-        return unless recording_web_transaction? && state.is_execution_traced?
+        return unless state.is_execution_traced?
 
         freeze_name_and_execute_if_not_ignored do
-          action_duration = end_time - start_time
           total_duration  = end_time - apdex_start
+          action_duration = end_time - start_time
 
-          apdex_bucket_global = apdex_bucket(total_duration)
-          apdex_bucket_txn    = apdex_bucket(action_duration)
-
-          @metrics.record_unscoped(APDEX_METRIC, apdex_bucket_global, apdex_t)
-          txn_apdex_metric = @frozen_name.gsub(/^[^\/]+\//, 'Apdex/')
-          @metrics.record_unscoped(txn_apdex_metric, apdex_bucket_txn, apdex_t)
+          if recording_web_transaction?
+            record_apdex_metrics(APDEX_METRIC, APDEX_TXN_METRIC_PREFIX,
+                                 total_duration, action_duration, apdex_t)
+          else
+            record_apdex_metrics(APDEX_OTHER_METRIC, APDEX_OTHER_TXN_METRIC_PREFIX,
+                                 total_duration, action_duration, transaction_specific_apdex_t)
+          end
         end
       end
 
+      def record_apdex_metrics(rollup_metric, transaction_prefix, total_duration, action_duration, current_apdex_t)
+        return unless current_apdex_t
+
+        apdex_bucket_global = apdex_bucket(total_duration, current_apdex_t)
+        apdex_bucket_txn    = apdex_bucket(action_duration, current_apdex_t)
+
+        @metrics.record_unscoped(rollup_metric, apdex_bucket_global, current_apdex_t)
+        @metrics.record_unscoped(APDEX_ALL_METRIC, apdex_bucket_global, current_apdex_t)
+        txn_apdex_metric = @frozen_name.gsub(/^[^\/]+\//, transaction_prefix)
+        @metrics.record_unscoped(txn_apdex_metric, apdex_bucket_txn, current_apdex_t)
+      end
+
       def apdex_t
         transaction_specific_apdex_t || Agent.config[:apdex_t]
       end
@@ -743,15 +785,8 @@ module NewRelic
         Agent.config[key] && Agent.config[key][best_name]
       end
 
-      # Yield to a block that is run with a database metric name context.  This means
-      # the Database instrumentation will use this for the metric name if it does not
-      # otherwise know about a model.  This is re-entrant.
-      #
-      # * <tt>model</tt> is the DB model class
-      # * <tt>method</tt> is the name of the finder method or other method to identify the operation with.
-      #
       def with_database_metric_name(model, method)
-        previous = @database_metric_name
+        previous = self.instrumentation_state[:datastore_override]
         model_name = case model
                      when Class
                        model.name
@@ -760,10 +795,10 @@ module NewRelic
                      else
                        model.to_s
                      end
-        @database_metric_name = "ActiveRecord/#{model_name}/#{method}"
+        self.instrumentation_state[:datastore_override] = [method, model_name]
         yield
       ensure
-        @database_metric_name=previous
+        self.instrumentation_state[:datastore_override] = previous
       end
 
       def custom_parameters
@@ -839,12 +874,6 @@ module NewRelic
         @ignore_enduser
       end
 
-      def notable_exceptions
-        @exceptions.keys.select do |exception|
-          !NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
-        end
-      end
-
       private
 
       def process_cpu