appmap 0.23.0 → 0.27.0

data/exe/_appmap-record-self

@@ -1,49 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'json'
-
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
-
-require 'appmap'
-require 'appmap/feature'
-require 'shellwords'
-
-def usage
-  warn 'Usage: trace-self <trace-file>'
-  exit 1
-end
-
-trace_file = ARGV.shift || usage
-usage unless ARGV.empty?
-
-replay_events = File.read(trace_file)
-                 .split("\n")
-                 .map(&:strip)
-                 .reject(&:empty?)
-                 .map(&JSON.method(:parse))
-                 .map { |te| te['event'] = te['event'].intern; te }
-                 .map { |te| OpenStruct.new(te) }
-
-require 'appmap/trace/tracer'
-
-def method_call_from_event(evt)
-  AppMap::Trace::MethodCall.new(evt.id, evt.event.intern, evt.defined_class, evt.method_id, evt.path, evt.lineno, evt.static, evt.thread_id, evt.variables)
-end
-
-# _parent_id and _elapsed are ignored since they are already specified in the 
-# data being replayed.
-def method_return_from_event(evt, _parent_id, _elapsed)
-  AppMap::Trace::MethodReturn.new(evt.id, evt.event.intern, evt.defined_class, evt.method_id, evt.path, evt.lineno, evt.static, evt.thread_id, evt.variables).tap do |mr|
-    mr.parent_id = evt.parent_id
-    mr.elapsed = evt.elapsed
-  end
-end
-
-tracer = AppMap::Trace.tracer
-handler = AppMap::Trace::TracePointHandler.new(tracer)
-handler.call_constructor = method(:method_call_from_event)
-handler.return_constructor = method(:method_return_from_event)
-
-replay_events.each do |evt|
-  handler.handle evt
-end

data/lib/appmap/command/inspect.rb

@@ -1,14 +0,0 @@
-module AppMap
-  module Command
-    InspectStruct = Struct.new(:config)
-
-    class Inspect < InspectStruct
-      def perform
-        require 'appmap/command/record'
-
-        features = AppMap.inspect(config)
-        { version: AppMap::APPMAP_FORMAT_VERSION, metadata: AppMap::Command::Record.detect_metadata, classMap: features }
-      end
-    end
-  end
-end

data/lib/appmap/command/upload.rb

@@ -1,99 +0,0 @@
-require 'json'
-require 'faraday'
-
-module AppMap
-  module Command
-    UploadResponse = Struct.new(:batch_id, :scenario_uuid)
-
-    UploadStruct = Struct.new(:config, :data, :url, :user, :org)
-    class Upload < UploadStruct
-      MAX_DEPTH = 12
-
-      attr_accessor :batch_id
-
-      def initialize(config, data, url, user, org)
-        super
-
-        # TODO: Make this an option
-        @max_depth = MAX_DEPTH
-      end
-
-      def perform
-        appmap = data.clone
-
-        events = data.delete('events')
-        class_map = data.delete('classMap') || []
-
-        unless events.blank?
-          pruned_events = []
-          stack = []
-          events.each do |evt|
-            if evt['event'] == 'call'
-              stack << evt
-              stack_depth = stack.length
-            else
-              stack_depth = stack.length
-              stack.pop
-            end
-
-            prune = stack_depth > @max_depth
-
-            pruned_events << evt unless prune
-          end
-
-          warn "Pruned events to #{pruned_events.length}" if events.length > pruned_events.length
-
-          appmap[:events] = pruned_events
-          appmap[:classMap] = prune(class_map, events: pruned_events)
-        else
-          appmap[:events] = []
-          appmap[:classMap] = prune(class_map)
-        end
-
-        upload_file = { user: user, org: org, data: appmap }.compact
-
-        conn = Faraday.new(url: url)
-        response = conn.post do |req|
-          req.url '/api/scenarios'
-          req.headers['Content-Type'] = 'application/json'
-          req.headers[AppMap::BATCH_HEADER_NAME] = @batch_id if @batch_id
-          req.body = JSON.generate(upload_file)
-        end
-
-        unless response.body.blank?
-          message = begin
-                      JSON.parse(response.body)
-                    rescue JSON::ParserError => e
-                      warn "Response is not valid JSON (#{e.message})"
-                      nil
-                    end
-        end
-
-        unless response.success?
-          error = [ 'Upload failed' ]
-          error << ": #{message}" if message
-          raise error.join
-        end
-
-        batch_id = @batch_id || response.headers[AppMap::BATCH_HEADER_NAME]
-
-        uuid = message['uuid']
-        UploadResponse.new(batch_id, uuid)
-      end
-
-      protected
-
-      def debug?
-        ENV['DEBUG'] == 'true' || ENV['GLI_DEBUG'] == 'true'
-      end
-
-      def prune(class_map, events: nil)
-        require 'appmap/algorithm/prune_class_map'
-        Algorithm::PruneClassMap.new(class_map).tap do |alg|
-          alg.events = events if events
-          alg.logger = ->(msg) { warn msg } if debug?
-        end.perform
-      end
-    end
-  end
-end

data/lib/appmap/config.rb

@@ -1,65 +0,0 @@
-require 'appmap/config/path'
-require 'appmap/config/file'
-require 'appmap/config/directory'
-require 'appmap/config/package_dir'
-require 'appmap/config/named_function'
-
-module AppMap
-  module Config
-    class Configuration
-      attr_reader :name, :packages, :files, :named_functions
-
-      def initialize(name)
-        @name = name
-        @packages = []
-        @files = []
-        @named_functions = []
-      end
-
-      def source_locations
-        packages + files + named_functions
-      end
-    end
-
-    class << self
-      NAMED_FUNCTIONS = [
-        Config::NamedFunction.new(:rack_handler_webrick, 'rack', 'lib/rack/handler/webrick.rb',
-                                  %w[Rack Handler WEBrick], 'service', false)
-      ].freeze
-
-      # 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)
-        Configuration.new(config_data['name']).tap do |config|
-          builders = Hash.new { |_, key| raise "Unknown config type #{key.inspect}" }
-          builders[:packages] = lambda { |path, options|
-            AppMap::Config::PackageDir.new(path).tap do |pdir|
-              pdir.package_name = options['name'] if options['name']
-              pdir.exclude = options['exclude'] if options['exclude']
-            end
-          }
-          builders[:files] = ->(path, _) { AppMap::Config::File.new(path) }
-
-          %i[packages files].each do |kind|
-            next unless (members = config_data[kind.to_s])
-            members.each do |member|
-              path = member.delete('path')
-              config.send(kind) << builders[kind].call(path, member)
-            end
-          end
-
-          NAMED_FUNCTIONS.each do |dep|
-            next if config_data['named_functions'] && !config_data['named_functions'].member?(dep.gem_name)
-
-            config.named_functions << dep
-          end
-        end
-      end
-    end
-  end
-end

data/lib/appmap/config/directory.rb

@@ -1,65 +0,0 @@
-module AppMap
-  module Config
-    # A normal directory is scanned for AppMap features without interpreting the
-    # directory as a 'package'.
-    #
-    # @appmap
-    class Directory < Path
-      # @appmap
-      def initialize(path)
-        super
-      end
-
-      # @appmap
-      def children
-        child_files.sort + child_directories.sort
-      end
-
-      protected
-
-      def ruby_file?(path)
-        ::File.file?(path) && (path =~ /\.rb$/ || ruby_shebang?(path))
-      end
-
-      def ruby_shebang?(path)
-        lines = begin
-          ::File.read(path).split("\n")
-        rescue ArgumentError => e
-          if e.message.index 'invalid byte sequence'
-            warn "Unable to load file #{path.inspect} : #{e.message}"
-            return false
-          end
-          raise
-        end
-        lines[0] && lines[0].index('#!/usr/bin/env ruby') == 0
-      end
-
-      def child_files
-        expand_path = ->(fname) { ::File.join(path, fname) }
-        Dir.new(path).entries.select do |fname|
-          ::File.file?(expand_path.call(fname)) &&
-            !::File.symlink?(expand_path.call(fname)) &&
-            ruby_file?(expand_path.call(fname))
-        end.select do |fname|
-          !exclude?(::File.join(path, fname))
-        end.map do |fname|
-          File.new(expand_path.call(fname)).tap do |f|
-            f.mode = mode
-          end
-        end
-      end
-
-      def child_directories
-        File.new(path).entries.select do |fname|
-          !%w[. ..].include?(fname) && !::File.directory?(fname)
-        end.select do |dir|
-          !exclude?(::File.join(path, dir))
-        end.map do |dir|
-          PackageDir.new(dir, [module_name, dir].join('/')).tap do |m|
-            m.mode = mode
-          end
-        end
-      end
-    end
-  end
-end

data/lib/appmap/config/file.rb

@@ -1,13 +0,0 @@
-module AppMap
-  module Config
-    # Scan a specific file for AppMap features.
-    #
-    # @appmap
-    class File < Path
-      # @appmap
-      def initialize(path)
-        super
-      end
-    end
-  end
-end

data/lib/appmap/config/named_function.rb

@@ -1,21 +0,0 @@
-module AppMap
-  module Config
-    NamedFunctionStruct = Struct.new(:id, :gem_name, :file_path, :class_names, :method_name, :static)
-
-    # Identifies a specific function within a Gem to be instrumented.
-    #
-    # * `id` A unique identifier for the named function. This is used to associate custom logic with the
-    #   named function when the trace events are being handled.
-    # * `gem_name` Name of the Gem.
-    # * `file_path` Name of the file within the Gem in which the function is located.
-    # * `class_names` Array of the module/class name scope which contains the function. For example,
-    #   `%w[Rack Handler WEBrick]`.
-    # * `method_name` Name of the method within the class name scope.
-    # * `static` Whether it's a static or instance method.
-    class NamedFunction < NamedFunctionStruct
-      def children
-        []
-      end
-    end
-  end
-end

data/lib/appmap/config/package_dir.rb

@@ -1,52 +0,0 @@
-require 'pathname'
-
-module AppMap
-  module Config
-    # Scan a directory for AppMap features, treating it as a package and its
-    # sub-folders as sub-packages.
-    #
-    # @appmap
-    class PackageDir < Directory
-      attr_accessor :package_name, :base_path, :exclude
-
-      # @appmap
-      def initialize(path, package_name = Pathname.new(path || '').basename.to_s)
-        super(path)
-
-        @package_name = package_name
-        @base_path = path
-        @exclude = []
-      end
-
-      def sub_package_dir(dir)
-        PackageDir.new(::File.join(path, dir), dir).tap do |m|
-          m.base_path = base_path
-          m.exclude = exclude
-          m.mode = mode
-        end
-      end
-
-      def exclude?(path)
-        relative_path = path.gsub("#{base_path}/", '')
-        exclude.member?(relative_path)
-      end
-
-      # @appmap
-      def children
-        child_files.sort + child_packages.sort
-      end
-
-      protected
-
-      def child_packages
-        ::Dir.new(path).entries.select do |fname|
-          !%w[. ..].include?(fname) && ::File.directory?(::File.join(path, fname))
-        end.select do |dir|
-          !exclude?(::File.join(path, dir))
-        end.map do |dir|
-          sub_package_dir(dir)
-        end
-      end
-    end
-  end
-end

data/lib/appmap/config/path.rb

@@ -1,25 +0,0 @@
-module AppMap
-  module Config
-    PathStruct = Struct.new(:path)
-
-    # Path is an abstract configuration of a file, directory, or package.
-    class Path < PathStruct
-      attr_accessor :mode
-
-      def initialize(path)
-        super(path)
-
-        @mode = :implicit
-      end
-
-      def <=>(other)
-        path <=> other.path
-      end
-
-      # Automatically determined configurations of child file/package paths.
-      def children
-        []
-      end
-    end
-  end
-end

data/lib/appmap/feature.rb

@@ -1,262 +0,0 @@
-module AppMap
-  # A Feature is a construct within the code that will be observed. Examples features include
-  # modules, classes and functions.
-  module Feature
-    TYPE_MAP = {
-      'cls' => 'class'
-    }.freeze
-
-    class << self
-      FEATURE_BUILDERS = {
-        module: ->(_) { Module.new },
-        class: ->(_) { Cls.new },
-        function: lambda do |hash|
-                    static = hash.delete('static')
-                    class_name = hash.delete('class_name')
-                    Function.new.tap do |e|
-                      e.static = static
-                      e.class_name = class_name
-                    end
-                  end
-      }.freeze
-
-      # Deserialize a feature from a Hash. The Hash is typically a deserialized JSON dump of the feature.
-      def from_hash(hash)
-        builder = FEATURE_BUILDERS[hash['type'].to_sym]
-        raise "Unrecognized type of feature: #{type.inspect}" unless builder
-
-        feature = builder.call(hash)
-        feature.name = hash['name']
-        feature.location = hash['location']
-        feature.attributes = hash['attributes'] || {}
-        feature.children = (hash['children'] || []).map { |child| from_hash(child) }
-        feature
-      end
-    end
-
-    FeatureStruct = Struct.new(:name, :location, :attributes)
-
-    # Base is an abstract base class for features.
-    class Base < FeatureStruct
-      class << self
-        def expand_path(location)
-          path, lineno = location.split(':')
-          [ path, lineno ].compact.join(':')
-        end
-      end
-
-      attr_reader :parent, :children
-
-      def initialize(name, location, attributes)
-        super(name, self.class.expand_path(location), attributes)
-
-        @parent = nil
-        @children = []
-      end
-
-      def remove_child(child)
-        # TODO: Encountered this indexing appland with active_dispatch
-        children.delete(child) or warn "Unable to remove #{name.inspect} from parent" # or raise "No such child : #{child}"
-        child.instance_variable_set('@parent', nil)
-      end
-
-      def add_child(child)
-        @children << child
-        child.instance_variable_set('@parent', self)
-      end
-
-      # Gets an array containing the type names which enclose this feature.
-      def enclosing_type_name
-        @enclosing_type_name ||= [].tap do |names|
-          p = self
-          while (p = p.parent) && p.type?
-            names << p.name
-          end
-        end.reverse
-      end
-
-      # true iff this feature has an enclosing type. An example of when this is false: when
-      # the parent of the feature is not a type (e.g. it's a location).
-      def enclosing_type_name?
-        !enclosing_type_name.empty?
-      end
-
-      # The 'include' attribute can indicate which elements of the parse subtree
-      # to automatically add as features. For example: public_classes, public_modules,
-      # public_methods.
-      def include_option
-        (attributes[:include] || '').split(',')
-      end
-
-      # yield each function to a block.
-      def collect_functions(accumulator = [])
-        accumulator.tap do |_|
-          accumulator << self if is_a?(Function)
-          children.each { |child| child.collect_functions(accumulator) }
-        end
-      end
-
-      def type?
-        false
-      end
-
-      def valid?
-        !name.blank? && !location.blank?
-      end
-
-      def to_json(*opts)
-        to_h.to_json(*opts)
-      end
-
-      def to_h
-        super.tap do |map|
-          map.delete(:parent)
-          class_name = self.class.name.underscore.split('/')[-1]
-          map[:type] = TYPE_MAP[class_name] || class_name
-          map[:children] = @children.map(&:to_h) unless @children.empty?
-          map.delete(:attributes) if map[:attributes].empty?
-        end
-      end
-
-      # Determines if this feature should be dropped from the feature tree.
-      # A feature is dropped from the feature tree if it doesn't add useful information for the user.
-      # Performing this operation removes feature nodes that don't add anything useful to the user.
-      # For example, empty classes.
-      def prune(parent = nil)
-        should_prune = prune? && !parent.nil?
-        parent = self unless should_prune
-        children.dup.each do |child|
-          child.prune(parent)
-        end
-
-        # Perform the prune in post-fix traversal order, otherwise the
-        # features will get confused about whether they should prune or not.
-        if should_prune
-          parent.remove_child(self)
-          children.each do |child|
-            parent.add_child(child)
-          end
-        end
-      end
-
-      # Determines if this feature should be re-parented as a child of a different feature.
-      #
-      # A feature is re-parented if the enclosing type of the feature has already been defined in the tree.
-      #
-      # @param parent the parent of this feature in the compacted tree.
-      def reparent(parent = nil, features_by_type = {})
-        # Determine if the enclosing type of the feature is defined.
-        # Generally, it should be.
-
-        existing_enclosing_type = features_by_type[enclosing_type_name] if enclosing_type_name?
-        if existing_enclosing_type
-          parent = existing_enclosing_type
-        end
-
-        # Determine if this feature is a type which is already defined.
-        type_exists = true if type? && features_by_type.key?(type_name)
-
-        # If this feature is a type that's already defined, skip over it and
-        # add the children to the existing feature. Otherwise, clone this feature
-        # under the parent and use the cloned object as the parent of the compacted 
-        # children.
-        if type_exists
-          features_by_type[type_name]
-        else
-          clone.tap do |f|
-            parent.add_child(f) if parent
-            features_by_type[type_name] = f if type?
-          end
-        end.tap do |updated_parent|
-          children.each do |child|
-            child.reparent(updated_parent, features_by_type)
-          end
-        end
-      end
-
-      def prune?
-        false
-      end
-
-      protected
-
-      def clone
-        self.class.new(name, location, attributes)
-      end
-
-      def child_classes
-        children.select { |c| c.is_a?(Cls) }
-      end
-
-      def child_nonclasses
-        children.reject { |c| c.is_a?(Cls) }
-      end
-    end
-
-    # Package is a feature which represents the directory containing code.
-    class Package < Base
-      # prune a package if it's empty, or if it contains anything but packages.
-      def prune?
-        children.empty? || children.any? { |c| !c.is_a?(Package) }
-      end
-    end
-
-    # Cls is a feature which represents a code class. A class defines a namespace which contains other
-    # features (such as member classes and functions), and it also usually encapsulates some data on which
-    # the member features operate.
-    class Cls < Base
-      # prune a class if it's empty.
-      def prune?
-        children.empty?
-      end
-
-      def type?
-        true
-      end
-
-      # Gets the type name of this class as an array.
-      def type_name
-        @type_name ||= enclosing_type_name + [ name ]
-      end
-    end
-
-    # Function is a feature which represents a code function. It can be an instance function or static (aka 'class')
-    # function. Instance functions operate on the instance data of the class on which they are defined. Static
-    # functions are used to perform operations which don't have want or need of instance data.
-    #
-    # * `handler_id` If provided, identifies a trace handler which can apply specialized logic to the
-    #   event data which is recorded for this function. For example, if the function represents a handler
-    #   method for a web server, the custom handler can inspect and record the HTTP request method and path info.
-    class Function < Base
-      attr_accessor :static, :class_name, :handler_id
-
-      alias static? static
-      def instance?
-        !static?
-      end
-
-      # Static functions must have an enclosing class defined in order to be traced.
-      def valid?
-        super && (instance? || !class_name.blank?)
-      end
-
-      def to_h
-        super.tap do |h|
-          # Suppress the class name when it can be inferred from the enclosing type.
-          h[:class_name] = class_name if class_name && class_name != enclosing_type_name.join('::')
-          h[:static] = static?
-        end
-      end
-
-      protected
-
-      def clone
-        super.tap do |obj|
-          obj.static = static
-          obj.class_name = class_name
-          obj.handler_id = handler_id
-        end
-      end
-    end
-  end
-end