appmap 0.35.1 → 0.38.1

data/lib/appmap/hook/method.rb

@@ -39,6 +39,7 @@ module AppMap
         end
 
         defined_class = @defined_class
+        hook_package = self.hook_package
         hook_method = self.hook_method
         before_hook = self.method(:before_hook)
         after_hook = self.method(:after_hook)
@@ -48,29 +49,34 @@ module AppMap
         hook_class.instance_eval do 
           hook_method_def = Proc.new do |*args, &block|
             instance_method = hook_method.bind(self).to_proc
+            call_instance_method = -> { instance_method.call(*args, &block) }
 
             # We may not have gotten the class for the method during
             # initialization (e.g. for a singleton method on an embedded
             # struct), so make sure we have it now.
-            defined_class,_ = Hook.qualify_method_name(hook_method) unless defined_class
+            defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
 
-            hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-            enabled = true if !hook_disabled && AppMap.tracing.enabled?
-            return instance_method.call(*args, &block) unless enabled
+            reentrant = Thread.current[HOOK_DISABLE_KEY]
+            disabled_by_shallow_flag = \
+              -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
 
-            call_event, start_time = with_disabled_hook.() do
-              before_hook.(self, defined_class, args)
+            enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
+
+            return call_instance_method.call unless enabled
+
+            call_event, start_time = with_disabled_hook.call do
+              before_hook.call(self, defined_class, args)
             end
             return_value = nil
             exception = nil
             begin
-              return_value = instance_method.(*args, &block)
+              return_value = call_instance_method.call
             rescue
               exception = $ERROR_INFO
               raise
             ensure
-              with_disabled_hook.() do
-                after_hook.(self, call_event, start_time, return_value, exception)
+              with_disabled_hook.call do
+                after_hook.call(self, call_event, start_time, return_value, exception)
               end
             end
           end
@@ -87,7 +93,7 @@ module AppMap
         [ call_event, TIME_NOW.call ]
       end
 
-      def after_hook(receiver, call_event, start_time, return_value, exception)
+      def after_hook(_receiver, call_event, start_time, return_value, exception)
         require 'appmap/event'
         elapsed = TIME_NOW.call - start_time
         return_event = \
@@ -95,12 +101,12 @@ module AppMap
         AppMap.tracing.record_event return_event
       end
 
-      def with_disabled_hook(&fn)
+      def with_disabled_hook(&function)
         # Don't record functions, such as to_s and inspect, that might be called
         # by the fn. Otherwise there can be a stack overflow.
         Thread.current[HOOK_DISABLE_KEY] = true
         begin
-          fn.call
+          function.call
         ensure
           Thread.current[HOOK_DISABLE_KEY] = false
         end

data/lib/appmap/rails/request_handler.rb

@@ -14,7 +14,14 @@ module AppMap
 
           @request_method = request.request_method
           @path_info = request.path_info.split('?')[0]
-          @params = ActionDispatch::Http::ParameterFilter.new(::Rails.application.config.filter_parameters).filter(request.params)
+          # ActionDispatch::Http::ParameterFilter is deprecated
+          parameter_filter_cls = \
+            if defined?(ActiveSupport::ParameterFilter)
+              ActiveSupport::ParameterFilter
+            else
+              ActionDispatch::Http::ParameterFilter
+            end
+          @params = parameter_filter_cls.new(::Rails.application.config.filter_parameters).filter(request.params)
         end
 
         def to_h

data/lib/appmap/railtie.rb

@@ -40,4 +40,4 @@ module AppMap
       end.call
     end
   end
-end
+end unless ENV['APPMAP_INITIALIZE'] == 'false'

data/lib/appmap/rspec.rb

@@ -148,7 +148,7 @@ module AppMap
 
         AppMap::RSpec.add_event_methods @trace.event_methods
 
-        class_map = AppMap.class_map(@trace.event_methods)
+        class_map = AppMap.class_map(@trace.event_methods, include_source: false)
 
         description = []
         scope = ScopeExample.new(example)

data/lib/appmap/trace.rb

@@ -15,34 +15,38 @@ module AppMap
 
     class Tracing
       def initialize
-        @tracing = []
+        @tracers = []
       end
 
       def empty?
-        @tracing.empty?
+        @tracers.empty?
       end
 
       def trace(enable: true)
         Tracer.new.tap do |tracer|
-          @tracing << tracer
+          @tracers << tracer
           tracer.enable if enable
         end
       end
 
       def enabled?
-        @tracing.any?(&:enabled?)
+        @tracers.any?(&:enabled?)
+      end
+
+      def last_package_for_current_thread
+        @tracers.first&.last_package_for_current_thread
       end
 
       def record_event(event, package: nil, defined_class: nil, method: nil)
-        @tracing.each do |tracer|
+        @tracers.each do |tracer|
           tracer.record_event(event, package: package, defined_class: defined_class, method: method)
         end
       end
 
       def delete(tracer)
-        return unless @tracing.member?(tracer)
+        return unless @tracers.member?(tracer)
 
-        @tracing.delete(tracer)
+        @tracers.delete(tracer)
         tracer.disable
       end
     end
@@ -52,6 +56,7 @@ module AppMap
     # Records the events which happen in a program.
     def initialize
       @events = []
+      @last_package_for_thread = {}
       @methods = Set.new
       @enabled = false
     end
@@ -75,11 +80,17 @@ module AppMap
     def record_event(event, package: nil, defined_class: nil, method: nil)
       return unless @enabled
 
+      @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event
       @methods << Trace::ScopedMethod.new(package, defined_class, method, event.static) \
         if package && defined_class && method && (event.event == :call)
     end
 
+    # Gets the last package which was observed on the current thread.
+    def last_package_for_current_thread
+      @last_package_for_thread[Thread.current.object_id]
+    end
+
     # Gets a unique list of the methods that were invoked by the program.
     def event_methods
       @methods.to_a

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.35.1'
+  VERSION = '0.38.1'
 
-  APPMAP_FORMAT_VERSION = '1.2'
+  APPMAP_FORMAT_VERSION = '1.3'
 end

data/spec/abstract_controller4_base_spec.rb

@@ -1,52 +1,50 @@
 require 'rails_spec_helper'
 
 describe 'AbstractControllerBase' do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails4_users_app' }
-  include_examples 'Rails app pg database'
-  
-  around(:each) do |example|
-    FileUtils.rm_rf tmpdir
-    FileUtils.mkdir_p tmpdir
-    cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:8"
-    run_cmd cmd, chdir: @fixture_dir
+  include_context 'Rails app pg database', 'spec/fixtures/rails4_users_app' do
+    around(:each) do |example|
+      FileUtils.rm_rf tmpdir
+      FileUtils.mkdir_p tmpdir
+      cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:8"
+      run_cmd cmd, chdir: fixture_dir
 
-    example.run
-  end
+      example.run
+    end
 
-  let(:tmpdir) { 'tmp/spec/AbstractControllerBase' }
-  let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+    let(:tmpdir) { 'tmp/spec/AbstractControllerBase' }
+    let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
 
-  describe 'testing with rspec' do
-    it 'Message fields are recorded in the appmap' do
-      expect(File).to exist(appmap_json)
-      appmap = JSON.parse(File.read(appmap_json)).to_yaml
+    describe 'testing with rspec' do
+      it 'Message fields are recorded in the appmap' do
+        expect(File).to exist(appmap_json)
+        appmap = JSON.parse(File.read(appmap_json)).to_yaml
 
-      expect(appmap).to include(<<-MESSAGE.strip)
+        expect(appmap).to include(<<-MESSAGE.strip)
   message:
   - name: login
     class: String
     value: alice
     object_id:
-      MESSAGE
+        MESSAGE
 
-      expect(appmap).to include(<<-MESSAGE.strip)
+        expect(appmap).to include(<<-MESSAGE.strip)
   - name: password
     class: String
     value: "[FILTERED]"
     object_id:
-      MESSAGE
+       MESSAGE
 
-      expect(appmap).to include(<<-SERVER_REQUEST.strip)
+        expect(appmap).to include(<<-SERVER_REQUEST.strip)
   http_server_request:
     request_method: POST
     path_info: "/api/users"
-      SERVER_REQUEST
-    end
-    it 'Properly captures method parameters in the appmap' do
-      expect(File).to exist(appmap_json)
-      appmap = JSON.parse(File.read(appmap_json)).to_yaml
+        SERVER_REQUEST
+      end
+      it 'Properly captures method parameters in the appmap' do
+        expect(File).to exist(appmap_json)
+        appmap = JSON.parse(File.read(appmap_json)).to_yaml
 
-      expect(appmap).to match(<<-CREATE_CALL.strip)
+        expect(appmap).to match(<<-CREATE_CALL.strip)
   event: call
   thread_id: .*
   defined_class: Api::UsersController
@@ -61,7 +59,8 @@ describe 'AbstractControllerBase' do
     value: '{"login"=>"alice"}'
     kind: req
   receiver:
-      CREATE_CALL
+        CREATE_CALL
+      end
     end
   end
 end

data/spec/abstract_controller_base_spec.rb

@@ -1,63 +1,67 @@
 require 'rails_spec_helper'
 
 describe 'AbstractControllerBase' do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
-  include_context 'Rails app pg database'
+  shared_examples 'rails version' do |rails_major_version|
+    include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" do
+      def run_spec(spec_name)
+        cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}"
+        run_cmd cmd, chdir: fixture_dir
+      end
 
-  around(:each) do |example|
-    FileUtils.rm_rf tmpdir
-    FileUtils.mkdir_p tmpdir
-    cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:8"
-    run_cmd cmd, chdir: @fixture_dir
+      before do
+        FileUtils.rm_rf tmpdir
+        FileUtils.mkdir_p tmpdir
+        run_spec spec_name
+      end
 
-    example.run
-  end
+      let(:tmpdir) { 'tmp/spec/AbstractControllerBase' }
 
-  let(:tmpdir) { 'tmp/spec/AbstractControllerBase' }
-  let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+      describe 'testing with rspec' do
+        let(:spec_name) { 'spec/controllers/users_controller_api_spec.rb:8' }
+        let(:appmap_json_file) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
 
-  describe 'testing with rspec' do
-    it 'inventory file is printed' do
-      expect(File).to exist(File.join(tmpdir, 'appmap/rspec/Inventory.appmap.json'))
-    end
+        describe 'creating a user' do
+          it 'inventory file is printed' do
+            expect(File).to exist(File.join(tmpdir, 'appmap/rspec/Inventory.appmap.json'))
+          end
 
-    it 'message fields are recorded in the appmap' do
-      expect(File).to exist(appmap_json)
-      appmap = JSON.parse(File.read(appmap_json)).to_yaml
+          it 'message fields are recorded in the appmap' do
+            expect(File).to exist(appmap_json_file)
+            appmap = JSON.parse(File.read(appmap_json_file)).to_yaml
 
-      expect(appmap).to include(<<-MESSAGE.strip)
+            expect(appmap).to include(<<-MESSAGE.strip)
   message:
   - name: login
     class: String
     value: alice
     object_id:
-      MESSAGE
+            MESSAGE
 
-      expect(appmap).to include(<<-MESSAGE.strip)
+            expect(appmap).to include(<<-MESSAGE.strip)
   - name: password
     class: String
     value: "[FILTERED]"
     object_id:
-      MESSAGE
+            MESSAGE
 
-      expect(appmap).to include(<<-SERVER_REQUEST.strip)
+            expect(appmap).to include(<<-SERVER_REQUEST.strip)
   http_server_request:
     request_method: POST
     path_info: "/api/users"
-      SERVER_REQUEST
+            SERVER_REQUEST
 
-      expect(appmap).to include(<<-SERVER_RESPONSE.strip)
+            expect(appmap).to include(<<-SERVER_RESPONSE.strip)
   http_server_response:
     status: 201
     mime_type: application/json; charset=utf-8
-      SERVER_RESPONSE
-    end
+            SERVER_RESPONSE
+          end
 
-    it 'properly captures method parameters in the appmap' do
-      expect(File).to exist(appmap_json)
-      appmap = JSON.parse(File.read(appmap_json)).to_yaml
+          it 'properly captures method parameters in the appmap' do
+            expect(File).to exist(appmap_json_file)
+            appmap = JSON.parse(File.read(appmap_json_file)).to_yaml
 
-      expect(appmap).to match(<<-CREATE_CALL.strip)
+            expect(appmap).to match(<<-CREATE_CALL.strip)
   event: call
   thread_id: .*
   defined_class: Api::UsersController
@@ -72,14 +76,45 @@ describe 'AbstractControllerBase' do
     value: '{"login"=>"alice"}'
     kind: req
   receiver:
-      CREATE_CALL
-    end
+            CREATE_CALL
+          end
+
+          it 'returns a minimal event' do
+            expect(File).to exist(appmap_json_file)
+            appmap = JSON.parse(File.read(appmap_json_file))
+            event = appmap['events'].find { |event| event['event'] == 'return' && event['return_value'] }
+            expect(event.keys).to eq(%w[id event thread_id parent_id elapsed return_value])
+          end
+        end
+
+        describe 'listing users' do
+          let(:spec_name) { 'spec/controllers/users_controller_spec.rb:11' }
+          let(:appmap_json_file) { File.join(tmpdir, 'appmap/rspec/UsersController_GET_users_lists_the_users.appmap.json') }
+          it 'records and labels view rendering' do
+            expect(File).to exist(appmap_json_file)
+            appmap = JSON.parse(File.read(appmap_json_file)).to_yaml
 
-    it 'returns a minimal event' do
-      expect(File).to exist(appmap_json)
-      appmap = JSON.parse(File.read(appmap_json))
-      event = appmap['events'].find { |event| event['event'] == 'return' && event['return_value'] }
-      expect(event.keys).to eq(%w[id event thread_id parent_id elapsed return_value])
+            expect(appmap).to match(<<-VIEW_CALL.strip)
+  event: call
+  thread_id: .*
+  defined_class: ActionView::Renderer
+  method_id: render
+  path: .*
+  lineno: .*
+  static: false
+            VIEW_CALL
+
+            expect(appmap).to match(<<-VIEW_LABEL.strip)
+        labels:
+        - view
+            VIEW_LABEL
+          end
+        end
+      end
     end
   end
+
+  %w[5 6].each do |version|
+    it_behaves_like 'rails version', version
+  end
 end

data/spec/class_map_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'AppMap::ClassMap' do
+  describe '.build_from_methods' do
+    it 'includes source code if available' do
+      map = AppMap.class_map([scoped_method(method(:test_method))])
+      function = dig_map(map, 5)[0]
+      expect(function[:source]).to include 'test method body'
+      expect(function[:comment]).to include 'test method comment'
+    end
+
+    it 'can omit source code even if available' do
+      map = AppMap.class_map([scoped_method((method :test_method))], include_source: false)
+      function = dig_map(map, 5)[0]
+      expect(function).to_not include(:source)
+      expect(function).to_not include(:comment)
+    end
+
+    # test method comment
+    def test_method
+      'test method body'
+    end
+
+    def scoped_method(method)
+      AppMap::Trace::ScopedMethod.new AppMap::Config::Package.new, method.receiver.class.name, method, false
+    end
+
+    def dig_map(map, depth)
+      return map if depth == 0
+
+      dig_map map[0][:children], depth - 1
+    end
+  end
+end