appmap 0.42.1 → 0.46.0

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,108 +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
-        # 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|
-            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
 
-        instance_methods.each(&hook.(cls))
-        # 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
+    protected
+
+    def trace_class(trace_point)
+      path = trace_point.path
+
+      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
-        AppMap.tracing.record_event return_event
+        return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
+        AppMap.tracing.record_event(return_event) if 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

data/lib/appmap/railtie.rb

@@ -8,12 +8,12 @@ module AppMap
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
     initializer 'appmap.subscribe' do |_| # params: app
-      require 'appmap/rails/sql_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
+      require 'appmap/handler/rails/sql_handler'
+      require 'appmap/handler/rails/request_handler'
+      ActiveSupport::Notifications.subscribe 'sql.sequel', AppMap::Handler::Rails::SQLHandler.new
+      ActiveSupport::Notifications.subscribe 'sql.active_record', AppMap::Handler::Rails::SQLHandler.new
 
-      AppMap::Rails::RequestHandler::HookMethod.new.activate
+      AppMap::Handler::Rails::RequestHandler::HookMethod.new.activate
     end
 
     # appmap.trace begins recording an AppMap trace and writes it to appmap.json.

data/lib/appmap/record.rb

@@ -23,5 +23,5 @@ at_exit do
     'classMap' => AppMap.class_map(tracer.event_methods),
     'events' => events
   }
-  File.write 'appmap.json', JSON.generate(appmap)
+  AppMap::Util.write_appmap('appmap.json', JSON.generate(appmap))
 end

data/lib/appmap/rspec.rb

@@ -94,8 +94,9 @@ module AppMap
         result
       end
 
-      def finish
+      def finish(exception)
         warn "Finishing recording of example #{example}" if AppMap::RSpec::LOG
+        warn "Exception: #{exception}" if exception && AppMap::RSpec::LOG
 
         events = []
         AppMap.tracing.delete @trace
@@ -104,7 +105,7 @@ module AppMap
 
         AppMap::RSpec.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)
 
         description = []
         scope = ScopeExample.new(example)
@@ -127,9 +128,11 @@ module AppMap
 
         full_description = normalize.call(description.join(' '))
 
-        AppMap::RSpec.save full_description,
-                           class_map,
-                           source_location,
+        AppMap::RSpec.save name: full_description,
+                           class_map: class_map,
+                           source_location: source_location,
+                           test_status: exception ? 'failed' : 'succeeded',
+                           exception: exception,
                            events: events
       end
     end
@@ -148,11 +151,11 @@ module AppMap
         @recordings_by_example[example.object_id] = Recording.new(example)
       end
 
-      def end_spec(example)
+      def end_spec(example, exception:)
         recording = @recordings_by_example.delete(example.object_id)
         return warn "No recording found for #{example}" unless recording
 
-        recording.finish
+        recording.finish exception
       end
 
       def config
@@ -163,12 +166,11 @@ 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::RSpec.metadata.tap do |m|
-          m[:name] = example_name
+          m[:name] = name
           m[:source_location] = source_location
           m[:app] = AppMap.configuration.name
-          m[:labels] = labels if labels
           m[:frameworks] ||= []
           m[:frameworks] << {
             name: 'rspec',
@@ -177,6 +179,13 @@ module AppMap
           m[:recorder] = {
             name: 'rspec'
           }
+          m[:test_status] = test_status
+          if exception
+            m[:exception] = {
+              class: exception.class.name,
+              message: exception.to_s
+            }
+          end
         end
 
         appmap = {
@@ -185,14 +194,9 @@ module AppMap
           classMap: class_map,
           events: events
         }.compact
-        fname = AppMap::Util.scenario_filename(example_name)
-
-        File.write(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
-      end
+        fname = AppMap::Util.scenario_filename(name)
 
-      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?
@@ -201,9 +205,6 @@ module AppMap
 
       def run
         init
-        at_exit do
-          print_inventory
-        end
       end
     end
   end
@@ -225,7 +226,7 @@ if AppMap::RSpec.enabled?
               begin
                 instance_exec(&fn)
               ensure
-                AppMap::RSpec.end_spec example
+                AppMap::RSpec.end_spec example, exception: $!
               end
             end
           end