oneapm_rpm 1.1.0

data/lib/one_apm/agent/pipe/pipe_service.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    class PipeService
+      attr_reader :channel_id, :buffer, :pipe
+      attr_accessor :request_timeout, :agent_id, :collector
+
+      def initialize(channel_id)
+        @channel_id = channel_id
+        @collector = OneApm::Support::Server.new(:name => 'parent', :port => 0)
+        @pipe = OneApm::Agent::PipeChannelManager.channels[@channel_id]
+        if @pipe && @pipe.parent_pid != $$
+          @pipe.after_fork_in_child
+        else
+          OneApm::Agent.logger.error("No communication channel to parent process, please see https://oneapm.com/docs/ruby/resque-instrumentation for more information.")
+        end
+      end
+
+      def connect(config)
+        nil
+      end
+
+      def get_agent_commands
+        []
+      end
+
+      def analytic_event_data(events)
+        write_to_pipe(:analytic_event_data, events) if events
+      end
+
+      def custom_event_data(events)
+        write_to_pipe(:custom_event_data, events) if events
+      end
+
+      def metric_data(unsent_timeslice_data)
+        write_to_pipe(:metric_data, unsent_timeslice_data)
+        {}
+      end
+
+      def transaction_sample_data(transactions)
+        write_to_pipe(:transaction_sample_data, transactions) if transactions
+      end
+
+      def error_data(errors)
+        write_to_pipe(:error_data, errors) if errors
+      end
+
+      def sql_trace_data(sql)
+        write_to_pipe(:sql_trace_data, sql) if sql
+      end
+
+      def shutdown(time)
+        @pipe.close if @pipe
+      end
+
+      # Invokes the block it is passed.  This is used to implement HTTP
+      # keep-alive in the CollectorService, 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 marshal_payload(data)
+        OneApm::LanguageSupport.with_cautious_gc do
+          Marshal.dump(data)
+        end
+      end
+
+      def write_to_pipe(endpoint, data)
+        @pipe.write(marshal_payload([endpoint, data])) if @pipe
+      end
+    end
+  end
+end

data/lib/one_apm/agent/sampler.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    class Sampler
+
+      attr_reader :id
+
+      @sampler_classes = []
+
+      class << self
+
+        def named(new_name)
+          @name = new_name
+        end
+
+        def name
+          @name
+        end
+
+        def inherited(subclass)
+          @sampler_classes << subclass
+        end
+
+        def supported_on_this_platform?
+          true
+        end
+
+        def enabled?
+          if @name
+            config_key = "disable_#{@name}_sampler"
+            !(Agent.config[config_key])
+          else
+            true
+          end
+        end
+
+        def sampler_classes
+          @sampler_classes
+        end
+
+      end
+
+      def initialize(id = nil)
+        @id = id || self.class.name
+      end
+
+      def poll
+        raise "Implement in the subclass"
+      end
+
+      class Unsupported < StandardError;  end
+    end
+  end
+end

data/lib/one_apm/agent/sampler_collection.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    class SamplerCollection
+      include Enumerable
+
+      def initialize(event_listener)
+        @samplers = []
+        @event_listener = event_listener
+        @event_listener.subscribe(:before_harvest) { poll_samplers }
+      end
+
+      def each(&blk)
+        @samplers.each(&blk)
+      end
+
+      def clear()
+        @samplers.clear
+      end
+
+      def sampler_class_registered?(sampler_class)
+        self.any? { |s| s.class == sampler_class }
+      end
+
+      # adds samplers to the sampler collection so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses OneApm::Agent::Sampler
+      def load_samplers
+        Sampler.sampler_classes.each do |subclass|
+          add_sampler(subclass)
+        end
+      end
+
+      def poll_samplers
+        @samplers.delete_if do |sampler|
+          begin
+            sampler.poll
+            false
+          rescue => e
+            ::OneApm::Agent.logger.warn("Removing #{sampler} from list", e)
+            true # remove the bad sampler
+          end
+        end
+      end
+
+      def add_sampler(sampler_class)
+        supported = sampler_class.supported_on_this_platform?
+        enabled   = sampler_class.enabled?
+        if supported && enabled && !sampler_class_registered?(sampler_class)
+          sampler = sampler_class.new
+          sampler.setup_events(@event_listener) if sampler.respond_to?(:setup_events)
+          @samplers << sampler
+          ::OneApm::Agent.logger.debug("Registered #{sampler_class.name} for harvest time sampling.")
+        else
+          ::OneApm::Agent.logger.debug("#{sampler_class.name} not supported on this platform.")
+        end
+      rescue OneApm::Agent::Sampler::Unsupported => e
+        ::OneApm::Agent.logger.info("#{sampler_class.name} not available: #{e}")
+      rescue => e
+        ::OneApm::Agent.logger.error("Error registering sampler:", e)
+      end
+    end
+  end
+end

data/lib/one_apm/agent/samplers/cpu_sampler.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'one_apm/agent/sampler'
+
+module OneApm
+  module Agent
+    module Samplers
+      class CpuSampler < OneApm::Agent::Sampler
+        attr_reader :last_time
+
+        named :cpu
+
+        def initialize
+          @processor_count = OneApm::Agent::SystemInfo.num_logical_processors
+          poll
+        end
+
+        def self.supported_on_this_platform?
+          # Process.times on JRuby < 1.7.0 reports wall clock elapsed time, not actual cpu time used
+          defined?(JRuby) ? (JRUBY_VERSION >= '1.7.0') : true
+        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
+
+            usertime = t.utime - @last_utime
+            systemtime = t.stime - @last_stime
+
+            if systemtime >= 0
+              OneApm::Agent.record_metric("CPU/System Time", systemtime)
+              OneApm::Agent.record_metric("CPU/System/Utilization", systemtime / (elapsed * @processor_count))
+            end
+            if usertime >= 0
+              OneApm::Agent.record_metric("CPU/User Time", usertime)
+              OneApm::Agent.record_metric("CPU/User/Utilization", usertime / (elapsed * @processor_count))
+            end
+          end
+          @last_utime = t.utime
+          @last_stime = t.stime
+          @last_time = now
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+require 'one_apm/agent/sampler'
+require 'one_apm/inst/background_job/delayed_job_injection'
+
+module OneApm
+  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 < OneApm::Agent::Sampler
+        named :delayed_job
+
+        # DelayedJob supports multiple backends, only some of which we can
+        # handle. Check whether we think we've got what we need here.
+        def self.supported_backend?
+          ::Delayed::Worker.backend.to_s == "Delayed::Backend::ActiveRecord::Job"
+        end
+
+        def initialize
+          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:disable_dj]
+          raise Unsupported, "DJ queue sampling unsupported with backend '#{::Delayed::Worker.backend}'" unless self.class.supported_backend?
+          raise Unsupported, "No DJ worker present. Skipping DJ queue sampler" unless OneApm::DelayedJobInjection.worker_name
+        end
+
+        def record_failed_jobs(value)
+          OneApm::Agent.record_metric("Workers/DelayedJob/failed_jobs", value)
+        end
+
+        def record_locked_jobs(value)
+          OneApm::Agent.record_metric("Workers/DelayedJob/locked_jobs", value)
+        end
+
+        FAILED_QUERY = 'failed_at is not NULL'.freeze
+        LOCKED_QUERY = 'locked_by is not NULL'.freeze
+
+        def failed_jobs
+          count(FAILED_QUERY)
+        end
+
+        def locked_jobs
+          count(LOCKED_QUERY)
+        end
+
+        def count(query)
+          if ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            ::Delayed::Job.count(query)
+          else
+            ::Delayed::Job.where(query).count
+          end
+        end
+
+        def self.supported_on_this_platform?
+          defined?(::Delayed::Job)
+        end
+
+        def poll
+          record_failed_jobs(failed_jobs)
+          record_locked_jobs(locked_jobs)
+          record_queue_length_metrics
+        end
+
+        private
+
+        def record_queue_length_metrics
+          counts = []
+          counts << record_counts_by("queue", "name") if ::Delayed::Job.instance_methods.include?(:queue)
+          counts << record_counts_by("priority")
+
+          all_metric = "Workers/DelayedJob/queue_length/all"
+          OneApm::Agent.record_metric(all_metric, counts.max)
+        end
+
+        QUEUE_QUERY_CONDITION = 'run_at <= ? and failed_at is NULL'.freeze
+
+        def record_counts_by(column_name, metric_segment = column_name)
+          all_count = 0
+          queue_counts(column_name).each do |column_val, count|
+            all_count += count
+            column_val = "default" if column_val.nil? || column_val == ""
+            metric = "Workers/DelayedJob/queue_length/#{metric_segment}/#{column_val}"
+            OneApm::Agent.record_metric(metric, count)
+          end
+          all_count
+        end
+
+        def queue_counts(column_name)
+          now = ::Delayed::Job.db_time_now
+          # There is not an ActiveRecord syntax for what we're trying to do
+          # here that's valid on 2.x through 4.1, so split it up.
+          result = if ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            ::Delayed::Job.count(:group => column_name,
+                                 :conditions => [QUEUE_QUERY_CONDITION, now])
+          else
+            ::Delayed::Job.where(QUEUE_QUERY_CONDITION, now).
+                           group(column_name).
+                           count
+          end
+          result.to_a
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+require 'one_apm/agent/sampler'
+
+module OneApm
+  module Agent
+    module Samplers
+
+      class MemorySampler < OneApm::Agent::Sampler
+        named :memory
+
+        attr_accessor :sampler
+
+        def initialize
+          # macos, linux, solaris
+          if defined? JRuby
+            @sampler = JavaHeapSampler.new
+          elsif platform =~ /linux/
+            @sampler = ProcStatus.new
+            if !@sampler.can_run?
+              ::OneApm::Agent.logger.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
+              @sampler = ShellPS.new("ps -o rsz")
+            else
+              ::OneApm::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
+          OneApm::Agent::Samplers::MemorySampler.platform
+        end
+
+        def poll
+          sample = @sampler.get_sample
+          if sample
+            OneApm::Agent.record_metric("Memory/Used", sample)
+          end
+        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?
+                ::OneApm::Agent.logger.warn "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+                @broken = true
+              end
+              return m
+            rescue => e
+              ::OneApm::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