appmap 0.34.5 → 0.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b4318e1ef7e025a8f616022cefd323784e7b8ee8ccf06b1b7167b9937e860df
-  data.tar.gz: c6a743f2c7f4ebe8cd58f7ae971b5dae15791bc808dab9d4dcf87f4971986818
+  metadata.gz: 587d9e4e90152c5ab6b04d4fa6b95d3071419563d82f4ed3c609def87111757b
+  data.tar.gz: b1867167f44a1f244e165a628293415dd54bcaacb0b4471c5d30c26dce3bef64
 SHA512:
-  metadata.gz: 9f271a71bb8bffa7004d054ae91646c9c93a476b15cbe80c459a9cafcb13ab0169be6c8a2db9b8cc993c3bc767deef4c9c0ca4befe6bd6881cf2d93c7b692b64
-  data.tar.gz: 3b6c5067a325fa2a0aed71b5ed92179196061cd6cfa015f907a25dab798e757c2cd53efbd028513df1f22cc2e2b8aa9345f8d19aa27018eccfbee4cd39766ece
+  metadata.gz: 23a6e927bda905ce13666aa514040415bbaf0b8f317ffac524b1f0f94de58de17c175e001c921825ac0cbe05287a3e137899e5a5f86609cdbd9ce4000b4cbe4f
+  data.tar.gz: dcd2ad0a96709cc28f383726c56e133a75ba81e3edbd6679913afc7c1ae4097c3767c79b07ebf5bc9357c40660be00d39205dcbf4c1316a7add323b613a2f1a3

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# v0.35.0
+* Provide a custom display string for files and HTTP requests.
+* Report `mime_type` on HTTP response.
+
+# v0.34.6
+* Only warn once about problems determining database version for an ActiveRecord
+  connection.
+
 # v0.34.5
 * Ensure that hooking a method doesn't change its arity.
 

data/lib/appmap.rb

@@ -84,7 +84,7 @@ module AppMap
 
     # Builds a class map from a config and a list of Ruby methods.
     def class_map(methods)
-      ClassMap.build_from_methods(configuration, methods)
+      ClassMap.build_from_methods(methods)
     end
 
     # Returns default metadata detected from the Ruby system and from the

data/lib/appmap/class_map.rb

@@ -61,25 +61,24 @@ module AppMap
             location: location,
             static: static,
             labels: labels
-          }.delete_if { |k,v| v.nil? || v == [] }
+          }.delete_if { |_, v| v.nil? || v == [] }
         end
       end
     end
 
     class << self
-      def build_from_methods(config, methods)
+      def build_from_methods(methods)
         root = Types::Root.new
         methods.each do |method|
-          package = config.package_for_method(method) \
-            or raise "No package found for method #{method}"
-          add_function root, package, method
+          add_function root, method
         end
         root.children.map(&:to_h)
       end
 
       protected
 
-      def add_function(root, package, method)
+      def add_function(root, method)
+        package = method.package
         static = method.static
 
         object_infos = [

data/lib/appmap/config.rb

@@ -6,7 +6,7 @@ module AppMap
       def initialize(path, package_name: nil, exclude: [], labels: [])
         super path, package_name, exclude, labels
       end
-  
+
       def to_h
         {
           path: path,
@@ -105,7 +105,7 @@ module AppMap
       hook = find_hook(defined_class)
       return nil unless hook
 
-      Array(hook.method_names).include?(method_name) ? hook.package : nil      
+      Array(hook.method_names).include?(method_name) ? hook.package : nil
     end
 
     def find_hook(defined_class)

data/lib/appmap/event.rb

@@ -36,20 +36,38 @@ module AppMap
             '*Error inspecting variable*'
           end
 
-          value_string = \
+          value_string = custom_display_string(value) || default_display_string(value)
+
+          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+        end
+
+        protected
+
+        def custom_display_string(value)
+          case value
+          when File
+            "#{value.class}[path=#{value.path}]"
+          when Net::HTTP
+            "#{value.class}[#{value.address}:#{value.port}]"
+          when Net::HTTPGenericRequest
+            "#{value.class}[#{value.method} #{value.path}]"
+          end
+        rescue StandardError
+          nil
+        end
+
+        def default_display_string(value)
+          begin
+            value.to_s
+          rescue NoMethodError
             begin
-              value.to_s
-            rescue NoMethodError
-              begin
-                value.inspect
-              rescue StandardError
-                last_resort_string.call
-              end
+              value.inspect
             rescue StandardError
               last_resort_string.call
             end
-
-          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+          rescue StandardError
+            last_resort_string.call
+          end
         end
       end
     end

data/lib/appmap/hook.rb

@@ -48,7 +48,6 @@ module AppMap
         hook = lambda do |hook_cls|
           lambda do |method_id|
             method = hook_cls.public_instance_method(method_id)
-            hook_method = Hook::Method.new(hook_cls, method)
 
             warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
@@ -56,14 +55,16 @@ module AppMap
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
-            # Don't try and trace the AppMap methods or there will be
-            # a stack overflow in the defined hook method.
-            next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
-
             next unless \
               config.always_hook?(hook_cls, method.name) ||
               config.included_by_location?(method)
 
+            hook_method = Hook::Method.new(config.package_for_method(method), hook_cls, method)
+
+            # Don't try and trace the AppMap methods or there will be
+            # a stack overflow in the defined hook method.
+            next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
+
             hook_method.activate
           end
         end
@@ -97,9 +98,9 @@ module AppMap
             end
 
           if method
-            Hook::Method.new(cls, method).activate
+            Hook::Method.new(hook.package, cls, method).activate
           else
-            warn "Method #{method_name} not found on #{cls.name}" 
+            warn "Method #{method_name} not found on #{cls.name}"
           end
         end
       end

data/lib/appmap/hook/method.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module AppMap
   class Hook
     class Method
-      attr_reader :hook_class, :hook_method
+      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
@@ -15,8 +17,9 @@ module AppMap
       # with the method we're hooking.
       TIME_NOW = Time.method(:now)
       private_constant :TIME_NOW
-      
-      def initialize(hook_class, hook_method)
+
+      def initialize(hook_package, hook_class, hook_method)
+        @hook_package = hook_package
         @hook_class = hook_class
         @hook_method = hook_method
 
@@ -67,23 +70,24 @@ module AppMap
               raise
             ensure
               with_disabled_hook.() do
-                after_hook.(call_event, start_time, return_value, exception)
+                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, 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
+        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.call - start_time
         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,9 +72,17 @@ 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
-            ActiveRecord::Base.connection.try(:database_version) ||\
-              warn("Unable to determine database version for #{database_type.inspect}")
+            ActiveRecord::Base.connection.try(:database_version) || issue_warning
           end
 
           def database_type

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/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.34.5'
+  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/hook_spec.rb

@@ -624,7 +624,7 @@ describe 'AppMap class Hooking', docker: false do
       config, tracer = invoke_test_file 'spec/fixtures/hook/compare.rb' do
         expect(Compare.compare('string', 'string')).to be_truthy
       end
-      cm = AppMap::Util.sanitize_paths(AppMap::ClassMap.build_from_methods(config, tracer.event_methods))
+      cm = AppMap::Util.sanitize_paths(AppMap::ClassMap.build_from_methods(tracer.event_methods))
       entry = cm[1][:children][0][:children][0][:children][0]
       # Sanity check, make sure we got the right one
       expect(entry[:name]).to eq('secure_compare')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.34.5
+  version: 0.35.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-23 00:00:00.000000000 Z
+date: 2020-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -338,7 +338,7 @@ files:
 - lib/appmap/middleware/remote_recording.rb
 - lib/appmap/minitest.rb
 - lib/appmap/open.rb
-- lib/appmap/rails/action_handler.rb
+- lib/appmap/rails/request_handler.rb
 - lib/appmap/rails/sql_handler.rb
 - lib/appmap/railtie.rb
 - lib/appmap/record.rb

data/lib/appmap/rails/action_handler.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'appmap/event'
-
-module AppMap
-  module Rails
-    module ActionHandler
-      Context = Struct.new(:id, :start_time)
-
-      module ContextKey
-        def context_key
-          "#{HTTPServerRequest.name}#call"
-        end
-      end
-
-      class HTTPServerRequest
-        include ContextKey
-
-        class Call < 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[:http_server_request] = {
-                request_method: payload[:method],
-                path_info: payload[:path]
-              }
-
-              params = payload[:params]
-              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
-
-        def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-          event = Call.new(payload)
-          Thread.current[context_key] = Context.new(event.id, Time.now)
-          AppMap.tracing.record_event(event)
-        end
-      end
-
-      class HTTPServerResponse
-        include ContextKey
-
-        class Call < AppMap::Event::MethodReturnIgnoreValue
-          attr_accessor :payload
-
-          def initialize(payload, parent_id, elapsed)
-            super AppMap::Event.next_id_counter, :return, Thread.current.object_id
-
-            self.payload = payload
-            self.parent_id = parent_id
-            self.elapsed = elapsed
-          end
-
-          def to_h
-            super.tap do |h|
-              h[:http_server_response] = {
-                status: payload[:status]
-              }
-            end
-          end
-        end
-
-        def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-          return unless Thread.current[context_key]
-
-          context = Thread.current[context_key]
-          Thread.current[context_key] = nil
-
-          event = Call.new(payload, context.id, Time.now - context.start_time)
-          AppMap.tracing.record_event(event)
-        end
-      end
-    end
-  end
-end