ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -1,8 +1,15 @@
+require 'base64'
+
 module NewRelic
   module Agent
+
+    #--
+    # Manages the registering and servicing of pipes used by child
+    # processes to report data to their parent, rather than directly
+    # to the collector.
     module PipeChannelManager
       extend self
-      
+
       def register_report_channel(id)
         listener.register_pipe(id)
       end
@@ -10,15 +17,15 @@ module NewRelic
       def channels
         listener.pipes
       end
-      
+
       def listener
         @listener ||= Listener.new
       end
-      
+
       class Pipe
         attr_accessor :in, :out
         attr_reader :last_read
-        
+
         def initialize
           @out, @in = IO.pipe
           if defined?(::Encoding::ASCII_8BIT)
@@ -26,7 +33,7 @@ module NewRelic
           end
           @last_read = Time.now
         end
-        
+
         def close
           @out.close unless @out.closed?
           @in.close unless @in.closed?
@@ -34,9 +41,12 @@ module NewRelic
 
         def write(data)
           @out.close unless @out.closed?
-          @in << Marshal.dump(data) + "\n\n"
+          @in << NewRelic::LanguageSupport.with_cautious_gc do
+            Marshal.dump(data)
+          end
+          @in << "\n\n"
         end
-        
+
         def read
           @in.close unless @in.closed?
           @last_read = Time.now
@@ -47,7 +57,7 @@ module NewRelic
           @out.closed? && @in.closed?
         end
       end
-      
+
       class Listener
         attr_reader   :thread
         attr_accessor :pipes, :timeout, :select_timeout
@@ -66,11 +76,16 @@ module NewRelic
         def start
           return if @started == true
           @started = true
-          @thread = Thread.new do
+          @thread = NewRelic::Agent::Thread.new('Pipe Channel Manager') do
+            now = nil
             loop do
               clean_up_pipes
               pipes_to_listen_to = @pipes.values.map{|pipe| pipe.out} + [wake.out]
-              if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout) 
+              NewRelic::Agent.instance.stats_engine \
+                .get_stats_no_scope('Supportability/Listeners') \
+                .record_data_point((Time.now - now).to_f) if now
+              if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
+                now = Time.now
                 pipe = ready[0][0]
                 if pipe == wake.out
                   pipe.read(1)
@@ -78,14 +93,13 @@ module NewRelic
                   merge_data_from_pipe(pipe)
                 end
               end
-              
+
               break if !should_keep_listening?
             end
           end
-          @thread #.abort_on_exception = true
           sleep 0.001 # give time for the thread to spawn
         end
-        
+
         def stop
           return unless @started == true
           @started = false
@@ -102,7 +116,7 @@ module NewRelic
           end
           @pipes = {}
         end
-        
+
         def wake
           @wake ||= Pipe.new
         end
@@ -116,12 +130,12 @@ module NewRelic
         def merge_data_from_pipe(pipe_handle)
           pipe = find_pipe_for_handle(pipe_handle)
           got = pipe.read
-          
+
           if got && !got.empty?
             payload = unmarshal(got)
             if payload == 'EOF'
               pipe.close
-            else
+            elsif payload
               NewRelic::Agent.agent.merge_data_from([payload[:stats],
                                                      payload[:transaction_traces],
                                                      payload[:error_traces]])
@@ -130,19 +144,19 @@ module NewRelic
         end
 
         def unmarshal(data)
-          if NewRelic::LanguageSupport.broken_gc?
-            NewRelic::LanguageSupport.with_disabled_gc do
-              Marshal.load(data)
-            end
-          else
+          NewRelic::LanguageSupport.with_cautious_gc do
             Marshal.load(data)
           end
+        rescue StandardError => e
+          msg = "#{e.class.name} '#{e.message}' trying to load #{Base64.encode64(data)}"
+          NewRelic::Control.instance.log.debug(msg)
+          nil
         end
-        
+
         def should_keep_listening?
           @started || @pipes.values.find{|pipe| !pipe.in.closed?}
         end
-        
+
         def clean_up_pipes
           @pipes.values.each do |pipe|
             if pipe.last_read.to_f + @timeout < Time.now.to_f

data/lib/new_relic/agent/pipe_service.rb

@@ -13,7 +13,11 @@ module NewRelic
       def connect(config)
         nil
       end
-      
+
+      def get_agent_commands
+        []
+      end
+
       def metric_data(last_harvest_time, now, unsent_timeslice_data)
         write_to_pipe(:stats => hash_from_metric_data(unsent_timeslice_data))
         {}

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

@@ -14,7 +14,7 @@ module NewRelic
       class DelayedJobSampler < NewRelic::Agent::Sampler
         def initialize
           super :delayed_job_queue
-          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj']
+          raise Unsupported, "DJ instrumentation disabled" if Agent.config[:disable_dj]
           raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
         end
 
@@ -33,9 +33,6 @@ module NewRelic
           local_env.dispatcher_instance_id
         end
 
-        def queued_jobs
-          Delayed::Job.count(:conditions => ['run_at < ? and failed_at is NULL', Time.now])
-        end
         def failed_jobs
           Delayed::Job.count(:conditions => 'failed_at is not NULL')
         end
@@ -62,7 +59,7 @@ module NewRelic
 
         def record_queue_length_across_dimension(column)
           all_count = 0
-          Delayed::Job.count(:group => column).each do | column_val, count |
+          Delayed::Job.count(:group => column, :conditions => ['run_at < ? and failed_at is NULL', Time.now]).each do | column_val, count |
             all_count += count
             record stats_engine.get_stats("Workers/DelayedJob/queue_length/#{column == 'queue' ? 'name' : column}/#{column_val}", false), count
           end

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 =~ /darwin1[01]/ # 10.6 & 10.7
+          elsif platform =~ /darwin1\d+/ # >= 10.6
             @sampler = ShellPS.new("ps -o rss")
           elsif platform =~ /freebsd/
             @sampler = ShellPS.new("ps -o rss")
@@ -35,7 +35,7 @@ module NewRelic
         end
 
         def self.supported_on_this_platform?
-          defined?(JRuby) or platform =~ /linux|darwin9|darwin10|freebsd|solaris/
+          defined?(JRuby) or platform =~ /linux|darwin|freebsd|solaris/
         end
 
         def self.platform

data/lib/new_relic/agent/sql_sampler.rb

@@ -1,5 +1,10 @@
+require 'zlib'
+require 'base64'
+require 'digest/md5'
+
 require 'new_relic/agent'
 require 'new_relic/control'
+
 module NewRelic
   module Agent
 
@@ -18,7 +23,6 @@ module NewRelic
       attr_reader :sql_traces
 
       def initialize
-        configure!
         @sql_traces = {}
         clear_transaction_data
 
@@ -27,59 +31,21 @@ module NewRelic
         # 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
+        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
-        transaction_data.set_transaction_info(path, uri, params, guid) if !disabled && transaction_data
+        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)
@@ -131,7 +97,7 @@ module NewRelic
       def notice_sql(sql, metric_name, config, duration)
         return unless transaction_data
         if NewRelic::Agent.is_sql_recorded?
-          if duration > @explain_threshold
+          if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
             transaction_data.sql_data << SlowSql.new(sql, metric_name, config,
                                                      duration, backtrace)
@@ -147,12 +113,12 @@ module NewRelic
       end
 
       def harvest
-        return [] if disabled
+        return [] if !Agent.config[:'slow_sql.enabled']
         result = []
         @samples_lock.synchronize do
           result = @sql_traces.values
           @sql_traces = {}
-        end        
+        end
         slowest = result.sort{|a,b| b.max_call_time <=> a.max_call_time}[0,10]
         slowest.each {|trace| trace.prepare_to_send }
         slowest
@@ -243,39 +209,49 @@ module NewRelic
 
         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'
+        Agent.config[:'slow_sql.record_sql'].to_s == 'obfuscated'
       end
 
       def need_to_explain?
-        agent_config['explain_enabled']
+        Agent.config[:'slow_sql.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)
+
+      def to_collector_array(marshaller)
+        params = if marshaller.respond_to?(:encode_compress)
+          marshaller.encode_compress(@params)
+        else
+          @params
+        end
+
+        [ @path, @url, @sql_id, @sql, @database_metric_name, @call_count,
+          Helper.time_to_millis(@total_call_time),
+          Helper.time_to_millis(@min_call_time),
+          Helper.time_to_millis(@max_call_time),
+          params ]
       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
+      def compress(data)
+        if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+          require 'json'
+          Base64.encode64(Zlib::Deflate.deflate(JSON.dump(data), Zlib::DEFAULT_COMPRESSION))
         else
-          string.hash
-        end.modulo(2**31-1)
-        # modulo ensures sql_id fits in an INT(11)
+          data
+        end
+      end
+
+      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

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

@@ -7,12 +7,13 @@ module NewRelic
           @profiler = RailsBench.new if RailsBench.enabled?
           @profiler = Ruby19.new if Ruby19.enabled?
           @profiler = Rubinius.new if Rubinius.enabled?
+          @profiler = RubiniusAgent.new if RubiniusAgent.enabled?
         end
 
         def self.capture
           @profiler.capture if @profiler
         end
-        
+
         class Profiler
           def initialize
             if self.class.enabled?
@@ -20,75 +21,76 @@ module NewRelic
               @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
+            # microseconds to seconds
+            elapsed = (call_time - @last_timestamp).to_f / 1_000_000.0
             @last_timestamp = call_time
             @last_count = call_count
             reset
-            
+
             record_gc_metric(num_calls, elapsed)
+            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 = NewRelic::Agent.instance.stats_engine \
+                .get_stats('GC/cumulative', true, false,
+                           NewRelic::Agent::TransactionInfo.get.transaction_name)
               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
         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
+
+          def reset
+            ::GC.clear_stats
+          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
@@ -96,6 +98,20 @@ module NewRelic
         end
 
         class Rubinius < Profiler
+          def self.enabled?
+            defined?(::Rubinius) && defined?(::Rubinius::GC) && ::Rubinius::GC.respond_to?(:count)
+          end
+
+          def call_time
+            ::Rubinius::GC.time * 1000
+          end
+
+          def call_count
+            ::Rubinius::GC.count
+          end
+        end
+
+        class RubiniusAgent < Profiler
           def self.enabled?
             if NewRelic::LanguageSupport.using_engine?('rbx')
               require 'rubinius/agent'
@@ -115,7 +131,7 @@ module NewRelic
             agent = ::Rubinius::Agent.loopback
             agent.get('system.gc.young.count')[1] +
               agent.get('system.gc.full.count')[1]
-          end          
+          end
         end
       end
     end