appmap 0.31.0 → 0.34.2

data/lib/appmap/cucumber.rb

@@ -4,6 +4,8 @@ require 'appmap/util'
 
 module AppMap
   module Cucumber
+    APPMAP_OUTPUT_DIR = 'tmp/appmap/cucumber'
+    
     ScenarioAttributes = Struct.new(:name, :feature, :feature_group)
 
     ProviderStruct = Struct.new(:scenario) do
@@ -38,18 +40,27 @@ module AppMap
     end
 
     class << self
+      def init
+        warn 'Configuring AppMap recorder for Cucumber'
+
+        FileUtils.mkdir_p APPMAP_OUTPUT_DIR
+      end
+      
       def write_scenario(scenario, appmap)
         appmap['metadata'] = update_metadata(scenario, appmap['metadata'])
         scenario_filename = AppMap::Util.scenario_filename(appmap['metadata']['name'])
 
-        FileUtils.mkdir_p 'tmp/appmap/cucumber'
-        File.write(File.join('tmp/appmap/cucumber', scenario_filename), JSON.generate(appmap))
+        File.write(File.join(APPMAP_OUTPUT_DIR, scenario_filename), JSON.generate(appmap))
       end
 
       def enabled?
         ENV['APPMAP'] == 'true'
       end
 
+      def run
+        init
+      end
+      
       protected
 
       def cucumber_version
@@ -87,3 +98,9 @@ module AppMap
     end
   end
 end
+
+if AppMap::Cucumber.enabled?
+  require 'appmap'
+
+  AppMap::Cucumber.run
+end

data/lib/appmap/event.rb

@@ -15,21 +15,15 @@ module AppMap
       end
     end
 
-    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :thread_id)
+    MethodEventStruct = Struct.new(:id, :event, :thread_id)
 
     class MethodEvent < MethodEventStruct
       LIMIT = 100
 
       class << self
-        def build_from_invocation(me, event_type, defined_class, method)
+        def build_from_invocation(me, event_type)
           me.id = AppMap::Event.next_id_counter
           me.event = event_type
-          me.defined_class = defined_class
-          me.method_id = method.name.to_s
-          path = method.source_location[0]
-          path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
-          me.path = path
-          me.lineno = method.source_location[1]
           me.thread_id = Thread.current.object_id
         end
 
@@ -58,15 +52,25 @@ module AppMap
           (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
         end
       end
-
     end
 
     class MethodCall < MethodEvent
-      attr_accessor :parameters, :receiver, :static
+      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)
           mc.tap do
+            static = receiver.is_a?(Module)
+            mc.defined_class = defined_class
+            mc.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]
+            else
+              mc.path = [ defined_class, static ? '.' : '#', method.name ].join
+            end
             mc.parameters = method.parameters.map.with_index do |method_param, idx|
               param_type, param_name = method_param
               param_name ||= 'arg'
@@ -84,17 +88,22 @@ module AppMap
               object_id: receiver.__id__,
               value: display_string(receiver)
             }
-            mc.static = receiver.is_a?(Module)
-            MethodEvent.build_from_invocation(mc, :call, defined_class, method)
+            mc.static = static
+            MethodEvent.build_from_invocation(mc, :call)
           end
         end
       end
 
       def to_h
         super.tap do |h|
+          h[:defined_class] = defined_class
+          h[:method_id] = method_id
+          h[:path] = path
+          h[:lineno] = lineno
           h[:static] = static
           h[:parameters] = parameters
           h[:receiver] = receiver
+          h.delete_if { |_, v| v.nil? }
         end
       end
 
@@ -105,11 +114,11 @@ module AppMap
       attr_accessor :parent_id, :elapsed
 
       class << self
-        def build_from_invocation(mr = MethodReturnIgnoreValue.new, defined_class, method, parent_id, elapsed)
+        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, defined_class, method)
+            MethodEvent.build_from_invocation(mr, :return)
           end
         end
       end
@@ -126,7 +135,7 @@ module AppMap
       attr_accessor :return_value, :exceptions
 
       class << self
-        def build_from_invocation(mr = MethodReturn.new, defined_class, method, parent_id, elapsed, return_value, exception)
+        def build_from_invocation(mr = MethodReturn.new, parent_id, elapsed, return_value, exception)
           mr.tap do |_|
             if return_value
               mr.return_value = {
@@ -152,7 +161,7 @@ module AppMap
 
               mr.exceptions = exceptions
             end
-            MethodReturnIgnoreValue.build_from_invocation(mr, defined_class, method, parent_id, elapsed)
+            MethodReturnIgnoreValue.build_from_invocation(mr, parent_id, elapsed)
           end
         end
       end

data/lib/appmap/hook.rb

@@ -4,27 +4,20 @@ require 'English'
 
 module AppMap
   class Hook
-    LOG = false
-
-    HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+    LOG = (ENV['DEBUG'] == 'true')
 
     class << self
+      def lock_builtins
+        return if @builtins_hooked
+
+        @builtins_hooked = true
+      end
+
       # Return the class, separator ('.' or '#'), and method name for
       # the given method.
       def qualify_method_name(method)
         if method.owner.singleton_class?
-          # Singleton class names can take two forms:
-          # #<Class:Foo> or
-          # #<Class:#<Bar:0x0123ABC>>. Retrieve the name of
-          # the class from the string.
-          # 
-          # (There really isn't a better way to do this. The
-          # singleton's reference to the class it was created
-          # from is stored in an instance variable named
-          # '__attached__'. It doesn't have the '@' prefix, so
-          # it's internal only, and not accessible from user
-          # code.)
-          class_name = /#<Class:((#<(?<cls>.*?):)|((?<cls>.*?)>))/.match(method.owner.to_s)['cls']
+          class_name = singleton_method_owner_name(method)
           [ class_name, '.', method.name ]
         else
           [ method.owner.name, '#', method.name ]
@@ -39,92 +32,74 @@ module AppMap
 
     # Observe class loading and hook all methods which match the config.
     def enable &block
-      before_hook = lambda do |defined_class, method, receiver, args|
-        require 'appmap/event'
-        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, method, receiver, args)
-        AppMap.tracing.record_event call_event, defined_class: defined_class, method: method
-        [ call_event, Time.now ]
-      end
-
-      after_hook = lambda do |call_event, defined_class, method, start_time, return_value, exception|
-        require 'appmap/event'
-        elapsed = Time.now - start_time
-        return_event = AppMap::Event::MethodReturn.build_from_invocation \
-                                                     defined_class, method, call_event.id, elapsed, return_value, exception
-        AppMap.tracing.record_event return_event
-      end
+      require 'appmap/hook/method'
 
-      with_disabled_hook = lambda do |&fn|
-        # Don't record functions, such as to_s and inspect, that might be called
-        # by the fn. Otherwise there can be a stack overflow.
-        Thread.current[HOOK_DISABLE_KEY] = true
-        begin
-          fn.call
-        ensure
-          Thread.current[HOOK_DISABLE_KEY] = false
-        end
-      end
+      hook_builtins
 
-      tp = TracePoint.new(:end) do |tp|
-        hook = self
-        cls = tp.self
+      tp = TracePoint.new(:end) do |trace_point|
+        cls = trace_point.self
 
         instance_methods = cls.public_instance_methods(false)
         class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
 
-        hook_method = lambda do |cls|
+        hook = lambda do |hook_cls|
           lambda do |method_id|
-            next if method_id.to_s =~ /_hooked_by_appmap$/
+            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
 
-            method = cls.public_instance_method(method_id)
             disasm = RubyVM::InstructionSequence.disasm(method)
             # Skip methods that have no instruction sequence, as they are obviously trivial.
             next unless disasm
 
-            defined_class, method_symbol, method_name = Hook.qualify_method_name(method)
-            method_display_name = [defined_class, method_symbol, method_name].join
-
             # Don't try and trace the AppMap methods or there will be
             # a stack overflow in the defined hook method.
-            next if /\AAppMap[:\.]/.match?(method_display_name) 
+            next if /\AAppMap[:\.]/.match?(hook_method.method_display_name)
 
             next unless \
-              config.always_hook?(defined_class, method_name) ||
+              config.always_hook?(hook_cls, method.name) ||
               config.included_by_location?(method)
 
-            warn "AppMap: Hooking #{method_display_name}" if LOG
-
-            cls.define_method method_id do |*args, &block|
-              base_method = method.bind(self).to_proc
-
-              hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-              enabled = true if !hook_disabled && AppMap.tracing.enabled?
-              return base_method.call(*args, &block) unless enabled
-
-              call_event, start_time = with_disabled_hook.call do
-                before_hook.call(defined_class, method, self, args)
-              end
-              return_value = nil
-              exception = nil
-              begin
-                return_value = base_method.call(*args, &block)
-              rescue
-                exception = $ERROR_INFO
-                raise
-              ensure
-                with_disabled_hook.call do
-                  after_hook.call(call_event, defined_class, method, start_time, return_value, exception)
-                end
-              end
-            end
+            hook_method.activate
           end
         end
 
-        instance_methods.each(&hook_method.call(cls))
-        class_methods.each(&hook_method.call(cls.singleton_class))
+        instance_methods.each(&hook.(cls))
+        class_methods.each(&hook.(cls.singleton_class))
       end
 
       tp.enable(&block)
     end
+
+    def hook_builtins
+      return unless self.class.lock_builtins
+
+      class_from_string = lambda do |fq_class|
+        fq_class.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
+
+      Config::BUILTIN_METHODS.each do |class_name, hook|
+        require hook.package.package_name if hook.package.package_name
+        Array(hook.method_names).each do |method_name|
+          method_name = method_name.to_sym
+          cls = class_from_string.(class_name)
+          method = \
+            begin
+              cls.instance_method(method_name)
+            rescue NameError
+              cls.method(method_name) rescue nil
+            end
+
+          if method
+            Hook::Method.new(cls, method).activate
+          else
+            warn "Method #{method_name} not found on #{cls.name}" 
+          end
+        end
+      end
+    end
   end
 end

data/lib/appmap/hook/method.rb

@@ -0,0 +1,103 @@
+module AppMap
+  class Hook
+    class Method
+      attr_reader :hook_class, :hook_method
+
+      # +method_display_name+ may be nil if name resolution gets
+      # deferred until runtime (e.g. for a singleton method on an
+      # embedded Struct).
+      attr_reader :method_display_name
+
+      HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+      private_constant :HOOK_DISABLE_KEY
+
+      # Grab the definition of Time.now here, to avoid interfering
+      # with the method we're hooking.
+      TIME_NOW = Time.method(:now)
+      private_constant :TIME_NOW
+      
+      def initialize(hook_class, hook_method)
+        @hook_class = hook_class
+        @hook_method = hook_method
+
+        # Get the class for the method, if it's known.
+        @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
+        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join if @defined_class
+      end
+
+      def activate
+        if Hook::LOG
+          msg = if method_display_name
+                  "#{method_display_name}"
+                else
+                  "#{hook_method.name} (class resolution deferrred)"
+                end
+          warn "AppMap: Hooking " + msg
+        end
+
+        defined_class = @defined_class
+        hook_method = self.hook_method
+        before_hook = self.method(:before_hook)
+        after_hook = self.method(:after_hook)
+        with_disabled_hook = self.method(:with_disabled_hook)
+
+        hook_class.define_method hook_method.name do |*args, &block|
+          instance_method = hook_method.bind(self).to_proc
+
+          # We may not have gotten the class for the method during
+          # initialization (e.g. for a singleton method on an embedded
+          # struct), so make sure we have it now.
+          defined_class,_ = Hook.qualify_method_name(hook_method) unless defined_class
+
+          hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+          enabled = true if !hook_disabled && AppMap.tracing.enabled?
+          return instance_method.call(*args, &block) unless enabled
+
+          call_event, start_time = with_disabled_hook.() do
+            before_hook.(self, defined_class, args)
+          end
+          return_value = nil
+          exception = nil
+          begin
+            return_value = instance_method.(*args, &block)
+          rescue
+            exception = $ERROR_INFO
+            raise
+          ensure
+            with_disabled_hook.() do
+              after_hook.(call_event, start_time, return_value, exception)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def before_hook(receiver, defined_class, args)
+        require 'appmap/event'
+        call_event = AppMap::Event::MethodCall.build_from_invocation(defined_class, hook_method, receiver, args)
+        AppMap.tracing.record_event call_event, defined_class: defined_class, method: hook_method
+        [ call_event, TIME_NOW.call ]
+      end
+
+      def after_hook(call_event, start_time, return_value, exception)
+        require 'appmap/event'
+        elapsed = TIME_NOW.call - start_time
+        return_event = \
+          AppMap::Event::MethodReturn.build_from_invocation call_event.id, elapsed, return_value, exception
+        AppMap.tracing.record_event return_event
+      end
+
+      def with_disabled_hook(&fn)
+        # Don't record functions, such as to_s and inspect, that might be called
+        # by the fn. Otherwise there can be a stack overflow.
+        Thread.current[HOOK_DISABLE_KEY] = true
+        begin
+          fn.call
+        ensure
+          Thread.current[HOOK_DISABLE_KEY] = false
+        end
+      end
+    end
+  end
+end

data/lib/appmap/open.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AppMap
+  OpenStruct = Struct.new(:appmap)
+
+  class Open < OpenStruct
+    attr_reader :port
+
+    def perform
+      server = run_server
+      open_browser
+      server.kill
+    end
+
+    def page
+      require 'rack/utils'
+      <<~PAGE
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>&hellip;</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+        <script type="text/javascript">
+        function dosubmit() { document.forms[0].submit(); }
+        </script>
+      </head>
+      <body onload="dosubmit();">
+        <form action="https://app.land/scenario_uploads" method="POST" accept-charset="utf-8">
+        <input type="hidden" name="data" value='#{Rack::Utils.escape_html appmap.to_json}'>
+        </form>
+      </body>
+      </html>
+      PAGE
+    end
+
+    def run_server
+      require 'rack'
+      Thread.new do
+        Rack::Handler::WEBrick.run(
+          lambda do |env|
+            return [200, { 'Content-Type' => 'text/html' }, [page]]
+          end,
+          :Port => 0
+        ) do |server|
+          @port = server.config[:Port]
+        end
+      end.tap do
+        sleep 1.0
+      end
+    end
+
+    def open_browser
+      system 'open', "http://localhost:#{@port}"
+      sleep 5.0
+    end
+  end
+end