appmap 0.66.2 → 0.68.1

data/lib/appmap/handler/net_http.rb

@@ -2,6 +2,7 @@
 
 require 'appmap/event'
 require 'appmap/util'
+require 'rack'
 
 module AppMap
   module Handler
@@ -60,10 +61,14 @@ module AppMap
       def initialize(response, parent_id, elapsed)
         super AppMap::Event.next_id_counter, :return, Thread.current.object_id
 
-        self.status = response.code.to_i
+        if response
+          self.status = response.code.to_i
+          self.headers = NetHTTP.copy_headers(response)
+        else
+          self.headers = {}
+        end
         self.parent_id = parent_id
         self.elapsed = elapsed
-        self.headers = NetHTTP.copy_headers(response)
       end
 
       def to_h

data/lib/appmap/hook.rb

@@ -15,10 +15,23 @@ module AppMap
     @method_arity = ::Method.instance_method(:arity)
 
     class << self
-      def lock_builtins
-        return if @builtins_hooked
+      def hook_builtins?
+        Mutex.new.synchronize do
+          @hook_builtins = true if @hook_builtins.nil?
 
-        @builtins_hooked = true
+          return false unless @hook_builtins
+
+          @hook_builtins = false
+          true
+        end
+      end
+
+      def already_hooked?(method)
+        # After a method is defined, the statement "module_function <the-method>" can convert that method
+        # into a module (class) method. The method is hooked first when it's defined, then AppMap will attempt to
+        # hook it again when it's redefined as a module method. So we check the method source location - if it's 
+        # part of the AppMap source tree, we ignore it.
+        method.source_location && method.source_location[0].index(__dir__) == 0
       end
 
       # Return the class, separator ('.' or '#'), and method name for
@@ -79,42 +92,43 @@ module AppMap
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
     # No TracePoint events are emitted for builtins, so a separate hooking mechanism is needed. 
     def hook_builtins
-      return unless self.class.lock_builtins
+      return unless self.class.hook_builtins?
 
-      class_from_string = lambda do |fq_class|
-        fq_class.split('::').inject(Object) do |mod, class_name|
-          mod.const_get(class_name)
-        end
-      end
+      hook_loaded_code = lambda do |hooks_by_class, builtin|
+        hooks_by_class.each do |class_name, hooks|
+          Array(hooks).each do |hook|
+            require hook.package.require_name if builtin && hook.package.require_name && hook.package.require_name != 'ruby'
 
-      config.builtin_hooks.each do |class_name, hooks|
-        Array(hooks).each do |hook|
-          require hook.package.package_name if hook.package.package_name && hook.package.package_name != 'ruby'
-          Array(hook.method_names).each do |method_name|
-            method_name = method_name.to_sym
-            base_cls = class_from_string.(class_name)
+            Array(hook.method_names).each do |method_name|
+              method_name = method_name.to_sym
+              base_cls = Util::class_from_string(class_name, must: false)
+              next unless base_cls
 
-            hook_method = lambda do |entry|
-              cls, method = entry
-              return false if config.never_hook?(cls, method)
+              hook_method = lambda do |entry|
+                cls, method = entry
+                return false if config.never_hook?(cls, method)
 
-              Hook::Method.new(hook.package, cls, method).activate
-            end
+                Hook::Method.new(hook.package, cls, method).activate
+              end
 
-            methods = []
-            methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
-            if base_cls.respond_to?(:singleton_class)
-              methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
-            end
-            methods.compact!
-            if methods.empty?
-              warn "Method #{method_name} not found on #{base_cls.name}"
-            else
-              methods.each(&hook_method)
+              methods = []
+              methods << [ base_cls, base_cls.public_instance_method(method_name) ] rescue nil
+              if base_cls.respond_to?(:singleton_class)
+                methods << [ base_cls.singleton_class, base_cls.singleton_class.public_instance_method(method_name) ] rescue nil
+              end
+              methods.compact!
+              if methods.empty?
+                warn "Method #{method_name} not found on #{base_cls.name}" if LOG
+              else
+                methods.each(&hook_method)
+              end
             end
           end
         end
       end
+
+      hook_loaded_code.(config.builtin_hooks, true)
+      hook_loaded_code.(config.gem_hooks, false)
     end
 
     protected
@@ -165,6 +179,8 @@ module AppMap
             next
           end
 
+          next if self.class.already_hooked?(method)
+
           warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
           disasm = RubyVM::InstructionSequence.disasm(method)

data/lib/appmap/minitest.rb

@@ -142,6 +142,7 @@ if AppMap::Minitest.enabled?
     alias run_without_hook run
 
     def run
+      GC.start
       AppMap::Minitest.begin_test self, name
       begin
         run_without_hook

data/lib/appmap/rspec.rb

@@ -87,6 +87,7 @@ module AppMap
         end
 
         warn "Starting recording of example #{example}@#{source_location}" if AppMap::RSpec::LOG
+        GC.start
         @trace = AppMap.tracing.trace
         @webdriver_port = webdriver_port.()
       end

data/lib/appmap/util.rb

@@ -21,6 +21,14 @@ module AppMap
     WHITE   = "\e[37m"
 
     class << self
+      def class_from_string(fq_class, must: true)
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      rescue NameError
+        raise if must
+      end
+
       def parse_function_name(name)
         package_tokens = name.split('/')
 

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.66.2'
+  VERSION = '0.68.1'
 
   APPMAP_FORMAT_VERSION = '1.5.1'
 

data/lib/appmap.rb

@@ -74,6 +74,6 @@ lambda do
     require 'appmap/depends'
   end
   
-end.call
+end.call unless ENV['APPMAP_AUTOREQUIRE'] == 'false'
 
-AppMap.initialize_configuration if ENV['APPMAP'] == 'true'
+AppMap.initialize_configuration if ENV['APPMAP'] == 'true' && ENV['APPMAP_INITIALIZE'] != 'false'

data/spec/config_spec.rb

@@ -4,83 +4,243 @@ require 'rails_spec_helper'
 require 'appmap/config'
 
 describe AppMap::Config, docker: false do
-  it 'loads from a Hash' do
+  it 'loads as expected' do
     config_data = {
-      exclude: [],
       name: 'test',
-      packages: [
+      packages: [],
+      functions: [
         {
-          path: 'path-1'
+          name: 'pkg/cls#fn',
         },
         {
-          path: 'path-2',
-          exclude: [ 'exclude-1' ]
-        }
-      ],
-      functions: [
-        {
-          package: 'pkg',
-          class: 'cls',
-          function: 'fn',
-          label: 'lbl'
+          methods: ['cls#new_fn'],
+          path: 'pkg'
         }
       ]
     }.deep_stringify_keys!
     config = AppMap::Config.load(config_data)
 
-    config_expectation = {
-      exclude: [],
-      name: 'test',
-      packages: [
+    expect(JSON.parse(JSON.generate(config.as_json))).to eq(JSON.parse(<<~FIXTURE))
+    {
+      "name": "test",
+      "appmap_dir": "tmp/appmap",
+      "packages": [
+      ],
+      "swagger_config": {
+        "project_name": null,
+        "project_version": "1.0",
+        "output_dir": "swagger",
+        "description": "Generate Swagger from AppMaps"
+      },
+      "depends_config": {
+        "base_dir": null,
+        "base_branches": [
+          "remotes/origin/main",
+          "remotes/origin/master"
+        ],
+        "test_file_patterns": [
+          "spec/**/*_spec.rb",
+          "test/**/*_test.rb"
+        ],
+        "dependent_tasks": [
+          "swagger"
+        ],
+        "description": "Bring AppMaps up to date with local file modifications, and updated derived data such as Swagger files",
+        "rspec_environment_method": "AppMap::Depends.test_env",
+        "minitest_environment_method": "AppMap::Depends.test_env",
+        "rspec_select_tests_method": "AppMap::Depends.select_rspec_tests",
+        "minitest_select_tests_method": "AppMap::Depends.select_minitest_tests",
+        "rspec_test_command_method": "AppMap::Depends.rspec_test_command",
+        "minitest_test_command_method": "AppMap::Depends.minitest_test_command"
+      },
+      "hook_paths": [
+        "pkg",
+        "#{Gem.loaded_specs['activesupport'].gem_dir}"
+      ],
+      "exclude": [
+      ],
+      "functions": [
         {
-          path: 'path-1',
-          handler_class: 'AppMap::Handler::Function'
+          "cls": "cls",
+          "target_methods": {
+            "package": "pkg",
+            "method_names": [
+              "fn"
+            ]
+          }
         },
         {
-          path: 'path-2',
-          handler_class: 'AppMap::Handler::Function',
-          exclude: [ 'exclude-1' ]
+          "cls": "cls",
+          "target_methods": {
+            "package": "pkg",
+            "method_names": [
+              "new_fn"
+            ]
+          }
         }
       ],
-      functions: [
-        {
-          package: 'pkg',
-          class: 'cls',
-          functions: [ :fn ],
-          labels: ['lbl']
-        }
-      ]
-    }.deep_stringify_keys!
-
-    expect(config.to_h.deep_stringify_keys!).to eq(config_expectation)
-  end
-
-  it 'interprets a function in canonical name format' do
-    config_data = {
-      name: 'test',
-      packages: [],
-      functions: [
-        {
-          name: 'pkg/cls#fn',
-        }
-      ]
-    }.deep_stringify_keys!
-    config = AppMap::Config.load(config_data)
-
-    config_expectation = {
-      exclude: [],
-      name: 'test',
-      packages: [],
-      functions: [
-        {
-          package: 'pkg',
-          class: 'cls',
-          functions: [ :fn ],
-        }
-      ]
-    }.deep_stringify_keys!
-
-    expect(config.to_h.deep_stringify_keys!).to eq(config_expectation)
+      "builtin_hooks": {
+        "JSON::Ext::Parser": [
+          {
+            "package": "json",
+            "method_names": [
+              "parse"
+            ]
+          }
+        ],
+        "JSON::Ext::Generator::State": [
+          {
+            "package": "json",
+            "method_names": [
+              "generate"
+            ]
+          }
+        ],
+        "Net::HTTP": [
+          {
+            "package": "net/http",
+            "method_names": [
+              "request"
+            ]
+          }
+        ],
+        "OpenSSL::PKey::PKey": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          }
+        ],
+        "OpenSSL::X509::Request": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "verify"
+            ]
+          }
+        ],
+        "OpenSSL::X509::Certificate": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "sign"
+            ]
+          }
+        ],
+        "OpenSSL::PKCS5": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "pbkdf2_hmac"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "pbkdf2_hmac_sha1"
+            ]
+          }
+        ],
+        "OpenSSL::Cipher": [
+          {
+            "package": "openssl",
+            "method_names": [
+              "encrypt"
+            ]
+          },
+          {
+            "package": "openssl",
+            "method_names": [
+              "decrypt"
+            ]
+          }
+        ],
+        "Psych": [
+          {
+            "package": "yaml",
+            "method_names": [
+              "load"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "load_stream"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "parse"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "parse_stream"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "dump"
+            ]
+          },
+          {
+            "package": "yaml",
+            "method_names": [
+              "dump_stream"
+            ]
+          }
+        ]
+      },
+      "gem_hooks": {
+        "cls": [
+          {
+            "package": "pkg",
+            "method_names": [
+              "fn"
+            ]
+          },
+          {
+            "package": "pkg",
+            "method_names": [
+              "new_fn"
+            ]
+          }
+        ],
+        "ActiveSupport::Callbacks::CallbackSequence": [
+          {
+            "package": "activesupport",
+            "method_names": [
+              "invoke_before"
+            ]
+          },
+          {
+            "package": "activesupport",
+            "method_names": [
+              "invoke_after"
+            ]
+          }
+        ],
+        "ActiveSupport::SecurityUtils": [
+          {
+            "package": "activesupport",
+            "method_names": [
+              "secure_compare"
+            ]
+          }
+        ]
+      }
+    }
+    FIXTURE
   end
 
   context do
@@ -94,7 +254,8 @@ describe AppMap::Config, docker: false do
       expect(config.to_h).to eq(YAML.load(<<~CONFIG))
       :name: appmap-ruby
       :packages:
-      - :path: lib
+      - :name: lib
+        :path: lib
         :handler_class: AppMap::Handler::Function
         :shallow: false
       :functions: []

data/spec/depends/api_spec.rb

@@ -104,7 +104,7 @@ describe 'Depends API' do
   describe '.run_tests' do
     def run_tests
       Dir.chdir 'spec/fixtures/depends' do
-        api.run_tests([ 'spec/actual_rspec_test.rb', 'test/actual_minitest_test.rb' ], appmap_dir: Pathname.new(DEPENDS_TEST_DIR).expand_path.to_s)
+        api.run_tests([ 'spec/actual_rspec_test.rb', 'test/actual_minitest_test.rb' ], appmap_dir: Pathname.new('.').expand_path.to_s)
       end
     end
 

data/spec/rails_spec_helper.rb

@@ -5,9 +5,14 @@ require 'active_support'
 require 'active_support/core_ext'
 require 'open3'
 
+# docker compose v2 replaced the --filter flag with --status
+PS_CMD=`docker-compose --version` =~ /version v2/ ?
+         "docker-compose ps -q --status running" :
+         "docker-compose ps -q --filter health=healthy"
+
 def wait_for_container(app_name)
   start_time = Time.now
-  until `docker-compose ps -q --filter health=healthy #{app_name}`.strip != ''
+  until `#{PS_CMD} #{app_name}`.strip != ''
     elapsed = Time.now - start_time
     raise "Timeout waiting for container #{app_name} to be ready" if elapsed > 10
 

data/test/agent_setup_validate_test.rb

@@ -2,28 +2,40 @@
 
 require 'test_helper'
 
+schema_path = File.expand_path('../../config-schema.yml', __FILE__)
+CONFIG_SCHEMA = YAML.safe_load(File.read(schema_path))
 class AgentSetupValidateTest < Minitest::Test
   NON_EXISTING_CONFIG_FILENAME = '123.yml'
   INVALID_YAML_CONFIG_FILENAME = 'spec/fixtures/config/invalid_yaml_config.yml'
   INVALID_CONFIG_FILENAME = 'spec/fixtures/config/invalid_config.yml'
   MISSING_PATH_OR_GEM_CONFIG_FILENAME = 'spec/fixtures/config/missing_path_or_gem.yml'
 
+  def check_output(output, expected_errors)
+    expected = JSON.pretty_generate(
+      {
+        version: 2,
+        errors: expected_errors,
+        schema: CONFIG_SCHEMA
+      }
+    )
+    assert_equal(expected, output.strip)
+  end
+    
   def test_init_when_config_exists
     output = `./exe/appmap-agent-validate`
     assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate([
+    check_output(output, [
       {
         level: :error,
         message: 'AppMap auto-configuration is currently not available for non Rails projects'
       }
     ])
-    assert_equal expected, output.strip
   end
 
   def test_init_with_non_existing_config_file
     output = `./exe/appmap-agent-validate -c #{NON_EXISTING_CONFIG_FILENAME}`
     assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate([
+    check_output(output, [
       {
         level: :error,
         message: 'AppMap auto-configuration is currently not available for non Rails projects'
@@ -34,13 +46,12 @@ class AgentSetupValidateTest < Minitest::Test
         message: "AppMap configuration #{NON_EXISTING_CONFIG_FILENAME} file does not exist"
       }
     ])
-    assert_equal expected, output.strip
   end
 
   def test_init_with_invalid_YAML
     output = `./exe/appmap-agent-validate -c #{INVALID_YAML_CONFIG_FILENAME}`
     assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate([
+    check_output(output, [
       {
         level: :error,
         message: 'AppMap auto-configuration is currently not available for non Rails projects'
@@ -53,13 +64,12 @@ class AgentSetupValidateTest < Minitest::Test
           'did not find expected key while parsing a block mapping at line 1 column 1'
       }
     ])
-    assert_equal expected, output.strip
   end
 
   def test_init_with_invalid_data_config
     output = `./exe/appmap-agent-validate -c #{INVALID_CONFIG_FILENAME}`
     assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate([
+    check_output(output, [
       {
         level: :error,
         message: 'AppMap auto-configuration is currently not available for non Rails projects'
@@ -71,13 +81,12 @@ class AgentSetupValidateTest < Minitest::Test
         detailed_message: "no implicit conversion of String into Integer"
       }
     ])
-    assert_equal expected, output.strip
   end
 
   def test_init_with_missing_package_key
     output = `./exe/appmap-agent-validate -c #{MISSING_PATH_OR_GEM_CONFIG_FILENAME}`
     assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate([
+    check_output(output, [
       {
         level: :error,
         message: 'AppMap auto-configuration is currently not available for non Rails projects'
@@ -89,6 +98,5 @@ class AgentSetupValidateTest < Minitest::Test
         detailed_message: "AppMap config 'package' element should specify 'gem' or 'path'"
       }
     ])
-    assert_equal expected, output.strip
   end
 end

data/test/fixtures/mocha_mock_app/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'appmap', git: 'applandinc/appmap-ruby', branch: `git rev-parse --abbrev-ref HEAD`.strip
+gem 'minitest'
+gem 'mocha'

data/test/fixtures/mocha_mock_app/appmap.yml

@@ -0,0 +1,5 @@
+name: mocha_mock_app
+packages:
+  - path: lib
+  - gem: mocha
+    shallow: false

data/test/fixtures/mocha_mock_app/lib/sheep.rb

@@ -0,0 +1,5 @@
+class Sheep
+  def baa
+    'baa'
+  end
+end

data/test/fixtures/mocha_mock_app/test/sheep_test.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'minitest/autorun'
+
+require 'appmap'
+require 'appmap/minitest' if ENV['APPMAP_AUTOREQUIRE'] == 'false'
+
+require 'sheep'
+require 'mocha/minitest'
+
+class SheepTest < Minitest::Test
+  def test_sheep
+    sheep = mock('sheep')
+    sheep.responds_like(Sheep.new)
+    sheep.expects(:baa).returns('baa')
+    sheep.baa
+  end
+end