rack-profiler 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10111d8a7faa32f82444b864868a3364a4c557b3
-  data.tar.gz: b77adab1e71c584c5075da95b8eb60f737c84d79
+  metadata.gz: d84a8f5ef46d358a0da6c75940fdb9c5faf28d2c
+  data.tar.gz: 80a1d8da3c99c037717710177999f98a90d2e6d6
 SHA512:
-  metadata.gz: 3306764da5aa9f681a1025ce5a0c43ea7cd08d210b8813e0a8e9ff7ab93ab7551ffdf11305479a28f7889e2641a0207170e32ed21e84b6c27117580529494514
-  data.tar.gz: 0647b6ba8a86a09f3d45e2d71c3c71164d494637364cdfdb8af90865ab1a488affc1fe115c9d2530f39f18af3ae53e638bf9b15f3a3e950a594a9d4d8d290fde
+  metadata.gz: 875f0998cdf03527b766fa2b9d83fa946673683fdd4842e737fa69fe8c82fb5a60fcf8767fccd0b1249f5d9354206189c364b96015fde59f4a25dcc945f73da6
+  data.tar.gz: 3c71402f03f05b104d2d5a2294ff17e4533e24b9925a75e2bc436ac1704f4be750bc7bdb04b597a581de362ddc36c5044d1870f7d6ca56bddc22bdd0579334e9

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rack-profiler.gemspec
 gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/README.md

@@ -1,22 +1,34 @@
 # Rack::Profiler
 
+[![Build Status](https://travis-ci.org/dawanda/rack-profiler.svg)](https://travis-ci.org/dawanda/rack-profiler) [![Code Climate](https://codeclimate.com/github/dawanda/rack-profiler/badges/gpa.svg)](https://codeclimate.com/github/dawanda/rack-profiler) [![Test Coverage](https://codeclimate.com/github/dawanda/rack-profiler/badges/coverage.svg)](https://codeclimate.com/github/dawanda/rack-profiler)
+
 Simple profiler for Rack applications (Sinatra and Ruby on Rails for example).
+It helps providing an answer to common questions like:
+
+  - Where is time spent in requests to my app?
+  - Which SQL queries are executed by `ActiveRecord`?
+  - Which are the parts of my app's request flow that need optimization?
+
+And more.
 
-`Rack::Profiler` uses the [Active Support Instrumentation API](http://guides.rubyonrails.org/active_support_instrumentation.html)
-and subscribes to the following hooks:
+`Rack::Profiler` uses the [Active Support Instrumentation
+API](http://guides.rubyonrails.org/active_support_instrumentation.html) and
+subscribes by default 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).
+On top of this, 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.
 
+![Rack::Profiler Web Dashboard](http://i.imgur.com/tcUSYle.png?1)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -25,8 +37,6 @@ 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
@@ -56,6 +66,7 @@ module YourApp
   class Application < Rails::Application
 
     # ...
+
     config.middleware.insert_before Rack::Runtime, Rack::Profiler
 
   end
@@ -64,28 +75,19 @@ end
 
 ## Configuration
 
-You can configure `Rack::Profiler` to subscribe to more notifications:
+You can configure `Rack::Profiler` passing a block to `use`. In the block you can subscribe to more notifications and change some defaults:
 
 ```ruby
-Rack::Profiler.configure do |config|
+use Rack::Profiler do |profiler|
   # Subscribe to email delivery in a Rails app
-  config.subscribe('deliver.action_mailer')
-end
-```
-
-You can also specify a backtrace filter to exclude lines that are not
-interesting:
+  profiler.subscribe('deliver.action_mailer')
 
-```ruby
-Rack::Profiler.configure do |config|
-  # Exclude gems from the backtrace
-  config.filter_backtrace { |line| !line.include? '/gems/' }
+  # You can also exclude lines that are not interesting from the backtrace
+  # For example, exclude gems from the backtrace:
+  profiler.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

data/lib/rack/profiler.rb

@@ -5,134 +5,107 @@ require "active_support/notifications"
 
 module Rack
   class Profiler
-    class DummyError < StandardError; end
-
-    module ClassMethods
-      def configure(&block)
-        block.call(config)
-      end
 
-      def config
-        @config ||= Configuration.new
-      end
+    attr_reader :events, :backtrace_filter, :subscriptions
+    attr_accessor :dashboard_path
 
-      def step(name, payload = {})
-        ActiveSupport::Notifications.instrument('rack-profiler.step', payload.merge(step_name: name)) do
-          yield
-        end
-      end
-    end
+    DEFAULT_SUBSCRIPTIONS = ['sql.active_record',
+                             'render_template.action_view',
+                             'render_partial.action_view',
+                             'process_action.action_controller',
+                             'rack-profiler.total_time',
+                             'rack-profiler.step']
 
-    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 initialize
-        @subscriptions  = DEFAULT_SUBSCRIPTIONS.clone
-        @dashboard_path = '/rack-profiler'
-      end
-
-      def subscribe(*names)
-        names.each { |name| @subscriptions << name }
-        @subscriptions.uniq!
-      end
+    class DummyError < StandardError; end
 
-      def filter_backtrace(&block)
-        @backtrace_filter = block
+    def self.step(name, payload = {})
+      ActiveSupport::Notifications.instrument('rack-profiler.step', payload.merge(step_name: name)) do
+        yield
       end
     end
 
-    extend ClassMethods
-
-    attr_reader :events
-
-    def initialize(app)
-      subscribe_to_all
-      @events = []
-      @app    = app
+    def initialize(app, &block)
+      @events         = []
+      @subscriptions  = []
+      @dashboard_path = '/rack-profiler'
+      @app            = app
+      subscribe_to_default
+      block.call(self) if block_given?
     end
 
     def call(env)
       @events = []
-      status, headers, body = [nil, nil, nil]
       req = Rack::Request.new(env)
 
-      if req.path == config.dashboard_path
+      if req.path == dashboard_path
         render_dashboard
       elsif req.params.has_key?('rack-profiler')
-        ActiveSupport::Notifications.instrument('rack-profiler.total_time') do
-          status, headers, body = @app.call(env)
-        end
-        [ 200,
-          { 'Content-Type' => 'application/json' },
-          [ { events:   events.sort_by { |event| event[:start] },
-              response: {
-                status:  status,
-                headers: headers,
-                body:    stringify_body(body)
-              }
-            }.to_json ]
-        ]
+        render_profiler_results(env)
       else
-        @status, @headers, @body = @app.call(env)
+        @app.call(env)
       end
     end
 
-    def subscribe(event_name)
-      ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, payload|
-        backtrace = filtered_backtrace(tap_backtrace)
-        evt = {
-          id:        id,
-          name:      name,
-          start:     start.to_f,
-          finish:    finish.to_f,
-          duration:  (finish - start) * 1000,
-          payload:   payload,
-          backtrace: backtrace
-        }
-        (@events ||= []) << evt
+    def subscribe(*events)
+      events.each do |event_name|
+        next if @subscriptions.include?(event_name)
+        ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, payload|
+          evt = {
+            id:        id,
+            name:      name,
+            start:     start.to_f,
+            finish:    finish.to_f,
+            duration:  (finish - start) * 1000,
+            payload:   payload,
+            backtrace: filtered_backtrace(caller(1))
+          }
+          (@events ||= []) << evt
+        end
+        @subscriptions << event_name
       end
     end
 
-    def config
-      self.class.config
+    def filter_backtrace(&block)
+      @backtrace_filter = block
     end
 
     private
 
+    def render_profiler_results(env)
+      status, headers, body = [nil, nil, nil]
+      ActiveSupport::Notifications.instrument('rack-profiler.total_time') do
+        status, headers, body = @app.call(env)
+      end
+      [ 200,
+        { 'Content-Type' => 'application/json' },
+        [ { events:   events.sort_by { |event| event[:start] },
+            response: {
+            status:  status,
+            headers: headers,
+            body:    stringify_body(body)
+          }
+        }.to_json ]
+      ]
+    end
+
     def render_dashboard
-      dashboard = ::File.expand_path( '../../public/rack-profiler.html', ::File.dirname( __FILE__ ) )
+      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 subscribe_to_all
-      # Subscribe to interesting events
-      config.subscriptions.each do |event|
+    def subscribe_to_default
+      DEFAULT_SUBSCRIPTIONS.each do |event|
         subscribe(event)
       end
     end
 
-    def tap_backtrace
-      begin
-        raise DummyError.new
-      rescue DummyError => e
-        e.backtrace
-      end
-    end
-
     def filtered_backtrace(backtrace)
-      if config.backtrace_filter.nil?
+      if backtrace_filter.nil?
         backtrace
       else
-        backtrace.select(&config.backtrace_filter)
+        backtrace.select(&backtrace_filter)
       end
     end
 

data/lib/rack/profiler/version.rb

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

data/public/rack-profiler.html

@@ -96,7 +96,7 @@
             <input type="text" id="req-path" class="form-control" placeholder="Path">
           </div>
           <div class="col-md-6">
-            <input type="text" id="req-data" class="form-control" placeholder="Data">
+            <input type="text" id="req-data" class="form-control" placeholder="Data (as query string/form data)">
           </div>
           <div class="col-md-1">
             <button type="submit" class="btn btn-success">Profile</button>
@@ -241,7 +241,7 @@
           $(".pr-queries tbody").html('')
           $(".pr-steps tbody").html('')
 
-          $.ajax( path, { type: type, data: $.extend(data, { "rack-profiler": 1 }) } )
+          $.ajax( path, { type: type, data: ["rack-profiler", data].join("&") } )
             .done(function( data, status, xhr ) {
               $(".stats").show()
 

data/spec/rack/profiler_spec.rb

@@ -16,14 +16,28 @@ describe Rack::Profiler do
 
   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)
-
-      profiler = Rack::Profiler.new(nil)
+      profiler = Rack::Profiler.new(nil) do |config|
+        config.subscribe("bar")
+      end
       trigger_dummy_event("bar")
       expect(profiler.events.last[:name]).to eq("bar")
     end
+
+    it "executes the given block passing self" do
+      block_arg = nil
+      profiler = Rack::Profiler.new(nil) do |p|
+        block_arg = p
+      end
+      expect(block_arg).to be(profiler)
+    end
+
+    it "sets the correct defaults" do
+      expect(profiler.dashboard_path).to eq('/rack-profiler')
+      expect(profiler.backtrace_filter).to be_nil
+      expect(profiler.subscriptions).to include(
+        *Rack::Profiler::DEFAULT_SUBSCRIPTIONS
+      )
+    end
   end
 
   describe :subscribe do
@@ -52,7 +66,7 @@ describe Rack::Profiler do
     end
 
     it "filters the backtrace if a filter was provided" do
-      Rack::Profiler.config.filter_backtrace do |line|
+      profiler.filter_backtrace do |line|
         !line.include?("trigger_dummy_event")
       end
       trigger_dummy_event("foo")
@@ -70,6 +84,23 @@ describe Rack::Profiler do
       event = profiler.events.last
       expect(event[:payload]).to eq(bar: "baz")
     end
+
+    it "accepts more than one subscription" do
+      profiler.subscribe('baz', 'qux')
+      trigger_dummy_event('baz')
+      event = profiler.events.last
+      expect(event[:name]).to eq('baz')
+      trigger_dummy_event('qux')
+      event = profiler.events.last
+      expect(event[:name]).to eq('qux')
+    end
+
+    it "prevents duplicate subscriptions" do
+      profiler.subscribe('baz')
+      profiler.subscribe('baz')
+      trigger_dummy_event('baz')
+      expect(profiler.events.size).to eq(1)
+    end
   end
 
   describe :call do
@@ -117,11 +148,14 @@ describe Rack::Profiler do
 
     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
+        path = ::File.expand_path('../../public/rack-profiler.html',
+                                     ::File.dirname( __FILE__ ) )
+        status, header, body = profiler.call env.merge(
+          "PATH_INFO"    => profiler.dashboard_path,
+          "REQUEST_PATH" => profiler.dashboard_path
         )
+        expect(body).to be_a(File)
+        expect(body.path).to eq(path)
       end
     end
 
@@ -178,63 +212,12 @@ describe Rack::Profiler 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'
+    it "returns whatever is returned by the block" do
+      returned = Rack::Profiler.step("xxx") do
+        "do stuff"
       end
-      filtered = ['foo', 'foobar', 'baz'].select(&config.backtrace_filter)
-      expect(filtered).to eq(['foo', 'foobar'])
+      expect(returned).to eq("do stuff")
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,5 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'rack/profiler'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-profiler
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Luca Ongaro
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-27 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack