appmap 0.102.2 → 0.103.0

data/lib/appmap/detect_enabled.rb

@@ -1,4 +1,4 @@
-require_relative './recording_methods'
+require_relative "recording_methods"
 
 module AppMap
   # Detects whether AppMap recording should be enabled. This test can be performed generally, or for
@@ -9,27 +9,29 @@ module AppMap
     @@detected_for_method = {}
 
     class << self
+      # rubocop:disable Metrics/MethodLength
       def discourage_conflicting_recording_methods(recording_method)
-        return if ENV['APPMAP_DISCOURAGE_CONFLICTING_RECORDING_METHODS'] == 'false'
+        return if ENV["APPMAP_DISCOURAGE_CONFLICTING_RECORDING_METHODS"] == "false"
 
         return unless enabled?(recording_method.to_sym) && enabled?(:requests)
 
         warn Util.color <<~MSG, :yellow
-AppMap recording is enabled for both 'requests' and '#{recording_method}'. This is not recommended
-because the recordings will contain duplicitive information, and in some case may conflict with each other.
+          AppMap recording is enabled for both 'requests' and '#{recording_method}'. This is not recommended
+          because the recordings will contain duplicitive information, and in some case may conflict with each other.
         MSG
 
-        return unless ENV['APPMAP'] == 'true'
+        return unless ENV["APPMAP"] == "true"
 
         warn Util.color <<~MSG, :yellow
-The environment contains APPMAP=true, which is not recommended in this application environment because
-it enables all recording methods. Consider letting AppMap detect the appropriate recording method,
-or explicitly enabling only the recording methods you want to use using environment variables like
-APPMAP_RECORD_REQUESTS, APPMAP_RECORD_RSPEC, etc.
-
-See https://appmap.io/docs/reference/appmap-ruby.html#advanced-runtime-options for more information.
+          The environment contains APPMAP=true, which is not recommended in this application environment because
+          it enables all recording methods. Consider letting AppMap detect the appropriate recording method,
+          or explicitly enabling only the recording methods you want to use using environment variables like
+          APPMAP_RECORD_REQUESTS, APPMAP_RECORD_RSPEC, etc.
+          
+          See https://appmap.io/docs/reference/appmap-ruby.html#advanced-runtime-options for more information.
         MSG
       end
+      # rubocop:enable Metrics/MethodLength
 
       def enabled?(recording_method)
         new(recording_method).enabled?
@@ -57,7 +59,7 @@ See https://appmap.io/docs/reference/appmap-ruby.html#advanced-runtime-options f
 
       if @recording_method && (enabled && enabled_by_app_env?)
         warn AppMap::Util.color(
-          "AppMap #{@recording_method.nil? ? '' : "#{@recording_method} "}recording is enabled because #{message}", :magenta
+          "AppMap #{@recording_method.nil? ? "" : "#{@recording_method} "}recording is enabled because #{message}", :magenta
         )
       end
 
@@ -77,63 +79,63 @@ See https://appmap.io/docs/reference/appmap-ruby.html#advanced-runtime-options f
       message, enabled = []
       message, enabled = method(detection_functions.shift).call while enabled.nil? && !detection_functions.empty?
 
-      return [ 'it is not enabled by any configuration or framework', false, false ] if enabled.nil?
+      return ["it is not enabled by any configuration or framework", false, false] if enabled.nil?
 
       _, enabled_by_env = enabled_by_app_env?
-      [ message, enabled, enabled_by_env ]
+      [message, enabled, enabled_by_env]
     end
 
     def enabled_by_testing?
       return unless %i[rspec minitest cucumber].member?(@recording_method)
 
-      [ "running tests with #{@recording_method}", true ]
+      ["running tests with #{@recording_method}", true]
     end
 
     def enabled_by_app_env?
       env_name, app_env = detect_app_env
-      return [ "#{env_name} is '#{app_env}'", true ] if @recording_method.nil? && %w[test development].member?(app_env)
+      return ["#{env_name} is '#{app_env}'", true] if @recording_method.nil? && %w[test development].member?(app_env)
 
       return unless %i[remote requests].member?(@recording_method)
-      return [ "#{env_name} is '#{app_env}'", true ] if app_env == 'development'
+      ["#{env_name} is '#{app_env}'", true] if app_env == "development"
     end
 
     def detect_app_env
       if rails_env
-        [ 'RAILS_ENV', rails_env ]
-      elsif ENV['APP_ENV']
-        [ 'APP_ENV', ENV['APP_ENV']]
+        ["RAILS_ENV", rails_env]
+      elsif ENV["APP_ENV"]
+        ["APP_ENV", ENV["APP_ENV"]]
       end
     end
 
     def globally_enabled?
       # Don't auto-enable request recording in the 'test' environment, because users probably don't want
       # AppMaps of both test cases and requests. Requests recording can always be enabled by APPMAP_RECORD_REQUESTS=true.
-      requests_recording_in_test = -> { [ :requests ].member?(@recording_method) && detect_app_env == 'test' }
-      [ 'APPMAP=true', true ] if ENV['APPMAP'] == 'true' && !requests_recording_in_test.call
+      requests_recording_in_test = -> { [:requests].member?(@recording_method) && detect_app_env == "test" }
+      ["APPMAP=true", true] if ENV["APPMAP"] == "true" && !requests_recording_in_test.call
     end
 
     def globally_disabled?
-      [ 'APPMAP=false', false ] if ENV['APPMAP'] == 'false'
+      ["APPMAP=false", false] if ENV["APPMAP"] == "false"
     end
 
     def recording_method_disabled?
       return false unless @recording_method
 
-      env_var = [ 'APPMAP', 'RECORD', @recording_method.upcase ].join('_')
-      [ "#{[ 'APPMAP', 'RECORD', @recording_method.upcase ].join('_')}=false", false ] if ENV[env_var] == 'false'
+      env_var = ["APPMAP", "RECORD", @recording_method.upcase].join("_")
+      ["#{["APPMAP", "RECORD", @recording_method.upcase].join("_")}=false", false] if ENV[env_var] == "false"
     end
 
     def recording_method_enabled?
       return false unless @recording_method
 
-      env_var = [ 'APPMAP', 'RECORD', @recording_method.upcase ].join('_')
-      [ "#{[ 'APPMAP', 'RECORD', @recording_method.upcase ].join('_')}=true", true ] if ENV[env_var] == 'true'
+      env_var = ["APPMAP", "RECORD", @recording_method.upcase].join("_")
+      ["#{["APPMAP", "RECORD", @recording_method.upcase].join("_")}=true", true] if ENV[env_var] == "true"
     end
 
     def rails_env
       return Rails.env if defined?(::Rails::Railtie)
 
-      ENV.fetch('RAILS_ENV', nil)
+      ENV.fetch("RAILS_ENV", nil)
     end
   end
 end

data/lib/appmap/gem_hooks/activejob.yml

@@ -1,6 +1,5 @@
 - method: ActiveJob::Enqueuing#enqueue
   label: job.create
 - methods:
-  - ActiveJob::Execution#perform
   - ActiveJob::Execution#perform_now
   label: job.perform

data/lib/appmap/hook/method/ruby2.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
-require 'appmap/util'
+require "appmap/util"
+require_relative "../record_around"
 
-def ruby2_keywords(*); end unless respond_to?(:ruby2_keywords, true)
+unless respond_to?(:ruby2_keywords, true)
+  def ruby2_keywords(*)
+  end
+end
 
 module AppMap
   class Hook
     # Delegation methods for Ruby 2.
     # cf. https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
     class Method
+      include RecordAround
+
       ruby2_keywords def call(receiver, *args, &block)
         call_event = false
+        record_around_before
         if trace?
           call_event, elapsed_before = with_disabled_hook { before_hook receiver, *args }
         end
@@ -22,7 +29,7 @@ module AppMap
       protected
 
       def before_hook(receiver, *args)
-        before_hook_start_time = AppMap::Util.gettime()
+        before_hook_start_time = AppMap::Util.gettime
         call_event = handle_call(receiver, args)
         if call_event
           AppMap.tracing.record_event \
@@ -31,10 +38,11 @@ module AppMap
             defined_class: defined_class,
             method: hook_method
         end
-        [call_event, AppMap::Util.gettime() - before_hook_start_time]
+        [call_event, AppMap::Util.gettime - before_hook_start_time]
       end
 
       ruby2_keywords def do_call(receiver, *args, &block)
+        # Do not allow this to change to bind_call, it's not defined for Ruby 2.
         hook_method.bind(receiver).call(*args, &block)
       end
 
@@ -42,16 +50,19 @@ module AppMap
       ruby2_keywords def trace_call(call_event, elapsed_before, receiver, *args, &block)
         return do_call(receiver, *args, &block) unless call_event
 
-        start_time = AppMap::Util.gettime()
+        start_time = AppMap::Util.gettime
         begin
           return_value = do_call(receiver, *args, &block)
         rescue # rubocop:disable Style/RescueStandardError
           exception = $ERROR_INFO
           raise
         ensure
-          after_start_time = AppMap::Util.gettime()
-          with_disabled_hook { after_hook receiver, call_event, elapsed_before, after_start_time - start_time, after_start_time, return_value, exception } \
-            if call_event
+          after_start_time = AppMap::Util.gettime
+          begin
+            with_disabled_hook { after_hook receiver, call_event, elapsed_before, after_start_time - start_time, after_start_time, return_value, exception }
+          ensure
+            record_around_after
+          end
         end
       end
       # rubocop:enable Metrics/MethodLength

data/lib/appmap/hook/method/ruby3.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
-require 'appmap/util'
+require "appmap/util"
+require_relative "../record_around"
 
 module AppMap
   class Hook
     # Delegation methods for Ruby 3.
     class Method
+      include RecordAround
+
       def call(receiver, *args, **kwargs, &block)
         call_event = false
+        record_around_before
         if trace?
           call_event, elapsed_before = with_disabled_hook { before_hook receiver, *args, **kwargs }
         end
-        # note we can't short-circuit directly to do_call because then the call stack
+        # NOTE: we can't short-circuit directly to do_call because then the call stack
         # depth changes and eval handler doesn't work correctly
         trace_call call_event, elapsed_before, receiver, *args, **kwargs, &block
       end
@@ -19,7 +23,7 @@ module AppMap
       protected
 
       def before_hook(receiver, *args, **kwargs)
-        before_hook_start_time = AppMap::Util.gettime()
+        before_hook_start_time = AppMap::Util.gettime
         args = [*args, kwargs] if !kwargs.empty? || keyrest?
         call_event = handle_call(receiver, args)
         if call_event
@@ -29,31 +33,34 @@ module AppMap
             defined_class: defined_class,
             method: hook_method
         end
-        [call_event, AppMap::Util.gettime() - before_hook_start_time]
+        [call_event, AppMap::Util.gettime - before_hook_start_time]
       end
 
       def keyrest?
         @keyrest ||= parameters.map(&:last).include? :keyrest
       end
 
-      def do_call(receiver, *args, **kwargs, &block)
-        hook_method.bind_call(receiver, *args, **kwargs, &block)
+      def do_call(receiver, ...)
+        hook_method.bind_call(receiver, ...)
       end
 
       # rubocop:disable Metrics/MethodLength
-      def trace_call(call_event, elapsed_before, receiver, *args, **kwargs, &block)
-        return do_call(receiver, *args, **kwargs, &block) unless call_event
+      def trace_call(call_event, elapsed_before, receiver, ...)
+        return do_call(receiver, ...) unless call_event
 
-        start_time = AppMap::Util.gettime()
+        start_time = AppMap::Util.gettime
         begin
-          return_value = do_call(receiver, *args, **kwargs, &block)
+          return_value = do_call(receiver, ...)
         rescue # rubocop:disable Style/RescueStandardError
           exception = $ERROR_INFO
           raise
         ensure
-          after_start_time = AppMap::Util.gettime()
-          with_disabled_hook { after_hook receiver, call_event, elapsed_before, after_start_time - start_time, after_start_time, return_value, exception } \
-            if call_event
+          after_start_time = AppMap::Util.gettime
+          begin
+            with_disabled_hook { after_hook receiver, call_event, elapsed_before, after_start_time - start_time, after_start_time, return_value, exception }
+          ensure
+            record_around_after
+          end
         end
       end
       # rubocop:enable Metrics/MethodLength

data/lib/appmap/hook/method.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
-require 'appmap/util'
+require "appmap/util"
 
 module AppMap
   class Hook
     class << self
       def method_hash_key(cls, method)
-        [ cls, method.name ].hash
+        [cls, method.name].hash
       rescue TypeError => e
         warn "Error building hash key for #{cls}, #{method}: #{e}"
       end
     end
-    
 
     SIGNATURES = {}
     LOOKUP_SIGNATURE = lambda do |id|
@@ -32,19 +31,20 @@ module AppMap
       method
     end
 
-    RUBY_MAJOR_VERSION, RUBY_MINOR_VERSION, _ = RUBY_VERSION.split('.').map(&:to_i)
+    RUBY_MAJOR_VERSION, RUBY_MINOR_VERSION, _ = RUBY_VERSION.split(".").map(&:to_i)
 
     # Single hooked method.
     # Call #activate to override the original.
     class Method
-      attr_reader :hook_package, :hook_class, :hook_method, :parameters, :arity
+      attr_reader :hook_package, :hook_class, :hook_method, :record_around, :parameters, :arity
 
-      HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+      HOOK_DISABLE_KEY = "AppMap::Hook.disable"
 
-      def initialize(hook_package, hook_class, hook_method)
+      def initialize(hook_package, hook_class, hook_method, record_around: false)
         @hook_package = hook_package
         @hook_class = hook_class
         @hook_method = hook_method
+        @record_around = record_around
         @parameters = hook_method.parameters
         @arity = hook_method.arity
       end
@@ -52,11 +52,11 @@ module AppMap
       def activate
         if HookLog.enabled?
           msg = if method_display_name
-              "#{method_display_name}"
-            else
-              "#{hook_method.name} (class resolution deferred)"
-            end
-          HookLog.log "Hooking #{msg} at line #{(hook_method.source_location || []).join(':')}"
+            "#{method_display_name}"
+          else
+            "#{hook_method.name} (class resolution deferred)"
+          end
+          HookLog.log "Hooking #{msg} at line #{(hook_method.source_location || []).join(":")}"
         end
 
         hook_method_parameters = hook_method.parameters.dup.freeze
@@ -79,13 +79,13 @@ module AppMap
 
       def defining_class(hook_class)
         cls = if RUBY_MAJOR_VERSION == 2 && RUBY_MINOR_VERSION <= 5
-            hook_class
-              .ancestors
-              .select { |cls| cls.method_defined?(hook_method.name) }
-              .find { |cls| cls.instance_method(hook_method.name).owner == cls }
-          else
-            hook_class.ancestors.find { |cls| cls.method_defined?(hook_method.name, false) }
-          end
+          hook_class
+            .ancestors
+            .select { |cls| cls.method_defined?(hook_method.name) }
+            .find { |cls| cls.instance_method(hook_method.name).owner == cls }
+        else
+          hook_class.ancestors.find { |cls| cls.method_defined?(hook_method.name, false) }
+        end
 
         return cls if cls
 
@@ -93,7 +93,7 @@ module AppMap
       end
 
       def trace?
-        return false unless AppMap.tracing_enabled?
+        return false unless AppMap.tracing_enabled?(thread: Thread.current)
         return false if Thread.current[HOOK_DISABLE_KEY]
         return false if hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package
 
@@ -103,7 +103,7 @@ module AppMap
       def method_display_name
         return @method_display_name if @method_display_name
 
-        return @method_display_name = [defined_class, '#', hook_method.name].join if defined_class
+        return @method_display_name = [defined_class, "#", hook_method.name].join if defined_class
 
         "#{hook_method.name} (class resolution deferred)"
       end
@@ -114,7 +114,7 @@ module AppMap
 
       def after_hook(_receiver, call_event, elapsed_before, elapsed, after_start_time, return_value, exception)
         return_event = handle_return(call_event.id, elapsed, return_value, exception)
-        return_event.elapsed_instrumentation = elapsed_before + (AppMap::Util.gettime() - after_start_time)
+        return_event.elapsed_instrumentation = elapsed_before + (AppMap::Util.gettime - after_start_time)
         AppMap.tracing.record_event(return_event) if return_event
       end
 
@@ -141,20 +141,20 @@ module AppMap
   end
 end
 
-unless ENV['APPMAP_NO_PATCH_OBJECT'] == 'true'
+unless ENV["APPMAP_NO_PATCH_OBJECT"] == "true"
   class Object
     prepend AppMap::ObjectMethods
   end
 end
 
-unless ENV['APPMAP_NO_PATCH_MODULE'] == 'true'
+unless ENV["APPMAP_NO_PATCH_MODULE"] == "true"
   class Module
     prepend AppMap::ModuleMethods
   end
 end
 
-if RUBY_VERSION < '3'
-  require 'appmap/hook/method/ruby2'
+if RUBY_VERSION < "3"
+  require "appmap/hook/method/ruby2"
 else
-  require 'appmap/hook/method/ruby3'
+  require "appmap/hook/method/ruby3"
 end

data/lib/appmap/hook/record_around.rb

@@ -0,0 +1,77 @@
+module AppMap
+  class Hook
+    # Start and stop a recording around a Hook::Method.
+    module RecordAround
+      APPMAP_OUTPUT_DIR = File.join(AppMap.output_dir, "requests")
+
+      # Context for a recording.
+      class Context
+        attr_reader :hook_method
+
+        def initialize(hook_method)
+          @hook_method = hook_method
+          @start_time = DateTime.now
+          @tracer = AppMap.tracing.trace(thread: Thread.current)
+        end
+
+        # Finish recording the AppMap by collecting the events and classMap and writing the output file.
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
+        def finish
+          return unless @tracer
+
+          tracer = @tracer
+          @tracer = nil
+          AppMap.tracing.delete(tracer)
+
+          events = tracer.events.map(&:to_h)
+
+          timestamp = DateTime.now
+          appmap_name = "#{hook_method.name} (#{Thread.current.object_id}) - #{timestamp.strftime("%T.%L")}"
+          appmap_file_name = AppMap::Util.scenario_filename([timestamp.to_f, hook_method.name, Thread.current.object_id].join("_"))
+
+          metadata = AppMap.detect_metadata.tap do |metadata|
+            metadata[:name] = appmap_name
+            metadata[:source_location] = hook_method.source_location
+            metadata[:recorder] = {
+              name: "command",
+              type: "requests"
+            }
+          end
+
+          appmap = {
+            version: AppMap::APPMAP_FORMAT_VERSION,
+            classMap: AppMap.class_map(tracer.event_methods),
+            metadata: metadata,
+            events: events
+          }
+
+          AppMap::Util.write_appmap(File.join(APPMAP_OUTPUT_DIR, appmap_file_name), appmap)
+        end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/AbcSize
+      end
+
+      # If requests recording is enabled, and we encounter a method which should always be recorded
+      # when requests recording is on, and there is no other recording in progress, then start a
+      # new recording and end it when the method returns.
+      def record_around?
+        (record_around && AppMap.recording_enabled?(:requests) && !AppMap.tracing_enabled?(thread: Thread.current))
+      end
+
+      def record_around_before
+        return unless record_around?
+
+        @record_around_context = Context.new(hook_method)
+      end
+
+      def record_around_after
+        return unless @record_around_context
+
+        context = @record_around_context
+        @record_around_context = nil
+        context.finish
+      end
+    end
+  end
+end