appmap 0.33.0 → 0.34.5

data/lib/appmap/hook.rb

@@ -6,23 +6,21 @@ module AppMap
   class Hook
     LOG = (ENV['DEBUG'] == 'true')
 
+    @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
+    @method_arity = ::Method.instance_method(:arity)
+
     class << self
+      def lock_builtins
+        return if @builtins_hooked
+
+        @builtins_hooked = true
+      end
+
       # Return the class, separator ('.' or '#'), and method name for
       # the given method.
       def qualify_method_name(method)
         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 = singleton_method_owner_name(method)
           [ class_name, '.', method.name ]
         else
           [ method.owner.name, '#', method.name ]
@@ -39,6 +37,8 @@ module AppMap
     def enable &block
       require 'appmap/hook/method'
 
+      hook_builtins
+
       tp = TracePoint.new(:end) do |trace_point|
         cls = trace_point.self
 
@@ -47,12 +47,10 @@ module AppMap
 
         hook = lambda do |hook_cls|
           lambda do |method_id|
-            next if method_id.to_s =~ /_hooked_by_appmap$/
-
             method = hook_cls.public_instance_method(method_id)
             hook_method = Hook::Method.new(hook_cls, method)
 
-            warn "AppMap: Examining #{hook_method.method_display_name}" if LOG
+            warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
             disasm = RubyVM::InstructionSequence.disasm(method)
             # Skip methods that have no instruction sequence, as they are obviously trivial.
@@ -63,7 +61,7 @@ module AppMap
             next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
 
             next unless \
-              config.always_hook?(hook_method.defined_class, method.name) ||
+              config.always_hook?(hook_cls, method.name) ||
               config.included_by_location?(method)
 
             hook_method.activate
@@ -76,5 +74,35 @@ module AppMap
 
       tp.enable(&block)
     end
+
+    def hook_builtins
+      return unless self.class.lock_builtins
+
+      class_from_string = lambda do |fq_class|
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
+
+      Config::BUILTIN_METHODS.each do |class_name, hook|
+        require hook.package.package_name if hook.package.package_name
+        Array(hook.method_names).each do |method_name|
+          method_name = method_name.to_sym
+          cls = class_from_string.(class_name)
+          method = \
+            begin
+              cls.instance_method(method_name)
+            rescue NameError
+              cls.method(method_name) rescue nil
+            end
+
+          if method
+            Hook::Method.new(cls, method).activate
+          else
+            warn "Method #{method_name} not found on #{cls.name}" 
+          end
+        end
+      end
+    end
   end
 end

data/lib/appmap/hook/method.rb

@@ -1,63 +1,91 @@
 module AppMap
   class Hook
     class Method
-      attr_reader :hook_class, :hook_method, :defined_class, :method_display_name
+      attr_reader :hook_class, :hook_method
+
+      # +method_display_name+ may be nil if name resolution gets
+      # deferred until runtime (e.g. for a singleton method on an
+      # embedded Struct).
+      attr_reader :method_display_name
 
       HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
       private_constant :HOOK_DISABLE_KEY
 
+      # Grab the definition of Time.now here, to avoid interfering
+      # with the method we're hooking.
+      TIME_NOW = Time.method(:now)
+      private_constant :TIME_NOW
+      
       def initialize(hook_class, hook_method)
         @hook_class = hook_class
         @hook_method = hook_method
+
+        # Get the class for the method, if it's known.
         @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
-        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join
+        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join if @defined_class
       end
 
       def activate
-        warn "AppMap: Hooking #{method_display_name}" if Hook::LOG
+        if Hook::LOG
+          msg = if method_display_name
+                  "#{method_display_name}"
+                else
+                  "#{hook_method.name} (class resolution deferred)"
+                end
+          warn "AppMap: Hooking " + msg
+        end
 
+        defined_class = @defined_class
         hook_method = self.hook_method
         before_hook = self.method(:before_hook)
         after_hook = self.method(:after_hook)
         with_disabled_hook = self.method(:with_disabled_hook)
 
-        hook_class.define_method hook_method.name do |*args, &block|
-          instance_method = hook_method.bind(self).to_proc
+        hook_method_def = nil
+        hook_class.instance_eval do 
+          hook_method_def = Proc.new do |*args, &block|
+            instance_method = hook_method.bind(self).to_proc
 
-          hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-          enabled = true if !hook_disabled && AppMap.tracing.enabled?
-          return instance_method.call(*args, &block) unless enabled
+            # 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
 
-          call_event, start_time = with_disabled_hook.() do
-            before_hook.(self, args)
-          end
-          return_value = nil
-          exception = nil
-          begin
-            return_value = instance_method.(*args, &block)
-          rescue
-            exception = $ERROR_INFO
-            raise
-          ensure
-            with_disabled_hook.() do
-              after_hook.(call_event, start_time, return_value, exception)
+            hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+            enabled = true if !hook_disabled && AppMap.tracing.enabled?
+            return instance_method.call(*args, &block) unless enabled
+
+            call_event, start_time = with_disabled_hook.() do
+              before_hook.(self, defined_class, args)
+            end
+            return_value = nil
+            exception = nil
+            begin
+              return_value = instance_method.(*args, &block)
+            rescue
+              exception = $ERROR_INFO
+              raise
+            ensure
+              with_disabled_hook.() do
+                after_hook.(call_event, start_time, return_value, exception)
+              end
             end
           end
         end
+        hook_class.define_method_with_arity(hook_method.name, hook_method.arity, hook_method_def)
       end
-
       protected
 
-      def before_hook(receiver, args)
+      def before_hook(receiver, defined_class, args)
         require 'appmap/event'
         call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
         AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
-        [ call_event, Time.now ]
+        [ call_event, TIME_NOW.call ]
       end
 
       def after_hook(call_event, start_time, return_value, exception)
         require 'appmap/event'
-        elapsed = Time.now - start_time
+        elapsed = TIME_NOW.call - start_time
         return_event = \
           AppMap::Event::MethodReturn.build_from_invocation call_event.id, elapsed, return_value, exception
         AppMap.tracing.record_event return_event

data/lib/appmap/rails/sql_handler.rb

@@ -73,20 +73,15 @@ module AppMap
 
         class ActiveRecordExaminer
           def server_version
-            case database_type
-            when :postgres
-              ActiveRecord::Base.connection.postgresql_version
-            when :sqlite
-              ActiveRecord::Base.connection.database_version.to_s
-            else
-              warn "Unable to determine database version for #{database_type.inspect}"
-            end
+            ActiveRecord::Base.connection.try(:database_version) ||\
+              warn("Unable to determine database version for #{database_type.inspect}")
           end
 
           def database_type
-            return :postgres if ActiveRecord::Base.connection.respond_to?(:postgresql_version)
+            type = ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+            type = :postgres if type == :postgresql
 
-            ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+            type
           end
 
           def execute_query(sql)

data/lib/appmap/rspec.rb

@@ -154,7 +154,7 @@ module AppMap
         end
 
         labels = labels.map(&:to_s).map(&:strip).reject(&:blank?).map(&:downcase).uniq
-        description.reject!(&:nil?).reject(&:blank?)
+        description.reject!(&:nil?).reject!(&:blank?)
         default_description = description.last
         description.reverse!
 

data/lib/appmap/util.rb

@@ -36,6 +36,23 @@ module AppMap
         [ fname, extension ].join
       end
 
+      # sanitize_paths removes ephemeral values from objects with
+      # embedded paths (e.g. an event or a classmap), making events
+      # easier to compare across runs.
+      def sanitize_paths(h)
+        require 'hashie'
+        h.extend(Hashie::Extensions::DeepLocate)
+        keys = %i(path location)
+        h.deep_locate ->(k,v,o) {
+          next unless keys.include?(k)
+          
+          fix = ->(v) {v.gsub(%r{#{Gem.dir}/gems/.*(?=lib)}, '')}
+          keys.each {|k| o[k] = fix.(o[k]) if o[k] }
+        }
+
+        h
+      end
+      
       # sanitize_event removes ephemeral values from an event, making
       # events easier to compare across runs.
       def sanitize_event(event, &block)
@@ -49,7 +66,7 @@ module AppMap
 
         case event[:event]
         when :call
-          event[:path] = event[:path].gsub(Gem.dir + '/', '')
+          sanitize_paths(event)
         end
 
         event

data/lib/appmap/version.rb

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

data/spec/fixtures/hook/instance_method.rb

@@ -20,4 +20,8 @@ class InstanceMethod
   def say_block(&block)
     yield
   end
+
+  def say_the_time
+    Time.now.to_s
+  end
 end

data/spec/fixtures/hook/singleton_method.rb

@@ -15,6 +15,20 @@ class SingletonMethod
     'defined with self class scope'
   end
 
+  module AddMethod
+    def self.included(base)
+      base.module_eval do
+        define_method "added_method" do
+          _added_method
+        end
+      end
+    end
+    
+    def _added_method
+      'defined by including a module'
+    end
+  end
+  
   # When called, do_include calls +include+ to bring in the module
   # AddMethod. AddMethod defines a new instance method, which gets
   # added to the singleton class of SingletonMethod.
@@ -32,23 +46,18 @@ class SingletonMethod
       end
     end
   end
-  
-  def to_s
-    'Singleton Method fixture'
-  end
-end
 
-module AddMethod
-  def self.included(base)
-    base.module_eval do
-      define_method "added_method" do
-        _added_method
+  STRUCT_TEST = Struct.new(:attr) do
+    class << self
+      def say_struct_singleton
+        'singleton for a struct'
       end
     end
   end
   
-  def _added_method
-    'defined by including a module'
+  def to_s
+    'Singleton Method fixture'
   end
 end
 
+

data/spec/hook_spec.rb

@@ -22,12 +22,12 @@ describe 'AppMap class Hooking', docker: false do
       while tracer.event?
         events << tracer.next_event.to_h
       end
-    end.map(&AppMap::Util.method(:sanitize_event)).to_yaml
+    end.map(&AppMap::Util.method(:sanitize_event))
   end
 
   def invoke_test_file(file, setup: nil, &block)
     AppMap.configuration = nil
-    package = AppMap::Package.new(file, nil, [])
+    package = AppMap::Config::Package.new(file)
     config = AppMap::Config.new('hook_spec', [ package ])
     AppMap.configuration = config
     tracer = nil
@@ -50,8 +50,9 @@ describe 'AppMap class Hooking', docker: false do
   def test_hook_behavior(file, events_yaml, setup: nil, &block)
     config, tracer = invoke_test_file(file, setup: setup, &block)
 
-    events = collect_events(tracer)
-    expect(Diffy::Diff.new(events, events_yaml).to_s).to eq('')
+    events = collect_events(tracer).to_yaml
+
+    expect(Diffy::Diff.new(events_yaml, events).to_s).to eq('')
 
     [ config, tracer ]
   end
@@ -99,7 +100,7 @@ describe 'AppMap class Hooking', docker: false do
       InstanceMethod.new.say_default
     end
     class_map = AppMap.class_map(tracer.event_methods).to_yaml
-    expect(Diffy::Diff.new(class_map, <<~YAML).to_s).to eq('')
+    expect(Diffy::Diff.new(<<~YAML, class_map).to_s).to eq('')
     ---
     - :name: spec/fixtures/hook/instance_method.rb
       :type: package
@@ -341,7 +342,7 @@ describe 'AppMap class Hooking', docker: false do
       :defined_class: SingletonMethod
       :method_id: added_method
       :path: spec/fixtures/hook/singleton_method.rb
-      :lineno: 44
+      :lineno: 21
       :static: false
       :parameters: []
       :receiver:
@@ -349,10 +350,10 @@ describe 'AppMap class Hooking', docker: false do
         :value: Singleton Method fixture
     - :id: 2
       :event: :call
-      :defined_class: AddMethod
+      :defined_class: SingletonMethod::AddMethod
       :method_id: _added_method
       :path: spec/fixtures/hook/singleton_method.rb
-      :lineno: 50
+      :lineno: 27
       :static: false
       :parameters: []
       :receiver:
@@ -394,10 +395,44 @@ describe 'AppMap class Hooking', docker: false do
     load 'spec/fixtures/hook/singleton_method.rb'
     setup = -> { SingletonMethod.new_with_instance_method }
     test_hook_behavior 'spec/fixtures/hook/singleton_method.rb', events_yaml, setup: setup do |s|
+      # Make sure we're testing the right thing
+      say_instance_defined = s.method(:say_instance_defined)
+      expect(say_instance_defined.owner.to_s).to start_with('#<Class:#<SingletonMethod:')
+
+      # Verify the native extension works as expected
+      expect(AppMap::Hook.singleton_method_owner_name(say_instance_defined)).to eq('SingletonMethod')
+      
       expect(s.say_instance_defined).to eq('defined for an instance')
     end
   end
 
+  it 'hooks a singleton method on an embedded struct' do
+    events_yaml = <<~YAML
+    ---
+    - :id: 1
+      :event: :call
+      :defined_class: SingletonMethod::STRUCT_TEST
+      :method_id: say_struct_singleton
+      :path: spec/fixtures/hook/singleton_method.rb
+      :lineno: 52
+      :static: true
+      :parameters: []
+      :receiver:
+        :class: Class
+        :value: SingletonMethod::STRUCT_TEST
+    - :id: 2
+      :event: :return
+      :parent_id: 1
+      :return_value:
+        :class: String
+        :value: singleton for a struct
+    YAML
+
+    test_hook_behavior 'spec/fixtures/hook/singleton_method.rb', events_yaml do
+      expect(SingletonMethod::STRUCT_TEST.say_struct_singleton).to eq('singleton for a struct')
+    end
+  end
+  
   it 'Reports exceptions' do
     events_yaml = <<~YAML
     ---
@@ -465,7 +500,7 @@ describe 'AppMap class Hooking', docker: false do
         :event: :call
         :defined_class: ActiveSupport::SecurityUtils
         :method_id: secure_compare
-        :path: gems/activesupport-6.0.3.2/lib/active_support/security_utils.rb
+        :path: lib/active_support/security_utils.rb
         :lineno: 26
         :static: true
         :parameters:
@@ -481,12 +516,52 @@ describe 'AppMap class Hooking', docker: false do
           :class: Module
           :value: ActiveSupport::SecurityUtils
       - :id: 3
+        :event: :call
+        :defined_class: Digest::Instance
+        :method_id: digest
+        :path: Digest::Instance#digest
+        :static: false
+        :parameters:
+        - :name: arg
+          :class: String
+          :value: string
+          :kind: :rest
+        :receiver:
+          :class: Digest::SHA256
+          :value: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      - :id: 4
+        :event: :return
+        :parent_id: 3
+        :return_value:
+          :class: String
+          :value: "G2__)__qc____X____3_].\\x02y__.___/_"
+      - :id: 5
+        :event: :call
+        :defined_class: Digest::Instance
+        :method_id: digest
+        :path: Digest::Instance#digest
+        :static: false
+        :parameters:
+        - :name: arg
+          :class: String
+          :value: string
+          :kind: :rest
+        :receiver:
+          :class: Digest::SHA256
+          :value: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      - :id: 6
+        :event: :return
+        :parent_id: 5
+        :return_value:
+          :class: String
+          :value: "G2__)__qc____X____3_].\\x02y__.___/_"
+      - :id: 7
         :event: :return
         :parent_id: 2
         :return_value:
           :class: TrueClass
           :value: 'true'
-      - :id: 4
+      - :id: 8
         :event: :return
         :parent_id: 1
         :return_value:
@@ -523,22 +598,82 @@ describe 'AppMap class Hooking', docker: false do
             :children:
             - :name: secure_compare
               :type: function
-              :location: gems/activesupport-6.0.3.2/lib/active_support/security_utils.rb:26
+              :location: lib/active_support/security_utils.rb:26
               :static: true
               :labels:
               - security
+              - crypto
+      - :name: openssl
+        :type: package
+        :children:
+        - :name: Digest
+          :type: class
+          :children:
+          - :name: Instance
+            :type: class
+            :children:
+            - :name: digest
+              :type: function
+              :location: Digest::Instance#digest
+              :static: false
+              :labels:
+              - security
+              - crypto
       YAML
 
       config, tracer = invoke_test_file 'spec/fixtures/hook/compare.rb' do
         expect(Compare.compare('string', 'string')).to be_truthy
       end
-      cm = AppMap::ClassMap.build_from_methods(config, tracer.event_methods)
+      cm = AppMap::Util.sanitize_paths(AppMap::ClassMap.build_from_methods(config, tracer.event_methods))
       entry = cm[1][:children][0][:children][0][:children][0]
       # Sanity check, make sure we got the right one
       expect(entry[:name]).to eq('secure_compare')
       spec = Gem::Specification.find_by_name('activesupport')
       entry[:location].gsub!(spec.base_dir + '/', '')
-      expect(Diffy::Diff.new(cm.to_yaml, classmap_yaml).to_s).to eq('')
+      expect(Diffy::Diff.new(classmap_yaml, cm.to_yaml).to_s).to eq('')
+    end
+  end
+
+  it "doesn't cause expectations on Time.now to fail" do
+    events_yaml = <<~YAML
+    ---
+    - :id: 1
+      :event: :call
+      :defined_class: InstanceMethod
+      :method_id: say_the_time
+      :path: spec/fixtures/hook/instance_method.rb
+      :lineno: 24
+      :static: false
+      :parameters: []
+      :receiver:
+        :class: InstanceMethod
+        :value: Instance Method fixture
+    - :id: 2
+      :event: :return
+      :parent_id: 1
+      :return_value:
+        :class: String
+        :value: '2020-01-01 00:00:00 +0000'
+    YAML
+    test_hook_behavior 'spec/fixtures/hook/instance_method.rb', events_yaml do
+      require 'timecop'
+      begin
+        tz = ENV['TZ']
+        ENV['TZ'] = 'UTC'
+        Timecop.freeze(Time.utc('2020-01-01')) do
+          expect(Time).to receive(:now).exactly(3).times.and_call_original
+          expect(InstanceMethod.new.say_the_time).to be
+        end
+      ensure
+        ENV['TZ'] = tz
+      end
+    end
+  end
+
+  it "preserves the arity of hooked methods" do
+    invoke_test_file 'spec/fixtures/hook/instance_method.rb' do
+      expect(InstanceMethod.instance_method(:say_echo).arity).to be(1)
+      expect(InstanceMethod.new.method(:say_echo).arity).to be(1)
     end
   end
 end