appmap 0.42.0 → 0.45.1

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

@@ -5,6 +5,7 @@ require 'English'
 module AppMap
   class Hook
     LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+    LOG_HOOK = (ENV['DEBUG_HOOK'] == 'true')
 
     OBJECT_INSTANCE_METHODS = %i[! != !~ <=> == === =~ __id__ __send__ class clone define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
     OBJECT_STATIC_METHODS = %i[! != !~ < <= <=> == === =~ > >= __id__ __send__ alias_method allocate ancestors attr attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
@@ -32,93 +33,148 @@ module AppMap
     end
 
     attr_reader :config
+
     def initialize(config)
       @config = config
+      @trace_locations = []
+      # Paths that are known to be non-tracing
+      @notrace_paths = Set.new
     end
 
     # Observe class loading and hook all methods which match the config.
-    def enable &block
+    def enable(&block)
       require 'appmap/hook/method'
 
       hook_builtins
 
-      tp = TracePoint.new(:end) do |trace_point|
-        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
-
-        hook = lambda do |hook_cls|
-          lambda do |method_id|
-            method = begin
-              hook_cls.public_instance_method(method_id)
-            rescue NameError
-              warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
-              return
-            end
+      @trace_begin = TracePoint.new(:class, &method(:trace_class))
+      @trace_end = TracePoint.new(:end, &method(:trace_end))
 
-            warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
+      @trace_begin.enable(&block)
+    end
 
-            disasm = RubyVM::InstructionSequence.disasm(method)
-            # Skip methods that have no instruction sequence, as they are obviously trivial.
-            next unless disasm
+    # hook_builtins builds hooks for code that is built in to the Ruby standard library.
+    # No TracePoint events are emitted for builtins, so a separate hooking mechanism is needed. 
+    def hook_builtins
+      return unless self.class.lock_builtins
 
-            next if config.never_hook?(method)
+      class_from_string = lambda do |fq_class|
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
 
-            next unless \
-              config.always_hook?(hook_cls, method.name) ||
-              config.included_by_location?(method)
+      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
+            base_cls = class_from_string.(class_name)
 
-            hook_method = Hook::Method.new(config.package_for_method(method), hook_cls, method)
+            hook_method = lambda do |entry|
+              cls, method = entry
+              return false if config.never_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.new(hook.package, cls, method).activate
+            end
 
-            hook_method.activate
+            methods = []
+            methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
+            if base_cls.respond_to?(:singleton_class)
+              methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
+            end
+            methods.compact!
+            if methods.empty?
+              warn "Method #{method_name} not found on #{base_cls.name}"
+            else
+              methods.each(&hook_method)
+            end
           end
         end
+      end
+    end
+
+    protected
+
+    def trace_class(trace_point)
+      path = trace_point.path
 
-        instance_methods.each(&hook.(cls))
-        class_methods.each(&hook.(cls.singleton_class))
+      return if @notrace_paths.member?(path)
+
+      if config.path_enabled?(path)
+        location = trace_location(trace_point)
+        warn "Entering hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+        @trace_locations << location
+        unless @trace_end.enabled?
+          warn "Enabling hooking" if Hook::LOG || Hook::LOG_HOOK
+          @trace_end.enable
+        end
+      else
+        @notrace_paths << path
       end
+    end
 
-      tp.enable(&block)
+    def trace_location(trace_point)
+      [ trace_point.path, trace_point.lineno ].join(':')
     end
 
-    # hook_builtins builds hooks for code that is built in to the Ruby standard library.
-    # No TracePoint events are emitted for builtins, so a separate hooking mechanism is needed. 
-    def hook_builtins
-      return unless self.class.lock_builtins
+    def trace_end(trace_point)
+      cls = trace_point.self
 
-      class_from_string = lambda do |fq_class|
-        fq_class.split('::').inject(Object) do |mod, class_name|
-          mod.const_get(class_name)
+      instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_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
 
-      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
-
-          cls = class_from_string.(class_name)
-          method = \
-            begin
-              cls.instance_method(method_name)
-            rescue NameError
-              cls.method(method_name) rescue nil
-            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.
+          next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || '').split('::')[0])
+
+          method = begin
+            hook_cls.public_instance_method(method_id)
+          rescue NameError
+            warn "AppMap: Method #{hook_cls} #{method.name} is not accessible" if LOG
+            next
+          end
 
-          next if config.never_hook?(method)
+          warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
-          if method
-            Hook::Method.new(hook.package, cls, method).activate
-          else
-            warn "Method #{method_name} not found on #{cls.name}"
-          end
+          disasm = RubyVM::InstructionSequence.disasm(method)
+          # Skip methods that have no instruction sequence, as they are obviously trivial.
+          next unless disasm
+
+          package = config.lookup_package(hook_cls, method)
+          next unless package
+
+          Hook::Method.new(package, hook_cls, method).activate
         end
       end
+
+      instance_methods.each(&hook.(cls))
+      begin
+        # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
+        class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
+      rescue NameError
+        # NameError:
+        #   uninitialized constant Faraday::Connection
+        warn "NameError in #{__FILE__}: #{$!.message}"
+      end
+
+      location = @trace_locations.pop
+      warn "Leaving hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
+      if @trace_locations.empty?
+        warn "Disabling hooking" if Hook::LOG || Hook::LOG_HOOK
+        @trace_end.disable
+      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/middleware/remote_recording.rb

@@ -67,7 +67,7 @@ module AppMap
 
         response = JSON.generate \
           version: AppMap::APPMAP_FORMAT_VERSION,
-          classMap: AppMap.class_map(tracer.event_methods, include_source: AppMap.include_source?),
+          classMap: AppMap.class_map(tracer.event_methods),
           metadata: metadata,
           events: @events
 

data/lib/appmap/minitest.rb

@@ -26,8 +26,9 @@ module AppMap
       end
 
 
-      def finish
+      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
@@ -36,15 +37,17 @@ module AppMap
 
         AppMap::Minitest.add_event_methods @trace.event_methods
 
-        class_map = AppMap.class_map(@trace.event_methods, include_source: AppMap.include_source?)
+        class_map = AppMap.class_map(@trace.event_methods)
 
         feature_group = test.class.name.underscore.split('_')[0...-1].join('_').capitalize
         feature_name = test.name.split('_')[1..-1].join(' ')
         scenario_name = [ feature_group, feature_name ].join(' ')
 
-        AppMap::Minitest.save scenario_name,
-                              class_map,
-                              source_location,
+        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
@@ -63,11 +66,11 @@ module AppMap
         @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
@@ -78,9 +81,9 @@ module AppMap
         @event_methods += event_methods
       end
 
-      def save(example_name, class_map, source_location, events: 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[:frameworks] ||= []
@@ -91,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 = {
@@ -99,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?
@@ -115,9 +120,6 @@ module AppMap
 
       def run
         init
-        at_exit do
-          print_inventory
-        end
       end
     end
   end
@@ -135,7 +137,7 @@ if AppMap::Minitest.enabled?
       begin
         run_without_hook
       ensure
-        AppMap::Minitest.end_test self
+        AppMap::Minitest.end_test self, exception: $!
       end
     end
   end