scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/git_revision.rb

@@ -1,59 +0,0 @@
-module ScoutApm
-  class GitRevision
-    attr_accessor :sha
-
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-      @sha = detect
-      logger.debug "Detected Git Revision [#{@sha}]"
-    end
-
-    def logger
-      context.logger
-    end
-
-    private
-
-    def detect
-      detect_from_config     ||
-      detect_from_heroku     ||
-      detect_from_capistrano ||
-      detect_from_git
-    end
-
-    def detect_from_heroku
-      ENV['HEROKU_SLUG_COMMIT']
-    end
-
-    # Config will locate the value from:
-    #   ENV variable - SCOUT_REVISION_SHA
-    #   YAML setting - revision_sha
-    def detect_from_config
-      context.config.value('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
-      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
-      logger.debug "Unable to detect Git Revision from Git: #{$!.message}"
-      nil
-    end
-
-    def app_root
-      context.environment.root
-    end
-  end
-end

data/lib/scout_apm/instrument_manager.rb

@@ -1,88 +0,0 @@
-module ScoutApm
-  class InstrumentManager
-    attr_reader :context
-
-    attr_reader :installed_instruments
-
-    def initialize(context)
-      @context = context
-      @installed_instruments = []
-    end
-
-    # Loads the instrumention logic.
-    def install!
-      case framework
-      when :rails then
-        install_instrument(ScoutApm::Instruments::ActionControllerRails2)
-      when :rails3_or_4 then
-        install_instrument(ScoutApm::Instruments::ActionControllerRails3Rails4)
-        install_instrument(ScoutApm::Instruments::RailsRouter)
-
-        if config.value("detailed_middleware")
-          install_instrument(ScoutApm::Instruments::MiddlewareDetailed)
-        else
-          install_instrument(ScoutApm::Instruments::MiddlewareSummary)
-        end
-      end
-
-      install_instrument(ScoutApm::Instruments::ActionView)
-      install_instrument(ScoutApm::Instruments::ActiveRecord)
-      install_instrument(ScoutApm::Instruments::Moped)
-      install_instrument(ScoutApm::Instruments::Mongoid)
-      install_instrument(ScoutApm::Instruments::NetHttp)
-      install_instrument(ScoutApm::Instruments::HttpClient)
-      install_instrument(ScoutApm::Instruments::Memcached)
-      install_instrument(ScoutApm::Instruments::Redis)
-      install_instrument(ScoutApm::Instruments::InfluxDB)
-      install_instrument(ScoutApm::Instruments::Elasticsearch)
-      install_instrument(ScoutApm::Instruments::Grape)
-    rescue
-      logger.warn "Exception loading instruments:"
-      logger.warn $!.message
-      logger.warn $!.backtrace
-    end
-
-    # Allows users to skip individual instruments via the config file
-    def skip_instrument?(instrument_klass)
-      instrument_short_name = instrument_klass.name.split("::").last
-      (config.value("disabled_instruments") || []).include?(instrument_short_name)
-    end
-
-    private
-
-    def install_instrument(instrument_klass)
-      return if already_installed?(instrument_klass)
-
-      if skip_instrument?(instrument_klass)
-        logger.info "Skipping Disabled Instrument: #{instrument_klass} - To re-enable, change `disabled_instruments` key in scout_apm.yml"
-        return
-      end
-
-      instance = instrument_klass.new(context)
-      @installed_instruments << instance
-      instance.install
-    end
-
-    def already_installed?(instrument_klass)
-      @installed_instruments.any? do |already_installed_instrument|
-        instrument_klass === already_installed_instrument
-      end
-    end
-
-    ###################
-    #  Lookup Helpers #
-    ###################
-
-    def logger
-      context.logger
-    end
-
-    def config
-      context.config
-    end
-
-    def framework
-      context.environment.framework
-    end
-  end
-end

data/lib/scout_apm/instruments/action_view.rb

@@ -1,141 +0,0 @@
-# Note, this instrument has the same logic in both Tracer and Module Prepend
-# versions. If you update, be sure you update in both spots.
-#
-# The prepend version was added for Rails 6 support - ActiveRecord prepends on
-# top of PartialRenderer#collection_with_template, which can (and does) cause
-# infinite loops with our alias_method approach.
-#
-# Even though Rails 6 forced us to use a prepend version, it is now used for
-# all Rubies that support it.
-module ScoutApm
-  module Instruments
-    class ActionView
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-        @installed = false
-      end
-
-      def logger
-        context.logger
-      end
-
-      def installed?
-        @installed
-      end
-
-      def prependable?
-        context.environment.supports_module_prepend?
-      end
-
-      def install
-        return unless defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
-
-        if prependable?
-          install_using_prepend
-        else
-          install_using_tracer
-        end
-        @installed = true
-      end
-
-      def install_using_tracer
-        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
-
-        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
-
-      def install_using_prepend
-        logger.info "Instrumenting ActionView::PartialRenderer"
-        ::ActionView::PartialRenderer.prepend(ActionViewPartialRendererInstruments)
-
-        logger.info "Instrumenting ActionView::TemplateRenderer"
-        ::ActionView::TemplateRenderer.prepend(ActionViewTemplateRendererInstruments)
-      end
-
-      module ActionViewPartialRendererInstruments
-        # In Rails 6, the signature changed to pass the view & template args directly, as opposed to through the instance var
-        # New signature is: def render_partial(view, template)
-        def render_partial(*args)
-          req = ScoutApm::RequestManager.lookup
-
-          maybe_template = args[1]
-
-          template_name = @template.virtual_path rescue nil        # Works on Rails 3.2 -> end of Rails 5 series
-          template_name ||= maybe_template.virtual_path rescue nil # Works on Rails 6 -> 6.0.3
-          template_name ||= "Unknown Partial"
-
-          layer_name = template_name + "/Rendering"
-          layer = ScoutApm::Layer.new("View", layer_name)
-          layer.subscopable!
-
-          begin
-            req.start_layer(layer)
-            super(*args)
-          ensure
-            req.stop_layer
-          end
-        end
-
-        def collection_with_template(*args)
-          req = ScoutApm::RequestManager.lookup
-
-          template_name = @template.virtual_path rescue "Unknown Collection"
-          template_name ||= "Unknown Collection"
-          layer_name = template_name + "/Rendering"
-
-          layer = ScoutApm::Layer.new("View", layer_name)
-          layer.subscopable!
-
-          begin
-            req.start_layer(layer)
-            super(*args)
-          ensure
-            req.stop_layer
-          end
-        end
-      end
-
-      module ActionViewTemplateRendererInstruments
-        def render_template(*args)
-          req = ScoutApm::RequestManager.lookup
-
-          template_name = args[0].virtual_path rescue "Unknown"
-          template_name ||= "Unknown"
-          layer_name = template_name + "/Rendering"
-
-          layer = ScoutApm::Layer.new("View", layer_name)
-          layer.subscopable!
-
-          begin
-            req.start_layer(layer)
-            super(*args)
-          ensure
-            req.stop_layer
-          end
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/instruments/http.rb

@@ -1,48 +0,0 @@
-module ScoutApm
-  module Instruments
-    class HTTP
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-        @installed = false
-      end
-
-      def logger
-        context.logger
-      end
-
-      def installed?
-        @installed
-      end
-
-      def install
-        if defined?(::HTTP) && defined?(::HTTP::Client)
-          @installed = true
-
-          logger.info "Instrumenting HTTP::Client"
-
-          ::HTTP::Client.class_eval do
-            include ScoutApm::Tracer
-
-            def request_with_scout_instruments(verb, uri, opts = {})
-              self.class.instrument("HTTP", verb, :ignore_children => true, :desc => request_scout_description(verb, uri)) do
-                request_without_scout_instruments(verb, uri, opts)
-              end
-            end
-
-            def request_scout_description(verb, uri)
-              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
-              (String(uri).split('?').first)[0..(max_length - 1)]
-            rescue
-              ""
-            end
-
-            alias request_without_scout_instruments request
-            alias request request_with_scout_instruments
-          end
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/instruments/memcached.rb

@@ -1,43 +0,0 @@
-module ScoutApm
-  module Instruments
-    class Memcached
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-        @installed = false
-      end
-
-      def logger
-        context.logger
-      end
-
-      def installed?
-        @installed
-      end
-
-      def install
-        if defined?(::Dalli) && defined?(::Dalli::Client)
-          @installed = true
-
-          logger.info "Instrumenting Memcached"
-
-          ::Dalli::Client.class_eval do
-            include ScoutApm::Tracer
-
-            def perform_with_scout_instruments(*args, &block)
-              command = args.first rescue "Unknown"
-
-              self.class.instrument("Memcached", command) do
-                perform_without_scout_instruments(*args, &block)
-              end
-            end
-
-            alias_method :perform_without_scout_instruments, :perform
-            alias_method :perform, :perform_with_scout_instruments
-          end
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/instruments/resque.rb

@@ -1,39 +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
-
-        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/instruments/samplers.rb

@@ -1,11 +0,0 @@
-module ScoutApm
-  module Instruments
-    class Samplers
-      DEFAULT_SAMPLERS = [
-        ScoutApm::Instruments::Process::ProcessCpu,
-        ScoutApm::Instruments::Process::ProcessMemory,
-        ScoutApm::Instruments::PercentileSampler,
-      ]
-    end
-  end
-end

data/lib/scout_apm/layer_children_set.rb

@@ -1,86 +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 or create limited_layer
-        @limited_layers ||= Hash.new 
-        layer = if @limited_layers.has_key?(metric_type)
-                  @limited_layers[metric_type]
-                else
-                  @limited_layers[metric_type] = LimitedLayer.new(metric_type)
-                end
-
-        layer.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
-
-    def length
-      @children.length
-    end
-
-    def size
-      @children.size
-    end
-  end
-end

data/lib/scout_apm/layer_converters/database_converter.rb

@@ -1,70 +0,0 @@
-module ScoutApm
-  module LayerConverters
-    class DatabaseConverter < ConverterBase
-      def initialize(*)
-        super
-        @db_query_metric_set = DbQueryMetricSet.new(context)
-      end
-
-      def register_hooks(walker)
-        super
-
-        return unless scope_layer
-
-        walker.on do |layer|
-          next if skip_layer?(layer)
-          stat = DbQueryMetricStats.new(
-            model_name(layer),
-            operation_name(layer),
-            scope_layer.legacy_metric_name, # controller_scope
-            1,                              # count, this is a single query, so 1
-            layer.total_call_time,
-            records_returned(layer)
-          )
-          @db_query_metric_set << stat
-        end
-      end
-
-      def record!
-        # Everything in the metric set here is from a single transaction, which
-        # we want to keep track of. (One web call did a User#find 10 times, but
-        # only due to 1 http request)
-        @db_query_metric_set.increment_transaction_count!
-        @store.track_db_query_metrics!(@db_query_metric_set)
-
-        nil # not returning anything in the layer results ... not used
-      end
-
-      def skip_layer?(layer)
-        layer.type != 'ActiveRecord' ||
-          layer.limited? ||
-          super
-      end
-
-      private
-
-
-      # If we can't name the model, default to:
-      DEFAULT_MODEL = "SQL"
-
-      # If we can't name the operation, default to:
-      DEFAULT_OPERATION = "other"
-
-      def model_name(layer)
-        layer.name.to_s.split("/").first || DEFAULT_MODEL
-      end
-
-      def operation_name(layer)
-        layer.name.to_s.split("/")[1] || DEFAULT_OPERATION
-      end
-
-      def records_returned(layer)
-        if layer.annotations
-          layer.annotations.fetch(:record_count, 0)
-        else
-          0
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/layer_converters/find_layer_by_type.rb

@@ -1,38 +0,0 @@
-# Scope is determined by the first Controller we hit.  Most of the time
-# there will only be 1 anyway.  But if you have a controller that calls
-# another controller method, we may pick that up:
-#     def update
-#       show
-#       render :update
-#     end
-module ScoutApm
-  module LayerConverters
-    class FindLayerByType
-      def initialize(request)
-        @request = request
-      end
-
-      def scope
-        @scope ||= call(["Controller", "Job"])
-      end
-
-      def controller
-        @controller ||= call(["Controller"])
-      end
-
-      def job
-        @job ||= call(["Job"])
-      end
-
-      def queue
-        @queue ||= call(["Queue"])
-      end
-
-      def call(layer_types)
-        walker = DepthFirstWalker.new(@request.root_layer)
-        walker.on {|l| return l if layer_types.include?(l.type) }
-        walker.walk
-      end
-    end
-  end
-end

data/lib/scout_apm/layer_converters/histograms.rb

@@ -1,15 +0,0 @@
-module ScoutApm
-  module LayerConverters
-    class Histograms < ConverterBase
-      # Updates immediate and long-term histograms for both job and web requests
-      def record!
-        if request.unique_name != :unknown
-          context.request_histograms.add(request.unique_name, root_layer.total_call_time)
-          context.request_histograms_by_time[@store.current_timestamp].
-            add(request.unique_name, root_layer.total_call_time)
-        end
-        nil # not returning anything in the layer results ... not used
-      end
-    end
-  end
-end