ghazel-newrelic_rpm 3.1.0.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,58 @@
+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
+
+        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?
+          # Process.times on JRuby reports wall clock elapsed time,
+          # not actual cpu time used, so we cannot use this sampler there.
+          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,40 @@
+require 'new_relic/agent/sampler'
+require 'new_relic/delayed_job_injection'
+
+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,144 @@
+require 'new_relic/agent/sampler'
+
+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,26 @@
+require 'new_relic/agent/sampler'
+
+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,29 @@
+# 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 serialize; end
+      def merge_data_from(*args); end
+      def push_trace_execution_flag(*args); end
+      def pop_trace_execution_flag(*args); end
+      def browser_timing_header; "" end
+      def browser_timing_footer; "" 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,182 @@
+module NewRelic
+  module Agent
+    class StatsEngine
+      module MetricStats
+        class SynchronizedHash < Hash
+          def initialize(*args)
+            @mutex = Mutex.new
+            super
+          end
+
+          def []=(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+
+          def [](*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+
+          def clear(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+
+          def delete(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+
+          def delete_if(*args)
+            @mutex.synchronize {
+              super
+            }
+          end
+        end
+
+        def metrics
+          stats_hash.keys.map(&:to_s)
+        end
+
+        def get_stats_no_scope(metric_name)
+          stats_hash[NewRelic::MetricSpec.new(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[NewRelic::MetricSpec.new(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[NewRelic::MetricSpec.new(metric_name)] ||= NewRelic::MethodTraceStats.new
+            if scope && scope != metric_name
+              spec = NewRelic::MetricSpec.new metric_name, scope
+              stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
+            end
+          end
+          stats
+        end
+
+        def lookup_stats(metric_name, scope_name = '')
+          stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)]
+        end
+
+        module Harvest
+
+          def merge_data(metric_data_hash)
+            metric_data_hash.each do |metric_spec, metric_data|
+              new_data = lookup_stats(metric_spec.name, metric_spec.scope)
+              if new_data
+                new_data.merge!(metric_data.stats)
+              else
+                stats_hash[metric_spec] = metric_data.stats
+              end
+            end
+          end
+
+          private
+          def get_stats_hash_from(engine_or_hash)
+            if engine_or_hash.is_a?(StatsEngine)
+              engine_or_hash.stats_hash
+            else
+              engine_or_hash
+            end
+          end
+
+          def coerce_to_metric_spec(metric_spec)
+            if metric_spec.is_a?(NewRelic::MetricSpec)
+              metric_spec
+            else
+              NewRelic::MetricSpec.new(metric_spec)
+            end
+          end
+
+          def clone_and_reset_stats(metric_spec, stats)
+            if stats.nil?
+              raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
+            end
+
+            stats_copy = stats.clone
+            stats.reset
+            stats_copy
+          end
+
+          # 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
+          def merge_old_data!(metric_spec, stats, old_data)
+            metric_data = old_data[metric_spec]
+            stats.merge!(metric_data.stats) unless metric_data.nil?
+          end
+
+          def add_data_to_send_unless_empty(data, stats, metric_spec, id)
+            # don't bother collecting and reporting stats that have
+            # zero-values for this timeslice. significant
+            # performance boost and storage savings.
+            return if stats.is_reset?
+            data[metric_spec] = NewRelic::MetricData.new((id ? nil : metric_spec), stats, id)
+          end
+
+          def merge_stats(other_engine_or_hash, metric_ids)
+            old_data = get_stats_hash_from(other_engine_or_hash)
+
+            timeslice_data = {}
+            stats_hash.each do | metric_spec, stats |
+
+              metric_spec = coerce_to_metric_spec(metric_spec)
+              stats_copy = clone_and_reset_stats(metric_spec, stats)
+              merge_old_data!(metric_spec, stats_copy, old_data)
+              add_data_to_send_unless_empty(timeslice_data, stats_copy, metric_spec, metric_ids[metric_spec])
+            end
+            timeslice_data
+          end
+
+        end
+        include Harvest
+
+        # 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)
+
+          poll harvest_samplers
+          merge_stats(previous_timeslice_data, metric_ids)
+        end
+
+        # Remove all stats.  For test code only.
+        def clear_stats
+          @stats_hash = SynchronizedHash.new
+          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 ||= SynchronizedHash.new
+        end
+      end
+    end
+  end
+end