appmap 0.46.0 → 0.48.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b563a80bb77c42dd44d9fd299ed9b1a273abaf9d43256e23a0856fc06849f74c
-  data.tar.gz: 25dead3dd3c057ee4585c8af0e85e8d495e689a18f3aa02d850bdf470c98d5ff
+  metadata.gz: 455ac48f4acf31694cb571912703f62b95687b8b833be0ced7b8ab5008c3960b
+  data.tar.gz: 272c68f804affe1a461ec504475b95d1c7968e506644442437a45dd28ff7d664
 SHA512:
-  metadata.gz: 6bc94e6ee51daf178d9db411f2393538e91e4cc6a985c9b1d28ccc08feda7b6b59708d9f5f0f2cbd2184b058ff39d245c2c84e4cb25a64d5e6ddac96587c2a76
-  data.tar.gz: 252d3955b6daedfb687091c8fb735c3f61d4cca3d7fa6ac44182c9c87f2185f53e886fa4e96f3896c35a7b5bb67e3302120dfa4e978324783b72d446f531b630
+  metadata.gz: 3bfbb562490380393c669aaeb2813389a52bf18f8e769f69a496ffe9fc26a493d9f55cfa161926d26deca370b1e18f99896eb0e269e59cbd6647801b7238c565
+  data.tar.gz: ba4b69852fc4be1850b5fd20c713e21799848bd32a251cdcc3bae87e4bf25605621dccc381e32018397ff52bbc442859065d8f1d8313211c135c1a9fb3ecb6d7

data/.dockerignore

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

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+## [0.48.2](https://github.com/applandinc/appmap-ruby/compare/v0.48.1...v0.48.2) (2021-05-26)
+
+
+### Bug Fixes
+
+* Correct the method-hooking logic to capture some missing model methods ([be529bd](https://github.com/applandinc/appmap-ruby/commit/be529bdce7d4fdf9f1a2fdd32259d792f29f4f13))
+
+## [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)
 
 

data/README.md

@@ -83,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
@@ -327,10 +311,10 @@ end
 
 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, with `APPMAP_RECORD=true`. For example:
+3. Start your Rails application server, with `APPMAP=true`. For example:
 
 ```sh-session
-$ APPMAP_RECORD=true bundle exec rails server
+$ APPMAP=true bundle exec rails server
 ```
 
 4. Start the recording

data/lib/appmap.rb

@@ -98,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/config.rb

@@ -85,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
 
@@ -118,28 +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', shallow: false, package_name: 'action_view', labels: %w[mvc.view], optional: true).tap do |package|
-        package.handler_class = AppMap::Handler::Rails::Template::RenderHandler if package
-      end),
-      'ActionView::Resolver' => TargetMethods.new(%i[find_all find_all_anywhere], Package.build_from_gem('actionview', shallow: false, package_name: 'action_view', labels: %w[mvc.template.resolver], optional: true).tap do |package|
-        package.handler_class = AppMap::Handler::Rails::Template::ResolverHandler if package
-      end),
-      'ActionDispatch::Request::Session' => TargetMethods.new(%i[destroy [] dig values []= clear update delete fetch merge], Package.build_from_gem('actionpack', shallow: false, 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', shallow: false, package_name: 'action_dispatch', labels: %w[http.cookie], optional: true)),
-      'ActionDispatch::Cookies::EncryptedCookieJar' => TargetMethods.new(%i[[]=], Package.build_from_gem('actionpack', shallow: false, 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', shallow: false, labels: %w[security.authorization], optional: true)),
-      'CanCan::Ability' => TargetMethods.new(%i[authorize!], Package.build_from_gem('cancancan', shallow: false, labels: %w[security.authorization], optional: true)),
-      'ActionController::Instrumentation' => [
-        TargetMethods.new(%i[process_action send_file send_data redirect_to], Package.build_from_gem('actionpack', shallow: false, package_name: 'action_controller', labels: %w[mvc.controller], 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])),
@@ -166,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

@@ -213,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

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

@@ -65,7 +65,7 @@ module AppMap
               next unless app.matches? request
               return normalized_path request, app.rack_app.routes.router if app.engine?
 
-              return route.path.spec.to_s
+              return AppMap::Util.swaggerize_path(route.path.spec.to_s)
             end
           end
         end

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

@@ -105,12 +105,18 @@ module AppMap
             # If so, populate the template path. In all cases, add a TemplateMethod so that the
             # template will be recorded in the classMap.
             def handle_return(call_event_id, elapsed, return_value, exception)
-              warn "Resolver return: #{return_value.inspect}" if LOG
-
               renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
-              path = Array(return_value).first&.inspect
+              path_obj = Array(return_value).first
+              
+              warn "Resolver return: #{path_obj}" if LOG
 
-              if path
+              if path_obj
+                path = if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
+                  path_obj.identifier
+                else
+                  path_obj.inspect
+                end
+                path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
                 AppMap.tracing.record_method(TemplateMethod.new(path))
                 renderer.path ||= path if renderer
               end

data/lib/appmap/hook.rb

@@ -36,7 +36,7 @@ module AppMap
 
     def initialize(config)
       @config = config
-      @trace_locations = []
+      @trace_enabled = []
       # Paths that are known to be non-tracing
       @notrace_paths = Set.new
     end
@@ -47,10 +47,8 @@ module AppMap
 
       hook_builtins
 
-      @trace_begin = TracePoint.new(:class, &method(:trace_class))
       @trace_end = TracePoint.new(:end, &method(:trace_end))
-
-      @trace_begin.enable(&block)
+      @trace_end.enable(&block)
     end
 
     # hook_builtins builds hooks for code that is built in to the Ruby standard library.
@@ -64,7 +62,7 @@ module AppMap
         end
       end
 
-      config.builtin_methods.each do |class_name, hooks|
+      config.builtin_hooks.each do |class_name, hooks|
         Array(hooks).each do |hook|
           require hook.package.package_name if hook.package.package_name
           Array(hook.method_names).each do |method_name|
@@ -96,29 +94,22 @@ module AppMap
 
     protected
 
-    def trace_class(trace_point)
-      path = trace_point.path
-
-      return if @notrace_paths.member?(path)
-
-      if config.path_enabled?(path)
-        location = trace_location(trace_point)
-        warn "Entering hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
-        @trace_locations << location
-        unless @trace_end.enabled?
-          warn "Enabling hooking" if Hook::LOG || Hook::LOG_HOOK
-          @trace_end.enable
-        end
-      else
-        @notrace_paths << path
-      end
-    end
-
     def trace_location(trace_point)
       [ trace_point.path, trace_point.lineno ].join(':')
     end
 
     def trace_end(trace_point)
+      location = trace_location(trace_point)
+      warn "Class or module ends at location #{trace_location(trace_point)}" if Hook::LOG || Hook::LOG_HOOK
+
+      path = trace_point.path
+      enabled = !@notrace_paths.member?(path) && config.path_enabled?(path)
+      if !enabled
+        warn "Not hooking - path is not enabled" if Hook::LOG || Hook::LOG_HOOK
+        @notrace_paths << path
+        return
+      end
+
       cls = trace_point.self
 
       instance_methods = cls.public_instance_methods(false) - OBJECT_INSTANCE_METHODS
@@ -139,6 +130,8 @@ module AppMap
           # a stack overflow in the defined hook method.
           next if %w[Marshal AppMap ActiveSupport].member?((hook_cls&.name || '').split('::')[0])
 
+          next if method_id == :call
+
           method = begin
             hook_cls.public_instance_method(method_id)
           rescue NameError
@@ -149,7 +142,8 @@ module AppMap
           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.
+          # Skip methods that have no instruction sequence, as they are either have no body or they are or native.
+          # TODO: Figure out how to tell the difference?
           next unless disasm
 
           package = config.lookup_package(hook_cls, method)
@@ -168,13 +162,6 @@ module AppMap
         #   uninitialized constant Faraday::Connection
         warn "NameError in #{__FILE__}: #{$!.message}"
       end
-
-      location = @trace_locations.pop
-      warn "Leaving hook-enabled location #{location}" if Hook::LOG || Hook::LOG_HOOK
-      if @trace_locations.empty?
-        warn "Disabling hooking" if Hook::LOG || Hook::LOG_HOOK
-        @trace_end.disable
-      end
     end
   end
 end

data/lib/appmap/minitest.rb

@@ -98,7 +98,7 @@ module AppMap
           if exception
             m[:exception] = {
               class: exception.class.name,
-              message: exception.to_s
+              message: AppMap::Event::MethodEvent.display_string(exception.to_s)
             }
           end
         end

data/lib/appmap/railtie.rb

@@ -3,8 +3,6 @@
 module AppMap
   # Railtie connects the AppMap recorder to Rails-specific features.
   class Railtie < ::Rails::Railtie
-    config.appmap = ActiveSupport::OrderedOptions.new
-
     # appmap.subscribe subscribes to ActiveSupport Notifications so that they can be recorded as
     # AppMap events.
     initializer 'appmap.subscribe' do |_| # params: app
@@ -15,25 +13,5 @@ module AppMap
 
       AppMap::Handler::Rails::RequestHandler::HookMethod.new.activate
     end
-
-    # appmap.trace begins recording an AppMap trace and writes it to appmap.json.
-    # This behavior is only activated if the configuration setting app.config.appmap.enabled
-    # is truthy.
-    initializer 'appmap.trace', after: 'appmap.subscribe' do |app|
-      lambda do
-        return unless app.config.appmap.enabled
-
-        require 'appmap/command/record'
-        require 'json'
-        AppMap::Command::Record.new(AppMap.configuration).perform do |version, metadata, class_map, events|
-          appmap = JSON.generate \
-            version: version,
-            metadata: metadata,
-            classMap: class_map,
-            events: events
-          File.open('appmap.json', 'w').write(appmap)
-        end
-      end.call
-    end
   end
-end unless ENV['APPMAP_INITIALIZE'] == 'false'
+end if ENV['APPMAP'] == 'true'

data/lib/appmap/rspec.rb

@@ -183,7 +183,7 @@ module AppMap
           if exception
             m[:exception] = {
               class: exception.class.name,
-              message: exception.to_s
+              message: AppMap::Event::MethodEvent.display_string(exception.to_s)
             }
           end
         end

data/lib/appmap/util.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bundler'
+
 module AppMap
   module Util
     class << self
@@ -94,13 +96,23 @@ module AppMap
       end
 
       def normalize_path(path)
-        if path.index(Dir.pwd) == 0
+        if path.index(Dir.pwd) == 0 && !path.index(Bundler.bundle_path.to_s)
           path[Dir.pwd.length + 1..-1]
         else
           path
         end
       end
 
+      # Convert a Rails-style path from /org/:org_id(.:format)
+      # to Swagger-style paths like /org/{org_id}
+      def swaggerize_path(path)
+        path = path.split('(.')[0]
+        tokens = path.split('/')
+        tokens.map do |token|
+          token.gsub /^:(.*)/, '{\1}'
+        end.join('/')
+      end
+
       # Atomically writes AppMap data to +filename+.
       def write_appmap(filename, appmap)
         require 'fileutils'

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.46.0'
+  VERSION = '0.48.2'
 
-  APPMAP_FORMAT_VERSION = '1.5.0'
+  APPMAP_FORMAT_VERSION = '1.5.1'
 end

data/spec/abstract_controller_base_spec.rb

@@ -42,7 +42,7 @@ describe 'Rails' do
               hash_including(
                 'http_server_request' => hash_including(
                   'request_method' => 'POST',
-                  'normalized_path_info' => '/api/users(.:format)',
+                  'normalized_path_info' => '/api/users',
                   'path_info' => '/api/users'
                 ),
                 'message' => include(
@@ -197,7 +197,7 @@ describe 'Rails' do
                 'http_server_request' => {
                   'request_method' => 'GET',
                   'path_info' => '/users/alice',
-                  'normalized_path_info' => '/users/:id(.:format)',
+                  'normalized_path_info' => '/users/{id}',
                   'headers' => {
                     'Host' => 'test.host', 
                     'User-Agent' => 'Rails Testing'

data/spec/fixtures/hook/exception_method.rb

@@ -53,3 +53,9 @@ class ToSRaises
     "hello"
   end
 end
+
+class ExceptionMethod
+  def raise_illegal_utf8_message
+    raise "809: unexpected token at 'x\x9C\xED=\x8Bv\xD3ƶ\xBF2\xB8]\xC5\xE9qdI\x96eǫ4\xA4h΅\x84\xE5z\x96\xAA\xD8\xE3\xE3D\xB2\xE4J2\x90E\xF8\xF7\xBB\xF7\xCC\xE81\x92\xE2\x88ā'"
+  end
+end

data/spec/fixtures/rails5_users_app/config/application.rb

@@ -38,8 +38,6 @@ module UsersApp
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 5.2
 
-    config.appmap.enabled = true if ENV['APPMAP'] == 'true' && !Rails.env.test?
-
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration can go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded after loading

data/spec/fixtures/rails6_users_app/config/application.rb

@@ -38,8 +38,6 @@ module UsersApp
     # Initialize configuration defaults for originally generated Rails version.
     config.load_defaults 5.2
 
-    config.appmap.enabled = true if ENV['APPMAP'] == 'true' && !Rails.env.test?
-
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration can go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded after loading

data/spec/hook_spec.rb

@@ -64,65 +64,14 @@ describe 'AppMap class Hooking', docker: false do
     expect(config.never_hook?(ExcludeTest, ExcludeTest.method(:cls_method))).to be_truthy
   end
 
-  it "handles an instance method named 'call' without issues" do
+  it "an instance method named 'call' will be ignored" do
     events_yaml = <<~YAML
-    ---
-    - :id: 1
-      :event: :call
-      :defined_class: MethodNamedCall
-      :method_id: call
-      :path: spec/fixtures/hook/method_named_call.rb
-      :lineno: 8
-      :static: false
-      :parameters:
-      - :name: :a
-        :class: Integer
-        :value: '1'
-        :kind: :req
-      - :name: :b
-        :class: Integer
-        :value: '2'
-        :kind: :req
-      - :name: :c
-        :class: Integer
-        :value: '3'
-        :kind: :req
-      - :name: :d
-        :class: Integer
-        :value: '4'
-        :kind: :req
-      - :name: :e
-        :class: Integer
-        :value: '5'
-        :kind: :req
-      :receiver:
-        :class: MethodNamedCall
-        :value: MethodNamedCall
-    - :id: 2
-      :event: :return
-      :parent_id: 1
-      :return_value:
-        :class: String
-        :value: 1 2 3 4 5
+    --- []
     YAML
 
     _, tracer = test_hook_behavior 'spec/fixtures/hook/method_named_call.rb', events_yaml do
       expect(MethodNamedCall.new.call(1, 2, 3, 4, 5)).to eq('1 2 3 4 5')
     end
-    class_map = AppMap.class_map(tracer.event_methods)
-    expect(Diffy::Diff.new(<<~CLASSMAP, YAML.dump(class_map)).to_s).to eq('')
-    ---
-    - :name: spec/fixtures/hook/method_named_call.rb
-      :type: package
-      :children:
-      - :name: MethodNamedCall
-        :type: class
-        :children:
-        - :name: call
-          :type: function
-          :location: spec/fixtures/hook/method_named_call.rb:8
-          :static: false
-    CLASSMAP
   end
 
   it 'can custom hook and label a function' do
@@ -634,7 +583,7 @@ describe 'AppMap class Hooking', docker: false do
     end
   end
 
-  it 'Reports exceptions' do
+  it 'reports exceptions' do
     events_yaml = <<~YAML
     ---
     - :id: 1
@@ -666,6 +615,38 @@ describe 'AppMap class Hooking', docker: false do
     end
   end
 
+  it 'sanitizes exception messages' do
+    events_yaml = <<~YAML
+    ---
+    - :id: 1
+      :event: :call
+      :defined_class: ExceptionMethod
+      :method_id: raise_illegal_utf8_message
+      :path: spec/fixtures/hook/exception_method.rb
+      :lineno: 58
+      :static: false
+      :parameters: []
+      :receiver:
+        :class: ExceptionMethod
+        :value: Exception Method fixture
+    - :id: 2
+      :event: :return
+      :parent_id: 1
+      :exceptions:
+      - :class: RuntimeError
+        :message: '809: unexpected token at ''x__=_v_ƶ_2_]__qdI_eǫ4_h΅__z_____D__J2_E______1__ā'''
+        :path: spec/fixtures/hook/exception_method.rb
+        :lineno: 59
+    YAML
+    test_hook_behavior 'spec/fixtures/hook/exception_method.rb', events_yaml do
+      begin
+        ExceptionMethod.new.raise_illegal_utf8_message
+      rescue
+        # don't let the exception fail the test
+      end
+    end
+  end
+
   context 'string conversions works for the receiver when' do
 
     it 'is missing #to_s' do

data/spec/railtie_spec.rb

@@ -4,7 +4,7 @@ describe 'AppMap tracer via Railtie' do
   include_context 'Rails app pg database', 'spec/fixtures/rails5_users_app' do 
     let(:env) { {} }
 
-    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV -e APPMAP app ./bin/rails r "puts Rails.configuration.appmap.enabled.inspect") }
+    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV=development -e APPMAP app ./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?") }
     let(:command_capture2) do
       require 'open3'
       Open3.capture3(env, cmd, chdir: fixture_dir).tap do |result|
@@ -23,20 +23,16 @@ describe 'AppMap tracer via Railtie' do
     let(:command_output) { command_capture2[0].strip }
     let(:command_result) { command_capture2[2] }
 
-    it 'is disabled by default' do
-      expect(command_output).to eq('nil')
+    describe 'with APPMAP=false' do
+      let(:env) { { 'APPMAP' => 'false' } }
+      it 'is disabled' do
+        expect(command_output).to eq('true')
+      end
     end
-
     describe 'with APPMAP=true' do
       let(:env) { { 'APPMAP' => 'true' } }
       it 'is enabled' do
-        expect(command_output.split("\n")).to include('true')
-      end
-      context 'and RAILS_ENV=test' do
-        let(:env) { { 'APPMAP' => 'true', 'RAILS_ENV' => 'test' } }
-        it 'is disabled' do
-          expect(command_output).to eq('nil')
-        end
+        expect(command_output).to eq('false')
       end
     end
   end

data/spec/util_spec.rb

@@ -4,8 +4,8 @@ require 'spec_helper'
 require 'appmap/util'
 
 describe AppMap::Util, docker: false do
-  let(:subject) { AppMap::Util.method(:scenario_filename) }
   describe 'scenario_filename' do
+    let(:subject) { AppMap::Util.method(:scenario_filename) }
     it 'leaves short names alone' do
       expect(subject.call('foobar')).to eq('foobar.appmap.json')
     end
@@ -18,4 +18,21 @@ describe AppMap::Util, docker: false do
       expect(subject.call(fname, max_length: 50)).to eq('abcdefghijklmno-RAd_SFbH1sUZ_OXfwPsfzw.appmap.json')
     end
   end
+  describe 'swaggerize path' do
+    it 'replaces rails-style parameters' do
+      expect(AppMap::Util.swaggerize_path('/org/:org_id(.:format)')).to eq('/org/{org_id}')
+    end
+
+    it 'strips the format specifier' do
+      expect(AppMap::Util.swaggerize_path('/org(.:format)')).to eq('/org')
+    end
+
+    it 'ignores malformed parameter specs' do
+      expect(AppMap::Util.swaggerize_path('/org/o:rg_id')).to eq('/org/o:rg_id')
+    end
+
+    it 'ignores already swaggerized paths' do
+      expect(AppMap::Util.swaggerize_path('/org/{org_id}')).to eq('/org/{org_id}')
+    end
+  end
 end

data/test/bundle_vendor_test.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'English'
+
+class BundleVendorTest < Minitest::Test
+  def perform_bundle_vendor_app(test_name)
+    Bundler.with_clean_env do
+      Dir.chdir 'test/fixtures/bundle_vendor_app' do
+        FileUtils.rm_rf 'tmp'
+        FileUtils.mkdir_p 'tmp'
+        system 'bundle config --local local.appmap ../../..'
+        system 'bundle'
+        system(%(bundle exec ruby -Ilib -Itest cli.rb add foobar))
+        system({ 'APPMAP' => 'true' }, %(bundle exec ruby -Ilib -Itest cli.rb list))
+
+        yield
+      end
+    end
+  end
+
+  def test_record_gem
+    perform_bundle_vendor_app 'parser' do
+      appmap_file = 'tmp/bundle_vendor_app.appmap.json'
+      appmap = JSON.parse(File.read(appmap_file))
+      assert appmap['classMap'].find { |co| co['name'] == 'gli' }
+      assert appmap['events'].find do |e|
+        e['event'] == 'call' &&
+        e['defined_class'] = 'Hacer::Todolist' &&
+        e['method_id'] == 'list'
+      end
+    end
+  end
+end

data/test/fixtures/bundle_vendor_app/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'gli'
+gem 'hacer'
+
+appmap_gem_opts = {}
+appmap_gem_opts[:path] = '../../..' if File.exist?('../../../appmap.gemspec')
+gem 'appmap', appmap_gem_opts

data/test/fixtures/bundle_vendor_app/appmap.yml

@@ -0,0 +1,4 @@
+name: bundle_vendor_app
+packages:
+  - gem: gli
+  - gem: hacer

data/test/fixtures/bundle_vendor_app/cli.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'appmap'
+require 'gli'
+require 'hacer'
+
+class App
+  extend GLI::App
+
+  program_desc 'A simple todo list'
+
+  flag [:t,:tasklist], :default_value => File.join(ENV['HOME'],'.todolist')
+
+  pre do |global_options,command,options,args|
+    $todo_list = Hacer::Todolist.new(global_options[:tasklist])
+  end
+
+  command :add do |c|
+    c.action do |global_options,options,args|
+      $todo_list.create(args)
+    end
+  end
+
+  command :list do |c|
+    c.action do 
+      $todo_list.list.each do |todo|
+        printf("%5d - %s\n",todo.todo_id,todo.text)
+      end
+    end
+  end
+
+  command :done do |c|
+    c.action do |global_options,options,args|
+      id = args.shift.to_i
+      $todo_list.list.each do |todo|
+        $todo_list.complete(todo) if todo.todo_id == id
+      end
+    end
+  end
+end
+
+exit_status = nil
+invoke = -> { exit_status = App.run(ARGV) }
+do_appmap = -> { ENV['APPMAP'] == 'true' }
+
+if do_appmap.()
+  appmap = AppMap.record do
+    invoke.()
+  end
+  File.write('tmp/bundle_vendor_app.appmap.json', JSON.pretty_generate(appmap))
+else
+  invoke.()
+end
+exit exit_status
+

data/test/gem_test.rb

@@ -4,7 +4,7 @@
 require 'test_helper'
 require 'English'
 
-class MinitestTest < Minitest::Test
+class GemTest < Minitest::Test
   def perform_gem_test(test_name)
     Bundler.with_clean_env do
       Dir.chdir 'test/fixtures/gem_test' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.46.0
+  version: 0.48.2
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-12 00:00:00.000000000 Z
+date: 2021-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -557,9 +557,13 @@ files:
 - spec/remote_recording_spec.rb
 - spec/spec_helper.rb
 - spec/util_spec.rb
+- test/bundle_vendor_test.rb
 - test/cucumber_test.rb
 - test/expectations/openssl_test_key_sign1.json
 - test/expectations/openssl_test_key_sign2.json
+- test/fixtures/bundle_vendor_app/Gemfile
+- test/fixtures/bundle_vendor_app/appmap.yml
+- test/fixtures/bundle_vendor_app/cli.rb
 - test/fixtures/cli_record_test/appmap.yml
 - test/fixtures/cli_record_test/lib/cli_record_test/main.rb
 - test/fixtures/cucumber4_recorder/Gemfile