sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,141 @@
+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.logger.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
+              @sampler = ShellPS.new("ps -o rsz")
+            else
+              ::NewRelic::Agent.logger.debug "Using /proc/#{$$}/status for reading process memory."
+            end
+          elsif platform =~ /darwin9/ # 10.5
+            @sampler = ShellPS.new("ps -o rsz")
+          elsif platform =~ /darwin1\d+/ # >= 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|darwin|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.logger.warn "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+                @broken = true
+              end
+              return m
+            rescue => e
+              ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}. Disabling memory sampler.", e
+              @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,28 @@
+# 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 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,251 @@
+require 'zlib'
+require 'base64'
+require 'digest/md5'
+
+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
+        @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 enabled?
+        Agent.config[:'slow_sql.enabled'] &&
+          (Agent.config[:'slow_sql.record_sql'] == 'raw' ||
+           Agent.config[:'slow_sql.record_sql'] == 'obfuscated') &&
+          Agent.config[:'transaction_tracer.enabled']
+      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
+        if Agent.config[:'slow_sql.enabled'] && transaction_data
+          transaction_data.set_transaction_info(path, uri, params, guid)
+        end
+      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.sql_data.size > 0
+          @samples_lock.synchronize do
+            ::NewRelic::Agent.logger.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 > Agent.config[:'slow_sql.explain_threshold']
+            backtrace = caller.join("\n")
+            transaction_data.sql_data << SlowSql.new(TransactionSampler.truncate_message(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 !Agent.config[:'slow_sql.enabled']
+        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 < Stats
+      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(float(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(float(slow_sql.duration))
+      end
+
+      def prepare_to_send
+        params[:explain_plan] = @slow_sql.explain if need_to_explain?
+        @sql = @slow_sql.obfuscate if need_to_obfuscate?
+      end
+
+      def need_to_obfuscate?
+        Agent.config[:'slow_sql.record_sql'].to_s == 'obfuscated'
+      end
+
+      def need_to_explain?
+        Agent.config[:'slow_sql.explain_enabled']
+      end
+
+      include NewRelic::Coerce
+
+      def to_collector_array(encoder)
+        [ string(@path),
+          string(@url),
+          int(@sql_id),
+          string(@sql),
+          string(@database_metric_name),
+          int(@call_count),
+          Helper.time_to_millis(@total_call_time),
+          Helper.time_to_millis(@min_call_time),
+          Helper.time_to_millis(@max_call_time),
+          encoder.encode(@params) ]
+      end
+
+      private
+
+      def consistent_hash(string)
+        # need to hash the same way in every process
+        Digest::MD5.hexdigest(string).hex \
+          .modulo(2**31-1)  # ensure sql_id fits in an INT(11)
+      end
+    end
+  end
+end