appmap 0.37.2 → 0.41.0

data/lib/appmap/config.rb

@@ -2,15 +2,22 @@
 
 module AppMap
   class Config
-    Package = Struct.new(:path, :gem, :package_name, :exclude, :labels) do
+    Package = Struct.new(:path, :gem, :package_name, :exclude, :labels, :shallow) do
+      # Indicates that only the entry points to a package will be recorded.
+      # Once the code has entered a package, subsequent calls within the package will not be
+      # recorded unless the code leaves the package and re-enters it.
+      def shallow?
+        shallow
+      end
+
       class << self
-        def build_from_path(path, package_name: nil, exclude: [], labels: [])
-          Package.new(path, nil, package_name, exclude, labels)
+        def build_from_path(path, shallow: false, package_name: nil, exclude: [], labels: [])
+          Package.new(path, nil, package_name, exclude, labels, shallow)
         end
 
-        def build_from_gem(gem, package_name: nil, exclude: [], labels: [])
+        def build_from_gem(gem, shallow: true, package_name: nil, exclude: [], labels: [])
           gem_paths(gem).map do |gem_path|
-            Package.new(gem_path, gem, package_name, exclude, labels)
+            Package.new(gem_path, gem, package_name, exclude, labels, shallow)
           end
         end
 
@@ -36,7 +43,8 @@ module AppMap
           package_name: package_name,
           gem: gem,
           exclude: exclude.blank? ? nil : exclude,
-          labels: labels.blank? ? nil : labels
+          labels: labels.blank? ? nil : labels,
+          shallow: shallow
         }.compact
       end
     end
@@ -49,31 +57,32 @@ module AppMap
     # Methods that should always be hooked, with their containing
     # package and labels that should be applied to them.
     HOOKED_METHODS = {
-      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.build_from_path('active_support', package_name: 'active_support', labels: %w[security crypto]))
+      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.build_from_path('active_support', package_name: 'active_support', labels: %w[provider.secure_compare])),
+      'ActionView::Renderer' => Hook.new(:render, Package.build_from_path('action_view', package_name: 'action_view', labels: %w[mvc.view]))
     }.freeze
 
     BUILTIN_METHODS = {
       'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGES),
-      'Digest::Instance' => Hook.new(:digest, OPENSSL_PACKAGES),
       'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGES),
       'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES),
       'OpenSSL::Cipher' => Hook.new(%i[encrypt decrypt final], OPENSSL_PACKAGES),
       'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGES),
-      'Net::HTTP' => Hook.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[http io])),
-      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[smtp email io])),
-      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[pop pop3 email io])),
-      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[imap email io])),
-      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[serialization marshal])),
-      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[serialization yaml])),
-      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json])),
-      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json]))
+      'Net::HTTP' => Hook.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[protocol.http io])),
+      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[protocol.smtp protocol.email io])),
+      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[protocol.pop protocol.email io])),
+      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[protocol.imap protocol.email io])),
+      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[format.marshal provider.serialization marshal])),
+      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[format.yaml provider.serialization])),
+      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[format.json provider.serialization])),
+      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json provider.serialization])),
     }.freeze
 
-    attr_reader :name, :packages
+    attr_reader :name, :packages, :exclude
 
-    def initialize(name, packages = [])
+    def initialize(name, packages = [], exclude = [])
       @name = name
       @packages = packages
+      @exclude = exclude
     end
 
     class << self
@@ -91,27 +100,38 @@ module AppMap
           raise 'AppMap package configuration should specify gem or path, not both' if gem && path
 
           if gem
-            Package.build_from_gem(gem, exclude: package['exclude'] || [])
+            shallow = package['shallow']
+            # shallow is true by default for gems
+            shallow = true if shallow.nil?
+            Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
           else
-            [ Package.build_from_path(path, exclude: package['exclude'] || []) ]
+            [ Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow']) ]
           end
         end.flatten
-        Config.new config_data['name'], packages
+        Config.new config_data['name'], packages, config_data['exclude'] || []
       end
     end
 
     def to_h
       {
         name: name,
-        packages: packages.map(&:to_h)
+        packages: packages.map(&:to_h),
+        exclude: exclude
       }
     end
 
+    # package_for_method finds the Package, if any, which configures the hook
+    # for a method.
     def package_for_method(method)
+      package_hooked_by_class(method) || package_hooked_by_source_location(method)
+    end
+
+    def package_hooked_by_class(method)
       defined_class, _, method_name = ::AppMap::Hook.qualify_method_name(method)
-      package = find_package(defined_class, method_name)
-      return package if package
+      return find_package(defined_class, method_name)
+    end
 
+    def package_hooked_by_source_location(method)
       location = method.source_location
       location_file, = location
       return unless location_file
@@ -123,14 +143,22 @@ module AppMap
       end
     end
 
-    def included_by_location?(method)
-      !!package_for_method(method)
+    def never_hook?(method)
+      defined_class, separator, method_name = ::AppMap::Hook.qualify_method_name(method)
+      return true if exclude.member?(defined_class) || exclude.member?([ defined_class, separator, method_name ].join)
     end
 
+    # always_hook? indicates a method that should always be hooked.
     def always_hook?(defined_class, method_name)
       !!find_package(defined_class, method_name)
     end
 
+    # included_by_location? indicates a method whose source location matches a method definition that has been
+    # configured for inclusion.
+    def included_by_location?(method)
+      !!package_for_method(method)
+    end
+
     def find_package(defined_class, method_name)
       hook = find_hook(defined_class)
       return nil unless hook

data/lib/appmap/hook.rb

@@ -6,6 +6,9 @@ module AppMap
   class Hook
     LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == '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
+
     @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
     @method_arity = ::Method.instance_method(:arity)
 
@@ -42,12 +45,17 @@ module AppMap
       tp = TracePoint.new(:end) do |trace_point|
         cls = trace_point.self
 
-        instance_methods = cls.public_instance_methods(false)
-        class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
+        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 = hook_cls.public_instance_method(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
 
             warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
@@ -55,6 +63,8 @@ module AppMap
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
+            next if config.never_hook?(method)
+
             next unless \
               config.always_hook?(hook_cls, method.name) ||
               config.included_by_location?(method)
@@ -76,6 +86,8 @@ module AppMap
       tp.enable(&block)
     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
 
@@ -89,6 +101,7 @@ module AppMap
         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
@@ -97,6 +110,8 @@ module AppMap
               cls.method(method_name) rescue nil
             end
 
+          next if config.never_hook?(method)
+
           if method
             Hook::Method.new(hook.package, cls, method).activate
           else

data/lib/appmap/hook/method.rb

@@ -39,6 +39,7 @@ module AppMap
         end
 
         defined_class = @defined_class
+        hook_package = self.hook_package
         hook_method = self.hook_method
         before_hook = self.method(:before_hook)
         after_hook = self.method(:after_hook)
@@ -48,29 +49,34 @@ module AppMap
         hook_class.instance_eval do 
           hook_method_def = Proc.new do |*args, &block|
             instance_method = hook_method.bind(self).to_proc
+            call_instance_method = -> { instance_method.call(*args, &block) }
 
             # We may not have gotten the class for the method during
             # initialization (e.g. for a singleton method on an embedded
             # struct), so make sure we have it now.
-            defined_class,_ = Hook.qualify_method_name(hook_method) unless defined_class
+            defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
 
-            hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-            enabled = true if !hook_disabled && AppMap.tracing.enabled?
-            return instance_method.call(*args, &block) unless enabled
+            reentrant = Thread.current[HOOK_DISABLE_KEY]
+            disabled_by_shallow_flag = \
+              -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
 
-            call_event, start_time = with_disabled_hook.() do
-              before_hook.(self, defined_class, args)
+            enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
+
+            return call_instance_method.call unless enabled
+
+            call_event, start_time = with_disabled_hook.call do
+              before_hook.call(self, defined_class, args)
             end
             return_value = nil
             exception = nil
             begin
-              return_value = instance_method.(*args, &block)
+              return_value = call_instance_method.call
             rescue
               exception = $ERROR_INFO
               raise
             ensure
-              with_disabled_hook.() do
-                after_hook.(self, call_event, start_time, return_value, exception)
+              with_disabled_hook.call do
+                after_hook.call(self, call_event, start_time, return_value, exception)
               end
             end
           end
@@ -87,7 +93,7 @@ module AppMap
         [ call_event, TIME_NOW.call ]
       end
 
-      def after_hook(receiver, 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 = \
@@ -95,12 +101,12 @@ module AppMap
         AppMap.tracing.record_event return_event
       end
 
-      def with_disabled_hook(&fn)
+      def with_disabled_hook(&function)
         # Don't record functions, such as to_s and inspect, that might be called
         # by the fn. Otherwise there can be a stack overflow.
         Thread.current[HOOK_DISABLE_KEY] = true
         begin
-          fn.call
+          function.call
         ensure
           Thread.current[HOOK_DISABLE_KEY] = false
         end

data/lib/appmap/rails/request_handler.rb

@@ -7,12 +7,13 @@ module AppMap
   module Rails
     module RequestHandler
       class HTTPServerRequest < AppMap::Event::MethodEvent
-        attr_accessor :request_method, :path_info, :params
+        attr_accessor :normalized_path_info, :request_method, :path_info, :params
 
         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]
           # ActionDispatch::Http::ParameterFilter is deprecated
           parameter_filter_cls = \
@@ -28,8 +29,9 @@ module AppMap
           super.tap do |h|
             h[:http_server_request] = {
               request_method: request_method,
-              path_info: path_info
-            }
+              path_info: path_info,
+              normalized_path_info: normalized_path_info
+            }.compact
 
             h[:message] = params.keys.map do |key|
               val = params[key]
@@ -42,6 +44,18 @@ module AppMap
             end
           end
         end
+
+        private
+
+        def normalized_path(request, router = ::Rails.application.routes.router)
+          router.recognize request do |route, _|
+            app = route.app
+            next unless app.matches? request
+            return normalized_path request, app.rack_app.routes.router if app.engine?
+
+            return route.path.spec.to_s
+          end
+        end
       end
 
       class HTTPServerResponse < AppMap::Event::MethodReturnIgnoreValue

data/lib/appmap/railtie.rb

@@ -5,13 +5,9 @@ module AppMap
   class Railtie < ::Rails::Railtie
     config.appmap = ActiveSupport::OrderedOptions.new
 
-    initializer 'appmap.init' do |_| # params: app
-      require 'appmap'
-    end
-
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
-    initializer 'appmap.subscribe', after: 'appmap.init' do |_| # params: app
+    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

data/lib/appmap/trace.rb

@@ -15,34 +15,38 @@ module AppMap
 
     class Tracing
       def initialize
-        @tracing = []
+        @tracers = []
       end
 
       def empty?
-        @tracing.empty?
+        @tracers.empty?
       end
 
       def trace(enable: true)
         Tracer.new.tap do |tracer|
-          @tracing << tracer
+          @tracers << tracer
           tracer.enable if enable
         end
       end
 
       def enabled?
-        @tracing.any?(&:enabled?)
+        @tracers.any?(&:enabled?)
+      end
+
+      def last_package_for_current_thread
+        @tracers.first&.last_package_for_current_thread
       end
 
       def record_event(event, package: nil, defined_class: nil, method: nil)
-        @tracing.each do |tracer|
+        @tracers.each do |tracer|
           tracer.record_event(event, package: package, defined_class: defined_class, method: method)
         end
       end
 
       def delete(tracer)
-        return unless @tracing.member?(tracer)
+        return unless @tracers.member?(tracer)
 
-        @tracing.delete(tracer)
+        @tracers.delete(tracer)
         tracer.disable
       end
     end
@@ -52,6 +56,7 @@ module AppMap
     # Records the events which happen in a program.
     def initialize
       @events = []
+      @last_package_for_thread = {}
       @methods = Set.new
       @enabled = false
     end
@@ -75,11 +80,17 @@ module AppMap
     def record_event(event, package: nil, defined_class: nil, method: nil)
       return unless @enabled
 
+      @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event
       @methods << Trace::ScopedMethod.new(package, defined_class, method, event.static) \
         if package && defined_class && method && (event.event == :call)
     end
 
+    # Gets the last package which was observed on the current thread.
+    def last_package_for_current_thread
+      @last_package_for_thread[Thread.current.object_id]
+    end
+
     # Gets a unique list of the methods that were invoked by the program.
     def event_methods
       @methods.to_a

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.37.2'
+  VERSION = '0.41.0'
 
-  APPMAP_FORMAT_VERSION = '1.3'
+  APPMAP_FORMAT_VERSION = '1.4'
 end

data/spec/abstract_controller_base_spec.rb

@@ -1,89 +1,150 @@
 require 'rails_spec_helper'
 
 describe 'AbstractControllerBase' do
-  shared_examples 'rails version' do |rails_major_version|
-    include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" do
-      around(:each) do |example|
+  %w[5 6].each do |rails_major_version| # rubocop:disable Metrics/BlockLength
+    context "in Rails #{rails_major_version}" do
+      include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app"
+      def run_spec(spec_name)
         FileUtils.rm_rf tmpdir
         FileUtils.mkdir_p tmpdir
-        cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:8"
+        cmd = <<~CMD.gsub "\n", ' '
+          docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true
+          -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
+        CMD
         run_cmd cmd, chdir: fixture_dir
+      end
 
-        example.run
+      def tmpdir
+        'tmp/spec/AbstractControllerBase'
       end
 
-      let(:tmpdir) { 'tmp/spec/AbstractControllerBase' }
-      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+      let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
+      let(:events) { appmap['events'] }
 
       describe 'testing with rspec' do
-        it 'inventory file is printed' do
-          expect(File).to exist(File.join(tmpdir, 'appmap/rspec/Inventory.appmap.json'))
-        end
-
-        it 'message fields are recorded in the appmap' do
-          expect(File).to exist(appmap_json)
-          appmap = JSON.parse(File.read(appmap_json)).to_yaml
+        describe 'creating a user' do
+          before(:all) { run_spec 'spec/controllers/users_controller_api_spec.rb:8' }
+          let(:appmap_json_file) do
+            'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json'
+          end
 
-          expect(appmap).to include(<<-MESSAGE.strip)
-  message:
-  - name: login
-    class: String
-    value: alice
-    object_id:
-          MESSAGE
+          it 'inventory file is printed' do
+            expect(File).to exist(File.join(tmpdir, 'appmap/rspec/Inventory.appmap.json'))
+          end
 
-          expect(appmap).to include(<<-MESSAGE.strip)
-  - name: password
-    class: String
-    value: "[FILTERED]"
-    object_id:
-          MESSAGE
+          it 'message fields are recorded in the appmap' do
+            expect(events).to include(
+              hash_including(
+                'http_server_request' => hash_including(
+                  'request_method' => 'POST',
+                  'path_info' => '/api/users'
+                ),
+                'message' => include(
+                  hash_including(
+                    'name' => 'login',
+                    'class' => 'String',
+                    'value' => 'alice',
+                    'object_id' => Integer
+                  ),
+                  hash_including(
+                    'name' => 'password',
+                    'class' => 'String',
+                    'value' => '[FILTERED]',
+                    'object_id' => Integer
+                  )
+                )
+              ),
+              hash_including(
+                'http_server_response' => {
+                  'status' => 201,
+                  'mime_type' => 'application/json; charset=utf-8'
+                }
+              )
+            )
+          end
 
-          expect(appmap).to include(<<-SERVER_REQUEST.strip)
-  http_server_request:
-    request_method: POST
-    path_info: "/api/users"
-          SERVER_REQUEST
+          it 'properly captures method parameters in the appmap' do
+            expect(events).to include hash_including(
+              'event' => 'call',
+              'thread_id' => Integer,
+              'defined_class' => 'Api::UsersController',
+              'method_id' => 'build_user',
+              'path' => 'app/controllers/api/users_controller.rb',
+              'lineno' => 23,
+              'static' => false,
+              'parameters' => include(
+                'name' => 'params',
+                'class' => 'ActiveSupport::HashWithIndifferentAccess',
+                'object_id' => Integer,
+                'value' => '{"login"=>"alice"}',
+                'kind' => 'req'
+              ),
+              'receiver' => anything
+            )
+          end
 
-          expect(appmap).to include(<<-SERVER_RESPONSE.strip)
-  http_server_response:
-    status: 201
-    mime_type: application/json; charset=utf-8
-          SERVER_RESPONSE
+          it 'returns a minimal event' do
+            expect(events).to include hash_including(
+              'event' => 'return',
+              'return_value' => Hash,
+              'id' => Integer,
+              'thread_id' => Integer,
+              'parent_id' => Integer,
+              'elapsed' => Numeric
+            )
+          end
         end
 
-        it 'properly captures method parameters in the appmap' do
-          expect(File).to exist(appmap_json)
-          appmap = JSON.parse(File.read(appmap_json)).to_yaml
+        describe 'showing a user' do
+          before(:all) { run_spec 'spec/controllers/users_controller_spec.rb:22' }
+          let(:appmap_json_file) do
+            'UsersController_GET_users_login_shows_the_user.appmap.json'
+          end
 
-          expect(appmap).to match(<<-CREATE_CALL.strip)
-  event: call
-  thread_id: .*
-  defined_class: Api::UsersController
-  method_id: build_user
-  path: app/controllers/api/users_controller.rb
-  lineno: 23
-  static: false
-  parameters:
-  - name: params
-    class: ActiveSupport::HashWithIndifferentAccess
-    object_id: .*
-    value: '{"login"=>"alice"}'
-    kind: req
-  receiver:
-          CREATE_CALL
+          it 'records the normalized path info' do
+            expect(events).to include(
+              hash_including(
+                'http_server_request' => {
+                  'request_method' => 'GET',
+                  'path_info' => '/users/alice',
+                  'normalized_path_info' => '/users/:id(.:format)'
+                }
+              )
+            )
+          end
         end
 
-        it 'returns a minimal event' do
-          expect(File).to exist(appmap_json)
-          appmap = JSON.parse(File.read(appmap_json))
-          event = appmap['events'].find { |event| event['event'] == 'return' && event['return_value'] }
-          expect(event.keys).to eq(%w[id event thread_id parent_id elapsed return_value])
+        describe 'listing users' do
+          before(:all) { run_spec 'spec/controllers/users_controller_spec.rb:11' }
+          let(:appmap_json_file) { 'UsersController_GET_users_lists_the_users.appmap.json' }
+
+          it 'records and labels view rendering' do
+            expect(events).to include hash_including(
+              'event' => 'call',
+              'thread_id' => Numeric,
+              'defined_class' => 'ActionView::Renderer',
+              'method_id' => 'render',
+              'path' => String,
+              'lineno' => Integer,
+              'static' => false
+            )
+
+            expect(appmap['classMap']).to include hash_including(
+              'name' => 'action_view',
+              'children' => include(hash_including(
+                'name' => 'ActionView',
+                'children' => include(hash_including(
+                  'name' => 'Renderer',
+                  'children' => include(hash_including(
+                    'name' => 'render',
+                    'labels' => ['mvc.view']
+                  ))
+                ))
+              ))
+            )
+          end
         end
       end
     end
   end
-
-  it_behaves_like 'rails version', '5'
-  it_behaves_like 'rails version', '6'
 end