newrelic_rpm 3.7.3.204 → 3.8.0.218

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

@@ -91,6 +91,7 @@ module NewRelic
 
         def record_queue_time(event)
           return unless event.queue_start
+          return unless NewRelic::Agent::Transaction.current.root?
           QueueTime.record_frontend_metrics(event.queue_start, event.time)
         end
 

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

@@ -16,12 +16,16 @@ DependencyDetection.defer do
   end
 
   executes do
+    class ActiveMerchant::Billing::Gateway
+      include NewRelic::Agent::MethodTracer
+    end
+
     ActiveMerchant::Billing::Gateway.implementations.each do |gateway|
       gateway.class_eval do
-        implemented_methods = public_instance_methods(false)
+        implemented_methods = public_instance_methods(false).map(&:to_sym)
         gateway_name = self.name.split('::').last
-        [:authorize, :purchase, :credit, :void, :capture, :recurring].each do |operation|
-          if implemented_methods.include?(operation.to_s)
+        [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
+          if implemented_methods.include?(operation)
             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

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

@@ -45,6 +45,7 @@ module NewRelic
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
+        # @api public
         module ClassMethods
           # Have NewRelic ignore actions in this controller.  Specify the actions as hash options
           # using :except and :only.  If no actions are specified, all actions are ignored.
@@ -385,7 +386,14 @@ module NewRelic
         def newrelic_response_code; end
 
         def newrelic_request_headers
-          self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
+          request = NewRelic::Agent::TransactionState.get.request
+          if request
+            if request.respond_to?(:headers)
+              request.headers
+            elsif request.respond_to?(:env)
+              request.env
+            end
+          end
         end
 
         # overrideable method to determine whether to trace an action
@@ -431,7 +439,7 @@ module NewRelic
           txn = Transaction.start(category, options)
           txn.name = TransactionNamer.new(self).name(options)
 
-          txn.apdex_start = _detect_upstream_wait(txn.start_time)
+          txn.apdex_start = _detect_upstream_wait(txn)
           _record_queue_length
 
           return txn
@@ -468,7 +476,9 @@ module NewRelic
         # Return a Time instance representing the upstream start time.
         # now is a Time instance to fall back on if no other candidate
         # for the start time is found.
-        def _detect_upstream_wait(now)
+        def _detect_upstream_wait(txn)
+          now = txn.start_time
+          return now unless txn.root?
           if newrelic_request_headers
             queue_start = QueueTime.parse_frontend_timestamp(newrelic_request_headers, now)
             QueueTime.record_frontend_metrics(queue_start, now) if queue_start

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -17,10 +17,13 @@ DependencyDetection.defer do
 
   executes do
     ActionView::PartialTemplate.class_eval do
+      include NewRelic::Agent::MethodTracer
       add_method_tracer :render, 'View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial'
     end
+
     # this is for template rendering, as opposed to partial rendering.
     ActionView::Template.class_eval do
+      include NewRelic::Agent::MethodTracer
       add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
     end
   end
@@ -41,9 +44,9 @@ DependencyDetection.defer do
 
   executes do
     ActionController::Base.class_eval do
+      include NewRelic::Agent::MethodTracer
       add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
     end
-
   end
 end
 
@@ -62,9 +65,12 @@ DependencyDetection.defer do
 
   executes do
     ActionView::RenderablePartial.module_eval do
+      include NewRelic::Agent::MethodTracer
       add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
     end
+
     ActionView::Template.class_eval do
+      include NewRelic::Agent::MethodTracer
       add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
     end
   end

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

@@ -17,7 +17,9 @@ DependencyDetection.defer do
     class NewRelic::SidekiqInstrumentation
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-      def call(worker, msg, queue)
+      # Client middleware has additional parameters, and our tests use the
+      # middleware client-side to work inline.
+      def call(worker, msg, queue, *_)
         perform_action_with_newrelic_trace(
           :name => 'perform',
           :class_name => msg['class'],

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

@@ -125,7 +125,7 @@ module NewRelic
         def route_eval_with_newrelic(*args, &block)
           begin
             txn_name = TransactionNamer.transaction_name_for_route(env, request)
-            ::NewRelic::Agent.set_transaction_name("#{self.class.name}/#{txn_name}") unless txn_name.nil?
+            ::NewRelic::Agent.set_transaction_name("#{self.class.name}/#{txn_name}", :category => :sinatra) unless txn_name.nil?
           rescue => e
             ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
           end
@@ -137,6 +137,8 @@ module NewRelic
           if ignore_request?
             env['newrelic.ignored'] = true
             return dispatch_without_newrelic
+          elsif NewRelic::Agent::Transaction.current
+            return dispatch_and_notice_errors_with_newrelic
           end
 
           name = TransactionNamer.initial_transaction_name(request)

data/lib/new_relic/agent/new_relic_service.rb

@@ -255,6 +255,14 @@ module NewRelic
         File.expand_path(File.join(control.newrelic_root, 'cert', 'cacert.pem'))
       end
 
+      def valid_to_marshal?(data)
+        @marshaller.dump(data)
+        true
+      rescue StandardError, SystemStackError => e
+        NewRelic::Agent.logger.warn("Unable to marshal environment report on connect.", e)
+        false
+      end
+
       private
 
       # A shorthand for NewRelic::Control.instance

data/lib/new_relic/agent/request_sampler.rb

@@ -140,10 +140,10 @@ class NewRelic::Agent::RequestSampler
   # scoped to just one transaction, so Datastore/all has what we want.
   map_metric('Datastore/all',         :total_call_time => "databaseDuration")
   map_metric('Datastore/all',         :call_count      => "databaseCallCount")
+  map_metric('GC/Transaction/all',    :total_call_time => "gcCumulative")
 
   # Web Metrics
   map_metric('WebFrontend/QueueTime', :total_call_time => "queueDuration")
-  map_metric("GC/cumulative",         :total_call_time => "gcCumulative")
   map_metric('Memcache/allWeb',       :total_call_time => "memcacheDuration")
 
   map_metric('External/allWeb',       :total_call_time => "externalDuration")

data/lib/new_relic/agent/sampler.rb

@@ -19,6 +19,14 @@ module NewRelic
       attr_reader :id
       @sampler_classes = []
 
+      def self.named(new_name)
+        @name = new_name
+      end
+
+      def self.name
+        @name
+      end
+
       def self.inherited(subclass)
         @sampler_classes << subclass
       end
@@ -28,12 +36,24 @@ module NewRelic
         true
       end
 
+      def self.enabled?
+        if @name
+          config_key = "disable_#{@name}_sampler"
+          !(Agent.config[config_key])
+        else
+          true
+        end
+      end
+
       def self.sampler_classes
         @sampler_classes
       end
 
-      def initialize(id)
-        @id = id
+      # The ID passed in here is unused by our code, but is preserved in case
+      # we have clients who are defining their own subclasses of this class, and
+      # expecting to be able to call super with an ID.
+      def initialize(id=nil)
+        @id = id || self.class.name
       end
 
       def poll

data/lib/new_relic/agent/sampler_collection.rb

@@ -25,6 +25,16 @@ module NewRelic
         self.any? { |s| s.class == sampler_class }
       end
 
+      # adds samplers to the sampler collection so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses NewRelic::Agent::Sampler
+      def load_samplers
+        Sampler.sampler_classes.each do |subclass|
+          add_sampler(subclass)
+        end
+      end
+
+
       def poll_samplers
         @samplers.delete_if do |sampler|
           begin
@@ -38,7 +48,9 @@ module NewRelic
       end
 
       def add_sampler(sampler_class)
-        if sampler_class.supported_on_this_platform?
+        supported = sampler_class.supported_on_this_platform?
+        enabled   = sampler_class.enabled?
+        if supported && enabled
           if !sampler_class_registered?(sampler_class)
             sampler = sampler_class.new
             sampler.setup_events(@event_listener) if sampler.respond_to?(:setup_events)

data/lib/new_relic/agent/samplers/cpu_sampler.rb

@@ -9,8 +9,10 @@ module NewRelic
     module Samplers
       class CpuSampler < NewRelic::Agent::Sampler
         attr_reader :last_time
+
+        named :cpu
+
         def initialize
-          super :cpu
           @processor_count = NewRelic::Agent::SystemInfo.processor_count
           if @processor_count.nil?
             NewRelic::Agent.logger.warn("Failed to determine processor count, assuming 1")

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -16,8 +16,9 @@ module NewRelic
       # versions of DJ where distinct queues are supported, it breaks it out by queue name.
       #
       class DelayedJobSampler < NewRelic::Agent::Sampler
+        named :delayed_job
+
         def initialize
-          super :delayed_job_queue
           raise Unsupported, "DJ instrumentation disabled" if Agent.config[:disable_dj]
           raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
         end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -9,10 +9,11 @@ module NewRelic
     module Samplers
 
       class MemorySampler < NewRelic::Agent::Sampler
+        named :memory
+
         attr_accessor :sampler
 
         def initialize
-          super :memory
           # macos, linux, solaris
           if defined? JRuby
             @sampler = JavaHeapSampler.new

data/lib/new_relic/agent/samplers/object_sampler.rb

@@ -8,9 +8,7 @@ module NewRelic
   module Agent
     module Samplers
       class ObjectSampler < NewRelic::Agent::Sampler
-        def initialize
-          super :objects
-        end
+        named :object
 
         def self.supported_on_this_platform?
           NewRelic::LanguageSupport.object_space_usable? && ObjectSpace.respond_to?(:live_objects)

data/lib/new_relic/agent/samplers/vm_sampler.rb

@@ -0,0 +1,126 @@
+# 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.
+
+require 'new_relic/agent/sampler'
+require 'new_relic/agent/vm'
+
+module NewRelic
+  module Agent
+    module Samplers
+      class VMSampler < Sampler
+        GC_RUNS_METRIC                = 'RubyVM/GC/runs'.freeze
+        HEAP_LIVE_METRIC              = 'RubyVM/GC/heap_live'.freeze
+        HEAP_FREE_METRIC              = 'RubyVM/GC/heap_free'.freeze
+        THREAD_COUNT_METRIC           = 'RubyVM/Threads/all'.freeze
+        OBJECT_ALLOCATIONS_METRIC     = 'RubyVM/GC/total_allocated_object'.freeze
+        MAJOR_GC_METRIC               = 'RubyVM/GC/major_gc_count'.freeze
+        MINOR_GC_METRIC               = 'RubyVM/GC/minor_gc_count'.freeze
+        METHOD_INVALIDATIONS_METRIC   = 'RubyVM/CacheInvalidations/method'.freeze
+        CONSTANT_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/constant'.freeze
+
+        attr_reader :transaction_count
+
+        named :vm
+
+        def initialize
+          @lock = Mutex.new
+          @transaction_count = 0
+          @last_snapshot = take_snapshot
+        end
+
+        def take_snapshot
+          NewRelic::Agent::VM.snapshot
+        end
+
+        def setup_events(event_listener)
+          event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
+        end
+
+        def on_transaction_finished(*_)
+          @lock.synchronize { @transaction_count += 1 }
+        end
+
+        def reset_transaction_count
+          @lock.synchronize do
+            old_count = @transaction_count
+            @transaction_count = 0
+            old_count
+          end
+        end
+
+        def record_gc_runs_metric(snapshot, txn_count)
+          if snapshot.gc_total_time || snapshot.gc_runs
+            if snapshot.gc_total_time
+              gc_time = snapshot.gc_total_time - @last_snapshot.gc_total_time.to_f
+            end
+            if snapshot.gc_runs
+              gc_runs = snapshot.gc_runs - @last_snapshot.gc_runs
+            end
+            wall_clock_time = snapshot.taken_at - @last_snapshot.taken_at
+            NewRelic::Agent.agent.stats_engine.record_metrics(GC_RUNS_METRIC) do |stats|
+              stats.call_count           += txn_count
+              stats.total_call_time      += gc_runs if gc_runs
+              stats.total_exclusive_time += gc_time if gc_time
+              stats.max_call_time         = (gc_time.nil? ? 0 : 1)
+              stats.sum_of_squares       += wall_clock_time
+            end
+          end
+        end
+
+        def record_delta(snapshot, key, metric, txn_count)
+          value = snapshot.send(key)
+          if value
+            delta = value - @last_snapshot.send(key)
+            NewRelic::Agent.agent.stats_engine.record_metrics(metric) do |stats|
+              stats.call_count      += txn_count
+              stats.total_call_time += delta
+            end
+          end
+        end
+
+        def record_gauge_metric(metric_name, value)
+          NewRelic::Agent.agent.stats_engine.record_metrics(metric_name) do |stats|
+            stats.call_count      = value
+            stats.sum_of_squares  = 1
+          end
+        end
+
+        def record_heap_live_metric(snapshot)
+          if snapshot.heap_live
+            record_gauge_metric(HEAP_LIVE_METRIC, snapshot.heap_live)
+          end
+        end
+
+        def record_heap_free_metric(snapshot)
+          if snapshot.heap_free
+            record_gauge_metric(HEAP_FREE_METRIC, snapshot.heap_free)
+          end
+        end
+
+        def record_thread_count_metric(snapshot)
+          if snapshot.thread_count
+            record_gauge_metric(THREAD_COUNT_METRIC, snapshot.thread_count)
+          end
+        end
+
+        def poll
+          snap = take_snapshot
+          tcount = reset_transaction_count
+
+          record_gc_runs_metric(snap, tcount)
+          record_delta(snap, :total_allocated_object, OBJECT_ALLOCATIONS_METRIC, tcount)
+          record_delta(snap, :major_gc_count, MAJOR_GC_METRIC, tcount)
+          record_delta(snap, :minor_gc_count, MINOR_GC_METRIC, tcount)
+          record_delta(snap, :method_cache_invalidations, METHOD_INVALIDATIONS_METRIC, tcount)
+          record_delta(snap, :constant_cache_invalidations, CONSTANT_INVALIDATIONS_METRIC, tcount)
+          record_heap_live_metric(snap)
+          record_heap_free_metric(snap)
+          record_thread_count_metric(snap)
+
+          @last_snapshot = snap
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/stats.rb

@@ -76,21 +76,6 @@ module NewRelic
 
       alias trace_call record_data_point
 
-      # Records multiple data points as one method call - this handles
-      # all the aggregation that would be done with multiple
-      # record_data_point calls
-      def record_multiple_data_points(total_value, count=1)
-        return record_data_point(total_value) if count == 1
-        @call_count += count
-        @total_call_time += total_value
-        avg_val = total_value / count
-        @min_call_time = avg_val if avg_val < @min_call_time || @call_count == count
-        @max_call_time = avg_val if avg_val > @max_call_time
-        @total_exclusive_time += total_value
-        @sum_of_squares += (avg_val * avg_val) * count
-        self
-      end
-
       # increments the call_count by one
       def increment_count(value = 1)
         @call_count += value

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

@@ -7,68 +7,83 @@ module NewRelic
   module Agent
     class StatsEngine
       module GCProfiler
+        GCSnapshot = Struct.new(:gc_time_s, :gc_call_count)
+
         def self.init
-          @profiler = RailsBenchProfiler.new if RailsBenchProfiler.enabled?
-          @profiler = CoreGCProfiler.new if CoreGCProfiler.enabled?
-          @profiler = LegacyRubiniusProfiler.new if LegacyRubiniusProfiler.enabled?
+          return @profiler if @initialized
+          @profiler = if RailsBenchProfiler.enabled?
+            RailsBenchProfiler.new
+          elsif CoreGCProfiler.enabled?
+            CoreGCProfiler.new
+          end
+          @initialized = true
           @profiler
         end
 
-        def self.capture
-          @profiler.capture if @profiler
+        def self.reset
+          @profiler    = nil
+          @initialized = nil
         end
 
-        class Profiler
-          def initialize
-            if self.class.enabled?
-              @last_timestamp = call_time
-              @last_count = call_count
-            end
+        def self.take_snapshot
+          init
+          if @profiler
+            GCSnapshot.new(@profiler.call_time_s, @profiler.call_count)
+          else
+            nil
           end
+        end
 
-          def capture
-            return unless self.class.enabled?
-            return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
+        def self.record_delta(start_snapshot, end_snapshot)
+          if @profiler && start_snapshot && end_snapshot
+            elapsed_gc_time_s = end_snapshot.gc_time_s - start_snapshot.gc_time_s
+            num_calls         = end_snapshot.gc_call_count - start_snapshot.gc_call_count
+            record_gc_metric(num_calls, elapsed_gc_time_s)
 
-            num_calls = call_count - @last_count
-            # microseconds to seconds
-            elapsed = (call_time - @last_timestamp).to_f / 1_000_000.0
-            @last_timestamp = call_time
-            @last_count = call_count
-            reset
+            @profiler.reset
+            elapsed_gc_time_s
+          end
+        end
 
-            record_gc_metric(num_calls, elapsed)
-            elapsed
+        def self.record_gc_metric(call_count, elapsed)
+          NewRelic::Agent.agent.stats_engine.record_metrics(gc_metric_specs) do |stats|
+            stats.call_count           += call_count
+            stats.total_call_time      += elapsed
+            stats.total_exclusive_time += elapsed
           end
+        end
 
-          def reset; end
+        GC_ROLLUP = 'GC/Transaction/all'.freeze
+        GC_OTHER  = 'GC/Transaction/allOther'.freeze
+        GC_WEB    = 'GC/Transaction/allWeb'.freeze
 
-          protected
-
-          def record_gc_metric(num_calls, elapsed)
-            if num_calls > 0
-              # GC stats are collected into a blamed metric which allows
-              # us to show the stats controller by controller
-              NewRelic::Agent.instance.stats_engine \
-                .record_metrics('GC/cumulative', nil, :scoped => true) do |stat|
-                stat.record_multiple_data_points(elapsed, num_calls)
-              end
-            end
-          end
+        SCOPE_PLACEHOLDER = NewRelic::Agent::StatsEngine::MetricStats::SCOPE_PLACEHOLDER
+
+        GC_ROLLUP_SPEC       = NewRelic::MetricSpec.new(GC_ROLLUP)
+        GC_OTHER_SPEC        = NewRelic::MetricSpec.new(GC_OTHER)
+        GC_OTHER_SCOPED_SPEC = NewRelic::MetricSpec.new(GC_OTHER, SCOPE_PLACEHOLDER)
+        GC_WEB_SPEC          = NewRelic::MetricSpec.new(GC_WEB)
+        GC_WEB_SCOPED_SPEC   = NewRelic::MetricSpec.new(GC_WEB, SCOPE_PLACEHOLDER)
 
-          def scope_stack
-            NewRelic::Agent::TransactionState.get.stats_scope_stack
+        def self.gc_metric_specs
+          # The .dup call on the scoped MetricSpec here is necessary because
+          # metric specs with non-empty scopes will have their scopes mutated
+          # when the metrics are merged into the global stats hash, and we don't
+          # want to mutate the original MetricSpec.
+          if NewRelic::Agent::Transaction.recording_web_transaction?
+            [GC_ROLLUP_SPEC, GC_WEB_SPEC, GC_WEB_SCOPED_SPEC.dup]
+          else
+            [GC_ROLLUP_SPEC, GC_OTHER_SPEC, GC_OTHER_SCOPED_SPEC.dup]
           end
         end
 
-        class RailsBenchProfiler < Profiler
+        class RailsBenchProfiler
           def self.enabled?
             ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
           end
 
-          # microseconds spent in GC
-          def call_time
-            ::GC.time # this should already be microseconds
+          def call_time_s
+            ::GC.time.to_f / 1_000_000 # this value is reported in us, so convert to s
           end
 
           def call_count
@@ -80,49 +95,25 @@ module NewRelic
           end
         end
 
-        class CoreGCProfiler < Profiler
+        class CoreGCProfiler
           def self.enabled?
-            !NewRelic::LanguageSupport.using_engine?('jruby') &&
-              defined?(::GC::Profiler) && ::GC::Profiler.enabled?
+            NewRelic::LanguageSupport.gc_profiler_enabled?
           end
 
-          # microseconds spent in GC
-          # 1.9 total_time returns seconds.  Don't trust the docs.  It's seconds.
-          def call_time
-            ::GC::Profiler.total_time * 1_000_000.0 # convert seconds to microseconds
+          def call_time_s
+            NewRelic::Agent.instance.monotonic_gc_profiler.total_time_s
           end
 
           def call_count
             ::GC.count
           end
 
-          def reset
-            ::GC::Profiler.clear
-            @last_timestamp = 0
-          end
-        end
-
-        # Only present for legacy support of Rubinius < 2.0.0
-        class LegacyRubiniusProfiler < Profiler
-          def self.enabled?
-            self.has_rubinius_profiler? && !has_core_profiler?
-          end
-
-          def self.has_rubinius_profiler?
-            defined?(::Rubinius) && defined?(::Rubinius::GC) && ::Rubinius::GC.respond_to?(:count)
-          end
-
-          def self.has_core_profiler?
-            defined?(::GC::Profiler)
-          end
-
-          def call_time
-            ::Rubinius::GC.time * 1000
-          end
-
-          def call_count
-            ::Rubinius::GC.count
-          end
+          # When using GC::Profiler, it's important to periodically call
+          # GC::Profiler.clear in order to avoid unbounded growth in the number
+          # of GC recordds that are stored. However, we actually do this
+          # internally within MonotonicGCProfiler on calls to #total_time_s,
+          # so the reset here is a no-op.
+          def reset; end
         end
       end
     end