appmap 0.23.0 → 0.25.0

data/lib/appmap/command/record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AppMap
   module Command
     RecordStruct = Struct.new(:config, :program)
@@ -61,12 +63,9 @@ module AppMap
       end
 
       def perform(&block)
-        features = AppMap.inspect(config)
-        functions = features.map(&:collect_functions).flatten
-
-        require 'appmap/trace/tracer'
+        AppMap::Hook.hook(config)
 
-        tracer = AppMap::Trace.tracers.trace(functions)
+        tracer = AppMap.tracing.trace
 
         events = []
         quit = false
@@ -85,7 +84,10 @@ module AppMap
         at_exit do
           quit = true
           event_thread.join
-          yield features, events
+          yield AppMap::APPMAP_FORMAT_VERSION,
+                self.class.detect_metadata,
+                AppMap.class_map(config, tracer.event_methods),
+                events
         end
 
         load program if program

data/lib/appmap/command/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AppMap
   module Command
     StatsStruct = Struct.new(:appmap)

data/lib/appmap/command/upload.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'faraday'
 
@@ -5,13 +7,13 @@ module AppMap
   module Command
     UploadResponse = Struct.new(:batch_id, :scenario_uuid)
 
-    UploadStruct = Struct.new(:config, :data, :url, :user, :org)
+    UploadStruct = Struct.new(:data, :url, :user, :org)
     class Upload < UploadStruct
       MAX_DEPTH = 12
 
       attr_accessor :batch_id
 
-      def initialize(config, data, url, user, org)
+      def initialize(data, url, user, org)
         super
 
         # TODO: Make this an option

data/lib/appmap/event.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Event
+    @@id_counter = 0
+
+    class << self
+      # reset_id_counter is used by test cases to get consistent event ids.
+      def reset_id_counter
+        @@id_counter = 0
+      end
+
+      def next_id_counter
+        @@id_counter += 1
+      end
+    end
+
+    MethodEventStruct = Struct.new(:id, :event, :defined_class, :method_id, :path, :lineno, :static, :thread_id)
+
+    class MethodEvent < MethodEventStruct
+      LIMIT = 100
+
+      class << self
+        def build_from_invocation(me, event_type, defined_class, method)
+          singleton = method.owner.singleton_class?
+
+          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.static = singleton
+          me.thread_id = Thread.current.object_id
+        end
+
+        # Gets a display string for a value. This is not meant to be a machine deserializable value.
+        def display_string(value)
+          return nil unless value
+
+          last_resort_string = lambda do
+            warn "AppMap encountered an error inspecting a #{value.class.name}: #{$!.message}"
+            '*Error inspecting variable*'
+          end
+
+          value_string = \
+            begin
+              value.to_s
+            rescue NoMethodError
+              begin
+                value.inspect
+              rescue StandardError
+                last_resort_string.call
+              end
+            rescue StandardError
+              last_resort_string.call
+            end
+
+          (value_string||'')[0...LIMIT].encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+        end
+      end
+
+      alias static? static
+    end
+
+    class MethodCall < MethodEvent
+      attr_accessor :parameters, :receiver
+
+      class << self
+        def build_from_invocation(mc = MethodCall.new, defined_class, method, receiver, arguments)
+          mc.tap do
+            mc.parameters = method.parameters.map.with_index do |method_param, idx|
+              param_type, param_name = method_param
+              param_name ||= 'arg'
+              value = arguments[idx]
+              {
+                name: param_name,
+                class: value.class.name,
+                object_id: value.__id__,
+                value: display_string(value),
+                kind: param_type
+              }
+            end
+            mc.receiver = {
+              class: receiver.class.name,
+              object_id: receiver.__id__,
+              value: display_string(receiver)
+            }
+            MethodEvent.build_from_invocation(mc, :call, defined_class, method)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:parameters] = parameters
+          h[:receiver] = receiver
+        end
+      end
+    end
+
+    class MethodReturnIgnoreValue < MethodEvent
+      attr_accessor :parent_id, :elapsed
+
+      class << self
+        def build_from_invocation(mr = MethodReturnIgnoreValue.new, defined_class, method, parent_id, elapsed)
+          mr.tap do |_|
+            mr.parent_id = parent_id
+            mr.elapsed = elapsed
+            MethodEvent.build_from_invocation(mr, :return, defined_class, method)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:parent_id] = parent_id
+          h[:elapsed] = elapsed
+        end
+      end
+    end
+
+    class MethodReturn < MethodReturnIgnoreValue
+      attr_accessor :return_value, :exceptions
+
+      class << self
+        def build_from_invocation(mr = MethodReturn.new, defined_class, method, parent_id, elapsed, return_value, exception)
+          mr.tap do |_|
+            if return_value
+              mr.return_value = {
+                class: return_value.class.name,
+                value: display_string(return_value),
+                object_id: return_value.__id__
+              }
+            end
+            if exception
+              next_exception = exception
+              exceptions = []
+              while next_exception
+                exception_backtrace = next_exception.backtrace_locations[0]
+                exceptions << {
+                  class: next_exception.class.name,
+                  message: next_exception.message,
+                  object_id: next_exception.__id__,
+                  path: exception_backtrace&.path,
+                  lineno: exception_backtrace&.lineno
+                }.compact
+                next_exception = next_exception.cause
+              end
+
+              mr.exceptions = exceptions
+            end
+            MethodReturnIgnoreValue.build_from_invocation(mr, defined_class, method, parent_id, elapsed)
+          end
+        end
+      end
+
+      def to_h
+        super.tap do |h|
+          h[:return_value] = return_value if return_value
+          h[:exceptions] = exceptions if exceptions
+        end
+      end
+    end
+  end
+end

data/lib/appmap/hook.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module AppMap
+  class Hook
+    LOG = false
+
+    Package = Struct.new(:path, :exclude) do
+      def to_h
+        {
+          path: path,
+          exclude: exclude.blank? ? nil : exclude
+        }.compact
+      end
+    end
+
+    Config = Struct.new(:name, :packages) do
+      class << self
+        # Loads configuration data from a file, specified by the file name.
+        def load_from_file(config_file_name)
+          require 'yaml'
+          load YAML.safe_load(::File.read(config_file_name))
+        end
+
+        # Loads configuration from a Hash.
+        def load(config_data)
+          packages = (config_data['packages'] || []).map do |package|
+            Package.new(package['path'], package['exclude'] || [])
+          end
+          Config.new config_data['name'], packages
+        end
+      end
+
+      def initialize(name, packages = [])
+        super name, packages || []
+      end
+
+      def to_h
+        {
+          name: name,
+          packages: packages.map(&:to_h)
+        }
+      end
+    end
+
+    HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
+
+    class << self
+      # Observe class loading and hook all methods which match the config.
+      def hook(config = AppMap.configure)
+        package_include_paths = config.packages.map(&:path)
+        package_exclude_paths = config.packages.map do |pkg|
+          pkg.exclude.map do |exclude|
+            File.join(pkg.path, exclude)
+          end
+        end.flatten
+
+        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
+
+        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 oveflow.
+          Thread.current[HOOK_DISABLE_KEY] = true
+          begin
+            fn.call
+          ensure
+            Thread.current[HOOK_DISABLE_KEY] = false
+          end
+        end
+
+        TracePoint.trace(:end) do |tp|
+          cls = tp.self
+
+          instance_methods = cls.public_instance_methods(false)
+          class_methods = cls.singleton_class.public_instance_methods(false) - instance_methods
+
+          hook_method = lambda do |cls|
+            lambda do |method_id|
+              next if method_id.to_s =~ /_hooked_by_appmap$/
+
+              method = cls.public_instance_method(method_id)
+              location = method.source_location
+              location_file, = location
+              next unless location_file
+
+              location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+              match = package_include_paths.find { |p| location_file.index(p) == 0 }
+              match &&= !package_exclude_paths.find { |p| location_file.index(p) }
+              next unless match
+
+              disasm = RubyVM::InstructionSequence.disasm(method)
+              # Skip methods that have no instruction sequence, as they are obviously trivial.
+              next unless disasm
+
+              defined_class, method_symbol = \
+                if method.owner.singleton_class?
+                  # Singleton class name is like: #<Class:<(.*)>>
+                  class_name = method.owner.to_s['#<Class:<'.length-1..-2]
+                  [ class_name, '.' ]
+                else
+                  [ method.owner.name, '#' ]
+                end
+
+              warn "AppMap: Hooking #{defined_class}#{method_symbol}#{method.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
+                ensure
+                  with_disabled_hook.call do
+                    after_hook.call(call_event, defined_class, method, start_time, return_value, exception)
+                  end
+                end
+              end
+            end
+          end
+
+          instance_methods.each(&hook_method.call(cls))
+          class_methods.each(&hook_method.call(cls.singleton_class))
+        end
+      end
+    end
+  end
+end

data/lib/appmap/middleware/remote_recording.rb

@@ -4,17 +4,14 @@ module AppMap
   module Middleware
     # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
     class RemoteRecording
-
       def initialize(app)
         require 'appmap/command/record'
         require 'appmap/command/upload'
-        require 'appmap/trace/tracer'
-        require 'appmap/config'
         require 'json'
 
         @app = app
-        @features = AppMap.inspect(config)
-        @functions = @features.map(&:collect_functions).flatten
+        @config = AppMap.configure
+        AppMap::Hook.hook(@config)
       end
 
       def event_loop
@@ -29,23 +26,23 @@ module AppMap
       end
 
       def start_recording
-        return [ false, 'Recording is already in progress' ] if @tracer
+        return [ 409, 'Recording is already in progress' ] if @tracer
 
         @events = []
-        @tracer = AppMap::Trace.tracers.trace(@functions)
+        @tracer = AppMap.tracing.trace
         @event_thread = Thread.new { event_loop }
         @event_thread.abort_on_exception = true
 
-        [ true ]
+        [ 200 ]
       end
 
       def stop_recording(req)
-        return [ false, 'No recording is in progress' ] unless @tracer
+        return [ 404, 'No recording is in progress' ] unless @tracer
 
         tracer = @tracer
         @tracer = nil
 
-        AppMap::Trace.tracers.delete(tracer)
+        AppMap.tracing.delete(tracer)
 
         @event_thread.exit
         @event_thread.join
@@ -73,9 +70,13 @@ module AppMap
           name: 'remote_recording'
         }
 
-        response = JSON.generate(version: AppMap::APPMAP_FORMAT_VERSION, classMap: @features, metadata: metadata, events: @events)
+        response = JSON.generate \
+          version: AppMap::APPMAP_FORMAT_VERSION,
+          classMap: AppMap.class_map(@config, tracer.event_methods),
+          metadata: metadata,
+          events: @events
 
-        [ true, response ]
+        [ 200, response ]
       end
 
       def call(env)
@@ -103,20 +104,13 @@ module AppMap
             [ 404, '' ]
           end
 
-        status = 200 if status == true
-        status = 500 if status == false
-
-        [status, { 'Content-Type' => 'application/text' }, [body || '']]
+        [status, { 'Content-Type' => 'application/json' }, [body || '']]
       end
 
       def html_response?(headers)
         headers['Content-Type'] && headers['Content-Type'] =~ /html/
       end
 
-      def config
-        @config ||= AppMap::Config.load_from_file 'appmap.yml'
-      end
-
       def recording?
         !@event_thread.nil?
       end