appmap 0.102.2 → 0.103.0

data/lib/appmap/hook.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
-require 'English'
-require_relative './hook_log'
-
+require "English"
+require_relative "hook_log"
+
+# rubocop:disable Metrics/ClassLength
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/BlockLength
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Complexity/CyclomaticComplexity
+# rubocop:disable Complexity/PerceivedComplexity
 module AppMap
   class Hook
     OBJECT_INSTANCE_METHODS = %i[! != !~ <=> == === =~ __id__ __send__ class clone define_singleton_method display dup
-                                 enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
+      enum_for eql? equal? extend freeze frozen? hash inspect instance_eval instance_exec instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method methods nil? object_id private_methods protected_methods public_method public_methods public_send remove_instance_variable respond_to? send singleton_class singleton_method singleton_methods taint tainted? tap then to_enum to_s to_h to_a trust untaint untrust untrusted? yield_self].freeze
     OBJECT_STATIC_METHODS = %i[! != !~ < <= <=> == === =~ > >= __id__ __send__ alias_method allocate ancestors attr
-                               attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
+      attr_accessor attr_reader attr_writer autoload autoload? class class_eval class_exec class_variable_defined? class_variable_get class_variable_set class_variables clone const_defined? const_get const_missing const_set constants define_method define_singleton_method deprecate_constant display dup enum_for eql? equal? extend freeze frozen? hash include include? included_modules inspect instance_eval instance_exec instance_method instance_methods instance_of? instance_variable_defined? instance_variable_get instance_variable_set instance_variables is_a? itself kind_of? method method_defined? methods module_eval module_exec name new nil? object_id prepend private_class_method private_constant private_instance_methods private_method_defined? private_methods protected_instance_methods protected_method_defined? protected_methods public_class_method public_constant public_instance_method public_instance_methods public_method public_method_defined? public_methods public_send remove_class_variable remove_instance_variable remove_method respond_to? send singleton_class singleton_class? singleton_method singleton_methods superclass taint tainted? tap then to_enum to_s trust undef_method untaint untrust untrusted? yield_self].freeze
     SLOW_PACKAGE_THRESHOLD = 0.001
 
     @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
@@ -39,9 +45,9 @@ module AppMap
       def qualify_method_name(method)
         if method.owner.singleton_class?
           class_name = singleton_method_owner_name(method)
-          [class_name, '.', method.name]
+          [class_name, ".", method.name]
         else
-          [method.owner.name, '#', method.name]
+          [method.owner.name, "#", method.name]
         end
       end
     end
@@ -55,7 +61,7 @@ module AppMap
 
     # Observe class loading and hook all methods which match the config.
     def enable(&block)
-      require 'appmap/hook/method'
+      require "appmap/hook/method"
 
       hook_builtins
 
@@ -66,7 +72,7 @@ module AppMap
       @module_load_times = Hash.new { |memo, k| memo[k] = 0 }
       @slow_packages = Set.new
 
-      if ENV['APPMAP_PROFILE_HOOK'] == 'true'
+      if ENV["APPMAP_PROFILE_HOOK"] == "true"
         dump_times = lambda do
           @module_load_times
             .keys
@@ -80,7 +86,7 @@ module AppMap
           end
         end
 
-        at_exit &dump_times
+        at_exit(&dump_times)
         Thread.new do
           while true
             dump_times.call
@@ -102,7 +108,7 @@ module AppMap
         hooks_by_class.each do |class_name, hooks|
           Array(hooks).each do |hook|
             HookLog.builtin class_name do
-              if builtin && hook.package.require_name && hook.package.require_name != 'ruby'
+              if builtin && hook.package.require_name && hook.package.require_name != "ruby"
                 begin
                   require hook.package.require_name
                 rescue
@@ -110,39 +116,59 @@ module AppMap
                   next
                 end
               end
-  
+
               begin
                 base_cls = Object.const_get class_name
               rescue NameError
                 HookLog.load_error class_name, "Class #{class_name} not found in global scope" if HookLog.enabled?
                 next
               end
-  
+
               Array(hook.method_names).each do |method_name|
                 method_name = method_name.to_sym
-  
+
                 hook_method = lambda do |entry|
                   cls, method = entry
                   next if config.never_hook?(cls, method)
-  
+
                   hook.package.handler_class.new(hook.package, cls, method).activate
                 end
-  
+
                 methods = []
                 # irb(main):001:0> Kernel.public_instance_method(:system)
                 # (irb):1:in `public_instance_method': method `system' for module `Kernel' is  private (NameError)
                 if base_cls == Kernel
-                  methods << [base_cls, base_cls.instance_method(method_name)] rescue nil
+                  begin
+                    methods << [base_cls, base_cls.instance_method(method_name)]
+                  rescue
+                    nil
+                  end
+                end
+                begin
+                  methods << [base_cls, base_cls.public_instance_method(method_name)]
+                rescue
+                  nil
+                end
+                begin
+                  methods << [base_cls, base_cls.protected_instance_method(method_name)]
+                rescue
+                  nil
                 end
-                methods << [base_cls, base_cls.public_instance_method(method_name)] rescue nil
-                methods << [base_cls, base_cls.protected_instance_method(method_name)] rescue nil
                 if base_cls.respond_to?(:singleton_class)
-                  methods << [base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name)] rescue nil
-                  methods << [base_cls.singleton_class, base_cls.singleton_class.protected_instance_method(method_name)] rescue nil
+                  begin
+                    methods << [base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name)]
+                  rescue
+                    nil
+                  end
+                  begin
+                    methods << [base_cls.singleton_class, base_cls.singleton_class.protected_instance_method(method_name)]
+                  rescue
+                    nil
+                  end
                 end
                 methods.compact!
                 if methods.empty?
-                  HookLog.load_error [ base_cls.name, method_name ].join('[#.]'), "Method #{method_name} not found on #{base_cls.name}" if HookLog.enabled?
+                  HookLog.load_error [base_cls.name, method_name].join("[#.]"), "Method #{method_name} not found on #{base_cls.name}" if HookLog.enabled?
                 else
                   methods.each(&hook_method)
                 end
@@ -152,13 +178,13 @@ module AppMap
         end
       end
 
-      hook_loaded_code.(config.builtin_hooks, true)
+      hook_loaded_code.call(config.builtin_hooks, true)
     end
 
     protected
 
     def trace_location(trace_point)
-      [trace_point.path, trace_point.lineno].join(':')
+      [trace_point.path, trace_point.lineno].join(":")
     end
 
     def trace_end(trace_point)
@@ -168,7 +194,7 @@ module AppMap
         path = trace_point.path
         enabled = !@notrace_paths.member?(path) && config.path_enabled?(path)
         unless enabled
-          HookLog.log 'Not hooking - path is not enabled' if HookLog.enabled?
+          HookLog.log "Not hooking - path is not enabled" if HookLog.enabled?
           @notrace_paths << path
           next
         end
@@ -178,31 +204,31 @@ module AppMap
         instance_methods = cls.public_instance_methods(false) + cls.protected_instance_methods(false) - OBJECT_INSTANCE_METHODS
         # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
         class_methods = begin
-            if cls.respond_to?(:singleton_class)
-              cls.singleton_class.public_instance_methods(false) + cls.singleton_class.protected_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
-            else
-              []
-            end
-          rescue NameError
+          if cls.respond_to?(:singleton_class)
+            cls.singleton_class.public_instance_methods(false) + cls.singleton_class.protected_instance_methods(false) - instance_methods - OBJECT_STATIC_METHODS
+          else
             []
           end
+        rescue NameError
+          []
+        end
 
         hook = lambda do |hook_cls|
           lambda do |method_id|
             method = begin
-                hook_cls.instance_method(method_id)
-              rescue NameError
-                HookLog.load_error [ hook_cls, method_id ].join('[#.]'), "Method #{hook_cls} #{method_id} is not accessible: #{$!}" if HookLog.enabled?
-                next
-              end
+              hook_cls.instance_method(method_id)
+            rescue NameError
+              HookLog.load_error [hook_cls, method_id].join("[#.]"), "Method #{hook_cls} #{method_id} is not accessible: #{$!}" if HookLog.enabled?
+              next
+            end
 
-            package = config.lookup_package(hook_cls, method)
+            hook_config = config.lookup_hook_config(hook_cls, method)
             # doing this check first returned early in 98.7% of cases in sample_app_6th_ed
-            next unless package
+            next unless hook_config
 
             # Don't try and trace the AppMap methods or there will be
             # a stack overflow in the defined hook method.
-            next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || '').split('::')[0])
+            next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || "").split("::")[0])
 
             next if method_id == :call
 
@@ -215,15 +241,19 @@ module AppMap
             # TODO: Figure out how to tell the difference?
             next unless disasm
 
-            package.handler_class.new(package, hook_cls, method).activate
+            record_around = Config::RECORD_AROUND_LABELS.find { |label| hook_config.labels.include?(label) }
+
+            HookLog.log "Detected labels: #{hook_config.labels.join(", ")} (record_around: #{record_around})" if !hook_config.labels.empty? && HookLog.enabled?
+
+            hook_config.package.handler_class.new(hook_config.package, hook_cls, method, record_around: record_around).activate
           end
         end
 
         start = Time.now
-        instance_methods.each(&hook.(cls))
+        instance_methods.each(&hook.call(cls))
         begin
           # NoMethodError: private method `singleton_class' called for Rack::MiniProfiler:Class
-          class_methods.each(&hook.(cls.singleton_class)) if cls.respond_to?(:singleton_class)
+          class_methods.each(&hook.call(cls.singleton_class)) if cls.respond_to?(:singleton_class)
         rescue NameError
           # NameError:
           #   uninitialized constant Faraday::Connection
@@ -231,12 +261,12 @@ module AppMap
         end
         elapsed = Time.now - start
         if location.index(Bundler.bundle_path.to_s) == 0
-          package_tokens = location[Bundler.bundle_path.to_s.length + 1..-1].split('/')
+          package_tokens = location[Bundler.bundle_path.to_s.length + 1..-1].split("/")
           @module_load_times[package_tokens[1]] += elapsed
         else
           file_path = location[Dir.pwd.length + 1..-1]
           if file_path
-            location = file_path.split('/', 3)[0..1].join('/')
+            location = file_path.split("/", 3)[0..1].join("/")
             @module_load_times[location] += elapsed
           end
         end

data/lib/appmap/metadata.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'appmap/util'
+require "appmap/util"
 
 module AppMap
   module Metadata
@@ -9,12 +9,12 @@ module AppMap
         {
           app: AppMap.configuration.name,
           language: {
-            name: 'ruby',
+            name: "ruby",
             engine: RUBY_ENGINE,
             version: RUBY_VERSION
           },
           client: {
-            name: 'appmap',
+            name: "appmap",
             url: AppMap::URL,
             version: AppMap::VERSION
           }
@@ -22,7 +22,7 @@ module AppMap
           if defined?(::Rails) && defined?(::Rails.version)
             m[:frameworks] ||= []
             m[:frameworks] << {
-              name: 'rails',
+              name: "rails",
               version: ::Rails.version
             }
           end
@@ -33,30 +33,18 @@ module AppMap
       protected
 
       def git_available
-        @git_available = system('git status 2>&1 > /dev/null') if @git_available.nil?
+        @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 Util.blank?(git_last_annotated_tag)
-        git_last_tag = `git describe --abbrev=0 --tags 2>/dev/null`.strip
-        git_last_tag = nil if Util.blank?(git_last_tag)
-        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
+          commit: git_sha
         }
       end
     end

data/lib/appmap/middleware/remote_recording.rb

@@ -6,7 +6,7 @@ module AppMap
     # It can also be enabled to emit an AppMap for each request.
     class RemoteRecording
       def initialize(app)
-        require 'json'
+        require "json"
 
         @app = app
       end
@@ -23,18 +23,18 @@ module AppMap
       end
 
       def ws_start_recording
-        return [ 409, 'Recording is already in progress' ] if @tracer
+        return [409, "Recording is already in progress"] if @tracer
 
         @events = []
         @tracer = AppMap.tracing.trace
         @event_thread = Thread.new { event_loop }
         @event_thread.abort_on_exception = true
 
-        [ 200 ]
+        [200]
       end
 
       def ws_stop_recording(req)
-        return [ 404, 'No recording is in progress' ] unless @tracer
+        return [404, "No recording is in progress"] unless @tracer
 
         tracer = @tracer
         @tracer = nil
@@ -50,7 +50,7 @@ module AppMap
         is_control_command_event = lambda do |event|
           event[:event] == :call &&
             event[:http_server_request] &&
-            event[:http_server_request][:path_info] == '/_appmap/record'
+            event[:http_server_request][:path_info] == "/_appmap/record"
         end
         control_command_events = @events.select(&is_control_command_event)
 
@@ -63,8 +63,8 @@ module AppMap
 
         metadata = AppMap.detect_metadata
         metadata[:recorder] = {
-          name: 'remote_recording',
-          type: 'remote'
+          name: "remote_recording",
+          type: "remote"
         }
 
         response = JSON.generate \
@@ -73,7 +73,7 @@ module AppMap
           metadata: metadata,
           events: @events
 
-        [ 200, response ]
+        [200, response]
       end
 
       def call(env)
@@ -82,7 +82,7 @@ module AppMap
         # 0
 
         req = Rack::Request.new(env)
-        return handle_record_request(req) if AppMap.recording_enabled?(:remote) && req.path == '/_appmap/record'
+        return handle_record_request(req) if AppMap.recording_enabled?(:remote) && req.path == "/_appmap/record"
 
         start_time = Time.now
         # Support multi-threaded web server such as Puma by recording each thread
@@ -100,20 +100,19 @@ module AppMap
           event_fields = events.map(&:keys).flatten.map(&:to_sym).uniq.sort
           return unless %i[http_server_request http_server_response].all? { |field| event_fields.include?(field) }
 
-          path = req.path.gsub(/\/{2,}/, '/') # Double slashes have been observed
-          appmap_name = "#{req.request_method} #{path} (#{status}) - #{start_time.strftime('%T.%L')}"
-          appmap_file_name = AppMap::Util.scenario_filename([ start_time.to_f, req.url ].join('_'))
-          output_dir = File.join(AppMap::DEFAULT_APPMAP_DIR, 'requests')
+          path = req.path.gsub(/\/{2,}/, "/") # Double slashes have been observed
+          appmap_name = "#{req.request_method} #{path} (#{status}) - #{start_time.strftime("%T.%L")}"
+          appmap_file_name = AppMap::Util.scenario_filename([start_time.to_f, req.url].join("_"))
+          output_dir = File.join(AppMap.output_dir, "requests")
           appmap_file_path = File.join(output_dir, appmap_file_name)
 
           metadata = AppMap.detect_metadata
           metadata[:name] = appmap_name
-          metadata[:timestamp] = start_time.to_f
           metadata[:recorder] = {
-            name: 'rack',
-            type: 'requests'
+            name: "rack",
+            type: "requests"
           }
-  
+
           appmap = {
             version: AppMap::APPMAP_FORMAT_VERSION,
             classMap: AppMap.class_map(tracer.event_methods),
@@ -124,36 +123,36 @@ module AppMap
           FileUtils.mkdir_p(output_dir)
           File.write(appmap_file_path, JSON.generate(appmap))
 
-          headers['AppMap-Name'] = File.expand_path(appmap_name)
-          headers['AppMap-File-Name'] = File.expand_path(appmap_file_path)
+          headers["AppMap-Name"] = File.expand_path(appmap_name)
+          headers["AppMap-File-Name"] = File.expand_path(appmap_file_path)
         end
 
         @app.call(env).tap(&record_request)
       end
 
       def recording_state
-        [ 200, JSON.generate({ enabled: recording? }) ]
+        [200, JSON.generate({enabled: recording?})]
       end
 
       def handle_record_request(req)
-        method = req.env['REQUEST_METHOD']
+        method = req.env["REQUEST_METHOD"]
 
         status, body = \
-          if method.eql?('GET')
+          if method.eql?("GET")
             recording_state
-          elsif method.eql?('POST')
+          elsif method.eql?("POST")
             ws_start_recording
-          elsif method.eql?('DELETE')
+          elsif method.eql?("DELETE")
             ws_stop_recording(req)
           else
-            [ 404, '' ]
+            [404, ""]
           end
 
-        [status, { 'Content-Type' => 'application/json' }, [body || '']]
+        [status, {"Content-Type" => "application/json"}, [body || ""]]
       end
 
       def html_response?(headers)
-        headers['Content-Type'] && headers['Content-Type'] =~ /html/
+        headers["Content-Type"] && headers["Content-Type"] =~ /html/
       end
 
       def record_all_requests?

data/lib/appmap/minitest.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require_relative '../appmap'
-require_relative './util'
-require_relative './detect_enabled'
-require 'fileutils'
-require 'active_support'
-require 'active_support/core_ext'
+require_relative "../appmap"
+require_relative "util"
+require_relative "detect_enabled"
+require "fileutils"
+require "active_support"
+require "active_support/core_ext"
 
 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 = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+    APPMAP_OUTPUT_DIR = File.join(AppMap.output_dir, "minitest")
+    LOG = (ENV["APPMAP_DEBUG"] == "true" || ENV["DEBUG"] == "true")
 
     def self.metadata
       AppMap.detect_metadata
@@ -28,13 +28,13 @@ module AppMap
 
       def source_location
         location = test.method(test_name).source_location
-        [ Util.normalize_path(location.first), location.last ].join(':')
+        [Util.normalize_path(location.first), location.last].join(":")
       end
 
       def finish(failures, exception)
         failed = failures.any? || exception
         if AppMap::Minitest::LOG
-          warn "Finishing recording of #{failed ? 'failed ' : ''} test #{test.class}.#{test.name}"
+          warn "Finishing recording of #{failed ? "failed " : ""} test #{test.class}.#{test.name}"
         end
         warn "Exception: #{exception}" if exception && AppMap::Minitest::LOG
 
@@ -53,17 +53,17 @@ module AppMap
 
         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(' ')
+        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 name: scenario_name,
-                              class_map: class_map,
-                              source_location: source_location,
-                              test_status: failed ? 'failed' : 'succeeded',
-                              test_failure: test_failure,
-                              exception: exception,
-                              events: events
+          class_map: class_map,
+          source_location: source_location,
+          test_status: failed ? "failed" : "succeeded",
+          test_failure: test_failure,
+          exception: exception,
+          events: events
       end
     end
 
@@ -96,7 +96,7 @@ module AppMap
       end
 
       def config
-        @config or raise 'AppMap is not configured'
+        @config or raise "AppMap is not configured"
       end
 
       def add_event_methods(event_methods)
@@ -110,12 +110,12 @@ module AppMap
           m[:app] = AppMap.configuration.name
           m[:frameworks] ||= []
           m[:frameworks] << {
-            name: 'minitest',
-            version: Gem.loaded_specs['minitest']&.version&.to_s
+            name: "minitest",
+            version: Gem.loaded_specs["minitest"]&.version&.to_s
           }
           m[:recorder] = {
-            name: 'minitest',
-            type: 'tests'
+            name: "minitest",
+            type: "tests"
           }
           m[:test_status] = test_status
           m[:test_failure] = test_failure if test_failure
@@ -145,11 +145,11 @@ module AppMap
 end
 
 if AppMap::Minitest.enabled?
-  require 'appmap'
-  require 'minitest/test'
+  require "appmap"
+  require "minitest/test"
 
   class ::Minitest::Test
-    alias run_without_hook run
+    alias_method :run_without_hook, :run
 
     def run
       AppMap::Minitest.begin_test self, name