wd_newrelic_rpm 3.3.4.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,143 @@
+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 =~ /darwin1[01]/ # 10.6 & 10.7
+            @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
+            proc_status = File.open(proc_status_file, "r") {|f| f.read_nonblock(4096).strip }
+            if proc_status =~ /RSS:\s*(\d+) kB/i
+              return $1.to_f / 1024.0
+            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
+        @stats_engine.extend NewRelic::Agent::StatsEngine::Shim
+        @stats_engine.extend NewRelic::Agent::StatsEngine::Transactions::Shim
+        @transaction_sampler.extend NewRelic::Agent::TransactionSampler::Shim
+        @sql_sampler.extend NewRelic::Agent::SqlSampler::Shim
+        @error_collector.extend NewRelic::Agent::ErrorCollector::Shim
+      end
+      def after_fork *args; end
+      def start *args; end
+      def shutdown *args; 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/sql_sampler.rb

@@ -0,0 +1,286 @@
+require 'new_relic/agent'
+require 'new_relic/control'
+module NewRelic
+  module Agent
+
+    class SqlSampler
+
+      # Module defining methods stubbed out when the agent is disabled
+      module Shim #:nodoc:
+        def notice_scope_empty(*args); end
+        def notice_first_scope_push(*args); end
+        def notice_transaction(*args); end
+      end
+
+      attr_reader :disabled
+
+      # this is for unit tests only
+      attr_reader :sql_traces
+
+      def initialize
+        configure!
+        @sql_traces = {}
+        clear_transaction_data
+
+        # This lock is used to synchronize access to the @last_sample
+        # and related variables. It can become necessary on JRuby or
+        # any 'honest-to-god'-multithreaded system
+        @samples_lock = Mutex.new
+      end
+      
+      def configure!
+        @explain_threshold = config.fetch('explain_threshold', 0.5).to_f
+        @explain_enabled = config.fetch('explain_enabled', true)
+        @stack_trace_threshold = config.fetch('stack_trace_threshold',
+                                              0.5).to_f
+        if config.fetch('enabled', true) &&
+            NewRelic::Control.instance['transaction_tracer'] &&
+            NewRelic::Control.instance['transaction_tracer'].fetch('enabled',
+                                                                   true) &&
+            NewRelic::Control.instance.fetch('collect_traces', true)
+          enable
+        else
+          disable
+        end
+      end
+      
+      def config
+        self.class.config
+      end
+      
+      def self.config
+        control = NewRelic::Control.instance
+        txn_config = control.fetch('transaction_tracer', {})
+
+        if txn_config.fetch('enabled', true) && control.has_slow_sql_config?
+          txn_config['enabled'] = control['slow_sql']['enabled']
+        end
+        
+        txn_config
+      end
+                  
+      # Enable the sql sampler - this also registers it with
+      # the statistics engine.
+      def enable
+        @disabled = false
+      end
+
+      # Disable the sql sampler - this also deregisters it
+      # with the statistics engine.
+      def disable
+        @disabled = true
+      end
+
+      def enabled?
+        !@disabled
+      end
+
+      def notice_transaction(path, uri=nil, params={})
+        if NewRelic::Agent.instance.transaction_sampler.builder
+          guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
+        end
+        transaction_data.set_transaction_info(path, uri, params, guid) if !disabled && transaction_data
+      end
+
+      def notice_first_scope_push(time)
+        create_transaction_data
+      end
+
+      def create_transaction_data
+        Thread.current[:new_relic_sql_data] = TransactionSqlData.new
+      end
+
+      def transaction_data
+        Thread.current[:new_relic_sql_data]
+      end
+
+      def clear_transaction_data
+        Thread.current[:new_relic_sql_data] = nil
+      end
+
+      # This is called when we are done with the transaction.
+      def notice_scope_empty(time=Time.now)
+        data = transaction_data
+        clear_transaction_data
+
+        if data.sql_data.size > 0
+          @samples_lock.synchronize do
+            NewRelic::Agent.instance.log.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
+            #FIXME get tx name and uri
+            harvest_slow_sql data
+          end
+        end
+      end
+
+      # this should always be called under the @samples_lock
+      def harvest_slow_sql(transaction_sql_data)
+        transaction_sql_data.sql_data.each do |sql_item|
+          normalized_sql = sql_item.normalize
+          sql_trace = @sql_traces[normalized_sql]
+          if sql_trace
+            sql_trace.aggregate(sql_item, transaction_sql_data.path,
+                                transaction_sql_data.uri)
+          else
+            @sql_traces[normalized_sql] = SqlTrace.new(normalized_sql,
+                sql_item, transaction_sql_data.path, transaction_sql_data.uri)
+          end
+        end
+
+      end
+
+      def notice_sql(sql, metric_name, config, duration)
+        return unless transaction_data
+        if NewRelic::Agent.is_sql_recorded?
+          if duration > @explain_threshold
+            backtrace = caller.join("\n")
+            transaction_data.sql_data << SlowSql.new(sql, metric_name, config,
+                                                     duration, backtrace)
+          end
+        end
+      end
+
+      def merge(sql_traces)
+        @samples_lock.synchronize do
+#FIXME we need to merge the sql_traces array back into the @sql_traces hash
+#          @sql_traces.merge! sql_traces
+        end
+      end
+
+      def harvest
+        return [] if disabled
+        result = []
+        @samples_lock.synchronize do
+          result = @sql_traces.values
+          @sql_traces = {}
+        end        
+        slowest = result.sort{|a,b| b.max_call_time <=> a.max_call_time}[0,10]
+        slowest.each {|trace| trace.prepare_to_send }
+        slowest
+      end
+
+      # reset samples without rebooting the web server
+      def reset!
+      end
+    end
+
+    class TransactionSqlData
+      attr_reader :path
+      attr_reader :uri
+      attr_reader :params
+      attr_reader :sql_data
+      attr_reader :guid
+
+      def initialize
+        @sql_data = []
+      end
+
+      def set_transaction_info(path, uri, params, guid)
+        @path = path
+        @uri = uri
+        @params = params
+        @guid = guid
+      end
+    end
+
+    class SlowSql
+      attr_reader :sql
+      attr_reader :metric_name
+      attr_reader :duration
+      attr_reader :backtrace
+
+      def initialize(sql, metric_name, config, duration, backtrace = nil)
+        @sql = sql
+        @metric_name = metric_name
+        @config = config
+        @duration = duration
+        @backtrace = backtrace
+      end
+
+      def obfuscate
+        NewRelic::Agent::Database.obfuscate_sql(@sql)
+      end
+
+      def normalize
+        NewRelic::Agent::Database::Obfuscator.instance \
+          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
+      end
+
+      def explain
+        NewRelic::Agent::Database.explain_sql(@sql, @config)
+      end
+    end
+
+    class SqlTrace < MethodTraceStats
+      attr_reader :path
+      attr_reader :url
+      attr_reader :sql_id
+      attr_reader :sql
+      attr_reader :database_metric_name
+      attr_reader :params
+
+      def initialize(normalized_query, slow_sql, path, uri)
+        super()
+        @params = {} #FIXME
+        @sql_id = consistent_hash(normalized_query)
+        set_primary slow_sql, path, uri
+        record_data_point slow_sql.duration
+      end
+
+      def set_primary(slow_sql, path, uri)
+        @slow_sql = slow_sql
+        @sql = slow_sql.sql
+        @database_metric_name = slow_sql.metric_name
+        @path = path
+        @url = uri
+        # FIXME
+        @params[:backtrace] = slow_sql.backtrace if slow_sql.backtrace
+      end
+
+      def aggregate(slow_sql, path, uri)
+        if slow_sql.duration > max_call_time
+          set_primary slow_sql, path, uri
+        end
+
+        record_data_point slow_sql.duration
+      end
+      
+      def prepare_to_send
+        begin
+          params[:explain_plan] = @slow_sql.explain if need_to_explain?
+        ensure
+          NewRelic::Agent::Database.close_connections
+        end
+        @sql = @slow_sql.obfuscate if need_to_obfuscate?
+      end
+      
+      def agent_config
+        NewRelic::Agent::SqlSampler.config
+      end
+      
+      def need_to_obfuscate?
+        agent_config['record_sql'] == 'obfuscated'
+      end
+
+      def need_to_explain?
+        agent_config['explain_enabled']
+      end
+      
+      def to_json(*a)
+        [@path, @url, @sql_id, @sql, @database_metric_name, @call_count, @total_call_time, @min_call_time, @max_call_time, @params].to_json(*a)
+      end
+
+      private
+
+      def consistent_hash(string)
+        if NewRelic::LanguageSupport.using_version?('1.9.2')
+          # String#hash is salted differently on every VM start in 1.9
+          require 'digest/md5'
+          Digest::MD5.hexdigest(string).hex
+        else
+          string.hash
+        end.modulo(2**31-1)
+        # modulo ensures sql_id fits in an INT(11)
+      end
+    end
+  end
+end