appmap 0.31.0

data/lib/appmap.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_support'
+  require 'active_support/core_ext'
+rescue NameError
+  warn 'active_support is not available. AppMap execution will continue optimistically without it...'
+end
+
+require 'appmap/version'
+require 'appmap/hook'
+require 'appmap/config'
+require 'appmap/trace'
+require 'appmap/class_map'
+require 'appmap/metadata'
+
+module AppMap
+  class << self
+    @configuration = nil
+    @configuration_file_path = nil
+
+    # configuration gets the configuration. If there is no configuration, the default
+    # configuration is initialized.
+    def configuration
+      @configuration ||= configure
+    end
+
+    # configuration= sets the configuration. This is only expected to happen once per
+    # Ruby process.
+    def configuration=(config)
+      warn 'AppMap is already configured' if @configuration && config
+
+      @configuration = config
+    end
+
+    # initialize configures AppMap for recording. Default behavior is to configure from "appmap.yml".
+    # This method also activates the code hooks which record function calls as trace events.
+    # Call this function before the program code is loaded by the Ruby VM, otherwise
+    # the load events won't be seen and the hooks won't activate.
+    def initialize(config_file_path = 'appmap.yml')
+      warn "Configuring AppMap from path #{config_file_path}"
+      self.configuration = Config.load_from_file(config_file_path)
+      Hook.new(configuration).enable
+    end
+
+    # tracing can be used to start tracing, stop tracing, and record events.
+    def tracing
+      @tracing ||= Trace::Tracing.new
+    end
+
+    # record records the events which occur while processing a block,
+    # and returns an AppMap as a Hash.
+    def record
+      tracer = tracing.trace
+      begin
+        yield
+      ensure
+        tracing.delete(tracer)
+      end
+
+      events = [].tap do |event_list|
+        event_list << tracer.next_event.to_h while tracer.event?
+      end
+      {
+        'version' => AppMap::APPMAP_FORMAT_VERSION,
+        'metadata' => detect_metadata,
+        'classMap' => class_map(tracer.event_methods),
+        'events' => events
+      }
+    end
+
+    # class_map builds a class map from a config and a list of Ruby methods.
+    def class_map(methods)
+      ClassMap.build_from_methods(configuration, methods)
+    end
+
+    # detect_metadata returns default metadata detected from the Ruby system and from the
+    # filesystem.
+    def detect_metadata
+      @metadata ||= Metadata.detect.freeze
+      @metadata.deep_dup
+    end
+  end
+end
+
+require 'appmap/railtie' if defined?(::Rails::Railtie)
+AppMap.initialize unless ENV['APPMAP_INITIALIZE'] == 'false'

data/lib/appmap/algorithm/prune_class_map.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Algorithm
+    # Prune a class map so that only functions, classes and packages which are referenced
+    # by some event are retained.
+    class PruneClassMap
+      attr_reader :class_map
+      # Set this attribute to a function which will log algorithm events.
+      attr_writer :logger
+      attr_accessor :events
+
+      # Construct the algorithm, with a class map that will be pruned in place.
+      def initialize(class_map)
+        @class_map = class_map
+        @logger = ->(msg) {}
+      end
+
+      def perform
+        # This proc counts the number of objects in the class map whose type is 'k'
+        count = proc do |k, e|
+          n = 0
+          n += 1 if e['type'] == k
+          n += (e['children'] || []).map { |child| count.call(k, child) }.reduce(0, :+)
+          n
+        end
+
+        @logger.call "Full classMap contains #{class_map.map { |m| count.call('class', m) }.reduce(0, :+)} classes"
+
+        # Prune all the classes which fail a test.
+        reject = proc do |list, test|
+          list.tap do |_|
+            list.each do |item|
+              children = item['children']
+              next unless children
+
+              reject.call(children, test)
+            end
+            list.reject!(&test)
+          end
+        end
+
+        if events
+          locations = \
+            Set.new(events.select { |e| e['event'] == 'call' }
+            .map { |e| [ e['path'], e['lineno'] ].join(':') })
+
+          # Prune all functions which aren't called
+          reject.call class_map,
+                      ->(e) { e['type'] == 'function' && !locations.member?(e['location']) }
+        end
+
+        # Prune all empty classes
+        reject.call class_map,
+                    ->(e) { e['type'] == 'class' && (e['children'] || []).empty? }
+
+        # Prune all empty packages
+        reject.call class_map,
+                    ->(e) { e['type'] == 'package' && (e['children'] || []).empty? }
+
+        @logger.call "Pruned classMap contains #{class_map.map { |m| count.call('class', m) }.reduce(0, :+)} classes"
+
+        class_map
+      end
+    end
+  end
+end

data/lib/appmap/algorithm/stats.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Algorithm
+    StatsStruct = Struct.new(:appmap)
+
+    # Compute AppMap statistics.
+    class Stats < StatsStruct
+      Result = Struct.new(:class_frequency, :method_frequency) do
+        def merge!(other)
+          merge = lambda do |freq, other_freq|
+            freq_by_name = freq.inject({}) do |table, entry|
+              table.tap do
+                table[entry.name] = entry
+              end
+            end
+            other_freq.each do |other_entry|
+              entry = freq_by_name[other_entry.name]
+              if entry
+                entry.count += other_entry.count
+              else
+                freq << other_entry
+              end
+            end
+          end
+          merge.call(class_frequency, other.class_frequency)
+          merge.call(method_frequency, other.method_frequency)
+
+          self
+        end
+
+        def sort!
+          comparator = ->(a,b) { b.count <=> a.count }
+          class_frequency.sort!(&comparator)
+          method_frequency.sort!(&comparator)
+
+          self
+        end
+
+        def limit!(limit)
+          self.class_frequency = class_frequency[0...limit]
+          self.method_frequency = method_frequency[0...limit]
+
+          self
+        end
+
+        def as_text
+          lines = [
+            "Class frequency:",
+            "----------------",
+          ] + class_frequency.map(&:to_a).map(&:reverse).map { |line | line.join("\t") } + [
+            "",
+            "Method frequency:",
+            "----------------",
+          ] + method_frequency.map(&:to_a).map(&:reverse).map { |line | line.join("\t") }
+          lines.join("\n")
+        end
+      end
+      Frequency = Struct.new(:name, :count)
+
+      def perform(limit: nil)
+        events = appmap['events'] || []
+        frequency_calc = lambda do |key_func|
+          events_by_key = events.inject(Hash.new(0))  do |memo, event|
+            key = key_func.call(event)
+            memo.tap do
+              memo[key] += 1 if key
+            end
+          end
+          events_by_key.map do |key, count|
+            Frequency.new(key, count)
+          end
+        end
+
+        class_name_func = ->(event) { event['defined_class'] }
+        full_name_func = lambda do |event|
+          call = event['event'] == 'call'
+          class_name = event['defined_class']
+          static = event['static']
+          function_name = event['method_id']
+          [ class_name, static ? '.' : '#', function_name ].join if call && class_name && !static.nil? && function_name
+        end
+
+        class_frequency = frequency_calc.call(class_name_func)
+        method_frequency = frequency_calc.call(full_name_func)
+
+        Result.new(class_frequency, method_frequency)
+      end
+    end
+  end
+end

data/lib/appmap/class_map.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+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, :labels
+
+        def type
+          'function'
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            location: location,
+            static: static,
+            labels: labels
+          }.delete_if {|k,v| v.nil?}
+        end
+      end
+    end
+
+    class << self
+      def build_from_methods(config, methods)
+        root = Types::Root.new
+        methods.each do |method|
+          package = config.package_for_method(method) \
+            or raise "No package found for method #{method}"
+          add_function root, package, method
+        end
+        root.children.map(&:to_h)
+      end
+
+      protected
+
+      def add_function(root, package, method)
+        location = 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.static
+
+        object_infos = [
+          {
+            name: package.path,
+            type: 'package'
+          }
+        ]
+        object_infos += method.defined_class.split('::').map do |name|
+          {
+            name: name,
+            type: 'class'
+          }
+        end
+        function_info = {
+          name: method.name,
+          type: 'function',
+          location: [ location_file, lineno ].join(':'),
+          static: static
+        }
+        function_info[:labels] = package.labels if package.labels
+        object_infos << function_info
+        
+        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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Command
+    RecordStruct = Struct.new(:config, :program)
+
+    class Record < RecordStruct
+      def perform(&block)
+        tracer = AppMap.tracing.trace
+
+        events = []
+        quit = false
+        event_thread = Thread.new do
+          while tracer.event? || !quit
+            event = tracer.next_event
+            if event
+              events << event.to_h
+            else
+              sleep 0.0001
+            end
+          end
+        end
+        event_thread.abort_on_exception = true
+
+        at_exit do
+          quit = true
+          event_thread.join
+          yield AppMap::APPMAP_FORMAT_VERSION,
+                AppMap.detect_metadata,
+                AppMap.class_map(tracer.event_methods),
+                events
+        end
+
+        load program if program
+      end
+    end
+  end
+end

data/lib/appmap/command/stats.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Command
+    StatsStruct = Struct.new(:appmap)
+
+    class Stats < StatsStruct
+      def perform(limit: nil)
+        require 'appmap/algorithm/stats'
+        AppMap::Algorithm::Stats.new(appmap).perform(limit: limit)
+      end
+    end
+  end
+end

data/lib/appmap/config.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AppMap
+  Package = Struct.new(:path, :exclude, :labels) do
+    def initialize(path, exclude, labels = nil)
+      super
+    end
+    
+    def to_h
+      {
+        path: path,
+        exclude: exclude.blank? ? nil : exclude,
+        labels: labels.blank? ? nil : labels
+      }.compact
+    end
+  end
+
+  class Config
+    # Methods that should always be hooked, with their containing
+    # package and labels that should be applied to them.
+    HOOKED_METHODS = {
+      'ActiveSupport::SecurityUtils' => {
+        secure_compare: Package.new('active_support', nil, ['security'])
+      },
+      'OpenSSL::X509::Certificate' => {
+        sign: Package.new('openssl', nil, ['security'])
+      }
+    }
+
+    attr_reader :name, :packages
+    def initialize(name, packages = [])
+      @name = name
+      @packages = packages
+    end
+
+    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 to_h
+      {
+        name: name,
+        packages: packages.map(&:to_h)
+      }
+    end
+
+    def package_for_method(method)
+      location = method.source_location
+      location_file, = location
+      return unless location_file
+
+      defined_class,_,method_name = Hook.qualify_method_name(method)
+      hooked_method = find_hooked_method(defined_class, method_name)
+      return hooked_method if hooked_method
+      
+      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
+    end
+
+    def included_by_location?(method)
+      !!package_for_method(method)
+    end
+
+    def always_hook?(defined_class, method_name)
+      !!find_hooked_method(defined_class, method_name)
+    end
+
+    def find_hooked_method(defined_class, method_name)
+      find_hooked_class(defined_class)[method_name]
+    end
+    
+    def find_hooked_class(defined_class)
+      HOOKED_METHODS[defined_class] || {}
+    end
+  end
+end