stackprof-remote 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ba94890adf64d5a692a8de6970d625aa2a8ea98
+  data.tar.gz: 59002cb8994625f857fdef77c6bb2d935ca88e24
+SHA512:
+  metadata.gz: 7e6149ad80253cfd9808610cffb054b9261a1a5406904ef0e6a66b9cd3161dd838c18f1f03d7268b3df1468dbdc7e3637f477dd085cd7ba4a66e1884b92a3f8f
+  data.tar.gz: 45b2de7669012da294af502b329428366fbc7545ac830866b4aafe232e9d49a167535dfa789636da46f94d4658d7e4efcad9e97a84a1446a48bf80d6a80c1ac5

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "rbtrace", "~>0.4.3"
+gem "stackprof", "~>0.2.6"
+gem "pry"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0.1"
+  gem "simplecov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,98 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.1.1)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    addressable (2.3.6)
+    builder (3.2.2)
+    coderay (1.1.0)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    docile (1.1.4)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.9.3)
+    git (1.2.7)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (3.0.0)
+    highline (1.6.21)
+    i18n (0.6.9)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (1.0.0)
+    method_source (0.8.2)
+    mini_portile (0.6.0)
+    minitest (5.3.4)
+    msgpack (0.5.8)
+    multi_json (1.10.1)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.2.1)
+      mini_portile (= 0.6.0)
+    oauth2 (0.9.4)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.5.2)
+    rake (10.3.2)
+    rbtrace (0.4.3)
+      ffi (>= 1.0.6)
+      msgpack (>= 0.4.3)
+      trollop (>= 1.16.2)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.2.1)
+    shoulda-matchers (2.6.1)
+      activesupport (>= 3.0.0)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.5.0)
+    stackprof (0.2.6)
+    thread_safe (0.3.4)
+    trollop (2.0)
+    tzinfo (1.2.1)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 2.0.1)
+  pry
+  rbtrace (~> 0.4.3)
+  rdoc (~> 3.12)
+  shoulda
+  simplecov
+  stackprof (~> 0.2.6)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Aaron Quint
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# stackprof-remote
+
+A Middleware and CLI for fetching and interacting with [StackProf](https://github.com/tmm1/stackprof) dumps.
+
+## Description
+
+stackprof-remote consists of a middleware for easy creation and retrieval of StackProf sampling profiler dumps from a remote machine, and a wrapper around pry (stackprof-cli) to create an interactive session for navigating dump files.
+
+Currently, this is aimed at Rails apps running with unicorn, but there are options that should make it usable with any Rack app. In the future, I'd like to see it work with Resque and non-rack applications, too.
+
+## Why
+
+StackProf is amazing (BIG UPS TO @TMM1) but is not very operator friendly when it comes to collecting data about a current process. I was inspired by the [`go tool pprof` process](http://golang.org/pkg/net/http/pprof/) to make something that could wrap StackProf in an interface that should be as easy as including a middleware and pointing a bin at it to fetch and navigate a dump.
+
+## Usage
+
+1 - Add the Middleware to your app. 
+
+``` ruby
+# rails 2.3 style
+require 'stackprof/remote/middleware'
+
+# Should we enable stackprof-remote for this request.
+# enabled can be a boolean or a proc that takes the Rack env hash
+enabled = proc do |env|
+  env['HOST_INFO'] =~ /private-hostname/ || Rails.env.development?
+end
+# Register the middleware
+ActionController::Dispatcher.middleware.use StackProf::Remote::Middleware, enabled: enabled, logger: Rails.logger
+```
+
+2 - Run/restart your app.
+3 - Attach to your application. 
+
+``` bash
+$ stackprof-remote localhost 
+=== StackProf on localhost ===
+Starting
+[localhost] StackProf Started
+Waiting for 30 seconds
+[localhost] Results: 3023kb
+Saved results to /home/paperless/.sp/sp-localhost-1402684964.dump
+>>> sp-localhost-1402684964.dump loaded
+stackprof> top 5
+==================================
+  Mode: cpu(1000)
+  Samples: 5045 (3.28% miss rate)
+  GC: 355 (7.04%)
+==================================
+     TOTAL    (pct)     SAMPLES    (pct)     FRAME
+       736  (14.6%)         707  (14.0%)     ActiveSupport::LogSubscriber#start
+       379   (7.5%)         379   (7.5%)     block in ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#execute
+      5248 (104.0%)         168   (3.3%)     Benchmark#realtime
+       282   (5.6%)         117   (2.3%)     ActiveSupport::LogSubscriber#finish
+        88   (1.7%)          88   (1.7%)     block (2 levels) in Sass::Importers::Filesystem#find_real_file
+```
+
+## CLI
+
+At the end of `stackprof-remote` it actually just enters a separate process `stackprof-cli`. This is a wrapper around [pry](https://github.com/pry/pry) that loads the dump file in an interactive session. It gives you a number of methods to interact with the dump:
+
+* top N: show the top methods ordered by inner sample time.
+* total N: show the top methods ordered by total time.
+* all: Show all the methods ordered by sample time.
+* method Name: show details about the callers and callees of Name
+
+You can use `stackprof-cli` on its own by calling `stackprof-cli [dump-name]`
+
+## Notes/Caveats
+
+- You should use `enabled` on the Middleware to lock this down in production environments.
+- Collecting dumps uses [`rbtrace`](https://github.com/tmm1/rbtrace) to execute the stackprof methods against the pool of unicorns running. If you're running something other than `unicorn` or you mess with the procline, you'll need to set the `:pid_finder` option.
+- In order to get line level code output when using the `method` view you need to execute `stackprof-cli` in the same directory structure that your unicorn runs in. This doesn't necessarily mean the same server - we use remote dumps and inspect them in our local Vagrant environments that have the same directory structure.
+
+## Requirements
+
+Only works on MRI Ruby 2.1 (Upgrade already!). Its only been tested against Ruby 2.1.2 running on Linux (Centos 6.4). 
+
+## Contributing to stackprof-remote
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2014 Aaron Quint. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "stackprof-remote"
+  gem.homepage = "http://github.com/quirkey/stackprof-remote"
+  gem.license = "MIT"
+  gem.summary = %Q{A Middleware and CLI for fetching and interacting with StackProf dumps}
+  gem.description = %Q{stackprof-remote consists of a middleware for easy creation and retreival of
+                       stackprof sampling profiler dumps from a remote machine, and a wrapper around
+                       pry (stackprof-cli) to create an interactive session for navigating stackprof
+                       dumps.}
+  gem.email = "aaron@quirkey.com"
+  gem.authors = ["Aaron Quint"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "stackprof-remote #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/stackprof-cli

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'stackprof/cli'
+
+StackProf::CLI.start(ARGV.shift)
+

data/bin/stackprof-remote

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# stackprof-remote
+require 'stackprof/remote/client'
+
+remote = StackProf::Remote::Client.new(ARGV.shift, ARGV.shift)
+remote.run
+
+

data/lib/stackprof/cli.rb

@@ -0,0 +1,116 @@
+require 'pry'
+require 'stackprof/remote/process_report_collector'
+
+module StackProf
+  # CLI is a simple wrapper around Pry that defines some helper
+  # methods for navigating stackprof dumps.
+  class CLI
+
+    class << self
+      # Set prompts and other defaults
+      def set_defaults
+        Pry.config.should_load_rc = false
+        Pry.config.prompt = proc {
+          "stackprof#{@current_report ? " (#{@current_report})" : ""}> "
+        }
+      end
+
+      # Add the helper methods to pry
+      def add_methods
+        session = Session.new
+        Pry::Commands.block_command "load-dump", "Load a stackprof dump at file" do |file|
+          session.with_context(self) {|s| s.load_dump(file) }
+        end
+        Pry::Commands.block_command "top", "print the top (n) results by sample time" do |limit|
+          session.with_context(self) {|s| s.top(limit) }
+        end
+        Pry::Commands.block_command "total", "print the top (n) results by total sample time" do |limit|
+          session.with_context(self) {|s| s.total(limit) }
+        end
+        Pry::Commands.block_command "all", "print all results by sample time" do
+          session.with_context(self) {|s| s.all }
+        end
+        Pry::Commands.block_command "method", "scope results to matching matching methods" do |method|
+          session.with_context(self) {|s| s.print_method(method) }
+        end
+      end
+
+      # Start a Pry session with an optional file
+      def start(file, options = {})
+        set_defaults
+        add_methods
+        initial = file ? StringIO.new("load-dump #{file}") : nil
+        Pry.start(nil, :input => initial)
+      end
+    end
+
+    class Session
+      attr_reader :ctx
+
+      # Load a dump into a StackProf::Report object.
+      def load_dump(file)
+        data = File.read(file)
+        @report = StackProf::Remote::ProcessReportCollector.report_from_marshaled_results(data)
+        @current_report = File.basename(file)
+        puts ">>> #{@current_report} loaded"
+      end
+
+      # Print the top `limit` methods by sample time
+      def top(limit = 10)
+        check_for_report
+        @report.print_text(false, limit.to_i, ctx.output)
+      end
+
+      # Print the top `limit` methods by total time
+      def total(limit = 10)
+        check_for_report
+        @report.print_text(true, limit.to_i, ctx.output)
+      end
+
+      # Print all the methods by sample time. Paged.
+      def all
+        check_for_report
+        page do |out|
+          @report.print_text(false, nil, out)
+        end
+      end
+
+      # Print callers/callees of methods matching method. Paged.
+      def print_method(method)
+        check_for_report
+        page do |out|
+          @report.print_method(method, out)
+        end
+      end
+
+      # Simple check to see if a report has been loaded.
+      def check_for_report
+        if !@report
+          puts "You have to load a dump first with load-dump"
+          return
+        end
+      end
+
+      # Wrap the execution of a method with a Pry context
+      def with_context(ctx, &block)
+        @ctx = ctx
+        res = yield self
+        @ctx = nil
+        res
+      end
+
+      # Helper to delegate puts to the current context
+      def puts(*args)
+        ctx.output.puts(*args)
+      end
+
+      # Wrap the output in pry's pager (less)
+      def page(&block)
+        out = StringIO.new
+        yield out
+        ctx._pry_.pager.page out.string
+      end
+
+    end
+  end
+end

data/lib/stackprof/remote/client.rb

@@ -0,0 +1,72 @@
+require 'net/http'
+require 'fileutils'
+require 'stackprof/cli'
+
+module StackProf
+  module Remote
+    # Client wraps the script that uses net/http to make the start/stop
+    # requests to a host running the StackProf::Remote::Middleware
+    class Client
+      attr_reader :host
+
+      def initialize(host, wait)
+        @host = host
+        @wait = (wait || 30).to_i
+        check_host
+      end
+
+      def run
+        start
+        wait
+        fetch_results
+        save_results
+        enter_console
+      end
+
+      def start
+        puts "=== StackProf on #{host} ==="
+        puts "Starting"
+        result = Net::HTTP.get(host, "/__stackprof__/start")
+        puts "[#{host}] #{result}"
+        if result !~ /Started/
+          raise "Did not start successfully"
+        end
+      end
+
+      def wait
+        puts "Waiting for #{@wait} seconds"
+        sleep @wait
+      end
+
+      def fetch_results
+        @results = Net::HTTP.get(host, "/__stackprof__/stop")
+        puts "[#{host}] Results: #{@results.bytesize / 1024}kb"
+        if !@results
+          raise "Could not retreive results"
+        end
+      end
+
+      def result_path
+        result_dir = File.expand_path('~/.sp')
+        FileUtils.mkdir_p(result_dir)
+        @result_path ||= File.expand_path(File.join(result_dir, "sp-#{@host}-#{Time.now.to_i}.dump"))
+      end
+
+      def save_results
+        File.open(result_path, 'wb') {|f| f << @results }
+        puts "Saved results to #{result_path}"
+      end
+
+      def enter_console
+        StackProf::CLI.start(result_path)
+      end
+
+      private
+      def check_host
+        if !host || !URI.parse(host)
+          raise "Please supply a valid host to connect to (#{host})"
+        end
+      end
+    end
+  end
+end

data/lib/stackprof/remote/middleware.rb

@@ -0,0 +1,88 @@
+require 'fileutils'
+require 'stackprof'
+
+module StackProf
+  module Remote
+    # Middleware is a simple Rack middleware that handles requests to
+    # urls matching /__stackprof__ for starting/stopping a profile
+    # session and retreiving the dump files. It delegates to the
+    # ProcessReportCollector to do the actual work of collecting
+    # and combining the dumps.
+    class Middleware
+      class << self
+        attr_accessor :enabled, :logger, :options
+
+        def enabled?(env)
+          if enabled.respond_to?(:call)
+            enabled.call(env)
+          else
+            enabled
+          end
+        end
+      end
+
+      def initialize(app, options = {})
+        @app       = app
+        self.class.logger   = options.delete(:logger) || Logger.new(STDOUT)
+        self.class.options  = options
+        logger.info "[stackprof] Stackprof Middleware enabled"
+      end
+
+      def call(env)
+        path = env['PATH_INFO']
+        if in_stackprof?(path)
+          handle_stackprof(path)
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+      def logger
+        self.class.logger
+      end
+
+      def in_stackprof?(path)
+        path =~ /^\/__stackprof__/
+      end
+
+      def handle_stackprof(path)
+        sp = StackProf::Remote::ProcessReportCollector.new(options)
+        if path =~ /start/
+          logger.debug "[stackprof] Starting StackProf"
+          sp.start
+          [200, {'Content-Type' => 'text/plain'}, ["StackProf Started"]]
+        elsif path =~ /stop/
+          logger.debug "[stackprof] Flushing StackProf"
+          sp.stop
+          sp.save
+          if results = sp.marshaled_results
+            [200, {'Content-Type' => 'binary/octet-stream'}, [results]]
+          else
+            [404, {'Content-Type' => 'text/plain'}, ["404 StackProf Results Not Found"]]
+          end
+        end
+      end
+    end
+
+    module ReportSaver
+      def self.marshaled_results
+        if results = StackProf.results
+          Marshal.dump(results)
+        end
+      end
+
+      def self.save(base_path)
+        if results = marshaled_results
+          FileUtils.mkdir_p(base_path)
+          filename = "stackprof-#{Process.pid}-#{Time.now.to_i}.dump"
+          path     = File.expand_path(File.join(base_path, filename))
+          File.open(path, 'wb') do |f|
+            f.write results
+          end
+          path
+        end
+      end
+    end
+  end
+end

data/lib/stackprof/remote/process_report_collector.rb

@@ -0,0 +1,86 @@
+require 'stackprof/report'
+require 'rbtrace/rbtracer'
+
+module StackProf
+  module Remote
+    # ProcessReportCollector handles the work of actually starting,
+    # stopping, and collecting the dumps from the StackProf profiler.
+    #
+    # Internally it uses RBTrace to execute the start/stop methods
+    # against all runnign processes that match pids found by the :pid_finder
+    # option. By default this matches unicorn workers.
+    class ProcessReportCollector
+      DEFAULT_OPTIONS = {
+        :pid_finder => -> {
+          `pgrep -f 'unicorn worker'`.strip.split.collect {|p| p.to_i }
+        },
+        :mode => :cpu,
+        :interval => 1000,
+        :raw => true,
+        :path => 'tmp'
+      }.freeze
+
+      def initialize(options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        collect_pids
+      end
+
+      def logger
+        StackProf::Remote::Middleware.logger
+      end
+
+      def start
+        command = "StackProf.start(mode: #{@options[:mode].inspect}, interval: #{@options[:interval].inspect}, raw: #{@options[:raw].inspect})"
+        execute(command)
+      end
+
+      def stop
+        command = "StackProf.stop"
+        execute(command)
+      end
+
+      def save
+        command = "StackProf::Remote::ReportSaver.save('#{@options[:path]}')"
+        @saved_files = execute(command)
+      end
+
+      def marshaled_results
+        if @saved_files
+          saved_data = @saved_files.collect {|f|
+            Marshal.load(File.read(f))
+          }
+          Marshal.dump(saved_data)
+        end
+      end
+
+      def self.report_from_marshaled_results(marshaled_data)
+        data = Marshal.load(marshaled_data)
+        report = data.inject(nil) {|sum, d| sum ? StackProf::Report.new(d) + sum : StackProf::Report.new(d) }
+      end
+
+      private
+      def collect_pids
+        logger.debug "[stackprof] Collecting PIDs"
+        @pids = @options[:pid_finder].call
+        @pids -= [Process.pid]
+        logger.debug "[stackprof] Found PIDs #{@pids.inspect} and current #{Process.pid}"
+      end
+
+      def execute(command)
+        logger.debug "[stackprof] execute: #{command}"
+        results = @pids.collect do |pid|
+          begin
+            tracer = RBTracer.new(pid)
+            output = tracer.eval(command)
+          ensure
+            tracer.detach
+            output
+          end
+        end
+        results << eval(command)
+        logger.debug "[stackprof] Results: #{results.inspect}"
+        results
+      end
+    end
+  end
+end

data/lib/stackprof-remote.rb

@@ -0,0 +1,2 @@
+require 'stackprof/remote/middleware'
+require 'stackprof/remote/client'

data/stackprof-remote.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: stackprof-remote 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "stackprof-remote"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Aaron Quint"]
+  s.date = "2014-06-13"
+  s.description = "stackprof-remote consists of a middleware for easy creation and retreival of\n                       stackprof sampling profiler dumps from a remote machine, and a wrapper around\n                       pry (stackprof-cli) to create an interactive session for navigating stackprof\n                       dumps."
+  s.email = "aaron@quirkey.com"
+  s.executables = ["stackprof-cli", "stackprof-remote"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/stackprof-cli",
+    "bin/stackprof-remote",
+    "lib/stackprof-remote.rb",
+    "lib/stackprof/cli.rb",
+    "lib/stackprof/remote/client.rb",
+    "lib/stackprof/remote/middleware.rb",
+    "lib/stackprof/remote/process_report_collector.rb",
+    "stackprof-remote.gemspec",
+    "test/helper.rb",
+    "test/test_stackprof-remote.rb"
+  ]
+  s.homepage = "http://github.com/quirkey/stackprof-remote"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.1"
+  s.summary = "A Middleware and CLI for fetching and interacting with StackProf dumps"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rbtrace>, ["~> 0.4.3"])
+      s.add_runtime_dependency(%q<stackprof>, ["~> 0.2.6"])
+      s.add_runtime_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<rbtrace>, ["~> 0.4.3"])
+      s.add_dependency(%q<stackprof>, ["~> 0.2.6"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rbtrace>, ["~> 0.4.3"])
+    s.add_dependency(%q<stackprof>, ["~> 0.2.6"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,34 @@
+require 'simplecov'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'stackprof-remote'
+
+class Test::Unit::TestCase
+end

data/test/test_stackprof-remote.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestStackprofRemote < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: stackprof-remote
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aaron Quint
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbtrace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  stackprof-remote consists of a middleware for easy creation and retreival of
+                         stackprof sampling profiler dumps from a remote machine, and a wrapper around
+                         pry (stackprof-cli) to create an interactive session for navigating stackprof
+                         dumps.
+email: aaron@quirkey.com
+executables:
+- stackprof-cli
+- stackprof-remote
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/stackprof-cli
+- bin/stackprof-remote
+- lib/stackprof-remote.rb
+- lib/stackprof/cli.rb
+- lib/stackprof/remote/client.rb
+- lib/stackprof/remote/middleware.rb
+- lib/stackprof/remote/process_report_collector.rb
+- stackprof-remote.gemspec
+- test/helper.rb
+- test/test_stackprof-remote.rb
+homepage: http://github.com/quirkey/stackprof-remote
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A Middleware and CLI for fetching and interacting with StackProf dumps
+test_files: []