appmap 0.27.0 → 0.33.0

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext'
-
 module AppMap
   class ClassMap
     module HasChildren
@@ -50,7 +48,7 @@ module AppMap
         end
       end
       Function = Struct.new(:name) do
-        attr_accessor :static, :location
+        attr_accessor :static, :location, :labels
 
         def type
           'function'
@@ -61,8 +59,9 @@ module AppMap
             name: name,
             type: type,
             location: location,
-            static: static
-          }
+            static: static,
+            labels: labels
+          }.delete_if {|k,v| v.nil?}
         end
       end
     end
@@ -71,35 +70,21 @@ module AppMap
       def build_from_methods(config, methods)
         root = Types::Root.new
         methods.each do |method|
-          package = package_for_method(config.packages, method)
-          add_function root, package.path, method
+          package = config.package_for_method(method) \
+            or raise "No package found for method #{method}"
+          add_function root, package, method
         end
         root.children.map(&:to_h)
       end
 
       protected
 
-      def package_for_method(packages, method)
-        location = method.method.source_location
-        location_file, = location
-        location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-
-        packages.find do |pkg|
-          (location_file.index(pkg.path) == 0) &&
-            !pkg.exclude.find { |p| location_file.index(p) }
-        end or raise "No package found for method #{method}"
-      end
-
-      def add_function(root, package_name, method)
-        location = method.method.source_location
-        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?
+      def add_function(root, package, method)
+        static = method.static
 
         object_infos = [
           {
-            name: package_name,
+            name: package.path,
             type: 'package'
           }
         ]
@@ -109,12 +94,20 @@ module AppMap
             type: 'class'
           }
         end
-        object_infos << {
-          name: method.method.name,
+        function_info = {
+          name: method.name,
           type: 'function',
-          location: [ location_file, lineno ].join(':'),
           static: static
         }
+        location = method.source_location
+        if location
+          location_file, lineno = location
+          location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+          function_info[:location] = [ location_file, lineno ].join(':')
+        end
+        function_info[:labels] = package.labels if package.labels
+        object_infos << function_info
+
         parent = root
         object_infos.each do |info|
           parent = find_or_create parent.children, info do

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/config.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module AppMap
+  Package = Struct.new(:path, :package_name, :exclude, :labels) do
+    def initialize(path, package_name, exclude, labels = nil)
+      super
+    end
+
+    def to_h
+      {
+        path: path,
+        package_name: package_name,
+        exclude: exclude.blank? ? nil : exclude,
+        labels: labels.blank? ? nil : labels
+      }.compact
+    end
+  end
+
+  class Config
+    # Methods that should always be hooked, with their containing
+    # package and labels that should be applied to them.
+    HOOKED_METHODS = {
+      'ActiveSupport::SecurityUtils' => {
+        secure_compare: Package.new('active_support', nil, nil, ['security'])
+      }
+    }
+
+    attr_reader :name, :packages
+    def initialize(name, packages = [])
+      @name = name
+      @packages = packages
+    end
+
+    class << self
+      # Loads configuration data from a file, specified by the file name.
+      def load_from_file(config_file_name)
+        require 'yaml'
+        load YAML.safe_load(::File.read(config_file_name))
+      end
+
+      # Loads configuration from a Hash.
+      def load(config_data)
+        packages = (config_data['packages'] || []).map do |package|
+          Package.new(package['path'], nil, package['exclude'] || [])
+        end
+        Config.new config_data['name'], packages
+      end
+    end
+
+    def to_h
+      {
+        name: name,
+        packages: packages.map(&:to_h)
+      }
+    end
+
+    def package_for_method(method)
+      defined_class, _, method_name = Hook.qualify_method_name(method)
+      hooked_method = find_hooked_method(defined_class, method_name)
+      return hooked_method if hooked_method
+
+      location = method.source_location
+      location_file, = location
+      return unless location_file
+
+      location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+      packages.find do |pkg|
+        (location_file.index(pkg.path) == 0) &&
+          !pkg.exclude.find { |p| location_file.index(p) }
+      end
+    end
+
+    def included_by_location?(method)
+      !!package_for_method(method)
+    end
+
+    def always_hook?(defined_class, method_name)
+      !!find_hooked_method(defined_class, method_name)
+    end
+
+    def find_hooked_method(defined_class, method_name)
+      find_hooked_class(defined_class)[method_name]
+    end
+
+    def find_hooked_class(defined_class)
+      HOOKED_METHODS[defined_class] || {}
+    end
+  end
+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,24 +15,15 @@ module AppMap
       end
     end
 
-    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :static, :thread_id)
+    MethodEventStruct = Struct.new(:id, :event, :thread_id)
 
     class MethodEvent < MethodEventStruct
       LIMIT = 100
 
       class << self
-        def build_from_invocation(me, event_type, defined_class, method)
-          singleton = method.owner.singleton_class?
-
+        def build_from_invocation(me, event_type)
           me.id = AppMap::Event.next_id_counter
           me.event = event_type
-          me.defined_class = defined_class
-          me.method_id = method.name.to_s
-          path = method.source_location[0]
-          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
 
@@ -61,16 +52,25 @@ module AppMap
           (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
         end
       end
-
-      alias static? static
     end
 
     class MethodCall < MethodEvent
-      attr_accessor :parameters, :receiver
+      attr_accessor :defined_class, :method_id, :path, :lineno, :parameters, :receiver, :static
 
       class << self
         def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
           mc.tap do
+            static = receiver.is_a?(Module)
+            mc.defined_class = defined_class
+            mc.method_id = method.name.to_s
+            if method.source_location
+              path = method.source_location[0]
+              path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
+              mc.path = path
+              mc.lineno = method.source_location[1]
+            else
+              mc.path = [ defined_class, static ? '.' : '#', method.name ].join
+            end
             mc.parameters = method.parameters.map.with_index do |method_param, idx|
               param_type, param_name = method_param
               param_name ||= 'arg'
@@ -88,28 +88,37 @@ module AppMap
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
-            MethodEvent.build_from_invocation(mc, :call, defined_class, method)
+            mc.static = static
+            MethodEvent.build_from_invocation(mc, :call)
           end
         end
       end
 
       def to_h
         super.tap do |h|
+          h[:defined_class] = defined_class
+          h[:method_id] = method_id
+          h[:path] = path
+          h[:lineno] = lineno
+          h[:static] = static
           h[:parameters] = parameters
           h[:receiver] = receiver
+          h.delete_if { |_, v| v.nil? }
         end
       end
+
+      alias static? static
     end
 
     class MethodReturnIgnoreValue < MethodEvent
       attr_accessor :parent_id, :elapsed
 
       class << self
-        def build_from_invocation(mr = MethodReturnIgnoreValue.new, defined_class, method, parent_id, elapsed)
+        def build_from_invocation(mr = MethodReturnIgnoreValue.new, parent_id, elapsed)
           mr.tap do |_|
             mr.parent_id = parent_id
             mr.elapsed = elapsed
-            MethodEvent.build_from_invocation(mr, :return, defined_class, method)
+            MethodEvent.build_from_invocation(mr, :return)
           end
         end
       end
@@ -126,7 +135,7 @@ module AppMap
       attr_accessor :return_value, :exceptions
 
       class << self
-        def build_from_invocation(mr = MethodReturn.new, defined_class, method, parent_id, elapsed, return_value, exception)
+        def build_from_invocation(mr = MethodReturn.new, parent_id, elapsed, return_value, exception)
           mr.tap do |_|
             if return_value
               mr.return_value = {
@@ -152,7 +161,7 @@ module AppMap
 
               mr.exceptions = exceptions
             end
-            MethodReturnIgnoreValue.build_from_invocation(mr, defined_class, method, parent_id, elapsed)
+            MethodReturnIgnoreValue.build_from_invocation(mr, parent_id, elapsed)
           end
         end
       end