appmap 0.77.3 → 0.79.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6889544929fdf05360b3e528847aaa1e3c4a423c580b982d5ecbb3403a44f6aa
-  data.tar.gz: dad6b337385f4700b0974bf727329afa2bcd4c33f5a17bd951fd9516608a5798
+  metadata.gz: f5c6a40273c5606504492f151b2feeb1addc83d92f6bec7a80ca51d3034cd79f
+  data.tar.gz: b10a582926396930d2a980cd4323bd83f7c3444aa0b77bf2dd2dfa632203f65d
 SHA512:
-  metadata.gz: 197d249f8aa3ca22766168688f3b31e3b9cdf4c16d20227012d77dc5d6d1eb16b7814af8e605b51a5dc5a60ef4861f8cfd3f7089878ff88b046fac59a15b52a3
-  data.tar.gz: 0e74d7f95043ea588f0a0ef9aca170765db7475c6009d6471ce2299885b59aca25eb4d87bb72cd7045a2a743b6b8c95fbb6348786d99cb938a269c73189a5234
+  metadata.gz: f56a49c05561a74ae2ee7512fbad2beadc1a0aa719e27b455ea330777c58e97b7c028f7eaaee13d52f20c8ace6bf9284ff8c717e17d922a45f2dca703781a737
+  data.tar.gz: d35ac177b2b12ddd4f4e0517ed4101043c8e9d29f89f53721969d45e3e2be293ae7ad0b8466a2fae63329bb7a13e27d699b30a2464a663014d04a71a8d464293

data/.rubocop.yml

@@ -19,6 +19,7 @@ Layout/LineLength:
 
 Metrics/BlockLength:
   ExcludedMethods:
+  - describe
   - it
   - context
 

data/.travis.yml

@@ -1,5 +1,8 @@
 language: ruby
 dist: bionic
+cache:
+- bundle
+- yarn
 
 # NB: if you update the ruby versions here, you also need to update
 # them in the Rakefile.
@@ -9,37 +12,15 @@ rbenv:
 - 3.0
 - 3.1
 
-addons:
-  apt:
-    packages:
-      # https://docs.travis-ci.com/user/docker/#installing-a-newer-docker-version
-      - docker-ce
-
 services:
-- docker
+- postgresql
 
 before_install:
-  - sudo apt-get update && sudo apt-get install apt-transport-https ca-certificates -y && sudo update-ca-certificates
-  # see https://blog.travis-ci.com/docker-rate-limits 
-  # and also https://www.docker.com/blog/what-you-need-to-know-about-upcoming-docker-hub-rate-limiting/
-  # if we do not use authorized account, 
-  # the pulls-per-IP quota is shared with other Travis users
-  - >
-    if [ ! -z "$DOCKERHUB_PASSWORD" ] && [ ! -z "$DOCKERHUB_USERNAME" ]; then
-      echo "$DOCKERHUB_PASSWORD" | docker login -u "$DOCKERHUB_USERNAME" --password-stdin  ;
-    fi
   - |
     nvm install --lts \
       && nvm use --lts \
       && npm i -g yarn
 
-jobs:
-  include:
-  - stage: test
-    env:
-      # GEM_ALTERNATIVE_NAME only needed for deployment 
-      - GEM_ALTERNATIVE_NAME=''
-
 before_deploy:
   - |
     npm i -g \

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [0.79.0](https://github.com/applandinc/appmap-ruby/compare/v0.78.0...v0.79.0) (2022-04-06)
+
+
+### Features
+
+* Use a more unique test database name ([0eed036](https://github.com/applandinc/appmap-ruby/commit/0eed036460f0384698ff91c1112a4a9c3214f7f4))
+
+# [0.78.0](https://github.com/applandinc/appmap-ruby/compare/v0.77.4...v0.78.0) (2022-04-04)
+
+
+### Features
+
+* Hook and label Kernel#eval ([e0c151d](https://github.com/applandinc/appmap-ruby/commit/e0c151d1371f5bed5597ffd0d3bfebb8bca247c2))
+
+## [0.77.4](https://github.com/applandinc/appmap-ruby/compare/v0.77.3...v0.77.4) (2022-04-04)
+
+
+### Bug Fixes
+
+* Update Rails request handler to the new hook architecture ([595b39a](https://github.com/applandinc/appmap-ruby/commit/595b39abb030c1dcf85c83e4717c25d4c5177d4d))
+
 ## [0.77.3](https://github.com/applandinc/appmap-ruby/compare/v0.77.2...v0.77.3) (2022-03-29)
 
 

data/README.md

@@ -28,7 +28,7 @@ Visit the [AppMap for Ruby](https://appland.com/docs/reference/appmap-ruby.html)
 
 **Configuration**
 
-*appmap.yml* is loaded into an `AppMap::Config`. 
+*appmap.yml* is loaded into an `AppMap::Config`.
 
 **Hooking**
 
@@ -39,7 +39,7 @@ method with calls that record the parameters and return value.
 **Builtins**
 
 `Hook` begins by iterating over builtin classes and modules defined in the `Config`. Builtins include code
-like `openssl` and `net/http`. This code is not dependent on any external libraries being present, and 
+like `openssl` and `net/http`. This code is not dependent on any external libraries being present, and
 `appmap` cannot guarantee that it will be loaded before builtins. Therefore, it's necessary to require it and
 hook it by looking up the classes and modules as constants in the `Object` namespace.
 
@@ -81,50 +81,20 @@ The fixture apps in `test/fixtures` are plain Ruby projects that exercise the ba
 
 The fixture apps in `spec/fixtures` are simple Rack, Rails5, and Rails6 apps.
 You can use them to interactively develop and test the recording features of the `appmap` gem.
-These fixture apps are more sophisticated than `test/fixtures`, because they include additional 
-resources such as a PostgreSQL database.
+These fixture apps are more sophisticated than `test/fixtures`, because they include additional
+resources such as a PostgreSQL database. Still, you can simply enter the fixture directory and `bundle`.
 
-To build the fixture container images, first run:
+If you don't have PostgreSQL on the local (default) socket, you can export `DATABASE_URL` to
+point to the database server you want to use. 
 
-```sh-session
-$ bundle exec rake build:fixtures:all
-```
-
-This will build the `appmap.gem`, along with a Docker image for each fixture app.
-
-Then move to the directory of the fixture you want to use, and provision the environment.
-In this example, we use Ruby 2.6.
-
-```sh-session
-$ export RUBY_VERSION=2.6
-$ docker-compose up -d pg
-$ sleep 10s # Or some reasonable amount of time
-$ docker-compose run --rm app ./create_app
-```
+You can launch a database like this:
 
-Now you can start a development container.
-
-```sh-session
-$ docker-compose run --rm -v $PWD:/app -v $PWD/../../..:/src/appmap-ruby app bash
-Starting rails_users_app_pg_1 ... done
-root@6fab5f89125f:/app# cd /src/appmap-ruby
-root@6fab5f89125f:/src/appmap-ruby# rm ext/appmap/*.so ext/appmap/*.o
-root@6fab5f89125f:/src/appmap-ruby# bundle
-root@6fab5f89125f:/src/appmap-ruby# bundle exec rake compile
-root@6fab5f89125f:/src/appmap-ruby# cd /src/app
-root@6fab5f89125f:/src/app# bundle config local.appmap /src/appmap-ruby
-root@6fab5f89125f:/src/app# bundle
 ```
-
-At this point, the bundle is built with the `appmap` gem located  in `/src/appmap`, which is volume-mounted from the host.
-So you can edit the fixture code and the appmap code and run test commands such as `rspec` in the container.
-For example:
-
-```sh-session
-root@6fab5f89125f:/src/app# APPMAP=true bundle exec rspec
-Configuring AppMap from path appmap.yml
-....
-
-Finished in 0.07357 seconds (files took 2.1 seconds to load)
-4 examples, 0 failures
+➜ docker-compose -p appmap-ruby up -d
+... stuff
+➜ docker-compose ps pg  
+      Name                    Command                 State                Ports         
+-----------------------------------------------------------------------------------------
+appmap-ruby_pg_1   docker-entrypoint.sh postgres   Up (healthy)   0.0.0.0:59134->5432/tcp
+➜ export DATABASE_URL=postgres://postgres@localhost:59134
 ```

data/README_CI.md

@@ -4,13 +4,6 @@
 * `GEM_HOST_API_KEY`: rubygems API key
 * `GEM_ALTERNATIVE_NAME` (optional): used for testing of CI flows, 
 to avoid publication of test releases under official package name
-* `DOCKERHUB\_USERNAME`, `DOCKERHUB_PASSWORD`: optional dockerhub credentials, 
-to avoid throttling of dockerhub anonymous pulls
-
-Note: for security reasons, it's better to use dedicated (not personal) 
-Dockerhub account, 
-and also use [access tokens](https://docs.docker.com/docker-hub/access-tokens/) 
-instead of primary password
 
 # Release command
 

data/Rakefile

@@ -1,26 +1,8 @@
 $: << File.join(__dir__, 'lib')
-require 'appmap/version'
-GEM_VERSION = AppMap::VERSION
-
-# Make sure the local version is not behind the one on
-# rubygems.org (it's ok if they're the same).
-#
-# If it is behind, the fixture images won't get updated with the gem
-# built from the local source, so you'll wind up testing the rubygems
-# version instead.
-unless ENV['SKIP_VERSION_CHECK']
-  require 'json'
-  require 'net/http'
-  rubygems_version = JSON.parse(Net::HTTP.get(URI.parse('https://rubygems.org/api/v1/gems/appmap.json')))['version']
-  if Gem::Version.new(GEM_VERSION) < Gem::Version.new(rubygems_version)
-    raise "#{GEM_VERSION} < #{rubygems_version}. Rebase to avoid build issues."
-  end
-end
 
+require 'rspec/core/rake_task'
 require 'rake/testtask'
 require 'rdoc/task'
-
-require 'open3'
 require 'rake/extensiontask'
 
 desc 'build the native extension'
@@ -28,138 +10,20 @@ Rake::ExtensionTask.new("appmap") do |ext|
   ext.lib_dir = "lib/appmap"
 end
 
-RUBY_VERSIONS=%w[2.6 2.7 3.0 3.1].select do |version|
-  travis_ruby_version = ENV['TRAVIS_RUBY_VERSION']
-  next true unless travis_ruby_version
-
-  if travis_ruby_version.index(version) == 0
-    warn "Testing Ruby version #{version}, since it matches TRAVIS_RUBY_VERSION=#{travis_ruby_version}"
-    next true
-  end
-
-  false
-end
-FIXTURE_APPS=[:rack_users_app, :rails6_users_app, :rails5_users_app, :rails7_users_app => {:ruby_version => '>= 2.7'}]
-
-def run_cmd(*cmd)
-  $stderr.puts "Running: #{cmd}"
-  out, s = Open3.capture2e(*cmd)
-  unless s.success?
-    $stderr.puts <<-END
-      Command failed:
-      <<< Output:
-      #{out}
-      >>> End of output
-    END
-    raise 'Docker build failed'
-  end
-end
-
-def build_base_image(ruby_version)
-  run_cmd "docker build" \
-         " --build-arg RUBY_VERSION=#{ruby_version}"    \
-         " --build-arg GEM_VERSION=#{GEM_VERSION}"      \
-         " -t appmap:#{GEM_VERSION} -f Dockerfile.appmap ."
-end
-
-def build_app_image(app, ruby_version)
-  Dir.chdir "spec/fixtures/#{app}" do
-    env = {"RUBY_VERSION" => ruby_version, "GEM_VERSION" => GEM_VERSION}
-    run_cmd(env,
-      "docker-compose build" \
-      " --build-arg RUBY_VERSION=#{ruby_version}" \
-      " --build-arg GEM_VERSION=#{GEM_VERSION}"  ) 
-  end
-end
-
 desc 'Install non-Ruby dependencies'
 task :install do
   system 'yarn install' or raise 'yarn install failed'
 end
 
-namespace :build do
-  namespace :base do
-    RUBY_VERSIONS.each do |ruby_version|
-      desc ruby_version
-      task ruby_version do
-        run_system = ->(cmd) { system(cmd) or raise "Command failed: #{cmd}" }
-
-        run_system.call 'mkdir -p pkg'
-        run_system.call "gem build appmap.gemspec --output pkg/appmap-#{GEM_VERSION}.gem"
-        build_base_image(ruby_version)
-      end.tap do |t|
-        desc "Build all images"
-        task all: t
-      end
-    end
-  end
-
-  namespace :fixtures do
-    RUBY_VERSIONS.each do |ruby_version|
-      namespace ruby_version do
-        desc "build:fixtures:#{ruby_version}"
-        FIXTURE_APPS.each do |app_spec|
-          app = if app_spec.instance_of?(Hash)
-            app_spec = app_spec.flatten
-            version_rqt = Gem::Requirement.create(app_spec[1][:ruby_version])
-            next unless version_rqt =~ (Gem::Version.new(ruby_version))
-            app = app_spec[0]
-          else
-            app = app_spec
-          end.to_s
-
-
-          desc app
-          task app => ["base:#{ruby_version}"] do
-            build_app_image(app, ruby_version)
-          end.tap do |t|
-            desc "Build all fixture images for #{ruby_version}"
-            task all: t
-          end
-        end
-      end
-
-      desc "Build all fixture images"
-      task all: ["#{ruby_version}:all"]
-    end
-  end
-
-  task all: ["fixtures:all"]
-end
-
-def run_specs(ruby_version, task_args)
-  require 'rspec/core/rake_task'
-  require 'climate_control'
-  # Define an rspec rake task for the specified Ruby version. It's hidden (i.e. doesn't have a
-  # description), because it's not intended to be invoked directly
-  RSpec::Core::RakeTask.new("rspec_#{ruby_version}", [:specs]) do |task, args|
-    task.exclude_pattern = 'spec/fixtures/**/*_spec.rb'
-    task.rspec_opts = '-f doc'
-    if args.count > 0
-      # There doesn't appear to be a value for +pattern+ that will
-      # cause it to be ignored. Setting it to '' or +nil+ causes an
-      # empty argument to get passed to rspec, which confuses it.
-      task.pattern = 'never match this'
-      task.rspec_opts += " " + args.to_a.join(' ')
-    end
-  end
-
-  # Set up the environment, then execute the rspec task we
-  # created above.
-  ClimateControl.modify(RUBY_VERSION: ruby_version) do
-    Rake::Task["rspec_#{ruby_version}"].execute(task_args)
-  end
-end
-
-namespace :spec do
-  RUBY_VERSIONS.each do |ruby_version|
-    desc ruby_version
-    task ruby_version, [:specs] => ["install", "compile", "build:fixtures:#{ruby_version}:all"] do |_, task_args|
-      run_specs(ruby_version, task_args)
-    end.tap do |t|
-      desc "Run all specs"
-      task :all, [:specs] => t
-    end
+RSpec::Core::RakeTask.new spec: %i[compile install] do |task, args|
+  task.exclude_pattern = 'spec/fixtures/**/*_spec.rb'
+  task.rspec_opts = '-f doc'
+  if args.count > 0
+    # There doesn't appear to be a value for +pattern+ that will
+    # cause it to be ignored. Setting it to '' or +nil+ causes an
+    # empty argument to get passed to rspec, which confuses it.
+    task.pattern = 'never match this'
+    task.rspec_opts += [nil, *args].join(' ')
   end
 end
 
@@ -169,14 +33,12 @@ Rake::RDocTask.new do |rd|
   rd.title = 'AppMap'
 end
 
-Rake::TestTask.new(minitest: 'compile') do |t|
+Rake::TestTask.new(minitest: :compile) do |t|
   t.libs << 'test'
   t.libs << 'lib'
   t.test_files = FileList['test/*_test.rb']
 end
 
-task spec: %i[spec:all]
-
-task test: %i[spec:all minitest]
+task test: %i[spec minitest]
 
 task default: :test

data/appmap.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'appmap/version'
 
 Gem::Specification.new do |spec|
-  # ability to parameterize gem name is added intentionally, 
+  # ability to parameterize gem name is added intentionally,
   # to support the possibility of unofficial releases, e.g. during CI tests
   spec.name          = (ENV['GEM_ALTERNATIVE_NAME'].to_s.empty? ? 'appmap' : ENV["GEM_ALTERNATIVE_NAME"] )
   spec.version       = AppMap::VERSION
@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'reverse_markdown'
 
   spec.add_development_dependency 'bundler', '>= 1.16'
-  spec.add_development_dependency 'minitest', '~> 5.14'
+  spec.add_development_dependency 'minitest', '~> 5.15'
   spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rdoc'
@@ -48,5 +48,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'webdrivers', '~> 4.0'
   spec.add_development_dependency 'timecop'
   spec.add_development_dependency 'hashie'
+  spec.add_development_dependency 'random-port', '~> 0.5.1'
   spec.add_development_dependency 'webrick'
 end

data/docker-compose.yml

@@ -0,0 +1,10 @@
+version: "3"
+services:
+  pg:
+    build:
+      context: .
+      dockerfile: Dockerfile.pg
+    ports:
+      - "5432"
+    environment:
+      POSTGRES_HOST_AUTH_METHOD: trust

data/ext/appmap/appmap.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/debug.h>
 #include <ruby/intern.h>
 
 // Seems like CLASS_OR_MODULE_P should really be in a header file in
@@ -39,7 +40,7 @@ am_define_method_with_arity(VALUE mod, VALUE name, VALUE arity, VALUE proc)
 {
   VALUE arities_key = rb_intern(ARITIES_KEY);
   VALUE arities = rb_ivar_get(mod, arities_key);
-  
+
   if (arities == Qundef || NIL_P(arities)) {
     arities = rb_hash_new();
     rb_ivar_set(mod, arities_key, arities);
@@ -62,7 +63,7 @@ am_get_method_arity(VALUE method, VALUE orig_arity_method)
   }
   // Didn't find one, call the original method.
   if (NIL_P(arity)) {
-    VALUE bound_method = rb_funcall(orig_arity_method, rb_intern("bind"), 1, method);    
+    VALUE bound_method = rb_funcall(orig_arity_method, rb_intern("bind"), 1, method);
     arity = rb_funcall(bound_method, rb_intern("call"), 0);
   }
 
@@ -83,11 +84,29 @@ am_method_arity(VALUE method)
   return am_get_method_arity(method, orig_method_arity);
 }
 
+static VALUE
+bindings_callback(const rb_debug_inspector_t *dbg_context, void *level)
+{
+  const int i = NUM2INT((VALUE) level);
+  if (i >= RARRAY_LEN(rb_debug_inspector_backtrace_locations(dbg_context))) {
+    return Qnil;
+  } else {
+    return rb_debug_inspector_frame_binding_get(dbg_context, i);
+  }
+}
+
+static VALUE
+am_previous_bindings(VALUE self, VALUE level)
+{
+  return rb_debug_inspector_open(bindings_callback, (void *) level);
+}
+
 void Init_appmap() {
   VALUE appmap = rb_define_module("AppMap");
   am_AppMapHook = rb_define_class_under(appmap, "Hook", rb_cObject);
 
   rb_define_singleton_method(am_AppMapHook, "singleton_method_owner_name", singleton_method_owner_name, 1);
+  rb_define_module_function(appmap, "caller_binding", am_previous_bindings, 1);
 
   rb_define_method(rb_cModule, "define_method_with_arity", am_define_method_with_arity, 3);
   rb_define_method(rb_cUnboundMethod, "arity", am_unbound_method_arity, 0);

data/lib/appmap/builtin_hooks/ruby.yml

@@ -14,14 +14,17 @@
   - String#unpack1
   require_name: ruby
   label: string.unpack
-#- methods:
+- methods:
+  - Kernel#eval
+  require_name: ruby
+  label: lang.eval
+  handler_class: AppMap::Handler::Eval
 # TODO: eval does not happen in the right context, and therefore any new constants
 # which are defined are placed on the wrong module/class.
-#  - Kernel#eval
 #  - Binding#eval
 #  - BasicObject#instance_eval
 # These methods cannot be hooked as far as I can tell.
-# Why? When calling one of these functions, the context at the point of 
+# Why? When calling one of these functions, the context at the point of
 # definition is used. It's not possible to bind class_eval to a new context.
 #  - Module#class_eval
 #  - Module#module_eval

data/lib/appmap/handler/eval.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'appmap/handler/function'
+
+module AppMap
+  module Handler
+    # Handler class for Kernel#eval.
+    #
+    # Second argument to eval is a Binding, which despite the name (and
+    # the accessible methods) in addition to locals and receiver also
+    # encapsulates the entire execution context, in particular including
+    # the lexical scope. This is especially important for constant lookup
+    # and definition.
+    #
+    # If the binding is not provided, by default eval will run in the
+    # current frame. Since we call it here, this will mean the #do_call
+    # frame, which would make AppMap::Handler::Eval the lexical scope
+    # for constant lookup and definition; as a consequence
+    # eg. `eval "class Foo; end"` would define
+    # AppMap::Handler::Eval::Foo instead of defining it in
+    # the module where the original call was made.
+    #
+    # To avoid this, we explicitly substitute the correct execution
+    # context, up several stack frames.
+    class Eval < Function
+      # The depth of the frame we need to pluck out:
+      # 1. Hook::Method#do_call
+      # 2. Hook::Method#trace_call
+      # 3. Hook::Method#call
+      # 4. proc generated by Hook::Method#hook_method_def
+      # 5. the (intended) frame of the original eval that we hooked
+      # Note it needs to be adjusted if this call sequence changes.
+      FRAME_DEPTH = 5
+
+      def do_call(receiver, src = nil, context = nil, *rest)
+        context ||= AppMap.caller_binding FRAME_DEPTH
+        hook_method.bind(receiver).call(src, context, *rest)
+      end
+    end
+  end
+end

data/lib/appmap/handler/function.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 require 'appmap/event'
+require 'appmap/hook/method'
 
 module AppMap
   module Handler
-    module Function
-      class << self
-        def handle_call(defined_class, hook_method, receiver, args)
-          AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
-        end
+    # Base handler class, will emit method call and return events.
+    class Function < Hook::Method
+      def handle_call(receiver, args)
+        AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
+      end
 
-        def handle_return(call_event_id, elapsed, return_value, exception)
-          AppMap::Event::MethodReturn.build_from_invocation(call_event_id, return_value, exception, elapsed: elapsed)
-        end
+      def handle_return(call_event_id, elapsed, return_value, exception)
+        AppMap::Event::MethodReturn.build_from_invocation(call_event_id, return_value, exception, elapsed: elapsed)
       end
     end
   end

data/lib/appmap/handler/net_http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'appmap/event'
+require 'appmap/hook/method'
 require 'appmap/util'
 require 'rack'
 
@@ -81,29 +82,29 @@ module AppMap
       end
     end
 
-    class NetHTTP
-      class << self
-        def copy_headers(obj)
-          {}.tap do |headers|
-            obj.each_header do |key, value|
-              key = key.split('-').map(&:capitalize).join('-')
-              headers[key] = value
-            end
+    # Handler class for HTTP requests.
+    # Emits HTTP request events instead of method calls.
+    class NetHTTP < Hook::Method
+      def self.copy_headers(obj)
+        {}.tap do |headers|
+          obj.each_header do |key, value|
+            key = key.split('-').map(&:capitalize).join('-')
+            headers[key] = value
           end
         end
+      end
 
-        def handle_call(defined_class, hook_method, receiver, args)
-          # request will call itself again in a start block if it's not already started.
-          return unless receiver.started?
+      def handle_call(receiver, args)
+        # request will call itself again in a start block if it's not already started.
+        return unless receiver.started?
 
-          http = receiver
-          request = args.first
-          HTTPClientRequest.new(http, request)
-        end
+        http = receiver
+        request = args.first
+        HTTPClientRequest.new(http, request)
+      end
 
-        def handle_return(call_event_id, elapsed, return_value, exception)
-          HTTPClientResponse.new(return_value, call_event_id, elapsed)
-        end
+      def handle_return(call_event_id, elapsed, return_value, exception)
+        HTTPClientResponse.new(return_value, call_event_id, elapsed)
       end
     end
   end

data/lib/appmap/handler/rails/request_handler.rb

@@ -100,15 +100,14 @@ module AppMap
 
           protected
 
-          def before_hook(receiver, defined_class, _) # args
+          def before_hook(receiver, *)
             call_event = HTTPServerRequest.new(receiver.request)
             # http_server_request events are i/o and do not require a package name.
             AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
-            [ call_event, TIME_NOW.call ]
+            call_event
           end
 
-          def after_hook(receiver, call_event, start_time, _, _) # return_value, exception
-            elapsed = TIME_NOW.call - start_time
+          def after_hook(receiver, call_event, elapsed, *)
             return_event = HTTPServerResponse.new receiver.response, call_event.id, elapsed
             AppMap.tracing.record_event return_event
           end