appmap 0.28.1 → 0.34.1

data/lib/appmap/metadata.rb

@@ -17,7 +17,7 @@ module AppMap
             version: AppMap::VERSION
           }
         }.tap do |m|
-          if defined?(::Rails)
+          if defined?(::Rails) && defined?(::Rails.version)
             m[:frameworks] ||= []
             m[:frameworks] << {
               name: 'rails',

data/lib/appmap/minitest.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'appmap/util'
+
+module AppMap
+  # Integration of AppMap with Minitest. When enabled with APPMAP=true, the AppMap tracer will
+  # be activated around each test.
+  module Minitest
+    APPMAP_OUTPUT_DIR = 'tmp/appmap/minitest'
+    LOG = false
+
+    def self.metadata
+      AppMap.detect_metadata
+    end
+
+    Recording = Struct.new(:test) do
+      def initialize(test)
+        super
+
+        warn "Starting recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+        @trace = AppMap.tracing.trace
+      end
+
+      def finish
+        warn "Finishing recording of test #{test.class}.#{test.name}" if AppMap::Minitest::LOG
+
+        events = []
+        AppMap.tracing.delete @trace
+
+        events << @trace.next_event.to_h while @trace.event?
+
+        AppMap::Minitest.add_event_methods @trace.event_methods
+
+        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,
+                              events: events,
+                              feature_name: feature_name,
+                              feature_group_name: feature_group
+      end
+    end
+
+    @recordings_by_test = {}
+    @event_methods = Set.new
+
+    class << self
+      def init
+        warn 'Configuring AppMap recorder for Minitest'
+
+        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+      end
+
+      def begin_test(test)
+        @recordings_by_test[test.object_id] = Recording.new(test)
+      end
+
+      def end_test(test)
+        recording = @recordings_by_test.delete(test.object_id)
+        return warn "No recording found for #{test}" unless recording
+
+        recording.finish
+      end
+
+      def config
+        @config or raise "AppMap is not configured"
+      end
+
+      def add_event_methods(event_methods)
+        @event_methods += event_methods
+      end
+
+      def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
+        metadata = AppMap::Minitest.metadata.tap do |m|
+          m[:name] = example_name
+          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',
+            version: Gem.loaded_specs['minitest']&.version&.to_s
+          }
+          m[:recorder] = {
+            name: 'minitest'
+          }
+        end
+
+        appmap = {
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          metadata: metadata,
+          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
+
+      def print_inventory
+        class_map = AppMap.class_map(@event_methods)
+        save 'Inventory', class_map, labels: %w[inventory]
+      end
+
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
+
+      def run
+        init
+        at_exit do
+          print_inventory
+        end
+      end
+    end
+  end
+end
+
+if AppMap::Minitest.enabled?
+  require 'appmap'
+  require 'minitest/test'
+
+  class ::Minitest::Test
+    alias run_without_hook run
+
+    def run
+      AppMap::Minitest.begin_test self
+      begin
+        run_without_hook
+      ensure
+        AppMap::Minitest.end_test self
+      end
+    end
+  end
+
+  AppMap::Minitest.run
+end

data/lib/appmap/open.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AppMap
+  OpenStruct = Struct.new(:appmap)
+
+  class Open < OpenStruct
+    attr_reader :port
+
+    def perform
+      server = run_server
+      open_browser
+      server.kill
+    end
+
+    def page
+      require 'rack/utils'
+      <<~PAGE
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>&hellip;</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+        <script type="text/javascript">
+        function dosubmit() { document.forms[0].submit(); }
+        </script>
+      </head>
+      <body onload="dosubmit();">
+        <form action="https://app.land/scenario_uploads" method="POST" accept-charset="utf-8">
+        <input type="hidden" name="data" value='#{Rack::Utils.escape_html appmap.to_json}'>
+        </form>
+      </body>
+      </html>
+      PAGE
+    end
+
+    def run_server
+      require 'rack'
+      Thread.new do
+        Rack::Handler::WEBrick.run(
+          lambda do |env|
+            return [200, { 'Content-Type' => 'text/html' }, [page]]
+          end,
+          :Port => 0
+        ) do |server|
+          @port = server.config[:Port]
+        end
+      end.tap do
+        sleep 1.0
+      end
+    end
+
+    def open_browser
+      system 'open', "http://localhost:#{@port}"
+      sleep 5.0
+    end
+  end
+end

data/lib/appmap/rails/action_handler.rb

@@ -16,11 +16,11 @@ module AppMap
       class HTTPServerRequest
         include ContextKey
 
-        class Call < AppMap::Event::MethodEvent
+        class Call < AppMap::Event::MethodCall
           attr_accessor :payload
 
-          def initialize(path, lineno, payload)
-            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, Thread.current.object_id
+          def initialize(payload)
+            super AppMap::Event.next_id_counter, :call, Thread.current.object_id
 
             self.payload = payload
           end
@@ -47,7 +47,7 @@ module AppMap
         end
 
         def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-          event = Call.new(__FILE__, __LINE__, payload)
+          event = Call.new(payload)
           Thread.current[context_key] = Context.new(event.id, Time.now)
           AppMap.tracing.record_event(event)
         end
@@ -59,8 +59,8 @@ module AppMap
         class Call < AppMap::Event::MethodReturnIgnoreValue
           attr_accessor :payload
 
-          def initialize(path, lineno, payload, parent_id, elapsed)
-            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, Thread.current.object_id
+          def initialize(payload, parent_id, elapsed)
+            super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
             self.payload = payload
             self.parent_id = parent_id
@@ -82,7 +82,7 @@ module AppMap
           context = Thread.current[context_key]
           Thread.current[context_key] = nil
 
-          event = Call.new(__FILE__, __LINE__, payload, context.id, Time.now - context.start_time)
+          event = Call.new(payload, context.id, Time.now - context.start_time)
           AppMap.tracing.record_event(event)
         end
       end

data/lib/appmap/rails/sql_handler.rb

@@ -5,11 +5,11 @@ require 'appmap/event'
 module AppMap
   module Rails
     class SQLHandler
-      class SQLCall < AppMap::Event::MethodEvent
+      class SQLCall < AppMap::Event::MethodCall
         attr_accessor :payload
 
-        def initialize(path, lineno, payload)
-          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, Thread.current.object_id
+        def initialize(payload)
+          super AppMap::Event.next_id_counter, :call, Thread.current.object_id
 
           self.payload = payload
         end
@@ -20,7 +20,7 @@ module AppMap
               sql: payload[:sql],
               database_type: payload[:database_type]
             }.tap do |sql_query|
-              %i[server_version explain_sql].each do |attribute|
+              %i[server_version].each do |attribute|
                 sql_query[attribute] = payload[attribute] if payload[attribute]
               end
             end
@@ -29,8 +29,8 @@ module AppMap
       end
 
       class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
-        def initialize(path, lineno, parent_id, elapsed)
-          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, Thread.current.object_id
+        def initialize(parent_id, elapsed)
+          super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
           self.parent_id = parent_id
           self.elapsed = elapsed
@@ -76,6 +76,8 @@ module AppMap
             case database_type
             when :postgres
               ActiveRecord::Base.connection.postgresql_version
+            when :sqlite
+              ActiveRecord::Base.connection.database_version.to_s
             else
               warn "Unable to determine database version for #{database_type.inspect}"
             end
@@ -133,9 +135,9 @@ module AppMap
 
           SQLExaminer.examine payload, sql: sql
 
-          call = SQLCall.new(__FILE__, __LINE__, payload)
+          call = SQLCall.new(payload)
           AppMap.tracing.record_event(call)
-          AppMap.tracing.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
+          AppMap.tracing.record_event(SQLReturn.new(call.id, finished - started))
         ensure
           Thread.current[reentry_key] = nil
         end

data/lib/appmap/record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'appmap'
+require 'json'
+
+tracer = AppMap.tracing.trace
+
+at_exit do
+  AppMap.tracing.delete(tracer)
+
+  events = [].tap do |event_list|
+    event_list << tracer.next_event.to_h while tracer.event?
+  end
+
+  metadata = AppMap.detect_metadata
+  metadata[:recorder] = {
+    name: 'record_process'
+  }
+
+  appmap = {
+    'version' => AppMap::APPMAP_FORMAT_VERSION,
+    'metadata' => metadata,
+    'classMap' => AppMap.class_map(tracer.event_methods),
+    'events' => events
+  }
+  File.write 'appmap.json', JSON.generate(appmap)
+end

data/lib/appmap/rspec.rb

@@ -154,7 +154,7 @@ module AppMap
         end
 
         labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
-        description.reject!(&:nil?).reject(&:blank?)
+        description.reject!(&:nil?).reject!(&:blank?)
         default_description = description.last
         description.reverse!
 
@@ -218,7 +218,7 @@ module AppMap
       end
 
       def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
-        metadata = RSpec.metadata.tap do |m|
+        metadata = AppMap::RSpec.metadata.tap do |m|
           m[:name] = example_name
           m[:app] = AppMap.configuration.name
           m[:feature] = feature_name if feature_name

data/lib/appmap/trace.rb

@@ -2,38 +2,46 @@
 
 module AppMap
   module Trace
-    ScopedMethod = Struct.new(:defined_class, :method, :static)
+    class ScopedMethod < SimpleDelegator
+      attr_reader :defined_class, :static
+      
+      def initialize(defined_class, method, static)
+        @defined_class = defined_class
+        @static = static
+        super(method)
+      end
+    end
 
     class Tracing
       def initialize
-        @Tracing = []
+        @tracing = []
       end
 
       def empty?
-        @Tracing.empty?
+        @tracing.empty?
       end
 
       def trace(enable: true)
         Tracer.new.tap do |tracer|
-          @Tracing << tracer
+          @tracing << tracer
           tracer.enable if enable
         end
       end
 
       def enabled?
-        @Tracing.any?(&:enabled?)
+        @tracing.any?(&:enabled?)
       end
 
       def record_event(event, defined_class: nil, method: nil)
-        @Tracing.each do |tracer|
+        @tracing.each do |tracer|
           tracer.record_event(event, defined_class: defined_class, method: method)
         end
       end
 
       def delete(tracer)
-        return unless @Tracing.member?(tracer)
+        return unless @tracing.member?(tracer)
 
-        @Tracing.delete(tracer)
+        @tracing.delete(tracer)
         tracer.disable
       end
     end

data/lib/appmap/util.rb

@@ -35,6 +35,25 @@ module AppMap
 
         [ fname, extension ].join
       end
+
+      # sanitize_event removes ephemeral values from an event, making
+      # events easier to compare across runs.
+      def sanitize_event(event, &block)
+        event.delete(:thread_id)
+        event.delete(:elapsed)
+        delete_object_id = ->(obj) { (obj || {}).delete(:object_id) }
+        delete_object_id.call(event[:receiver])
+        delete_object_id.call(event[:return_value])
+        (event[:parameters] || []).each(&delete_object_id)
+        (event[:exceptions] || []).each(&delete_object_id)
+
+        case event[:event]
+        when :call
+          event[:path] = event[:path].gsub(Gem.dir + '/', '')
+        end
+
+        event
+      end
     end
   end
 end

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.28.1'
+  VERSION = '0.34.1'
 
   APPMAP_FORMAT_VERSION = '1.2'
 end

data/spec/abstract_controller4_base_spec.rb

@@ -48,11 +48,11 @@ describe 'AbstractControllerBase' do
 
       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
-  thread_id: .*
   static: false
   parameters:
   - name: params