appmap 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54b9a05aeb3eea84572b115a6de1106e6743b74046048e3c168f99a75aa9e669
-  data.tar.gz: eb8a690376d833c4bec9f0789c5499f413f7dcb3b1ef111257785bd344861f64
+  metadata.gz: f6becd9530caf01e14b8a7db69e74b40297d41e4724f25315cd7b44ea6ad3e02
+  data.tar.gz: 2863e714f0651d73fc9f2f87d0ea2c5f9fb7f9f553d1f109d9d8f10fff35f5be
 SHA512:
-  metadata.gz: 453f06041220ecd0a4fc563ae007e7f8247d3dfcccf49657cbf47ddc53d0175e6834d1dbd89a2338a032d6cfae866929216b58a11bb6f0fe3fd2ea69508d7b2a
-  data.tar.gz: 77f372ad255c3c664c690affa2962958cebd1e8f34579809e4d975fdf57404889d8506f9153d44a95afda297ffe7b1654529252a5293487477e803bdf0cc9608
+  metadata.gz: a5574478fee68b2531449df2b9ec135a60110950cdcd518cf5b85d10e6d0d756b3e22740a4ce0905d7fccb2e6e7d684ee38ac61fd11ad6fdfcff4355a7ae7b36
+  data.tar.gz: d15827a809ffde6b6ff98bfb62057f759cdc03e7e24452c1a8273801f94e37d61bab265ddb863ce8f60d83c639875fcf2d247f27abe9b27164817f0739b7c699

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.32.0
+
+* Removes un-necessary fields from `return` events.
+
 # v0.31.0
 
 * Add the ability to hook methods by default, and optionally add labels to them in the

data/README.md

@@ -33,7 +33,7 @@ There are several ways to record AppMaps of your Ruby program using the `appmap`
 
 Once you have recorded some AppMaps (for example, by running RSpec tests), you use the `appland upload` command
 to upload them to the AppLand server. This command, and some others, is provided
-by the [AppLand CLI](https://github.com/applandinc/appland-cli/releases), to
+by the [AppLand CLI](https://github.com/applandinc/appland-cli/releases).
 Then, on the [AppLand website](https://app.land), you can
 visualize the design of your code and share links with collaborators.
 
@@ -87,12 +87,25 @@ Each entry in the `packages` list is a YAML object which has the following keys:
 
 To record RSpec tests, follow these additional steps:
 
-1) Require `appmap/rspec` in your `spec_helper.rb`.
+1) Require `appmap/rspec` in your `spec_helper.rb` before any other classes are loaded.
 
 ```ruby
 require 'appmap/rspec'
 ```
 
+Note that `spec_helper.rb` in a Rails project typically loads the application's classes this way:
+
+```ruby
+require File.expand_path("../../config/environment", __FILE__)
+```
+
+and `appmap/rspec` must be required before this:
+
+```ruby
+require 'appmap/rspec'
+require File.expand_path("../../config/environment", __FILE__)
+```
+
 2) *Optional* Add `feature: '<feature name>'` and `feature_group: '<feature group name>'` annotations to your 
    examples. 
 
@@ -136,6 +149,19 @@ To record Minitest tests, follow these additional steps:
 require 'appmap/minitest'
 ```
 
+Note that `test_helper.rb` in a Rails project typically loads the application's classes this way:
+
+```ruby
+require_relative '../config/environment'
+```
+
+and `appmap/rspec` must be required before this:
+
+```ruby
+require 'appmap/rspec'
+require_relative '../config/environment'
+```
+
 2) Run the tests with the environment variable `APPMAP=true`:
 
 ```sh-session
@@ -159,6 +185,8 @@ To record Cucumber tests, follow these additional steps:
 require 'appmap/cucumber'
 ```
 
+Be sure to require it before `config/environment` is required.
+
 2) Create an `Around` hook in `support/hooks.rb` to record the scenario:
 
 

data/lib/appmap.rb

@@ -13,6 +13,7 @@ require 'appmap/config'
 require 'appmap/trace'
 require 'appmap/class_map'
 require 'appmap/metadata'
+require 'appmap/util'
 
 module AppMap
   class << self

data/lib/appmap/class_map.rb

@@ -80,10 +80,6 @@ module AppMap
       protected
 
       def add_function(root, package, method)
-        location = 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.static
 
         object_infos = [
@@ -101,12 +97,17 @@ module AppMap
         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/config.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
 module AppMap
-  Package = Struct.new(:path, :exclude, :labels) do
-    def initialize(path, exclude, labels = nil)
+  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
@@ -20,10 +21,7 @@ module AppMap
     # package and labels that should be applied to them.
     HOOKED_METHODS = {
       'ActiveSupport::SecurityUtils' => {
-        secure_compare: Package.new('active_support', nil, ['security'])
-      },
-      'OpenSSL::X509::Certificate' => {
-        sign: Package.new('openssl', nil, ['security'])
+        secure_compare: Package.new('active_support', nil, nil, ['security'])
       }
     }
 
@@ -43,7 +41,7 @@ module AppMap
       # Loads configuration from a Hash.
       def load(config_data)
         packages = (config_data['packages'] || []).map do |package|
-          Package.new(package['path'], package['exclude'] || [])
+          Package.new(package['path'], nil, package['exclude'] || [])
         end
         Config.new config_data['name'], packages
       end
@@ -57,14 +55,14 @@ module AppMap
     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
 
-      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_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) &&
@@ -83,7 +81,7 @@ module AppMap
     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

data/lib/appmap/event.rb

@@ -15,21 +15,15 @@ module AppMap
       end
     end
 
-    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :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)
+        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.thread_id = Thread.current.object_id
         end
 
@@ -58,15 +52,25 @@ module AppMap
           (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
         end
       end
-
     end
 
     class MethodCall < MethodEvent
-      attr_accessor :parameters, :receiver, :static
+      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'
@@ -84,17 +88,22 @@ module AppMap
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
-            mc.static = receiver.is_a?(Module)
-            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
 
@@ -105,11 +114,11 @@ module AppMap
       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

data/lib/appmap/hook.rb

@@ -4,9 +4,7 @@ require 'English'
 
 module AppMap
   class Hook
-    LOG = false
-
-    HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+    LOG = (ENV['DEBUG'] == 'true')
 
     class << self
       # Return the class, separator ('.' or '#'), and method name for
@@ -17,7 +15,7 @@ module AppMap
           # #<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
@@ -39,89 +37,41 @@ module AppMap
 
     # Observe class loading and hook all methods which match the config.
     def enable &block
-      before_hook = lambda do |defined_class, method, receiver, args|
-        require 'appmap/event'
-        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, method, receiver, args)
-        AppMap.tracing.record_event call_event, defined_class: defined_class, method: method
-        [ call_event, Time.now ]
-      end
-
-      after_hook = lambda do |call_event, defined_class, method, start_time, return_value, exception|
-        require 'appmap/event'
-        elapsed = Time.now - start_time
-        return_event = AppMap::Event::MethodReturn.build_from_invocation \
-                                                     defined_class, method, call_event.id, elapsed, return_value, exception
-        AppMap.tracing.record_event return_event
-      end
-
-      with_disabled_hook = lambda do |&fn|
-        # 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
-        ensure
-          Thread.current[HOOK_DISABLE_KEY] = false
-        end
-      end
+      require 'appmap/hook/method'
 
-      tp = TracePoint.new(:end) do |tp|
-        hook = self
-        cls = tp.self
+      tp = TracePoint.new(:end) do |trace_point|
+        cls = trace_point.self
 
         instance_methods = cls.public_instance_methods(false)
         class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
 
-        hook_method = lambda do |cls|
+        hook = lambda do |hook_cls|
           lambda do |method_id|
             next if method_id.to_s =~ /_hooked_by_appmap$/
 
-            method = cls.public_instance_method(method_id)
+            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
+
             disasm = RubyVM::InstructionSequence.disasm(method)
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
-            defined_class, method_symbol, method_name = Hook.qualify_method_name(method)
-            method_display_name = [defined_class, method_symbol, method_name].join
-
             # Don't try and trace the AppMap methods or there will be
             # a stack overflow in the defined hook method.
-            next if /\AAppMap[:\.]/.match?(method_display_name) 
+            next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
 
             next unless \
-              config.always_hook?(defined_class, method_name) ||
+              config.always_hook?(hook_method.defined_class, method.name) ||
               config.included_by_location?(method)
 
-            warn "AppMap: Hooking #{method_display_name}" if LOG
-
-            cls.define_method method_id do |*args, &block|
-              base_method = method.bind(self).to_proc
-
-              hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-              enabled = true if !hook_disabled && AppMap.tracing.enabled?
-              return base_method.call(*args, &block) unless enabled
-
-              call_event, start_time = with_disabled_hook.call do
-                before_hook.call(defined_class, method, self, args)
-              end
-              return_value = nil
-              exception = nil
-              begin
-                return_value = base_method.call(*args, &block)
-              rescue
-                exception = $ERROR_INFO
-                raise
-              ensure
-                with_disabled_hook.call do
-                  after_hook.call(call_event, defined_class, method, start_time, return_value, exception)
-                end
-              end
-            end
+            hook_method.activate
           end
         end
 
-        instance_methods.each(&hook_method.call(cls))
-        class_methods.each(&hook_method.call(cls.singleton_class))
+        instance_methods.each(&hook.(cls))
+        class_methods.each(&hook.(cls.singleton_class))
       end
 
       tp.enable(&block)

data/lib/appmap/hook/method.rb

@@ -0,0 +1,78 @@
+module AppMap
+  class Hook
+    class Method
+      attr_reader :hook_class, :hook_method, :defined_class, :method_display_name
+
+      HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+      private_constant :HOOK_DISABLE_KEY
+
+      def initialize(hook_class, hook_method)
+        @hook_class = hook_class
+        @hook_method = hook_method
+        @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
+        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join
+      end
+
+      def activate
+        warn "AppMap: Hooking #{method_display_name}" if Hook::LOG
+
+        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_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, 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
+
+      protected
+
+      def before_hook(receiver, 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 ]
+      end
+
+      def after_hook(call_event, start_time, return_value, exception)
+        require 'appmap/event'
+        elapsed = Time.now - start_time
+        return_event = \
+          AppMap::Event::MethodReturn.build_from_invocation call_event.id, elapsed, return_value, exception
+        AppMap.tracing.record_event return_event
+      end
+
+      def with_disabled_hook(&fn)
+        # 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
+        ensure
+          Thread.current[HOOK_DISABLE_KEY] = false
+        end
+      end
+    end
+  end
+end

data/lib/appmap/rails/action_handler.rb

@@ -16,11 +16,11 @@ module AppMap
       class HTTPServerRequest
         include ContextKey
 
-        class Call < AppMap::Event::MethodEvent
+        class Call < AppMap::Event::MethodCall
           attr_accessor :payload
 
-          def initialize(path, lineno, payload)
-            super AppMap::Event.next_id_counter, :call, HTTPServerRequest, :call, path, lineno, Thread.current.object_id
+          def initialize(payload)
+            super AppMap::Event.next_id_counter, :call, Thread.current.object_id
 
             self.payload = payload
           end
@@ -47,7 +47,7 @@ module AppMap
         end
 
         def call(_, started, finished, _, payload) # (name, started, finished, unique_id, payload)
-          event = Call.new(__FILE__, __LINE__, payload)
+          event = Call.new(payload)
           Thread.current[context_key] = Context.new(event.id, Time.now)
           AppMap.tracing.record_event(event)
         end
@@ -59,8 +59,8 @@ module AppMap
         class Call < AppMap::Event::MethodReturnIgnoreValue
           attr_accessor :payload
 
-          def initialize(path, lineno, payload, parent_id, elapsed)
-            super AppMap::Event.next_id_counter, :return, HTTPServerResponse, :call, path, lineno, Thread.current.object_id
+          def initialize(payload, parent_id, elapsed)
+            super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
             self.payload = payload
             self.parent_id = parent_id
@@ -82,7 +82,7 @@ module AppMap
           context = Thread.current[context_key]
           Thread.current[context_key] = nil
 
-          event = Call.new(__FILE__, __LINE__, payload, context.id, Time.now - context.start_time)
+          event = Call.new(payload, context.id, Time.now - context.start_time)
           AppMap.tracing.record_event(event)
         end
       end

data/lib/appmap/rails/sql_handler.rb

@@ -5,11 +5,11 @@ require 'appmap/event'
 module AppMap
   module Rails
     class SQLHandler
-      class SQLCall < AppMap::Event::MethodEvent
+      class SQLCall < AppMap::Event::MethodCall
         attr_accessor :payload
 
-        def initialize(path, lineno, payload)
-          super AppMap::Event.next_id_counter, :call, SQLHandler, :call, path, lineno, Thread.current.object_id
+        def initialize(payload)
+          super AppMap::Event.next_id_counter, :call, Thread.current.object_id
 
           self.payload = payload
         end
@@ -20,7 +20,7 @@ module AppMap
               sql: payload[:sql],
               database_type: payload[:database_type]
             }.tap do |sql_query|
-              %i[server_version explain_sql].each do |attribute|
+              %i[server_version].each do |attribute|
                 sql_query[attribute] = payload[attribute] if payload[attribute]
               end
             end
@@ -29,8 +29,8 @@ module AppMap
       end
 
       class SQLReturn < AppMap::Event::MethodReturnIgnoreValue
-        def initialize(path, lineno, parent_id, elapsed)
-          super AppMap::Event.next_id_counter, :return, SQLHandler, :call, path, lineno, Thread.current.object_id
+        def initialize(parent_id, elapsed)
+          super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
           self.parent_id = parent_id
           self.elapsed = elapsed
@@ -76,6 +76,8 @@ module AppMap
             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
@@ -133,9 +135,9 @@ module AppMap
 
           SQLExaminer.examine payload, sql: sql
 
-          call = SQLCall.new(__FILE__, __LINE__, payload)
+          call = SQLCall.new(payload)
           AppMap.tracing.record_event(call)
-          AppMap.tracing.record_event(SQLReturn.new(__FILE__, __LINE__, call.id, finished - started))
+          AppMap.tracing.record_event(SQLReturn.new(call.id, finished - started))
         ensure
           Thread.current[reentry_key] = nil
         end

data/lib/appmap/trace.rb

@@ -14,34 +14,34 @@ module AppMap
 
     class Tracing
       def initialize
-        @Tracing = []
+        @tracing = []
       end
 
       def empty?
-        @Tracing.empty?
+        @tracing.empty?
       end
 
       def trace(enable: true)
         Tracer.new.tap do |tracer|
-          @Tracing << tracer
+          @tracing << tracer
           tracer.enable if enable
         end
       end
 
       def enabled?
-        @Tracing.any?(&:enabled?)
+        @tracing.any?(&:enabled?)
       end
 
       def record_event(event, defined_class: nil, method: nil)
-        @Tracing.each do |tracer|
+        @tracing.each do |tracer|
           tracer.record_event(event, defined_class: defined_class, method: method)
         end
       end
 
       def delete(tracer)
-        return unless @Tracing.member?(tracer)
+        return unless @tracing.member?(tracer)
 
-        @Tracing.delete(tracer)
+        @tracing.delete(tracer)
         tracer.disable
       end
     end

data/lib/appmap/util.rb

@@ -35,6 +35,25 @@ module AppMap
 
         [ fname, extension ].join
       end
+
+      # sanitize_event removes ephemeral values from an event, making
+      # events easier to compare across runs.
+      def sanitize_event(event, &block)
+        event.delete(:thread_id)
+        event.delete(:elapsed)
+        delete_object_id = ->(obj) { (obj || {}).delete(:object_id) }
+        delete_object_id.call(event[:receiver])
+        delete_object_id.call(event[:return_value])
+        (event[:parameters] || []).each(&delete_object_id)
+        (event[:exceptions] || []).each(&delete_object_id)
+
+        case event[:event]
+        when :call
+          event[:path] = event[:path].gsub(Gem.dir + '/', '')
+        end
+
+        event
+      end
     end
   end
 end

data/lib/appmap/version.rb

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

data/spec/abstract_controller4_base_spec.rb

@@ -48,11 +48,11 @@ describe 'AbstractControllerBase' do
 
       expect(appmap).to match(<<-CREATE_CALL.strip)
   event: call
+  thread_id: .*
   defined_class: Api::UsersController
   method_id: build_user
   path: app/controllers/api/users_controller.rb
   lineno: 23
-  thread_id: .*
   static: false
   parameters:
   - name: params

data/spec/abstract_controller_base_spec.rb

@@ -47,17 +47,17 @@ describe 'AbstractControllerBase' do
       SERVER_REQUEST
     end
 
-    it 'Properly captures method parameters in the appmap' do
+    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)
   event: call
+  thread_id: .*
   defined_class: Api::UsersController
   method_id: build_user
   path: app/controllers/api/users_controller.rb
   lineno: 23
-  thread_id: .*
   static: false
   parameters:
   - name: params
@@ -68,5 +68,12 @@ describe 'AbstractControllerBase' do
   receiver:
       CREATE_CALL
     end
+
+    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])
+    end
   end
 end

data/spec/hook_spec.rb

@@ -16,36 +16,18 @@ end
 Psych::Visitors::YAMLTree.prepend(ShowYamlNulls)
 
 describe 'AppMap class Hooking', docker: false do
+  require 'appmap/util'
   def collect_events(tracer)
     [].tap do |events|
       while tracer.event?
         events << tracer.next_event.to_h
       end
-    end.map do |event|
-      event.delete(:thread_id)
-      event.delete(:elapsed)
-      delete_object_id = ->(obj) { (obj || {}).delete(:object_id) }
-      delete_object_id.call(event[:receiver])
-      delete_object_id.call(event[:return_value])
-      (event[:parameters] || []).each(&delete_object_id)
-      (event[:exceptions] || []).each(&delete_object_id)
-
-      case event[:event]
-      when :call
-        event[:path] = event[:path].gsub(Gem.dir + '/', '')
-      when :return
-        # These should be removed from the appmap spec
-        %i[defined_class method_id path lineno static].each do |obsolete_field|
-          event.delete(obsolete_field)
-        end
-      end
-      event
-    end.to_yaml
+    end.map(&AppMap::Util.method(:sanitize_event)).to_yaml
   end
 
   def invoke_test_file(file, setup: nil, &block)
     AppMap.configuration = nil
-    package = AppMap::Package.new(file, [])
+    package = AppMap::Package.new(file, nil, [])
     config = AppMap::Config.new('hook_spec', [ package ])
     AppMap.configuration = config
     tracer = nil
@@ -99,7 +81,7 @@ describe 'AppMap class Hooking', docker: false do
         :class: String
         :value: default
     YAML
-    config, tracer = test_hook_behavior 'spec/fixtures/hook/instance_method.rb', events_yaml do
+    test_hook_behavior 'spec/fixtures/hook/instance_method.rb', events_yaml do
       expect(InstanceMethod.new.say_default).to eq('default')
     end
   end
@@ -456,20 +438,6 @@ describe 'AppMap class Hooking', docker: false do
     end
   end
 
-  context 'OpenSSL::X509::Certificate.sign' do
-    # OpenSSL::X509 is not being hooked.
-    # This might be because the class is being loaded before AppMap, and so the TracePoint
-    # set by AppMap doesn't see it.
-    xit 'is hooked' do
-      events_yaml = <<~YAML
-      ---
-      YAML
-      test_hook_behavior 'spec/fixtures/hook/openssl_sign.rb', events_yaml do
-        expect(OpenSSLExample.example).to be_truthy
-      end
-    end
-  end
-
   context 'ActiveSupport::SecurityUtils.secure_compare' do
     it 'is hooked' do
       events_yaml = <<~YAML
@@ -560,7 +528,7 @@ describe 'AppMap class Hooking', docker: false do
               :labels:
               - security
       YAML
-      
+
       config, tracer = invoke_test_file 'spec/fixtures/hook/compare.rb' do
         expect(Compare.compare('string', 'string')).to be_truthy
       end

data/spec/record_sql_rails_pg_spec.rb

@@ -1,6 +1,6 @@
 require 'rails_spec_helper'
 
-describe 'Record SQL queries in a Rails app' do
+describe 'SQL events' do
   before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
   include_context 'Rails app pg database'
 
@@ -14,54 +14,77 @@ describe 'Record SQL queries in a Rails app' do
   end
 
   let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
-  let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
 
-  context 'while creating a new record' do
+  describe 'fields' do
     let(:test_line_number) { 8 }
     let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+    let(:orm_module) { 'sequel' }
+    let(:appmap) { JSON.parse(File.read(appmap_json)) }
+    describe 'on a call event' do
+      let(:event) do
+        appmap['events'].find do |event|
+          event['event'] == 'call' &&
+            event.keys.include?('sql_query')
+        end
+      end
+      it 'do not include function-only fields' do
+        expect(event.keys).to_not include('defined_class')
+        expect(event.keys).to_not include('method_id')
+        expect(event.keys).to_not include('path')
+        expect(event.keys).to_not include('lineno')
+      end
+    end
+  end
+
+  describe 'in a Rails app' do
+    let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
+    context 'while creating a new record' do
+      let(:test_line_number) { 8 }
+      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
 
-    context 'using Sequel ORM' do
-      let(:orm_module) { 'sequel' }
-      it 'detects the sql INSERT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      context 'using Sequel ORM' do
+        let(:orm_module) { 'sequel' }
+        it 'detects the sql INSERT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login") VALUES ('alice') RETURNING *
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
-    end
-    context 'using ActiveRecord ORM' do
-      let(:orm_module) { 'activerecord' }
-      it 'detects the sql INSERT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      context 'using ActiveRecord ORM' do
+        let(:orm_module) { 'activerecord' }
+        it 'detects the sql INSERT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login") VALUES ($1) RETURNING "id"
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
     end
-  end
-
-  context 'while listing records' do
-    let(:test_line_number) { 23 }
-    let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
-
-    context 'using Sequel ORM' do
-      let(:orm_module) { 'sequel' }
-      it 'detects the sql SELECT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+  
+    context 'while listing records' do
+      let(:test_line_number) { 23 }
+      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
+  
+      context 'using Sequel ORM' do
+        let(:orm_module) { 'sequel' }
+        it 'detects the sql SELECT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT * FROM "users"
-        SQL_QUERY
-
-        expect(appmap).to include('sql:')
+          SQL_QUERY
+  
+          expect(appmap).to include('sql:')
+        end
       end
-    end
-    context 'using ActiveRecord ORM' do
-      let(:orm_module) { 'activerecord' }
-      it 'detects the sql SELECT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      context 'using ActiveRecord ORM' do
+        let(:orm_module) { 'activerecord' }
+        it 'detects the sql SELECT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT "users".* FROM "users"
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
     end
   end

data/test/cli_test.rb

@@ -55,7 +55,7 @@ class CLITest < Minitest::Test
     assert_equal <<~OUTPUT.strip, output.strip
     Class frequency:
     ----------------
-    2	Main
+    1	Main
 
     Method frequency:
     ----------------
@@ -79,7 +79,7 @@ class CLITest < Minitest::Test
       "class_frequency": [
         {
           "name": "Main",
-          "count": 2
+          "count": 1
         }
       ],
       "method_frequency": [

data/test/test_helper.rb

@@ -2,3 +2,4 @@ $LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 require 'appmap'
 
 require 'minitest/autorun'
+require 'diffy'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.31.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-21 00:00:00.000000000 Z
+date: 2020-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -273,6 +273,7 @@ files:
 - lib/appmap/cucumber.rb
 - lib/appmap/event.rb
 - lib/appmap/hook.rb
+- lib/appmap/hook/method.rb
 - lib/appmap/metadata.rb
 - lib/appmap/middleware/remote_recording.rb
 - lib/appmap/minitest.rb
@@ -311,7 +312,6 @@ files:
 - spec/fixtures/hook/constructor.rb
 - spec/fixtures/hook/exception_method.rb
 - spec/fixtures/hook/instance_method.rb
-- spec/fixtures/hook/openssl_sign.rb
 - spec/fixtures/hook/singleton_method.rb
 - spec/fixtures/rack_users_app/.dockerignore
 - spec/fixtures/rack_users_app/.gitignore

data/spec/fixtures/hook/openssl_sign.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-# From the manual page https://ruby-doc.org/stdlib-2.5.1/libdoc/openssl/rdoc/OpenSSL.html
-
-require 'openssl'
-
-module OpenSSLExample
-  def OpenSSLExample.example
-    ca_key = OpenSSL::PKey::RSA.new 2048
-    pass_phrase = 'my secure pass phrase goes here'
-
-    cipher = OpenSSL::Cipher.new 'AES-256-CBC'
-
-    open 'tmp/ca_key.pem', 'w', 0644 do |io|
-      io.write ca_key.export(cipher, pass_phrase)
-    end
-
-    ca_name = OpenSSL::X509::Name.parse '/CN=ca/DC=example'
-
-    ca_cert = OpenSSL::X509::Certificate.new
-    ca_cert.serial = 0
-    ca_cert.version = 2
-    ca_cert.not_before = Time.now
-    ca_cert.not_after = Time.now + 86400
-
-    ca_cert.public_key = ca_key.public_key
-    ca_cert.subject = ca_name
-    ca_cert.issuer = ca_name
-
-    extension_factory = OpenSSL::X509::ExtensionFactory.new
-    extension_factory.subject_certificate = ca_cert
-    extension_factory.issuer_certificate = ca_cert
-
-    ca_cert.add_extension    extension_factory.create_extension('subjectKeyIdentifier', 'hash')
-    ca_cert.add_extension    extension_factory.create_extension('basicConstraints', 'CA:TRUE', true)
-
-    ca_cert.add_extension    extension_factory.create_extension(
-      'keyUsage', 'cRLSign,keyCertSign', true)
-
-    ca_cert.sign ca_key, OpenSSL::Digest::SHA1.new
-
-    open 'tmp/ca_cert.pem', 'w' do |io|
-      io.write ca_cert.to_pem
-    end
-
-    csr = OpenSSL::X509::Request.new
-    csr.version = 0
-    csr.subject = OpenSSL::X509::Name.new([ ['CN', 'the name to sign', OpenSSL::ASN1::UTF8STRING] ])
-    csr.public_key = ca_key.public_key
-    csr.sign ca_key, OpenSSL::Digest::SHA1.new
-
-    open 'tmp/csr.pem', 'w' do |io|
-      io.write csr.to_pem
-    end
-
-    csr = OpenSSL::X509::Request.new File.read 'tmp/csr.pem'
-
-    raise 'CSR can not be verified' unless csr.verify csr.public_key
-
-    csr_cert = OpenSSL::X509::Certificate.new
-    csr_cert.serial = 0
-    csr_cert.version = 2
-    csr_cert.not_before = Time.now
-    csr_cert.not_after = Time.now + 600
-
-    csr_cert.subject = csr.subject
-    csr_cert.public_key = csr.public_key
-    csr_cert.issuer = ca_cert.subject
-
-    extension_factory = OpenSSL::X509::ExtensionFactory.new
-    extension_factory.subject_certificate = csr_cert
-    extension_factory.issuer_certificate = ca_cert
-
-    csr_cert.add_extension    extension_factory.create_extension('basicConstraints', 'CA:FALSE')
-
-    csr_cert.add_extension    extension_factory.create_extension(
-        'keyUsage', 'keyEncipherment,dataEncipherment,digitalSignature')
-
-    csr_cert.add_extension    extension_factory.create_extension('subjectKeyIdentifier', 'hash')
-
-    csr_cert.sign ca_key, OpenSSL::Digest::SHA1.new
-
-    open 'tmp/csr_cert.pem', 'w' do |io|
-      io.write csr_cert.to_pem
-    end
-  end
-end