appmap 0.77.3 → 0.79.0

data/spec/fixtures/rails7_users_app/Gemfile

@@ -69,31 +69,7 @@ group :test do
   gem "webdrivers"
 end
 
-appmap_path = \
-  # Support debugging inside the container with volume-mounted source
-  if File.directory?('/src/appmap-ruby')
-    '/src/appmap-ruby'
-  elsif File.exist?('../../../appmap.gemspec')
-    '../../..'
-  end
-
-if appmap_path
-  # Set the branch parameter, so that 'bundle config local.appmap' will work
-  appmap_branch = Dir.chdir appmap_path do
-    `git rev-parse --abbrev-ref HEAD`.strip
-  end
-end
-
-appmap_options = \
-  if appmap_path && appmap_branch
-    { git: appmap_path, branch: appmap_branch }
-  elsif appmap_path
-    { path: appmap_path }
-  else
-    {}
-  end.merge(require: %w[appmap])
-
 group :development, :test do
-  gem 'appmap', appmap_options
+  gem 'appmap', path: '../../..'
   gem 'pry-byebug', '>=0', '< 99'
 end

data/spec/fixtures/rails7_users_app/config/database.yml

@@ -0,0 +1 @@
+../../database.yml

data/spec/handler/eval_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# rubocop:disable Security/Eval, Style/EvalWithLocation
+
+require 'spec_helper'
+require 'appmap/config'
+
+describe 'AppMap::Handler::Eval' do
+  include_context 'collect events'
+  let!(:config) { AppMap::Config.new('hook_spec') }
+  before { AppMap.configuration = config }
+  after { AppMap.configuration = nil }
+
+  def record_block
+    AppMap::Hook.new(config).enable do
+      tracer = AppMap.tracing.trace
+      AppMap::Event.reset_id_counter
+      begin
+        yield
+      ensure
+        AppMap.tracing.delete(tracer)
+      end
+      tracer
+    end
+  end
+
+  it 'produces a simple result' do
+    tracer = record_block do
+      expect(eval('12')).to eq(12)
+    end
+    events = collect_events(tracer)
+    expect(events[0]).to match hash_including \
+      defined_class: 'Kernel',
+      method_id: 'eval',
+      parameters: [{ class: 'Array', kind: :rest, name: 'arg', value: '[12]' }]
+  end
+
+  # a la Ruby 2.6.3 ruby-token.rb
+  # token_c = eval("class #{token_n} < #{super_token}; end; #{token_n}")
+  it 'can define a new class' do
+    num = (Random.random_number * 10_000).to_i
+    class_name = "Cls_#{num}"
+    m = ClassMaker
+    cls = nil
+    record_block do
+      cls = m.make_class class_name
+    end
+    expect(cls).to be_instance_of(Class)
+    # If execution context wasn't substituted, the class would be defined as
+    # eg. AppMap::Handler::Eval::Cls_7566
+    expect { AppMap::Handler::Eval.const_get(class_name) }.to raise_error(NameError)
+    # This would be the right behavior
+    expect(m.const_get(class_name)).to be_instance_of(Class)
+    expect(m.const_get(class_name)).to eq(cls)
+    new_cls = Class.new do
+      include m
+    end
+    expect(new_cls.const_get(class_name)).to eq(cls)
+  end
+end
+
+module ClassMaker
+  def self.make_class(class_name)
+    eval "class #{class_name}; end; #{class_name}"
+  end
+end

data/spec/hook_spec.rb

@@ -16,7 +16,7 @@ module ShowYamlNulls
 end
 Psych::Visitors::YAMLTree.prepend(ShowYamlNulls)
 
-describe 'AppMap class Hooking', docker: false do
+describe 'AppMap class Hooking' do
   include_context 'collect events'
 
   def invoke_test_file(file, setup: nil, packages: nil)
@@ -115,7 +115,7 @@ describe 'AppMap class Hooking', docker: false do
     require 'appmap/hook/method'
     package = config.lookup_package(hook_cls, method)
     expect(package).to be
-    hook_method = AppMap::Hook::Method.new(package, hook_cls, method)
+    hook_method = AppMap::Handler::Function.new(package, hook_cls, method)
     hook_method.activate
 
     tracer = AppMap.tracing.trace
@@ -1188,7 +1188,7 @@ describe 'AppMap class Hooking', docker: false do
       require 'appmap/hook/method'
 
       pkg = AppMap::Config::Package.new('fixtures/hook/prependend_override')
-      AppMap::Hook::Method.new(pkg, PrependedClass, PrependedClass.public_instance_method(:say_hello)).activate
+      AppMap::Handler::Function.new(pkg, PrependedClass, PrependedClass.public_instance_method(:say_hello)).activate
 
       tracer = AppMap.tracing.trace
       AppMap::Event.reset_id_counter

data/spec/rails_recording_spec.rb

@@ -15,14 +15,6 @@ describe 'Rails' do
       include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" unless use_existing_data?
       include_context 'rails integration test setup'
 
-      def run_spec(spec_name)
-        cmd = <<~CMD.gsub "\n", ' '
-          docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true
-          -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
-        CMD
-        run_cmd cmd, chdir: fixture_dir
-      end
-
       describe 'an API route' do
         describe 'creating an object' do
           let(:appmap_json_file) do
@@ -123,7 +115,7 @@ describe 'Rails' do
                     )
                   )
                 )
-              )    
+              )
             end
           end
         end
@@ -201,7 +193,7 @@ describe 'Rails' do
                   'path_info' => '/users/alice',
                   'normalized_path_info' => '/users/{id}',
                   'headers' => {
-                    'Host' => 'test.host', 
+                    'Host' => 'test.host',
                     'User-Agent' => 'Rails Testing'
                   }
                 }
@@ -236,7 +228,7 @@ describe 'Rails' do
               'defined_class' => 'inline_template',
               'method_id' => 'render'
             )
-  
+
             expect(appmap['classMap']).to include hash_including(
               'name' => 'actionview',
               'children' => include(hash_including(
@@ -251,7 +243,7 @@ describe 'Rails' do
                 ))
               ))
             )
-          end  
+          end
         end
       end
     end
@@ -261,14 +253,6 @@ describe 'Rails' do
     include_context 'Rails app pg database', "spec/fixtures/rails6_users_app" unless use_existing_data?
     include_context 'rails integration test setup'
 
-    def run_spec(spec_name)
-      cmd = <<~CMD.gsub "\n", ' '
-        docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true -e APPMAP_CONFIG_FILE=no/such/file
-        -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
-      CMD
-      run_cmd cmd, chdir: fixture_dir
-    end
-
     let(:appmap_json_file) do
       'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json'
     end

data/spec/rails_spec_helper.rb

@@ -1,93 +1,106 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 require 'spec_helper'
 require 'active_support'
 require 'active_support/core_ext'
-require 'open3'
 
-# The RUBY_VERSION global variable indicates the version of the
-# runtime. The RUBY_VERSION environment variable is the version we're
-# testing, so it needs to be used to pick a fixture directory.
 def testing_ruby_2?
-  ENV['RUBY_VERSION'].split('.')[0].to_i == 2
+  RUBY_VERSION.split('.')[0].to_i == 2
 end
 
-# 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"
+class TestRailsApp
+  def initialize(fixture_dir)
+    @fixture_dir = fixture_dir
+  end
 
-def wait_for_container(app_name)
-  start_time = Time.now
-  until `#{PS_CMD} #{app_name}`.strip != ''
-    elapsed = Time.now - start_time
-    raise "Timeout waiting for container #{app_name} to be ready" if elapsed > 10
+  attr_reader :fixture_dir
 
-    $stderr.write '.' if elapsed > 3
-    sleep 0.25
+  def run_cmd(cmd, env = {})
+    run_process method(:system), cmd, env, exception: true
   end
-end
 
-def run_cmd(*cmd, &failed)
-  out, status = Open3.capture2e(*cmd)
-  return [ out, status ] if status.success?
-
-  warn <<~WARNING
-    Command failed:
-    #{cmd}
-    <<< Output:
-    #{out}
-    >>> End of output
-  WARNING
-  failed&.call
-  raise 'Command failed'
-end
+  def spawn_cmd(cmd, env = {})
+    puts "Spawning `#{cmd}` in #{fixture_dir}..."
+    run_process Process.method(:spawn), cmd, env
+  end
 
-shared_context 'Rails app pg database' do |fixture_dir|
-  define_method(:fixture_dir) { fixture_dir }
+  def capture_cmd(cmd, env = {})
+    puts "Capturing `#{cmd}` in #{fixture_dir}..."
+    run_process(Open3.method(:capture2), cmd, env).first
+  end
 
-  before(:all) do
-    print_pg_logs = lambda do
-      logs, = run_cmd 'docker-compose logs pg'
-      puts "docker-compose logs for pg:"
-      puts
-      puts logs
-    end
+  def database_name
+    # This is used locally too, so make the name nice and unique.
+    @database_name ||= "appland-rails-test-#{Random.bytes(8).unpack1('h*')}"
+  end
 
-    Dir.chdir fixture_dir do
-      run_cmd 'docker-compose down -v'
-      cmd = 'docker-compose up -d pg'
-      run_cmd cmd
-      wait_for_container 'pg'
+  def bundle
+    return if @bundled
 
-      cmd = 'docker-compose run --rm app ./create_app'
-      run_cmd cmd, &print_pg_logs
-    end
+    run_cmd 'bundle'
+    @bundled = true
   end
 
-  after(:all) do
-    if ENV['NOKILL'] != 'true'
-      cmd = 'docker-compose down -v'
-      run_cmd cmd, chdir: fixture_dir
-    end
+  def prepare_db
+    return if @db_prepared
+
+    bundle
+    run_cmd './bin/rake db:create db:schema:load'
+    @db_prepared = true
+    at_exit { drop_db }
+  end
+
+  def drop_db
+    return unless @db_prepared
+
+    run_cmd './bin/rake db:drop'
+    @db_prepared = false
   end
-end
 
-shared_context 'rails integration test setup' do
   def tmpdir
-    'tmp/spec/AbstractControllerBase'
+    @tmpdir ||= File.join(fixture_dir, 'tmp')
+  end
+
+  def run_specs
+    return if @specs_ran or use_existing_data?
+
+    prepare_db
+    FileUtils.rm_rf tmpdir
+    run_cmd \
+      './bin/rspec spec/controllers/users_controller_spec.rb spec/controllers/users_controller_api_spec.rb',
+      'APPMAP' => 'true'
+    @specs_ran = true
+  end
+
+  def self.for_fixture(fixture_dir)
+    @apps ||= {}
+    @apps[fixture_dir] ||= TestRailsApp.new fixture_dir
   end
 
-  unless use_existing_data?
-    before(:all) do
-      FileUtils.rm_rf tmpdir
-      FileUtils.mkdir_p tmpdir
-      run_spec 'spec/controllers/users_controller_spec.rb'
-      run_spec 'spec/controllers/users_controller_api_spec.rb'
+  protected
+
+  def run_process(method, cmd, env, options = {})
+    Bundler.with_clean_env do
+      method.call \
+        env.merge('TEST_DATABASE' => database_name),
+        cmd,
+        options.merge(chdir: fixture_dir)
     end
   end
+end
+
+shared_context 'Rails app pg database' do |dir|
+  before(:all) { @app = TestRailsApp.for_fixture dir }
+  let(:app) { @app }
+end
+
+shared_context 'rails integration test setup' do
+  let(:tmpdir) { app.tmpdir }
+
+  before(:all) { @app.run_specs } unless use_existing_data?
 
-  let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
   let(:appmap_json_path) { File.join(tmpdir, 'appmap/rspec', appmap_json_file) }
   let(:appmap) { JSON.parse File.read(appmap_json_path) }
   let(:events) { appmap['events'] }

data/spec/rails_test_spec.rb

@@ -3,7 +3,7 @@ require 'rails_spec_helper'
 # Rails5 doesn't work with Ruby 3.x, Rails 7 doesn't work with Ruby < 2.7.
 def default_rails_versions
   if testing_ruby_2?
-    if Gem::Requirement.create('>= 2.7') =~ Gem::Version.new(ENV['RUBY_VERSION'])
+    if Gem::Requirement.create('>= 2.7') =~ Gem::Version.new(RUBY_VERSION)
       [ 5, 6, 7 ]
     else
       [ 5, 6 ]
@@ -21,24 +21,14 @@ describe 'Rails' do
   rails_versions.each do |rails_major_version| # rubocop:disable Metrics/BlockLength
     context "#{rails_major_version}" do
       include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" unless use_existing_data?
-      def tmpdir
-        'tmp/spec/rails_test_spec'
-      end
-      before(:all) do
-        FileUtils.rm_rf tmpdir
-        FileUtils.mkdir_p tmpdir
-      end
-
-      def run_tests
-        cmd = <<~CMD.gsub "\n", ' '
-          docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true -e TEST_OPTS=--verbose
-          -v #{File.absolute_path tmpdir}:/app/tmp app bundle exec rake
-        CMD
-        run_cmd cmd, chdir: fixture_dir
-      end
 
       it 'runs tests with APPMAP=true' do
-        run_tests
+        app.prepare_db
+        app.run_cmd \
+          'bundle exec rake',
+          'RAILS_ENV' => 'test',
+          'APPMAP' => 'true',
+          'TEST_OPTS' => '--verbose'
       end
     end
   end

data/spec/railtie_spec.rb

@@ -1,27 +1,13 @@
 require 'rails_spec_helper'
 
 describe 'AppMap tracer via Railtie' do
-  include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do 
+  include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do
     let(:env) { {} }
 
-    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV=development -e APPMAP app ./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?") }
-    let(:command_capture2) do
-      require 'open3'
-      Open3.capture3(env, cmd, chdir: fixture_dir).tap do |result|
-        unless result[2] == 0
-          warn <<~STDERR
-            Failed to run rails6_users_app container
-            <<< Output:
-            #{result[0]}
-            #{result[1]}
-            >>> End of output
-          STDERR
-          raise 'Failed to run rails6_users_app container'
-        end
-      end
+    let(:command_output) do
+      app.prepare_db
+      app.capture_cmd(%{./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?"}, env).strip
     end
-    let(:command_output) { command_capture2[0].strip }
-    let(:command_result) { command_capture2[2] }
 
     describe 'with APPMAP=false' do
       let(:env) { { 'APPMAP' => 'false' } }

data/spec/record_sql_rails_pg_spec.rb

@@ -2,89 +2,58 @@ require 'rails_spec_helper'
 
 describe 'SQL events' do
   include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do
-    around(:each) do |example|
-      FileUtils.rm_rf tmpdir
-      FileUtils.mkdir_p tmpdir
-      cmd = "docker-compose run --rm -e ORM_MODULE=#{orm_module} -e RAILS_ENV=test -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:#{test_line_number}"
-      run_cmd cmd, chdir: fixture_dir
-
-      example.run
-    end
-
-    let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
-
-    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')
+    def self.check_queries(cases)
+      cases.each do |test_case, query|
+        context "in #{test_case}" do
+          let(:test_case) { test_case }
+          it "captures #{query}" do
+            expect(sql_events).to include sql_query 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 'with Sequel' do
+      before(:context) { run_specs 'sequel' }
 
-        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
-          end
-        end
-        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
-          end
-        end
-      end
+      check_queries(
+        'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user' =>
+          %(INSERT INTO "users" ("login") VALUES ('alice') RETURNING *),
+        'Api_UsersController_GET_api_users_lists_the_users' => %(SELECT * FROM "users")
+      )
+    end
 
-      context 'while listing records' do
-        let(:test_line_number) { 29 }
-        let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
+    context 'with ActiveRecord' do
+      before(:context) { run_specs 'activerecord' }
 
-        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:')
-          end
-        end
-        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
-          end
-        end
-      end
+      check_queries(
+        'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user' =>
+          %(INSERT INTO "users" ("login") VALUES ($1) RETURNING "id"),
+        'Api_UsersController_GET_api_users_lists_the_users' => %(SELECT "users".* FROM "users")
+      )
+    end
+
+    def run_specs(orm_module)
+      @app.prepare_db
+      @app.run_cmd \
+        './bin/rspec spec/controllers/users_controller_api_spec.rb:8 spec/controllers/users_controller_api_spec.rb:29',
+        'ORM_MODULE' => orm_module,
+        'RAILS_ENV' => 'test',
+        'APPMAP' => 'true'
+    end
+
+    let(:appmap_json) { File.join tmpdir, "appmap/rspec/#{test_case}.appmap.json" }
+    let(:appmap) { JSON.parse(File.read(appmap_json)) }
+    let(:tmpdir) { app.tmpdir }
+    let(:sql_events) { appmap['events'].select { |ev| ev.include? 'sql_query' } }
+
+    RSpec::Matchers.define_negated_matcher :not_include, :include
+    def sql_query(query)
+      (include('sql_query' => (include 'sql' => query)))
+        .and(not_include('defined_class'))
+        .and(not_include('method_id'))
+        .and(not_include('path'))
+        .and(not_include('lineno'))
     end
   end
 end

data/spec/remote_recording_spec.rb

@@ -1,41 +1,27 @@
 require 'rails_spec_helper'
+
+require 'random-port'
+
 require 'net/http'
 require 'socket'
 
 describe 'remote recording', :order => :defined do
   include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do
     before(:all) do
-      fixture_dir = 'spec/fixtures/rails6_users_app'
-      start_cmd = 'docker-compose up -d app'
-      run_cmd({ 'ORM_MODULE' => 'sequel', 'APPMAP' => 'true' }, start_cmd, chdir: fixture_dir)
-      Dir.chdir fixture_dir do
-        wait_for_container 'app'
-      end
+      @service_port = RandomPort::Pool::SINGLETON.acquire
+      @app.prepare_db
+      @server = @app.spawn_cmd \
+        "./bin/rails server -p #{@service_port}",
+        'ORM_MODULE' => 'sequel',
+        'APPMAP' => 'true'
 
-      port_cmd = 'docker-compose port app 3000'
-      port_out, = run_cmd port_cmd, chdir: fixture_dir
-      @service_port = port_out.strip.split(':')[1]
-
-      service_running = false
-      retry_count = 0
       uri = URI("http://localhost:#{@service_port}/health")
 
-      until service_running
-        sleep(0.25)
-        begin
-          res = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(Net::HTTP::Get.new(uri))
-          end
-
-          status = res.response.code.to_i
-          service_running = true if status >= 200 && status < 300
-
-          # give up after a certain error threshold is met
-          # we don't want to wait forever if there's an unrecoverable issue
-          raise 'gave up waiting on fixture service' if (retry_count += 1) == 10
-        rescue Errno::ETIMEDOUT, Errno::ECONNRESET, EOFError
-          $stderr.print('.')
-        end
+      100.times do
+        Net::HTTP.get(uri)
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 0.1
       end
     end
 
@@ -44,8 +30,10 @@ describe 'remote recording', :order => :defined do
     end
 
     after(:all) do
-      fixture_dir = 'spec/fixtures/rails6_users_app'
-      run_cmd 'docker-compose rm -fs app', chdir: fixture_dir
+      if @server
+        Process.kill 'INT', @server
+        Process.wait @server
+      end
     end
 
     let(:service_address) { URI("http://localhost:#{@service_port}") }

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ require 'appmap'
 
 RSpec.configure do |config|
   config.example_status_persistence_file_path = "tmp/rspec_failed_examples.txt"
+  config.profile_examples = true
 end
 
 # Re-run the Rails specs without re-generating the data. This is useful for efficiently enhancing and