rack-speedtracer 0.1.0

data/README.md

@@ -0,0 +1,88 @@
+Rack::SpeedTracer
+=========
+
+Blog post: [Speed Tracer Server-side Tracing with Rack](http://www.igvita.com/2010/07/19/speed-tracer-server-side-tracing-with-rack/)
+
+Rack::SpeedTracer middleware provides server-side tracing capabilities to any Rack compatible app. Include the middleware, instrument your application, and then load it in your Google Chrome + SpeedTracer to view detailed breakdown of your JavaScript/CSS load times, GC cycles, as well as, server side performance data provided by this middleware - you can preview both server side and client side performance data all within the same view in SpeedTracer!
+
+Preview of a sample, server side Rails trace (see below for setup) in SpeedTracer:
+![rails trace](http://img.skitch.com/20100717-cd31bhd5dh13sge7c2q1hefh4p.png)
+
+Todo / Wishlist
+---------------
+
+* Pluggable storage, ala rack-cache: capped mongo collection, or capped redis list would be ideal
+  * At the moment all of the data is stored directly in memory (unbounded)
+  * It would be great to have a mechanism to either (a) limit number of store traces or (b) expire them
+* Authentication / optional enable, ala rack-bug: IP-based, password based
+  * At the moment, every request will record & store a trace
+  * Could also do conditional tracing based on a request header: 'X-SpeedTracer: true'
+* Automagic Rails instrumentation for AR, layout, etc, ala rack-bug
+
+Because the middleware has no authentication, or does not yet provide a capped memory footprint, it is not ready to be run in production - use it in development mode until these mechanisms are in place. Patches are welcome, of course!
+
+How it works
+------------
+
+Rack::SpeedTracer provides a Tracer class which you can use to instrument your code. From there, the trace details are stored as a JSON blob, and a special X-TraceUrl header is sent back to the client. If the user clicks on the network resource that corresponds to a request which returned a X-TraceUrl header, then SpeedTracer will make a request to our app to load the server side trace. Rack::SpeedTracer responds to this request and returns the full trace - aka, the data is provided on demand.
+
+### Quickstart Guide ###
+
+    gem install rack-speedtracer
+
+    # in your rack app / rackup file
+    use Rack::SpeedTracer
+
+    # in your app
+    env['st.tracer'].run('name of operation') do
+      ... your code ...
+    end
+
+Check out a full sample rack app: examples/runner.rb
+
+### Manually instrumenting Rails ###
+To produce a server-side trace equivalent to one in the screenshot above:
+
+    # in your Gemfile
+    gem 'rack-speedtracer', :require => 'rack/speedtracer'
+
+    # in development.rb environment
+    config.middleware.use Rack::SpeedTracer
+
+    # define a widgets controller
+    class WidgetsController < ApplicationController
+      def index
+        env['st.tracer'].run('Widgets#index') do
+          env['st.tracer'].run("ActiveRecord: Widgets.all") do
+            Widget.all
+          end
+
+          env['st.tracer'].run('Render') { render :text => 'oh hai' }
+        end
+      end
+    end
+
+Speed Tracer
+------------
+
+Speed Tracer is a Google Chrome extension to help you identify and fix performance problems in your web applications. It visualizes metrics that are taken from low level instrumentation points inside of the browser and analyzes them as your application runs. Speed Tracer is available as a Chrome extension and works on all platforms where extensions are currently supported (Windows and Linux).
+
+Using Speed Tracer you are able to get a better picture of where time is being spent in your application. This includes problems caused by JavaScript parsing and execution, layout, CSS style recalculation and selector matching, DOM event handling, network resource loading, timer fires, XMLHttpRequest callbacks, painting, and more.
+
+* [Official SpeedTracer site](http://code.google.com/webtoolkit/speedtracer/)
+* [Install SpeedTracer](http://code.google.com/webtoolkit/speedtracer/get-started.html#downloading)
+* [Getting Started](http://code.google.com/webtoolkit/speedtracer/speed-tracer-examples.html)
+* [Google Group](https://groups.google.com/group/speedtracer/topics)
+
+License
+-------
+
+(The MIT License)
+
+Copyright © 2010 Ilya Grigorik
+
+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/Rakefile

@@ -0,0 +1,31 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'rack-speedtracer'
+    gemspec.summary = 'SpeedTracer middleware for server side debugging'
+    gemspec.description = gemspec.summary
+    gemspec.email = 'ilya@igvita.com'
+    gemspec.homepage = 'http://github.com/igrigorik/rack-speedtracer'
+    gemspec.authors = ['Ilya Grigorik']
+    gemspec.add_dependency('rack')
+    gemspec.add_dependency('uuid')
+    gemspec.add_dependency('yajl-ruby')
+    gemspec.rubyforge_project = 'rack-speedtracer'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org'
+end
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.ruby_opts = ['-rtest/unit']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/runner.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rack'
+
+$LOAD_PATH.unshift 'lib'
+require 'rack/speedtracer'
+
+class SomeApp
+  def call(env)
+    env['st.tracer'].run('computation: 5**100000') do
+      env['st.tracer'].run('computation 2: 5**10000') do
+        5**10000
+      end
+
+      env['st.tracer'].run('sleep(0.01)') { sleep(0.01) }
+
+      5**100000
+    end
+
+    env['st.tracer'].run('sleep(0.5)') do
+      sleep(0.5)
+    end
+
+    [200, {"Content-Type" => "text/plain"}, "Hello World"]
+  end
+end
+
+builder = Rack::Builder.new do
+  use Rack::CommonLogger
+  use Rack::SpeedTracer
+
+  run SomeApp.new
+end
+
+Rack::Handler::Thin.run builder.to_app, :Port => 4567

data/lib/rack/speedtracer.rb

@@ -0,0 +1,14 @@
+require 'rack'
+require 'yajl'
+require 'uuid'
+
+require 'rack/speedtracer/context'
+require 'rack/speedtracer/tracer'
+
+module Rack
+  module SpeedTracer
+    def self.new(app, options = {}, &blk)
+      Context.new(app, options, &blk)
+    end
+  end
+end

data/lib/rack/speedtracer/context.rb

@@ -0,0 +1,73 @@
+module Rack
+  module SpeedTracer
+
+    class Context
+      TRACER_PATH  = /^\/speedtracer/.freeze
+      CONTENT_TYPE = 'application/json;charset=UTF-8'.freeze
+
+      attr_accessor :db
+
+      def initialize(app, options = {}, &blk)
+        @app  = app
+        @uuid = UUID.new
+
+        # TODO: storage strategy...
+        # initialize_options with options
+        # yield self if block_given?
+
+        @db = {}
+      end
+
+      def call(env)
+        if env['PATH_INFO'].match(TRACER_PATH)
+
+          resp = Rack::Response.new('', 200)
+          resp['Content-Type'] = CONTENT_TYPE
+
+          case env['REQUEST_METHOD']
+            when 'HEAD' then
+              # SpeedTracer dispatches HEAD requests to verify the
+              # tracer endpoint when it detects the X-TraceUrl
+              # header for the first time. After the initial load
+              # the verification is cached by the extension.
+              #
+              # By default, we'll return 200.
+
+            when 'GET' then
+              # GET requests for specific trace are generated by
+              # the extension when the user expands the network
+              # resource tab. Hence, server-side tracer data is
+              # request on-demand, and we need to store it for
+              # some time.
+
+              qs = Rack::Utils.parse_query(env['QUERY_STRING'])
+              if qs['id'] && @db[qs['id']]
+                resp.write @db[qs['id']]
+              else
+                # Invalid request or missing request trace id
+                resp.status = 404
+              end
+            else
+              # SpeedTracer should only issue GET & HEAD requests
+              resp.status = 400
+          end
+
+          return resp.finish
+        end
+
+        env['st.id']   = @uuid.generate
+        env['st.tracer'] = Tracer.new(env['st.id'], env['REQUEST_METHOD'], env['REQUEST_URI'])
+
+        @status, @headers, @response = @app.call(env)
+        @db[env['st.id']] = env['st.tracer'].finish
+
+        # set the TraceUrl header to notify SpeedTracer that
+        # serverside meta-data is available for this request
+        @headers['X-TraceUrl'] = '/speedtracer?id=' + env['st.id']
+
+        [@status, @headers, @response]
+      end
+    end
+
+  end
+end

data/lib/rack/speedtracer/tracer.rb

@@ -0,0 +1,122 @@
+module Rack
+  module SpeedTracer
+
+    class TraceRecord
+      def initialize(id)
+        @id = id
+        @start = Time.now
+        @children = []
+      end
+
+      def finish; @finish = Time.now; end
+
+      private
+        # all timestamps in SpeedTracer are in milliseconds
+        def range(start, finish)
+          {
+            'duration'  =>  ((finish - start) * 1000).to_i,
+            'start'     =>  [start.to_i,  start.usec/1000].join(''),
+            'end'       =>  [finish.to_i, finish.usec/1000].join('')
+          }
+        end
+    end
+
+    class ServerEvent < TraceRecord
+      attr_accessor :children
+
+      def initialize(id, file, line, method, name)
+        super(id)
+
+        @file = file
+        @line = line
+        @method = method
+        @name = name
+      end
+
+      def to_json
+        Yajl::Encoder.encode({
+          'range' => range(@start, @finish),
+          'id' =>  @id,
+          'operation' =>  {
+            'sourceCodeLocation' =>  {
+              'className'   =>  @file,
+              'methodName'  =>  @method,
+              'lineNumber'  =>  @line
+            },
+            'type' =>  'METHOD',
+            'label' =>  @name
+          },
+          'children' =>  @children
+        })
+      end
+    end
+
+    class Tracer < TraceRecord
+      def initialize(id, method, uri)
+        super(id)
+
+        @method = method
+        @uri = uri
+        @event_id = 0
+        @pstack = []
+      end
+
+      def run(name = '', &blk)
+        file, line, method = caller.first.split(':')
+        method = method.gsub(/^in|[^\w]+/, '') if method
+
+        # SpeedTracer allows us to nest events via child relationships,
+        # which means that we can use a stack to keep track of the currently
+        # executing events to produce a proper execution tree.
+        #
+        # Example execution graph:
+        #
+        # root
+        # -- event 1
+        #    ---- event 2
+        # -- event 3
+        #    ----- event 4
+        #    ----- event 5
+        #         ------ event 6
+        #
+
+        @event_id += 1
+        event = ServerEvent.new(@event_id, file, line, method, name)
+        @pstack.push event
+
+        blk.call      # execute the provided code block
+        event.finish  # finalize current event timers
+        @pstack.pop   # pop current event from parent stack
+
+        if parent = @pstack.last
+          parent.children.push event
+        else
+          # no parent, means this is a child of root node
+          @children.push event
+        end
+      end
+
+      def finish
+        super()
+
+        Yajl::Encoder.encode({
+          'trace' =>  {
+            'date' =>  @start.to_i,
+            'application' => 'Rack SpeedTracer',
+            'range' =>  range(@start, @finish),
+            'id' =>  @id,
+            'frameStack' =>  {
+              'range' =>  range(@start, @finish),
+              'id' =>  '0',
+              'operation' =>  {
+                'type' =>  'HTTP',
+                'label' =>  [@method, @uri].join(' ')
+              },
+              'children' =>  @children
+            }
+          }
+        })
+      end
+    end
+  end
+end

data/rack-speedtracer.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rack-speedtracer}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ilya Grigorik"]
+  s.date = %q{2010-07-19}
+  s.description = %q{SpeedTracer middleware for server side debugging}
+  s.email = %q{ilya@igvita.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "README.md",
+     "Rakefile",
+     "VERSION",
+     "examples/runner.png",
+     "examples/runner.rb",
+     "lib/rack/speedtracer.rb",
+     "lib/rack/speedtracer/context.rb",
+     "lib/rack/speedtracer/tracer.rb",
+     "rack-speedtracer.gemspec",
+     "spec/spec_helper.rb",
+     "spec/speedtracer_spec.rb",
+     "spec/tracer_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/igrigorik/rack-speedtracer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rack-speedtracer}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{SpeedTracer middleware for server side debugging}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/speedtracer_spec.rb",
+     "spec/tracer_spec.rb",
+     "examples/runner.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_runtime_dependency(%q<uuid>, [">= 0"])
+      s.add_runtime_dependency(%q<yajl-ruby>, [">= 0"])
+    else
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<uuid>, [">= 0"])
+      s.add_dependency(%q<yajl-ruby>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<uuid>, [">= 0"])
+    s.add_dependency(%q<yajl-ruby>, [">= 0"])
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+$LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
+
+require 'rubygems'
+require 'rack/speedtracer'
+require 'yajl'
+require 'spec'
+require 'pp'
+
+[ STDOUT, STDERR ].each { |io| io.sync = true }
+
+def respond_with(status=200, headers={}, body=['Hello World'])
+  called = false
+  @app = lambda do |env|
+    called = true
+    response = Rack::Response.new(body, status, headers)
+    request = Rack::Request.new(env)
+
+    yield request, response if block_given?
+
+    response.finish
+  end
+
+  @app
+end
+
+def request(method, uri='/', opts={})
+  opts = {
+    'rack.run_once' => true,
+    'rack.errors' => @errors,
+  }.merge(opts)
+
+  @speedtracer ||= Rack::SpeedTracer::Context.new(@app)
+  @request = Rack::MockRequest.new(@speedtracer)
+
+  yield @speedtracer if block_given?
+
+  @request.request(method.to_s.upcase, uri, opts)
+end
+
+def get(uri, env={}, &b)
+  request(:get, uri, env, &b)
+end
+
+def head(uri, env={}, &b)
+  request(:head, uri, env, &b)
+end

data/spec/speedtracer_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Rack::SpeedTracer do
+  let(:app) { [200, {'Content-Type' => 'text/plain'}, 'Hello World'] }
+
+  describe 'middleware' do
+    it 'take a backend and returns a middleware component' do
+      Rack::SpeedTracer.new(app).should respond_to(:call)
+    end
+
+    it 'take an options Hash' do
+      lambda { Rack::Cache.new(app, {}) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe 'response' do
+    it 'should set the X-TraceUrl header after rendering the response' do
+      respond_with(200)
+      response = get('/')
+
+      response.headers.should include 'X-TraceUrl'
+      response.headers['X-TraceUrl'].should match(/^\/speedtracer\?id=/)
+    end
+
+    it 'should respond with 200 to HEAD requests to the speedtracer endpoint' do
+      respond_with(200)
+      response = head('/speedtracer?id=test')
+
+      response.status.should == 200
+      response.headers['Content-Length'].to_i.should == 0
+    end
+
+    it 'should return a stored trace in JSON format' do
+      sample_trace = Yajl::Encoder.encode({'trace' => {}})
+
+      respond_with(200)
+      response = get('/speedtracer?id=test') do |st|
+        st.db['test'] = sample_trace
+      end
+
+      response.body.should == sample_trace
+    end
+
+    it 'should return 404 on missing trace' do
+      response = get('/speedtracer?id=test-missing')
+      response.status.should == 404
+    end
+  end
+end

data/spec/tracer_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Rack::SpeedTracer::Tracer do
+
+  it 'should accept unique id, method, uri on initialize' do
+    lambda { Rack::SpeedTracer::Tracer.new(1, 'GET', '/') }.should_not raise_error
+  end
+
+  describe 'response' do
+    let(:tracer) { Rack::SpeedTracer::Tracer.new(1, 'GET', '/test') }
+
+    it 'should serialize to json on finish' do
+      lambda { Yajl::Parser.parse(tracer.finish) }.should_not raise_error
+    end
+
+    it 'should conform to base speedtracer JSON schema' do
+      trace = Yajl::Parser.parse(tracer.finish)['trace']
+
+      # Example base trace:
+      # {"date"=>1279403357,
+      #  "application"=>"Rack SpeedTracer",
+      #  "id"=>1,
+      #  "range"=>{"duration"=>0, "end"=>"1279403357651", "start"=>"1279403357651"},
+      #  "frameStack"=>
+      #   {"id"=>"0",
+      #    "range"=>{"duration"=>0, "end"=>"1279403357651", "start"=>"1279403357651"},
+      #    "operation"=>{"label"=>"GET /test", "type"=>"HTTP"},
+      #    "children"=>[]}}
+
+      trace.should include 'date'
+      trace.should include 'application'
+      trace.should include 'id'
+
+      trace.should include 'range'
+      trace['range'].should be_an_instance_of Hash
+
+      trace.should include 'frameStack'
+      trace['frameStack'].should be_an_instance_of Hash
+
+      # root node description
+      root = trace['frameStack']
+      root.should include 'id'
+      root['id'].to_i.should == 0
+
+      root.should include 'range'
+      root['range'].should be_an_instance_of Hash
+
+      root.should include 'operation'
+      root['operation'].should be_an_instance_of Hash
+      root['operation']['label'].should match('GET /test')
+      root['operation']['type'].should match('HTTP')
+
+      root.should include 'children'
+      root['children'].should be_an_instance_of Array
+    end
+  end
+
+  describe 'code tracing' do
+    let(:tracer) { Rack::SpeedTracer::Tracer.new(1, 'GET', '/test') }
+
+    it 'should provide a mechanism to trace a code block' do
+      lambda { tracer.run { sleep(0.01) }}.should_not raise_error
+    end
+
+    it 'should measure execution time in milliseconds' do
+      tracer.run { sleep(0.01) }
+      trace = Yajl::Parser.parse(tracer.finish)['trace']
+
+      trace['range']['duration'].to_i.should == 10
+    end
+
+    it 'should report traced codeblocks' do
+      tracer.run { sleep(0.01) }
+      trace = Yajl::Parser.parse(tracer.finish)['trace']
+
+      trace['frameStack']['children'].size.should == 1
+
+      child = trace['frameStack']['children'].first
+      child['id'].to_i.should == 1
+      child.should include 'operation'
+      child['operation'].should include 'label'
+      child.should include 'children'
+    end
+
+    it 'should accept optional label for each trace' do
+      tracer.run('label') { sleep(0.01) }
+      trace = Yajl::Parser.parse(tracer.finish)['trace']
+
+      trace['frameStack']['children'].first['operation']['label'].should match('label')
+    end
+
+    it 'should produce nested traces' do
+      tracer.run('parent') do
+        tracer.run('child') { sleep(0.01) }
+      end
+
+      trace = Yajl::Parser.parse(tracer.finish)['trace']
+
+      parent = trace['frameStack']['children'].first
+      parent['operation']['label'].should match('parent')
+      parent['children'].size.should == 1
+
+      child = parent['children'].first
+      child['operation']['label'].should match('child')
+      child['id'].to_i.should == 2
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: rack-speedtracer
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: SpeedTracer middleware for server side debugging
+email: ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- examples/runner.png
+- examples/runner.rb
+- lib/rack/speedtracer.rb
+- lib/rack/speedtracer/context.rb
+- lib/rack/speedtracer/tracer.rb
+- rack-speedtracer.gemspec
+- spec/spec_helper.rb
+- spec/speedtracer_spec.rb
+- spec/tracer_spec.rb
+has_rdoc: true
+homepage: http://github.com/igrigorik/rack-speedtracer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rack-speedtracer
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SpeedTracer middleware for server side debugging
+test_files: 
+- spec/spec_helper.rb
+- spec/speedtracer_spec.rb
+- spec/tracer_spec.rb
+- examples/runner.rb