appmap 0.18.1

data/exe/_appmap-record-self

@@ -0,0 +1,49 @@
+#!/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/exe/appmap

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'gli'
+
+require 'appmap'
+require 'appmap/version'
+
+# AppMap CLI.
+module AppMap
+  class App
+    extend GLI::App
+
+    program_desc 'AppMap client'
+
+    version AppMap::VERSION
+
+    subcommand_option_handling :normal
+    arguments :strict
+    preserve_argv true
+
+    class << self
+      protected
+
+      def default_appmap_file
+        ENV['APPMAP_FILE'] || 'appmap.json'
+      end
+
+      def output_file_flag(c, default_value: nil)
+        c.desc 'Name of the output file'
+        c.long_desc <<~DESC
+        Use a single dash '-' for stdout.
+        DESC
+        c.default_value default_value if default_value
+        c.arg_name 'filename'
+        c.flag %i[o output]
+      end
+    end
+
+    desc 'AppMap configuration file name'
+    default_value ENV['APPMAP_CONFIG'] || 'appmap.yml'
+    arg_name 'filename'
+    flag %i[c config]
+
+    desc 'Inspect code and generate a classmap file'
+    command :inspect do |c|
+      output_file_flag(c, default_value: default_appmap_file)
+
+      c.action do
+        require 'appmap/command/inspect'
+        features = AppMap::Command::Inspect.new(@config).perform
+        @output_file.write JSON.pretty_generate(features)
+      end
+    end
+
+    desc 'Record the execution of a program and generate an AppMap.'
+    arg_name 'program'
+    command :record do |c|
+      output_file_flag(c, default_value: default_appmap_file)
+
+      c.action do |_, _, args|
+        # My subcommand name
+        ARGV.shift
+
+        # Consume the :output option, if provided
+        if %w[-o --output].find { |arg_name| ARGV[0] == arg_name.to_s }
+          ARGV.shift
+          ARGV.shift
+        end
+
+        # Name of the program to execute. GLI will ensure that it's present.
+        program = args.shift or help_now!("'program' argument is required")
+
+        # Also pop the program name from ARGV, because the command will use raw ARGV
+        # to load the extra arguments into this Ruby process.
+        ARGV.shift
+
+        require 'appmap/command/record'
+        AppMap::Command::Record.new(@config, program).perform do |features, events|
+          @output_file.write JSON.generate(classMap: features,
+                                           metadata: AppMap::Command::Record.detect_metadata,
+                                           events: events)
+        end
+      end
+    end
+
+    desc 'Upload a scenario file to AppLand.'
+    arg_name 'filename'
+    command :upload do |c|
+      output_file_flag(c, default_value: '-')
+
+      c.desc 'Whether to open the new scenario in the browser'
+      c.default_value true
+      c.switch [:open]
+
+      c.desc 'AppLand website URL'
+      c.default_value ENV['APPLAND_URL'] || 'https://appland-staging.herokuapp.com'
+      c.flag :url
+
+      # TODO: This will be replaced with proper login
+      c.desc 'User id to own the scenario'
+      c.default_value(ENV['APPLAND_USER'])
+      c.flag :user
+
+      c.desc 'Organization id to own the scenario'
+      c.default_value(ENV['APPLAND_ORG'])
+      c.flag :org
+
+      c.action do |_, options, args|
+        require 'appmap/command/upload'
+
+        filenames = args
+        help_now!("'filename' argument is required") if filenames.empty?
+
+        url = options[:url]
+        user = options[:user]
+        org = options[:org]
+
+        batch_id = nil
+        uuids = filenames.map do |filename|
+          appmap = JSON.parse(File.read(filename))
+
+          warn "Uploading #{filename.inspect}"
+          upload = AppMap::Command::Upload.new(@config, appmap, url, user, org)
+          upload.batch_id = batch_id if batch_id
+          upload.perform.tap do |response|
+            batch_id ||= response.batch_id
+            @output_file.puts "Scenario Id: #{response.scenario_uuid}"
+          end.scenario_uuid
+        end
+        @output_file.puts "Batch Id: #{batch_id}"
+
+        if options[:open] && STDIN.tty?
+          if uuids.length == 1
+            system "open #{url}/scenarios/#{uuids.first}"
+          else
+            system "open #{url}/scenario_batches/#{batch_id}"
+          end
+        end
+      end
+    end
+
+    pre do |global, _, options, _|
+      @config = interpret_config_option(global[:config])
+      @output_file = interpret_output_file_option(options[:output])
+
+      true
+    end
+
+    class << self
+      protected
+
+      def interpret_config_option(fname)
+        require 'appmap/config'
+        AppMap::Config.load_from_file fname
+      end
+
+      def interpret_output_file_option(file_name)
+        Hash.new { |_, fname| -> { File.new(fname, 'w') } }.tap do |open_output_file|
+          open_output_file[nil] = -> { nil }
+          open_output_file['-'] = -> { $stdout }
+        end[file_name].call
+      end
+    end
+  end
+end
+
+exit AppMap::App.run(ARGV)

data/lib/appmap/algorithm/prune_class_map.rb

@@ -0,0 +1,65 @@
+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 prune
+        # 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/command/inspect.rb

@@ -0,0 +1,11 @@
+module AppMap
+  module Command
+    InspectStruct = Struct.new(:config)
+
+    class Inspect < InspectStruct
+      def perform
+        AppMap.inspect(config)
+      end
+    end
+  end
+end

data/lib/appmap/command/record.rb

@@ -0,0 +1,91 @@
+module AppMap
+  module Command
+    RecordStruct = Struct.new(:config, :program)
+
+    class Record < RecordStruct
+      class << self
+        # Builds a Hash of metadata which can be detected by inspecting the system.
+        def detect_metadata
+          {
+            language: {
+              name: 'ruby',
+              engine: RUBY_ENGINE,
+              version: RUBY_VERSION
+            }
+          }.tap do |m|
+            if defined?(::Rails)
+              m[:frameworks] ||= []
+              m[:frameworks] << {
+                name: 'rails',
+                version: ::Rails.version
+              }
+              m[:layout] = 'rails'
+            end
+            m[:git] = git_metadata if git_available
+          end
+        end
+
+        protected
+
+        def git_available
+          @git_available = system('git status 2>&1 > /dev/null') if @git_available.nil?
+        end
+
+        def git_metadata
+          git_repo = `git config --get remote.origin.url`.strip
+          git_branch = `git rev-parse --abbrev-ref HEAD`.strip
+          git_sha = `git rev-parse HEAD`.strip
+          git_status = `git status -s`.split("\n").map(&:strip)
+          git_last_annotated_tag = `git describe --abbrev=0 2>/dev/null`.strip
+          git_last_annotated_tag = nil if git_last_annotated_tag.blank?
+          git_last_tag = `git describe --abbrev=0 --tags 2>/dev/null`.strip
+          git_last_tag = nil if git_last_tag.blank?
+          git_commits_since_last_annotated_tag = `git describe`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_annotated_tag
+          git_commits_since_last_tag = `git describe --tags`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_tag
+
+          {
+            repository: git_repo,
+            branch: git_branch,
+            commit: git_sha,
+            status: git_status,
+            git_last_annotated_tag: git_last_annotated_tag,
+            git_last_tag: git_last_tag,
+            git_commits_since_last_annotated_tag: git_commits_since_last_annotated_tag,
+            git_commits_since_last_tag: git_commits_since_last_tag
+          }
+        end
+      end
+
+      def perform(&block)
+        features = AppMap.inspect(config)
+        functions = features.map(&:collect_functions).flatten
+
+        require 'appmap/trace/tracer'
+
+        tracer = AppMap::Trace.tracers.trace(functions)
+
+        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 features, events
+        end
+
+        load program if program
+      end
+    end
+  end
+end

data/lib/appmap/command/upload.rb

@@ -0,0 +1,103 @@
+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
+
+        # If it's a list, upload it as a classMap
+        if data.is_a?(Hash)
+          events = data.delete('events') || []
+          class_map = data.delete('classMap') || []
+
+          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
+
+          events = pruned_events
+
+          class_map = prune(class_map, events: events)
+          appmap[:classMap] = class_map
+          appmap[:events] = events
+        else
+          class_map = prune(data)
+          appmap = { "classMap": class_map, "events": [] }
+        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.prune
+      end
+    end
+  end
+end

data/lib/appmap/config/directory.rb

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,25 @@
+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