newrelic_rpm 2.9.9 → 2.10.3

data/lib/new_relic/agent/sampler.rb

@@ -1,6 +1,39 @@
+# A Sampler is used to capture meaningful metrics in a background thread 
+# periodically.  They will either be invoked once a minute just before the
+# data is sent to the agent (default) or every 10 seconds, when #use_harvest_sampler?
+# returns false.
+#
+# Samplers can be added to New Relic by subclassing NewRelic::Agent::Sampler.
+# Instances are created when the agent is enabled and installed.  Subclasses
+# are registered for instantiation automatically.
 class NewRelic::Agent::Sampler
+  
+  # Exception denotes a sampler is not available and it will not be registered.
+  class Unsupported < StandardError;  end
+  
   attr_accessor :stats_engine
   attr_reader :id
+  @sampler_classes = []
+  
+  def self.inherited(subclass)
+    @sampler_classes << subclass
+  end
+  
+  # Override with check.  Called before instantiating.
+  def self.supported_on_this_platform?
+    true
+  end
+  
+  # Override to use the periodic sampler instead of running the sampler on the
+  # minute during harvests.
+  def self.use_harvest_sampler?
+    true
+  end
+  
+  def self.sampler_classes
+    @sampler_classes
+  end
+  
   def initialize(id)
     @id = id
   end
@@ -9,4 +42,5 @@ class NewRelic::Agent::Sampler
     raise "Implement in the subclass"
   end
   
+  
 end

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

@@ -1,10 +1,13 @@
-module NewRelic::Agent::Samplers
+module NewRelic
+  module Agent
+    module Samplers
   class CpuSampler < NewRelic::Agent::Sampler
     attr_reader :last_time
     def initialize
       super :cpu
       poll
     end
+    
     def user_util_stats
       stats_engine.get_stats_no_scope("CPU/User/Utilization")
     end
@@ -17,6 +20,11 @@ module NewRelic::Agent::Samplers
     def systemtime_stats
       stats_engine.get_stats_no_scope("CPU/System Time")
     end
+    
+    def self.supported_on_this_platform?
+      not defined?(JRuby)
+    end
+    
     def poll
       now = Time.now
       t = Process.times
@@ -41,4 +49,6 @@ module NewRelic::Agent::Samplers
     end
   end
 end
+end
+end
 

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

@@ -0,0 +1,37 @@
+module NewRelic
+  module Agent
+    module Samplers
+  class DelayedJobLockSampler < NewRelic::Agent::Sampler
+    def initialize
+      super :delayed_job_lock
+      raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj'] 
+      raise Unsupported, "No DJ worker present" if NewRelic::DelayedJobInjection.worker_name
+    end
+    
+    def stats
+      stats_engine.get_stats("Custom/DJ Locked Jobs", false)
+    end
+    
+    def local_env
+      NewRelic::Control.instance.local_env
+    end
+    
+    def worker_name
+      local_env.dispatcher_instance_id
+    end
+    
+    def locked_jobs
+      Delayed::Job.count(:conditions => {:locked_by => NewRelic::DelayedJobInjection.worker_name})
+    end
+    
+    def self.supported_on_this_platform?
+      defined?(Delayed::Job)
+    end
+    
+    def poll
+      stats.record_data_point locked_jobs
+    end
+  end
+end
+end
+end

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

@@ -1,21 +1,22 @@
-module NewRelic::Agent::Samplers
+module NewRelic
+  module Agent
+module Samplers
   
   class MemorySampler < NewRelic::Agent::Sampler
     attr_accessor :sampler
     
     def initialize
       super :memory
-      
       # macos, linux, solaris
-      if defined? Java
+      if defined? JRuby
         @sampler = JavaHeapSampler.new
       elsif platform =~ /linux/
         @sampler = ProcStatus.new
         if !@sampler.can_run?
-          NewRelic::Agent.instance.log.warn "Error attempting to use /proc/$$/status file for reading memory. Using ps command instead."
+          NewRelic::Agent.instance.warn.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
           @sampler = ShellPS.new("ps -o rsz")
         else
-          NewRelic::Agent.instance.log.info "Using /proc/$$/status for reading process memory."
+          NewRelic::Agent.instance.log.debug "Using /proc/#{$$}/status for reading process memory."
         end
       elsif platform =~ /darwin9/ # 10.5
         @sampler = ShellPS.new("ps -o rsz")
@@ -27,17 +28,25 @@ module NewRelic::Agent::Samplers
         @sampler = ShellPS.new("/usr/bin/ps -o rss -p")
       end
       
-      raise "Unsupported platform for getting memory: #{platform}" if @sampler.nil?
-      raise "Unable to run #{@sampler}" unless @sampler.can_run?
+      raise Unsupported, "Unsupported platform for getting memory: #{platform}" if @sampler.nil?
+      raise Unsupported, "Unable to run #{@sampler}" unless @sampler.can_run?
     end
-    def platform
+    
+    def self.supported_on_this_platform?
+      defined?(JRuby) or platform =~ /linux|darwin9|darwin10|freebsd|solaris/
+    end
+
+    def self.platform
       if RUBY_PLATFORM =~ /java/
         %x[uname -s].downcase
       else
         RUBY_PLATFORM.downcase
       end
     end
-    
+    def platform
+      NewRelic::Agent::Samplers::MemorySampler.platform
+    end
+
     def stats
       stats_engine.get_stats("Memory/Physical", false) 
     end
@@ -66,6 +75,7 @@ module NewRelic::Agent::Samplers
           NewRelic::Agent.instance.log.debug e.backtrace.join("\n  ")
           NewRelic::Agent.instance.log.error "Disabling memory sampler."
           @broken = true
+          return nil
         end
       end
     end
@@ -73,7 +83,7 @@ module NewRelic::Agent::Samplers
     class JavaHeapSampler < Base
 
       def get_memory
-        raise "Can't sample Java heap unless running in JRuby" unless defined? Java
+        raise "Can't sample Java heap unless running in JRuby" unless defined? JRuby
         java.lang.Runtime.getRuntime.totalMemory / (1024 * 1024).to_f rescue nil
       end
       def to_s
@@ -128,3 +138,5 @@ module NewRelic::Agent::Samplers
     end
   end    
 end  
+end
+end

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

@@ -0,0 +1,24 @@
+module NewRelic
+  module Agent
+    module Samplers
+      class ObjectSampler < NewRelic::Agent::Sampler
+
+        def initialize
+          super :objects
+        end
+
+        def stats
+          stats_engine.get_stats_no_scope("GC/objects")          
+        end
+
+        def self.supported_on_this_platform?
+          defined?(ObjectSpace) && ObjectSpace.respond_to?(:live_objects)
+        end
+
+        def poll
+          stats.record_data_point(ObjectSpace.live_objects)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/shim_agent.rb

@@ -5,7 +5,17 @@ class NewRelic::Agent::ShimAgent < NewRelic::Agent::Agent
   def self.instance
     @instance ||= self.new
   end  
+  def initialize
+    super
+    @histogram.extend NewRelic::Histogram::Shim
+    @stats_engine.extend NewRelic::Agent::StatsEngine::Shim
+    @stats_engine.extend NewRelic::Agent::StatsEngine::Transactions::Shim
+    @transaction_sampler.extend NewRelic::Agent::TransactionSampler::Shim
+    @error_collector.extend NewRelic::Agent::ErrorCollector::Shim
+  end
   def ensure_worker_thread_started; end
   def start *args; end
   def shutdown; end
+  def push_trace_execution_flag(*args); end
+  def pop_trace_execution_flag(*args); end
 end

data/lib/new_relic/agent/stats_engine.rb

@@ -1,286 +1,24 @@
+require 'new_relic/agent/stats_engine/metric_stats'
+require 'new_relic/agent/stats_engine/samplers'
+require 'new_relic/agent/stats_engine/transactions'
 
-module NewRelic::Agent
-  class StatsEngine
-    POLL_PERIOD = 10
-    
-    ScopeStackElement = Struct.new(:name, :children_time, :deduct_call_time_from_parent)
-    
-    def initialize
-      @stats_hash = {}
-      @harvest_samplers = []
-      @periodic_samplers = []
-      @scope_stack_listener = nil
-      
-      # Makes the unit tests happy
-      Thread::current[:newrelic_scope_stack] = nil
-      
-      spawn_sampler_thread
-    end
-
-    def log
-      NewRelic::Control.instance.log
-    end
-    
-    def spawn_sampler_thread
-      
-      return if !@sampler_process.nil? && @sampler_process == $$ 
-      
-      # start up a thread that will periodically poll for metric samples
-      @sampler_thread = Thread.new do
-        while true do
-          begin
-            sleep POLL_PERIOD
-            poll @periodic_samplers
-          end
-        end
-      end
-      @sampler_thread['newrelic_label'] = 'Sampler Tasks'
-      @sampler_process = $$
-    end
-    
-    def add_scope_stack_listener(l)
-      fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
-      @scope_stack_listener =  l
-    end
-    
-    def remove_scope_stack_listener(l)
-      @scope_stack_listener = nil
-    end
-    
-    def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
-      
-      stack = (Thread::current[:newrelic_scope_stack] ||= [])
-      
-      if @scope_stack_listener
-        @scope_stack_listener.notice_first_scope_push(time) if stack.empty? 
-        @scope_stack_listener.notice_push_scope metric, time
-      end
-      
-      scope = ScopeStackElement.new(metric, 0, deduct_call_time_from_parent)
-      stack.push scope
-      
-      scope
-    end
-    
-    def pop_scope(expected_scope, duration, time=Time.now.to_f)
-
-      stack = Thread::current[:newrelic_scope_stack]
-      
-      scope = stack.pop
-      
-      fail "unbalanced pop from blame stack: #{scope.name} != #{expected_scope.name}" if scope != expected_scope
-       
-      stack.last.children_time += duration unless (stack.empty? || !scope.deduct_call_time_from_parent)
-      
-      if !scope.deduct_call_time_from_parent && !stack.empty?
-        stack.last.children_time += scope.children_time
-      end
-      
-      if @scope_stack_listener
-        @scope_stack_listener.notice_pop_scope(scope.name, time)
-        @scope_stack_listener.notice_scope_empty(time) if stack.empty? 
-      end
-      
-      scope
-    end
-    
-    def peek_scope
-      scope_stack.last
-    end
-    
-    # Add an instance of Sampler to be invoked about every 10 seconds on a background
-    # thread.
-    def add_sampler sampler
-      @periodic_samplers << sampler
-      sampler.stats_engine = self
-      log.debug "Adding sampler #{sampler.id.to_s}"
-    end
-    
-    # Add a sampler to be invoked just before each harvest.
-    def add_harvest_sampler sampler
-      @harvest_samplers << sampler
-      sampler.stats_engine = self
-      log.debug "Adding harvest time sampler: #{sampler.id.to_s}"
-    end
-    
-    # set the name of the transaction for the current thread, which will be used
-    # to define the scope of all traced methods called on this thread until the
-    # scope stack is empty.  
-    #
-    # currently the transaction name is the name of the controller action that 
-    # is invoked via the dispatcher, but conceivably we could use other transaction
-    # names in the future if the traced application does more than service http request
-    # via controller actions
-    def transaction_name=(transaction)
-      Thread::current[:newrelic_transaction_name] = transaction
-    end
-    
-    def transaction_name
-      Thread::current[:newrelic_transaction_name]
-    end
-    
-    
-    def lookup_stat(metric_name)
-      return @stats_hash[metric_name]
-    end
-    def metrics
-      return @stats_hash.keys
-    end
-    
-    def get_stats_no_scope(metric_name)
-      stats = @stats_hash[metric_name]
-      if stats.nil?
-        stats = NewRelic::MethodTraceStats.new
-        @stats_hash[metric_name] = stats
-      end
-      stats
-    end
-    
-    # This version allows a caller to pass a stat class to use
-    #
-    def get_custom_stats(metric_name, stat_class)
-      stats = @stats_hash[metric_name]
-      if stats.nil?
-        stats = stat_class.new
-        @stats_hash[metric_name] = stats
-      end
-      stats
-    end
-    
-    # If use_scope is true, two chained metrics are created, one with scope and one without
-    # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
-    def get_stats(metric_name, use_scope = true, scoped_metric_only = false)
-      
-      if scoped_metric_only
-        spec = NewRelic::MetricSpec.new metric_name, transaction_name
-        
-        stats = @stats_hash[spec]
-        if stats.nil?
-          stats = NewRelic::MethodTraceStats.new
-          @stats_hash[spec] = stats        
-        end
-      else  
-        stats = @stats_hash[metric_name]
-        if stats.nil?
-          stats = NewRelic::MethodTraceStats.new
-          @stats_hash[metric_name] = stats
-        end
-        
-        if use_scope && transaction_name
-          spec = NewRelic::MetricSpec.new metric_name, transaction_name
-          
-          scoped_stats = @stats_hash[spec]
-          if scoped_stats.nil?
-            scoped_stats = NewRelic::ScopedMethodTraceStats.new stats
-            @stats_hash[spec] = scoped_stats        
-          end
-          
-          stats = scoped_stats
-        end
-      end
-      
-      stats
-    end
-    
-    # Harvest the timeslice data.  First recombine current statss
-    # with any previously
-    # unsent metrics, clear out stats cache, and return the current
-    # stats. 
-    # ---
-    # Note: this is not synchronized.  There is still some risk in this and
-    # we will revisit later to see if we can make this more robust without
-    # sacrificing efficiency.
-    # +++
-    def harvest_timeslice_data(previous_timeslice_data, metric_ids)
-      timeslice_data = {}
-      poll @harvest_samplers
-      @stats_hash.keys.each do | metric_spec |
-        
-        
-        # get a copy of the stats collected since the last harvest, and clear
-        # the stats inside our hash table for the next time slice.
-        stats = @stats_hash[metric_spec]
-
-        # we have an optimization for unscoped metrics
-        if !(metric_spec.is_a? NewRelic::MetricSpec)
-          metric_spec = NewRelic::MetricSpec.new metric_spec
-        end
-
-        if stats.nil? 
-          raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
-        end
-        
-        stats_copy = stats.clone
-        stats.reset
-        
-        # if the previous timeslice data has not been reported (due to an error of some sort)
-        # then we need to merge this timeslice with the previously accumulated - but not sent
-        # data
-        previous_metric_data = previous_timeslice_data[metric_spec]
-        stats_copy.merge! previous_metric_data.stats unless previous_metric_data.nil?
-        stats_copy.round!
-        
-        # don't bother collecting and reporting stats that have zero-values for this timeslice.
-        # significant performance boost and storage savings.
-        unless stats_copy.is_reset?
-          
-          metric_spec_for_transport = (metric_ids[metric_spec].nil?) ? metric_spec : nil
-          
-          metric_data = NewRelic::MetricData.new(metric_spec_for_transport, stats_copy, metric_ids[metric_spec])
-          
-          timeslice_data[metric_spec] = metric_data
-        end
-      end
-      
-      timeslice_data
-    end
-    
-    def start_transaction
-      Thread::current[:newrelic_scope_stack] = []
-    end
-    
-    # Try to clean up gracefully, otherwise we leave things hanging around on thread locals
-    #
-    def end_transaction
-      stack = Thread::current[:newrelic_scope_stack]
-      
-      if stack
-        @scope_stack_listener.notice_scope_empty(Time.now) if @scope_stack_listener && !stack.empty? 
+module NewRelic
+  module Agent
+    class StatsEngine
+      include MetricStats
+      include Samplers
+      include Transactions
+      
+      def initialize
+        # Makes the unit tests happy
         Thread::current[:newrelic_scope_stack] = nil
+        spawn_sampler_thread
       end
       
-      Thread::current[:newrelic_transaction_name] = nil
-    end
-    
-    # Remove all stats.  For test code only.
-    def clear_stats 
-      @stats_hash.clear
-    end
-    
-    # Reset each of the stats, such as when a new passenger instance starts up.
-    def reset_stats 
-      @stats_hash.values.each { |s| s.reset }
-    end
-
-    private
-    
-    # Call poll on each of the samplers.  Remove
-    # the sampler if it raises.
-    def poll(samplers)
-      samplers.delete_if do |sampled_item|
-        begin 
-          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
-          true # remove the sampler
-        end
+      def log
+        NewRelic::Control.instance.log
       end
-    end
-    def scope_stack
-      Thread::current[:newrelic_scope_stack] ||= []
+      
     end
   end
 end