newrelic_rpm 2.13.4 → 2.13.5.beta1

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

@@ -1,54 +1,56 @@
+require 'new_relic/agent/sampler'
+
 module NewRelic
   module Agent
     module Samplers
-  class CpuSampler < NewRelic::Agent::Sampler
-    attr_reader :last_time
-    def initialize
-      super :cpu
-      poll
-    end
+      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 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 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
+        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
+            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)
+            # 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
-      @last_utime = t.utime
-      @last_stime = t.stime
-      @last_time = now
     end
   end
 end
-end
-end
 

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

@@ -1,3 +1,5 @@
+require 'new_relic/agent/sampler'
+
 module NewRelic
   module Agent
     module Samplers

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

@@ -1,142 +1,144 @@
+require 'new_relic/agent/sampler'
+
 module NewRelic
   module Agent
-module Samplers
+    module Samplers
 
-  class MemorySampler < NewRelic::Agent::Sampler
-    attr_accessor :sampler
+      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.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.debug "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
+        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.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.debug "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
+          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.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 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
+        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
-          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
+        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
+          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
+        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
+        # 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
+          # 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
-        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
-end
-end

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

@@ -1,3 +1,5 @@
+require 'new_relic/agent/sampler'
+
 module NewRelic
   module Agent
     module Samplers

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

@@ -116,7 +116,6 @@ module NewRelic
               # 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.

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

@@ -32,25 +32,31 @@ module Agent
         @sampler_thread['newrelic_label'] = 'Sampler Tasks'
       end
 
+      private
+      
+      def add_sampler_to(sampler_array, sampler)
+        raise "Sampler #{sampler.inspect} is already registered.  Don't call add_sampler directly anymore." if sampler_array.include?(sampler)
+        sampler_array << sampler
+        sampler.stats_engine = self
+      end
+
+      def log_added_sampler(type, sampler)
+        log.debug "Adding #{type} sampler: #{sampler.inspect}"
+      end
+      
+      public
+
       # 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.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.object_id.to_s}"
+      def add_sampler(sampler)
+        add_sampler_to(periodic_samplers, sampler)
+        log_added_sampler('periodic', sampler)
       end
 
       # Add a sampler to be invoked just before each harvest.
-      def add_harvest_sampler sampler
-        harvest_samplers.each do |s|
-          raise "Sampler #{sampler.id} is already registered.  Don't call add_sampler directly anymore." if s.id == sampler.id
-        end
-        harvest_samplers << sampler
-        sampler.stats_engine = self
-        log.debug "Adding harvest time sampler: #{sampler.id.to_s}"
+      def add_harvest_sampler(sampler)
+        add_sampler_to(harvest_samplers, sampler)
+        log_added_sampler('harvest-time', sampler)
       end
 
       private

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

@@ -41,8 +41,8 @@ module Agent
         if collecting_gc?
           if stack.empty?
             # reset the gc time so we only include gc time spent during this call
-            @last_gc_timestamp = GC.time
-            @last_gc_count = GC.collections
+            @last_gc_timestamp = gc_time
+            @last_gc_count = gc_collections
           else
             capture_gc_time
           end
@@ -113,17 +113,45 @@ module Agent
 
       # Make sure we don't do this in a multi-threaded environment
       def collecting_gc?
-        @@collecting_gc ||= GC.respond_to?(:time) && GC.respond_to?(:collections) && !NewRelic::Control.instance.multi_threaded?
+        if !defined?(@@collecting_gc)
+          @@collecting_gc = false
+          if !NewRelic::Control.instance.multi_threaded?
+            @@collecting_gc = true if GC.respond_to?(:time) && GC.respond_to?(:collections) # 1.8.x
+            @@collecting_gc = true if defined?(GC::Profiler) && GC::Profiler.enabled? # 1.9.2
+          end  
+        end
+        @@collecting_gc
+      end
+
+      # The total number of times the garbage collector has run since
+      # profiling was enabled
+      def gc_collections
+        if GC.respond_to?(:count)
+          GC.count
+        elsif GC.respond_to?(:collections)
+          GC.collections
+        end
+      end
+
+      # The total amount of time taken by garbage collection since
+      # profiling was enabled
+      def gc_time
+        if GC.respond_to?(:time)
+          GC.time
+        elsif defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
+          # The 1.9 profiler returns a time in usec
+          GC::Profiler.total_time * 1000000.0
+        end
       end
 
       # Assumes collecting_gc?
       def capture_gc_time
         # Skip this if we are already in this segment
         return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
-        num_calls = GC.collections - @last_gc_count
-        elapsed = (GC.time - @last_gc_timestamp).to_f
-        @last_gc_timestamp = GC.time
-        @last_gc_count = GC.collections
+        num_calls = gc_collections - @last_gc_count
+        elapsed = (gc_time - @last_gc_timestamp).to_f
+        @last_gc_timestamp = gc_time
+        @last_gc_count = gc_collections
         if num_calls > 0
           # µs to seconds
           elapsed = elapsed / 1000000.0