appmap 0.77.4 → 0.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a3775abc9bff6d949fa377e2da5121414500735c37d9c5b9d6f03a7a2ae31a7
-  data.tar.gz: 7254e2e5c3f25f431cdb25e8d0512d55a155afd8b64647b255b3a8223b663f3f
+  metadata.gz: eb003b96b494282db035877377124bc3736d78320a64e479b7caa0b8df49063a
+  data.tar.gz: 3aab36a97c90485e1c7f77bed373c4c572b46a5c8c93ac4aa012db3becf201f4
 SHA512:
-  metadata.gz: cf54fd237e40750eff85fb4723651a747ba6e69214ea04acae1a95964a09e4a800ea1de31dbc4f7dec7d26c585ef7fb9167a3e97eb36e9b0c14003240696d6d6
-  data.tar.gz: 81f413c5e21379b145a99f9882db9faea3d27e75ef56df7a8a928ce0b74f141c26025300cf0449fbf00128eb4991d99c94316f4fb522c5bd25042fb6ad2cfff3
+  metadata.gz: 8637610caacf145c5badb4de3eb399858a231d3de9a794f86e8fcb3d14801d3b5309453da7e9b799d47ddb9c4eed55bbd97bf2f77eabe7e605e95089b560c5bf
+  data.tar.gz: bba8d4f2f8ffa5b0e5d8b113657324561dfa71e7b7128273631d62d426c8e12339e305d9fb0fe0d05244685a1ddc1b4be4bfbe5a4b44607a2df96e5d60749557

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,25 +12,10 @@ 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 \

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+# [0.80.0](https://github.com/applandinc/appmap-ruby/compare/v0.79.0...v0.80.0) (2022-04-08)
+
+
+### Bug Fixes
+
+* Don't record SQL within an existing event ([ff37a69](https://github.com/applandinc/appmap-ruby/commit/ff37a69af1af02263df216e49aea0d0954b93925))
+
+
+### Features
+
+* Env var to EXPLAIN queries ([740be75](https://github.com/applandinc/appmap-ruby/commit/740be75c2bc59e343d67ecf86b7715e61cddadba))
+* Optionally record parameter schema ([b7f41b1](https://github.com/applandinc/appmap-ruby/commit/b7f41b15a4556a0ce78650a6a77301d365632bb8))
+* query_plan is available whether a current transaction exists or not ([6edf774](https://github.com/applandinc/appmap-ruby/commit/6edf774fea858d825c4b971be2c4c15db1652446))
+* Record parameter and return value size ([6e69754](https://github.com/applandinc/appmap-ruby/commit/6e697543cb421378832492e286f972dc4cb1e1aa))
+* Save render return value to a thread-local ([f9d1e3f](https://github.com/applandinc/appmap-ruby/commit/f9d1e3f0aa9972482ff77233d38220104515b1d6))
+
+# [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)
 
 

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/agent.rb

@@ -100,5 +100,13 @@ module AppMap
       @metadata ||= Metadata.detect.freeze
       Util.deep_dup(@metadata)
     end
+
+    def parameter_schema?
+      ENV['APPMAP_PARAMETER_SCHEMA'] == 'true'
+    end
+
+    def explain_queries?
+      ENV['APPMAP_EXPLAIN_QUERIES'] == 'true'
+    end
   end
 end

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/event.rb

@@ -60,16 +60,18 @@ module AppMap
           final ? value_string : encode_display_string(value_string)
         end
 
-        def object_properties(hash_like)
-          hash = hash_like.to_h
-          hash.keys.map do |key|
-            {
-              name: key,
-              class: hash[key].class.name,
-            }
+        def add_schema(param, value)
+          begin
+            if value.respond_to?(:keys)
+              param[:properties] = value.keys.map { |key| { name: key, class: best_class_name(value[key]) } }
+            elsif value.respond_to?(:first) && value.first
+              if value.first != value
+                add_schema param, value.first
+              end
+            end
+          rescue
+            warn "Error in add_schema(#{value.class})", $!
           end
-        rescue
-          nil
         end
 
         # Heuristic for dynamically defined class whose name can be nil
@@ -221,7 +223,9 @@ module AppMap
                 object_id: value.__id__,
                 value: display_string(value),
                 kind: param_type
-              }
+              }.tap do |param|
+                param[:size] = value.size if value.respond_to?(:size) && value.is_a?(Enumerable)
+              end
             end
             event.receiver = {
               class: best_class_name(receiver),
@@ -276,7 +280,7 @@ module AppMap
       attr_accessor :return_value, :exceptions
 
       class << self
-        def build_from_invocation(parent_id, return_value, exception, elapsed: nil, event: MethodReturn.new)
+        def build_from_invocation(parent_id, return_value, exception, elapsed: nil, event: MethodReturn.new, parameter_schema: false)
           event ||= MethodReturn.new
           event.tap do |_|
             if return_value
@@ -284,7 +288,10 @@ module AppMap
                 class: best_class_name(return_value),
                 value: display_string(return_value),
                 object_id: return_value.__id__
-              }
+              }.tap do |param|
+                param[:size] = return_value.size if return_value.respond_to?(:size) && return_value.is_a?(Enumerable)
+                add_schema param, return_value if parameter_schema && !exception
+              end
             end
             if exception
               next_exception = exception

data/lib/appmap/gem_hooks/actionpack.yml

@@ -43,3 +43,9 @@
   - ActionController::Instrumentation#redirect_to
   label: mvc.controller
   require_name: action_controller
+- methods:
+  - AbstractController::Rendering#render_to_body
+  - ActionController::Renderers#render_to_body
+  label: mvc.render
+  handler_class: AppMap::Handler::Rails::RenderHandler
+  require_name: action_controller

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/rails/render_handler.rb

@@ -0,0 +1,29 @@
+require 'appmap/handler/function'
+
+module AppMap
+  module Handler
+    module Rails
+      class RenderHandler < AppMap::Handler::Function
+        def handle_call(receiver, args)
+          options, _ = args
+          # TODO: :file, :xml
+          # https://guides.rubyonrails.org/v5.1/layouts_and_rendering.html
+          if options[:json]
+            Thread.current[TEMPLATE_RENDER_FORMAT] = :json
+          end
+
+          super
+        end
+
+        def handle_return(call_event_id, elapsed, return_value, exception)
+          if Thread.current[TEMPLATE_RENDER_FORMAT] == :json
+            Thread.current[TEMPLATE_RENDER_VALUE] = JSON.parse(return_value) rescue nil
+          end
+          Thread.current[TEMPLATE_RENDER_FORMAT] = nil
+
+          super
+        end
+      end
+    end
+  end
+end