wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -0,0 +1,175 @@
+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
+
+      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)
+            @in.set_encoding(::Encoding::ASCII_8BIT)
+          end
+          @last_read = Time.now
+        end
+
+        def close
+          @out.close unless @out.closed?
+          @in.close unless @in.closed?
+        end
+
+        def write(data)
+          @out.close unless @out.closed?
+          @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
+          @out.gets("\n\n")
+        end
+
+        def closed?
+          @out.closed? && @in.closed?
+        end
+      end
+
+      class Listener
+        attr_reader   :thread
+        attr_accessor :pipes, :timeout, :select_timeout
+
+        def initialize
+          @pipes = {}
+          @timeout = 360
+          @select_timeout = 60
+        end
+
+        def register_pipe(id)
+          @pipes[id] = Pipe.new
+          wake.in << '.'
+        end
+
+        def start
+          return if @started == true
+          @started = true
+          @thread = NewRelic::Agent::AgentThread.new('Pipe Channel Manager') do
+            now = nil
+            loop do
+              clean_up_pipes
+              pipes_to_listen_to = @pipes.values.map{|pipe| pipe.out} + [wake.out]
+              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)
+                else
+                  merge_data_from_pipe(pipe)
+                end
+              end
+
+              break if !should_keep_listening?
+            end
+          end
+          sleep 0.001 # give time for the thread to spawn
+        end
+
+        def stop
+          return unless @started == true
+          @started = false
+          wake.in << '.' unless wake.in.closed?
+          @thread.join # make sure we wait for the thread to exit
+          close_all_pipes
+          @wake.close
+          @wake = nil
+        end
+
+        def close_all_pipes
+          @pipes.each do |id, pipe|
+            pipe.close if pipe
+          end
+          @pipes = {}
+        end
+
+        def wake
+          @wake ||= Pipe.new
+        end
+
+        def started?
+          @started
+        end
+
+        protected
+
+        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
+            elsif payload
+              NewRelic::Agent.agent.merge_data_from([payload[:stats],
+                                                     payload[:transaction_traces],
+                                                     payload[:error_traces]])
+            end
+          end
+        end
+
+        def unmarshal(data)
+          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::Agent.logger.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
+              pipe.close unless pipe.closed?
+            end
+          end
+          @pipes.reject! {|id, pipe| pipe.out.closed? }
+        end
+
+        def find_pipe_for_handle(out_handle)
+          @pipes.values.find{|pipe| pipe.out == out_handle }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/pipe_service.rb

@@ -0,0 +1,58 @@
+module NewRelic
+  module Agent
+    class PipeService
+      attr_reader :channel_id, :buffer
+      attr_accessor :request_timeout, :agent_id, :collector
+      
+      def initialize(channel_id)
+        @channel_id = channel_id
+        @collector = NewRelic::Control::Server.new(:name => 'parent',
+                                                   :port => 0)
+      end
+      
+      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))
+        {}
+      end
+
+      def transaction_sample_data(transactions)
+        write_to_pipe(:transaction_traces => transactions) if transactions
+      end
+
+      def error_data(errors)
+        write_to_pipe(:error_traces => errors) if errors
+      end
+
+      def sql_trace_data(sql)
+        write_to_pipe(:sql_traces => sql) if sql
+      end
+      
+      def shutdown(time)
+        write_to_pipe('EOF')
+        NewRelic::Agent::PipeChannelManager.channels[@channel_id].close
+      end
+      
+      private
+
+      def hash_from_metric_data(metric_data)
+        metric_hash = {}
+        metric_data.each do |metric_entry|
+          metric_hash[metric_entry.metric_spec] = metric_entry
+        end
+        metric_hash
+      end
+
+      def write_to_pipe(data)
+        NewRelic::Agent::PipeChannelManager.channels[@channel_id].write(data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'new_relic/agent/sampler'
+require 'new_relic/delayed_job_injection'
+
+module NewRelic
+  module Agent
+    module Samplers
+      # This sampler records the status of your delayed job table once a minute.
+      # It assumes jobs are cleared after being run, and failed jobs are not (otherwise
+      # the failed job metric is useless).
+      #
+      # In earlier versions it will break out the queue length by priority.  In later
+      # versions of DJ where distinct queues are supported, it breaks it out by queue name.
+      #
+      class DelayedJobSampler < NewRelic::Agent::Sampler
+        def initialize
+          super :delayed_job_queue
+          raise Unsupported, "DJ instrumentation disabled" if Agent.config[:disable_dj]
+          raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
+        end
+
+        def error_stats
+          stats_engine.get_stats("Workers/DelayedJob/failed_jobs", false)
+        end
+        def locked_job_stats
+          stats_engine.get_stats("Workers/DelayedJob/locked_jobs", false)
+        end
+
+        def local_env
+          NewRelic::Control.instance.local_env
+        end
+
+        def worker_name
+          local_env.dispatcher_instance_id
+        end
+
+        def failed_jobs
+          Delayed::Job.count(:conditions => 'failed_at is not NULL')
+        end
+        def locked_jobs
+          Delayed::Job.count(:conditions => 'locked_by is not NULL')
+        end
+
+        def self.supported_on_this_platform?
+          defined?(Delayed::Job)
+        end
+
+        def poll
+          record error_stats, failed_jobs
+          record locked_job_stats, locked_jobs
+
+          if @queue
+            record_queue_length_across_dimension('queue')
+          else
+            record_queue_length_across_dimension('priority')
+          end
+        end
+
+        private
+
+        def record_queue_length_across_dimension(column)
+          all_count = 0
+          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
+          record(stats_engine.get_stats("Workers/DelayedJob/queue_length/all", false), all_count)
+        end
+
+        # Figure out if we get the queues.
+        def setup
+          return unless @queue.nil?
+          @setup = true
+          columns = Delayed::Job.columns
+          columns.each do | c |
+            @queue = true if c.name.to_s == 'priority'
+          end
+          @queue ||= false
+        end
+
+        def record(stat, size)
+          stat.record_data_point size
+        end
+      end
+    end
+  end
+end

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

@@ -15,14 +15,14 @@ module NewRelic
           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."
+              ::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.instance.log.debug "Using /proc/#{$$}/status for reading process memory."
+              ::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[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
@@ -68,14 +68,12 @@ module NewRelic
             begin
               m = get_memory
               if m.nil?
-                NewRelic::Agent.instance.log.error "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+                ::NewRelic::Agent.logger.warn "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."
+              ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}. Disabling memory sampler.", e
               @broken = true
               return nil
             end

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)
@@ -105,7 +71,7 @@ module NewRelic
 
         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)"
+            ::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
@@ -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,43 +209,34 @@ module NewRelic
 
         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
+        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(encoder)
+        [ @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),
+          encoder.encode(@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
-        else
-          string.hash
-        end.modulo(2**31-1)
-        # modulo ensures sql_id fits in an INT(11)
+        # 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