appmap 0.45.1 → 0.48.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b91b79723565f45d9d59ce341a9944a3a4e1c853bc77c1b176dc7b26ede9df22
-  data.tar.gz: f9be88ae7e83b801f66ada4087a06923ad9fa4d10e498f1c8b07fe0e301552d7
+  metadata.gz: 698da91c88a89867584e3d78e10974a4a2f8d726636d60366c214be9e3ddbf97
+  data.tar.gz: eee0b62c442eecc5cf978960128c0b19ff2ebdc393770d8cefc820c82a451d4f
 SHA512:
-  metadata.gz: e7eda447c67a44ad10226f5b6e9eb51c82995a4b2df970af27b0e2b5304101d419a6b3843ef6f0a983a3f952da2e3ed55f0de327b2856fcf970961c410c19b79
-  data.tar.gz: 839df6608d503e74f663d42673d9cf91866592a1715cee1c828c3de23ae472fdff6025ea9ee767a33e384b2ed51f46a999001d354f3e763deba46a5253eb5661
+  metadata.gz: 77ae4b055912a7bd6f62f32bb2db7d3684d614453fb82bb7d8f53496181919609ca2af0a65906ca36f1f28aaf28e06c64d6f5e6326b8f384f4c1206c22af559a
+  data.tar.gz: a72831c1908beb0130b4797ea5455b976677caec810edcdf0009b9be609ba6510a59873b66ca4df5406fe8f3e5aea995d8dabc983573517adc67fdf86cad822a

data/.dockerignore

@@ -2,4 +2,3 @@ vendor
 node_modules
 spec/fixtures/rails*_users_app
 spec/fixtures/rack_users_app
-

data/.travis.yml

@@ -17,6 +17,16 @@ before_script:
 cache:
   bundler: true
 
+before_install:
+  # 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
+
  
 # GEM_ALTERNATIVE_NAME only needed for deployment 
 jobs:

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+## [0.48.1](https://github.com/applandinc/appmap-ruby/compare/v0.48.0...v0.48.1) (2021-05-25)
+
+
+### Bug Fixes
+
+* Account for bundle path when normalizing source path ([095c278](https://github.com/applandinc/appmap-ruby/commit/095c27818fc8ae8dfa39b30516d37c6dfd642d9c))
+* Scan exception messages for non-UTF8 characters ([3dcaeae](https://github.com/applandinc/appmap-ruby/commit/3dcaeae44da5e40e432eda41caf5b9ebff5bea12))
+
+# [0.48.0](https://github.com/applandinc/appmap-ruby/compare/v0.47.1...v0.48.0) (2021-05-19)
+
+
+### Features
+
+* Hook the code only when APPMAP=true ([dd9e383](https://github.com/applandinc/appmap-ruby/commit/dd9e383024d1d9205a617d46bd64b90820035533))
+* Remove server process recording from doc and tests ([383ba0a](https://github.com/applandinc/appmap-ruby/commit/383ba0ad444922a0a85409477d11bc7ed06a9160))
+
+## [0.47.1](https://github.com/applandinc/appmap-ruby/compare/v0.47.0...v0.47.1) (2021-05-13)
+
+
+### Bug Fixes
+
+* Add the proper template function hooks for Rails 6.0.7 ([175f489](https://github.com/applandinc/appmap-ruby/commit/175f489acbaed77ad52a18d805e4b6eeae1abfdb))
+
+# [0.47.0](https://github.com/applandinc/appmap-ruby/compare/v0.46.0...v0.47.0) (2021-05-13)
+
+
+### Features
+
+* Emit swagger-style normalized paths instead of Rails-style ones ([5a93cd7](https://github.com/applandinc/appmap-ruby/commit/5a93cd7096ca195146a84a6733c7d502dbcd0272))
+
+# [0.46.0](https://github.com/applandinc/appmap-ruby/compare/v0.45.1...v0.46.0) (2021-05-12)
+
+
+### Features
+
+* Record view template rendering events and template paths ([973b258](https://github.com/applandinc/appmap-ruby/commit/973b2581b6e2d4e15a1b93331e4e95a88678faae))
+
 ## [0.45.1](https://github.com/applandinc/appmap-ruby/compare/v0.45.0...v0.45.1) (2021-05-04)
 
 

data/README.md

@@ -9,7 +9,6 @@
   - [Minitest](#minitest)
   - [Cucumber](#cucumber)
   - [Remote recording](#remote-recording)
-  - [Server process recording](#server-process-recording)
 - [AppMap for VSCode](#appmap-for-vscode)
 - [AppMap Swagger](#appmap-swagger)
 - [Uploading AppMaps](#uploading-appmaps)
@@ -84,22 +83,6 @@ If you are using Ruby on Rails, require the railtie after Rails is loaded.
 require 'appmap/railtie' if defined?(AppMap).
 ```
 
-**application.rb**
-
-Add this line to *application.rb*, to enable server recording with `APPMAP_RECORD=true`:
-
-```ruby
-module MyApp
-  class Application < Rails::Application
-    ...
-  
-    config.appmap.enabled = true if ENV['APPMAP_RECORD']
-    
-    ...
-  end
-end
-```
-
 # Configuration
 
 When you run your program, the `appmap` gem reads configuration settings from `appmap.yml`. Here's a sample configuration
@@ -326,25 +309,25 @@ if defined?(AppMap)
 end
 ```
 
-2. Download and unpack the [AppLand browser extension](https://github.com/applandinc/appland-browser-extension). Install into Chrome using `chrome://extensions/`. Turn on "Developer Mode" and then load the extension using the "Load unpacked" button.
+2. (optional) Download and unpack the [AppLand browser extension](https://github.com/applandinc/appland-browser-extension). Install into Chrome using `chrome://extensions/`. Turn on "Developer Mode" and then load the extension using the "Load unpacked" button.
 
-3. Start your Rails application server. For example:
+3. Start your Rails application server, with `APPMAP_RECORD=true`. For example:
 
 ```sh-session
-$ bundle exec rails server
+$ APPMAP_RECORD=true bundle exec rails server
 ```
 
-4. Open the AppLand browser extension and push `Start`.
+4. Start the recording
 
-5. Use your app. For example, perform a login flow, or run through a manual UI test.
+Option 1: Open the AppLand browser extension and push `Start`.
+Option 2: `curl -XPOST localhost:3000/_appmap/record` (be sure and get the port number right)
 
-6. Open the AppLand browser extension and push `Stop`. The recording will be transferred to the AppLand website and opened in your browser.
-
-## Server process recording
+5. Use your app. For example, perform a login flow, or run through a manual UI test.
 
-Run your Rails server with `APPMAP_RECORD=true`. When the server exits, an *appmap.json* file will be written to the project directory. This is a great way to start the server, interact with your app as a user (or through it's API), and then view an AppMap of everything that happened.
+6. Finish the recording.
 
-Be sure and set `WEB_CONCURRENCY=1`, if you are using a webserver that can run multiple processes. You only want there to be one process while you are recording, otherwise they will both try and write *appmap.json* and one of them will clobber the other.
+Option 1: Open the AppLand browser extension and push `Stop`. The recording will be transferred to the AppLand website and opened in your browser.
+Option 2: `curl -XDELETE localhost:3000/_appmap/record > recording.appmap.json` - Saves the recording as a local file.
 
 
 # AppMap for VSCode

data/lib/appmap.rb

@@ -9,7 +9,6 @@ end
 
 require 'appmap/version'
 require 'appmap/hook'
-require 'appmap/handler/net_http'
 require 'appmap/config'
 require 'appmap/trace'
 require 'appmap/class_map'
@@ -99,4 +98,4 @@ module AppMap
 end
 
 require 'appmap/railtie' if defined?(::Rails::Railtie)
-AppMap.initialize unless ENV['APPMAP_INITIALIZE'] == 'false'
+AppMap.initialize if ENV['APPMAP'] == 'true'

data/lib/appmap/class_map.rb

@@ -82,16 +82,13 @@ module AppMap
       protected
 
       def add_function(root, method)
-        package = method.package
-        static = method.static
-
         object_infos = [
           {
-            name: package.name,
+            name: method.package,
             type: 'package'
           }
         ]
-        object_infos += method.defined_class.split('::').map do |name|
+        object_infos += method.class_name.split('::').map do |name|
           {
             name: name,
             type: 'class'
@@ -100,7 +97,7 @@ module AppMap
         function_info = {
           name: method.name,
           type: 'function',
-          static: static
+          static: method.static
         }
         location = method.source_location
 
@@ -108,20 +105,15 @@ module AppMap
           if location
             location_file, lineno = location
             location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
-            [ location_file, lineno ].join(':')
+            [ location_file, lineno ].compact.join(':')
           else
-            [ method.defined_class, static ? '.' : '#', method.name ].join
+            [ method.class_name, method.static ? '.' : '#', method.name ].join
           end
 
-        comment = begin
-          method.comment
-        rescue MethodSource::SourceNotFoundError
-          nil
-        end
-
+        comment = method.comment
         function_info[:comment] = comment unless comment.blank?
 
-        function_info[:labels] = parse_labels(comment) + (package.labels || [])
+        function_info[:labels] = parse_labels(comment) + (method.labels || [])
         object_infos << function_info
 
         parent = root

data/lib/appmap/config.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'appmap/handler/net_http'
+require 'appmap/handler/rails/template'
+
 module AppMap
   class Config
     # Specifies a code +path+ to be mapped.
@@ -82,18 +85,7 @@ module AppMap
       end
     end
 
-    Function = Struct.new(:package, :cls, :labels, :function_names) do # :nodoc:
-      def to_h
-        {
-          package: package,
-          class: cls,
-          labels: labels,
-          functions: function_names.map(&:to_sym)
-        }.compact
-      end
-    end
-    private_constant :Function
-
+    # Identifies specific methods within a package which should be hooked.
     class TargetMethods # :nodoc:
       attr_reader :method_names, :package
 
@@ -115,24 +107,91 @@ module AppMap
     end
     private_constant :TargetMethods
 
-    OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
+    # Function represents a specific function configured for hooking by the +functions+
+    # entry in appmap.yml. When the Config is initialized, each Function is converted into
+    # a Package and TargetMethods. It's called a Function rather than a Method, because Function
+    # is the AppMap terminology.
+    Function = Struct.new(:package, :cls, :labels, :function_names) do # :nodoc:
+      def to_h
+        {
+          package: package,
+          class: cls,
+          labels: labels,
+          functions: function_names.map(&:to_sym)
+        }.compact
+      end
+    end
+    private_constant :Function
 
-    # Methods that should always be hooked, with their containing
-    # package and labels that should be applied to them.
-    HOOKED_METHODS = {
-      'ActionView::Renderer' => TargetMethods.new(:render, Package.build_from_gem('actionview', package_name: 'action_view', labels: %w[mvc.view], optional: true)),
-      'ActionDispatch::Request::Session' => TargetMethods.new(%i[destroy [] dig values []= clear update delete fetch merge], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.session], optional: true)),
-      'ActionDispatch::Cookies::CookieJar' => TargetMethods.new(%i[[]= clear update delete recycle], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.cookie], optional: true)),
-      'ActionDispatch::Cookies::EncryptedCookieJar' => TargetMethods.new(%i[[]=], Package.build_from_gem('actionpack', package_name: 'action_dispatch', labels: %w[http.cookie crypto.encrypt], optional: true)),
-      'CanCan::ControllerAdditions' => TargetMethods.new(%i[authorize! can? cannot?], Package.build_from_gem('cancancan', labels: %w[security.authorization], optional: true)),
-      'CanCan::Ability' => TargetMethods.new(%i[authorize!], Package.build_from_gem('cancancan', labels: %w[security.authorization], optional: true)),
-      'ActionController::Instrumentation' => [
-        TargetMethods.new(%i[process_action send_file send_data redirect_to], Package.build_from_gem('actionpack', package_name: 'action_controller', labels: %w[mvc.controller], optional: true)),
-        TargetMethods.new(%i[render], Package.build_from_gem('actionpack', package_name: 'action_controller', labels: %w[mvc.view], optional: true)),
-      ]
-    }.freeze
+    ClassTargetMethods = Struct.new(:cls, :target_methods) # :nodoc:
+    private_constant :ClassTargetMethods
+
+    MethodHook = Struct.new(:cls, :method_names, :labels) # :nodoc:
+    private_constant :MethodHook
+    
+    class << self
+      def package_hooks(gem_name, methods, handler_class: nil, package_name: nil)
+        Array(methods).map do |method|
+          package = Package.build_from_gem(gem_name, package_name: package_name, labels: method.labels, shallow: false, optional: true)
+          next unless package
+
+          package.handler_class = handler_class if handler_class
+          ClassTargetMethods.new(method.cls, TargetMethods.new(Array(method.method_names), package))
+        end.compact
+      end
+
+      def method_hook(cls, method_names, labels)
+        MethodHook.new(cls, method_names, labels)
+      end
+    end
+
+    # Hook well-known functions. When a function configured here is available in the bundle, it will be hooked with the
+    # predefined labels specified here. If any of these hooks are not desired, they can be disabled in the +exclude+ section
+    # of appmap.yml.
+    METHOD_HOOKS = [
+      package_hooks('actionview',
+        [
+          method_hook('ActionView::Renderer', :render, %w[mvc.view]),
+          method_hook('ActionView::TemplateRenderer', :render, %w[mvc.view]),
+          method_hook('ActionView::PartialRenderer', :render, %w[mvc.view])
+        ],
+        handler_class: AppMap::Handler::Rails::Template::RenderHandler,
+        package_name: 'action_view'
+      ),
+      package_hooks('actionview',
+        [
+          method_hook('ActionView::Resolver', %i[find_all find_all_anywhere], %w[mvc.template.resolver])
+        ],
+        handler_class: AppMap::Handler::Rails::Template::ResolverHandler,
+        package_name: 'action_view'
+      ),
+      package_hooks('actionpack',
+        [
+          method_hook('ActionDispatch::Request::Session', %i[destroy [] dig values []= clear update delete fetch merge], %w[http.session]),
+          method_hook('ActionDispatch::Cookies::CookieJar', %i[[]= clear update delete recycle], %w[http.session]),
+          method_hook('ActionDispatch::Cookies::EncryptedCookieJar', %i[[]= clear update delete recycle], %w[http.cookie crypto.encrypt])
+        ],
+        package_name: 'action_dispatch'
+      ),
+      package_hooks('cancancan',
+        [
+          method_hook('CanCan::ControllerAdditions', %i[authorize! can? cannot?], %w[security.authorization]),
+          method_hook('CanCan::Ability', %i[authorize?], %w[security.authorization])
+        ]
+      ),
+      package_hooks('actionpack',
+        [
+          method_hook('ActionController::Instrumentation', %i[process_action send_file send_data redirect_to], %w[mvc.controller])
+        ],
+        package_name: 'action_controller'
+      )
+    ].flatten.freeze
 
-    BUILTIN_METHODS = {
+    OPENSSL_PACKAGES = ->(labels) { Package.build_from_path('openssl', package_name: 'openssl', labels: labels) }
+
+    # Hook functions which are builtin to Ruby. Because they are builtins, they may be loaded before appmap.
+    # Therefore, we can't rely on TracePoint to report the loading of this code.
+    BUILTIN_HOOKS = {
       'OpenSSL::PKey::PKey' => TargetMethods.new(:sign, OPENSSL_PACKAGES.(%w[crypto.pkey])),
       'OpenSSL::X509::Request' => TargetMethods.new(%i[sign verify], OPENSSL_PACKAGES.(%w[crypto.x509])),
       'OpenSSL::PKCS5' => TargetMethods.new(%i[pbkdf2_hmac_sha1 pbkdf2_hmac], OPENSSL_PACKAGES.(%w[crypto.pkcs5])),
@@ -159,26 +218,29 @@ module AppMap
       'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json])),
     }.freeze
 
-    attr_reader :name, :packages, :exclude, :hooked_methods, :builtin_methods
+    attr_reader :name, :packages, :exclude, :hooked_methods, :builtin_hooks
 
     def initialize(name, packages, exclude: [], functions: [])
       @name = name
       @packages = packages
-      @hook_paths = packages.map(&:path)
+      @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
-      @builtin_methods = BUILTIN_METHODS
+      @builtin_hooks = BUILTIN_HOOKS
       @functions = functions
-      @hooked_methods = HOOKED_METHODS.dup
+
+      @hooked_methods = METHOD_HOOKS.each_with_object(Hash.new { |h,k| h[k] = [] }) do |cls_target_methods, hooked_methods|
+        hooked_methods[cls_target_methods.cls] << cls_target_methods.target_methods
+      end
+
       functions.each do |func|
         package_options = {}
         package_options[:labels] = func.labels if func.labels
-        @hooked_methods[func.cls] ||= []
         @hooked_methods[func.cls] << TargetMethods.new(func.function_names, Package.build_from_path(func.package, package_options))
       end
 
       @hooked_methods.each_value do |hooks|
         Array(hooks).each do |hook|
-          @hook_paths << hook.package.path if hook.package
+          @hook_paths << hook.package.path
         end
       end
     end

data/lib/appmap/event.rb

@@ -21,10 +21,10 @@ module AppMap
       LIMIT = 100
 
       class << self
-        def build_from_invocation(me, event_type)
-          me.id = AppMap::Event.next_id_counter
-          me.event = event_type
-          me.thread_id = Thread.current.object_id
+        def build_from_invocation(event_type, event:)
+          event.id = AppMap::Event.next_id_counter
+          event.event = event_type
+          event.thread_id = Thread.current.object_id
         end
 
         # Gets a display string for a value. This is not meant to be a machine deserializable value.
@@ -48,8 +48,6 @@ module AppMap
           nil
         end
 
-        protected
-
         # Heuristic for dynamically defined class whose name can be nil
         def best_class_name(value)
           value_cls = value.class
@@ -103,19 +101,20 @@ module AppMap
       attr_accessor :defined_class, :method_id, :path, :lineno, :parameters, :receiver, :static
 
       class << self
-        def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
+        def build_from_invocation(defined_class, method, receiver, arguments, event: MethodCall.new)
+          event ||= MethodCall.new
           defined_class ||= 'Class'
-          mc.tap do
+          event.tap do
             static = receiver.is_a?(Module)
-            mc.defined_class = defined_class
-            mc.method_id = method.name.to_s
+            event.defined_class = defined_class
+            event.method_id = method.name.to_s
             if method.source_location
               path = method.source_location[0]
               path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
-              mc.path = path
-              mc.lineno = method.source_location[1]
+              event.path = path
+              event.lineno = method.source_location[1]
             else
-              mc.path = [ defined_class, static ? '.' : '#', method.name ].join
+              event.path = [ defined_class, static ? '.' : '#', method.name ].join
             end
 
             # Check if the method has key parameters. If there are any they'll always be last.
@@ -123,7 +122,7 @@ module AppMap
             has_key = [[:dummy], *method.parameters].last.first.to_s.start_with?('key') && arguments[-1].is_a?(Hash)
             kwargs = has_key && arguments[-1].dup || {}
 
-            mc.parameters = method.parameters.map.with_index do |method_param, idx|
+            event.parameters = method.parameters.map.with_index do |method_param, idx|
               param_type, param_name = method_param
               param_name ||= 'arg'
               value = case param_type
@@ -144,13 +143,13 @@ module AppMap
                 kind: param_type
               }
             end
-            mc.receiver = {
+            event.receiver = {
               class: best_class_name(receiver),
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
-            mc.static = static
-            MethodEvent.build_from_invocation(mc, :call)
+            event.static = static
+            MethodEvent.build_from_invocation(:call, event: event)
           end
         end
       end
@@ -175,11 +174,12 @@ module AppMap
       attr_accessor :parent_id, :elapsed
 
       class << self
-        def build_from_invocation(mr = MethodReturnIgnoreValue.new, parent_id, elapsed)
-          mr.tap do |_|
-            mr.parent_id = parent_id
-            mr.elapsed = elapsed
-            MethodEvent.build_from_invocation(mr, :return)
+        def build_from_invocation(parent_id, elapsed: nil, event: MethodReturnIgnoreValue.new)
+          event ||= MethodReturnIgnoreValue.new
+          event.tap do |_|
+            event.parent_id = parent_id
+            event.elapsed = elapsed
+            MethodEvent.build_from_invocation(:return, event: event)
           end
         end
       end
@@ -187,7 +187,7 @@ module AppMap
       def to_h
         super.tap do |h|
           h[:parent_id] = parent_id
-          h[:elapsed] = elapsed
+          h[:elapsed] = elapsed if elapsed
         end
       end
     end
@@ -196,10 +196,11 @@ module AppMap
       attr_accessor :return_value, :exceptions
 
       class << self
-        def build_from_invocation(mr = MethodReturn.new, parent_id, elapsed, return_value, exception)
-          mr.tap do |_|
+        def build_from_invocation(parent_id, return_value, exception, elapsed: nil, event: MethodReturn.new)
+          event ||= MethodReturn.new
+          event.tap do |_|
             if return_value
-              mr.return_value = {
+              event.return_value = {
                 class: best_class_name(return_value),
                 value: display_string(return_value),
                 object_id: return_value.__id__
@@ -212,7 +213,7 @@ module AppMap
                 exception_backtrace = next_exception.backtrace_locations.try(:[], 0)
                 exceptions << {
                   class: best_class_name(next_exception),
-                  message: next_exception.message,
+                  message: display_string(next_exception.message),
                   object_id: next_exception.__id__,
                   path: exception_backtrace&.path,
                   lineno: exception_backtrace&.lineno
@@ -220,9 +221,9 @@ module AppMap
                 next_exception = next_exception.cause
               end
 
-              mr.exceptions = exceptions
+              event.exceptions = exceptions
             end
-            MethodReturnIgnoreValue.build_from_invocation(mr, parent_id, elapsed)
+            MethodReturnIgnoreValue.build_from_invocation(parent_id, elapsed: elapsed, event: event)
           end
         end
       end