appmap 0.25.2 → 0.28.1

data/lib/appmap/algorithm/stats.rb

@@ -74,10 +74,11 @@ module AppMap
 
         class_name_func = ->(event) { event['defined_class'] }
         full_name_func = lambda do |event|
+          call = event['event'] == 'call'
           class_name = event['defined_class']
           static = event['static']
           function_name = event['method_id']
-          [ class_name, static ? '.' : '#', function_name ].join if class_name && !static.nil? && function_name
+          [ class_name, static ? '.' : '#', function_name ].join if call && class_name && !static.nil? && function_name
         end
 
         class_frequency = frequency_calc.call(class_name_func)

data/lib/appmap/class_map.rb

@@ -95,7 +95,7 @@ module AppMap
         location_file, lineno = location
         location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
 
-        static = method.method.owner.singleton_class?
+        static = method.static
 
         object_infos = [
           {

data/lib/appmap/command/record.rb

@@ -5,66 +5,7 @@ module AppMap
     RecordStruct = Struct.new(:config, :program)
 
     class Record < RecordStruct
-      class << self
-        # Builds a Hash of metadata which can be detected by inspecting the system.
-        def detect_metadata
-          {
-            language: {
-              name: 'ruby',
-              engine: RUBY_ENGINE,
-              version: RUBY_VERSION
-            },
-            client: {
-              name: 'appmap',
-              url: AppMap::URL,
-              version: AppMap::VERSION
-            }
-          }.tap do |m|
-            if defined?(::Rails)
-              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
-
       def perform(&block)
-        AppMap::Hook.hook(config)
-
         tracer = AppMap.tracing.trace
 
         events = []
@@ -85,8 +26,8 @@ module AppMap
           quit = true
           event_thread.join
           yield AppMap::APPMAP_FORMAT_VERSION,
-                self.class.detect_metadata,
-                AppMap.class_map(config, tracer.event_methods),
+                AppMap.detect_metadata,
+                AppMap.class_map(tracer.event_methods),
                 events
         end
 

data/lib/appmap/cucumber.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'appmap/util'
+
+module AppMap
+  module Cucumber
+    ScenarioAttributes = Struct.new(:name, :feature, :feature_group)
+
+    ProviderStruct = Struct.new(:scenario) do
+      def feature_group
+        # e.g. <Cucumber::Core::Ast::Location::Precise: cucumber/api/features/authenticate.feature:1>
+        feature_path.split('/').last.split('.')[0]
+      end
+    end
+
+    # ProviderBefore4 provides scenario name, feature name, and feature group name for Cucumber
+    # versions before 4.0.
+    class ProviderBefore4 < ProviderStruct
+      def attributes
+        ScenarioAttributes.new(scenario.name, scenario.feature.name, feature_group)
+      end
+
+      def feature_path
+        scenario.feature.location.to_s
+      end
+    end
+
+    # Provider4 provides scenario name, feature name, and feature group name for Cucumber
+    # versions 4.0 and later.
+    class Provider4 < ProviderStruct
+      def attributes
+        ScenarioAttributes.new(scenario.name, scenario.name.split(' ')[0..1].join(' '), feature_group)
+      end
+
+      def feature_path
+        scenario.location.file
+      end
+    end
+
+    class << self
+      def write_scenario(scenario, appmap)
+        appmap['metadata'] = update_metadata(scenario, appmap['metadata'])
+        scenario_filename = AppMap::Util.scenario_filename(appmap['metadata']['name'])
+
+        FileUtils.mkdir_p 'tmp/appmap/cucumber'
+        File.write(File.join('tmp/appmap/cucumber', scenario_filename), JSON.generate(appmap))
+      end
+
+      def enabled?
+        ENV['APPMAP'] == 'true'
+      end
+
+      protected
+
+      def cucumber_version
+        Gem.loaded_specs['cucumber']&.version&.to_s
+      end
+
+      def provider(scenario)
+        major, = cucumber_version.split('.').map(&:to_i)
+        if major < 4
+          ProviderBefore4
+        else
+          Provider4
+        end.new(scenario)
+      end
+
+      def update_metadata(scenario, base_metadata)
+        attributes = provider(scenario).attributes
+
+        base_metadata.tap do |m|
+          m['name'] = attributes.name
+          m['feature'] = attributes.feature
+          m['feature_group'] = attributes.feature_group
+          m['labels'] ||= []
+          m['labels'] += (scenario.tags&.map(&:name) || [])
+          m['frameworks'] ||= []
+          m['frameworks'] << {
+            'name' => 'cucumber',
+            'version' => Gem.loaded_specs['cucumber']&.version&.to_s
+          }
+          m['recorder'] = {
+            'name' => 'cucumber'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/appmap/event.rb

@@ -15,15 +15,13 @@ module AppMap
       end
     end
 
-    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :static, :thread_id)
+    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :thread_id)
 
     class MethodEvent < MethodEventStruct
       LIMIT = 100
 
       class << self
         def build_from_invocation(me, event_type, defined_class, method)
-          singleton = method.owner.singleton_class?
-
           me.id = AppMap::Event.next_id_counter
           me.event = event_type
           me.defined_class = defined_class
@@ -32,7 +30,6 @@ module AppMap
           path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
           me.path = path
           me.lineno = method.source_location[1]
-          me.static = singleton
           me.thread_id = Thread.current.object_id
         end
 
@@ -62,11 +59,10 @@ module AppMap
         end
       end
 
-      alias static? static
     end
 
     class MethodCall < MethodEvent
-      attr_accessor :parameters, :receiver
+      attr_accessor :parameters, :receiver, :static
 
       class << self
         def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
@@ -88,6 +84,7 @@ module AppMap
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
+            mc.static = receiver.is_a?(Module)
             MethodEvent.build_from_invocation(mc, :call, defined_class, method)
           end
         end
@@ -95,10 +92,13 @@ module AppMap
 
       def to_h
         super.tap do |h|
+          h[:static] = static
           h[:parameters] = parameters
           h[:receiver] = receiver
         end
       end
+
+      alias static? static
     end
 
     class MethodReturnIgnoreValue < MethodEvent

data/lib/appmap/hook.rb

@@ -106,16 +106,30 @@ module AppMap
               # Skip methods that have no instruction sequence, as they are obviously trivial.
               next unless disasm
 
-              defined_class, method_symbol = \
-                if method.owner.singleton_class?
-                  # Singleton class name is like: #<Class:<(.*)>>
-                  class_name = method.owner.to_s['#<Class:<'.length-1..-2]
-                  [ class_name, '.' ]
-                else
-                  [ method.owner.name, '#' ]
-                end
+              defined_class, method_symbol = if method.owner.singleton_class?
+                # Singleton class names can take two forms:
+                # #<Class:Foo> or
+                # #<Class:#<Bar:0x0123ABC>>. Retrieve the name of
+                # the class from the string.
+                # 
+                # (There really isn't a better way to do this. The
+                # singleton's reference to the class it was created
+                # from is stored in an instance variable named
+                # '__attached__'. It doesn't have the '@' prefix, so
+                # it's internal only, and not accessible from user
+                # code.)
+                class_name = /#<Class:((#<(?<cls>.*?):)|((?<cls>.*?)>))/.match(method.owner.to_s)['cls']
+                [ class_name, '.' ]
+              else
+                [ method.owner.name, '#' ]
+              end
+              
+              method_display_name = "#{defined_class}#{method_symbol}#{method.name}"
+              # Don't try and trace the tracing method or there will be a stack overflow
+              # in the defined hook method.
+              next if method_display_name == "AppMap.tracing"
 
-              warn "AppMap: Hooking #{defined_class}#{method_symbol}#{method.name}" if LOG
+              warn "AppMap: Hooking #{method_display_name}" if LOG
 
               cls.define_method method_id do |*args, &block|
                 base_method = method.bind(self).to_proc
@@ -141,11 +155,11 @@ module AppMap
                 end
               end
             end
-          end
-
-          instance_methods.each(&hook_method.call(cls))
-          class_methods.each(&hook_method.call(cls.singleton_class))
         end
+
+        instance_methods.each(&hook_method.call(cls))
+        class_methods.each(&hook_method.call(cls.singleton_class))
+      end
       end
     end
   end

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)
+            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,13 +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 'appmap/command/upload'
         require 'json'
 
         @app = app
-        @config = AppMap.configure
-        AppMap::Hook.hook(@config)
       end
 
       def event_loop
@@ -64,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/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