appmap 0.23.0 → 0.27.0

data/lib/appmap/algorithm/stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AppMap
   module Algorithm
     StatsStruct = Struct.new(:appmap)
@@ -31,7 +33,7 @@ module AppMap
           comparator = ->(a,b) { b.count <=> a.count }
           class_frequency.sort!(&comparator)
           method_frequency.sort!(&comparator)
-          
+
           self
         end
 
@@ -55,7 +57,7 @@ module AppMap
         end
       end
       Frequency = Struct.new(:name, :count)
-      
+
       def perform(limit: nil)
         events = appmap['events'] || []
         frequency_calc = lambda do |key_func|

data/lib/appmap/class_map.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext'
+
+module AppMap
+  class ClassMap
+    module HasChildren
+      def self.included(base)
+        base.module_eval do
+          def children
+            @children ||= []
+          end
+        end
+      end
+    end
+
+    module Types
+      class Root
+        include HasChildren
+      end
+
+      Package = Struct.new(:name) do
+        include HasChildren
+
+        def type
+          'package'
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            children: children.map(&:to_h)
+          }
+        end
+      end
+      Class = Struct.new(:name) do
+        include HasChildren
+
+        def type
+          'class'
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            children: children.map(&:to_h)
+          }
+        end
+      end
+      Function = Struct.new(:name) do
+        attr_accessor :static, :location
+
+        def type
+          'function'
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            location: location,
+            static: static
+          }
+        end
+      end
+    end
+
+    class << self
+      def build_from_methods(config, methods)
+        root = Types::Root.new
+        methods.each do |method|
+          package = package_for_method(config.packages, method)
+          add_function root, package.path, method
+        end
+        root.children.map(&:to_h)
+      end
+
+      protected
+
+      def package_for_method(packages, method)
+        location = method.method.source_location
+        location_file, = location
+        location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+
+        packages.find do |pkg|
+          (location_file.index(pkg.path) == 0) &&
+            !pkg.exclude.find { |p| location_file.index(p) }
+        end or raise "No package found for method #{method}"
+      end
+
+      def add_function(root, package_name, method)
+        location = method.method.source_location
+        location_file, lineno = location
+        location_file = location_file[Dir.pwd.length + 1..-1] if location_file.index(Dir.pwd) == 0
+
+        static = method.method.owner.singleton_class?
+
+        object_infos = [
+          {
+            name: package_name,
+            type: 'package'
+          }
+        ]
+        object_infos += method.defined_class.split('::').map do |name|
+          {
+            name: name,
+            type: 'class'
+          }
+        end
+        object_infos << {
+          name: method.method.name,
+          type: 'function',
+          location: [ location_file, lineno ].join(':'),
+          static: static
+        }
+        parent = root
+        object_infos.each do |info|
+          parent = find_or_create parent.children, info do
+            Types.const_get(info[:type].classify).new(info[:name].to_s).tap do |type|
+              info.keys.tap do |keys|
+                keys.delete(:name)
+                keys.delete(:type)
+              end.each do |key|
+                type.send "#{key}=", info[key]
+              end
+            end
+          end
+        end
+      end
+
+      def find_or_create(list, info)
+        obj = list.find { |item| item.type == info[:type] && item.name == info[:name] }
+        return obj if obj
+
+        yield.tap do |new_obj|
+          list << new_obj
+        end
+      end
+    end
+  end
+end

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/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.try(:[], 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,152 @@
+# 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
+                  raise
+                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