appmap 0.45.0 → 0.48.0

data/lib/appmap/event.rb

@@ -21,10 +21,10 @@ module AppMap
       LIMIT = 100
 
       class << self
-        def build_from_invocation(me, event_type)
-          me.id = AppMap::Event.next_id_counter
-          me.event = event_type
-          me.thread_id = Thread.current.object_id
+        def build_from_invocation(event_type, event:)
+          event.id = AppMap::Event.next_id_counter
+          event.event = event_type
+          event.thread_id = Thread.current.object_id
         end
 
         # Gets a display string for a value. This is not meant to be a machine deserializable value.
@@ -48,8 +48,6 @@ module AppMap
           nil
         end
 
-        protected
-
         # Heuristic for dynamically defined class whose name can be nil
         def best_class_name(value)
           value_cls = value.class
@@ -103,19 +101,20 @@ module AppMap
       attr_accessor :defined_class, :method_id, :path, :lineno, :parameters, :receiver, :static
 
       class << self
-        def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
+        def build_from_invocation(defined_class, method, receiver, arguments, event: MethodCall.new)
+          event ||= MethodCall.new
           defined_class ||= 'Class'
-          mc.tap do
+          event.tap do
             static = receiver.is_a?(Module)
-            mc.defined_class = defined_class
-            mc.method_id = method.name.to_s
+            event.defined_class = defined_class
+            event.method_id = method.name.to_s
             if method.source_location
               path = method.source_location[0]
               path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
-              mc.path = path
-              mc.lineno = method.source_location[1]
+              event.path = path
+              event.lineno = method.source_location[1]
             else
-              mc.path = [ defined_class, static ? '.' : '#', method.name ].join
+              event.path = [ defined_class, static ? '.' : '#', method.name ].join
             end
 
             # Check if the method has key parameters. If there are any they'll always be last.
@@ -123,7 +122,7 @@ module AppMap
             has_key = [[:dummy], *method.parameters].last.first.to_s.start_with?('key') && arguments[-1].is_a?(Hash)
             kwargs = has_key && arguments[-1].dup || {}
 
-            mc.parameters = method.parameters.map.with_index do |method_param, idx|
+            event.parameters = method.parameters.map.with_index do |method_param, idx|
               param_type, param_name = method_param
               param_name ||= 'arg'
               value = case param_type
@@ -144,13 +143,13 @@ module AppMap
                 kind: param_type
               }
             end
-            mc.receiver = {
+            event.receiver = {
               class: best_class_name(receiver),
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
-            mc.static = static
-            MethodEvent.build_from_invocation(mc, :call)
+            event.static = static
+            MethodEvent.build_from_invocation(:call, event: event)
           end
         end
       end
@@ -175,11 +174,12 @@ module AppMap
       attr_accessor :parent_id, :elapsed
 
       class << self
-        def build_from_invocation(mr = MethodReturnIgnoreValue.new, parent_id, elapsed)
-          mr.tap do |_|
-            mr.parent_id = parent_id
-            mr.elapsed = elapsed
-            MethodEvent.build_from_invocation(mr, :return)
+        def build_from_invocation(parent_id, elapsed: nil, event: MethodReturnIgnoreValue.new)
+          event ||= MethodReturnIgnoreValue.new
+          event.tap do |_|
+            event.parent_id = parent_id
+            event.elapsed = elapsed
+            MethodEvent.build_from_invocation(:return, event: event)
           end
         end
       end
@@ -187,7 +187,7 @@ module AppMap
       def to_h
         super.tap do |h|
           h[:parent_id] = parent_id
-          h[:elapsed] = elapsed
+          h[:elapsed] = elapsed if elapsed
         end
       end
     end
@@ -196,10 +196,11 @@ module AppMap
       attr_accessor :return_value, :exceptions
 
       class << self
-        def build_from_invocation(mr = MethodReturn.new, parent_id, elapsed, return_value, exception)
-          mr.tap do |_|
+        def build_from_invocation(parent_id, return_value, exception, elapsed: nil, event: MethodReturn.new)
+          event ||= MethodReturn.new
+          event.tap do |_|
             if return_value
-              mr.return_value = {
+              event.return_value = {
                 class: best_class_name(return_value),
                 value: display_string(return_value),
                 object_id: return_value.__id__
@@ -220,9 +221,9 @@ module AppMap
                 next_exception = next_exception.cause
               end
 
-              mr.exceptions = exceptions
+              event.exceptions = exceptions
             end
-            MethodReturnIgnoreValue.build_from_invocation(mr, parent_id, elapsed)
+            MethodReturnIgnoreValue.build_from_invocation(parent_id, elapsed: elapsed, event: event)
           end
         end
       end

data/lib/appmap/handler/function.rb

@@ -11,7 +11,7 @@ module AppMap
         end
 
         def handle_return(call_event_id, elapsed, return_value, exception)
-          AppMap::Event::MethodReturn.build_from_invocation(call_event_id, elapsed, return_value, exception)
+          AppMap::Event::MethodReturn.build_from_invocation(call_event_id, return_value, exception, elapsed: elapsed)
         end
       end
     end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+require 'appmap/hook'
+
+module AppMap
+  module Handler
+    module Rails
+      module RequestHandler
+        class HTTPServerRequest < AppMap::Event::MethodEvent
+          attr_accessor :normalized_path_info, :request_method, :path_info, :params, :mime_type, :headers, :authorization
+
+          def initialize(request)
+            super AppMap::Event.next_id_counter, :call, Thread.current.object_id
+
+            self.request_method = request.request_method
+            self.normalized_path_info = normalized_path(request)
+            self.mime_type = request.headers['Content-Type']
+            self.headers = AppMap::Util.select_headers(request.env)
+            self.authorization = request.headers['Authorization']
+            self.path_info = request.path_info.split('?')[0]
+            # ActionDispatch::Http::ParameterFilter is deprecated
+            parameter_filter_cls = \
+              if defined?(ActiveSupport::ParameterFilter)
+                ActiveSupport::ParameterFilter
+              else
+                ActionDispatch::Http::ParameterFilter
+              end
+            self.params = parameter_filter_cls.new(::Rails.application.config.filter_parameters).filter(request.params)
+          end
+
+          def to_h
+            super.tap do |h|
+              h[:http_server_request] = {
+                request_method: request_method,
+                path_info: path_info,
+                mime_type: mime_type,
+                normalized_path_info: normalized_path_info,
+                authorization: authorization,
+                headers: headers,
+              }.compact
+
+              unless params.blank?
+                h[:message] = params.keys.map do |key|
+                  val = params[key]
+                  {
+                    name: key,
+                    class: val.class.name,
+                    value: self.class.display_string(val),
+                    object_id: val.__id__,
+                  }.tap do |message|
+                    properties = object_properties(val)
+                    message[:properties] = properties if properties
+                  end
+                end
+              end
+            end
+          end
+
+          private
+
+          def normalized_path(request, router = ::Rails.application.routes.router)
+            router.recognize request do |route, _|
+              app = route.app
+              next unless app.matches? request
+              return normalized_path request, app.rack_app.routes.router if app.engine?
+
+              return AppMap::Util.swaggerize_path(route.path.spec.to_s)
+            end
+          end
+        end
+
+        class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue
+          attr_accessor :status, :mime_type, :headers
+
+          def initialize(response, parent_id, elapsed)
+            super AppMap::Event.next_id_counter, :return, Thread.current.object_id
+
+            self.status = response.status
+            self.mime_type = response.headers['Content-Type']
+            self.parent_id = parent_id
+            self.elapsed = elapsed
+            self.headers = AppMap::Util.select_headers(response.headers)
+          end
+
+          def to_h
+            super.tap do |h|
+              h[:http_server_response] = {
+                status_code: status,
+                mime_type: mime_type,
+                headers: headers
+              }.compact
+            end
+          end
+        end
+
+        class HookMethod < AppMap::Hook::Method
+          def initialize
+            # ActionController::Instrumentation has issued start_processing.action_controller and
+            # process_action.action_controller since Rails 3. Therefore it's a stable place to hook
+            # the request. Rails controller notifications can't be used directly because they don't
+            # provide response headers, and we want the Content-Type.
+            super(nil, ActionController::Instrumentation, ActionController::Instrumentation.instance_method(:process_action))
+          end
+
+          protected
+
+          def before_hook(receiver, defined_class, _) # args
+            call_event = HTTPServerRequest.new(receiver.request)
+            # http_server_request events are i/o and do not require a package name.
+            AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
+            [ call_event, TIME_NOW.call ]
+          end
+
+          def after_hook(receiver, call_event, start_time, _, _) # return_value, exception
+            elapsed = TIME_NOW.call - start_time
+            return_event = HTTPServerResponse.new receiver.response, call_event.id, elapsed
+            AppMap.tracing.record_event return_event
+          end
+        end
+      end
+    end
+  end
+end

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,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