appmap 0.23.0 → 0.27.0

data/lib/appmap/middleware/remote_recording.rb

@@ -4,17 +4,13 @@ module AppMap
   module Middleware
     # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
     class RemoteRecording
-
       def initialize(app)
         require 'appmap/command/record'
-        require 'appmap/command/upload'
-        require 'appmap/trace/tracer'
-        require 'appmap/config'
         require 'json'
 
         @app = app
-        @features = AppMap.inspect(config)
-        @functions = @features.map(&:collect_functions).flatten
+        @config = AppMap.configure
+        AppMap::Hook.hook(@config)
       end
 
       def event_loop
@@ -29,23 +25,23 @@ module AppMap
       end
 
       def start_recording
-        return [ false, 'Recording is already in progress' ] if @tracer
+        return [ 409, 'Recording is already in progress' ] if @tracer
 
         @events = []
-        @tracer = AppMap::Trace.tracers.trace(@functions)
+        @tracer = AppMap.tracing.trace
         @event_thread = Thread.new { event_loop }
         @event_thread.abort_on_exception = true
 
-        [ true ]
+        [ 200 ]
       end
 
       def stop_recording(req)
-        return [ false, 'No recording is in progress' ] unless @tracer
+        return [ 404, 'No recording is in progress' ] unless @tracer
 
         tracer = @tracer
         @tracer = nil
 
-        AppMap::Trace.tracers.delete(tracer)
+        AppMap.tracing.delete(tracer)
 
         @event_thread.exit
         @event_thread.join
@@ -73,9 +69,13 @@ module AppMap
           name: 'remote_recording'
         }
 
-        response = JSON.generate(version: AppMap::APPMAP_FORMAT_VERSION, classMap: @features, metadata: metadata, events: @events)
+        response = JSON.generate \
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          classMap: AppMap.class_map(@config, tracer.event_methods),
+          metadata: metadata,
+          events: @events
 
-        [ true, response ]
+        [ 200, response ]
       end
 
       def call(env)
@@ -103,20 +103,13 @@ module AppMap
             [ 404, '' ]
           end
 
-        status = 200 if status == true
-        status = 500 if status == false
-
-        [status, { 'Content-Type' => 'application/text' }, [body || '']]
+        [status, { 'Content-Type' => 'application/json' }, [body || '']]
       end
 
       def html_response?(headers)
         headers['Content-Type'] && headers['Content-Type'] =~ /html/
       end
 
-      def config
-        @config ||= AppMap::Config.load_from_file 'appmap.yml'
-      end
-
       def recording?
         !@event_thread.nil?
       end

data/lib/appmap/rails/action_handler.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'appmap/event'
+
 module AppMap
   module Rails
     module ActionHandler
@@ -12,11 +16,11 @@ module AppMap
       class HTTPServerRequest
         include ContextKey
 
-        class Call < AppMap::Trace::MethodEvent
+        class Call < AppMap::Event::MethodEvent
           attr_accessor :payload
 
           def initialize(path, lineno, payload)
-            super AppMap::Trace::MethodEvent.next_id, :call, HTTPServerRequest, :call, path, lineno, false, Thread.current.object_id
+            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, false, Thread.current.object_id
 
             self.payload = payload
           end
@@ -45,18 +49,18 @@ module AppMap
         def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
           event = Call.new(__FILE__, __LINE__, payload)
           Thread.current[context_key] = Context.new(event.id, Time.now)
-          AppMap::Trace.tracers.record_event(event)
+          AppMap.tracing.record_event(event)
         end
       end
 
       class HTTPServerResponse
         include ContextKey
 
-        class Call < AppMap::Trace::MethodReturnIgnoreValue
+        class Call < AppMap::Event::MethodReturnIgnoreValue
           attr_accessor :payload
 
           def initialize(path, lineno, payload, parent_id, elapsed)
-            super AppMap::Trace::MethodEvent.next_id, :return, HTTPServerResponse, :call, path, lineno, false, Thread.current.object_id
+            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, false, Thread.current.object_id
 
             self.payload = payload
             self.parent_id = parent_id
@@ -79,7 +83,7 @@ module AppMap
           Thread.current[context_key] = nil
 
           event = Call.new(__FILE__, __LINE__, payload, context.id, Time.now - context.start_time)
-          AppMap::Trace.tracers.record_event(event)
+          AppMap.tracing.record_event(event)
         end
       end
     end

data/lib/appmap/rails/sql_handler.rb

@@ -1,13 +1,15 @@
-require 'appmap/trace/tracer'
+# frozen_string_literal: true
+
+require 'appmap/event'
 
 module AppMap
   module Rails
     class SQLHandler
-      class SQLCall < AppMap::Trace::MethodEvent
+      class SQLCall < AppMap::Event::MethodEvent
         attr_accessor :payload
 
         def initialize(path, lineno, payload)
-          super AppMap::Trace::MethodEvent.next_id, :call, SQLHandler, :call, path, lineno, false, Thread.current.object_id
+          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, false, Thread.current.object_id
 
           self.payload = payload
         end
@@ -26,9 +28,9 @@ module AppMap
         end
       end
 
-      class SQLReturn < AppMap::Trace::MethodReturnIgnoreValue
+      class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
         def initialize(path, lineno, parent_id, elapsed)
-          super AppMap::Trace::MethodEvent.next_id, :return, SQLHandler, :call, path, lineno, false, Thread.current.object_id
+          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, false, Thread.current.object_id
 
           self.parent_id = parent_id
           self.elapsed = elapsed
@@ -92,7 +94,7 @@ module AppMap
       end
 
       def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-        return if AppMap::Trace.tracers.empty?
+        return if AppMap.tracing.empty?
 
         reentry_key = "#{self.class.name}#call"
         return if Thread.current[reentry_key] == true
@@ -100,9 +102,6 @@ module AppMap
         Thread.current[reentry_key] = true
         begin
           sql = payload[:sql].strip
-          sql_upper = sql.upcase
-
-          return unless WHITELIST.find { |keyword| sql_upper.index(keyword) == 0 }
 
           # Detect whether a function call within a specified filename is present in the call stack.
           find_in_backtrace = lambda do |file_name, function_name = nil|
@@ -135,14 +134,12 @@ module AppMap
           SQLExaminer.examine payload, sql: sql
 
           call = SQLCall.new(__FILE__, __LINE__, payload)
-          AppMap::Trace.tracers.record_event(call)
-          AppMap::Trace.tracers.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
+          AppMap.tracing.record_event(call)
+          AppMap.tracing.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
         ensure
           Thread.current[reentry_key] = nil
         end
       end
-
-      WHITELIST = %w[SELECT INSERT UPDATE DELETE].freeze
     end
   end
 end

data/lib/appmap/railtie.rb

@@ -1,32 +1,45 @@
+# frozen_string_literal: true
+
 module AppMap
+  # Railtie connects the AppMap recorder to Rails-specific features.
   class Railtie < ::Rails::Railtie
     config.appmap = ActiveSupport::OrderedOptions.new
 
-    initializer 'appmap.trace' do |app|
+    initializer 'appmap.init' do |_| #  params: app
+      AppMap.configure
+    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
+      require 'appmap/rails/sql_handler'
+      require 'appmap/rails/action_handler'
+      ActiveSupport::Notifications.subscribe 'sql.sequel', AppMap::Rails::SQLHandler.new
+      ActiveSupport::Notifications.subscribe 'sql.active_record', AppMap::Rails::SQLHandler.new
+      ActiveSupport::Notifications.subscribe \
+        'start_processing.action_controller', AppMap::Rails::ActionHandler::HTTPServerRequest.new
+      ActiveSupport::Notifications.subscribe \
+        'process_action.action_controller', AppMap::Rails::ActionHandler::HTTPServerResponse.new
+    end
+
+    # appmap.trace begins recording an AppMap trace and writes it to appmap.json.
+    # This behavior is only activated if the configuration setting app.config.appmap.enabled
+    # is truthy.
+    initializer 'appmap.trace', after: 'appmap.subscribe' do |app|
       lambda do
         return unless app.config.appmap.enabled
 
-        require 'appmap'
-        require 'appmap/config'
-        config = AppMap::Config.load_from_file 'appmap.yml'
-
         require 'appmap/command/record'
         require 'json'
-        AppMap::Command::Record.new(config).perform do |features, events|
-          File.open('appmap.json', 'w').write JSON.generate(classMap: features, events: events)
+        AppMap::Command::Record.new(AppMap.configuration).perform do |version, metadata, class_map, events|
+          appmap = JSON.generate \
+            version: version,
+            metadata: metadata,
+            classMap: class_map,
+            events: events
+          File.open('appmap.json', 'w').write(appmap)
         end
       end.call
     end
-
-    initializer 'appmap.subscribe', after: 'appmap.trace' do |_| # params: app
-      lambda do
-        require 'appmap/rails/sql_handler'
-        require 'appmap/rails/action_handler'
-        ActiveSupport::Notifications.subscribe('sql.sequel', AppMap::Rails::SQLHandler.new)
-        ActiveSupport::Notifications.subscribe('sql.active_record', AppMap::Rails::SQLHandler.new)
-        ActiveSupport::Notifications.subscribe('start_processing.action_controller', AppMap::Rails::ActionHandler::HTTPServerRequest.new)
-        ActiveSupport::Notifications.subscribe('process_action.action_controller', AppMap::Rails::ActionHandler::HTTPServerResponse.new)
-      end.call
-    end
   end
 end

data/lib/appmap/rspec.rb

@@ -1,342 +1,329 @@
 # frozen_string_literal: true
 
-require 'appmap'
-require 'appmap/config'
-require 'appmap/inspect'
-require 'appmap/trace/tracer'
-
-require 'active_support/inflector/transliterate'
-
 module AppMap
   # Integration of AppMap with RSpec. When enabled with APPMAP=true, the AppMap tracer will
   # be activated around each scenario which has the metadata key `:appmap`.
   module RSpec
     APPMAP_OUTPUT_DIR = 'tmp/appmap/rspec'
+    LOG = false
 
-    class Recorder
-      attr_reader :config, :features, :functions
+    def self.metadata
+      require 'appmap/command/record'
+      @metadata ||= AppMap::Command::Record.detect_metadata
+      @metadata.freeze
+      @metadata.deep_dup
+    end
 
-      def initialize
-        @config = AppMap::Config.load_from_file('appmap.yml')
+    module FeatureAnnotations
+      def feature
+        return nil unless annotations
 
-        raise "Missing AppMap configuration setting: 'name'" unless @config.name
+        annotations[:feature]
+      end
 
-        @features = AppMap.inspect(@config)
-        @functions = @features.map(&:collect_functions).flatten
+      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 setup
-        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+      def feature_group
+        return nil unless annotations
+
+        annotations[:feature_group]
       end
 
-      def save(example_name, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
-        require 'appmap/command/record'
-        metadata = AppMap::Command::Record.detect_metadata.tap do |m|
-          m[:name] = example_name
-          m[:app] = @config.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',
-            version: Gem.loaded_specs['rspec-core']&.version&.to_s
-          }
-          m[:recorder] = {
-            name: 'rspec'
-          }
+      def annotations
+        metadata.tap do |md|
+          description_args_hashes.each do |h|
+            md.merge! h
+          end
         end
-
-        appmap = {
-          version: AppMap::APPMAP_FORMAT_VERSION,
-          classMap: features,
-          metadata: metadata,
-          events: events
-        }.compact
-        fname = sanitize_filename(example_name)
-        File.write(File.join(APPMAP_OUTPUT_DIR, "#{fname}.appmap.json"), JSON.generate(appmap))
       end
 
-      # Cribbed from v5 version of ActiveSupport:Inflector#parameterize:
-      # https://github.com/rails/rails/blob/v5.2.4/activesupport/lib/active_support/inflector/transliterate.rb#L92
-      def sanitize_filename(fname, separator: '_')
-        # Replace accented chars with their ASCII equivalents.
-        fname = fname.encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+      protected
 
-        # Turn unwanted chars into the separator.
-        fname.gsub!(/[^a-z0-9\-_]+/i, separator)
+      def metadata
+        return {} unless example_obj.respond_to?(:metadata)
 
-        re_sep = Regexp.escape(separator)
-        re_duplicate_separator        = /#{re_sep}{2,}/
-        re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
+        example_obj.metadata
+      end
 
-        # No more than one of the separator in a row.
-        fname.gsub!(re_duplicate_separator, separator)
+      def description_args_hashes
+        return [] unless example_obj.respond_to?(:metadata)
 
-        # Finally, Remove leading/trailing separator.
-        fname.gsub(re_leading_trailing_separator, '')
+        (example_obj.metadata[:description_args] || []).select { |arg| arg.is_a?(Hash) }
       end
     end
 
-    class << self
-      module FeatureAnnotations
-        def feature
-          return nil unless annotations
+    # 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
 
-          annotations[:feature]
-        end
+      alias_method :example_obj, :example
 
-        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 description?
+        true
+      end
 
-        def feature_group
-          return nil unless annotations
+      def description
+        example.description
+      end
 
-          annotations[:feature_group]
-        end
+      def parent
+        ScopeExampleGroup.new(example.example_group)
+      end
+    end
 
-        def annotations
-          metadata.tap do |md|
-            description_args_hashes.each do |h|
-              md.merge! h
-            end
-          end
-        end
+    # 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
 
-        protected
+      alias_method :example_obj, :example_group
 
-        def metadata
-          return {} unless example_obj.respond_to?(:metadata)
+      def description_args
+        # Don't stringify any hashes that RSpec considers part of the example group description.
+        example_group.metadata[:description_args].reject { |arg| arg.is_a?(Hash) }
+      end
 
-          example_obj.metadata
-        end
+      def description?
+        return true if example_group.respond_to?(:described_class) && example_group.described_class
 
-        def description_args_hashes
-          return [] unless example_obj.respond_to?(:metadata)
+        return true if example_group.respond_to?(:description) && !description_args.empty?
 
-          (example_obj.metadata[:description_args] || []).select { |arg| arg.is_a?(Hash) }
-        end
+        false
       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
+      def description
+        description? ? description_args.join(' ') : nil
+      end
 
-        alias_method :example_obj, :example
+      def parent
+        # An example group always has a parent; but it might be 'self'...
 
-        def description?
-          true
-        end
+        # DEPRECATION WARNING: `Module#parent` has been renamed to `module_parent`. `parent` is deprecated and will be
+        # removed in Rails 6.1. (called from parent at /Users/kgilpin/source/appland/appmap-ruby/lib/appmap/rspec.rb:110)
+        example_group_parent = \
+          if example_group.respond_to?(:module_parent)
+            example_group.module_parent
+          else
+            example_group.parent
+          end
 
-        def description
-          example.description
-        end
+        example_group_parent != example_group ? ScopeExampleGroup.new(example_group_parent) : nil
+      end
+    end
 
-        def parent
-          ScopeExampleGroup.new(example.example_group)
-        end
+    Recording = Struct.new(:example) do
+      def initialize(example)
+        super
+
+        warn "Starting recording of example #{example}" if AppMap::RSpec::LOG
+        @trace = AppMap.tracing.trace
       end
 
-      # 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
+      def finish
+        warn "Finishing recording of example #{example}" if AppMap::RSpec::LOG
 
-        alias_method :example_obj, :example_group
+        events = []
+        AppMap.tracing.delete @trace
 
-        def description_args
-          # Don't stringify any hashes that RSpec considers part of the example group description.
-          example_group.metadata[:description_args].reject { |arg| arg.is_a?(Hash) }
-        end
+        events << @trace.next_event.to_h while @trace.event?
+
+        AppMap::RSpec.add_event_methods @trace.event_methods
 
-        def description?
-          return true if example_group.respond_to?(:described_class) && example_group.described_class
+        class_map = AppMap.class_map(AppMap::RSpec.config, @trace.event_methods)
 
-          return true if example_group.respond_to?(:description) && !description_args.empty?
+        description = []
+        scope = ScopeExample.new(example)
+        feature_group = feature = nil
 
-          false
+        labels = []
+        while scope
+          labels += scope.labels
+          description << scope.description
+          feature ||= scope.feature
+          feature_group ||= scope.feature_group
+          scope = scope.parent
         end
 
-        def description
-          description? ? description_args.join(' ') : nil
+        labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
+        description.reject!(&:nil?).reject(&:blank?)
+        default_description = description.last
+        description.reverse!
+
+        normalize = lambda do |desc|
+          desc.gsub('it should behave like', '')
+              .gsub(/Controller$/, '')
+              .gsub(/\s+/, ' ')
+              .strip
         end
 
-        def parent
-          # An example group always has a parent; but it might be 'self'...
-          example_group.parent != example_group ? ScopeExampleGroup.new(example_group.parent) : nil
+        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
+      end
+    end
+
+    @recordings_by_example = {}
+    @config = nil
+    @event_methods = Set.new
+
+    class << self
+      def init
+        warn 'Configuring AppMap recorder for RSpec'
+
+        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+
+        require 'appmap/hook'
+        @config = AppMap.configure
+        AppMap::Hook.hook(@config)
       end
 
-      LOG = false
-
-      def is_example_group_subclass_call?(tp)
-        # Order is important here. Checking for method_id == :subclass
-        # first will avoid calling defined_class.to_s in many cases,
-        # some of which will fail.
-        #
-        # For example, ActiveRecord in Rails 4 defines #inspect (and
-        # therefore #to_s) in such a way that it will fail if called
-        # here.
-        tp.event == :call &&
-          tp.method_id == :subclass &&
-          tp.defined_class.singleton_class? &&
-          tp.defined_class.to_s == '#<Class:RSpec::Core::ExampleGroup>'
+      def begin_spec(example)
+        @recordings_by_example[example.object_id] = Recording.new(example)
       end
 
-      def is_example_initialize_call?(tp)
-        tp.event == :call &&
-          tp.method_id == :initialize &&
-          tp.defined_class.to_s == 'RSpec::Core::Example'
+      def end_spec(example)
+        recording = @recordings_by_example.delete(example.object_id)
+        return warn "No recording found for #{example}" unless recording
+
+        recording.finish
       end
 
-      def generate_inventory
-        Recorder.new.tap do |recorder|
-          recorder.setup
-        end.save 'Inventory', labels: %w[inventory]
+      def config
+        @config or raise "AppMap is not configured"
       end
 
-      def generate_appmaps_from_specs
-        recorder = Recorder.new
-        recorder.setup
-
-        require 'set'
-        # file:lineno at which an Example block begins
-        trace_block_start = Set.new
-        # file:lineno at which an Example block ends
-        trace_block_end = Set.new
-
-        # value: a BlockParseNode from an RSpec file
-        # key: file:lineno at which the block begins
-        rspec_blocks = {}
-
-        # value: an Example instance
-        # key: file:lineno at which the Example block ends
-        examples = {}
-
-        current_tracer = nil
-
-        TracePoint.trace(:call, :b_call, :b_return) do |tp|
-          # When a new ExampleGroup is encountered, parse the source file containing it and look
-          # for blocks that might be Examples. Index each BlockParseNode by the start file:lineno.
-          if is_example_group_subclass_call?(tp)
-            example_block = tp.binding.eval('example_group_block')
-            source_path, start_line = example_block.source_location
-            require 'appmap/rspec/parser'
-            nodes, = AppMap::RSpec::Parser.new(file_path: source_path).parse
-            nodes.each do |node|
-              start_loc = [ node.file_path, node.first_line ].join(':')
-              rspec_blocks[start_loc] = node
-            end
-          end
+      def add_event_methods(event_methods)
+        @event_methods += event_methods
+      end
 
-          # When a new Example is constructed with a block, look for the BlockParseNode that starts at the block's
-          # file:lineno. If it exists, store the Example object, indexed by the file:lineno at which it ends.
-          if is_example_initialize_call?(tp)
-            example_block = tp.binding.eval('example_block')
-            if example_block
-              source_path, start_line = example_block.source_location
-              start_loc = [ source_path, start_line ].join(':')
-              if (rspec_block = rspec_blocks[start_loc])
-                end_loc = [ source_path, rspec_block.last_line ].join(':')
-                trace_block_start << start_loc.tap { |loc| puts "Start: #{loc}" if LOG }
-                trace_block_end << end_loc.tap { |loc| puts "End: #{loc}" if LOG }
-                examples[end_loc] = tp.binding.eval('self')
-              end
-            end
-          end
+      def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
+        metadata = RSpec.metadata.tap do |m|
+          m[:name] = example_name
+          m[:app] = @config.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',
+            version: Gem.loaded_specs['rspec-core']&.version&.to_s
+          }
+          m[:recorder] = {
+            name: 'rspec'
+          }
+        end
 
-          if %i[b_call b_return].member?(tp.event)
-            loc = [ tp.path, tp.lineno ].join(':')
-            puts loc if LOG && (trace_block_start.member?(loc) || trace_block_end.member?(loc))
+        appmap = {
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          metadata: metadata,
+          classMap: class_map,
+          events: events
+        }.compact
+        fname = sanitize_filename(example_name)
 
-            # When a new block is started, check if an Example block is known to begin at that
-            # file:lineno. If it is, enable the AppMap tracer.
-            if  tp.event == :b_call && trace_block_start.member?(loc)
-              puts "Starting trace on #{loc}" if LOG
-              current_tracer = AppMap::Trace.tracers.trace(recorder.functions)
-            end
+        File.write(File.join(APPMAP_OUTPUT_DIR, "#{fname}.appmap.json"), JSON.generate(appmap))
+      end
 
-            # When the tracer is enabled and a block is completed, check to see if there is an
-            # Example stored at the file:lineno. If so, finish tracing and emit the 
-            # AppMap file.
-            if current_tracer && tp.event == :b_return && trace_block_end.member?(loc)
-              puts "Ending trace on #{loc}" if LOG
-              events = []
-              AppMap::Trace.tracers.delete current_tracer
+      def print_inventory
+        class_map = AppMap.class_map(@config, @event_methods)
+        save 'Inventory', class_map, labels: %w[inventory]
+      end
 
-              while current_tracer.event?
-                events << current_tracer.next_event.to_h
-              end
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
 
-              example = examples[loc]
-              description = []
-              leaf = 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
+      def run
+        init
+        at_exit do
+          print_inventory
+        end
+      end
 
-              labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
-              description.reject!(&:nil?).reject(&:blank?)
-              default_description = description.last
-              description.reverse!
+      private
 
-              normalize = lambda do |desc|
-                desc.gsub('it should behave like', '')
-                    .gsub(/Controller$/, '')
-                    .gsub(/\s+/, ' ')
-                    .strip
-              end
+      # Cribbed from v5 version of ActiveSupport:Inflector#parameterize:
+      # https://github.com/rails/rails/blob/v5.2.4/activesupport/lib/active_support/inflector/transliterate.rb#L92
+      def sanitize_filename(fname, separator: '_')
+        # Replace accented chars with their ASCII equivalents.
+        fname = fname.encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
 
-              full_description = normalize.call(description.join(' '))
+        # Turn unwanted chars into the separator.
+        fname.gsub!(/[^a-z0-9\-_]+/i, separator)
 
-              compute_feature_name = lambda do
-                return 'unknown' if description.empty?
+        re_sep = Regexp.escape(separator)
+        re_duplicate_separator        = /#{re_sep}{2,}/
+        re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
 
-                feature_description = description.dup
-                num_tokens = [2, feature_description.length - 1].min
-                feature_description[0...num_tokens].map(&:strip).join(' ')
-              end
+        # No more than one of the separator in a row.
+        fname.gsub!(re_duplicate_separator, separator)
 
-              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
+        # Finally, Remove leading/trailing separator.
+        fname.gsub(re_leading_trailing_separator, '')
+      end
+    end
+  end
+end
+
+if AppMap::RSpec.enabled?
+  require 'appmap'
+  require 'active_support/inflector/transliterate'
+  require 'rspec/core'
+  require 'rspec/core/example'
 
-              recorder.save full_description,
-                            events: events,
-                            feature_name: feature_name,
-                            feature_group_name: feature_group,
-                            labels: labels.blank? ? nil : labels
+  module RSpec
+    module Core
+      class Example
+        class << self
+          def wrap_example_block(example, fn)
+            proc do
+              AppMap::RSpec.begin_spec example
+              begin
+                instance_exec(&fn)
+              ensure
+                AppMap::RSpec.end_spec example
+              end
             end
           end
         end
-      end
 
-      def enabled?
-        ENV['APPMAP'] == 'true'
-      end
-
-      def run
-        generate_inventory
-        generate_appmaps_from_specs
+        def self.new(*arguments, &block)
+          warn "Wrapping example_block for #{name}" if AppMap::RSpec::LOG
+          allocate.tap do |obj|
+            arguments[arguments.length - 1] = wrap_example_block(obj, arguments.last) if arguments.last.is_a?(Proc)
+            obj.send :initialize, *arguments, &block
+          end
+        end
       end
     end
   end
-end
 
-AppMap::RSpec.run if AppMap::RSpec.enabled?
+  AppMap::RSpec.run
+end