honkster-newrelic_rpm 2.13.1

data/lib/new_relic/agent/sampler.rb

@@ -0,0 +1,50 @@
+# 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.
+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
+end

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

@@ -0,0 +1,54 @@
+module NewRelic
+  module Agent
+    module 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
+end
+end
+

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

@@ -0,0 +1,37 @@
+module NewRelic
+  module Agent
+    module Samplers
+      class DelayedJobLockSampler < NewRelic::Agent::Sampler
+        def initialize
+          super :delayed_job_lock
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+module NewRelic
+  module Agent
+module 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.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
+
+    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 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
+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,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.
+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
+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
+  module Agent
+    class StatsEngine
+      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

@@ -0,0 +1,118 @@
+module NewRelic
+module 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, 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
+            spec = NewRelic::MetricSpec.new metric_name, scope
+            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]
+      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?
+
+            id = metric_ids[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
+        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
+        stats_hash.values.each { |s| s.reset }
+      end
+
+      def stats_hash
+        @stats_hash ||= {}
+      end
+    end
+  end
+end
+end