appmap 0.34.4 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a509a94faa2a85ff11702ae55ab3df975f04416d93d169b0a24989fd520b9d
-  data.tar.gz: 3895b9c788413f85738ba487e717bf48e4dfc2e8c0792f30c6f9f6ba7dc5e9c8
+  metadata.gz: 102dab80f2d8cffd51fd1377583a1b063078cd77ab7ad4ffdcd20867a084b11b
+  data.tar.gz: cbb87144593416f84099cf8a9d8ac18f18d9763dce28277320ae6a99ff59ec58
 SHA512:
-  metadata.gz: 07fe201395cad27e731402b5b2ff0efd653056dad16b9301657034df0b6e7fd3a205768ef3656874f55109edfc4d788d752f8bc73f4ff6874c815104547ce281
-  data.tar.gz: cbbd1551c352519954e9ddc9dd27279d6d232663fb67fd5ed4369a603a382f140593aa195aa08f35a57b0a14d38bef07bfef0aa7bd942d660a865fb3682d500d
+  metadata.gz: a24e2ecb22a654d11e91ef28a7fdd961c178144f474a36e26c70e8e243bac18c13e3c5ff606f5ed2a058ddf6d98f9dbd0678a0f986ddfae4f18ed7524c27d41d
+  data.tar.gz: 712cb7e18026aa80135af7ce54a7a8c412362355c0eb6b151a0f05354cf991ebe9402e298d9646b9fab2e5d673d3338a773a0b1b1d0e1846ec3ed970074a1f77

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+# v0.36.0
+* *appmap.yml* package definition may specify `gem`.
+* Skip loading the railtie if `APPMAP_INITIALIZE` environment variable
+  is set to `false`.
+
+# v0.35.2
+* Make sure `MethodEvent#display_string` works when the value's `#to_s` and/or `#inspect`
+  methods have problems.
+  
+# 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.

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
@@ -67,6 +76,7 @@ name: MyProject
 packages:
 - path: app/controllers
 - path: app/models
+- gem: activerecord
 ```
 
 * **name** Provides the project name (required)
@@ -78,6 +88,7 @@ Each entry in the `packages` list is a YAML object which has the following keys:
 
 * **path** The path to the source code directory. The path may be relative to the current working directory, or it may
   be an absolute path.
+* **gem** As an alternative to specifying the path, specify the name of a dependency gem. When using `gem`, don't specify `path`.
 * **exclude** A list of files and directories which will be ignored. By default, all modules, classes and public
   functions are inspected.
 

data/Rakefile

@@ -113,7 +113,7 @@ namespace :spec do
     desc ruby_version
     task ruby_version, [:specs] => ["compile", "build:fixtures:#{ruby_version}:all"] do |_, task_args|
       run_specs(ruby_version, task_args)
-    end.tap do|t|
+    end.tap do |t|
       desc "Run all specs"
       task :all, [:specs] => t
     end

data/appmap.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'parser'
   spec.add_dependency 'rack'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'bundler', '>= 1.16'
   spec.add_development_dependency 'minitest', '~> 5.0'
   spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'rake', '>= 12.3.3'

data/appmap.yml

@@ -1,8 +1,2 @@
 name: AppMap Rubygem
-packages:
-  - path: lib/appmap
-    exclude:
-      - server
-      - trace
-
-  - path: examples
+packages: []

data/ext/appmap/appmap.c

@@ -8,7 +8,12 @@
     (!SPECIAL_CONST_P(obj) && \
      (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE))
 
-static VALUE singleton_method_owner_name(VALUE klass, VALUE method)
+#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__"));
@@ -27,10 +32,64 @@ static VALUE singleton_method_owner_name(VALUE klass, VALUE method)
   // #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");
-  VALUE hook = rb_define_class_under(appmap, "Hook", rb_cObject);
+  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_singleton_method(hook, "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/lib/appmap.rb

@@ -84,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,30 +61,29 @@ 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 = [
           {
-            name: package.path,
+            name: package.name,
             type: 'package'
           }
         ]

data/lib/appmap/config.rb

@@ -2,15 +2,39 @@
 
 module AppMap
   class Config
-    Package = Struct.new(:path, :package_name, :exclude, :labels) do
-      def initialize(path, package_name: nil, exclude: [], labels: [])
-        super path, package_name, exclude, labels
+    Package = Struct.new(:path, :gem, :package_name, :exclude, :labels) do
+      class << self
+        def build_from_path(path, package_name: nil, exclude: [], labels: [])
+          Package.new(path, nil, package_name, exclude, labels)
+        end
+
+        def build_from_gem(gem, package_name: nil, exclude: [], labels: [])
+          gem_paths(gem).map do |gem_path|
+            Package.new(gem_path, gem, package_name, exclude, labels)
+          end
+        end
+
+        private_class_method :new
+
+        protected
+
+        def gem_paths(gem)
+          gemspec = Gem.loaded_specs[gem] or raise "Gem #{gem.inspect} not found"
+          gemspec.source_paths.map do |path|
+            File.join(gemspec.gem_dir, path)
+          end
+        end
+      end
+
+      def name
+        gem || path
       end
-  
+
       def to_h
         {
           path: path,
           package_name: package_name,
+          gem: gem,
           exclude: exclude.blank? ? nil : exclude,
           labels: labels.blank? ? nil : labels
         }.compact
@@ -20,31 +44,29 @@ module AppMap
     Hook = Struct.new(:method_names, :package) do
     end
 
-    OPENSSL_PACKAGE = Package.new('openssl', package_name: 'openssl', labels: %w[security crypto])
+    OPENSSL_PACKAGES = Package.build_from_path('openssl', package_name: 'openssl', labels: %w[security crypto])
 
     # Methods that should always be hooked, with their containing
     # package and labels that should be applied to them.
     HOOKED_METHODS = {
-      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.new('active_support', package_name: 'active_support', labels: %w[security crypto]))
+      'ActiveSupport::SecurityUtils' => Hook.new(:secure_compare, Package.build_from_path('active_support', package_name: 'active_support', labels: %w[security crypto]))
     }.freeze
 
     BUILTIN_METHODS = {
-      'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGE),
-      'Digest::Instance' => Hook.new(:digest, OPENSSL_PACKAGE),
-      'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGE),
-      '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])),
-      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.new('json', package_name: 'json', labels: %w[serialization json]))
+      'OpenSSL::PKey::PKey' => Hook.new(:sign, OPENSSL_PACKAGES),
+      'Digest::Instance' => Hook.new(:digest, OPENSSL_PACKAGES),
+      'OpenSSL::X509::Request' => Hook.new(%i[sign verify], OPENSSL_PACKAGES),
+      'OpenSSL::PKCS5' => Hook.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES),
+      'OpenSSL::Cipher' => Hook.new(%i[encrypt decrypt final], OPENSSL_PACKAGES),
+      'OpenSSL::X509::Certificate' => Hook.new(:sign, OPENSSL_PACKAGES),
+      'Net::HTTP' => Hook.new(:request, Package.build_from_path('net/http', package_name: 'net/http', labels: %w[http io])),
+      'Net::SMTP' => Hook.new(:send, Package.build_from_path('net/smtp', package_name: 'net/smtp', labels: %w[smtp email io])),
+      'Net::POP3' => Hook.new(:mails, Package.build_from_path('net/pop3', package_name: 'net/pop', labels: %w[pop pop3 email io])),
+      'Net::IMAP' => Hook.new(:send_command, Package.build_from_path('net/imap', package_name: 'net/imap', labels: %w[imap email io])),
+      'Marshal' => Hook.new(%i[dump load], Package.build_from_path('marshal', labels: %w[serialization marshal])),
+      'Psych' => Hook.new(%i[dump dump_stream load load_stream parse parse_stream], Package.build_from_path('yaml', package_name: 'psych', labels: %w[serialization yaml])),
+      'JSON::Ext::Parser' => Hook.new(:parse, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json])),
+      'JSON::Ext::Generator::State' => Hook.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[serialization json]))
     }.freeze
 
     attr_reader :name, :packages
@@ -64,8 +86,16 @@ module AppMap
       # Loads configuration from a Hash.
       def load(config_data)
         packages = (config_data['packages'] || []).map do |package|
-          Package.new(package['path'], exclude: package['exclude'] || [])
-        end
+          gem = package['gem']
+          path = package['path']
+          raise 'AppMap package configuration should specify gem or path, not both' if gem && path
+
+          if gem
+            Package.build_from_gem(gem, exclude: package['exclude'] || [])
+          else
+            [ Package.build_from_path(path, exclude: package['exclude'] || []) ]
+          end
+        end.flatten
         Config.new config_data['name'], packages
       end
     end
@@ -105,7 +135,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

@@ -31,25 +31,43 @@ module AppMap
         def display_string(value)
           return nil unless value
 
+          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)
           last_resort_string = lambda do
             warn "AppMap encountered an error inspecting a #{value.class.name}: #{$!.message}"
             '*Error inspecting variable*'
           end
 
-          value_string = \
+          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
@@ -45,7 +48,6 @@ 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_cls} #{method.name}" if LOG
 
@@ -53,14 +55,16 @@ module AppMap
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
-            # 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_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)
+
             hook_method.activate
           end
         end
@@ -94,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