rack-profiler 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f67856e0027806b21c8fa11c400055049be97e5f
-  data.tar.gz: 50a680263ec4263e64cf53f63ff991bed6d6bd8e
+  metadata.gz: 10111d8a7faa32f82444b864868a3364a4c557b3
+  data.tar.gz: b77adab1e71c584c5075da95b8eb60f737c84d79
 SHA512:
-  metadata.gz: 8df8668240edd5c83482b5f9c67efd68c191af79fc279eb6f704af00139ad98a1b219f4cfa8c481ec557b6761be64f8891d1b09cdb754a1833fa442653c03875
-  data.tar.gz: 18c2d0048b5bc978d7937ca24b8d727ef2b815f00e1a097cbfca81538c33ecf5ef799ef86435e0728ab828fe41a6c61c3e5f9a1a8c58a69a375c7540eaf1910d
+  metadata.gz: 3306764da5aa9f681a1025ce5a0c43ea7cd08d210b8813e0a8e9ff7ab93ab7551ffdf11305479a28f7889e2641a0207170e32ed21e84b6c27117580529494514
+  data.tar.gz: 0647b6ba8a86a09f3d45e2d71c3c71164d494637364cdfdb8af90865ab1a488affc1fe115c9d2530f39f18af3ae53e638bf9b15f3a3e950a594a9d4d8d290fde

data/README.md

@@ -1,6 +1,21 @@
 # Rack::Profiler
 
-Simple profiler for Rack applications
+Simple profiler for Rack applications (Sinatra and Ruby on Rails for example).
+
+`Rack::Profiler` uses the [Active Support Instrumentation API](http://guides.rubyonrails.org/active_support_instrumentation.html)
+and subscribes to the following hooks:
+
+  * [sql.active_record](http://guides.rubyonrails.org/active_support_instrumentation.html#sql-active-record)
+  * [render_template.action_view](http://guides.rubyonrails.org/active_support_instrumentation.html#render_template.action_view)
+  * [render_partial.action_view](http://guides.rubyonrails.org/active_support_instrumentation.html#render_partial.action_view)
+  * [process_action.action_controller](http://guides.rubyonrails.org/active_support_instrumentation.html#process_action.action_controller)
+
+You can also define your own events, by wrapping your code with the
+[`Rack::Profiler.step`](#custom-steps).
+
+`Rack::Profiler` is easy to integrate in any Rack application and it produces a
+JSON response with the results. It also exposes a simple web dashboard to directly
+issue HTTP requests to your application and see the results of the profiling.
 
 ## Installation
 
@@ -10,6 +25,8 @@ Add this line to your application's Gemfile:
 gem 'rack-profiler'
 ```
 
+*You might want to put the gem in the development group if you are using Rails.*
+
 And then execute:
 
     $ bundle
@@ -18,7 +35,7 @@ Or install it yourself as:
 
     $ gem install rack-profiler
 
-## Usage
+### Rack/Sinatra
 
 In your `config.ru` use the `Rack::Profiler` middleware at the beginning of your
 middleware stack:
@@ -28,21 +45,31 @@ require 'rack/profiler'
 use Rack::Profiler
 ```
 
-By default `Rack::Profiler` will subscribe to `ActiveRecord` SQL queries and to
-steps you define in your code with:
+### Rails
+
+You can add the `Rack::Profiler` middleware at the beginning of your `config.ru`
+like in the Rack/Sinatra installation or insert it in the middlewares stack configuration
+in the `application.rb`:
 
 ```ruby
-Rack::Profiler.step('your-step-name') do
-  # Do stuff. The profiler will tell you how long it took to perform this step
+module YourApp
+  class Application < Rails::Application
+
+    # ...
+    config.middleware.insert_before Rack::Runtime, Rack::Profiler
+
+  end
 end
 ```
 
-You can also subscribe to more notifications:
+## Configuration
+
+You can configure `Rack::Profiler` to subscribe to more notifications:
 
 ```ruby
-Rack::Profiler.configure do |profiler|
-  # Subscribe to template rendering in a Rails app
-  profiler.subscribe('render_template.action_view')
+Rack::Profiler.configure do |config|
+  # Subscribe to email delivery in a Rails app
+  config.subscribe('deliver.action_mailer')
 end
 ```
 
@@ -50,12 +77,52 @@ You can also specify a backtrace filter to exclude lines that are not
 interesting:
 
 ```ruby
-Rack::Profiler.configure do |profiler|
+Rack::Profiler.configure do |config|
   # Exclude gems from the backtrace
-  profiler.filter_backtrace { |line| !line.include? '/gems/' }
+  config.filter_backtrace { |line| !line.include? '/gems/' }
 end
 ```
 
+You can put these configurations in your `config.ru` for a Rack/Sinatra application
+or in an initializer `config/rack_profiler.rb` for Rails apps.
+
+## Usage
+
+### Custom steps
+
+By default `Rack::Profiler` will subscribe to `ActiveRecord` SQL queries,
+`ActionView` rendering events (templates and partials), `ActionController`
+actions and to steps you define in your code with:
+
+```ruby
+Rack::Profiler.step('your-step-name') do
+  # Do stuff. The profiler will tell you how long it took to perform this step
+end
+```
+
+### Web Dashboard
+
+A graphical interface to profile your application pages/endpoints and display the
+results is automatically mounted at this route:
+
+    http://<your-app-url>/rack-profiler
+
+Just select the HTTP verb, insert the relative path to your app and add some
+optional parameters like POST/PUT data: `Rack::Profiler` automatically send
+the request to your app with the `rack-profiler` param and display the
+results in a nice graphical way.
+
+
+### Raw JSON result
+
+If you want to access the results of the profiling as raw JSON data, you can just
+add the `rack-profiler` parameter (it can be null) to any HTTP request
+to your app (GET, POST, PUT, PATCH, DELETE): `Rack::Profiler` will execute the
+request and return a JSON response containing the results along with the
+original response.
+
+    http://<your-app-url>/<path>?rack-profiler
+
 ## Contributing
 
 1. Fork it ( https://github.com/dawanda/rack-profiler/fork )

data/lib/rack/profiler.rb

@@ -1,3 +1,5 @@
+require "rack"
+require "rack/request"
 require "rack/profiler/version"
 require "active_support/notifications"
 
@@ -6,22 +8,12 @@ module Rack
     class DummyError < StandardError; end
 
     module ClassMethods
-      attr_reader :backtrace_filter
-
       def configure(&block)
-        instance_exec(self, &block)
-      end
-
-      def filter_backtrace(&block)
-        @backtrace_filter = block
+        block.call(config)
       end
 
-      def dashboard_path=(path)
-        @dashboard_path = path
-      end
-
-      def dashboard_path
-        @dashboard_path || '/rack-profiler'
+      def config
+        @config ||= Configuration.new
       end
 
       def step(name, payload = {})
@@ -29,37 +21,42 @@ module Rack
           yield
         end
       end
+    end
+
+    class Configuration
+      attr_reader :subscriptions, :backtrace_filter
+      attr_accessor :dashboard_path
+
+      DEFAULT_SUBSCRIPTIONS = ['sql.active_record',
+                               'render_template.action_view',
+                               'render_partial.action_view',
+                               'process_action.action_controller',
+                               'rack-profiler.total_time',
+                               'rack-profiler.step']
 
-      def render_dashboard
-        dashboard = ::File.expand_path( '../../public/rack-profiler.html', ::File.dirname( __FILE__ ) )
-        body      = ::File.open(dashboard, ::File::RDONLY)
-        [200, { 'Content-Type' => 'text/html' }, body]
+      def initialize
+        @subscriptions  = DEFAULT_SUBSCRIPTIONS.clone
+        @dashboard_path = '/rack-profiler'
       end
 
-      def subscribe(name)
-        (@subscriptions ||= []) << name
+      def subscribe(*names)
+        names.each { |name| @subscriptions << name }
         @subscriptions.uniq!
       end
 
-      def subscriptions
-        @subscriptions || []
+      def filter_backtrace(&block)
+        @backtrace_filter = block
       end
     end
 
     extend ClassMethods
 
-    # Subscribe to interesting events
-    subscribe('sql.active_record')
-    subscribe('render_template.action_view')
-    subscribe('render_partial.action_view')
-    subscribe('process_action.action_controller')
-    subscribe('rack-profiler.step')
-
     attr_reader :events
 
     def initialize(app)
-      subscribe_all_events
-      @app = app
+      subscribe_to_all
+      @events = []
+      @app    = app
     end
 
     def call(env)
@@ -67,13 +64,22 @@ module Rack
       status, headers, body = [nil, nil, nil]
       req = Rack::Request.new(env)
 
-      if req.path == Profiler.dashboard_path
-        Profiler.render_dashboard
+      if req.path == config.dashboard_path
+        render_dashboard
       elsif req.params.has_key?('rack-profiler')
-        Profiler.step('total_time') do
+        ActiveSupport::Notifications.instrument('rack-profiler.total_time') do
           status, headers, body = @app.call(env)
         end
-        [200, { 'Content-Type' => 'application/json' }, [{ events: nested_events, response: { status: status, headers: headers, body: stringify_body(body) } }.to_json]]
+        [ 200,
+          { 'Content-Type' => 'application/json' },
+          [ { events:   events.sort_by { |event| event[:start] },
+              response: {
+                status:  status,
+                headers: headers,
+                body:    stringify_body(body)
+              }
+            }.to_json ]
+        ]
       else
         @status, @headers, @body = @app.call(env)
       end
@@ -95,28 +101,23 @@ module Rack
       end
     end
 
-    def nested_events
-      events.sort_by { |evt| evt[:start] }.reduce([]) do |list, evt|
-        nest_event(list, list, evt)
-      end
+    def config
+      self.class.config
     end
 
     private
 
-    def subscribe_all_events
-      self.class.subscriptions.each do |event|
-        subscribe(event)
-      end
+    def render_dashboard
+      dashboard = ::File.expand_path( '../../public/rack-profiler.html', ::File.dirname( __FILE__ ) )
+      body      = ::File.open(dashboard, ::File::RDONLY)
+      [200, { 'Content-Type' => 'text/html' }, body]
     end
 
-    def nest_event(list, children, evt)
-      previous = children.last
-      if previous && evt[:finish] <= previous[:finish]
-        nest_event(list, previous[:children] ||= [], evt)
-      else
-        children << evt
+    def subscribe_to_all
+      # Subscribe to interesting events
+      config.subscriptions.each do |event|
+        subscribe(event)
       end
-      list
     end
 
     def tap_backtrace
@@ -128,17 +129,17 @@ module Rack
     end
 
     def filtered_backtrace(backtrace)
-      if self.class.backtrace_filter.nil?
+      if config.backtrace_filter.nil?
         backtrace
       else
-        backtrace.select(&self.class.backtrace_filter)
+        backtrace.select(&config.backtrace_filter)
       end
     end
 
     def stringify_body(body)
       body.close if body.respond_to?(:close)
       str = ""
-      body.each {|part| str << part }
+      body.each { |part| str << part }
       str
     end
   end

data/lib/rack/profiler/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class Profiler
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/public/rack-profiler.html

@@ -16,6 +16,9 @@
       .response-info {
         margin-bottom: 1em;
       }
+        .response-info pre {
+          max-height: 350px;
+        }
 
       .pr-steps td:first-child {
         width: 800px;
@@ -23,7 +26,7 @@
 
       .step-bar {
         display: inline-block;
-        background: #5bc0de;
+        background: #777;
         position: relative;
         box-sizing: border-box;
         margin-top: 0.2em;
@@ -31,6 +34,10 @@
         box-shadow: inset 0 -1px 0 rgba(0, 0, 0, .15)
       }
 
+      .step-bar.step-type-step {
+        background: #5bc0de;
+      }
+
       .step-bar.step-type-sql {
         background: #f0ad4e;
       }
@@ -51,6 +58,7 @@
         background-color: #f5f5f5;
         border: 1px solid #ccc;
         border-radius: 4px;
+        overflow-wrap: break-word;
       }
 
       .key-value-list li {
@@ -237,8 +245,11 @@
             .done(function( data, status, xhr ) {
               $(".stats").show()
 
-              var rootEvent     = data.events[0],
-                  queryCount    = 0,
+              var rootEvent = data.events.filter(function(event) {
+                return event.name == 'rack-profiler.total_time'
+              })[0]
+
+              var queryCount    = 0,
                   headersKeyVal = exposeKeyValues( data.response.headers ),
                   responseWrap  = $.extend( {}, data.response, { headers: headersKeyVal } )
 
@@ -270,6 +281,7 @@
                     case 'render_template.action_view':      eventType = 'render-template'; break;
                     case 'process_action.action_controller': eventType = 'process-action'; break;
                     case 'rack-profiler.step':               eventType = 'step'; break;
+                    case 'rack-profiler.total_time':         eventType = 'total-time'; break;
                     default:                                 eventType = 'other'
                   }
 
@@ -285,10 +297,6 @@
                   }
                   $(".pr-steps tbody").append( Mustache.render( stepTmpl, stepEvent ) )
 
-                  // Recurse on children
-                  if ( event.children ) {
-                    renderEvents( event.children )
-                  }
                 })
               }
 

data/rack-profiler.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "rack"
   spec.add_dependency "activesupport", ">= 3.0.0"
 
   spec.add_development_dependency "bundler", "~> 1.7"

data/spec/rack/profiler_spec.rb

@@ -1,55 +1,50 @@
-require 'spec_helper'
+require "spec_helper"
+require 'json'
+
+def trigger_dummy_event(name, payload = {})
+  ActiveSupport::Notifications.instrument(name, payload) do
+    "do stuff"
+  end
+end
 
 describe Rack::Profiler do
   let(:profiler) { Rack::Profiler.new(nil) }
 
-  def trigger_dummy_event(name, payload = {})
-    ActiveSupport::Notifications.instrument(name, payload) do
-      "do stuff"
-    end
+  it "has a version number" do
+    expect(Rack::Profiler::VERSION).not_to be_nil
   end
 
-  it 'has a version number' do
-    expect(Rack::Profiler::VERSION).not_to be nil
-  end
+  describe :initialize do
+    it "subscribes to all subscriptions" do
+      config = Rack::Profiler::Configuration.new
+      config.subscribe("bar")
+      allow(Rack::Profiler).to receive(:config).and_return(config)
 
-  describe :nested_events do
-    it "returns events properly nested" do
-      evt1 = { start: 1, finish: 10 }
-      evt2 = { start: 2, finish: 3 }
-      evt3 = { start: 4, finish: 8 }
-      evt4 = { start: 5, finish: 8 }
-      evt5 = { start: 9, finish: 10 }
-      evts = [evt1, evt2, evt3, evt4, evt5]
-      allow(profiler).to receive(:events).and_return(evts)
-      nested = profiler.nested_events
-      expect(nested.first).to be(evt1)
-      expect(evt1[:children].first).to be(evt2)
-      expect(evt1[:children][1]).to be(evt3)
-      expect(evt3[:children].first).to be(evt4)
-      expect(evt1[:children].last).to be(evt5)
+      profiler = Rack::Profiler.new(nil)
+      trigger_dummy_event("bar")
+      expect(profiler.events.last[:name]).to eq("bar")
     end
   end
 
   describe :subscribe do
     before do
-      profiler.subscribe('foo')
+      profiler.subscribe("foo")
     end
 
-    it "subscribe to event populating the event list" do
-      trigger_dummy_event('foo')
+    it "subscribes to event populating the event list" do
+      trigger_dummy_event("foo")
       event = profiler.events.last
-      expect(event[:name]).to eq('foo')
+      expect(event[:name]).to eq("foo")
     end
 
-    it "populate event with the proper keys" do
-      trigger_dummy_event('foo')
+    it "populates event with the proper keys" do
+      trigger_dummy_event("foo")
       event = profiler.events.last
       expect(event.keys).to include(:id, :name, :start, :finish, :duration, :payload, :backtrace)
     end
 
     it "adds the backtrace" do
-      trigger_dummy_event('foo')
+      trigger_dummy_event("foo")
       event = profiler.events.last
       expect(event[:backtrace].any? do |line|
         line.include?("trigger_dummy_event")
@@ -57,10 +52,10 @@ describe Rack::Profiler do
     end
 
     it "filters the backtrace if a filter was provided" do
-      Rack::Profiler.filter_backtrace do |line|
+      Rack::Profiler.config.filter_backtrace do |line|
         !line.include?("trigger_dummy_event")
       end
-      trigger_dummy_event('foo')
+      trigger_dummy_event("foo")
       event = profiler.events.last
       expect(event[:backtrace].any? do |line|
         line.include?("trigger_dummy_event")
@@ -71,37 +66,175 @@ describe Rack::Profiler do
     end
 
     it "adds the payload" do
-      trigger_dummy_event('foo', bar: 'baz')
+      trigger_dummy_event("foo", bar: "baz")
       event = profiler.events.last
-      expect(event[:payload]).to eq(bar: 'baz')
+      expect(event[:payload]).to eq(bar: "baz")
     end
   end
 
-  describe ".subscribe" do
-    it "causes any newly created instance to subscribe to the given event" do
-      Rack::Profiler.subscribe('bar')
-      profiler = Rack::Profiler.new(nil)
-      trigger_dummy_event('bar')
-      event = profiler.events.last
-      expect(event[:name]).to eq('bar')
+  describe :call do
+    let(:app) do
+      Proc.new { |env|
+        Rack::Profiler.step 'foo' do
+          [200, { 'X-My-Header' => 'foo' }, ['hello hello']]
+        end
+      }
+    end
+
+    let(:profiler) do
+      Rack::Profiler.new(app)
+    end
+
+    let(:env) do
+      {
+        "PATH_INFO" => "/",
+        "QUERY_STRING" => "",
+        "REMOTE_HOST" => "localhost",
+        "REQUEST_METHOD" => "GET",
+        "REQUEST_URI" => "http://localhost:3000/",
+        "SCRIPT_NAME" => "",
+        "SERVER_NAME" => "localhost",
+        "SERVER_PORT" => "3000",
+        "SERVER_PROTOCOL" => "HTTP/1.1",
+        "HTTP_HOST" => "localhost:3000",
+        "rack.version" => [1, 2],
+        "rack.input" => StringIO.new,
+        "rack.errors" => StringIO.new,
+        "rack.multithread" => true,
+        "rack.multiprocess" => false,
+        "rack.run_once" => false,
+        "rack.url_scheme" => "http",
+        "HTTP_VERSION" => "HTTP/1.1",
+        "REQUEST_PATH" => "/"
+      }
+    end
+
+    it "clears events" do
+      profiler.events << 'xxx'
+      profiler.call(env)
+      expect(profiler.events).not_to include('xxx')
+    end
+
+    context "when the path is config.dashboard_path" do
+      it "renders dashboard" do
+        expect(profiler).to receive(:render_dashboard)
+        profiler.call env.merge(
+          "PATH_INFO"    => profiler.config.dashboard_path,
+          "REQUEST_PATH" => profiler.config.dashboard_path
+        )
+      end
+    end
+
+    context "when the rack-profiler parameter is not present" do
+      it "transparently returns the original response" do
+        expect(profiler.call(env)).to eq(app.call(env))
+      end
+    end
+
+    context "when the rack-profiler parameter is present" do
+      let(:env_with_param) {
+        env.merge('QUERY_STRING' => 'rack-profiler')
+      }
+
+      it "returns a JSON response" do
+        status, headers, body = profiler.call(env_with_param)
+        expect(headers).to match('Content-Type' => 'application/json')
+        expect { JSON.parse(body.join) }.not_to raise_error
+      end
+
+      it "puts the original response in the JSON payload" do
+        status, headers, body = profiler.call(env_with_param)
+        parsed_body = JSON.parse(body.join)
+        expect(parsed_body['response']).to eq(
+          'status'  => 200,
+          'headers' => { 'X-My-Header' => 'foo' },
+          'body'    => 'hello hello'
+        )
+      end
+
+      it "puts the received events in the JSON payload" do
+        status, headers, body = profiler.call(env_with_param)
+        parsed_body = JSON.parse(body.join)
+        expect(
+          parsed_body['events'].map { |e| e['name'] }
+        ).to include('rack-profiler.total_time', 'rack-profiler.step')
+      end
     end
   end
 
   describe ".step" do
-    it "calls ActiveSupport::Notifications.instrument with the right arguments" do
+    it "calls ActiveSupport::Notifications.instrument with the right args" do
       expect(ActiveSupport::Notifications).to receive(:instrument).with(
-        'rack-profiler.step', { step_name: 'xxx' })
-      Rack::Profiler.step('xxx') do
+        "rack-profiler.step", { step_name: "xxx" })
+      Rack::Profiler.step("xxx") do
         "do stuff"
       end
     end
 
     it "mixes data in the payload if provided" do
       expect(ActiveSupport::Notifications).to receive(:instrument).with(
-        'rack-profiler.step', { step_name: 'xxx', foo: 'bar' })
-      Rack::Profiler.step('xxx', foo: 'bar') do
+        "rack-profiler.step", { step_name: "xxx", foo: "bar" })
+      Rack::Profiler.step("xxx", foo: "bar") do
         "do stuff"
       end
     end
   end
+
+  describe ".configure" do
+    it "executes the given block passing the configuration object" do
+      config_inside_block = nil
+      Rack::Profiler.configure do |c|
+        config_inside_block = c
+      end
+      expect(config_inside_block).to be(Rack::Profiler.config)
+    end
+  end
+
+  describe ".config" do
+    it "instantiates a Configuration object if there is none" do
+      Rack::Profiler.send(:instance_variable_set, :@config, nil)
+      expect(Rack::Profiler.config).to be_a(Rack::Profiler::Configuration)
+    end
+  end
+end
+
+describe Rack::Profiler::Configuration do
+  let(:config) { Rack::Profiler::Configuration.new }
+
+  it "has the correct defaults" do
+    expect(config.dashboard_path).to eq('/rack-profiler')
+    expect(config.backtrace_filter).to be_nil
+    expect(config.subscriptions).to include(
+      *Rack::Profiler::Configuration::DEFAULT_SUBSCRIPTIONS
+    )
+  end
+
+  describe :subscribe do
+    it "adds entries to subscriptions" do
+      config.subscribe('bar')
+      expect(config.subscriptions).to include('bar')
+    end
+
+    it "accepts more than one subscription" do
+      config.subscribe('bar', 'baz')
+      expect(config.subscriptions).to include('bar', 'baz')
+    end
+
+    it "does not add duplicates" do
+      config.subscribe('bar', 'bar')
+      expect(
+        config.subscriptions.count { |s| s == 'bar' }
+      ).to eq(1)
+    end
+  end
+
+  describe :filter_backtrace do
+    it "sets the backtrace_filter" do
+      config.filter_backtrace do |line|
+        line.include? 'foo'
+      end
+      filtered = ['foo', 'foobar', 'baz'].select(&config.backtrace_filter)
+      expect(filtered).to eq(['foo', 'foobar'])
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-profiler
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Luca Ongaro
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-26 00:00:00.000000000 Z
+date: 2015-01-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: activesupport
   requirement: !ruby/object:Gem::Requirement