scout_apm 3.0.0.pre28 → 4.0.0

data/lib/scout_apm/agent.rb

@@ -37,10 +37,13 @@ module ScoutApm
 
       logger.info "Scout Agent [#{ScoutApm::VERSION}] Initialized"
 
-      instrument_manager.install! if should_load_instruments? || force
-
-      install_background_job_integrations
-      install_app_server_integration
+      if should_load_instruments? || force
+        instrument_manager.install!
+        install_background_job_integrations
+        install_app_server_integration
+      else
+        logger.info "Not Loading Instruments"
+      end
 
       logger.info "Scout Agent [#{ScoutApm::VERSION}] Installed"
 
@@ -63,6 +66,7 @@ module ScoutApm
 
       if context.started?
         start_background_worker unless background_worker_running?
+        start_error_service_background_worker unless error_service_background_worker_running?
         return
       end
 
@@ -78,6 +82,7 @@ module ScoutApm
       @app_server_load ||= AppServerLoad.new(context).run
 
       start_background_worker
+      start_error_service_background_worker
     end
 
     def instrument_manager
@@ -165,12 +170,6 @@ module ScoutApm
 
       ScoutApm::Agent::ExitHandler.new(context).install
 
-      if context.config.value('profile')
-        # After we fork, setup the handlers here.
-        ScoutApm::Instruments::Stacks.install
-        ScoutApm::Instruments::Stacks.start
-      end
-
       periodic_work = ScoutApm::PeriodicWork.new(context)
 
       @background_worker = ScoutApm::BackgroundWorker.new(context)
@@ -201,5 +200,25 @@ module ScoutApm
         @background_worker               &&
         @background_worker.running?
     end
+
+    # seconds to batch error reports
+    ERROR_SEND_FREQUENCY = 5
+    def start_error_service_background_worker
+      periodic_work = ScoutApm::ErrorService::PeriodicWork.new(context)
+
+      @error_service_background_worker = ScoutApm::BackgroundWorker.new(context, ERROR_SEND_FREQUENCY)
+      @error_service_background_worker_thread = Thread.new do
+        @error_service_background_worker.start { 
+          periodic_work.run
+        }
+      end
+    end
+
+    def error_service_background_worker_running?
+      @error_service_background_worker_thread          &&
+        @error_service_background_worker_thread.alive? &&
+        @error_service_background_worker               &&
+        @error_service_background_worker.running?
+    end
   end
 end

data/lib/scout_apm/agent/exit_handler.rb

@@ -35,7 +35,6 @@ module ScoutApm
         logger.info "Shutting down ScoutApm"
         return if !context.started?
         context.shutting_down!
-        ScoutApm::Instruments::Stacks.uninstall
         ::ScoutApm::Agent.instance.stop_background_worker
       end
 

data/lib/scout_apm/agent_context.rb

@@ -96,11 +96,18 @@ module ScoutApm
     end
 
     def slow_request_policy
-      @slow_request_policy ||= ScoutApm::SlowRequestPolicy.new(self)
+      @slow_request_policy ||= ScoutApm::SlowRequestPolicy.new(self).tap{|p| p.add_default_policies }
     end
 
     def slow_job_policy
-      @slow_job_policy ||= ScoutApm::SlowJobPolicy.new(self)
+      @slow_job_policy ||= ScoutApm::SlowRequestPolicy.new(self).tap{|p| p.add_default_policies }
+    end
+
+    # Maintains a Histogram of insignificant/significant autoinstrument layers.
+    # significant = 1
+    # insignificant = 0
+    def auto_instruments_layer_histograms
+      @auto_instruments_layer_histograms ||= ScoutApm::RequestHistograms.new
     end
 
     # Histogram of the cumulative requests since the start of the process
@@ -135,6 +142,18 @@ module ScoutApm
       config.value('dev_trace') && environment.env == "development"
     end
 
+    ###################
+    #  Error Service  #
+    ###################
+
+    def error_buffer
+      @error_buffer ||= ScoutApm::ErrorService::ErrorBuffer.new(self)
+    end
+
+    def ignored_exceptions
+      @ignored_exceptions ||= ScoutApm::ErrorService::IgnoredExceptions.new(self, config.value('errors_ignored_exceptions'))
+    end
+
     #############
     #  Setters  #
     #############
@@ -205,7 +224,7 @@ module ScoutApm
       if !@config.any_keys_found?
         logger.info("No configuration file loaded, and no configuration found in ENV. " +
                     "For assistance configuring Scout, visit " +
-                    "http://help.apm.scoutapp.com/#configuration-options")
+                    "https://docs.scoutapm.com/#ruby-configuration-options")
       end
     end
   end

data/lib/scout_apm/app_server_load.rb

@@ -29,12 +29,17 @@ module ScoutApm
     end
 
     def data
-      { :server_time        => to_s_safe(Time.now),
+      { 
+        :language           => 'ruby',
+        :language_version   => RUBY_VERSION,
+        :ruby_version       => RUBY_VERSION, # Deprecated.
+
         :framework          => to_s_safe(environment.framework_integration.human_name),
         :framework_version  => to_s_safe(environment.framework_integration.version),
+
+        :server_time        => to_s_safe(Time.now),
         :environment        => to_s_safe(environment.framework_integration.env),
         :app_server         => to_s_safe(environment.app_server),
-        :ruby_version       => RUBY_VERSION,
         :hostname           => to_s_safe(environment.hostname),
         :database_engine    => to_s_safe(environment.database_engine),      # Detected
         :database_adapter   => to_s_safe(environment.raw_database_adapter), # Raw

data/lib/scout_apm/attribute_arranger.rb

@@ -5,8 +5,6 @@ module ScoutApm
     def self.call(subject, attributes_list)
       attributes_list.inject({}) do |attribute_hash, attribute|
         case attribute
-        when :traces
-          attribute_hash[attribute] = subject.traces.to_a
         when Array
           attribute_hash[attribute[0]] = subject.send(attribute[1])
         when :bucket

data/lib/scout_apm/auto_instrument.rb

@@ -0,0 +1,5 @@
+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/auto_instrument/instruction_sequence.rb

@@ -0,0 +1,31 @@
+
+require 'scout_apm/auto_instrument/rails'
+
+module ScoutApm
+  module AutoInstrument
+    module InstructionSequence
+      def load_iseq(path)
+        if Rails.controller_path?(path) & !Rails.ignore?(path)
+          begin
+            new_code = Rails.rewrite(path)
+            return self.compile(new_code, path, path)
+          rescue
+            warn "Failed to apply auto-instrumentation to #{path}: #{$!}"
+          end
+        elsif Rails.ignore?(path)
+          warn "AutoInstruments are ignored for path=#{path}."
+        end
+
+        return self.compile_file(path)
+      end
+    end
+
+    # This should work (https://bugs.ruby-lang.org/issues/15572), but it doesn't.
+    # RubyVM::InstructionSequence.extend(InstructionSequence)
+
+    # So we do this instead:
+    class << ::RubyVM::InstructionSequence
+      prepend InstructionSequence
+    end
+  end
+end

data/lib/scout_apm/auto_instrument/layer.rb

@@ -0,0 +1,23 @@
+
+module ScoutApm
+  def self.AutoInstrument(name, backtrace)
+    request = ScoutApm::RequestManager.lookup
+
+    file_name, _ = backtrace.first.split(":", 2)
+
+    begin
+      layer = ScoutApm::Layer.new('AutoInstrument', name)
+      layer.backtrace = backtrace
+      layer.file_name = file_name
+
+      request.start_layer(layer)
+      started_layer = true
+
+      result = yield
+    ensure
+      request.stop_layer if started_layer
+    end
+
+    return result
+  end
+end

data/lib/scout_apm/auto_instrument/parser.rb

@@ -0,0 +1,27 @@
+
+require 'parser/current'
+raise LoadError, "Parser::TreeRewriter was not defined" unless defined?(Parser::TreeRewriter)
+
+module ScoutApm
+  module AutoInstrument
+    class Cache
+      def initialize
+        @local_assignments = {}
+      end
+      
+      def local_assignments?(node)
+        unless @local_assignments.key?(node)
+          if node.type == :lvasgn
+            @local_assignments[node] = true
+          elsif node.children.find{|child| child.is_a?(Parser::AST::Node) && self.local_assignments?(child)}
+            @local_assignments[node] = true
+          else
+            @local_assignments[node] = false
+          end
+        end
+        
+        return @local_assignments[node]
+      end
+    end
+  end
+end

data/lib/scout_apm/auto_instrument/rails.rb

@@ -0,0 +1,175 @@
+
+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/background_job_integrations/legacy_sneakers.rb

@@ -0,0 +1,55 @@
+# 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