rack-bug-speedtracer 0.0.1

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,243 @@
+require 'rubygems'
+require 'rubygems/installer'
+require 'rake/gempackagetask'
+require 'rake/gemcutter'
+require 'hanna/rdoctask'
+require 'spec/rake/spectask'
+require 'mailfactory'
+require 'net/smtp'
+
+require File.dirname(__FILE__) +'/gemspec'
+require 'spec/rake/verify_rcov'
+
+PACKAGE_DIR = "pkg"
+directory "doc"
+
+#spec_files = FileList["spec/**/*.rb"]
+
+RakeConfig = {
+  :email_servers => [ {
+  :server => "ruby-lang.org", 
+  :helo => "gmail.com"
+} ],
+  :announce_to_email => "ruby-talk@ruby-lang.org"
+}
+
+class SpecTask < Spec::Rake::SpecTask
+  def initialize(name=:spec)
+    super(name) do
+      @spec_files = FileList["spec/**/*"]
+      @libs = [%w{spec_help interpose}, %w{lib}, %w{spec_help}].map do|dir|
+        File::join(File::dirname(__FILE__), *dir)
+      end
+      @ruby_opts = %w{-rubygems}
+      self.spec_opts= %w{-f s --diff c --color}
+      @rcov_opts = %w{--exclude ^gemspec.rb,^spec/,^spec_help/ --sort coverage --threshold 101 -o doc/coverage --xrefs --no-color} 
+      @rcov = true
+      @failure_message = "Spec examples failed."
+      @verbose = true
+      yield(self) if block_given?
+    end
+  end
+
+  def spec_opts=(opts)
+    @spec_opts = %w{-r cbt-tweaker -f e:last_run} + opts + %w{-r spec_helper -p spec/**/*.rb}
+  end
+end
+
+task :needs_root do
+  unless Process::uid == 0
+    fail "This task must be run as root"
+  end
+end
+
+desc "Run failing examples if any exist, otherwise, run the whole suite"
+task :spec => "spec:quick"
+
+namespace :spec do
+  desc "Always run every spec"
+  SpecTask.new(:all)
+
+  desc "Generate spec/spec.opts"
+  SpecTask.new(:spec_opts) do |t|
+    t.spec_opts= %w{-f s --diff c --color --generate-options spec/spec.opts}
+    t.rcov = false
+  end
+
+  desc "Generate specifications documentation"
+  SpecTask.new(:doc) do |t|
+    t.spec_opts = %w{-f s:doc/Specifications -b}
+    t.failure_message = "Failed generating specification docs"
+    t.verbose = false
+  end
+
+  desc "Run specs with Ruby profiling"
+  SpecTask.new(:profile) do |t|
+    t.ruby_opts += %w{-rprofile}
+  end
+
+  desc "Run only failing examples"
+  SpecTask.new(:quick) do |t|
+    t.spec_opts = %w{-f s --diff c --color --example last_run -b}
+    t.rcov = false
+    t.failure_message = "Spec examples failed."
+  end
+
+  desc "Run rspecs prior to a package publication"
+  SpecTask.new(:check) do |t|
+    t.spec_opts = %w{--format p:/dev/null}  
+    t.failure_message = "Package does not conform to spec"
+    t.verbose = false
+  end
+
+  desc "Open firefox to view RCov output"
+  task :view_coverage => :doc do |t|
+    sh "/usr/bin/chromium coverage/index.html"
+  end
+end
+
+namespace :package do
+  RCov::VerifyTask.new do |t|
+    t.require_exact_threshold = false
+    t.threshold = 80
+    t.verbose = true
+  end
+  task :verify_rcov => ['spec:doc']
+
+  task :chown_coverage do
+    unless (user = ENV['SUDO_USER']).nil?
+      FileUtils::chown_R(user, ENV['SUDO_GID'].to_i, 'coverage')
+    end
+  end
+
+  package = Rake::GemPackageTask.new(SPEC) {|t|
+    t.need_tar_gz = true
+    t.need_tar_bz2 = true
+  }
+  task(:package).prerequisites.each do |package_type|
+    file package_type => "spec:check"
+  end
+
+  Rake::RDocTask.new(:docs) do |rd|
+    rd.options += SPEC.rdoc_options
+    rd.rdoc_dir = 'rubydoc'
+    rd.rdoc_files.include("lib/**/*.rb")
+    rd.rdoc_files += (SPEC.extra_rdoc_files)
+  end
+  task :docs => ['spec:doc']
+end
+
+desc "Publish the gem and its documentation to Rubyforge and Gemcutter"
+task :publish => ['publish:docs', 'publish:rubyforge', 'publish:gem:push']
+namespace :publish do
+  desc "Deploy gem via scp"
+  task :scp, :dest, :destpath, :needs => :package do |t, args|
+    destpath = args[:destpath] || "~"
+    sh "scp", File::join(package.package_dir, package.gem_file), "#{args[:dest]}:#{destpath}"
+    sh *(%w{ssh} + [args[:dest]] +  %w{sudo gem install} + [File::join(destpath, package.gem_file)])
+  end
+
+  task :sign_off => %w{package:verify_rcov package:gem package:chown_coverage}
+
+  Rake::Gemcutter::Tasks.new(SPEC)
+  task 'gem:push' => :sign_off
+  task 'gem:install' => [:needs_root, :sign_off]
+  task 'gem:reinstall' => :needs_root
+
+  desc 'Publish RDoc to RubyForge'
+  task :docs => 'package:docs' do
+    config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
+    host = "#{config["username"]}@rubyforge.org"
+    remote_dir = "/var/www/gforge-projects/#{RUBYFORGE[:group_id]}"
+    local_dir = 'rubydoc'
+    sh %{rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}}
+  end
+
+  task :scrape_rubyforge do
+    require 'rubyforge'
+    forge = RubyForge.new
+    forge.configure
+    forge.scrape_project(RUBYFORGE[:package_id])
+  end
+
+  desc "Publishes to RubyForge"
+  task :rubyforge => ['package:verify_rcov', 'package:package', :docs, :scrape_rubyforge] do |t|
+    require 'rubyforge'
+    forge = RubyForge.new
+    forge.configure
+    files = [".gem", ".tar.gz", ".tar.bz2"].map do |extension|
+      File::join(PACKAGE_DIR, SPEC.full_name) + extension
+    end
+    release = forge.lookup("release", RUBYFORGE[:package_id])[RUBYFORGE[:release_name]] rescue nil
+    if release.nil?
+      forge.add_release(RUBYFORGE[:group_id], RUBYFORGE[:package_id], RUBYFORGE[:release_name], *files)
+    else
+      files.each do |file|
+        forge.add_file(RUBYFORGE[:group_id], RUBYFORGE[:package_id], RUBYFORGE[:release_name], file)
+      end
+    end
+  end
+end
+
+def announcement # :nodoc:
+  changes = ""
+  begin
+    File::open("./Changelog", "r") do |changelog|
+      changes = "Changes:\n\n"
+      changes += changelog.read
+    end
+  rescue Exception
+  end
+
+  urls = "Project: #{RUBYFORGE[:project_page]}\n" +
+         "Homepage: #{RUBYFORGE[:home_page]}"
+
+  subject = "#{SPEC.name} #{SPEC.version} Released"
+  title = "#{SPEC.name} version #{SPEC.version} has been released!"
+  body = "#{SPEC.description}\n\n#{changes}\n\n#{urls}"
+
+  return subject, title, body
+end
+
+desc 'Announce release on RubyForge and email'
+task :press => ['press:rubyforge', 'press:email']
+namespace :press do
+  desc 'Post announcement to rubyforge.'
+  task :rubyforge do
+    require 'rubyforge'
+    subject, title, body = announcement
+
+    forge = RubyForge.new
+    forge.configure
+    forge.post_news(RUBYFORGE[:group_id], subject, "#{title}\n\n#{body}")
+    puts "Posted to rubyforge"
+  end
+
+  desc 'Generate email announcement file.'
+  task :email do
+    require 'rubyforge'
+    subject, title, body= announcement
+
+    mail = MailFactory.new
+    mail.To = RakeConfig[:announce_to_email]
+    mail.From = SPEC.email
+    mail.Subject = "[ANN] " + subject
+    mail.text = [title, body].join("\n\n")
+
+    File.open("email.txt", "w") do |mailfile|
+      mailfile.write mail.to_s
+    end
+    puts "Created email.txt"
+
+    RakeConfig[:email_servers].each do |server_config|
+      begin
+        Net::SMTP.start(server_config[:server], 25, server_config[:helo], server_config[:username], server_config[:password]) do |smtp|
+          smtp.send_message(mail.to_s, mail.From, mail.To)
+        end
+        break
+      rescue Object => ex
+        puts ex.message
+      end
+    end
+  end
+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-bug-speedtracer.rb

@@ -0,0 +1 @@
+require 'rack/bug/speedtracer'

data/lib/rack/bug/speedtracer.rb

@@ -0,0 +1,56 @@
+require 'rack/bug'
+require 'yajl'
+require 'uuid'
+
+require 'rack/bug/speedtracer/trace-app'
+require 'rack/bug/speedtracer/tracer'
+
+module Rack::Bug
+  class SpeedTracer < Panel
+    include Rack::Bug::SpeedTrace::Render
+
+    def self.database
+      @db ||= {}
+    end
+
+    def database
+      self.class.database
+    end
+
+    def initialize(app)
+      @app  = app
+      @uuid = UUID.new
+      super
+    end
+
+    def panel_app
+      return SpeedTrace::TraceApp.new(database)
+    end
+
+    def name
+      "speedtracer"
+    end
+
+    def heading
+      "#{database.keys.length} traces"
+    end
+
+    def content
+      render_template "traces", :traces => database
+    end
+
+    def before(env)
+      env['st.id']   = @uuid.generate
+
+      tracer = SpeedTrace::Tracer.new(env['st.id'], env['REQUEST_METHOD'], env['REQUEST_URI'])
+      env['st.tracer'] = tracer
+      Thread::current['st.tracer'] = tracer
+    end
+
+    def after(env, status, headers, body)
+      env['st.tracer'].finish
+      database[env['st.id']] = env['st.tracer']
+      headers['X-TraceUrl'] = '/speedtracer?id=' + env['st.id']
+    end
+  end
+end

data/lib/rack/bug/speedtracer/default-rails-tracing.rb

@@ -0,0 +1,13 @@
+require "rack/bug/speedtracer/duck-puncher"
+
+find_constant("ActionView::Template"){|avt| avt.trace_methods :render_template}
+
+find_constant("ActiveRecord::Base") do |ar_b| 
+  ar_b.trace_class_methods :find, :all, :first, :last, :count, :delete_all
+  ar_b.trace_methods :save, :save!, :destroy, :delete
+end
+
+find_constant("ActionController::Base") do |ac_b|
+  ac_b.trace_methods :process, :render
+end
+

data/lib/rack/bug/speedtracer/duck-puncher.rb

@@ -0,0 +1,82 @@
+require 'rack/bug/speedtracer'
+
+module Kernel
+  def find_constant(name)
+    parts = name.split("::")
+    begin
+      const = parts.inject(Kernel) do |namespace, part|
+        namespace.const_get(part)
+      end
+    rescue NameError => ex
+      warn "Couldn't find #{name}"
+      return nil
+    end
+    yield(const) if block_given?
+    return const
+  end
+
+#        trace_run(method_name, context, caller[1], *args) do
+  def trace_run(context = "::", called_at=caller[1], args=[])
+    tracer = Thread.current['st.tracer']
+    result = nil
+    if tracer.nil?
+      Rails.logger.debug{"Null trace"}
+      result = yield
+    else
+      tracer.run(context, called_at, args){ result = yield }
+    end
+    result
+  end
+end
+
+class Rack::Bug::SpeedTracer
+  class << self
+    def safe_method_names(mod, method_names)
+      unsafe_names = (mod.public_instance_methods(true) + 
+        mod.protected_instance_methods(true) + 
+        mod.private_instance_methods(true)).sort.uniq
+
+      method_names.map do |name|
+        name = name.to_s
+        prefix = "0"
+        hidden_name = ["_", prefix, name].join("_")
+        while unsafe_names.include?(hidden_name)
+          prefix = prefix.next
+          hidden_name = ["_", prefix, name].join("_")
+        end
+
+        unsafe_names << hidden_name
+        [name, hidden_name]
+      end
+    end
+  end
+end
+
+class Module
+  def trace_class_methods(*methods_names)
+    (class << self; self; end).build_tracing_wrappers('#{self.name}::', *methods_names)
+  end
+
+  def trace_methods(*methods)
+    build_tracing_wrappers('#{self.class.name}#', *methods)
+  end
+
+  def build_tracing_wrappers(context, *methods)
+    @traced ||= {}
+
+    Rack::Bug::SpeedTracer::safe_method_names(self, methods).each do |method_name, old_method|
+      next if @traced.has_key?(method_name)
+      @traced[method_name] = true
+
+      alias_method old_method, method_name
+
+      self.class_eval <<-EOC, __FILE__, __LINE__
+      def #{method_name}(*args, &block)
+        trace_run("#{context}", caller(0)[0], args) do
+          #{old_method}(*args, &block)
+        end
+      end
+      EOC
+    end
+  end
+end

data/lib/rack/bug/speedtracer/profiling.rb

@@ -0,0 +1,29 @@
+require 'rack/bug/speedtracer'
+
+module Rack::Bug
+  #Variant of the Speed Tracer Panel that performs a nearly complete profile of 
+  #all code called during a request.  Note that this will slow overall response 
+  #time by several orders of magnitude, and may return more data than 
+  #SpeedTracer is prepared to display
+  class ProfilingSpeedTracer < SpeedTracer
+    def before(env)
+      super
+      tracer = env['st.tracer']
+      Kernel::set_trace_func proc {|event, file, line, name, binding,classname|
+        case event
+        when "c-call", "call"
+          methodname = classname ? "" : classname
+          methodname += name.to_s
+          tracer.start_event(file, line, name, classname || "", "")
+        when "c-return", "return"
+          tracer.finish_event
+        end
+      }
+    end
+
+    def after(env, status, headers, body)
+      Kernel::set_trace_func(nil)
+      super
+    end
+  end
+end

data/lib/rack/bug/speedtracer/render.rb

@@ -0,0 +1,9 @@
+module Rack::Bug::SpeedTrace
+  module Render
+    include ::Rack::Bug::Render
+
+    def compiled_source(filename)
+      ::ERB.new(::File.read(::File.dirname(__FILE__) + "/../views/#{filename}.html.erb"), nil, "-").src
+    end
+  end
+end

data/lib/rack/bug/speedtracer/trace-app.rb

@@ -0,0 +1,51 @@
+module Rack::Bug
+  module SpeedTrace
+    class TraceApp
+      TRACER_PATH  = /^\/speedtracer/.freeze
+      CONTENT_TYPE = 'application/json;charset=UTF-8'.freeze
+
+      FourOhFour = [404, {"Content-Type" => "text/html"}, "App tracker doesn't know that path or id"].freeze
+
+      def initialize(db)
+        @db = db
+      end
+
+      def call(env)
+        return FourOhFour unless 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']].to_json
+          else
+            # Invalid request or missing request trace id
+            return FourOhFour
+          end
+        else
+          # SpeedTracer should only issue GET & HEAD requests
+          resp.status = 400
+        end
+
+        return resp.finish
+      end
+    end
+  end
+end

data/lib/rack/bug/speedtracer/tracer.rb

@@ -0,0 +1,212 @@
+require 'rack/bug/speedtracer/render'
+
+module Rack::Bug
+  module SpeedTrace
+    class TraceRecord
+      include Render
+      def initialize(id)
+        @id = id
+        @start = Time.now
+        @children = []
+      end
+
+      def finish; @finish = Time.now; end
+
+      def time_in_children
+        @children.inject(0) do |time, child|
+          time + child.duration
+        end
+      end
+
+      def duration
+        ((@finish - @start) * 1000).to_i
+      end
+
+      def to_json
+        Yajl::Encoder.encode(hash_representation, :pretty => true, :indent => '  ')
+      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
+
+      def symbolize_hash(hash)
+        hash.each_key do |key|
+          if String === key
+            next if hash.has_key?(key.to_sym)
+            hash[key.to_sym] = hash[key]
+          end
+        end
+      end
+    end
+
+    class ServerEvent < TraceRecord
+      attr_accessor :children
+      attr_reader :name
+
+      def initialize(id, file, line, method, context, arguments)
+        super(id)
+
+        @file = file
+        @line = line
+        @method = method
+        @context = context
+        @arguments = arguments
+        @name = [context, method, "(", arguments, ")"].join("")
+      end
+
+      def hash_representation
+        {
+          'range' => range(@start, @finish),
+          #'id' =>  @id,
+          'operation' =>  {
+          #          'sourceCodeLocation' =>  {
+          #          'className'   =>  @file,
+          #          'methodName'  =>  @method,
+          #          'lineNumber'  =>  @line
+          #        },
+          'type' =>  'METHOD',
+          'label' =>  @name
+        },
+          'children' =>  @children
+        }
+      end
+
+      def to_html
+        render_template('serverevent', 
+                        {:self_time => duration - time_in_children}.merge(symbolize_hash(hash_representation)))
+      end
+    end
+
+    class Tracer < TraceRecord
+      def initialize(id, method, uri)
+        super(id)
+
+        @method = method
+        @uri = uri
+        @event_id = 0
+        @pstack = []
+      end
+
+      #TODO: Threadsafe
+      def run(context="::", called_at = caller[0], args=[], &blk)
+        file, line, method = called_at.split(':')
+
+        method = method.gsub(/^in|[^\w]+/, '') if method
+
+        start_event(file, line, method, context, args)
+        blk.call      # execute the provided code block
+        finish_event
+      end
+
+      def short_string(item, max_per_elem = 50)
+        begin
+          string = item.inspect
+          if string.length > max_per_elem
+            case item
+            when NilClass
+              "nil"
+            when Hash
+              "{ " + item.map do |key, value|
+                short_string(key, 15) + "=>" + short_string(value, 30)
+              end.join(", ") + " }"
+            when find_constant("ActionView::Base")
+              tmpl = item.template
+              if tmpl.nil?
+                item.path.inspect
+              else
+                [tmpl.base_path, tmpl.name].join("/")
+              end
+            when find_constant("ActiveRecord::Base")
+              string = "#{item.class.name}(#{item.id})" 
+            else
+              string = item.class.name
+            end
+          else
+            string
+          end
+        rescue Exception => ex
+          "..."
+        end
+      end
+
+      def make_string_of(array)
+        array.map do |item|
+          short_string(item)
+        end.join(",")
+      end
+
+      def start_event(file, line, method, context, arguments)
+        @event_id += 1
+
+        arguments_string = make_string_of(arguments)
+        event = ServerEvent.new(@event_id, file, line, method, context, arguments_string)
+        @pstack.push event
+      end
+
+      def finish_event
+        event = @pstack.pop
+        if event.nil?
+        else
+          event.finish
+
+
+          unless (parent = @pstack.last).nil?
+            parent.children.push event
+          else
+            @children.push event
+          end
+        end
+      end
+
+      def hash_representation
+        finish
+        { 'trace' =>  {
+
+          'url' => "/speedtracer?id=#@id",
+
+          'frameStack' => {
+
+            'range' => range(@start, @finish),
+            'operation' =>  {
+            'type' =>  'HTTP',
+            'label' =>  [@method, @uri].join(' ')
+          },
+            'children' =>  @children
+
+          }, #end frameStack
+
+            'resources' => {
+            'Application' => '/', #Should get the Rails app name...
+            'Application.endpoint' => '/' #Should get the env path thing
+          }, #From what I can tell, Speed Tracer treats this whole hash as optional
+
+            'range' =>  range(@start, @finish)
+        }
+        }
+      end
+
+      def to_html
+        hash = hash_representation
+        extra = {:self_time => duration - time_in_children}
+        "<a href='#{hash['url']}'>Raw JSON</a>\n" + 
+          render_template('serverevent', extra.merge(symbolize_hash(hash['trace']['frameStack'])))
+      end
+
+      def finish
+        super()
+
+        until @pstack.empty?
+          finish_event
+        end
+        self
+      end
+    end
+  end
+end

data/lib/rack/bug/views/serverevent.html.erb

@@ -0,0 +1,10 @@
+<div class="traceblock">
+  <%=operation['label']%> - <%=range['duration']%>ms (self: <%=self_time%>ms)
+  <% unless children.empty? %>
+    <ul>
+      <% children.each do |child|%>
+        <li><%=child.to_html%></li>
+      <%end%>
+    </ul>
+  <% end %>
+</div>

data/lib/rack/bug/views/traces.html.erb

@@ -0,0 +1,8 @@
+<h3>Traces</h3>
+
+<dl>
+  <% traces.each_pair do |uuid, trace| %>
+    <dt><%= uuid %></dt>
+    <dd><%= trace.to_html %></dd>
+  <% end %>
+</dl>

data/spec/duck-puncher.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "rack/bug/speedtracer/duck-puncher"
+
+describe "Duck punching" do
+  describe "::find_constant" do
+    it "should find constants" do
+      find_constant("Rack::Bug").should == Rack::Bug
+    end
+
+    it "should yield constants" do
+      find_constant("Rack::Bug") do |rb|
+        rb.should == Rack::Bug
+      end
+    end
+    
+    it "should swallow exceptions when constants aren't found" do 
+      expect do 
+        find_constant("I::Made::This::Up")
+      end.to_not raise_error
+    end
+  end
+  describe "with tracing" do
+
+    before :each do
+      @tracer = Rack::Bug::SpeedTrace::Tracer.new(0, 'GET', '/test')
+      Thread.current["st.tracer"] = @tracer
+
+      @test_class = Class.new do
+        class << self
+          def klass_method(a,b,c)
+            b
+          end
+        end
+
+        def instance_method(a,b,c)
+          a << b
+          a << c
+        end
+
+        def other_instance_method
+        end
+      end
+    end
+
+    it "should trace instance methods" do
+      @test_class.trace_methods :instance_method
+
+      test_instance = @test_class.new
+
+      array = []
+      test_instance.instance_method(array, 1, 2)
+      array.should include(1,2)
+
+      @tracer.finish.to_json.should =~ /"operation":\s*{\s*"label":\s*"#instance_method\(\[\],1,2\)"/m
+    end
+
+    it "should trace class methods" do
+      @test_class.trace_class_methods :klass_method
+
+      @test_class.klass_method([5],6,7).should == 6
+      @tracer.finish.to_json.should =~ /"label":\s*"::klass_method\(\[5\],6,7\)"/
+
+
+    end
+  end
+end

data/spec/profiling-speedtracer.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'rack/bug/speedtracer/profiling'
+
+describe Rack::Bug::ProfilingSpeedTracer 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
+end

data/spec/speedtracer_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Rack::Bug::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::Bug::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' => {}})
+      tracer = mock(Rack::Bug::SpeedTrace::Tracer)
+      tracer.stub!(:to_json => sample_trace)
+
+      respond_with(200)
+      response = get('/speedtracer?id=test') do |st|
+        st.database['test'] = tracer
+      end
+
+      response.body.should == sample_trace
+    end
+
+    it 'should return 404 on missing trace' do
+      respond_with(404)
+      response = get('/speedtracer?id=test-missing')
+      response.status.should == 404
+    end
+  end
+end

data/spec/tracer_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Rack::Bug::SpeedTrace::Tracer do
+
+  it 'should accept unique id, method, uri on initialize' do
+    lambda { Rack::Bug::SpeedTrace::Tracer.new(1, 'GET', '/') }.should_not raise_error
+  end
+
+  describe 'response' do
+    let(:tracer) { Rack::Bug::SpeedTrace::Tracer.new(1, 'GET', '/test') }
+
+    it 'should produce decent HTML' do 
+      doc = tracer.finish.to_html
+      doc.should =~ /<div class="traceblock">\s*GET \/test/
+    end
+
+    it 'should serialize to json on finish' do
+      lambda { Yajl::Parser.parse(tracer.finish.to_json) }.should_not raise_error
+    end
+
+    it 'should conform to base speedtracer JSON schema' do
+      trace = Yajl::Parser.parse(tracer.finish.to_json)['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 '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 '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
+    before :each do
+      @tracer = Rack::Bug::SpeedTrace::Tracer.new(1, 'GET', '/test')
+    end
+
+    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.to_json)['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.to_json)['trace']
+
+      trace['frameStack']['children'].size.should == 1
+
+      child = trace['frameStack']['children'].first
+      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.to_json)['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.to_json)['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')
+    end
+  end
+end

data/spec_help/spec_helper.rb

@@ -0,0 +1,48 @@
+$LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
+
+require 'rubygems'
+require 'rack/bug/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={})
+  @errors ||= []
+  opts = {
+    'rack.run_once' => true,
+    'rack.errors' => @errors,
+    'rack-bug.panels' => []
+  }.merge(opts)
+
+  @speedtracer ||= self.class.described_class.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

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: rack-bug-speedtracer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ilya Grigorik
+- Judson Lester
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack-bug
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Rack-bug SpeedTracer panel for server side debugging
+email: judson@lrdesign.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- examples/runner.png
+- examples/runner.rb
+- lib/rack/bug/speedtracer.rb
+- lib/rack/bug/views/serverevent.html.erb
+- lib/rack/bug/views/traces.html.erb
+- lib/rack/bug/speedtracer/profiling.rb
+- lib/rack/bug/speedtracer/duck-puncher.rb
+- lib/rack/bug/speedtracer/default-rails-tracing.rb
+- lib/rack/bug/speedtracer/trace-app.rb
+- lib/rack/bug/speedtracer/render.rb
+- lib/rack/bug/speedtracer/tracer.rb
+- lib/rack-bug-speedtracer.rb
+- spec_help/spec_helper.rb
+- spec/speedtracer_spec.rb
+- spec/profiling-speedtracer.rb
+- spec/duck-puncher.rb
+- spec/tracer_spec.rb
+has_rdoc: true
+homepage: http://github.com/nyarly/rack-speedtracer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rack-bug-speedtracer
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rack::Bug Panel for server side information for Speed Tracer
+test_files: 
+- spec/speedtracer_spec.rb
+- spec/tracer_spec.rb
+- examples/runner.rb