wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/stats_engine.rb

@@ -16,11 +16,6 @@ module NewRelic
         Thread::current[:newrelic_scope_stack] = nil
         start_sampler_thread
       end
-
-      def log
-        NewRelic::Control.instance.log
-      end
-
     end
   end
 end

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

@@ -7,12 +7,13 @@ module NewRelic
           @profiler = RailsBench.new if RailsBench.enabled?
           @profiler = Ruby19.new if Ruby19.enabled?
           @profiler = Rubinius.new if Rubinius.enabled?
+          @profiler = RubiniusAgent.new if RubiniusAgent.enabled?
         end
 
         def self.capture
           @profiler.capture if @profiler
         end
-        
+
         class Profiler
           def initialize
             if self.class.enabled?
@@ -20,75 +21,76 @@ module NewRelic
               @last_count = call_count
             end
           end
-          
+
           def capture
             return unless self.class.enabled?
             return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
-            
+
             num_calls = call_count - @last_count
-            elapsed = (call_time - @last_timestamp).to_f
+            # microseconds to seconds
+            elapsed = (call_time - @last_timestamp).to_f / 1_000_000.0
             @last_timestamp = call_time
             @last_count = call_count
             reset
-            
+
             record_gc_metric(num_calls, elapsed)
+            elapsed
           end
 
           def reset; end
-          
+
           protected
-                    
+
           def record_gc_metric(num_calls, elapsed)
             if num_calls > 0
-              # microseconds to seconds
-              elapsed = elapsed / 1_000_000.0
-              # Allocate the GC time to a scope as if the GC just ended
-              # right now.
-              time = Time.now.to_f
-              gc_scope = NewRelic::Agent.instance.stats_engine.push_scope("GC/cumulative", time - elapsed)
               # GC stats are collected into a blamed metric which allows
               # us to show the stats controller by controller
-              gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
+              gc_stats = NewRelic::Agent.instance.stats_engine \
+                .get_stats('GC/cumulative', true, false,
+                           NewRelic::Agent::TransactionInfo.get.transaction_name)
               gc_stats.record_multiple_data_points(elapsed, num_calls)
-              NewRelic::Agent.instance.stats_engine.pop_scope(gc_scope, elapsed, time)
             end
           end
 
           def scope_stack
             Thread::current[:newrelic_scope_stack] ||= []
-          end        
+          end
         end
-        
+
         class RailsBench < Profiler
           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
           end
-          
+
           def call_count
             ::GC.collections
           end
+
+          def reset
+            ::GC.clear_stats
+          end
         end
-        
+
         class Ruby19 < Profiler
           def self.enabled?
             defined?(::GC::Profiler) && ::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
           end
-          
+
           def call_count
             ::GC.count
           end
-          
+
           def reset
             ::GC::Profiler.clear
             @last_timestamp = 0
@@ -96,6 +98,20 @@ module NewRelic
         end
 
         class Rubinius < Profiler
+          def self.enabled?
+            defined?(::Rubinius) && defined?(::Rubinius::GC) && ::Rubinius::GC.respond_to?(:count)
+          end
+
+          def call_time
+            ::Rubinius::GC.time * 1000
+          end
+
+          def call_count
+            ::Rubinius::GC.count
+          end
+        end
+
+        class RubiniusAgent < Profiler
           def self.enabled?
             if NewRelic::LanguageSupport.using_engine?('rbx')
               require 'rubinius/agent'
@@ -115,7 +131,7 @@ module NewRelic
             agent = ::Rubinius::Agent.loopback
             agent.get('system.gc.young.count')[1] +
               agent.get('system.gc.full.count')[1]
-          end          
+          end
         end
       end
     end

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

@@ -8,34 +8,82 @@ module NewRelic
         # A simple mutex-synchronized hash to make sure our statistics
         # are internally consistent even in truly-threaded rubies like JRuby
         class SynchronizedHash < ::Hash
-          include NewRelic::LanguageSupport::SynchronizedHash
-          
+          attr_reader :lock
+
           def initialize
             @lock = Mutex.new
           end
-          
+
+          def initialize_copy(old)
+            super
+            old.each do |key, value|
+              self.store(key, value.dup)
+            end
+          end
+
           def []=(*args)
             @lock.synchronize { super }
+          rescue => e
+            log_error(e)
           end
 
           def clear(*args)
             @lock.synchronize { super }
+          rescue => e
+            log_error(e)
           end
 
           def delete(*args)
             @lock.synchronize { super }
+          rescue => e
+            log_error(e)
           end
 
           def delete_if(*args)
             @lock.synchronize { super }
+          rescue => e
+            log_error(e)
+          end
+
+          def reset
+            values.each { |s| s.reset }
+          end
+
+          def log_error(e)
+            backtraces = Thread.list.map { |t| log_thread(t) }.join("\n\n")
+            ::NewRelic::Agent.logger.warn(
+              "SynchronizedHash failure: #{e.class.name}: #{e.message}\n#{backtraces}")
+          end
+
+          def log_thread(t)
+            # Ruby 1.8 doesn't expose backtrace properly, so make sure it's there
+            if t.nil? || !t.respond_to?(:backtrace) || t.backtrace.nil?
+              return "#{t}\n\tNo backtrace for thread" 
+            end
+
+            backtrace = t.backtrace.map { |b| "\t#{b}" }.join("\n")
+            "\t#{t}\n#{backtrace}"
+
+          rescue Exception => e
+            # JRuby 1.7.0 has a nasty habit of raising a
+            # java.lang.NullPointerException when we iterate through threads
+            # asking for backtraces.  This line allows us to swallow java
+            # exceptions without referencing their classes (since they don't
+            # exist in MRI).  It also prevents us from swallowing signals or
+            # other nasty things that can happen when you rescue Exception.
+            ::NewRelic::Agent.logger.warn(
+              "Error collecting thread backtraces: #{e.class.name}: #{e.message}")
+            ::NewRelic::Agent.logger.debug( e.backtrace.join("\n") )
+
+            raise e if e.class.ancestors.include? Exception
           end
         end
-        
+
         # Returns all of the metric names of all the stats in the engine
         def metrics
           stats_hash.keys.map(&:to_s)
         end
-        
+
         # a simple accessor for looking up a stat with no scope -
         # returns a new stats object if no stats object for that
         # metric exists yet
@@ -64,17 +112,43 @@ module NewRelic
           end
           stats
         end
-        
+
         # Returns a stat if one exists, otherwise returns nil. If you
         # want auto-initialization, use one of get_stats or get_stats_no_scope
         def lookup_stats(metric_name, scope_name = '')
           stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)]
         end
-        
+
+
+        # Helper method for timing supportability metrics
+        def record_supportability_metrics_timed(metrics)
+          start_time = Time.now
+          yield
+          end_time = Time.now
+          duration = (end_time - start_time).to_f
+        ensure
+          record_supportability_metrics(duration, metrics) do |value, metric|
+            metric.record_data_point(value)
+          end
+        end
+
+        # Helper for recording a straight value into the count
+        def record_supportability_metrics_count(value, *metrics)
+          record_supportability_metrics(value, *metrics) do |value, metric|
+            metric.call_count = value
+          end
+        end
+
+        # Helper method for recording supportability metrics consistently
+        def record_supportability_metrics(value, *metrics)
+          metrics.each do |metric|
+              yield(value, get_stats_no_scope("Supportability/#{metric}"))
+          end
+        end
+
         # This module was extracted from the harvest method and should
         # be refactored
         module Harvest
-          
           # merge data from previous harvests into this stats engine -
           # takes into account the case where there are new stats for
           # that metric, and the case where there is no current data
@@ -135,10 +209,12 @@ module NewRelic
 
           def merge_stats(other_engine_or_hash, metric_ids)
             old_data = get_stats_hash_from(other_engine_or_hash)
-
             timeslice_data = {}
-            stats_hash.each do | metric_spec, stats |
-
+            stats_hash.lock.synchronize do
+              Thread.current['newrelic_stats_hash'] = stats_hash.clone
+              stats_hash.reset
+            end
+            Thread.current['newrelic_stats_hash'].each do |metric_spec, stats|
               metric_spec = coerce_to_metric_spec(metric_spec)
               stats_copy = clone_and_reset_stats(metric_spec, stats)
               merge_old_data!(metric_spec, stats_copy, old_data)
@@ -160,7 +236,6 @@ module NewRelic
         # sacrificing efficiency.
         # +++
         def harvest_timeslice_data(previous_timeslice_data, metric_ids)
-
           poll harvest_samplers
           merge_stats(previous_timeslice_data, metric_ids)
         end
@@ -173,9 +248,9 @@ module NewRelic
 
         # Reset each of the stats, such as when a new passenger instance starts up.
         def reset_stats
-          stats_hash.values.each { |s| s.reset }
+          stats_hash.reset
         end
-        
+
         # returns a memoized SynchronizedHash that holds the actual
         # instances of Stats keyed off their MetricName
         def stats_hash

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

@@ -27,15 +27,19 @@ module Agent
         # start up a thread that will periodically poll for metric samples
         return if periodic_samplers.empty?
 
-        @sampler_thread = Thread.new do
-          while true do
+        @sampler_thread = NewRelic::Agent::AgentThread.new('Sampler Tasks') do
+          loop do
+            now = Time.now
             begin
               sleep POLL_PERIOD
               poll periodic_samplers
+            ensure
+              NewRelic::Agent.instance.stats_engine \
+                .get_stats_no_scope('Supportability/Samplers') \
+                .record_data_point((Time.now - now).to_f)
             end
           end
         end
-        @sampler_thread['newrelic_label'] = 'Sampler Tasks'
       end
 
       private
@@ -47,7 +51,7 @@ module Agent
       end
 
       def log_added_sampler(type, sampler)
-        log.debug "Adding #{type} sampler: #{sampler.inspect}"
+        ::NewRelic::Agent.logger.debug "Adding #{type} sampler: #{sampler.id}"
       end
 
       public
@@ -75,9 +79,7 @@ module Agent
             sampled_item.poll
             false # it's okay.  don't delete it.
           rescue => e
-            log.error "Removing #{sampled_item} from list"
-            log.error e
-            log.debug e.backtrace.to_s
+            ::NewRelic::Agent.logger.warn "Removing #{sampled_item} from list", e
             true # remove the sampler
           end
         end

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

@@ -13,11 +13,11 @@ module Agent
         @children_time = 0
       end
     end
-    
+
     # Handles pushing and popping elements onto an internal stack that
     # tracks where time should be allocated in Transaction Traces
     module Transactions
-      
+
       # Defines methods that stub out the stats engine methods
       # when the agent is disabled
       module Shim # :nodoc:
@@ -29,34 +29,32 @@ module Agent
         def scope_name; end
         def pop_scope(*args); end
       end
-      
+
       # add a new transaction sampler, unless we're currently in a
       # transaction (then we fail)
       def transaction_sampler= sampler
         fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
         @transaction_sampler = sampler
       end
-      
+
       # removes a transaction sampler
       def remove_transaction_sampler(l)
         @transaction_sampler = nil
       end
-      
+
       # Pushes a scope onto the transaction stack - this generates a
       # TransactionSample::Segment at the end of transaction execution
       def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
         stack = scope_stack
-        stack.empty? ? GCProfiler.init : GCProfiler.capture
-        @transaction_sampler.notice_push_scope metric, time if @transaction_sampler
+        @transaction_sampler.notice_push_scope metric, time if sampler_enabled?
         scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
         stack.push scope
         scope
       end
-      
+
       # Pops a scope off the transaction stack - this updates the
       # transaction sampler that we've finished execution of a traced method
       def pop_scope(expected_scope, duration, time=Time.now.to_f)
-        GCProfiler.capture
         stack = scope_stack
         scope = stack.pop
         fail "unbalanced pop from blame stack, got #{scope ? scope.name : 'nil'}, expected #{expected_scope ? expected_scope.name : 'nil'}" if scope != expected_scope
@@ -68,10 +66,14 @@ module Agent
             stack.last.children_time += scope.children_time
           end
         end
-        @transaction_sampler.notice_pop_scope(scope.name, time) if @transaction_sampler
+        @transaction_sampler.notice_pop_scope(scope.name, time) if sampler_enabled?
         scope
       end
       
+      def sampler_enabled?
+        @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
+      end
+      
       # Returns the latest ScopeStackElement
       def peek_scope
         scope_stack.last
@@ -88,7 +90,7 @@ module Agent
       def scope_name=(transaction)
         Thread::current[:newrelic_scope_name] = transaction
       end
-      
+
       # Returns the current scope name from the thread local
       def scope_name
         Thread::current[:newrelic_scope_name]
@@ -98,6 +100,7 @@ module Agent
       def start_transaction(name = nil)
         Thread::current[:newrelic_scope_stack] ||= []
         self.scope_name = name if name
+        GCProfiler.init
       end
 
       # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
@@ -105,6 +108,11 @@ module Agent
       # and is ignored.
       #
       def end_transaction
+        elapsed = GCProfiler.capture
+        if @transaction_sampler && @transaction_sampler.last_sample
+          @transaction_sampler.last_sample.params[:custom_params] ||= {}
+          @transaction_sampler.last_sample.params[:custom_params][:gc_time] = elapsed
+        end
         stack = scope_stack
 
         if stack && stack.empty?
@@ -114,7 +122,7 @@ module Agent
       end
 
       private
-      
+
       # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []