genki-newrelic_rpm 2.10.1

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,49 @@
+module NewRelic::Agent::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
+    def system_util_stats
+      stats_engine.get_stats_no_scope("CPU/System/Utilization")
+    end
+    def usertime_stats
+      stats_engine.get_stats_no_scope("CPU/User Time")
+    end
+    def systemtime_stats
+      stats_engine.get_stats_no_scope("CPU/System Time")
+    end
+    
+    def self.supported_on_this_platform?
+      not defined?(Java)
+    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,137 @@
+module NewRelic::Agent::Samplers
+  
+  class MemorySampler < NewRelic::Agent::Sampler
+    attr_accessor :sampler
+    
+    def initialize
+      super :memory
+      
+      # macos, linux, solaris
+      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."
+          @sampler = ShellPS.new("ps -o rsz")
+        else
+          NewRelic::Agent.instance.log.info "Using /proc/$$/status for reading process memory."
+        end
+      elsif platform =~ /darwin9/ # 10.5
+        @sampler = ShellPS.new("ps -o rsz")
+      elsif platform =~ /darwin10/ # 10.6
+        @sampler = ShellPS.new("ps -o rss")
+      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 self.supported_on_this_platform?
+      defined?(Java) 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
+    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
+      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,21 @@
+# 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 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

@@ -0,0 +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
+    include MetricStats
+    include Samplers
+    include Transactions
+    # race condition
+#    include Transactions::Shim if NewRelic::Control.instance['disable_scope_tracking']
+    
+    def initialize
+      # Makes the unit tests happy
+      Thread::current[:newrelic_scope_stack] = nil
+      spawn_sampler_thread
+    end
+    
+    def log
+      NewRelic::Control.instance.log
+    end
+    
+  end
+end

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

@@ -0,0 +1,111 @@
+module NewRelic::Agent
+  class StatsEngine
+    module MetricStats
+      # The stats hash hashes either a metric name for an unscoped metric,
+      # or a metric_spec for a scoped metric value.
+      def lookup_stat(metric_name)
+        stats_hash[metric_name]
+      end
+
+      def metrics
+        stats_hash.keys.map(&:to_s)
+      end
+      
+      def get_stats_no_scope(metric_name)
+        stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new 
+      end
+      
+      # This version allows a caller to pass a stat class to use
+      #
+      def get_custom_stats(metric_name, stat_class)
+        stats_hash[metric_name] ||= stat_class.new
+      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] ||= NewRelic::MethodTraceStats.new 
+        else  
+          stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new 
+          if use_scope && transaction_name
+            spec = NewRelic::MetricSpec.new metric_name, transaction_name
+            scoped_stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats) 
+            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
+      
+      # Remove all stats.  For test code only.
+      def clear_stats 
+        stats_hash.clear
+        NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.reset
+      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
+      
+      def stats_hash
+        @stats_hash ||= {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module NewRelic::Agent
+  class StatsEngine
+    module Shim # :nodoc:
+      def add_sampler(*args); end
+      def add_harvest_sampler(*args); end
+      def spawn_sampler_thread(*args); end
+    end
+    
+    module Samplers
+      
+      POLL_PERIOD = 10
+      
+      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
+      
+      # 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  
+      
+      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
+        end
+      end
+      
+      def harvest_samplers
+        @harvest_samplers ||= []
+      end
+      def periodic_samplers
+        @periodic_samplers ||= []
+      end
+    end
+  end
+end