sundawg_newrelic_rpm 3.5.8.1

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,63 @@
+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 => 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
+
+      # Invokes the block it is passed.  This is used to implement HTTP
+      # keep-alive in the NewRelicService, and is a required interface for any
+      # Service class.
+      def session
+        yield
+      end
+
+      def reset_metric_id_cache
+        # we don't cache metric IDs, so nothing to do
+      end
+
+      private
+
+      def write_to_pipe(data)
+        NewRelic::Agent::PipeChannelManager.channels[@channel_id].write(data)
+      rescue => e
+        NewRelic::Agent.logger.error("#{e.message}: Unable to send data to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
+      end
+    end
+  end
+end

data/lib/new_relic/agent/rules_engine.rb

@@ -0,0 +1,72 @@
+module NewRelic
+  module Agent
+    class RulesEngine
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :@rules, :size, :<<, :inspect, :each
+
+      attr_accessor :rules
+
+      def initialize(rules=[])
+        @rules = rules
+      end
+
+      def rename(original_string)
+        @rules.sort.inject(original_string) do |string,rule|
+          if rule.each_segment
+            result, matched = rule.map_to_list(string.split('/'))
+            result = result.join('/')
+          else
+            result, matched = rule.apply(string)
+          end
+
+          break result if matched && rule.terminate_chain
+          result
+        end
+      end
+
+      class Rule
+        attr_reader(:terminate_chain, :each_segment, :ignore, :replace_all, :eval_order,
+                    :match_expression, :replacement)
+
+        def initialize(options)
+          if !options['match_expression']
+            raise ArgumentError.new('missing required match_expression')
+          end
+          if !options['replacement'] && !options['ignore']
+            raise ArgumentError.new('must specify replacement when ignore is false')
+          end
+
+          @match_expression = Regexp.new(options['match_expression'])
+          @replacement      = options['replacement']
+          @ignore           = options['ignore'] || false
+          @eval_order       = options['eval_order'] || 0
+          @replace_all      = options['replace_all'] || false
+          @each_segment     = options['each_segment'] || false
+          @terminate_chain  = options['terminate_chain'] || false
+        end
+
+        def apply(string)
+          method = @replace_all ? :gsub : :sub
+          result = string.send(method, @match_expression, @replacement)
+          [result, result != string]
+        end
+
+        def map_to_list(list)
+          matched = false
+          result = list.map do |string|
+            str_result, str_match = apply(string)
+            matched ||= str_match
+            str_result
+          end
+          [result, matched]
+        end
+
+        def <=>(other)
+          eval_order <=> other.eval_order
+        end
+      end
+    end
+  end
+end

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_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