appmap 0.45.1 → 0.46.0

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Handler
+    module Rails
+      class SQLHandler
+        class SQLCall < AppMap::Event::MethodCall
+          attr_accessor :payload
+
+          def initialize(payload)
+            super AppMap::Event.next_id_counter, :call, Thread.current.object_id
+
+            self.payload = payload
+          end
+
+          def to_h
+            super.tap do |h|
+              h[:sql_query] = {
+                sql: payload[:sql],
+                database_type: payload[:database_type]
+              }.tap do |sql_query|
+                %i[server_version].each do |attribute|
+                  sql_query[attribute] = payload[attribute] if payload[attribute]
+                end
+              end
+            end
+          end
+        end
+
+        class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
+          def initialize(parent_id, elapsed)
+            super AppMap::Event.next_id_counter, :return, Thread.current.object_id
+
+            self.parent_id = parent_id
+            self.elapsed = elapsed
+          end
+        end
+
+        module SQLExaminer
+          class << self
+            def examine(payload, sql:)
+              return unless (examiner = build_examiner)
+
+              payload[:server_version] = examiner.server_version
+              payload[:database_type] = examiner.database_type.to_s
+            end
+
+            protected
+
+            def build_examiner
+              if defined?(Sequel)
+                SequelExaminer.new
+              elsif defined?(ActiveRecord)
+                ActiveRecordExaminer.new
+              end
+            end
+          end
+
+          class SequelExaminer
+            def server_version
+              Sequel::Model.db.server_version
+            end
+
+            def database_type
+              Sequel::Model.db.database_type.to_sym
+            end
+
+            def execute_query(sql)
+              Sequel::Model.db[sql].all
+            end
+          end
+
+          class ActiveRecordExaminer
+            @@db_version_warning_issued = {}
+            
+            def issue_warning
+              db_type = database_type
+              return if @@db_version_warning_issued[db_type]
+              warn("AppMap: Unable to determine database version for #{db_type.inspect}") 
+              @@db_version_warning_issued[db_type] = true
+            end
+            
+            def server_version
+              ActiveRecord::Base.connection.try(:database_version) || issue_warning
+            end
+
+            def database_type
+              type = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+              type = :postgres if type == :postgresql
+
+              type
+            end
+
+            def execute_query(sql)
+              ActiveRecord::Base.connection.execute(sql).inject([]) { |memo, r| memo << r; memo }
+            end
+          end
+        end
+
+        def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
+          return if AppMap.tracing.empty?
+
+          reentry_key = "#{self.class.name}#call"
+          return if Thread.current[reentry_key] == true
+
+          Thread.current[reentry_key] = true
+          begin
+            sql = payload[:sql].strip
+
+            # Detect whether a function call within a specified filename is present in the call stack.
+            find_in_backtrace = lambda do |file_name, function_name = nil|
+              Thread.current.backtrace.find do |line|
+                tokens = line.split(':')
+                matches_file = tokens.find { |t| t.rindex(file_name) == (t.length - file_name.length) }
+                matches_function = function_name.nil? || tokens.find { |t| t == "in `#{function_name}'" }
+                matches_file && matches_function
+              end
+            end
+
+            # Ignore SQL calls which are made while establishing a new connection.
+            #
+            # Example:
+            # /path/to/ruby/2.6.0/gems/sequel-5.20.0/lib/sequel/connection_pool.rb:122:in `make_new'
+            return if find_in_backtrace.call('lib/sequel/connection_pool.rb', 'make_new')
+            # lib/active_record/connection_adapters/abstract/connection_pool.rb:811:in `new_connection'
+            return if find_in_backtrace.call('lib/active_record/connection_adapters/abstract/connection_pool.rb', 'new_connection')
+
+            # Ignore SQL calls which are made while inspecting the DB schema.
+            #
+            # Example:
+            # /path/to/ruby/2.6.0/gems/sequel-5.20.0/lib/sequel/model/base.rb:812:in `get_db_schema'
+            return if find_in_backtrace.call('lib/sequel/model/base.rb', 'get_db_schema')
+            # /usr/local/bundle/gems/activerecord-5.2.3/lib/active_record/model_schema.rb:466:in `load_schema!'
+            return if find_in_backtrace.call('lib/active_record/model_schema.rb', 'load_schema!')
+            return if find_in_backtrace.call('lib/active_model/attribute_methods.rb', 'define_attribute_methods')
+            return if find_in_backtrace.call('lib/active_record/connection_adapters/schema_cache.rb')
+
+            SQLExaminer.examine payload, sql: sql
+
+            call = SQLCall.new(payload)
+            AppMap.tracing.record_event(call)
+            AppMap.tracing.record_event(SQLReturn.new(call.id, finished - started))
+          ensure
+            Thread.current[reentry_key] = nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# 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)
+              warn "Resolver return: #{return_value.inspect}" if LOG
+
+              renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
+              path = Array(return_value).first&.inspect
+
+              if path
+                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/method.rb

@@ -95,7 +95,7 @@ module AppMap
       def after_hook(_receiver, call_event, start_time, return_value, exception)
         elapsed = TIME_NOW.call - start_time
         return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
-        AppMap.tracing.record_event return_event
+        AppMap.tracing.record_event(return_event) if return_event
         nil
       end
 

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)
 
@@ -83,10 +111,22 @@ module AppMap
       @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event
       static = event.static if event.respond_to?(:static)
-      @methods << Trace::ScopedMethod.new(package, defined_class, method, 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]

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.45.1'
+  VERSION = '0.46.0'
 
   APPMAP_FORMAT_VERSION = '1.5.0'
 end

data/package-lock.json

@@ -551,9 +551,9 @@
       }
     },
     "lodash": {
-      "version": "4.17.19",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.19.tgz",
-      "integrity": "sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ=="
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
     },
     "longest": {
       "version": "1.0.1",

data/spec/abstract_controller_base_spec.rb

@@ -144,7 +144,49 @@ describe 'Rails' do
       end
 
       describe 'a UI route' do
-        describe 'rendering a page' do
+        describe 'rendering a page using a template file' do
+          let(:appmap_json_file) do
+            'UsersController_GET_users_lists_the_users.appmap.json'
+          end
+
+          it 'records the template file' do
+            expect(events).to include hash_including(
+              'event' => 'call',
+              'defined_class' => 'app_views_users_index_html_haml',
+              'method_id' => 'render',
+              'path' => 'app/views/users/index.html.haml'
+            )
+
+            expect(appmap['classMap']).to include hash_including(
+              'name' => 'app/views',
+              'children' => include(hash_including(
+                'name' => 'app_views_users_index_html_haml',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'app/views/users/index.html.haml',
+                  'static' => true,
+                  'labels' => [ 'mvc.template' ]
+                ))
+              ))
+            )
+            expect(appmap['classMap']).to include hash_including(
+              'name' => 'app/views',
+              'children' => include(hash_including(
+                'name' => 'app_views_layouts_application_html_haml',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'app/views/layouts/application.html.haml',
+                  'static' => true,
+                  'labels' => [ 'mvc.template' ]
+                ))
+              ))
+            )
+          end
+        end
+
+        describe 'rendering a page using a text template' do
           let(:appmap_json_file) do
             'UsersController_GET_users_login_shows_the_user.appmap.json'
           end
@@ -165,15 +207,32 @@ describe 'Rails' do
             )
           end
 
+          it 'ignores the text template' do
+            expect(events).to_not include hash_including(
+              'event' => 'call',
+              'method_id' => 'render',
+              'render_template' => anything
+            )
+
+            expect(appmap['classMap']).to_not include hash_including(
+              'name' => 'views',
+              'children' => include(hash_including(
+                'name' => 'ViewTemplate',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'text template'
+                ))
+              ))
+            )
+          end
+
           it 'records and labels view rendering' do
             expect(events).to include hash_including(
               'event' => 'call',
               'thread_id' => Numeric,
-              'defined_class' => 'ActionView::Renderer',
-              'method_id' => 'render',
-              'path' => String,
-              'lineno' => Integer,
-              'static' => false
+              'defined_class' => 'inline_template',
+              'method_id' => 'render'
             )
   
             expect(appmap['classMap']).to include hash_including(