peek-performance_bar 1.1.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 1.0.0
+
+- Initial release.
+
+# 1.1.0
+
+- Add support for Turbolinks. (#2)
+
+# 1.1.1
+
+- Remove HTML from tooltips to remove any text artifacts. (#4)
+
+# 1.1.2
+
+- Namespace the tooltips to not conflict with application styles. (#8)
+- Don't render the performance bar when `window.performance` doesn't exist. (#10)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in peek-performance_bar.gemspec
+gemspec

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,78 @@
+# Peek::PerformanceBar
+
+Take a peek into the `window.performance` timing behind your app.
+
+![image](https://f.cloud.github.com/assets/79995/268624/14d9df90-8f47-11e2-9718-111c7c367974.png)
+
+Things this peek view provides:
+
+- Frontend
+- Latency / Receiving
+- Backend
+- TCP / SSL
+- Redirect
+- DNS Lookup
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'peek-performance_bar'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install peek-performance_bar
+
+## Usage
+
+Add the following to your `config/initializers/peek.rb`: 
+
+```ruby
+Peek.into Peek::Views::PerformanceBar
+```
+
+You'll then need to add the following CSS and CoffeeScript:
+
+CSS:
+
+```scss
+//= require peek
+//= require peek/views/performance_bar
+```
+
+CoffeeScript:
+
+```coffeescript
+#= require peek
+#= require peek/views/performance_bar
+```
+
+Lastly this view requires you insert an additional partial after the `peek/results`:
+
+```erb
+...
+<%= yield %>
+<%= render 'peek/results' %>
+<%= render 'peek/results/performance_bar' %>
+...
+```
+
+## Contributors
+
+- [@josh](https://github.com/josh) - The original implementation.
+- [@tmm1](https://github.com/tmm1) - The original implementation.
+- [@rtomayko](https://github.com/rtomayko) - The original implementation.
+- [@kneath](https://github.com/kneath) - The original implementation.
+- [@dewski](https://github.com/dewski) - Just the extractor.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/app/assets/javascripts/peek/views/performance_bar.coffee

@@ -0,0 +1,167 @@
+# The mission control window.performance.timing display area.
+#
+# Breaks the window.performance.timing numbers down into these groups:
+#
+# dns         - Time looking up domain. Usually zero.
+# tcp and ssl - Time used establishing tcp and ssl connections.
+# redirect    - Time spent redirecting since navigation began.
+# app         - Real server time as recorded in the app.
+# latency     - Extra backend and network time where browser was waiting.
+# frontend    - Time spent loading and rendering the DOM until interactive.
+#
+# Not all frontend time is counted. The page is considered ready when the
+# domInteractive ready state is reached. This is before DOMContentLoaded and
+# onload javascript handlers.
+class PerformanceBar
+  # Additional app info to show with the app timing.
+  appInfo: null
+
+  # The pixel width we're rendering the timing graph into.
+  width: null
+
+  # Format a time as ms or s based on how big it is.
+  @formatTime: (value) ->
+    if value >= 1000
+      "#{(value / 1000).toFixed(3)}s"
+    else
+      "#{value.toFixed(0)}ms"
+
+  # Create a new PerformanceBar view bound to a given element. The el and width
+  # options should be provided here.
+  constructor: (options={}) ->
+    @el = $('#peek-view-performance-bar .performance-bar')
+    @[k] = v for k, v of options
+    @width  ?= @el.width()
+    @timing ?= window.performance.timing
+
+  # Render the performance bar in the associated element. This is a little weird
+  # because it includes the server-side rendering time reported with the
+  # response document which may not line up when using the back/forward button
+  # and loading from cache.
+  render: (serverTime=0) ->
+    @el.empty()
+    @addBar 'frontend', '#90d35b', 'domLoading', 'domInteractive'
+
+    # time spent talking with the app according to performance.timing
+    perfNetworkTime = (@timing.responseEnd - @timing.requestStart)
+
+    # only include serverTime if it's less than than the browser reported
+    # talking-to-the-app time; otherwise, assume we're loading from cache.
+    if serverTime and serverTime <= perfNetworkTime
+      networkTime = perfNetworkTime - serverTime
+      @addBar 'latency / receiving', '#f1faff',
+        @timing.requestStart + serverTime,
+        @timing.requestStart + serverTime + networkTime
+      @addBar 'app', '#90afcf',
+        @timing.requestStart,
+        @timing.requestStart + serverTime,
+        @appInfo
+    else
+      @addBar 'backend', '#c1d7ee', 'requestStart', 'responseEnd'
+
+    @addBar 'tcp / ssl', '#45688e', 'connectStart', 'connectEnd'
+    @addBar 'redirect', '#0c365e', 'redirectStart', 'redirectEnd'
+    @addBar 'dns', '#082541', 'domainLookupStart', 'domainLookupEnd'
+
+    @el
+
+  # Determine if the page has reached the interactive state yet.
+  isLoaded: ->
+    @timing.domInteractive
+
+  # Integer unix timestamp representing the very beginning of the graph.
+  start: ->
+    @timing.navigationStart
+
+  # Integer unix timestamp representing the very end of the graph.
+  end: ->
+    @timing.domInteractive
+
+  # Total number of milliseconds between the start and end times.
+  total: ->
+    @end() - @start()
+
+  # Helper used to add a bar to the graph.
+  addBar: (name, color, start, end, info) ->
+    start = @timing[start] if typeof start is 'string'
+    end   = @timing[end]   if typeof end is 'string'
+
+    # Skip missing stats
+    return unless start? and end?
+
+    time   = end - start
+    offset = start - @start()
+    left = @mapH(offset)
+    width = @mapH(time)
+
+    title = "#{name}: #{PerformanceBar.formatTime(time)}"
+    bar = $ '<li></li>', title: title, class: 'peek-tooltip'
+    bar.css
+      width: "#{width}px"
+      left:  "#{left}px"
+      background: color
+    bar.tipsy gravity: 'n'
+    @el.append bar
+
+  # Map a time offset value to a horizontal pixel offset.
+  mapH: (offset) ->
+    offset * (@width / @total())
+
+renderPerformanceBar = ->
+  resp = $('#peek-server_response_time')
+  time = Math.round(resp.data('time') * 1000)
+
+  bar = new PerformanceBar
+  bar.render time
+
+  span = $('<span>', {'class': 'peek-tooltip', title: 'Total navigation time for this page.'})
+    .text(PerformanceBar.formatTime(bar.total()))
+  span.tipsy({ gravity: 'n' })
+  updateStatus span
+
+
+updateStatus = (html) ->
+  $('#serverstats').html html
+
+ajaxStart = null
+$(document).on 'pjax:start page:fetch', (event) ->
+  ajaxStart = event.timeStamp
+
+$(document).on 'pjax:end page:change', (event, xhr) ->
+  ajaxEnd    = event.timeStamp
+  total      = ajaxEnd - ajaxStart
+  serverTime = if xhr then parseInt(xhr.getResponseHeader('X-Runtime')) else 0
+
+  # Defer to include the timing of pjax hook evaluation
+  setTimeout ->
+    now = new Date().getTime()
+    bar = new PerformanceBar
+      timing:
+        requestStart: ajaxStart,
+        responseEnd: ajaxEnd,
+        domLoading: ajaxEnd,
+        domInteractive: now
+      isLoaded: -> true
+      start: -> ajaxStart
+      end: -> now
+
+    bar.render serverTime
+
+    if $.fn.pjax?
+      tech = 'PJAX'
+    else
+      tech = 'Turbolinks'
+
+    span = $('<span>', {'class': 'peek-tooltip', title: "#{tech} navigation time"})
+      .text(PerformanceBar.formatTime(total))
+    span.tipsy({ gravity: 'n' })
+    updateStatus span
+
+    ajaxStart = null
+  , 0
+
+$ ->
+  if window.performance
+    renderPerformanceBar()
+  else
+    $('#peek-view-performance-bar').remove()

data/app/assets/stylesheets/peek/views/performance_bar.scss

@@ -0,0 +1,27 @@
+.performance-bar {
+  position: relative;
+  top: 2px;
+  display: inline-block;
+  width: 75px;
+  height: 10px;
+  margin: 0 0 0 5px;
+  list-style: none;
+  background-color: rgba(0, 0, 0, .5);
+  border: 1px solid rgba(0, 0, 0, .7);
+  border-radius: 2px;
+  box-shadow: 0 1px 0 rgba(255, 255, 255, .15);
+
+  li {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    overflow: hidden;
+    opacity: .8;
+    color: transparent;
+
+    &:hover {
+      opacity: 1;
+      cursor: default;
+    }
+  }
+}

data/app/helpers/peek/performance_bar_helper.rb

@@ -0,0 +1,10 @@
+module Peek
+  module PerformanceBarHelper
+    def render_server_response_time
+      if start_time = request.env['process.request_start']
+        time = "%.5f" % (Time.now - start_time)
+        "<span id='peek-server_response_time' data-time='#{time}'></span>".html_safe
+      end
+    end
+  end
+end

data/app/views/peek/results/_performance_bar.html.erb

@@ -0,0 +1 @@
+<%= render_server_response_time %>

data/app/views/peek/views/_performance_bar.html.erb

@@ -0,0 +1,2 @@
+<span id="serverstats">...</span>
+<ul class="performance-bar"></ul>

data/glimpse-performance_bar.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'peek-performance_bar/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'peek-performance_bar'
+  gem.version       = Peek::PerformanceBar::VERSION
+  gem.authors       = ['Garrett Bjerkhoel']
+  gem.email         = ['me@garrettbjerkhoel.com']
+  gem.description   = %q{Take a peek into the MySQL queries made during your application's requests.}
+  gem.summary       = %q{Take a peek into the MySQL queries made during your application's requests.}
+  gem.homepage      = 'https://github.com/peek/peek-performance_bar'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'peek', '>= 0.0.5'
+end

data/lib/peek/views/performance_bar.rb

@@ -0,0 +1,6 @@
+module Peek
+  module Views
+    class PerformanceBar < View
+    end
+  end
+end

data/lib/peek-performance_bar/railtie.rb

@@ -0,0 +1,11 @@
+require 'rack/process_utilization'
+
+module Peek
+  module PerformanceBar
+    class Railtie < ::Rails::Engine
+      initializer 'peek.performance_bar.mount_process_utilization' do |app|
+        app.config.middleware.use Rack::ProcessUtilization
+      end
+    end
+  end
+end

data/lib/peek-performance_bar/version.rb

@@ -0,0 +1,5 @@
+module Peek
+  module PerformanceBar
+    VERSION = '1.1.2'
+  end
+end

data/lib/peek-performance_bar.rb

@@ -0,0 +1,3 @@
+require 'peek-performance_bar/version'
+require 'peek/views/performance_bar'
+require 'peek-performance_bar/railtie'

data/lib/rack/process_utilization.rb

@@ -0,0 +1,143 @@
+module Rack
+  # Middleware that tracks the amount of time this process spends processing
+  # requests, as opposed to being idle waiting for a connection. Statistics
+  # are dumped to rack.errors every 5 minutes.
+  #
+  # NOTE This middleware is not thread safe. It should only be used when
+  # rack.multiprocess is true and rack.multithread is false.
+  class ProcessUtilization
+    class << self
+      # The instance of this middleware in a single-threaded production server.
+      # Useful for fetching stats about the current request:
+      #
+      #   o = Rack::ProcessUtilization.singleton
+      #   time, calls = o.gc_stats if o.track_gc?
+      attr_accessor :singleton
+    end
+
+    def initialize(app, opts={})
+      @app = app
+      @window = opts[:window] || 100
+      @horizon = nil
+      @requests = nil
+      @active_time = nil
+      @total_requests = 0
+
+      self.class.singleton = self
+    end
+
+    # time when we began sampling. this is reset every once in a while so
+    # averages don't skew over time.
+    attr_accessor :horizon
+
+    # total number of requests that have been processed by this worker since
+    # the horizon time.
+    attr_accessor :requests
+
+    # decimal number of seconds the worker has been active within a request
+    # since the horizon time.
+    attr_accessor :active_time
+
+    # total requests processed by this worker process since it started
+    attr_accessor :total_requests
+
+    # the amount of time since the horizon
+    def horizon_time
+      Time.now - horizon
+    end
+
+    # decimal number of seconds this process has been active since the horizon
+    # time. This is the inverse of the active time.
+    def idle_time
+      horizon_time - active_time
+    end
+
+    # percentage of time this process has been active since the horizon time.
+    def percentage_active
+      (active_time / horizon_time) * 100
+    end
+
+    # percentage of time this process has been idle since the horizon time.
+    def percentage_idle
+      (idle_time / horizon_time) * 100
+    end
+
+    # number of requests processed per second since the horizon
+    def requests_per_second
+      requests / horizon_time
+    end
+
+    # average response time since the horizon in milliseconds
+    def average_response_time
+      (active_time / requests.to_f) * 1000
+    end
+
+    # called exactly once before the first request is processed by a worker
+    def first_request
+      reset_horizon
+    end
+
+    # reset various counters before the new request
+    def reset_stats
+      @start = Time.now
+    end
+
+    # resets the horizon and all dependent variables
+    def reset_horizon
+      @horizon = Time.now
+      @active_time = 0.0
+      @requests = 0
+    end
+
+    # called immediately after a request to record statistics, update the
+    # procline, and dump information to the logfile
+    def record_request
+      now = Time.now
+      diff = (now - @start)
+      @active_time += diff
+      @requests += 1
+
+      reset_horizon if now - horizon > @window
+    rescue => boom
+      warn "ProcessUtilization#record_request failed: #{boom.inspect}"
+    end
+
+    # Body wrapper. Yields to the block when body is closed. This is used to
+    # signal when a response is fully finished processing.
+    class Body
+      def initialize(body, &block)
+        @body = body
+        @block = block
+      end
+
+      def each(&block)
+        @body.each(&block)
+      end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+        @block.call
+        nil
+      end
+    end
+
+    # Rack entry point.
+    def call(env)
+      @env = env
+      reset_stats
+
+      @total_requests += 1
+      first_request if @total_requests == 1
+
+      env['process.request_start'] = @start.to_f
+      env['process.total_requests'] = total_requests
+
+      # newrelic X-Request-Start
+      env.delete('HTTP_X_REQUEST_START')
+
+      status, headers, body = @app.call(env)
+      body = Body.new(body) { record_request }
+      [status, headers, body]
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: peek-performance_bar
+version: !ruby/object:Gem::Version
+  version: 1.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Garrett Bjerkhoel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: peek
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+description: Take a peek into the MySQL queries made during your application's requests.
+email:
+- me@garrettbjerkhoel.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/peek/views/performance_bar.coffee
+- app/assets/stylesheets/peek/views/performance_bar.scss
+- app/helpers/peek/performance_bar_helper.rb
+- app/views/peek/results/_performance_bar.html.erb
+- app/views/peek/views/_performance_bar.html.erb
+- glimpse-performance_bar.gemspec
+- lib/peek-performance_bar.rb
+- lib/peek-performance_bar/railtie.rb
+- lib/peek-performance_bar/version.rb
+- lib/peek/views/performance_bar.rb
+- lib/rack/process_utilization.rb
+homepage: https://github.com/peek/peek-performance_bar
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Take a peek into the MySQL queries made during your application's requests.
+test_files: []