scout_apm 2.1.32 → 2.2.0.pre0

data/ext/rusage/README.md

@@ -1,26 +0,0 @@
-This is a vendored copy of the rusage gem.
-
-
-= rusage
-
-* http://github.com/sandofsky/rusage
-
-== DESCRIPTION:
-
-A gem that calls getrusage to get details on the current process.
-
-Ripped out of the proc/wait3 library, originally written by Daniel J. Berger.
-
-http://raa.ruby-lang.org/project/proc-wait3/
-
-== LICENSE:
-
-Inherits the Artistic License 2.0 from proc/wait3.
-
-== COPYRIGHT:
-
-The original code is still copyright Daniel J. Berger.
-
-rusage gem is copyright Ben Sandofsky.
-
-Code changes after being added to this repository are copyright Zimuth, Inc.

data/ext/rusage/extconf.rb

@@ -1,5 +0,0 @@
-require 'mkmf'
-
-dir_config("rusage")
-
-create_makefile("rusage")

data/ext/rusage/rusage.c

@@ -1,52 +0,0 @@
-// VERSION = "x.y.z"
-#include <ruby.h>
-#include <sys/resource.h>
-
-VALUE v_usage_struct;
-
-static VALUE do_rusage_get(int who){
-  struct rusage r;
-  int ret;
-
-  ret = getrusage(who, &r);
-  if(ret == -1)
-    rb_sys_fail("getrusage");
-
-  return rb_struct_new(v_usage_struct,
-      rb_float_new((double)r.ru_utime.tv_sec+(double)r.ru_utime.tv_usec/1e6),
-      rb_float_new((double)r.ru_stime.tv_sec+(double)r.ru_stime.tv_usec/1e6),
-      LONG2NUM(r.ru_maxrss),
-      LONG2NUM(r.ru_ixrss),
-      LONG2NUM(r.ru_idrss),
-      LONG2NUM(r.ru_isrss),
-      LONG2NUM(r.ru_minflt),
-      LONG2NUM(r.ru_majflt),
-      LONG2NUM(r.ru_nswap),
-      LONG2NUM(r.ru_inblock),
-      LONG2NUM(r.ru_oublock),
-      LONG2NUM(r.ru_msgsnd),
-      LONG2NUM(r.ru_msgrcv),
-      LONG2NUM(r.ru_nsignals),
-      LONG2NUM(r.ru_nvcsw),
-      LONG2NUM(r.ru_nivcsw)
-   );
-}
-
-static VALUE rusage_get(int argc, VALUE* argv, VALUE mod){
-  return do_rusage_get(RUSAGE_SELF);
-}
-
-static VALUE crusage_get(int argc, VALUE* argv, VALUE mod){
-  return do_rusage_get(RUSAGE_CHILDREN);
-}
-
-void Init_rusage(){
-  v_usage_struct =
-     rb_struct_define("RUsage","utime","stime","maxrss","ixrss","idrss",
-        "isrss","minflt","majflt","nswap","inblock","oublock","msgsnd",
-        "msgrcv","nsignals","nvcsw","nivcsw",NULL
-     );
-
-  rb_define_module_function(rb_mProcess, "rusage", rusage_get, -1);
-  rb_define_module_function(rb_mProcess, "crusage", crusage_get, -1);
-}

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -1,85 +0,0 @@
-module ScoutApm
-  module BackgroundJobIntegrations
-    class Resque
-      def name
-        :resque
-      end
-
-      def present?
-        defined?(::Resque) &&
-          ::Resque.respond_to?(:before_first_fork) &&
-          ::Resque.respond_to?(:after_fork)
-      end
-
-      # Lies. This forks really aggressively, but we have to do handling
-      # of it manually here, rather than via any sort of automatic
-      # background worker starting
-      def forking?
-        false
-      end
-
-      def install
-        install_before_fork
-        install_after_fork
-      end
-
-      def install_before_fork
-        ::Resque.before_first_fork do
-          begin
-            ScoutApm::Agent.instance.start(:skip_app_server_check => true)
-            ScoutApm::Agent.instance.start_background_worker
-            ScoutApm::Agent.instance.start_remote_server(bind, port)
-          rescue Errno::EADDRINUSE
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
-          rescue => e
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
-          end
-        end
-      end
-
-      def install_after_fork
-        ::Resque.after_fork do
-          begin
-            ScoutApm::Agent.instance.use_remote_recorder(bind, port)
-            inject_job_instrument
-          rescue => e
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
-          end
-        end
-      end
-
-      # Insert ourselves into the point when resque turns a string "TestJob"
-      # into the class constant TestJob, and insert our instrumentation plugin
-      # into that constantized class
-      #
-      # This automates away any need for the user to insert our instrumentation into
-      # each of their jobs
-      def inject_job_instrument
-        ::Resque::Job.class_eval do
-          def payload_class_with_scout_instruments
-            klass = payload_class_without_scout_instruments
-            klass.extend(ScoutApm::Instruments::Resque)
-            klass
-          end
-          alias_method :payload_class_without_scout_instruments, :payload_class
-          alias_method :payload_class, :payload_class_with_scout_instruments
-        end
-      end
-
-      private
-
-      def bind
-        config.value("remote_agent_host")
-      end
-
-      def port
-        config.value("remote_agent_port")
-      end
-
-      def config
-        @config || ScoutApm::Agent.instance.config
-      end
-    end
-  end
-end
-

data/lib/scout_apm/background_recorder.rb

@@ -1,43 +0,0 @@
-# Provide a background thread queue to do the processing of
-# TrackedRequest objects, to remove it from the hot-path of returning a
-# web response
-
-module ScoutApm
-  class BackgroundRecorder
-    attr_reader :queue
-    attr_reader :thread
-    attr_reader :logger
-
-    def initialize(logger)
-      @logger = logger
-      @queue = Queue.new
-    end
-
-    def start
-      logger.info("Starting BackgroundRecorder")
-      @thread = Thread.new(&method(:thread_func))
-      self
-    end
-
-    def stop
-      @thread.kill
-    end
-
-    def record!(request)
-      start unless @thread.alive?
-      @queue.push(request)
-    end
-
-    def thread_func
-      while req = queue.pop
-        begin
-          logger.debug("recording in thread. Queue size: #{queue.size}")
-          # For now, just proxy right back into the TrackedRequest object's record function
-          req.record!
-        rescue => e
-          logger.warn("Error in BackgroundRecorder - #{e.message} : #{e.backtrace}")
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/debug.rb

@@ -1,37 +0,0 @@
-module ScoutApm
-  class Debug
-    # see self.instance
-    @@instance = nil
-
-    def self.instance
-      @@instance ||= new
-    end
-
-    def register_periodic_hook(&hook)
-      @periodic_hooks << hook
-    end
-
-    def call_periodic_hooks
-      @periodic_hooks.each do |hook|
-        begin
-          hook.call
-        rescue => e
-          logger.info("Periodic debug hook failed to run: #{e}\n\t#{e.backtrace.join("\n\t")}")
-        end
-      end
-    rescue
-      # Something went super wrong for the inner rescue to not catch this. Just
-      # swallow the error. The debug tool should never crash the app.
-    end
-
-    private
-
-    def initialize
-      @periodic_hooks = []
-    end
-
-    def logger
-      ScoutApm::Agent.instance.logger
-    end
-  end
-end

data/lib/scout_apm/git_revision.rb

@@ -1,51 +0,0 @@
-module ScoutApm
-  class GitRevision
-
-    attr_accessor :sha
-
-    def initialize
-      @sha = detect
-      ScoutApm::Agent.instance.logger.debug "Detected Git Revision [#{@sha}]"
-    end
-
-    private
-
-    def detect
-      detect_from_env_var    ||
-      detect_from_heroku     ||
-      detect_from_capistrano ||
-      detect_from_git
-    end
-
-    def detect_from_heroku
-      ENV['HEROKU_SLUG_COMMIT']
-    end
-
-    def detect_from_env_var
-      ENV['SCOUT_REVISION_SHA']
-    end
-
-    def detect_from_capistrano
-      version = File.read(File.join(app_root, 'REVISION')).strip
-      # Capistrano 3.0 - 3.1.x
-      version || File.open(File.join(app_root, '..', 'revisions.log')).to_a.last.strip.sub(/.*as release ([0-9]+).*/, '\1')
-    rescue
-      ScoutApm::Agent.instance.logger.debug "Unable to detect Git Revision from Capistrano: #{$!.message}"
-      nil
-    end
-
-    def detect_from_git
-      if File.directory?(".git")
-        `git rev-parse --short HEAD`.strip 
-      end
-    rescue
-      ScoutApm::Agent.instance.logger.debug "Unable to detect Git Revision from Git: #{$!.message}"
-      nil
-    end
-
-    def app_root
-      ScoutApm::Environment.instance.root
-    end
-
-  end
-end

data/lib/scout_apm/instruments/action_view.rb

@@ -1,49 +0,0 @@
-module ScoutApm
-  module Instruments
-    # instrumentation for Rails 3 and Rails 4 is the same.
-    class ActionView
-      attr_reader :logger
-
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
-        @installed = false
-      end
-
-      def installed?
-        @installed
-      end
-
-      def install
-        @installed = true
-
-        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
-          ::ActionView::PartialRenderer.class_eval do
-            include ScoutApm::Tracer
-
-            instrument_method :render_partial,
-              :type => "View",
-              :name => '#{@template.virtual_path rescue "Unknown Partial"}/Rendering',
-              :scope => true
-
-            instrument_method :collection_with_template,
-              :type => "View",
-              :name => '#{@template.virtual_path rescue "Unknown Collection"}/Rendering',
-              :scope => true
-          end
-
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::TemplateRenderer"
-          ::ActionView::TemplateRenderer.class_eval do
-            include ScoutApm::Tracer
-            instrument_method :render_template,
-              :type => "View",
-              :name => '#{args[0].virtual_path rescue "Unknown"}/Rendering',
-              :scope => true
-          end
-        end
-      end
-    end
-  end
-end
-
-

data/lib/scout_apm/instruments/resque.rb

@@ -1,40 +0,0 @@
-module ScoutApm
-  module Instruments
-    module Resque
-      def around_perform_with_scout_instruments(*args)
-        job_name = self.to_s
-        queue = find_queue
-
-        if job_name == "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
-          job_name = args.first["job_class"] rescue job_name
-          queue = args.first["queue_name"] rescue queue_name
-        end
-
-        req = ScoutApm::RequestManager.lookup
-        req.job!
-
-        begin
-          req.start_layer(ScoutApm::Layer.new('Queue', queue))
-          started_queue = true
-          req.start_layer(ScoutApm::Layer.new('Job', job_name))
-          started_job = true
-
-          yield
-        rescue => e
-          req.error!
-          raise
-        ensure
-          req.stop_layer if started_job
-          req.stop_layer if started_queue
-        end
-      end
-
-      def find_queue
-        return @queue if @queue
-        return queue if self.respond_to?(:queue)
-        return "unknown"
-      end
-    end
-  end
-end
-

data/lib/scout_apm/layer_children_set.rb

@@ -1,77 +0,0 @@
-module ScoutApm
-  # A set of children records for any given Layer.  This implements some
-  # rate-limiting logic.
-  #
-  # We store the first `unique_cutoff` count of each layer type. So if cutoff
-  # is 1000, we'd store 1000 HTTP layers, and 1000 ActiveRecord calls, and 1000
-  # of each other layer type. After that, make a LimitedLayer object and store
-  # only aggregate counts and times of future layers of that type. (So the
-  # 1001st an onward of ActiveRecord would get only aggregate times, and
-  # counts, without any detail about the SQL called)
-  #
-  # When the set of children is small, keep them unique
-  # When the set of children gets large enough, stop keeping details
-  #
-  # The next optimization, which is not yet implemented:
-  #   when the set of children gets larger, attempt to merge them without data loss
-  class LayerChildrenSet
-    include Enumerable
-
-    # By default, how many unique children of a type do we store before
-    # flipping over to storing only aggregate info.
-    DEFAULT_UNIQUE_CUTOFF = 2000
-    attr_reader :unique_cutoff
-
-    # The Set of children objects
-    attr_reader :children
-    private :children
-
-    def initialize(unique_cutoff = DEFAULT_UNIQUE_CUTOFF)
-      @children = Hash.new
-      @limited_layers = nil # populated when needed
-      @unique_cutoff = unique_cutoff
-    end
-
-    def child_set(metric_type)
-      children[metric_type] = Set.new if !children.has_key?(metric_type)
-      children[metric_type]
-    end
-
-    # Add a new layer into this set
-    # Only add completed layers - otherwise this will collect up incorrect info
-    # into the created LimitedLayer, since it will "freeze" any current data for
-    # total_call_time and similar methods.
-    def <<(child)
-      metric_type = child.type
-      set = child_set(metric_type)
-
-      if set.size >= unique_cutoff
-        # find limited_layer
-        @limited_layers || init_limited_layers
-        @limited_layers[metric_type].absorb(child)
-      else
-        # we have space just add it
-        set << child
-      end
-    end
-
-    def each
-      children.each do |_type, set|
-        set.each do |child_layer|
-          yield child_layer
-        end
-      end
-
-      if @limited_layers
-        @limited_layers.each do |_type, limited_layer|
-          yield limited_layer
-        end
-      end
-    end
-
-    # hold off initializing this until we know we need it
-    def init_limited_layers
-      @limited_layers ||= Hash.new { |hash, key| hash[key] = LimitedLayer.new(key) }
-    end
-  end
-end