appmap 0.43.0 → 0.47.0

data/lib/appmap/trace.rb

@@ -2,14 +2,36 @@
 
 module AppMap
   module Trace
-    class ScopedMethod < SimpleDelegator
-      attr_reader :package, :defined_class, :static
+    class RubyMethod
+      attr_reader :class_name, :static
 
-      def initialize(package, defined_class, method, static)
+      def initialize(package, class_name, method, static)
         @package = package
-        @defined_class = defined_class
+        @class_name = class_name
+        @method = method
         @static = static
-        super(method)
+      end
+
+      def source_location
+        @method.source_location
+      end
+
+      def comment
+        @method.comment
+      rescue MethodSource::SourceNotFoundError
+        nil
+      end
+
+      def package
+        @package.name
+      end
+
+      def name
+        @method.name
+      end
+
+      def labels
+        @package.labels
       end
     end
 
@@ -43,6 +65,12 @@ module AppMap
         end
       end
 
+      def record_method(method)
+        @tracers.each do |tracer|
+          tracer.record_method(method)
+        end
+      end
+
       def delete(tracer)
         return unless @tracers.member?(tracer)
 
@@ -82,10 +110,23 @@ module AppMap
 
       @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event
-      @methods << Trace::ScopedMethod.new(package, defined_class, method, event.static) \
+      static = event.static if event.respond_to?(:static)
+      @methods << Trace::RubyMethod.new(package, defined_class, method, static) \
         if package && defined_class && method && (event.event == :call)
     end
 
+    # +method+ should be duck-typed to respond to the following:
+    # * package
+    # * defined_class
+    # * name
+    # * static
+    # * comment
+    # * labels
+    # * source_location
+    def record_method(method)
+      @methods << method
+    end
+
     # Gets the last package which was observed on the current thread.
     def last_package_for_current_thread
       @last_package_for_thread[Thread.current.object_id]

data/lib/appmap/util.rb

@@ -61,8 +61,16 @@ module AppMap
         delete_object_id = ->(obj) { (obj || {}).delete(:object_id) }
         delete_object_id.call(event[:receiver])
         delete_object_id.call(event[:return_value])
-        (event[:parameters] || []).each(&delete_object_id)
-        (event[:exceptions] || []).each(&delete_object_id)
+        %i[parameters exceptions message].each do |field|
+          (event[field] || []).each(&delete_object_id)
+        end
+        %i[http_client_request http_client_response http_server_request http_server_response].each do |field|
+          headers = event.dig(field, :headers)
+          next unless headers
+
+          headers['Date'] = '<instanceof date>' if headers['Date']
+          headers['Server'] = headers['Server'].match(/^(\w+)/)[0] if headers['Server']
+        end
 
         case event[:event]
         when :call
@@ -71,6 +79,53 @@ module AppMap
 
         event
       end
+
+      def select_headers(env)
+        # Rack prepends HTTP_ to all client-sent headers.
+        matching_headers = env
+          .select { |k,v| k.start_with? 'HTTP_'}
+          .reject { |k,v| v.blank? }
+          .each_with_object({}) do |kv, memo|
+            key = kv[0].sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+            value = kv[1]
+            memo[key] = value
+          end
+        matching_headers.blank? ? nil : matching_headers
+      end
+
+      def normalize_path(path)
+        if path.index(Dir.pwd) == 0
+          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'
+        require 'tmpdir'
+
+        # This is what Ruby Tempfile does; but we don't want the file to be unlinked.
+        mode = File::RDWR | File::CREAT | File::EXCL
+        ::Dir::Tmpname.create([ 'appmap_', '.json' ]) do |tmpname|
+          tempfile = File.open(tmpname, mode)
+          tempfile.write(appmap)
+          tempfile.close
+          # Atomically move the tempfile into place.
+          FileUtils.mv tempfile.path, filename
+        end
+      end
     end
   end
 end

data/lib/appmap/version.rb

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

data/package-lock.json

@@ -551,9 +551,9 @@
       }
     },
     "lodash": {
-      "version": "4.17.19",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.19.tgz",
-      "integrity": "sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ=="
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
     },
     "longest": {
       "version": "1.0.1",

data/release.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# using bash wrapper as Rake blows up in `require/extentiontask` (line 10)
+
+RELEASE_FLAGS=""
+if [ ! -z "$TRAVIS_REPO_SLUG" ]; then
+    RELEASE_FLAGS="-r git+https://github.com/${TRAVIS_REPO_SLUG}.git"
+fi 
+
+if [ ! -z "$GEM_ALTERNATIVE_NAME" ]; then
+    echo "Release: GEM_ALTERNATIVE_NAME=$GEM_ALTERNATIVE_NAME"
+else
+    echo "No GEM_ALTERNATIVE_NAME is provided, releasing gem with default name ('appmap')"
+fi
+
+set -x
+exec semantic-release $RELEASE_FLAGS
+

data/spec/abstract_controller_base_spec.rb

@@ -27,6 +27,8 @@ describe 'Rails' do
       end
 
       let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
+      let(:appmap_json_path) { File.join(tmpdir, 'appmap/rspec', appmap_json_file) }
+      let(:appmap) { JSON.parse File.read(appmap_json_path) }
       let(:events) { appmap['events'] }
 
       describe 'an API route' do
@@ -35,16 +37,12 @@ describe 'Rails' do
             'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json'
           end
 
-          it 'inventory file is printed' do
-            expect(File).to exist(File.join(tmpdir, 'appmap/rspec/Inventory.appmap.json'))
-          end
-
           it 'http_server_request is recorded in the appmap' do
             expect(events).to include(
               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(
@@ -69,8 +67,8 @@ describe 'Rails' do
             expect(events).to include(
               hash_including(
                 'http_server_response' => hash_including(
-                  'status' => 201,
-                  'mime_type' => 'application/json; charset=utf-8'
+                  'status_code' => 201,
+                  'mime_type' => 'application/json; charset=utf-8',
                 )
               )
             )
@@ -146,7 +144,49 @@ describe 'Rails' do
       end
 
       describe 'a UI route' do
-        describe 'rendering a page' do
+        describe 'rendering a page using a template file' do
+          let(:appmap_json_file) do
+            'UsersController_GET_users_lists_the_users.appmap.json'
+          end
+
+          it 'records the template file' do
+            expect(events).to include hash_including(
+              'event' => 'call',
+              'defined_class' => 'app_views_users_index_html_haml',
+              'method_id' => 'render',
+              'path' => 'app/views/users/index.html.haml'
+            )
+
+            expect(appmap['classMap']).to include hash_including(
+              'name' => 'app/views',
+              'children' => include(hash_including(
+                'name' => 'app_views_users_index_html_haml',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'app/views/users/index.html.haml',
+                  'static' => true,
+                  'labels' => [ 'mvc.template' ]
+                ))
+              ))
+            )
+            expect(appmap['classMap']).to include hash_including(
+              'name' => 'app/views',
+              'children' => include(hash_including(
+                'name' => 'app_views_layouts_application_html_haml',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'app/views/layouts/application.html.haml',
+                  'static' => true,
+                  'labels' => [ 'mvc.template' ]
+                ))
+              ))
+            )
+          end
+        end
+
+        describe 'rendering a page using a text template' do
           let(:appmap_json_file) do
             'UsersController_GET_users_login_shows_the_user.appmap.json'
           end
@@ -157,25 +197,46 @@ 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'
+                  }
                 }
               )
             )
           end
 
+          it 'ignores the text template' do
+            expect(events).to_not include hash_including(
+              'event' => 'call',
+              'method_id' => 'render',
+              'render_template' => anything
+            )
+
+            expect(appmap['classMap']).to_not include hash_including(
+              'name' => 'views',
+              'children' => include(hash_including(
+                'name' => 'ViewTemplate',
+                'children' => include(hash_including(
+                  'name' => 'render',
+                  'type' => 'function',
+                  'location' => 'text template'
+                ))
+              ))
+            )
+          end
+
           it 'records and labels view rendering' do
             expect(events).to include hash_including(
               'event' => 'call',
               'thread_id' => Numeric,
-              'defined_class' => 'ActionView::Renderer',
-              'method_id' => 'render',
-              'path' => String,
-              'lineno' => Integer,
-              'static' => false
+              'defined_class' => 'inline_template',
+              'method_id' => 'render'
             )
   
             expect(appmap['classMap']).to include hash_including(
-              'name' => 'action_view',
+              'name' => 'actionview',
               'children' => include(hash_including(
                 'name' => 'ActionView',
                 'children' => include(hash_including(

data/spec/class_map_spec.rb

@@ -4,18 +4,10 @@ require 'spec_helper'
 
 describe 'AppMap::ClassMap' do
   describe '.build_from_methods' do
-    it 'includes source code if available' do
-      map = AppMap.class_map([scoped_method(method(:test_method))])
+    it 'includes method comment' do
+      map = AppMap.class_map([ruby_method((method :test_method))])
       function = dig_map(map, 5)[0]
-      expect(function[:source]).to include 'test method body'
-      expect(function[:comment]).to include 'test method comment'
-    end
-
-    it 'can omit source code even if available' do
-      map = AppMap.class_map([scoped_method((method :test_method))], include_source: false)
-      function = dig_map(map, 5)[0]
-      expect(function).to_not include(:source)
-      expect(function).to_not include(:comment)
+      expect(function).to include(:comment)
     end
 
     # test method comment
@@ -23,8 +15,8 @@ describe 'AppMap::ClassMap' do
       'test method body'
     end
 
-    def scoped_method(method)
-      AppMap::Trace::ScopedMethod.new AppMap::Config::Package.new, method.receiver.class.name, method, false
+    def ruby_method(method)
+      AppMap::Trace::RubyMethod.new AppMap::Config::Package.new, method.receiver.class.name, method, false
     end
 
     def dig_map(map, depth)

data/spec/config_spec.rb

@@ -17,10 +17,42 @@ describe AppMap::Config, docker: false do
           path: 'path-2',
           exclude: [ 'exclude-1' ]
         }
+      ],
+      functions: [
+        {
+          package: 'pkg',
+          class: 'cls',
+          function: 'fn',
+          label: 'lbl'
+        }
       ]
     }.deep_stringify_keys!
     config = AppMap::Config.load(config_data)
 
-    expect(config.to_h.deep_stringify_keys!).to eq(config_data)
+    config_expectation = {
+      exclude: [],
+      name: 'test',
+      packages: [
+        {
+          path: 'path-1',
+          handler_class: 'AppMap::Handler::Function'
+        },
+        {
+          path: 'path-2',
+          handler_class: 'AppMap::Handler::Function',
+          exclude: [ 'exclude-1' ]
+        }
+      ],
+      functions: [
+        {
+          package: 'pkg',
+          class: 'cls',
+          functions: [ :fn ],
+          labels: ['lbl']
+        }
+      ]
+    }.deep_stringify_keys!
+
+    expect(config.to_h.deep_stringify_keys!).to eq(config_expectation)
   end
 end

data/spec/fixtures/hook/custom_instance_method.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CustomInstanceMethod
+  def to_s
+    'CustomInstance Method fixture'
+  end
+
+  def say_default
+    'default'
+  end
+end

data/spec/fixtures/hook/method_named_call.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class MethodNamedCall
+  def to_s
+    'MethodNamedCall'
+  end
+
+  def call(a, b, c, d, e)
+    [ a, b, c, d, e ].join(' ')
+  end
+end

data/spec/hook_spec.rb

@@ -16,14 +16,7 @@ end
 Psych::Visitors::YAMLTree.prepend(ShowYamlNulls)
 
 describe 'AppMap class Hooking', docker: false do
-  require 'appmap/util'
-  def collect_events(tracer)
-    [].tap do |events|
-      while tracer.event?
-        events << tracer.next_event.to_h
-      end
-    end.map(&AppMap::Util.method(:sanitize_event))
-  end
+  include_context 'collect events'
 
   def invoke_test_file(file, setup: nil, &block)
     AppMap.configuration = nil
@@ -64,11 +57,144 @@ describe 'AppMap class Hooking', docker: false do
   it 'excludes named classes and methods' do
     load 'spec/fixtures/hook/exclude.rb'
     package = AppMap::Config::Package.build_from_path('spec/fixtures/hook/exclude.rb')
-    config = AppMap::Config.new('hook_spec', [ package ], %w[ExcludeTest])
+    config = AppMap::Config.new('hook_spec', [ package ], exclude: %w[ExcludeTest])
     AppMap.configuration = config
 
-    expect(config.never_hook?(ExcludeTest.new.method(:instance_method))).to be_truthy
-    expect(config.never_hook?(ExcludeTest.method(:cls_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.new.method(:instance_method))).to be_truthy
+    expect(config.never_hook?(ExcludeTest, ExcludeTest.method(:cls_method))).to be_truthy
+  end
+
+  it "handles an instance method named 'call' without issues" 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
+    events_yaml = <<~YAML
+    ---
+    - :id: 1
+      :event: :call
+      :defined_class: CustomInstanceMethod
+      :method_id: say_default
+      :path: spec/fixtures/hook/custom_instance_method.rb
+      :lineno: 8
+      :static: false
+      :parameters: []
+      :receiver:
+        :class: CustomInstanceMethod
+        :value: CustomInstance Method fixture
+    - :id: 2
+      :event: :return
+      :parent_id: 1
+      :return_value:
+        :class: String
+        :value: default
+    YAML
+
+    config = AppMap::Config.load({
+      functions: [
+        {
+          package: 'hook_spec',
+          class: 'CustomInstanceMethod',
+          functions: [ :say_default ],
+          labels: ['cowsay']
+        }
+      ]
+    }.deep_stringify_keys)
+
+    load 'spec/fixtures/hook/custom_instance_method.rb'
+    hook_cls = CustomInstanceMethod
+    method = hook_cls.instance_method(:say_default)
+
+    require 'appmap/hook/method'
+    package = config.lookup_package(hook_cls, method)
+    expect(package).to be
+    hook_method = AppMap::Hook::Method.new(package, hook_cls, method)
+    hook_method.activate
+
+    tracer = AppMap.tracing.trace
+    AppMap::Event.reset_id_counter
+    begin
+      expect(CustomInstanceMethod.new.say_default).to eq('default')
+    ensure
+      AppMap.tracing.delete(tracer)
+    end
+
+    events = collect_events(tracer).to_yaml
+
+    expect(Diffy::Diff.new(events_yaml, events).to_s).to eq('')
+    class_map = AppMap.class_map(tracer.event_methods)
+    expect(Diffy::Diff.new(<<~CLASSMAP, YAML.dump(class_map)).to_s).to eq('')
+    ---
+    - :name: hook_spec
+      :type: package
+      :children:
+      - :name: CustomInstanceMethod
+        :type: class
+        :children:
+        - :name: say_default
+          :type: function
+          :location: spec/fixtures/hook/custom_instance_method.rb:8
+          :static: false
+          :labels:
+          - cowsay
+    CLASSMAP
   end
 
   it 'parses labels from comments' do
@@ -91,9 +217,6 @@ describe 'AppMap class Hooking', docker: false do
           :labels:
           - has-fn-label
           :comment: "# @label has-fn-label\\n"
-          :source: |2
-              def fn_with_label
-              end
       YAML
   end
 
@@ -127,8 +250,8 @@ describe 'AppMap class Hooking', docker: false do
     _, tracer = invoke_test_file 'spec/fixtures/hook/instance_method.rb' do
       InstanceMethod.new.say_default
     end
-    expect(tracer.event_methods.to_a.map(&:defined_class)).to eq([ 'InstanceMethod' ])
-    expect(tracer.event_methods.to_a.map(&:to_s)).to eq([ InstanceMethod.public_instance_method(:say_default).to_s ])
+    expect(tracer.event_methods.to_a.map(&:class_name)).to eq([ 'InstanceMethod' ])
+    expect(tracer.event_methods.to_a.map(&:name)).to eq([ InstanceMethod.public_instance_method(:say_default).name ])
   end
 
   it 'builds a class map of invoked methods' do
@@ -148,10 +271,6 @@ describe 'AppMap class Hooking', docker: false do
           :type: function
           :location: spec/fixtures/hook/instance_method.rb:8
           :static: false
-          :source: |2
-              def say_default
-                'default'
-              end
     YAML
   end
 
@@ -744,8 +863,11 @@ describe 'AppMap class Hooking', docker: false do
       _, _, events = test_hook_behavior 'spec/fixtures/hook/compare.rb', nil do
         expect(Compare.compare('string', 'string')).to be_truthy
       end
+
       secure_compare_event = YAML.load(events).find { |evt| evt[:defined_class] == 'ActiveSupport::SecurityUtils' }
+      expect(secure_compare_event).to be_truthy
       secure_compare_event.delete(:lineno)
+      secure_compare_event.delete(:path)
 
       expect(Diffy::Diff.new(<<~YAML, secure_compare_event.to_yaml).to_s).to eq('')
       ---
@@ -753,7 +875,6 @@ describe 'AppMap class Hooking', docker: false do
       :event: :call
       :defined_class: ActiveSupport::SecurityUtils
       :method_id: secure_compare
-      :path: lib/active_support/security_utils.rb
       :static: true
       :parameters:
       - :name: :a
@@ -837,7 +958,7 @@ describe 'AppMap class Hooking', docker: false do
       entry = cm[1][:children][0][:children][0][:children][0]
       # Sanity check, make sure we got the right one
       expect(entry[:name]).to eq('secure_compare')
-      expect(entry[:labels]).to eq(%w[provider.secure_compare])
+      expect(entry[:labels]).to eq(%w[crypto.secure_compare])
     end
   end