appmap 0.44.0 → 0.47.1

data/lib/appmap/handler/rails/template.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Handler
+    module Rails
+      class Template
+        LOG = (ENV['APPMAP_TEMPLATE_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+
+        # All the code which is touched by the AppMap is recorded in the classMap.
+        # This duck-typed 'method' is used to represent a view template as a package, 
+        # class, and method in the classMap.
+        # The class name is generated from the template path. The package name is
+        # 'app/views', and the method name is 'render'. The source location of the method
+        # is, of course, the path to the view template.
+        TemplateMethod = Struct.new(:path) do
+          private_instance_methods :path
+          attr_reader :class_name
+ 
+          def initialize(path)
+            super
+
+            @class_name = path.parameterize.underscore
+          end
+  
+          def package
+            'app/views'
+          end
+  
+          def name
+            'render'
+          end
+  
+          def source_location
+            path
+          end
+  
+          def static
+            true
+          end
+  
+          def comment
+            nil
+          end
+  
+          def labels
+            [ 'mvc.template' ]
+          end
+        end
+  
+        # TemplateCall is a type of function call which is specialized to view template rendering. Since
+        # there isn't really a perfect method in Rails to hook, this one is synthesized from the available
+        # information. 
+        class TemplateCall < AppMap::Event::MethodEvent
+          # This is basically the +self+ parameter.
+          attr_reader :render_instance
+          # Path to the view template.
+          attr_accessor :path
+  
+          def initialize(render_instance)
+            super :call
+  
+            AppMap::Event::MethodEvent.build_from_invocation(:call, event: self)
+            @render_instance = render_instance
+          end
+  
+          def static?
+            true
+          end
+    
+          def to_h
+            super.tap do |h|
+              h[:defined_class] = path ? path.parameterize.underscore : 'inline_template'
+              h[:method_id] = 'render'
+              h[:path] = path
+              h[:static] = static?
+              h[:parameters] = []
+              h[:receiver] = {
+                class: AppMap::Event::MethodEvent.best_class_name(render_instance),
+                object_id: render_instance.__id__,
+                value: AppMap::Event::MethodEvent.display_string(render_instance)
+              }
+              h.compact
+            end
+          end
+        end
+ 
+        TEMPLATE_RENDERER = 'appmap.handler.rails.template.renderer'
+
+        # Hooks the ActionView::Resolver methods +find_all+, +find_all_anywhere+. The resolver is used
+        # during template rendering to lookup the template file path from parameters such as the
+        # template name, prefix, and partial (boolean).
+        class ResolverHandler
+          class << self
+            # Handled as a normal function call.
+            def handle_call(defined_class, hook_method, receiver, args)
+              name, prefix, partial = args
+              warn "Resolver: #{{ name: name, prefix: prefix, partial: partial }}" if LOG
+
+              AppMap::Handler::Function.handle_call(defined_class, hook_method, receiver, args)
+            end
+
+            # When the resolver returns, look to see if there is template rendering underway.
+            # If so, populate the template path. In all cases, add a TemplateMethod so that the
+            # template will be recorded in the classMap.
+            def handle_return(call_event_id, elapsed, return_value, exception)
+              renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
+              path_obj = Array(return_value).first
+              
+              warn "Resolver return: #{path_obj}" if LOG
+
+              if path_obj
+                path = if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
+                  path_obj.identifier
+                else
+                  path_obj.inspect
+                end
+                path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
+                AppMap.tracing.record_method(TemplateMethod.new(path))
+                renderer.path ||= path if renderer
+              end
+
+              AppMap::Handler::Function.handle_return(call_event_id, elapsed, return_value, exception)
+            end
+          end
+        end
+
+        # Hooks the ActionView::Renderer method +render+. This method is used by Rails to perform
+        # template rendering. The TemplateCall event which is emitted by this handler has a
+        # +path+ parameter, which is nil until it's filled in by a ResolverHandler. 
+        class RenderHandler
+          class << self
+            def handle_call(defined_class, hook_method, receiver, args)
+              context, options = args
+
+              warn "Renderer: #{options}" if LOG
+
+              TemplateCall.new(receiver).tap do |call|
+                Thread.current[TEMPLATE_RENDERER] ||= []
+                Thread.current[TEMPLATE_RENDERER] << call
+              end
+            end
+  
+            def handle_return(call_event_id, elapsed, return_value, exception)
+              Array(Thread.current[TEMPLATE_RENDERER]).pop
+
+              AppMap::Event::MethodReturnIgnoreValue.build_from_invocation(call_event_id, elapsed: elapsed)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appmap/hook.rb

@@ -5,6 +5,7 @@ require 'English'
 module AppMap
   class Hook
     LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+    LOG_HOOK = (ENV['DEBUG_HOOK'] == 'true')
 
     OBJECT_INSTANCE_METHODS = %i[! != !~ <=> == === =~ __id__ __send__ class clone define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
     OBJECT_STATIC_METHODS = %i[! != !~ < <= <=> == === =~ > >= __id__ __send__ alias_method allocate ancestors attr attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
@@ -35,73 +36,21 @@ module AppMap
 
     def initialize(config)
       @config = config
+      @trace_locations = []
+      # Paths that are known to be non-tracing
+      @notrace_paths = Set.new
     end
 
     # Observe class loading and hook all methods which match the config.
-    def enable &block
+    def enable(&block)
       require 'appmap/hook/method'
 
       hook_builtins
 
-      tp = TracePoint.new(:end) do |trace_point|
-        cls = trace_point.self
+      @trace_begin = TracePoint.new(:class, &method(:trace_class))
+      @trace_end = TracePoint.new(:end, &method(:trace_end))
 
-        instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
-        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
-        class_methods = begin
-          if cls.respond_to?(:singleton_class)
-            cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
-          else
-            []
-          end
-        rescue NameError
-          []
-        end
-
-        hook = lambda do |hook_cls|
-          lambda do |method_id|
-            # Don't try and trace the AppMap methods or there will be
-            # a stack overflow in the defined hook method.
-            return if (hook_cls&.name || '').split('::')[0] == AppMap.name
-
-            method = begin
-              hook_cls.public_instance_method(method_id)
-            rescue NameError
-              warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
-              return
-            end
-
-            warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
-
-            disasm = RubyVM::InstructionSequence.disasm(method)
-            # Skip methods that have no instruction sequence, as they are obviously trivial.
-            next unless disasm
-
-            next if config.never_hook?(method)
-
-            next unless \
-              config.always_hook?(hook_cls, method.name) ||
-              config.included_by_location?(method)
-
-            package = config.package_for_method(method)
-
-            hook_method = Hook::Method.new(package, hook_cls, method)
-
-            hook_method.activate
-          end
-        end
-
-        instance_methods.each(&hook.(cls))
-        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
-        begin
-          class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
-        rescue NameError
-          # NameError:
-          #   uninitialized constant Faraday::Connection
-        end
-      end
-
-      tp.enable(&block)
+      @trace_begin.enable(&block)
     end
 
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
@@ -115,30 +64,119 @@ module AppMap
         end
       end
 
-      config.builtin_methods.each do |class_name, hooks|
+      config.builtin_hooks.each do |class_name, hooks|
         Array(hooks).each do |hook|
           require hook.package.package_name if hook.package.package_name
           Array(hook.method_names).each do |method_name|
             method_name = method_name.to_sym
+            base_cls = class_from_string.(class_name)
 
-            cls = class_from_string.(class_name)
-            method = \
-              begin
-                cls.instance_method(method_name)
-              rescue NameError
-                cls.method(method_name) rescue nil
-              end
-
-            next if config.never_hook?(method)
+            hook_method = lambda do |entry|
+              cls, method = entry
+              return false if config.never_hook?(cls, method)
 
-            if method
               Hook::Method.new(hook.package, cls, method).activate
+            end
+
+            methods = []
+            methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
+            if base_cls.respond_to?(:singleton_class)
+              methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
+            end
+            methods.compact!
+            if methods.empty?
+              warn "Method #{method_name} not found on #{base_cls.name}"
             else
-              warn "Method #{method_name} not found on #{cls.name}"
+              methods.each(&hook_method)
             end
           end
         end
       end
     end
+
+    protected
+
+    def trace_class(trace_point)
+      path = trace_point.path
+
+      return if @notrace_paths.member?(path)
+
+      if config.path_enabled?(path)
+        location = trace_location(trace_point)
+        warn "Entering hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+        @trace_locations << location
+        unless @trace_end.enabled?
+          warn "Enabling hooking" if Hook::LOG || Hook::LOG_HOOK
+          @trace_end.enable
+        end
+      else
+        @notrace_paths << path
+      end
+    end
+
+    def trace_location(trace_point)
+      [ trace_point.path, trace_point.lineno ].join(':')
+    end
+
+    def trace_end(trace_point)
+      cls = trace_point.self
+
+      instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
+      # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
+      class_methods = begin
+        if cls.respond_to?(:singleton_class)
+          cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
+        else
+          []
+        end
+      rescue NameError
+        []
+      end
+
+      hook = lambda do |hook_cls|
+        lambda do |method_id|
+          # Don't try and trace the AppMap methods or there will be
+          # a stack overflow in the defined hook method.
+          next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || '').split('::')[0])
+
+          next if method_id == :call
+
+          method = begin
+            hook_cls.public_instance_method(method_id)
+          rescue NameError
+            warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
+            next
+          end
+
+          warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
+
+          disasm = RubyVM::InstructionSequence.disasm(method)
+          # Skip methods that have no instruction sequence, as they are obviously trivial.
+          next unless disasm
+
+          package = config.lookup_package(hook_cls, method)
+          next unless package
+
+          Hook::Method.new(package, hook_cls, method).activate
+        end
+      end
+
+      instance_methods.each(&hook.(cls))
+      begin
+        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
+        class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
+      rescue NameError
+        # NameError:
+        #   uninitialized constant Faraday::Connection
+        warn "NameError in #{__FILE__}: #{$!.message}"
+      end
+
+      location = @trace_locations.pop
+      warn "Leaving hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+      if @trace_locations.empty?
+        warn "Disabling hooking" if Hook::LOG || Hook::LOG_HOOK
+        @trace_end.disable
+      end
+    end
   end
 end

data/lib/appmap/hook/method.rb

@@ -76,7 +76,7 @@ module AppMap
               raise
             ensure
               with_disabled_hook.call do
-                after_hook.call(self, call_event, start_time, return_value, exception)
+                after_hook.call(self, call_event, start_time, return_value, exception) if call_event
               end
             end
           end
@@ -87,18 +87,16 @@ module AppMap
       protected
 
       def before_hook(receiver, defined_class, args)
-        require 'appmap/event'
-        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
-        AppMap.tracing.record_event call_event, package: hook_package, defined_class: defined_class, method: hook_method
+        call_event = hook_package.handler_class.handle_call(defined_class, hook_method, receiver, args)
+        AppMap.tracing.record_event(call_event, package: hook_package, defined_class: defined_class, method: hook_method) if call_event
         [ call_event, TIME_NOW.call ]
       end
 
       def after_hook(_receiver, call_event, start_time, return_value, exception)
-        require 'appmap/event'
         elapsed = TIME_NOW.call - start_time
-        return_event = \
-          AppMap::Event::MethodReturn.build_from_invocation call_event.id, elapsed, return_value, exception
-        AppMap.tracing.record_event return_event
+        return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
+        AppMap.tracing.record_event(return_event) if return_event
+        nil
       end
 
       def with_disabled_hook(&function)

data/lib/appmap/railtie.rb

@@ -8,12 +8,12 @@ module AppMap
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
     initializer 'appmap.subscribe' do |_| # params: app
-      require 'appmap/rails/sql_handler'
-      require 'appmap/rails/request_handler'
-      ActiveSupport::Notifications.subscribe 'sql.sequel', AppMap::Rails::SQLHandler.new
-      ActiveSupport::Notifications.subscribe 'sql.active_record', AppMap::Rails::SQLHandler.new
+      require 'appmap/handler/rails/sql_handler'
+      require 'appmap/handler/rails/request_handler'
+      ActiveSupport::Notifications.subscribe 'sql.sequel', AppMap::Handler::Rails::SQLHandler.new
+      ActiveSupport::Notifications.subscribe 'sql.active_record', AppMap::Handler::Rails::SQLHandler.new
 
-      AppMap::Rails::RequestHandler::HookMethod.new.activate
+      AppMap::Handler::Rails::RequestHandler::HookMethod.new.activate
     end
 
     # appmap.trace begins recording an AppMap trace and writes it to appmap.json.

data/lib/appmap/trace.rb

@@ -2,14 +2,36 @@
 
 module AppMap
   module Trace
-    class ScopedMethod < SimpleDelegator
-      attr_reader :package, :defined_class, :static
+    class RubyMethod
+      attr_reader :class_name, :static
 
-      def initialize(package, defined_class, method, static)
+      def initialize(package, class_name, method, static)
         @package = package
-        @defined_class = defined_class
+        @class_name = class_name
+        @method = method
         @static = static
-        super(method)
+      end
+
+      def source_location
+        @method.source_location
+      end
+
+      def comment
+        @method.comment
+      rescue MethodSource::SourceNotFoundError
+        nil
+      end
+
+      def package
+        @package.name
+      end
+
+      def name
+        @method.name
+      end
+
+      def labels
+        @package.labels
       end
     end
 
@@ -43,6 +65,12 @@ module AppMap
         end
       end
 
+      def record_method(method)
+        @tracers.each do |tracer|
+          tracer.record_method(method)
+        end
+      end
+
       def delete(tracer)
         return unless @tracers.member?(tracer)
 
@@ -82,10 +110,23 @@ module AppMap
 
       @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event
-      @methods << Trace::ScopedMethod.new(package, defined_class, method, event.static) \
+      static = event.static if event.respond_to?(:static)
+      @methods << Trace::RubyMethod.new(package, defined_class, method, static) \
         if package && defined_class && method && (event.event == :call)
     end
 
+    # +method+ should be duck-typed to respond to the following:
+    # * package
+    # * defined_class
+    # * name
+    # * static
+    # * comment
+    # * labels
+    # * source_location
+    def record_method(method)
+      @methods << method
+    end
+
     # Gets the last package which was observed on the current thread.
     def last_package_for_current_thread
       @last_package_for_thread[Thread.current.object_id]