scout_apm 2.5.3 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef6a530f826be85aee200f178152090c96dc8f2bab731c0f5220fa95a4662f56
-  data.tar.gz: e8ab6688fec666ff02c76a996dff3daf84fa1ca84be19b2666ba13b256f9fa92
+  metadata.gz: a0d5d02cc644b23e02868a9705fba1a15f0250bba5bff1c92eb97efaf04f1d87
+  data.tar.gz: e0f5acef9895941f7d2f327596d1f9eef9f6a3ef374ddced1ee658b2882bc525
 SHA512:
-  metadata.gz: 4b8d53395a108407d445d1c386c1234ddbfa90e7105249ce357d288b92c5c9727a9c110a6e3510a111b6a4a9788f5e5f3a3eaedc532683cecbc09a8261c2f572
-  data.tar.gz: 3a35a76ed54a96df86948ad486d5a86a9dffed67271c5efae229b80a8106c00eb3830be469875cd301f7a262fba34672a8db52a25d4e82cba5105ce80af26dde
+  metadata.gz: 976b31dc166e501368825e07b3377138be135790a23a92fc52681f81d780034641d86496ac0d03dda0639127673d6b1908f5191f966a9193488094a24a7720a7
+  data.tar.gz: 835d1e4f4db51c71a41521f5892e91d1d67c7cd96effc91f684bacbe6fa9e9303e9abdb9b697c75d79d656bab45d9b241b3200ac8203236fb75a07c101f3c5fb

data/.rubocop.yml

@@ -1,6 +1,9 @@
 # Disable all cops by default
 AllCops:
   DisabledByDefault: true
+  Exclude:
+    - 'test/unit/auto_instrument/*'
+    - vendor/bundle/**/*
 
 # 80 is stifling, especially with a few levels of nesting before we even start.
 # So bump it to 100 to keep really long lines from creeping in.

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+# 2.6.0
+
+* Autoinstruments (#247). Disabled by default. Set `auto_instruments: true` to enable.
+
 # 2.5.3
 
 * Add Que support (#265)
@@ -27,7 +31,7 @@
 
 # 2.4.22
 
-* Support Rails 6.0 View Instruments (#251) 
+* Support Rails 6.0 View Instruments (#251)
 * Update documentation URLs (#236)
 
 # 2.4.21
@@ -675,7 +679,7 @@ Big set of features getting merged in for this release.
 
 # 0.1.3
 
-* Adds capacity calculation via "Instance/Capacity" metric. 
+* Adds capacity calculation via "Instance/Capacity" metric.
 * Tweaks tracing to still count a transaction if it results in a 500 error and includes it in accumulated time.
 * Adds per-transaction error tracking (ex: Errors/Controller/widgets/index)
 

data/lib/scout_apm.rb

@@ -196,6 +196,13 @@ if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR
         # Attempt to start right away, this will work best for preloading apps, Unicorn & Puma & similar
         ScoutApm::Agent.instance.install
 
+        if ScoutApm::Agent.instance.context.config.value("auto_instruments")
+          ScoutApm::Agent.instance.context.logger.debug("AutoInstruments is enabled.")
+          require 'scout_apm/auto_instrument'
+        else
+          ScoutApm::Agent.instance.context.logger.debug("AutoInstruments is disabled.")
+        end
+
         # Install the middleware every time in development mode.
         # The middleware is a noop if dev_trace is not enabled in config
         if Rails.env.development?

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,29 @@
+
+require 'scout_apm/auto_instrument/rails'
+
+module ScoutApm
+  module AutoInstrument
+    module InstructionSequence
+      def load_iseq(path)
+        if Rails.controller_path?(path)
+          begin
+            new_code = Rails.rewrite(path)
+            return self.compile(new_code, File.basename(path), path)
+          rescue
+            warn "Failed to apply auto-instrumentation to #{path}: #{$!}"
+          end
+        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,20 @@
+
+module ScoutApm
+  def self.AutoInstrument(name, backtrace = nil)
+    request = ScoutApm::RequestManager.lookup
+
+    begin
+      layer = ScoutApm::Layer.new('AutoInstrument', name)
+      layer.backtrace = backtrace
+
+      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,158 @@
+
+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
+
+      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_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/config.rb

@@ -33,6 +33,7 @@ require 'scout_apm/environment'
 # remote_agent_port - What port to bind the remote webserver to
 # start_resque_server_instrument - Used in special situations with certain Resque installs
 # timeline_traces - true/false to enable sending of of the timeline trace format.
+# auto_instruments - true/false whether to install autoinstruments. Only installed if on a supported Ruby version.
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
@@ -75,7 +76,8 @@ module ScoutApm
         'start_resque_server_instrument',
         'uri_reporting',
         'instrument_http_url_length',
-        'timeline_traces'
+        'timeline_traces',
+        'auto_instruments'
     ]
 
     ################################################################################
@@ -168,7 +170,8 @@ module ScoutApm
       'database_metric_report_limit' => IntegerCoercion.new,
       'instrument_http_url_length' => IntegerCoercion.new,
       'start_resque_server_instrument' => BooleanCoercion.new,
-      'timeline_traces' => BooleanCoercion.new
+      'timeline_traces' => BooleanCoercion.new,
+      'auto_instruments' => BooleanCoercion.new
     }
 
 
@@ -276,7 +279,8 @@ module ScoutApm
         'instrument_http_url_length' => 300,
         'start_resque_server_instrument' => true, # still only starts if Resque is detected
         'collect_remote_ip' => true,
-        'timeline_traces' => true
+        'timeline_traces' => true,
+        'auto_instruments' => false
       }.freeze
 
       def value(key)

data/lib/scout_apm/layer.rb

@@ -36,7 +36,7 @@ module ScoutApm
 
     # If this layer took longer than a fixed amount of time, store the
     # backtrace of where it occurred.
-    attr_reader :backtrace
+    attr_accessor :backtrace
 
     # As we go through a part of a request, instrumentation can store additional data
     # Known Keys:

data/lib/scout_apm/tracked_request.rb

@@ -52,6 +52,10 @@ module ScoutApm
     # see that on Sidekiq.
     REQUEST_TYPES = ["Controller", "Job"]
 
+    # Layers of type 'AutoInstrument' are not recorded if their total_call_time doesn't exceed this threshold.
+    # AutoInstrument layers are frequently of short duration. This throws out this deadweight that is unlikely to be optimized.
+    AUTO_INSTRUMENT_TIMING_THRESHOLD = 5/1_000.0 # units = seconds
+
     def initialize(agent_context, store)
       @agent_context = agent_context
       @store = store #this is passed in so we can use a real store (normal operation) or fake store (instant mode only)
@@ -110,6 +114,9 @@ module ScoutApm
       layer.record_stop_time!
       layer.record_allocations!
 
+      # Must follow layer.record_stop_time! as the total_call_time is used to determine if the layer is significant.
+      return if layer_insignificant?(layer)
+
       @layers[-1].add_child(layer) if @layers.any?
 
       # This must be called before checking if a backtrace should be collected as the call count influences our capture logic.
@@ -150,6 +157,10 @@ module ScoutApm
     def capture_backtrace?(layer)
       return if ignoring_request?
 
+      # A backtrace has already been recorded. This happens with autoinstruments as
+      # the partial backtrace is set when creating the layer.
+      return false if layer.backtrace
+
       # Never capture backtraces for this kind of layer. The backtrace will
       # always be 100% framework code.
       return false if BACKTRACE_BLACKLIST.include?(layer.type)
@@ -169,6 +180,16 @@ module ScoutApm
       false
     end
 
+    def layer_insignificant?(layer)
+      if layer.type == 'AutoInstrument'
+        if layer.total_call_time < AUTO_INSTRUMENT_TIMING_THRESHOLD
+          context.logger.debug("IGNORE LAYER name=#{layer.name} total_call_time=#{layer.total_call_time}")
+          return true
+        end
+      end
+      return false
+    end
+
     # Maintains a lookup Hash of call counts by layer name. Used to determine if we should capture a backtrace.
     def update_call_counts!(layer)
       @call_set[layer.name].update!(layer.desc)

data/lib/scout_apm/utils/backtrace_parser.rb

@@ -11,6 +11,9 @@ module ScoutApm
 
       attr_reader :call_stack
 
+      # call_stack - an +Array+ of calls, typically generated via the +caller+ method. 
+      # Example single line: 
+      # "/Users/dlite/.rvm/rubies/ruby-2.4.5/lib/ruby/2.4.0/irb/workspace.rb:87:in `eval'"
       def initialize(call_stack, root=ScoutApm::Agent.instance.context.environment.root)
         @call_stack = call_stack
         # We can't use a constant as it'd be too early to fetch environment info

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "2.5.3"
+  VERSION = "2.6.0"
 end

data/scout_apm.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake-compiler"
   s.add_development_dependency "addressable"
   s.add_development_dependency "activesupport"
+  s.add_runtime_dependency "parser"
 
   # These are general development dependencies which are used in instrumentation
   # tests. Specific versions are pulled in using specific gemfiles, e.g. 

data/test/unit/auto_instrument/assignments-instrumented.rb

@@ -0,0 +1,26 @@
+
+class Assignments
+  def nested_assignment
+    @email ||= if (email = ::ScoutApm::AutoInstrument("session[\"email\"]",["BACKTRACE"]){session["email"]}).present?
+        ::ScoutApm::AutoInstrument("User.where(email: email).first",["BACKTRACE"]){User.where(email: email).first}
+      else
+        nil
+      end
+  end
+
+  def paginate_collection(coll)
+    page = (::ScoutApm::AutoInstrument("params[:page].present?",["BACKTRACE"]){params[:page].to_i} : 1)
+    per_page = (::ScoutApm::AutoInstrument("params[:per_page].present?",["BACKTRACE"]){params[:per_page].to_i} : 20)
+    pagination, self.collection = ::ScoutApm::AutoInstrument("pagy(...",["BACKTRACE"]){pagy(
+      coll,
+      items: per_page,
+      page: page
+    )}
+    ::ScoutApm::AutoInstrument("headers[PAGINATION_TOTAL_HEADER] = pagination.count.to_s",["BACKTRACE"]){headers[PAGINATION_TOTAL_HEADER] = pagination.count.to_s}
+    ::ScoutApm::AutoInstrument("headers[PAGINATION_TOTAL_PAGES_HEADER] = pagination.pages.to_s",["BACKTRACE"]){headers[PAGINATION_TOTAL_PAGES_HEADER] = pagination.pages.to_s}
+    ::ScoutApm::AutoInstrument("headers[PAGINATION_PER_PAGE_HEADER] = per_page.to_s",["BACKTRACE"]){headers[PAGINATION_PER_PAGE_HEADER] = per_page.to_s}
+    ::ScoutApm::AutoInstrument("headers[PAGINATION_PAGE_HEADER] = pagination.page.to_s",["BACKTRACE"]){headers[PAGINATION_PAGE_HEADER] = pagination.page.to_s}
+    ::ScoutApm::AutoInstrument("headers[PAGINATION_NEXT_PAGE_HEADER] = pagination.next.to_s",["BACKTRACE"]){headers[PAGINATION_NEXT_PAGE_HEADER] = pagination.next.to_s}
+    ::ScoutApm::AutoInstrument("collection",["BACKTRACE"]){collection}
+  end
+end

data/test/unit/auto_instrument/assignments.rb

@@ -0,0 +1,26 @@
+
+class Assignments
+  def nested_assignment
+    @email ||= if (email = session["email"]).present?
+        User.where(email: email).first
+      else
+        nil
+      end
+  end
+
+  def paginate_collection(coll)
+    page = (params[:page].present? ? params[:page].to_i : 1)
+    per_page = (params[:per_page].present? ? params[:per_page].to_i : 20)
+    pagination, self.collection = pagy(
+      coll,
+      items: per_page,
+      page: page
+    )
+    headers[PAGINATION_TOTAL_HEADER] = pagination.count.to_s
+    headers[PAGINATION_TOTAL_PAGES_HEADER] = pagination.pages.to_s
+    headers[PAGINATION_PER_PAGE_HEADER] = per_page.to_s
+    headers[PAGINATION_PAGE_HEADER] = pagination.page.to_s
+    headers[PAGINATION_NEXT_PAGE_HEADER] = pagination.next.to_s
+    collection
+  end
+end

data/test/unit/auto_instrument/controller-ast.txt

@@ -0,0 +1,57 @@
+s(:class,
+  s(:const, nil, :ClientsController),
+  s(:const, nil, :ApplicationController),
+  s(:begin,
+    s(:send, nil, :before_action,
+      s(:sym, :check_authorization)),
+    s(:def, :index,
+      s(:args),
+      s(:if,
+        s(:send,
+          s(:send,
+            s(:send, nil, :params), :[],
+            s(:sym, :status)), :==,
+          s(:str, "activated")),
+        s(:ivasgn, :@clients,
+          s(:send,
+            s(:const, nil, :Client), :activated)),
+        s(:ivasgn, :@clients,
+          s(:send,
+            s(:const, nil, :Client), :inactivated)))),
+    s(:def, :create,
+      s(:args),
+      s(:begin,
+        s(:ivasgn, :@client,
+          s(:send,
+            s(:const, nil, :Client), :new,
+            s(:send,
+              s(:send, nil, :params), :[],
+              s(:sym, :client)))),
+        s(:if,
+          s(:send,
+            s(:ivar, :@client), :save),
+          s(:send, nil, :redirect_to,
+            s(:ivar, :@client)),
+          s(:send, nil, :render,
+            s(:str, "new"))))),
+    s(:def, :edit,
+      s(:args),
+      s(:begin,
+        s(:ivasgn, :@client,
+          s(:send,
+            s(:const, nil, :Client), :new,
+            s(:send,
+              s(:send, nil, :params), :[],
+              s(:sym, :client)))),
+        s(:if,
+          s(:send,
+            s(:send, nil, :request), :post?),
+          s(:block,
+            s(:send,
+              s(:ivar, :@client), :transaction),
+            s(:args),
+            s(:send,
+              s(:ivar, :@client), :update_attributes,
+              s(:send,
+                s(:send, nil, :params), :[],
+                s(:sym, :client)))), nil)))))

data/test/unit/auto_instrument/controller-instrumented.rb

@@ -0,0 +1,49 @@
+
+class ClientsController < ApplicationController
+  before_action :check_authorization
+
+  def index
+    if ::ScoutApm::AutoInstrument("params[:status] == \"activated\"",["BACKTRACE"]){params[:status] == "activated"}
+      @clients = ::ScoutApm::AutoInstrument("Client.activated",["BACKTRACE"]){Client.activated}
+    else
+      @clients = ::ScoutApm::AutoInstrument("Client.inactivated",["BACKTRACE"]){Client.inactivated}
+    end
+  end
+
+  def create
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["BACKTRACE"]){Client.new(params[:client])}
+    if ::ScoutApm::AutoInstrument("@client.save",["BACKTRACE"]){@client.save}
+      ::ScoutApm::AutoInstrument("redirect_to @client",["BACKTRACE"]){redirect_to @client}
+    else
+      # This line overrides the default rendering behavior, which
+      # would have been to render the "create" view.
+      ::ScoutApm::AutoInstrument("render \"new\"",["BACKTRACE"]){render "new"}
+    end
+  end
+
+  def edit
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["BACKTRACE"]){Client.new(params[:client])}
+
+    if ::ScoutApm::AutoInstrument("request.post?",["BACKTRACE"]){request.post?}
+      ::ScoutApm::AutoInstrument("@client.transaction do...",["BACKTRACE"]){@client.transaction do
+        @client.update_attributes(params[:client])
+      end}
+    end
+  end
+
+  def data
+    @clients = ::ScoutApm::AutoInstrument("Client.all",["BACKTRACE"]){Client.all}
+
+    formatter = ::ScoutApm::AutoInstrument("proc do |row|...",["BACKTRACE"]){proc do |row|
+      row.to_json
+    end}
+
+    ::ScoutApm::AutoInstrument("respond_with @clients.each(&formatter).join(\"\\n\"), :content_type => 'application/json; boundary=NL'",["BACKTRACE"]){respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'}
+  end
+  
+  def things
+    x = {}
+    x[:this] ||= 'foo'
+    x[:that] &&= ::ScoutApm::AutoInstrument("'foo'.size",["BACKTRACE"]){'foo'.size}
+  end
+end

data/test/unit/auto_instrument/controller.rb

@@ -0,0 +1,49 @@
+
+class ClientsController < ApplicationController
+  before_action :check_authorization
+
+  def index
+    if params[:status] == "activated"
+      @clients = Client.activated
+    else
+      @clients = Client.inactivated
+    end
+  end
+
+  def create
+    @client = Client.new(params[:client])
+    if @client.save
+      redirect_to @client
+    else
+      # This line overrides the default rendering behavior, which
+      # would have been to render the "create" view.
+      render "new"
+    end
+  end
+
+  def edit
+    @client = Client.new(params[:client])
+
+    if request.post?
+      @client.transaction do
+        @client.update_attributes(params[:client])
+      end
+    end
+  end
+
+  def data
+    @clients = Client.all
+
+    formatter = proc do |row|
+      row.to_json
+    end
+
+    respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'
+  end
+  
+  def things
+    x = {}
+    x[:this] ||= 'foo'
+    x[:that] &&= 'foo'.size
+  end
+end

data/test/unit/auto_instrument/rescue_from-instrumented.rb

@@ -0,0 +1,13 @@
+
+class BrokenController < ApplicationController
+  rescue_from Exception do |e|
+    if e.is_a? Pundit::NotAuthorizedError
+      unauthorized_error
+    elsif e.is_a? ActionController::ParameterMissing
+      error(status: 422, message: e.message)
+    else
+      log_error(e)
+      error message: 'Internal error', exception: e
+    end
+  end
+end

data/test/unit/auto_instrument/rescue_from.rb

@@ -0,0 +1,13 @@
+
+class BrokenController < ApplicationController
+  rescue_from Exception do |e|
+    if e.is_a? Pundit::NotAuthorizedError
+      unauthorized_error
+    elsif e.is_a? ActionController::ParameterMissing
+      error(status: 422, message: e.message)
+    else
+      log_error(e)
+      error message: 'Internal error', exception: e
+    end
+  end
+end

data/test/unit/auto_instrument_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+require 'scout_apm/auto_instrument'
+
+class AutoInstrumentTest < Minitest::Test
+  def source_path(name)
+    File.expand_path("auto_instrument/#{name}.rb", __dir__)
+  end
+
+  def instrumented_path(name)
+    File.expand_path("auto_instrument/#{name}-instrumented.rb", __dir__)
+  end
+
+  def instrumented_source(name)
+    File.read(instrumented_path(name))
+  end
+
+  # Autoinstruments adds a backtrace to each created layer. This is the full path to the
+  # test controller.rb file, which will be different on different environments.
+  # This normalizes backtraces across environments.
+  def normalize_backtrace(string)
+    string.gsub(/\[".+auto_instrument\/.+?:.+?"\]/,'["BACKTRACE"]')
+  end
+
+  # Use this to automatically update the test fixtures.
+  def update_instrumented_source(name)
+    File.write(
+      instrumented_path(name),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path(name)))
+    )
+  end
+
+  def test_controller_rewrite
+    assert_equal instrumented_source("controller"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("controller")))
+
+    # update_instrumented_source("controller")
+  end
+
+  def test_rescue_from_rewrite
+    assert_equal instrumented_source("rescue_from"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("rescue_from")))
+
+    # update_instrumented_source("rescue_from")
+  end
+
+  def test_assignments_rewrite
+    assert_equal instrumented_source("assignments"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("assignments")))
+
+    # update_instrumented_source("assignments")
+  end
+end if defined? ScoutApm::AutoInstrument

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 2.5.3
+  version: 2.6.0
 platform: ruby
 authors:
 - Derek Haynes
@@ -109,6 +109,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -230,6 +244,11 @@ files:
 - lib/scout_apm/agent_context.rb
 - lib/scout_apm/app_server_load.rb
 - lib/scout_apm/attribute_arranger.rb
+- lib/scout_apm/auto_instrument.rb
+- lib/scout_apm/auto_instrument/instruction_sequence.rb
+- lib/scout_apm/auto_instrument/layer.rb
+- lib/scout_apm/auto_instrument/parser.rb
+- lib/scout_apm/auto_instrument/rails.rb
 - lib/scout_apm/background_job_integrations/delayed_job.rb
 - lib/scout_apm/background_job_integrations/que.rb
 - lib/scout_apm/background_job_integrations/resque.rb
@@ -370,6 +389,14 @@ files:
 - test/test_helper.rb
 - test/tmp/README.md
 - test/unit/agent_test.rb
+- test/unit/auto_instrument/assignments-instrumented.rb
+- test/unit/auto_instrument/assignments.rb
+- test/unit/auto_instrument/controller-ast.txt
+- test/unit/auto_instrument/controller-instrumented.rb
+- test/unit/auto_instrument/controller.rb
+- test/unit/auto_instrument/rescue_from-instrumented.rb
+- test/unit/auto_instrument/rescue_from.rb
+- test/unit/auto_instrument_test.rb
 - test/unit/background_job_integrations/sidekiq_test.rb
 - test/unit/config_test.rb
 - test/unit/context_test.rb
@@ -430,7 +457,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby application performance monitoring
@@ -439,6 +466,14 @@ test_files:
 - test/test_helper.rb
 - test/tmp/README.md
 - test/unit/agent_test.rb
+- test/unit/auto_instrument/assignments-instrumented.rb
+- test/unit/auto_instrument/assignments.rb
+- test/unit/auto_instrument/controller-ast.txt
+- test/unit/auto_instrument/controller-instrumented.rb
+- test/unit/auto_instrument/controller.rb
+- test/unit/auto_instrument/rescue_from-instrumented.rb
+- test/unit/auto_instrument/rescue_from.rb
+- test/unit/auto_instrument_test.rb
 - test/unit/background_job_integrations/sidekiq_test.rb
 - test/unit/config_test.rb
 - test/unit/context_test.rb