newrelic_rpm 2.8.11 → 2.9.2

data/lib/new_relic/agent/patch_const_missing.rb

@@ -1,44 +1,62 @@
 # This class is for debugging purposes only.
 # It inserts instrumentation into class loading to verify
 # that no classes are being loaded on the new relic thread,
-# which can cause problems in the class loader code.
+# which can cause problems in the class loader code. 
+# It is only loaded by agent.rb when a particular newrelic.yml
+# option is set.
 
-module ClassLoadingWatcher
+module ClassLoadingWatcher # :nodoc: all
   
   extend self
   @@background_thread = nil
+  @@flag_const_missing = nil
   
   def background_thread
     @@background_thread
   end
+  def flag_const_missing
+    @@flag_const_missing
+  end
+  def flag_const_missing=(val)
+    @@flag_const_missing = val
+  end
   
-  def set_background_thread(thread)
+  def background_thread=(thread)
     @@background_thread = thread
     
-    # these tests that check is working...
-    #    begin
-    #      bad = Bad
-    #    rescue
-    #    end
-    
-    #    require 'new_relic/agent/patch_const_missing'
-    #    load 'new_relic/agent/patch_const_missing.rb'
+    # these tests verify that check is working
+=begin
+        @@background_thread = nil
+        bad = ConstMissingInForegroundThread rescue nil
+        @@background_thread = thread
+        bad = ConstMissingInBackgroundThread rescue nil
+        require 'new_relic/agent/patch_const_missing'
+        load 'new_relic/agent/patch_const_missing.rb'
+=end
   end
   module SanityCheck 
-    def new_relic_check_for_badness(*args)
+    def nr_check_for_classloading(*args)
       
       if Thread.current == ClassLoadingWatcher.background_thread    
-        msg = "Agent background thread shouldn't be loading classes (#{args.inspect})\n"
-        
-        exception = NewRelic::Agent::BackgroundLoadingError.new(msg.clone)
-        exception.set_backtrace(caller)
-        
-        NewRelic::Agent.instance.error_collector.notice_error(nil, nil, [], exception)
-        msg << caller.join("\n")
-        
-        NewRelic::Config.instance.log.error msg
+        nr_error "Agent background thread shouldn't be loading classes (#{args.inspect})"  
       end
     end
+    # 
+    def nr_check_for_constmissing(*args)
+      if ClassLoadingWatcher.flag_const_missing
+        nr_error "Classes in Agent should not be loaded via const_missing (#{args.inspect})"        
+      end
+    end
+    private
+    def nr_error(msg)
+      exception = NewRelic::Agent::BackgroundLoadingError.new(msg)
+      backtrace = caller
+      backtrace.shift
+      exception.set_backtrace(backtrace)
+      NewRelic::Agent.instance.error_collector.notice_error(exception, nil)
+      msg << "\n" << backtrace.join("\n")
+      NewRelic::Control.instance.log.error msg
+    end
   end
   def enable_warning
     Object.class_eval do
@@ -81,25 +99,27 @@ module ClassLoadingWatcher
   end
 end
 
-class Object
+class Object # :nodoc:
   include ClassLoadingWatcher::SanityCheck
   
   def new_relic_require(*args)
-    new_relic_check_for_badness("Object require", *args)    
+    nr_check_for_classloading("Object require", *args)    
     non_new_relic_require(*args)
   end
   
   def new_relic_load(*args)
-    new_relic_check_for_badness("Object load", *args)
+    nr_check_for_classloading("Object load", *args)
     non_new_relic_load(*args)
   end
 end
 
-class Module
+
+class Module # :nodoc:
   include ClassLoadingWatcher::SanityCheck
   
   def new_relic_const_missing(*args)
-    new_relic_check_for_badness("Module #{self.name} const_missing", *args)
+    nr_check_for_constmissing("Module #{self.name} const_missing", *args)
+    nr_check_for_classloading("Module #{self.name} const_missing", *args)
     non_new_relic_const_missing(*args)
   end
 end

data/lib/new_relic/agent/sampler.rb

@@ -0,0 +1,12 @@
+class NewRelic::Agent::Sampler
+  attr_accessor :stats_engine
+  attr_reader :id
+  def initialize(id)
+    @id = id
+  end
+  
+  def poll
+    raise "Implement in the subclass"
+  end
+  
+end

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

@@ -0,0 +1,44 @@
+module NewRelic::Agent::Samplers
+  class CpuSampler < NewRelic::Agent::Sampler
+    attr_reader :last_time
+    def initialize
+      super :cpu
+      poll
+    end
+    def user_util_stats
+      @userutil ||= stats_engine.get_stats("CPU/User/Utilization", false)
+    end
+    def system_util_stats
+      @systemutil ||= stats_engine.get_stats("CPU/System/Utilization", false)
+    end
+    def usertime_stats
+      @usertime ||= stats_engine.get_stats("CPU/User Time", false)
+    end
+    def systemtime_stats
+      @systemtime ||= stats_engine.get_stats("CPU/System Time", false)
+    end
+    def poll
+      now = Time.now
+      t = Process.times
+      if @last_time
+        elapsed = now - @last_time
+        return if elapsed < 1 # Causing some kind of math underflow
+        num_processors = NewRelic::Control.instance.local_env.processors || 1
+        usertime = t.utime - @last_utime
+        systemtime = t.stime - @last_stime
+
+        systemtime_stats.record_data_point(systemtime) if systemtime >= 0
+        usertime_stats.record_data_point(usertime) if usertime >= 0
+        
+        # Calculate the true utilization by taking cpu times and dividing by
+        # elapsed time X num_processors.
+        user_util_stats.record_data_point usertime / (elapsed * num_processors)
+        system_util_stats.record_data_point systemtime / (elapsed * num_processors)
+      end
+      @last_utime = t.utime
+      @last_stime = t.stime
+      @last_time = now
+    end
+  end
+end
+

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

@@ -0,0 +1,126 @@
+module NewRelic::Agent::Samplers
+  
+  class MemorySampler < NewRelic::Agent::Sampler
+    def initialize
+      super :memory
+      
+      # macos, linux, solaris
+      if defined? Java
+        @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."
+          @sampler = ShellPS.new("ps -o rsz")
+        else
+          NewRelic::Agent.instance.log.info "Using /proc/$$/status for reading process memory."
+        end
+      elsif platform =~ /darwin/
+        @sampler = ShellPS.new("ps -o rsz")
+      elsif platform =~ /freebsd/
+        @sampler = ShellPS.new("ps -o rss")
+      elsif platform =~ /solaris/
+        @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?
+    end
+    def platform
+      if RUBY_PLATFORM =~ /java/
+        %x[uname -s].downcase
+      else
+        RUBY_PLATFORM.downcase
+      end
+    end
+    
+    def stats
+      @stats ||= stats_engine.get_stats("Memory/Physical", false) 
+    end
+    def poll
+      sample = @sampler.get_sample
+      stats.record_data_point sample if sample
+      stats
+    end
+    class Base
+      def can_run?
+        return false if @broken
+        m = get_memory rescue nil
+        m && m > 0
+      end
+      def get_sample
+        return nil if @broken
+        begin
+          m = get_memory
+          if m.nil?
+            NewRelic::Agent.instance.log.error "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+            @broken = true
+          end
+          return m
+        rescue => e
+          NewRelic::Agent.instance.log.error "Unable to get the resident memory for process #{$$}. (#{e})"
+          NewRelic::Agent.instance.log.debug e.backtrace.join("\n  ")
+          NewRelic::Agent.instance.log.error "Disabling memory sampler."
+          @broken = true
+        end
+      end
+    end
+
+    class JavaHeapSampler < Base
+
+      def get_memory
+        raise "Can't sample Java heap unless running in JRuby" unless defined? Java
+        java.lang.Runtime.getRuntime.totalMemory / (1024 * 1024).to_f rescue nil
+      end
+      def to_s
+        "JRuby Java heap sampler"
+      end
+    end
+
+    class ShellPS < Base
+      def initialize(command)
+        super()
+        @command = command
+      end
+      # Returns the amount of resident memory this process is using in MB
+      #
+      def get_memory
+        process = $$
+        memory = `#{@command} #{process}`.split("\n")[1].to_f / 1024.0 rescue nil
+        # if for some reason the ps command doesn't work on the resident os,
+        # then don't execute it any more.
+        raise "Faulty command: `#{@command} #{process}`" if memory.nil? || memory <= 0
+        memory
+      end
+      def to_s
+        "shell command sampler: #{@command}"
+      end
+    end
+    
+    # ProcStatus
+    #
+    # A class that samples memory by reading the file /proc/$$/status, which is specific to linux
+    #
+    class ProcStatus < Base 
+      
+      # Returns the amount of resident memory this process is using in MB
+      #
+      def get_memory
+        File.open(proc_status_file, "r") do |f|
+          while !f.eof? 
+            if f.readline =~ /RSS:\s*(\d+) kB/i
+              return $1.to_f / 1024.0
+            end
+          end
+        end
+        raise "Unable to find RSS in #{proc_status_file}"
+      end
+      def proc_status_file
+        "/proc/#{$$}/status"
+      end
+      def to_s
+        "proc status file sampler: #{proc_status_file}"
+      end
+    end
+  end    
+end  

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

@@ -0,0 +1,22 @@
+module NewRelic::Agent::Samplers
+  # NewRelic Instrumentation for Mongrel - tracks the queue length of the mongrel server.
+  class MongrelSampler < NewRelic::Agent::Sampler
+    def initialize
+      super :mongrel
+    end
+    def queue_stats
+      @queue_stats ||= stats_engine.get_stats("Mongrel/Queue Length", false)
+    end
+    def poll
+      mongrel = NewRelic::Control.instance.local_env.mongrel
+      if mongrel
+        # The mongrel workers list includes workers actively processing requests
+        # so you need to subtract what appears to be the active workers from the total
+        # number of workers to get the queue size.
+        qsize = mongrel.workers.list.length - NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+        qsize = 0 if qsize < 0
+        queue_stats.record_data_point qsize
+      end
+    end
+  end
+end

data/lib/new_relic/agent/shim_agent.rb

@@ -0,0 +1,11 @@
+# This agent is loaded by the plug when the plug-in is disabled
+# It recreates just enough of the API to not break any clients that
+# invoke the Agent.
+class NewRelic::Agent::ShimAgent < NewRelic::Agent::Agent
+  def self.instance
+    @instance ||= self.new
+  end  
+  def ensure_worker_thread_started; end
+  def start *args; end
+  def shutdown; end
+end

data/lib/new_relic/agent/stats_engine.rb

@@ -3,32 +3,23 @@ module NewRelic::Agent
   class StatsEngine
     POLL_PERIOD = 10
     
-    attr_accessor :log
-
     ScopeStackElement = Struct.new(:name, :children_time, :deduct_call_time_from_parent)
     
-    class SampledItem
-      def initialize(stats, &callback)
-        @stats = stats
-        @callback = callback
-      end
-      
-      def poll
-        @callback.call @stats
-      end
-    end
-    
-    def initialize(log = Logger.new(STDERR))
+    def initialize
       @stats_hash = {}
-      @sampled_items = []
+      @harvest_samplers = []
+      @periodic_samplers = []
       @scope_stack_listener = nil
-      @log = log
       
       # 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
       
@@ -39,20 +30,11 @@ module NewRelic::Agent
         while true do
           begin
             sleep POLL_PERIOD
-            @sampled_items.each do |sampled_item|
-              begin 
-                sampled_item.poll
-              rescue => e
-                log.error e
-                @sampled_items.delete sampled_item
-                log.error "Removing #{sampled_item} from list"
-                log.debug e.backtrace.to_s
-              end
-            end
+            poll @periodic_samplers
           end
         end
       end
-
+      @sampler_thread['newrelic_label'] = 'Sampler Tasks'
       @sampler_process = $$
     end
     
@@ -106,9 +88,19 @@ module NewRelic::Agent
       scope_stack.last
     end
     
-    def add_sampled_metric(metric_name, &sampler_callback)
-      stats = get_stats(metric_name, false)
-      @sampled_items << SampledItem.new(stats, &sampler_callback)
+    # 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
@@ -144,33 +136,65 @@ module NewRelic::Agent
       stats
     end
     
-    def get_stats(metric_name, use_scope = true)
+    # 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 = NewRelic::MethodTraceStats.new
+        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 use_scope && transaction_name
+      if scoped_metric_only
         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        
+        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
         
-        stats = scoped_stats
+        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
-      return stats
+      
+      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 = {}
-      @stats_hash.keys.each do |metric_spec|
+      poll @harvest_samplers
+      @stats_hash.keys.each do | metric_spec |
         
         
         # get a copy of the stats collected since the last harvest, and clear
@@ -194,12 +218,11 @@ module NewRelic::Agent
         # 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.call_count == 0 && stats_copy.total_call_time == 0.0 && stats_copy.total_exclusive_time == 0.0
+        unless stats_copy.is_reset?
           
           metric_spec_for_transport = (metric_ids[metric_spec].nil?) ? metric_spec : nil
           
@@ -212,12 +235,10 @@ module NewRelic::Agent
       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
@@ -231,10 +252,28 @@ module NewRelic::Agent
       Thread::current[:newrelic_transaction_name] = nil
     end
     
+    def clear_stats # :nodoc: for test code only
+      @stats_hash.clear
+    end
     private
     
-      def scope_stack
-        Thread::current[:newrelic_scope_stack] ||= []
+    # 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
       end
+    end
+    def scope_stack
+      Thread::current[:newrelic_scope_stack] ||= []
+    end
   end
 end