scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/auto_instrument/rails.rb

@@ -1,175 +0,0 @@
-
-require 'scout_apm/auto_instrument/layer'
-require 'scout_apm/auto_instrument/parser'
-
-module ScoutApm
-  module AutoInstrument
-    module Rails
-      # A general pattern to match Rails controller files:
-      CONTROLLER_FILE = /\/app\/controllers\/*\/.*_controller.rb$/.freeze
-
-      # Some gems (Devise) provide controllers that match CONTROLLER_FILE pattern.
-      # Try a simple match to see if it's a Gemfile
-      GEM_FILE = /\/gems?\//.freeze
-
-      # Whether the given path is likely to be a Rails controller and not provided by a Gem.
-      def self.controller_path? path
-        CONTROLLER_FILE.match(path) && !GEM_FILE.match(path)
-      end
-
-      # Autoinstruments increases overhead when applied to many code expressions that perform little work.
-      # You can exclude files from autoinstruments via the `auto_instruments_ignore` option.
-      def self.ignore?(path)
-        res = false
-        ScoutApm::Agent.instance.context.config.value('auto_instruments_ignore').each do |ignored_file_name|
-          if path.include?(ignored_file_name)
-            res = true
-            break
-          end
-        end
-        res
-      end
-
-      def self.rewrite(path, code = nil)
-        code ||= File.read(path)
-
-        ast = ::Parser::CurrentRuby.parse(code)
-
-        # pp ast
-
-        buffer = ::Parser::Source::Buffer.new(path)
-        buffer.source = code
-
-        rewriter = Rewriter.new
-
-        # Rewrite the AST, returns a String with the new form.
-        rewriter.rewrite(buffer, ast)
-      end
-
-      class Rewriter < ::Parser::TreeRewriter
-        def initialize
-          super
-
-          # Keeps track of the parent - child relationship between nodes:
-          @nesting = []
-
-          # The stack of method nodes (type :def):
-          @method = []
-
-          # The stack of class nodes:
-          @scope = []
-
-          @cache = Cache.new
-        end
-
-        def instrument(source, file_name, line)
-          # Don't log huge chunks of code... just the first line:
-          if lines = source.lines and lines.count > 1
-            source = lines.first.chomp + "..."
-          end
-
-          method_name = @method.last.children[0]
-          class_name = @scope.last.children[1]
-          bt = ["#{file_name}:#{line}:in `#{method_name}'"]
-
-          return [
-            "::ScoutApm::AutoInstrument("+ source.dump + ",#{bt}){",
-            "}"
-          ]
-        end
-
-        # Look up 1 or more nodes to check if the parent exists and matches the given type.
-        # @param type [Symbol] the symbol type to match.
-        # @param up [Integer] how far up to look.
-        def parent_type?(type, up = 1)
-          parent = @nesting[@nesting.size - up - 1] and parent.type == type
-        end
-
-        def on_block(node)
-          # If we are not in a method, don't do any instrumentation:
-          return if @method.empty?
-
-          line = node.location.line || 'line?'
-          column = node.location.column || 'column?' # not used
-          method_name = node.children[0].children[1] || '*unknown*' # not used
-          file_name = @source_rewriter.source_buffer.name
-
-          wrap(node.location.expression, *instrument(node.location.expression.source, file_name, line))
-        end
-
-        def on_mlhs(node)
-          # Ignore / don't instrument multiple assignment (LHS).
-          return
-        end
-
-        def on_op_asgn(node)
-          process(node.children[2])
-        end
-
-        def on_or_asgn(node)
-          process(node.children[1])
-        end
-
-        def on_and_asgn(node)
-          process(node.children[1])
-        end
-
-        # Handle the method call AST node. If this method doesn't call `super`, no futher rewriting is applied to children.
-        def on_send(node)
-          # We aren't interested in top level function calls:
-          return if @method.empty?
-
-          if @cache.local_assignments?(node)
-            return super
-          end
-
-          # This ignores both initial block method invocation `*x*{}`, and subsequent nested invocations `x{*y*}`:
-          return if parent_type?(:block)
-
-          # Extract useful metadata for instrumentation:
-          line = node.location.line || 'line?'
-          column = node.location.column || 'column?' # not used
-          method_name = node.children[1] || '*unknown*' # not used
-          file_name = @source_rewriter.source_buffer.name
-
-          # Wrap the expression with instrumentation:
-          wrap(node.location.expression, *instrument(node.location.expression.source, file_name, line))
-        end
-
-        # def on_class(node)
-        #   class_name = node.children[1]
-        #
-        #   Kernel.const_get(class_name).ancestors.include? ActionController::Controller
-        #
-        #   if class_name =~ /.../
-        #     super # continue processing
-        #   end
-        # end
-
-        # Invoked for every AST node as it is processed top to bottom.
-        def process(node)
-          # We are nesting inside this node:
-          @nesting.push(node)
-
-          if node and node.type == :def
-            # If the node is a method, push it on the method stack as well:
-            @method.push(node)
-            super
-            @method.pop
-          elsif node and node.type == :class
-            @scope.push(node.children[0])
-            super
-            @scope.pop
-          else
-            super
-          end
-
-          @nesting.pop
-        end
-      end
-    end
-  end
-end
-
-# Force any lazy loading to occur here, before we patch iseq_load. Otherwise you might end up in an infinite loop when rewriting code.
-ScoutApm::AutoInstrument::Rails.rewrite('(preload)', '')

data/lib/scout_apm/auto_instrument.rb

@@ -1,5 +0,0 @@
-if RUBY_VERSION >= "2.3"
-  require 'scout_apm/auto_instrument/instruction_sequence'
-else
-  warn "ScoutApm::AutoInstrument requires Ruby >= v2.3. Skipping."
-end

data/lib/scout_apm/background_job_integrations/legacy_sneakers.rb

@@ -1,55 +0,0 @@
-# This is different than other BackgroundJobIntegrations and must be prepended
-# manually in each job.
-#
-# class MyWorker
-#   prepend ScoutApm::BackgroundJobIntegrations::LegacySneakers
-#
-#   def work(msg)
-#     ...
-#   end
-# end
-module ScoutApm
-  module BackgroundJobIntegrations
-    module LegacySneakers
-      UNKNOWN_QUEUE_PLACEHOLDER = 'default'.freeze
-
-      def self.prepended(base)
-        ScoutApm::Agent.instance.logger.info("Prepended LegacySneakers in #{base}")
-      end
-
-      def initialize(*args)
-        super
-
-        # Save off the existing value to call the correct existing work
-        # function in the instrumentation. But then override Sneakers to always
-        # use the extra-argument version, which has data Scout needs
-        @call_work = respond_to?(:work)
-      end
-
-      def work_with_params(msg, delivery_info, metadata)
-        queue = delivery_info[:routing_key] || UNKNOWN_QUEUE_PLACEHOLDER
-        job_class = self.class.name
-        req = ScoutApm::RequestManager.lookup
-
-        begin
-          req.start_layer(ScoutApm::Layer.new('Queue', queue))
-          started_queue = true
-          req.start_layer(ScoutApm::Layer.new('Job', job_class))
-          started_job = true
-
-          if @call_work
-            work(msg)
-          else
-            super
-          end
-        rescue Exception
-          req.error!
-          raise
-        ensure
-          req.stop_layer if started_job
-          req.stop_layer if started_queue
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/background_job_integrations/que.rb

@@ -1,134 +0,0 @@
-module ScoutApm
-  module BackgroundJobIntegrations
-    class Que
-
-      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper'.freeze
-      UNKNOWN_QUEUE_PLACEHOLDER = 'UnknownQueue'.freeze
-
-      attr_reader :logger
-
-      def name
-        :que
-      end
-
-      def present?
-        if defined?(::Que) && File.basename($PROGRAM_NAME).start_with?('que')
-          # 0.x releases used "Version" constant.
-          # 1.x releases used "VERSION" constant.
-          return defined?(::Que::Version)
-        end
-      end
-
-      def forking?
-        false
-      end
-
-      def install
-        install_tracer
-        install_worker
-        install_job
-      end
-
-      def install_tracer
-        ::Que::Job.class_eval do
-          include ScoutApm::Tracer
-        end
-      end
-
-      def install_worker
-        ::Que::Worker.class_eval do
-          def initialize_with_scout(*args)
-            agent = ::ScoutApm::Agent.instance
-            agent.start
-            initialize_without_scout(*args)
-          end
-
-          alias_method :initialize_without_scout, :initialize
-          alias_method :initialize, :initialize_with_scout
-        end
-      end
-
-      def install_job
-        ::Que::Job.class_eval do
-          # attrs = {
-          #   "queue"=>"",
-          #   "priority"=>100,
-          #   "run_at"=>2018-12-19 15:12:32 -0700,
-          #   "job_id"=>4,
-          #   "job_class"=>"ExampleJob",
-          #   "args"=>[{"key"=>"value"}],
-          #   "error_count"=>0
-          # }
-          #
-          # With ActiveJob, v0.14.3:
-          # attrs = {
-          #   "queue"=>"",
-          #   "priority"=>100,
-          #   "run_at"=>2018-12-19 15:29:18 -0700,
-          #   "job_id"=>6,
-          #   "job_class"=>"ActiveJob::QueueAdapters::QueAdapter::JobWrapper",
-          #   "args"=> [{
-          #     "job_class"=>"ExampleJob",
-          #     "job_id"=>"60798b45-4b55-436e-806d-693939266c97",
-          #     "provider_job_id"=>nil,
-          #     "queue_name"=>"default",
-          #     "priority"=>nil,
-          #     "arguments"=>[],
-          #     "executions"=>0,
-          #     "locale"=>"en"
-          #   }],
-          #   "error_count"=>0
-          # }
-          #
-          # With ActiveJob, v1.0:
-          #   There are changes here to make Que more compatible with ActiveJob
-          #   and this probably needs to be revisited.
-
-          def _run_with_scout(*args)
-            # default queue unless specifed is a blank string
-            queue = attrs['queue'] || UNKNOWN_QUEUE_PLACEHOLDER
-
-            job_class = begin
-                          if self.class == ActiveJob::QueueAdapters::QueAdapter::JobWrapper
-                            Array(attrs['args']).first['job_class'] || UNKNOWN_CLASS_PLACEHOLDER
-                          else
-                            self.class.name
-                          end
-                        rescue => e
-                          UNKNOWN_CLASS_PLACEHOLDER
-                        end
-
-            latency = begin
-                        Time.now - attrs['run_at']
-                      rescue
-                        0
-                      end
-
-            req = ScoutApm::RequestManager.lookup
-            req.annotate_request(:queue_latency => latency)
-
-            begin
-              req.start_layer(ScoutApm::Layer.new('Queue', queue))
-              started_queue = true
-              req.start_layer(ScoutApm::Layer.new('Job', job_class))
-              started_job = true
-
-              _run_without_scout(*args)
-            rescue Exception => e
-              req.error!
-              raise
-            ensure
-              req.stop_layer if started_job
-              req.stop_layer if started_queue
-            end
-          end
-
-          alias_method :_run_without_scout, :_run
-          alias_method :_run, :_run_with_scout
-        end
-      end
-    end
-
-  end
-end

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -1,88 +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
-            if ScoutApm::Agent.instance.context.config.value('start_resque_server_instrument')
-              ScoutApm::Agent.instance.start
-              ScoutApm::Agent.instance.context.start_remote_server!(bind, port)
-            else
-              logger.info("Not starting remote server due to 'start_resque_server_instrument' setting")
-            end
-          rescue Errno::EADDRINUSE
-            ScoutApm::Agent.instance.context.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.context.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.context.become_remote_client!(bind, port)
-            inject_job_instrument
-          rescue => e
-            ScoutApm::Agent.instance.context.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.context.config
-      end
-    end
-  end
-end
-

data/lib/scout_apm/background_job_integrations/shoryuken.rb

@@ -1,124 +0,0 @@
-module ScoutApm
-  module BackgroundJobIntegrations
-    class Shoryuken
-      attr_reader :logger
-
-      def name
-        :shoryuken
-      end
-
-      def present?
-        defined?(::Shoryuken) && File.basename($PROGRAM_NAME).start_with?('shoryuken')
-      end
-
-      def forking?
-        false
-      end
-
-      def install
-        install_tracer
-        add_middleware
-        install_processor
-      end
-
-      def install_tracer
-        # ScoutApm::Tracer is not available when this class is defined
-        ShoryukenMiddleware.class_eval do
-          include ScoutApm::Tracer
-        end
-      end
-
-      def add_middleware
-        ::Shoryuken.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.add ShoryukenMiddleware
-          end
-        end
-      end
-
-      def install_processor
-        require 'shoryuken/processor' # sidekiq v4 has not loaded this file by this point
-
-        ::Shoryuken::Processor.class_eval do
-          def initialize_with_scout(*args)
-            agent = ::ScoutApm::Agent.instance
-            agent.start
-            initialize_without_scout(*args)
-          end
-
-          alias_method :initialize_without_scout, :initialize
-          alias_method :initialize, :initialize_with_scout
-        end
-      end
-    end
-
-    # We insert this middleware into the Shoryuken stack, to capture each job,
-    # and time them.
-    class ShoryukenMiddleware
-      def call(worker_instance, queue, msg, body)
-        job_class =
-          begin
-            if worker_instance.class.to_s == ACTIVE_JOB_KLASS
-              body["job_class"]
-            else
-              worker_instance.class.to_s
-            end
-          rescue
-            UNKNOWN_CLASS_PLACEHOLDER
-          end
-
-        req = ScoutApm::RequestManager.lookup
-        req.annotate_request(:queue_latency => latency(msg))
-
-        begin
-          req.start_layer(ScoutApm::Layer.new('Queue', queue))
-          started_queue = true
-          req.start_layer(ScoutApm::Layer.new('Job', job_class))
-          started_job = true
-
-          yield
-        rescue Exception => e
-          req.error!
-          raise
-        ensure
-          req.stop_layer if started_job
-          req.stop_layer if started_queue
-        end
-      end
-
-      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper'.freeze
-
-      def latency(msg, time = Time.now.to_f)
-        ms_since_epoch_str = msg.attributes.fetch('SentTimestamp', 0)
-        return 0 if ms_since_epoch_str.nil?
-
-        # Convert from ms to seconds as a float
-        created_at = ms_since_epoch_str.to_i / 1000.0
-
-        time - created_at
-      rescue => e
-        0
-      end
-    end
-  end
-end
-
-# MSG: #<Shoryuken::Message:0x007fb742a96950 @client=#<Aws::SQS::Client>
-# @data=#<struct Aws::SQS::Types::Message message_id="7a2ef0af-2bbd-4368-9c39-34cc89e4da15"
-# receipt_handle="AQEB8YK4+TCyvCM3p0EanmhZiTbBCM6uMeyCn7zibNn+XZcMnjZp2Z8D8yoUs4mMX9vJqlQvaS8gRUGBYG7ciq+BthmEqDWfxbcJ8jN+Vp/PXIyyTgYL3vvlnHcQajDz3H7Bd30UmLu80sqeLSjXXNEiKolcIxdGuIsIdSM4aUEPXsecr5eH7o8pZHcDV+bGcLuE7VbvKRZT3A2HeezW7wWwkYve/wt6asS1bYB+VJurAORY0y26xgCooEMNbs5yqxcnSD/CiNT822hkmw0eHNpTHOjF9WLgxLbkpITnQl1lsfK5TsM/ukE1oB1F9nN5ZkCBVCDeFYJDBAo81VvVV9G16knxyCYzjnmpwhvHg2BqTA56iV6r9KZYbiwOaMPdH5ealKLRnWhFoLOEPNA4yjG1yw=="
-# md5_of_body="8b3be018857a74f9e46b4c6ef3c3f515"
-# body="Unique Person #7532"
-# attributes={"SenderId"=>"AIDAJZXBVF26MLZPE6FOO"
-# "ApproximateFirstReceiveTimestamp"=>"1534873932213"
-# "ApproximateReceiveCount"=>"1"
-# "SentTimestamp"=>"1534873927868"}
-# md5_of_message_attributes="c70f52a6566cf42ec5e61e81877132dd"
-# message_attributes={"shoryuken_class"=>#<struct Aws::SQS::Types::MessageAttributeValue string_value="DummyWorker"
-    # binary_value=nil
-    # string_list_values=[]
-    # binary_list_values=[]
-    # data_type="String">}>
-# @queue_url="https://sqs.us-west-2.amazonaws.com/023109228371/shoryuken_test"
-# @queue_name="shoryuken_test">
-

data/lib/scout_apm/background_job_integrations/sneakers.rb

@@ -1,87 +0,0 @@
-module ScoutApm
-  module BackgroundJobIntegrations
-    class Sneakers
-      def name
-        :sneakers
-      end
-
-      def present?
-        defined?(::Sneakers) && supported_version?
-      end
-      
-      # Only support Sneakers 2.7 and up
-      def supported_version?
-        result = Gem::Version.new(::Sneakers::VERSION) > Gem::Version.new("2.7.0")
-        ScoutApm::Agent.instance.logger.info("Skipping Sneakers instrumentation. Only versions 2.7+ are supported. See docs or contact support@scoutapm.com for instrumentation of older versions.")
-        result
-      rescue
-        ScoutApm::Agent.instance.logger.info("Failed comparing Sneakers Version. Skipping")
-        false
-      end
-
-      def forking?
-        false
-      end
-
-      def install
-        install_worker_override
-      end
-
-      def install_worker_override
-        ::Sneakers::Worker.module_eval do
-          def initialize_with_scout(*args)
-            agent = ::ScoutApm::Agent.instance
-            agent.start
-            initialize_without_scout(*args)
-          end
-
-          alias_method :initialize_without_scout, :initialize
-          alias_method :initialize, :initialize_with_scout
-
-          def process_work_with_scout(*args)
-            delivery_info, _metadata, msg, _handler = args
-
-            queue = delivery_info[:routing_key] || UNKNOWN_QUEUE_PLACEHOLDER
-
-            job_class = begin
-              if self.class == ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper
-                msg["job_class"] || UNKNOWN_CLASS_PLACEHOLDER
-              else
-                self.class.name
-              end
-            rescue => e
-              UNKNOWN_CLASS_PLACEHOLDER
-            end
-
-            req = ScoutApm::RequestManager.lookup
-
-            # RabbitMQ does not store a created-at timestamp
-            # req.annotate_request(:queue_latency => latency(msg))
-
-            begin
-              req.start_layer(ScoutApm::Layer.new('Queue', queue))
-              started_queue = true
-              req.start_layer(ScoutApm::Layer.new('Job', job_class))
-              started_job = true
-
-              process_work_without_scout(*args)
-            rescue Exception => e
-              req.error!
-              raise
-            ensure
-              req.stop_layer if started_job
-              req.stop_layer if started_queue
-            end
-          end
-
-          alias_method :process_work_without_scout, :process_work
-          alias_method :process_work, :process_work_with_scout
-        end
-      end
-
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper'.freeze
-      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
-      UNKNOWN_QUEUE_PLACEHOLDER = 'default'.freeze
-    end
-  end
-end