factorylabs-newrelic_rpm 2.10.2.2

data/lib/new_relic/agent/patch_const_missing.rb

@@ -0,0 +1,125 @@
+# 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. 
+# It is only loaded by agent.rb when a particular newrelic.yml
+# option is set.
+
+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 background_thread=(thread)
+    @@background_thread = thread
+    
+    # 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 nr_check_for_classloading(*args)
+      
+      if Thread.current == ClassLoadingWatcher.background_thread    
+        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
+      if !defined?(non_new_relic_require)
+        alias_method :non_new_relic_require, :require
+        alias_method :require, :new_relic_require
+      end
+      
+      if !defined?(non_new_relic_load)
+        alias_method :non_new_relic_load, :load
+        alias_method :load, :new_relic_load
+      end
+    end
+    Module.class_eval do
+      if !defined?(non_new_relic_const_missing)
+        alias_method :non_new_relic_const_missing, :const_missing
+        alias_method :const_missing, :new_relic_const_missing
+      end
+    end
+  end
+  
+  def disable_warning
+    Object.class_eval do
+      if defined?(non_new_relic_require)
+        alias_method :require, :non_new_relic_require
+        undef non_new_relic_require
+      end
+      
+      if defined?(non_new_relic_load)
+        alias_method :load, :non_new_relic_load
+        undef non_new_relic_load
+      end
+    end
+    Module.class_eval do
+      if defined?(non_new_relic_const_missing)
+        alias_method :const_missing, :non_new_relic_const_missing
+        undef non_new_relic_const_missing
+      end
+    end
+  end
+end
+
+class Object # :nodoc:
+  include ClassLoadingWatcher::SanityCheck
+  
+  def new_relic_require(*args)
+    nr_check_for_classloading("Object require", *args)    
+    non_new_relic_require(*args)
+  end
+  
+  def new_relic_load(*args)
+    nr_check_for_classloading("Object load", *args)
+    non_new_relic_load(*args)
+  end
+end
+
+
+class Module # :nodoc:
+  include ClassLoadingWatcher::SanityCheck
+  
+  def new_relic_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,46 @@
+# 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
+  
+  def poll
+    raise "Implement in the subclass"
+  end
+  
+  
+end

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

@@ -0,0 +1,50 @@
+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?(JRuby)
+    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,141 @@
+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, "Unsupported platform for getting memory: #{platform}" if @sampler.nil?
+      raise Unsupported, "Unable to run #{@sampler}" unless @sampler.can_run?
+    end
+    def self.supported_on_this_platform?
+      defined?(JRuby) or platform =~ /linux|darwin9|darwin10|freebsd|solaris/
+    end
+
+    def self.use_harvest_sampler?
+      false
+    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
+          return nil
+        end
+      end
+    end
+
+    class JavaHeapSampler < Base
+
+      def get_memory
+        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
+        "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,23 @@
+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
+      raise Unsupported, "Mongrel not running" unless NewRelic::Control.instance.local_env.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::BusyCalculator.busy_count
+        qsize = 0 if qsize < 0
+        queue_stats.record_data_point qsize
+      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

@@ -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,22 @@
+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
+    
+    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