appmap 0.41.1 → 0.44.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/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

@@ -35,7 +35,7 @@ module AppMap
                 else
                   "#{hook_method.name} (class resolution deferred)"
                 end
-          warn "AppMap: Hooking " + msg
+          warn "AppMap: Hooking #{msg} at line #{(hook_method.source_location || []).join(':')}"
         end
 
         defined_class = @defined_class

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

@@ -6,15 +6,38 @@ require 'appmap/hook'
 module AppMap
   module Rails
     module RequestHandler
+      # Host and User-Agent will just introduce needless variation.
+      # Content-Type and Authorization get their own fields in the request.
+      IGNORE_HEADERS = %w[host user_agent content_type authorization].map(&:upcase).map {|h| "HTTP_#{h}"}.freeze
+
+      class << self
+        def selected_headers(env)
+          # Rack prepends HTTP_ to all client-sent headers.
+          matching_headers = env
+            .select { |k,v| k.start_with? 'HTTP_'}
+            .reject { |k,v| IGNORE_HEADERS.member?(k) }
+            .reject { |k,v| v.blank? }
+            .each_with_object({}) do |kv, memo|
+              key = kv[0].sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+              value = kv[1]
+              memo[key] = value
+            end
+          matching_headers.blank? ? nil : matching_headers
+        end
+      end
+
       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 = RequestHandler.selected_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 +45,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,7 +53,10 @@ 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|
@@ -39,8 +65,11 @@ module AppMap
                 name: key,
                 class: val.class.name,
                 value: self.class.display_string(val),
-                object_id: val.__id__
-              }
+                object_id: val.__id__,
+              }.tap do |message|
+                properties = object_properties(val)
+                message[:properties] = properties if properties
+              end
             end
           end
         end
@@ -59,7 +88,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 +97,15 @@ module AppMap
           self.mime_type = response.headers['Content-Type']
           self.parent_id = parent_id
           self.elapsed = elapsed
+          self.headers = RequestHandler.selected_headers(response.headers)
         end
 
         def to_h
           super.tap do |h|
             h[:http_server_response] = {
               status: status,
-              mime_type: mime_type
+              mime_type: mime_type,
+              headers: headers
             }.compact
           end
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'appmap/util'
+require 'set'
 
 module AppMap
   # Integration of AppMap with RSpec. When enabled with APPMAP=true, the AppMap tracer will
@@ -13,58 +14,9 @@ module AppMap
       AppMap.detect_metadata
     end
 
-    module FeatureAnnotations
-      def feature
-        return nil unless annotations
-
-        annotations[:feature]
-      end
-
-      def labels
-        labels = metadata[:appmap]
-        if labels.is_a?(Array)
-          labels
-        elsif labels.is_a?(String) || labels.is_a?(Symbol)
-          [ labels ]
-        else
-          []
-        end
-      end
-
-      def feature_group
-        return nil unless annotations
-
-        annotations[:feature_group]
-      end
-
-      def annotations
-        metadata.tap do |md|
-          description_args_hashes.each do |h|
-            md.merge! h
-          end
-        end
-      end
-
-      protected
-
-      def metadata
-        return {} unless example_obj.respond_to?(:metadata)
-
-        example_obj.metadata
-      end
-
-      def description_args_hashes
-        return [] unless example_obj.respond_to?(:metadata)
-
-        (example_obj.metadata[:description_args] || []).select { |arg| arg.is_a?(Hash) }
-      end
-    end
-
     # ScopeExample and ScopeExampleGroup is a way to handle the weird way that RSpec
     # stores the nested example names.
     ScopeExample = Struct.new(:example) do
-      include FeatureAnnotations
-
       alias_method :example_obj, :example
 
       def description?
@@ -83,8 +35,6 @@ module AppMap
     # As you can see here, the way that RSpec stores the example description and
     # represents the example group hierarchy is pretty weird.
     ScopeExampleGroup = Struct.new(:example_group) do
-      include FeatureAnnotations
-
       alias_method :example_obj, :example_group
 
       def description_args
@@ -133,13 +83,20 @@ module AppMap
           page.driver.options[:http_client].instance_variable_get('@server_url').port
         end
 
-        warn "Starting recording of example #{example}" if AppMap::RSpec::LOG
+        warn "Starting recording of example #{example}@#{source_location}" if AppMap::RSpec::LOG
         @trace = AppMap.tracing.trace
         @webdriver_port = webdriver_port.()
       end
 
-      def finish
+      def source_location
+        result = example.location_rerun_argument.split(':')[0]
+        result = result[2..-1] if result.index('./') == 0
+        result
+      end
+
+      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
@@ -148,22 +105,16 @@ module AppMap
 
         AppMap::RSpec.add_event_methods @trace.event_methods
 
-        class_map = AppMap.class_map(@trace.event_methods, include_source: false)
+        class_map = AppMap.class_map(@trace.event_methods)
 
         description = []
         scope = ScopeExample.new(example)
-        feature_group = feature = nil
 
-        labels = []
         while scope
-          labels += scope.labels
           description << scope.description
-          feature ||= scope.feature
-          feature_group ||= scope.feature_group
           scope = scope.parent
         end
 
-        labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
         description.reject!(&:nil?).reject!(&:blank?)
         default_description = description.last
         description.reverse!
@@ -177,24 +128,12 @@ module AppMap
 
         full_description = normalize.call(description.join(' '))
 
-        compute_feature_name = lambda do
-          return 'unknown' if description.empty?
-
-          feature_description = description.dup
-          num_tokens = [2, feature_description.length - 1].min
-          feature_description[0...num_tokens].map(&:strip).join(' ')
-        end
-
-        feature_group ||= normalize.call(default_description).underscore.gsub('/', '_').humanize
-        feature_name = feature || compute_feature_name.call if feature_group
-        feature_name = normalize.call(feature_name) if feature_name
-
-        AppMap::RSpec.save full_description,
-                           class_map,
-                           events: events,
-                           feature_name: feature_name,
-                           feature_group_name: feature_group,
-                           labels: labels.blank? ? nil : labels
+        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
 
@@ -212,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
@@ -227,13 +166,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::RSpec.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[:labels] = labels if labels
           m[:frameworks] ||= []
           m[:frameworks] << {
             name: 'rspec',
@@ -242,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 = {
@@ -250,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?
@@ -266,9 +205,6 @@ module AppMap
 
       def run
         init
-        at_exit do
-          print_inventory
-        end
       end
     end
   end
@@ -290,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