appmap 0.41.2 → 0.45.0

data/lib/appmap/cucumber.rb

@@ -50,7 +50,7 @@ module AppMap
         appmap['metadata'] = update_metadata(scenario, appmap['metadata'])
         scenario_filename = AppMap::Util.scenario_filename(appmap['metadata']['name'])
 
-        File.write(File.join(APPMAP_OUTPUT_DIR, scenario_filename), JSON.generate(appmap))
+        AppMap::Util.write_appmap(File.join(APPMAP_OUTPUT_DIR, scenario_filename), JSON.generate(appmap))
       end
 
       def enabled?

data/lib/appmap/event.rb

@@ -36,6 +36,18 @@ module AppMap
           (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
         end
 
+        def object_properties(hash_like)
+          hash = hash_like.to_h
+          hash.keys.map do |key|
+            {
+              name: key,
+              class: hash[key].class.name,
+            }
+          end
+        rescue
+          nil
+        end
+
         protected
 
         # Heuristic for dynamically defined class whose name can be nil
@@ -79,6 +91,12 @@ module AppMap
           end
         end
       end
+
+      protected
+
+      def object_properties(hash_like)
+        self.class.object_properties(hash_like)
+      end
     end
 
     class MethodCall < MethodEvent

data/lib/appmap/handler/function.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Handler
+    module Function
+      class << self
+        def handle_call(defined_class, hook_method, receiver, args)
+          AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
+        end
+
+        def handle_return(call_event_id, elapsed, return_value, exception)
+          AppMap::Event::MethodReturn.build_from_invocation(call_event_id, elapsed, return_value, exception)
+        end
+      end
+    end
+  end
+end

data/lib/appmap/handler/net_http.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
+module AppMap
+  module Handler
+    class HTTPClientRequest < AppMap::Event::MethodEvent
+      attr_accessor :request_method, :url, :params, :headers
+
+      def initialize(http, request)
+        super AppMap::Event.next_id_counter, :call, Thread.current.object_id
+
+        path, query = request.path.split('?')
+        query ||= ''
+
+        protocol = http.use_ssl? ? 'https' : 'http'
+        port = if http.use_ssl? && http.port == 443
+          nil
+        elsif !http.use_ssl? && http.port == 80
+          nil
+        else
+          ":#{http.port}"
+        end
+
+        url = [ protocol, '://', http.address, port, path ].compact.join
+
+        self.request_method = request.method
+        self.url = url
+        self.headers = AppMap::Util.select_headers(NetHTTP.request_headers(request))
+        self.params = Rack::Utils.parse_nested_query(query)
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:http_client_request] = {
+            request_method: request_method,
+            url: url,
+            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__,
+              }
+            end
+          end
+        end
+      end
+    end
+
+    class HTTPClientResponse < 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.code.to_i
+        self.parent_id = parent_id
+        self.elapsed = elapsed
+        self.headers = AppMap::Util.select_headers(NetHTTP.response_headers(response))
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:http_client_response] = {
+            status_code: status,
+            mime_type: mime_type,
+            headers: headers
+          }.compact
+        end
+      end
+    end
+
+    class NetHTTP
+      class << self
+        def request_headers(request)
+          {}.tap do |headers|
+            request.each_header do |k,v|
+              key = [ 'HTTP', k.underscore.upcase ].join('_')
+              headers[key] = v
+            end
+          end
+        end
+    
+        alias response_headers request_headers
+    
+        def handle_call(defined_class, hook_method, receiver, args)
+          # request will call itself again in a start block if it's not already started.
+          return unless receiver.started?
+
+          http = receiver
+          request = args.first
+          HTTPClientRequest.new(http, request)
+        end
+
+        def handle_return(call_event_id, elapsed, return_value, exception)
+          HTTPClientResponse.new(return_value, call_event_id, elapsed)
+        end
+      end
+    end
+  end
+end

data/lib/appmap/hook.rb

@@ -32,6 +32,7 @@ module AppMap
     end
 
     attr_reader :config
+
     def initialize(config)
       @config = config
     end
@@ -46,10 +47,23 @@ module AppMap
         cls = trace_point.self
 
         instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
-        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods - OBJECT_STATIC_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
@@ -69,18 +83,22 @@ module AppMap
               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)
+            package = config.package_for_method(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 = Hook::Method.new(package, hook_cls, method)
 
             hook_method.activate
           end
         end
 
         instance_methods.each(&hook.(cls))
-        class_methods.each(&hook.(cls.singleton_class))
+        # 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)
@@ -97,25 +115,27 @@ module AppMap
         end
       end
 
-      Config::BUILTIN_METHODS.each do |class_name, 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
+      config.builtin_methods.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
 
-          cls = class_from_string.(class_name)
-          method = \
-            begin
-              cls.instance_method(method_name)
-            rescue NameError
-              cls.method(method_name) rescue nil
-            end
+            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)
+            next if config.never_hook?(method)
 
-          if method
-            Hook::Method.new(hook.package, cls, method).activate
-          else
-            warn "Method #{method_name} not found on #{cls.name}"
+            if method
+              Hook::Method.new(hook.package, cls, method).activate
+            else
+              warn "Method #{method_name} not found on #{cls.name}"
+            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
+        return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
         AppMap.tracing.record_event return_event
+        nil
       end
 
       def with_disabled_hook(&function)

data/lib/appmap/minitest.rb

@@ -7,22 +7,28 @@ module AppMap
   # be activated around each test.
   module Minitest
     APPMAP_OUTPUT_DIR = 'tmp/appmap/minitest'
-    LOG = false
+    LOG = ( ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true' )
 
     def self.metadata
       AppMap.detect_metadata
     end
 
-    Recording = Struct.new(:test) do
-      def initialize(test)
+    Recording = Struct.new(:test, :test_name) do
+      def initialize(test, test_name)
         super
 
-        warn "Starting recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+        warn "Starting recording of test #{test.class}.#{test.name}@#{source_location}" if AppMap::Minitest::LOG
         @trace = AppMap.tracing.trace
       end
 
-      def finish
+      def source_location
+        test.method(test_name).source_location.join(':')
+      end
+
+
+      def finish(exception)
         warn "Finishing recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+        warn "Exception: #{exception}" if exception && AppMap::Minitest::LOG
 
         events = []
         AppMap.tracing.delete @trace
@@ -37,11 +43,12 @@ module AppMap
         feature_name = test.name.split('_')[1..-1].join(' ')
         scenario_name = [ feature_group, feature_name ].join(' ')
 
-        AppMap::Minitest.save scenario_name,
-                              class_map,
-                              events: events,
-                              feature_name: feature_name,
-                              feature_group_name: feature_group
+        AppMap::Minitest.save name: scenario_name,
+                              class_map: class_map,
+                              source_location: source_location,
+                              test_status: exception ? 'failed' : 'succeeded',
+                              exception: exception,
+                              events: events
       end
     end
 
@@ -55,15 +62,15 @@ module AppMap
         FileUtils.mkdir_p APPMAP_OUTPUT_DIR
       end
 
-      def begin_test(test)
-        @recordings_by_test[test.object_id] = Recording.new(test)
+      def begin_test(test, name)
+        @recordings_by_test[test.object_id] = Recording.new(test, name)
       end
 
-      def end_test(test)
+      def end_test(test, exception:)
         recording = @recordings_by_test.delete(test.object_id)
         return warn "No recording found for #{test}" unless recording
 
-        recording.finish
+        recording.finish exception
       end
 
       def config
@@ -74,12 +81,11 @@ module AppMap
         @event_methods += event_methods
       end
 
-      def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
+      def save(name:, class_map:, source_location:, test_status:, exception:, events:)
         metadata = AppMap::Minitest.metadata.tap do |m|
-          m[:name] = example_name
+          m[:name] = name
+          m[:source_location] = source_location
           m[:app] = AppMap.configuration.name
-          m[:feature] = feature_name if feature_name
-          m[:feature_group] = feature_group_name if feature_group_name
           m[:frameworks] ||= []
           m[:frameworks] << {
             name: 'minitest',
@@ -88,6 +94,13 @@ module AppMap
           m[:recorder] = {
             name: 'minitest'
           }
+          m[:test_status] = test_status
+          if exception
+            m[:exception] = {
+              class: exception.class.name,
+              message: exception.to_s
+            }
+          end
         end
 
         appmap = {
@@ -96,14 +109,9 @@ module AppMap
           classMap: class_map,
           events: events
         }.compact
-        fname = AppMap::Util.scenario_filename(example_name)
+        fname = AppMap::Util.scenario_filename(name)
 
-        File.write(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
-      end
-
-      def print_inventory
-        class_map = AppMap.class_map(@event_methods)
-        save 'Inventory', class_map, labels: %w[inventory]
+        AppMap::Util.write_appmap(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
       end
 
       def enabled?
@@ -112,9 +120,6 @@ module AppMap
 
       def run
         init
-        at_exit do
-          print_inventory
-        end
       end
     end
   end
@@ -128,11 +133,11 @@ if AppMap::Minitest.enabled?
     alias run_without_hook run
 
     def run
-      AppMap::Minitest.begin_test self
+      AppMap::Minitest.begin_test self, name
       begin
         run_without_hook
       ensure
-        AppMap::Minitest.end_test self
+        AppMap::Minitest.end_test self, exception: $!
       end
     end
   end

data/lib/appmap/rails/request_handler.rb

@@ -7,14 +7,17 @@ module AppMap
   module Rails
     module RequestHandler
       class HTTPServerRequest < AppMap::Event::MethodEvent
-        attr_accessor :normalized_path_info, :request_method, :path_info, :params
+        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
 
-          @request_method = request.request_method
-          @normalized_path_info = normalized_path request
-          @path_info = request.path_info.split('?')[0]
+          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)
@@ -22,7 +25,7 @@ module AppMap
             else
               ActionDispatch::Http::ParameterFilter
             end
-          @params = parameter_filter_cls.new(::Rails.application.config.filter_parameters).filter(request.params)
+          self.params = parameter_filter_cls.new(::Rails.application.config.filter_parameters).filter(request.params)
         end
 
         def to_h
@@ -30,17 +33,25 @@ module AppMap
             h[:http_server_request] = {
               request_method: request_method,
               path_info: path_info,
-              normalized_path_info: normalized_path_info
+              mime_type: mime_type,
+              normalized_path_info: normalized_path_info,
+              authorization: authorization,
+              headers: headers,
             }.compact
 
-            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__
-              }
+            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
@@ -59,7 +70,7 @@ module AppMap
       end
 
       class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue
-        attr_accessor :status, :mime_type
+        attr_accessor :status, :mime_type, :headers
 
         def initialize(response, parent_id, elapsed)
           super AppMap::Event.next_id_counter, :return, Thread.current.object_id
@@ -68,13 +79,15 @@ module AppMap
           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: status,
-              mime_type: mime_type
+              status_code: status,
+              mime_type: mime_type,
+              headers: headers
             }.compact
           end
         end