ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

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

@@ -22,7 +22,7 @@ module NewRelic
             end
           elsif platform =~ /darwin9/ # 10.5
             @sampler = ShellPS.new("ps -o rsz")
-          elsif platform =~ /darwin10/ # 10.6
+          elsif platform =~ /darwin1[01]/ # 10.6 & 10.7
             @sampler = ShellPS.new("ps -o rss")
           elsif platform =~ /freebsd/
             @sampler = ShellPS.new("ps -o rss")
@@ -122,18 +122,17 @@ module NewRelic
           # 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
+            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

data/lib/new_relic/agent/shim_agent.rb

@@ -9,19 +9,19 @@ module NewRelic
       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
+        @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; 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 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

data/lib/new_relic/agent/sql_sampler.rb

@@ -0,0 +1,282 @@
+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
+        params[:explain_plan] = @slow_sql.explain if need_to_explain?
+        @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

data/lib/new_relic/agent/stats_engine.rb

@@ -1,9 +1,11 @@
 require 'new_relic/agent/stats_engine/metric_stats'
 require 'new_relic/agent/stats_engine/samplers'
 require 'new_relic/agent/stats_engine/transactions'
+require 'new_relic/agent/stats_engine/gc_profiler'
 
 module NewRelic
   module Agent
+    # This class handles all the statistics gathering for the agent
     class StatsEngine
       include MetricStats
       include Samplers

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

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+module NewRelic
+  module Agent
+    class StatsEngine
+      module GCProfiler
+        def self.init
+          @profiler = RailsBench.new if RailsBench.enabled?
+          @profiler = Ruby19.new if Ruby19.enabled?
+          @profiler = Rubinius.new if Rubinius.enabled?
+        end
+
+        def self.capture
+          @profiler.capture if @profiler
+        end
+        
+        class Profiler
+          def initialize
+            if self.class.enabled?
+              @last_timestamp = call_time
+              @last_count = call_count
+            end
+          end
+          
+          def capture
+            return unless self.class.enabled?
+            return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
+            
+            num_calls = call_count - @last_count
+            elapsed = (call_time - @last_timestamp).to_f
+            @last_timestamp = call_time
+            @last_count = call_count
+            reset
+            
+            record_gc_metric(num_calls, elapsed)
+          end
+
+          def reset; end
+          
+          protected
+                    
+          def record_gc_metric(num_calls, elapsed)
+            if num_calls > 0
+              # microseconds to seconds
+              elapsed = elapsed / 1_000_000.0
+              # Allocate the GC time to a scope as if the GC just ended
+              # right now.
+              time = Time.now.to_f
+              gc_scope = NewRelic::Agent.instance.stats_engine.push_scope("GC/cumulative", time - elapsed)
+              # GC stats are collected into a blamed metric which allows
+              # us to show the stats controller by controller
+              gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
+              gc_stats.record_multiple_data_points(elapsed, num_calls)
+              NewRelic::Agent.instance.stats_engine.pop_scope(gc_scope, elapsed, time)
+            end
+          end
+
+          def scope_stack
+            Thread::current[:newrelic_scope_stack] ||= []
+          end        
+        end
+        
+        class RailsBench < Profiler
+          def self.enabled?
+            ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
+          end
+          
+          # microseconds spent in GC
+          def call_time
+            ::GC.time # this should already be microseconds
+          end
+          
+          def call_count
+            ::GC.collections
+          end
+        end
+        
+        class Ruby19 < Profiler
+          def self.enabled?
+            defined?(::GC::Profiler) && ::GC::Profiler.enabled?
+          end
+          
+          # microseconds spent in GC
+          # 1.9 total_time returns seconds.  Don't trust the docs.  It's seconds.
+          def call_time
+            ::GC::Profiler.total_time * 1_000_000.0 # convert seconds to microseconds
+          end
+          
+          def call_count
+            ::GC.count
+          end
+          
+          def reset
+            ::GC::Profiler.clear
+            @last_timestamp = 0
+          end
+        end
+
+        class Rubinius < Profiler
+          def self.enabled?
+            if NewRelic::LanguageSupport.using_engine?('rbx')
+              require 'rubinius/agent'
+              true
+            else
+              false
+            end
+          end
+
+          def call_time
+            agent = ::Rubinius::Agent.loopback
+            (agent.get('system.gc.young.total_wallclock')[1] +
+              agent.get('system.gc.full.total_wallclock')[1]) * 1000
+          end
+
+          def call_count
+            agent = ::Rubinius::Agent.loopback
+            agent.get('system.gc.young.count')[1] +
+              agent.get('system.gc.full.count')[1]
+          end          
+        end
+      end
+    end
+  end
+end