appmap 0.34.1 → 0.35.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39576d59d2648a009f888fa9c5720d8fdb91b04fcb4d08949a05a0a5c453d0c8
-  data.tar.gz: 8b1d5442421d9dd37c3db4fa0329321e6b6e6ebc87e94bb67be3da9b3f1467b0
+  metadata.gz: baf04e5395f8456142064fd8413363f6e29aa1bf2b68150e79b904d3879b8b7f
+  data.tar.gz: ca27e18b4778b9341801ac81e25e9025ab26a047824b58ab4bcf113ab91fd5b9
 SHA512:
-  metadata.gz: 40bc1a630b65a83f7516085ec4cd25a72f83e574a9c2f150f8e302c9756c376a1fc820d490393d9625aeb3f5b781ca44d34431efe2722a7a0031b49334ccbca7
-  data.tar.gz: 9d32eb02deebdfb16e99ee0f157f5c9de6cb77cafa46233867e0173577609d4390b98a675f67c11868d57370066666bf9f9da39b2ee2ab25ba16cbaf4ebcd8ca
+  metadata.gz: f7a97d2d7a4e8bd5ae7db133e6287775dcff0373af82f187bc7d82411f868731e30fdb1a1267b173578a38d44017b20127cb20dcd7ddf3924d813e9ba6b32eb5
+  data.tar.gz: 784ea7d032b9186d50352c0222b168887249b0a9bde5d850f4b2b98e12555ed728f1dc95c1604e2e45d7d6a15c6765eda467ddbd55530af859c82842a1aca4ca

data/.gitignore

@@ -14,4 +14,4 @@ Gemfile.lock
 appmap.json
 .vscode
 .byebug_history
-
+/lib/appmap/appmap.bundle

data/.rbenv-gemsets

@@ -0,0 +1 @@
+appmap-ruby

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+# v0.35.1
+* Take out hooking of `IO` and `Logger` methods.
+* Enable logging if either `APPMAP_DEBUG` or `DEBUG` is `true`.
+
+# v0.35.0
+* Provide a custom display string for files and HTTP requests.
+* Report `mime_type` on HTTP response.
+
+# v0.34.6
+* Only warn once about problems determining database version for an ActiveRecord
+  connection.
+
+# v0.34.5
+* Ensure that hooking a method doesn't change its arity.
+
+# v0.34.4
+* Make sure `AppMap:Rails::SQLExaminer::ActiveRecordExaminer.server_version` only calls
+  `ActiveRecord::Base.connection.database_version` if it's available.
+* Fix `AppMap:Rails::SQLExaminer::ActiveRecordExaminer.database_type` returns `:postgres`
+  in all supported versions of Rails.
+
+# v0.34.3
+* Fix a crash in `singleton_method_owner_name` that occurred if `__attached__.class` returned
+  something other than a `Module` or a `Class`.
+  
+# v0.34.2
+* Add an extension that gets the name of the owner of a singleton method without calling
+  any methods that may have been redefined (e.g. `#to_s` or `.name`).
+  
 # v0.34.1
 * Ensure that capturing events doesn't change the behavior of a hooked method that uses
   `Time.now`. For example, if a test expects that `Time.now` will be called a certain

data/README.md

@@ -57,6 +57,15 @@ end
 
 Then install with `bundle`.
 
+**Railtie**
+
+If you are using Ruby on Rails, require the railtie after Rails is loaded. 
+
+```
+# application.rb is a good place to do this, along with all the other railties.
+require 'appmap/railtie'
+```
+
 # Configuration
 
 When you run your program, the `appmap` gem reads configuration settings from `appmap.yml`. Here's a sample configuration
@@ -267,7 +276,13 @@ $ bundle config local.appmap $(pwd)
 Run the tests via `rake`:
 ```
 $ bundle exec rake test
-```  
+```
+
+The `test` target will build the native extension first, then run the tests. If you need
+to build the extension separately, run
+```
+$ bundle exec rake compile
+```
 
 ## Using fixture apps
 
@@ -286,7 +301,7 @@ resources such as a PostgreSQL database.
 To build the fixture container images, first run:
 
 ```sh-session
-$ bundle exec rake fixtures:all
+$ bundle exec rake build:fixtures:all
 ```
 
 This will build the `appmap.gem`, along with a Docker image for each fixture app.

data/Rakefile

@@ -6,6 +6,13 @@ require 'rdoc/task'
 
 require 'open3'
 
+require "rake/extensiontask"
+
+desc 'build the native extension'
+Rake::ExtensionTask.new("appmap") do |ext|
+  ext.lib_dir = "lib/appmap"
+end
+
 namespace 'gem' do
   require 'bundler/gem_tasks'
 end
@@ -104,7 +111,7 @@ end
 namespace :spec do
   RUBY_VERSIONS.each do |ruby_version|
     desc ruby_version
-    task ruby_version, [:specs] => ["build:fixtures:#{ruby_version}:all"] do |_, task_args|
+    task ruby_version, [:specs] => ["compile", "build:fixtures:#{ruby_version}:all"] do |_, task_args|
       run_specs(ruby_version, task_args)
     end.tap do|t|
       desc "Run all specs"
@@ -119,13 +126,13 @@ Rake::RDocTask.new do |rd|
   rd.title = 'AppMap'
 end
 
-Rake::TestTask.new(:minitest) 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: "spec:all"
+task spec: %i[spec:all]
 
 task test: %i[spec:all minitest]
 

data/appmap.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = `git ls-files --no-deleted`.split("
 ")
+  spec.extensions << "ext/appmap/extconf.rb"
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
@@ -34,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rdoc'
   spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency "rake-compiler"
 
   # Testing
   spec.add_development_dependency 'climate_control'
@@ -43,4 +46,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'selenium-webdriver'
   spec.add_development_dependency 'webdrivers', '~> 4.0'
   spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'hashie'
 end

data/ext/appmap/appmap.c

@@ -0,0 +1,95 @@
+#include <ruby.h>
+#include <ruby/intern.h>
+
+// Seems like CLASS_OR_MODULE_P should really be in a header file in
+// the ruby source -- it's in object.c and duplicated in eval.c.  In
+// the future, we'll fail if it does get moved to a header.
+#define CLASS_OR_MODULE_P(obj) \
+    (!SPECIAL_CONST_P(obj) && \
+     (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE))
+
+#define ARITIES_KEY "__arities__"
+
+VALUE am_AppMapHook;
+
+static VALUE
+singleton_method_owner_name(VALUE klass, VALUE method)
+{
+  VALUE owner = rb_funcall(method, rb_intern("owner"), 0);
+  VALUE attached = rb_ivar_get(owner, rb_intern("__attached__"));
+  if (!CLASS_OR_MODULE_P(attached)) {
+    attached = rb_funcall(attached, rb_intern("class"), 0);
+  }
+
+  // Did __attached__.class return an object that's a Module or a
+  // Class?
+  if (CLASS_OR_MODULE_P(attached)) {
+    // Yup, get it's name
+    return rb_mod_name(attached);
+  }
+
+  // Nope (which seems weird, but whatever). Fall back to calling
+  // #to_s on the method's owner and hope for the best.
+  return rb_funcall(owner, rb_intern("to_s"), 0);
+}
+
+
+static VALUE
+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);
+  }
+  rb_hash_aset(arities, name, arity);
+
+  return rb_funcall(mod, rb_intern("define_method"), 2, name, proc);
+}
+
+static VALUE
+am_get_method_arity(VALUE method, VALUE orig_arity_method)
+{
+  VALUE owner = rb_funcall(method, rb_intern("owner"), 0);
+  VALUE arities = rb_ivar_get(owner, rb_intern(ARITIES_KEY));
+  VALUE name = rb_funcall(method, rb_intern("name"), 0);
+  VALUE arity = Qnil;
+  // See if we saved an arity for the method.
+  if (!NIL_P(arities)) {
+    arity = rb_hash_aref(arities, name);
+  }
+  // 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);    
+    arity = rb_funcall(bound_method, rb_intern("call"), 0);
+  }
+
+  return arity;
+}
+
+static VALUE
+am_unbound_method_arity(VALUE method)
+{
+  VALUE orig_unbound_method_arity = rb_ivar_get(am_AppMapHook, rb_intern("@unbound_method_arity"));
+  return am_get_method_arity(method, orig_unbound_method_arity);
+}
+
+static VALUE
+am_method_arity(VALUE method)
+{
+  VALUE orig_method_arity = rb_ivar_get(am_AppMapHook, rb_intern("@method_arity"));
+  return am_get_method_arity(method, orig_method_arity);
+}
+
+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_method(rb_cModule, "define_method_with_arity", am_define_method_with_arity, 3);
+  rb_define_method(rb_cUnboundMethod, "arity", am_unbound_method_arity, 0);
+  rb_define_method(rb_cMethod, "arity", am_method_arity, 0);
+}

data/ext/appmap/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+$CFLAGS='-Werror'
+extension_name = "appmap"
+dir_config(extension_name)
+create_makefile(File.join(extension_name, extension_name))

data/lib/appmap.rb

@@ -16,6 +16,9 @@ require 'appmap/metadata'
 require 'appmap/util'
 require 'appmap/open'
 
+# load extension
+require 'appmap/appmap'
+
 module AppMap
   class << self
     @configuration = nil
@@ -81,7 +84,7 @@ module AppMap
 
     # Builds a class map from a config and a list of Ruby methods.
     def class_map(methods)
-      ClassMap.build_from_methods(configuration, methods)
+      ClassMap.build_from_methods(methods)
     end
 
     # Returns default metadata detected from the Ruby system and from the

data/lib/appmap/class_map.rb

@@ -61,25 +61,24 @@ module AppMap
             location: location,
             static: static,
             labels: labels
-          }.delete_if { |k,v| v.nil? || v == [] }
+          }.delete_if { |_, v| v.nil? || v == [] }
         end
       end
     end
 
     class << self
-      def build_from_methods(config, methods)
+      def build_from_methods(methods)
         root = Types::Root.new
         methods.each do |method|
-          package = config.package_for_method(method) \
-            or raise "No package found for method #{method}"
-          add_function root, package, method
+          add_function root, method
         end
         root.children.map(&:to_h)
       end
 
       protected
 
-      def add_function(root, package, method)
+      def add_function(root, method)
+        package = method.package
         static = method.static
 
         object_infos = [

data/lib/appmap/config.rb

@@ -6,7 +6,7 @@ module AppMap
       def initialize(path, package_name: nil, exclude: [], labels: [])
         super path, package_name, exclude, labels
       end
-  
+
       def to_h
         {
           path: path,
@@ -35,12 +35,10 @@ module AppMap
       'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGE),
       'OpenSSL::Cipher' => Hook.new(%i[encrypt decrypt final], OPENSSL_PACKAGE),
       'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGE),
-      'Logger' => Hook.new(:add, Package.new('logger', labels: %w[log io])),
       'Net::HTTP' => Hook.new(:request, Package.new('net/http', package_name: 'net/http', labels: %w[http io])),
       'Net::SMTP' => Hook.new(:send, Package.new('net/smtp', package_name: 'net/smtp', labels: %w[smtp email io])),
       'Net::POP3' => Hook.new(:mails, Package.new('net/pop3', package_name: 'net/pop', labels: %w[pop pop3 email io])),
       'Net::IMAP' => Hook.new(:send_command, Package.new('net/imap', package_name: 'net/imap', labels: %w[imap email io])),
-      'IO' => Hook.new(%i[read write open close], Package.new('io', labels: %w[io])),
       'Marshal' => Hook.new(%i[dump load], Package.new('marshal', labels: %w[serialization marshal])),
       'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.new('yaml', package_name: 'psych', labels: %w[serialization yaml])),
       'JSON::Ext::Parser' => Hook.new(:parse, Package.new('json', package_name: 'json', labels: %w[serialization json])),
@@ -105,7 +103,7 @@ module AppMap
       hook = find_hook(defined_class)
       return nil unless hook
 
-      Array(hook.method_names).include?(method_name) ? hook.package : nil      
+      Array(hook.method_names).include?(method_name) ? hook.package : nil
     end
 
     def find_hook(defined_class)

data/lib/appmap/event.rb

@@ -36,20 +36,38 @@ module AppMap
             '*Error inspecting variable*'
           end
 
-          value_string = \
+          value_string = custom_display_string(value) || default_display_string(value)
+
+          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+        end
+
+        protected
+
+        def custom_display_string(value)
+          case value
+          when File
+            "#{value.class}[path=#{value.path}]"
+          when Net::HTTP
+            "#{value.class}[#{value.address}:#{value.port}]"
+          when Net::HTTPGenericRequest
+            "#{value.class}[#{value.method} #{value.path}]"
+          end
+        rescue StandardError
+          nil
+        end
+
+        def default_display_string(value)
+          begin
+            value.to_s
+          rescue NoMethodError
             begin
-              value.to_s
-            rescue NoMethodError
-              begin
-                value.inspect
-              rescue StandardError
-                last_resort_string.call
-              end
+              value.inspect
             rescue StandardError
               last_resort_string.call
             end
-
-          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+          rescue StandardError
+            last_resort_string.call
+          end
         end
       end
     end

data/lib/appmap/hook.rb

@@ -4,7 +4,10 @@ require 'English'
 
 module AppMap
   class Hook
-    LOG = (ENV['DEBUG'] == 'true')
+    LOG = (ENV['APPMAP_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
+
+    @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
+    @method_arity = ::Method.instance_method(:arity)
 
     class << self
       def lock_builtins
@@ -17,18 +20,7 @@ module AppMap
       # the given method.
       def qualify_method_name(method)
         if method.owner.singleton_class?
-          # Singleton class names can take two forms:
-          # #<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
-          # '__attached__'. It doesn't have the '@' prefix, so
-          # it's internal only, and not accessible from user
-          # code.)
-          class_name = /#<Class:((#<(?<cls>.*?):)|((?<cls>.*?)>))/.match(method.owner.to_s)['cls']
+          class_name = singleton_method_owner_name(method)
           [ class_name, '.', method.name ]
         else
           [ method.owner.name, '#', method.name ]
@@ -56,22 +48,23 @@ module AppMap
         hook = lambda do |hook_cls|
           lambda do |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
+            warn "AppMap: Examining #{hook_cls} #{method.name}" if LOG
 
             disasm = RubyVM::InstructionSequence.disasm(method)
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
+            next unless \
+              config.always_hook?(hook_cls, method.name) ||
+              config.included_by_location?(method)
+
+            hook_method = Hook::Method.new(config.package_for_method(method), hook_cls, method)
+
             # Don't try and trace the AppMap methods or there will be
             # a stack overflow in the defined hook method.
             next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
 
-            next unless \
-              config.always_hook?(hook_method.defined_class, method.name) ||
-              config.included_by_location?(method)
-
             hook_method.activate
           end
         end
@@ -105,9 +98,9 @@ module AppMap
             end
 
           if method
-            Hook::Method.new(cls, method).activate
+            Hook::Method.new(hook.package, cls, method).activate
           else
-            warn "Method #{method_name} not found on #{cls.name}" 
+            warn "Method #{method_name} not found on #{cls.name}"
           end
         end
       end