appmap 0.34.0 → 0.35.0

data/lib/appmap/hook/method.rb

@@ -1,63 +1,95 @@
+# frozen_string_literal: true
+
 module AppMap
   class Hook
     class Method
-      attr_reader :hook_class, :hook_method, :defined_class, :method_display_name
+      attr_reader :hook_package, :hook_class, :hook_method
+
+      # +method_display_name+ may be nil if name resolution gets
+      # deferred until runtime (e.g. for a singleton method on an
+      # embedded Struct).
+      attr_reader :method_display_name
 
       HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
       private_constant :HOOK_DISABLE_KEY
 
-      def initialize(hook_class, hook_method)
+      # Grab the definition of Time.now here, to avoid interfering
+      # with the method we're hooking.
+      TIME_NOW = Time.method(:now)
+      private_constant :TIME_NOW
+
+      def initialize(hook_package, hook_class, hook_method)
+        @hook_package = hook_package
         @hook_class = hook_class
         @hook_method = hook_method
+
+        # Get the class for the method, if it's known.
         @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
-        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join
+        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join if @defined_class
       end
 
       def activate
-        warn "AppMap: Hooking #{method_display_name}" if Hook::LOG
+        if Hook::LOG
+          msg = if method_display_name
+                  "#{method_display_name}"
+                else
+                  "#{hook_method.name} (class resolution deferred)"
+                end
+          warn "AppMap: Hooking " + msg
+        end
 
+        defined_class = @defined_class
         hook_method = self.hook_method
         before_hook = self.method(:before_hook)
         after_hook = self.method(:after_hook)
         with_disabled_hook = self.method(:with_disabled_hook)
 
-        hook_class.define_method hook_method.name do |*args, &block|
-          instance_method = hook_method.bind(self).to_proc
+        hook_method_def = nil
+        hook_class.instance_eval do 
+          hook_method_def = Proc.new do |*args, &block|
+            instance_method = hook_method.bind(self).to_proc
 
-          hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-          enabled = true if !hook_disabled && AppMap.tracing.enabled?
-          return instance_method.call(*args, &block) unless enabled
+            # We may not have gotten the class for the method during
+            # initialization (e.g. for a singleton method on an embedded
+            # struct), so make sure we have it now.
+            defined_class,_ = Hook.qualify_method_name(hook_method) unless defined_class
 
-          call_event, start_time = with_disabled_hook.() do
-            before_hook.(self, args)
-          end
-          return_value = nil
-          exception = nil
-          begin
-            return_value = instance_method.(*args, &block)
-          rescue
-            exception = $ERROR_INFO
-            raise
-          ensure
-            with_disabled_hook.() do
-              after_hook.(call_event, start_time, return_value, exception)
+            hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+            enabled = true if !hook_disabled && AppMap.tracing.enabled?
+            return instance_method.call(*args, &block) unless enabled
+
+            call_event, start_time = with_disabled_hook.() do
+              before_hook.(self, defined_class, args)
+            end
+            return_value = nil
+            exception = nil
+            begin
+              return_value = instance_method.(*args, &block)
+            rescue
+              exception = $ERROR_INFO
+              raise
+            ensure
+              with_disabled_hook.() do
+                after_hook.(self, call_event, start_time, return_value, exception)
+              end
             end
           end
         end
+        hook_class.define_method_with_arity(hook_method.name, hook_method.arity, hook_method_def)
       end
 
       protected
 
-      def before_hook(receiver, args)
+      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, defined_class: defined_class, method: hook_method
-        [ call_event, Time.now ]
+        AppMap.tracing.record_event call_event, package: hook_package, defined_class: defined_class, method: hook_method
+        [ call_event, TIME_NOW.call ]
       end
 
-      def after_hook(call_event, start_time, return_value, exception)
+      def after_hook(receiver, call_event, start_time, return_value, exception)
         require 'appmap/event'
-        elapsed = Time.now - start_time
+        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

data/lib/appmap/rails/request_handler.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+require 'appmap/hook'
+
+module AppMap
+  module Rails
+    module RequestHandler
+      class HTTPServerRequest < AppMap::Event::MethodEvent
+        attr_accessor :request_method, :path_info, :params
+
+        def initialize(request)
+          super AppMap::Event.next_id_counter, :call, Thread.current.object_id
+
+          @request_method = request.request_method
+          @path_info = request.path_info.split('?')[0]
+          @params = ActionDispatch::Http::ParameterFilter.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
+            }
+
+            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__
+              }
+            end
+          end
+        end
+      end
+
+      class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue
+        attr_accessor :status, :mime_type
+
+        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
+        end
+
+        def to_h
+          super.tap do |h|
+            h[:http_server_response] = {
+              status: status,
+              mime_type: mime_type
+            }.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

data/lib/appmap/rails/sql_handler.rb

@@ -72,21 +72,24 @@ module AppMap
         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
-            case database_type
-            when :postgres
-              ActiveRecord::Base.connection.postgresql_version
-            when :sqlite
-              ActiveRecord::Base.connection.database_version.to_s
-            else
-              warn "Unable to determine database version for #{database_type.inspect}"
-            end
+            ActiveRecord::Base.connection.try(:database_version) || issue_warning
           end
 
           def database_type
-            return :postgres if ActiveRecord::Base.connection.respond_to?(:postgresql_version)
+            type = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+            type = :postgres if type == :postgresql
 
-            ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+            type
           end
 
           def execute_query(sql)

data/lib/appmap/railtie.rb

@@ -13,13 +13,11 @@ module AppMap
     # AppMap events.
     initializer 'appmap.subscribe', after: 'appmap.init' do |_| # params: app
       require 'appmap/rails/sql_handler'
-      require 'appmap/rails/action_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
-      ActiveSupport::Notifications.subscribe \
-        'start_processing.action_controller', AppMap::Rails::ActionHandler::HTTPServerRequest.new
-      ActiveSupport::Notifications.subscribe \
-        'process_action.action_controller', AppMap::Rails::ActionHandler::HTTPServerResponse.new
+
+      AppMap::Rails::RequestHandler::HookMethod.new.activate
     end
 
     # appmap.trace begins recording an AppMap trace and writes it to appmap.json.

data/lib/appmap/rspec.rb

@@ -124,8 +124,18 @@ module AppMap
       def initialize(example)
         super
 
+        webdriver_port = lambda do
+          return unless defined?(page) && page&.driver
+
+          # This is the ugliest thing ever but I don't want to lose it.
+          # All the WebDriver calls are getting app-mapped and it's really unclear
+          # what they are.
+          page.driver.options[:http_client].instance_variable_get('@server_url').port
+        end
+
         warn "Starting recording of example #{example}" if AppMap::RSpec::LOG
         @trace = AppMap.tracing.trace
+        @webdriver_port = webdriver_port.()
       end
 
       def finish

data/lib/appmap/trace.rb

@@ -3,9 +3,10 @@
 module AppMap
   module Trace
     class ScopedMethod < SimpleDelegator
-      attr_reader :defined_class, :static
-      
-      def initialize(defined_class, method, static)
+      attr_reader :package, :defined_class, :static
+
+      def initialize(package, defined_class, method, static)
+        @package = package
         @defined_class = defined_class
         @static = static
         super(method)
@@ -32,9 +33,9 @@ module AppMap
         @tracing.any?(&:enabled?)
       end
 
-      def record_event(event, defined_class: nil, method: nil)
+      def record_event(event, package: nil, defined_class: nil, method: nil)
         @tracing.each do |tracer|
-          tracer.record_event(event, defined_class: defined_class, method: method)
+          tracer.record_event(event, package: package, defined_class: defined_class, method: method)
         end
       end
 
@@ -71,11 +72,12 @@ module AppMap
     # Record a program execution event.
     #
     # The event should be one of the MethodEvent subclasses.
-    def record_event(event, defined_class: nil, method: nil)
+    def record_event(event, package: nil, defined_class: nil, method: nil)
       return unless @enabled
 
       @events << event
-      @methods << Trace::ScopedMethod.new(defined_class, method, event.static) if (defined_class && method && event.event == :call)
+      @methods << Trace::ScopedMethod.new(package, defined_class, method, event.static) \
+        if package && defined_class && method && (event.event == :call)
     end
 
     # Gets a unique list of the methods that were invoked by the program.

data/lib/appmap/util.rb

@@ -36,6 +36,23 @@ module AppMap
         [ fname, extension ].join
       end
 
+      # sanitize_paths removes ephemeral values from objects with
+      # embedded paths (e.g. an event or a classmap), making events
+      # easier to compare across runs.
+      def sanitize_paths(h)
+        require 'hashie'
+        h.extend(Hashie::Extensions::DeepLocate)
+        keys = %i(path location)
+        h.deep_locate ->(k,v,o) {
+          next unless keys.include?(k)
+          
+          fix = ->(v) {v.gsub(%r{#{Gem.dir}/gems/.*(?=lib)}, '')}
+          keys.each {|k| o[k] = fix.(o[k]) if o[k] }
+        }
+
+        h
+      end
+      
       # sanitize_event removes ephemeral values from an event, making
       # events easier to compare across runs.
       def sanitize_event(event, &block)
@@ -49,7 +66,7 @@ module AppMap
 
         case event[:event]
         when :call
-          event[:path] = event[:path].gsub(Gem.dir + '/', '')
+          sanitize_paths(event)
         end
 
         event

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.34.0'
+  VERSION = '0.35.0'
 
   APPMAP_FORMAT_VERSION = '1.2'
 end

data/spec/abstract_controller4_base_spec.rb

@@ -39,7 +39,7 @@ describe 'AbstractControllerBase' do
       expect(appmap).to include(<<-SERVER_REQUEST.strip)
   http_server_request:
     request_method: POST
-    path_info: "/api/users?login=alice&password=foobar
+    path_info: "/api/users"
       SERVER_REQUEST
     end
     it 'Properly captures method parameters in the appmap' do

data/spec/abstract_controller_base_spec.rb

@@ -45,6 +45,12 @@ describe 'AbstractControllerBase' do
     request_method: POST
     path_info: "/api/users"
       SERVER_REQUEST
+
+      expect(appmap).to include(<<-SERVER_RESPONSE.strip)
+  http_server_response:
+    status: 201
+    mime_type: application/json; charset=utf-8
+      SERVER_RESPONSE
     end
 
     it 'properly captures method parameters in the appmap' do

data/spec/fixtures/hook/instance_method.rb

@@ -20,4 +20,8 @@ class InstanceMethod
   def say_block(&block)
     yield
   end
+
+  def say_the_time
+    Time.now.to_s
+  end
 end

data/spec/fixtures/hook/singleton_method.rb

@@ -15,6 +15,20 @@ class SingletonMethod
     'defined with self class scope'
   end
 
+  module AddMethod
+    def self.included(base)
+      base.module_eval do
+        define_method "added_method" do
+          _added_method
+        end
+      end
+    end
+    
+    def _added_method
+      'defined by including a module'
+    end
+  end
+  
   # When called, do_include calls +include+ to bring in the module
   # AddMethod. AddMethod defines a new instance method, which gets
   # added to the singleton class of SingletonMethod.
@@ -32,23 +46,18 @@ class SingletonMethod
       end
     end
   end
-  
-  def to_s
-    'Singleton Method fixture'
-  end
-end
 
-module AddMethod
-  def self.included(base)
-    base.module_eval do
-      define_method "added_method" do
-        _added_method
+  STRUCT_TEST = Struct.new(:attr) do
+    class << self
+      def say_struct_singleton
+        'singleton for a struct'
       end
     end
   end
   
-  def _added_method
-    'defined by including a module'
+  def to_s
+    'Singleton Method fixture'
   end
 end
 
+