appmap 0.26.0 → 0.31.0

data/lib/appmap/metadata.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Metadata
+    class << self
+      def detect
+        {
+          app: AppMap.configuration.name,
+          language: {
+            name: 'ruby',
+            engine: RUBY_ENGINE,
+            version: RUBY_VERSION
+          },
+          client: {
+            name: 'appmap',
+            url: AppMap::URL,
+            version: AppMap::VERSION
+          }
+        }.tap do |m|
+          if defined?(::Rails) && defined?(::Rails.version)
+            m[:frameworks] ||= []
+            m[:frameworks] << {
+              name: 'rails',
+              version: ::Rails.version
+            }
+          end
+          m[:git] = git_metadata if git_available
+        end
+      end
+
+      protected
+
+      def git_available
+        @git_available = system('git status 2>&1 > /dev/null') if @git_available.nil?
+      end
+
+      def git_metadata
+        git_repo = `git config --get remote.origin.url`.strip
+        git_branch = `git rev-parse --abbrev-ref HEAD`.strip
+        git_sha = `git rev-parse HEAD`.strip
+        git_status = `git status -s`.split("\n").map(&:strip)
+        git_last_annotated_tag = `git describe --abbrev=0 2>/dev/null`.strip
+        git_last_annotated_tag = nil if git_last_annotated_tag.blank?
+        git_last_tag = `git describe --abbrev=0 --tags 2>/dev/null`.strip
+        git_last_tag = nil if git_last_tag.blank?
+        git_commits_since_last_annotated_tag = `git describe`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_annotated_tag
+        git_commits_since_last_tag = `git describe --tags`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_tag
+
+        {
+          repository: git_repo,
+          branch: git_branch,
+          commit: git_sha,
+          status: git_status,
+          git_last_annotated_tag: git_last_annotated_tag,
+          git_last_tag: git_last_tag,
+          git_commits_since_last_annotated_tag: git_commits_since_last_annotated_tag,
+          git_commits_since_last_tag: git_commits_since_last_tag
+        }
+      end
+    end
+  end
+end

data/lib/appmap/middleware/remote_recording.rb

@@ -5,12 +5,9 @@ module AppMap
     # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
     class RemoteRecording
       def initialize(app)
-        require 'appmap/command/record'
         require 'json'
 
         @app = app
-        @config = AppMap.configure
-        AppMap::Hook.hook(@config)
       end
 
       def event_loop
@@ -63,15 +60,14 @@ module AppMap
         @events.delete_if(&is_control_command_event)
         @events.delete_if(&is_return_from_control_command_event)
 
-        require 'appmap/command/record'
-        metadata = AppMap::Command::Record.detect_metadata
+        metadata = AppMap.detect_metadata
         metadata[:recorder] = {
           name: 'remote_recording'
         }
 
         response = JSON.generate \
           version: AppMap::APPMAP_FORMAT_VERSION,
-          classMap: AppMap.class_map(@config, tracer.event_methods),
+          classMap: AppMap.class_map(tracer.event_methods),
           metadata: metadata,
           events: @events
 

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/rails/action_handler.rb

@@ -20,7 +20,7 @@ module AppMap
           attr_accessor :payload
 
           def initialize(path, lineno, payload)
-            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, false, Thread.current.object_id
+            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, Thread.current.object_id
 
             self.payload = payload
           end
@@ -60,7 +60,7 @@ module AppMap
           attr_accessor :payload
 
           def initialize(path, lineno, payload, parent_id, elapsed)
-            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, false, Thread.current.object_id
+            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, Thread.current.object_id
 
             self.payload = payload
             self.parent_id = parent_id

data/lib/appmap/rails/sql_handler.rb

@@ -9,7 +9,7 @@ module AppMap
         attr_accessor :payload
 
         def initialize(path, lineno, payload)
-          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, false, Thread.current.object_id
+          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, Thread.current.object_id
 
           self.payload = payload
         end
@@ -30,7 +30,7 @@ module AppMap
 
       class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
         def initialize(path, lineno, parent_id, elapsed)
-          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, false, Thread.current.object_id
+          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, Thread.current.object_id
 
           self.parent_id = parent_id
           self.elapsed = elapsed

data/lib/appmap/railtie.rb

@@ -5,8 +5,8 @@ module AppMap
   class Railtie < ::Rails::Railtie
     config.appmap = ActiveSupport::OrderedOptions.new
 
-    initializer 'appmap.init' do |_| #  params: app
-      AppMap.configure
+    initializer 'appmap.init' do |_| # params: app
+      require 'appmap'
     end
 
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'appmap/util'
+
 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`.
@@ -8,10 +10,7 @@ module AppMap
     LOG = false
 
     def self.metadata
-      require 'appmap/command/record'
-      @metadata ||= AppMap::Command::Record.detect_metadata
-      @metadata.freeze
-      @metadata.dup
+      AppMap.detect_metadata
     end
 
     module FeatureAnnotations
@@ -107,7 +106,17 @@ module AppMap
 
       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
+
+        # 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
+
+        example_group_parent != example_group ? ScopeExampleGroup.new(example_group_parent) : nil
       end
     end
 
@@ -129,7 +138,7 @@ module AppMap
 
         AppMap::RSpec.add_event_methods @trace.event_methods
 
-        class_map = AppMap.class_map(AppMap::RSpec.config, @trace.event_methods)
+        class_map = AppMap.class_map(@trace.event_methods)
 
         description = []
         scope = ScopeExample.new(example)
@@ -180,7 +189,6 @@ module AppMap
     end
 
     @recordings_by_example = {}
-    @config = nil
     @event_methods = Set.new
 
     class << self
@@ -188,10 +196,6 @@ module AppMap
         warn 'Configuring AppMap recorder for RSpec'
 
         FileUtils.mkdir_p APPMAP_OUTPUT_DIR
-
-        require 'appmap/hook'
-        @config = AppMap.configure
-        AppMap::Hook.hook(@config)
       end
 
       def begin_spec(example)
@@ -214,9 +218,9 @@ module AppMap
       end
 
       def save(example_name, class_map, events: nil, feature_name: nil, feature_group_name: nil, labels: nil)
-        metadata = RSpec.metadata.dup.tap do |m|
+        metadata = AppMap::RSpec.metadata.tap do |m|
           m[:name] = example_name
-          m[:app] = @config.name
+          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
@@ -236,13 +240,13 @@ module AppMap
           classMap: class_map,
           events: events
         }.compact
-        fname = sanitize_filename(example_name)
+        fname = AppMap::Util.scenario_filename(example_name)
 
-        File.write(File.join(APPMAP_OUTPUT_DIR, "#{fname}.appmap.json"), JSON.generate(appmap))
+        File.write(File.join(APPMAP_OUTPUT_DIR, fname), JSON.generate(appmap))
       end
 
       def print_inventory
-        class_map = AppMap.class_map(@config, @event_methods)
+        class_map = AppMap.class_map(@event_methods)
         save 'Inventory', class_map, labels: %w[inventory]
       end
 
@@ -256,28 +260,6 @@ module AppMap
           print_inventory
         end
       end
-
-      private
-
-      # 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: '_')
-
-        # Turn unwanted chars into the separator.
-        fname.gsub!(/[^a-z0-9\-_]+/i, separator)
-
-        re_sep = Regexp.escape(separator)
-        re_duplicate_separator        = /#{re_sep}{2,}/
-        re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
-
-        # No more than one of the separator in a row.
-        fname.gsub!(re_duplicate_separator, separator)
-
-        # Finally, Remove leading/trailing separator.
-        fname.gsub(re_leading_trailing_separator, '')
-      end
     end
   end
 end

data/lib/appmap/trace.rb

@@ -2,38 +2,46 @@
 
 module AppMap
   module Trace
-    ScopedMethod = Struct.new(:defined_class, :method)
+    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 Tracers
+    class Tracing
       def initialize
-        @tracers = []
+        @Tracing = []
       end
 
       def empty?
-        @tracers.empty?
+        @Tracing.empty?
       end
 
       def trace(enable: true)
         Tracer.new.tap do |tracer|
-          @tracers << tracer
+          @Tracing << tracer
           tracer.enable if enable
         end
-      end 
+      end
 
       def enabled?
-        @tracers.any?(&:enabled?)
+        @Tracing.any?(&:enabled?)
       end
 
       def record_event(event, defined_class: nil, method: nil)
-        @tracers.each do |tracer|
+        @Tracing.each do |tracer|
           tracer.record_event(event, defined_class: defined_class, method: method)
         end
       end
 
       def delete(tracer)
-        return unless @tracers.member?(tracer)
+        return unless @Tracing.member?(tracer)
 
-        @tracers.delete(tracer)
+        @Tracing.delete(tracer)
         tracer.disable
       end
     end
@@ -67,7 +75,7 @@ module AppMap
       return unless @enabled
 
       @events << event
-      @methods << Trace::ScopedMethod.new(defined_class, method) if defined_class && method
+      @methods << Trace::ScopedMethod.new(defined_class, method, event.static) if (defined_class && method && event.event == :call)
     end
 
     # Gets a unique list of the methods that were invoked by the program.