newrelic_rpm 2.13.0.beta5 → 2.13.1

data/lib/new_relic/agent/sampler.rb

@@ -1,4 +1,4 @@
-# A Sampler is used to capture meaningful metrics in a background thread 
+# 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.
@@ -6,41 +6,45 @@
 # 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
+module NewRelic
+  module Agent
+    class 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
   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
+end

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

@@ -7,7 +7,7 @@ module NewRelic
       super :cpu
       poll
     end
-    
+
     def user_util_stats
       stats_engine.get_stats_no_scope("CPU/User/Utilization")
     end
@@ -20,11 +20,11 @@ module NewRelic
     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
@@ -37,7 +37,7 @@ module NewRelic
 
         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)

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

@@ -4,30 +4,30 @@ module NewRelic
       class DelayedJobLockSampler < NewRelic::Agent::Sampler
         def initialize
           super :delayed_job_lock
-          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj'] 
+          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj']
           raise Unsupported, "No DJ worker present" unless 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

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

@@ -1,10 +1,10 @@
 module NewRelic
   module Agent
 module Samplers
-  
+
   class MemorySampler < NewRelic::Agent::Sampler
     attr_accessor :sampler
-    
+
     def initialize
       super :memory
       # macos, linux, solaris
@@ -27,11 +27,11 @@ module Samplers
       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
@@ -48,7 +48,7 @@ module Samplers
     end
 
     def stats
-      stats_engine.get_stats("Memory/Physical", false) 
+      stats_engine.get_stats("Memory/Physical", false)
     end
     def poll
       sample = @sampler.get_sample
@@ -110,18 +110,18 @@ module Samplers
         "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 
-      
+    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? 
+          while !f.eof?
             if f.readline =~ /RSS:\s*(\d+) kB/i
               return $1.to_f / 1024.0
             end
@@ -136,7 +136,7 @@ module Samplers
         "proc status file sampler: #{proc_status_file}"
       end
     end
-  end    
-end  
+  end
+end
 end
 end

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

@@ -8,7 +8,7 @@ module NewRelic
         end
 
         def stats
-          stats_engine.get_stats_no_scope("GC/objects")          
+          stats_engine.get_stats_no_scope("GC/objects")
         end
 
         def self.supported_on_this_platform?

data/lib/new_relic/agent/shim_agent.rb

@@ -1,21 +1,25 @@
 # 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
+module NewRelic
+  module Agent
+    class 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 after_fork *args; end
+      def start *args; end
+      def shutdown; end
+      def push_trace_execution_flag(*args); end
+      def pop_trace_execution_flag(*args); end
+    end
   end
-  def after_fork *args; 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

@@ -8,17 +8,17 @@ module NewRelic
       include MetricStats
       include Samplers
       include Transactions
-      
+
       def initialize
         # Makes the unit tests happy
         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/metric_stats.rb

@@ -11,35 +11,35 @@ module Agent
       def metrics
         stats_hash.keys.map(&:to_s)
       end
-      
+
       def get_stats_no_scope(metric_name)
-        stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new 
+        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, scope = nil)
         scope ||= scope_name if use_scope
         if scoped_metric_only
           spec = NewRelic::MetricSpec.new metric_name, scope
-          stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new 
-        else  
-          stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new 
-          if scope && scope != metric_name 
+          stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new
+        else
+          stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
+          if scope && scope != metric_name
             spec = NewRelic::MetricSpec.new metric_name, scope
-            scoped_stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats) 
+            scoped_stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
             stats = scoped_stats
           end
         end
         stats
       end
-      
+
       def lookup_stats(metric_name, scope_name = nil)
         stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)] ||
         stats_hash[metric_name]
@@ -47,7 +47,7 @@ module Agent
       # Harvest the timeslice data.  First recombine current statss
       # with any previously
       # unsent metrics, clear out stats cache, and return the current
-      # stats. 
+      # 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
@@ -57,58 +57,58 @@ module Agent
         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? 
+
+          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?
 
             id = metric_ids[metric_spec]
-            metric_spec_for_transport = id ? nil : metric_spec 
-            
+            metric_spec_for_transport = id ? nil : metric_spec
+
             metric_data = NewRelic::MetricData.new(metric_spec_for_transport, stats_copy, id)
-            
+
             timeslice_data[metric_spec] = metric_data
           end
         end
-        
+
         timeslice_data
       end
-      
+
       # Remove all stats.  For test code only.
-      def clear_stats 
+      def clear_stats
         stats_hash.clear
         NewRelic::Agent::BusyCalculator.reset
       end
-      
+
       # Reset each of the stats, such as when a new passenger instance starts up.
-      def reset_stats 
+      def reset_stats
         stats_hash.values.each { |s| s.reset }
       end
-      
+
       def stats_hash
         @stats_hash ||= {}
       end

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

@@ -6,21 +6,21 @@ module Agent
       def add_harvest_sampler(*args); end
       def start_sampler_thread(*args); end
     end
-    
+
     module Samplers
-      
-      # By default a sampler polls on harvest time, once a minute.  However you can 
+
+      # By default a sampler polls on harvest time, once a minute.  However you can
       # override #use_harvest_sampler? to return false and it will sample
       # every POLL_PERIOD seconds on a background thread.
       POLL_PERIOD = 20
-      
+
       def start_sampler_thread
-        
+
         return if @sampler_thread && @sampler_thread.alive?
-        
+
         # start up a thread that will periodically poll for metric samples
         return if periodic_samplers.empty?
-        
+
         @sampler_thread = Thread.new do
           while true do
             begin
@@ -31,18 +31,18 @@ module Agent
         end
         @sampler_thread['newrelic_label'] = 'Sampler Tasks'
       end
-      
+
       # Add an instance of Sampler to be invoked about every 10 seconds on a background
       # thread.
       def add_sampler sampler
         periodic_samplers.each do |s|
-          raise "Sampler #{sampler.id} is already registered.  Don't call add_sampler directly anymore." if s.id == sampler.id
+          raise "Sampler #{sampler.object_id} is already registered.  Don't call add_sampler directly anymore." if s.object_id == sampler.object_id
         end
         periodic_samplers << sampler
         sampler.stats_engine = self
-        log.debug "Adding sampler #{sampler.id.to_s}"
+        log.debug "Adding sampler #{sampler.object_id.to_s}"
       end
-      
+
       # Add a sampler to be invoked just before each harvest.
       def add_harvest_sampler sampler
         harvest_samplers.each do |s|
@@ -51,15 +51,15 @@ module Agent
         harvest_samplers << sampler
         sampler.stats_engine = self
         log.debug "Adding harvest time sampler: #{sampler.id.to_s}"
-      end  
-      
+      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 
+          begin
             sampled_item.poll
             false # it's okay.  don't delete it.
           rescue Exception => e
@@ -70,7 +70,7 @@ module Agent
           end
         end
       end
-      
+
       def harvest_samplers
         @harvest_samplers ||= []
       end