speed_gun 0.0.1

data/lib/speed_gun/browser/navigation.rb

@@ -0,0 +1,23 @@
+require 'speed_gun/browser'
+
+class SpeedGun::Browser::Navigation < Hash
+  NAVIGATION_TYPES = [
+    'Navigate',
+    'Reload',
+    'Back/Forward'
+  ]
+
+  def initialize(hash)
+    hash.each_pair do |key, val|
+      self[key.to_s.to_sym] = val
+    end
+  end
+
+  def type
+    NAVIGATION_TYPES[self[:type].to_i] || 'Unknown'
+  end
+
+  def redirect_count
+    self[:redirect_count].to_i
+  end
+end

data/lib/speed_gun/browser/timing.rb

@@ -0,0 +1,92 @@
+require 'speed_gun/browser'
+
+class SpeedGun::Browser::Timing < Hash
+  # rubocop:disable SymbolName
+  ATTRIBUTES = [
+    :navigationStart,
+    :unloadEventStart,
+    :unloadEventEnd,
+    :redirectStart,
+    :redirectEnd,
+    :fetchStart,
+    :domainLookupStart,
+    :domainLookupEnd,
+    :connectStart,
+    :connectEnd,
+    :secureConnectionStart,
+    :requestStart,
+    :responseStart,
+    :responseEnd,
+    :domLoading,
+    :domInteractive,
+    :domContentLoadedEventStart,
+    :domContentLoadedEventEnd,
+    :domComplete,
+    :loadEventStart,
+    :loadEventEnd,
+  ]
+  # rubocop:enable all
+
+  class Timing
+    def initialize(name, base, started_at, ended_at)
+      @name = name
+      @started_at = started_at - base
+      @elapsed_time = ended_at - started_at
+    end
+    attr_reader :name, :started_at, :elapsed_time
+  end
+
+  def initialize(hash)
+    hash.each_pair do |key, val|
+      self[key.to_s.to_sym] = val.to_i
+    end
+  end
+
+  ATTRIBUTES.each do |key|
+    define_method(key) { self[key] }
+  end
+
+  def load_time
+    loadEventEnd - navigationStart
+  end
+
+  # rubocop:disable MethodLength
+  def timings
+    @timings ||= [
+      (
+        if redirectStart > 0
+          Timing.new('Redirect', navigationStart, redirectStart, redirectEnd)
+        else
+          nil
+        end
+      ),
+      Timing.new('Fetch all', navigationStart, fetchStart, responseEnd),
+      Timing.new(
+        'DNS Lookup', navigationStart, domainLookupStart, domainLookupEnd
+      ),
+      Timing.new(
+        'TCP Connecting', navigationStart, connectStart, connectEnd
+      ),
+      (
+        if secureConnectionStart > 0
+          Timing.new('SSL', navigationStart, secureConnectionStart, connectEnd)
+        else
+          nil
+        end
+      ),
+      Timing.new('Request', navigationStart, requestStart, responseStart),
+      Timing.new('Response', navigationStart, responseStart, responseEnd),
+      Timing.new('Unload', navigationStart, unloadEventStart, unloadEventEnd),
+      Timing.new('DOM Load', navigationStart, domLoading, domInteractive),
+      Timing.new(
+        'DOMContentLoaded Event',
+        navigationStart, domContentLoadedEventStart, domContentLoadedEventEnd
+      ),
+      Timing.new(
+        'Sub resources loading', navigationStart, domInteractive, domComplete
+      ),
+      Timing.new('Load Event', navigationStart, loadEventStart, loadEventEnd),
+    ].reject { |timing| timing.nil? }
+  end
+  # rubocop:enable
+end

data/lib/speed_gun/browser.rb

@@ -0,0 +1,22 @@
+require 'speed_gun'
+require 'useragent'
+
+class SpeedGun::Browser
+  def initialize(hash)
+    @user_agent = UserAgent.parse(hash['user_agent'] || '')
+    @navigation = Navigation.new(hash['navigation'] || {})
+    @timing = Timing.new(hash['timing'] || {})
+  end
+  attr_reader :user_agent, :navigation, :timing
+
+  def as_msgpack(*args)
+    {
+      user_agent: @user_agent.to_s,
+      navigation: @navigation,
+      timing: @timing,
+    }
+  end
+end
+
+require 'speed_gun/browser/navigation'
+require 'speed_gun/browser/timing'

data/lib/speed_gun/config.rb

@@ -0,0 +1,59 @@
+require 'speed_gun'
+
+class SpeedGun::Config < Hash
+  def enable?
+    enable && enable_if.call
+  end
+
+  def enable
+    fetch(:enable, true)
+  end
+
+  def enable_if
+    self[:enable_if] ||= -> { true }
+  end
+
+  def prefix
+    self[:prefix] ||= '/speed_gun'
+  end
+
+  def prefix_regexp
+    self[:prefix_regexp] ||= /^#{Regexp.escape(prefix)}/x
+  end
+
+  def store
+    self[:store] ||= SpeedGun::Store::Memory.new
+  end
+
+  def auto_inject?
+    fetch(:auto_inject, true)
+  end
+
+  def backtrace_remove
+    self[:backtrace_remove] ||= ''
+  end
+
+  def backtrace_includes
+    self[:backtrace_includes] ||= []
+  end
+
+  def show_button?
+    fetch(:show_button, true)
+  end
+
+  def no_include_jquery?
+    fetch(:no_include_jquery, false)
+  end
+
+  def skip_paths
+    self[:skip_paths] ||= [/favicon/]
+  end
+
+  def force_profile?
+    fetch(:force_profile, true)
+  end
+
+  def authorize_proc
+    self[:authorize_proc] ||= ->(request) { true }
+  end
+end

data/lib/speed_gun/hook.rb

@@ -0,0 +1,25 @@
+require 'speed_gun'
+
+class SpeedGun::Hook
+  HOOKS = []
+
+  def self.inherited(klass)
+    HOOKS.push(klass) unless HOOKS.include?(klass)
+  end
+
+  def self.invoke_all(profiler)
+    HOOKS.each { |hook| hook.invoke(profiler) }
+  end
+
+  def self.invoke(profiler)
+    new(profiler).invoke
+  end
+
+  def initialize(profiler)
+    @profiler = profiler
+  end
+  attr_reader :profiler
+
+  def invoke
+  end
+end

data/lib/speed_gun/middleware.rb

@@ -0,0 +1,91 @@
+require 'speed_gun'
+require 'speed_gun/app'
+require 'speed_gun/profiler'
+require 'speed_gun/profiler/rack'
+require 'speed_gun/template'
+
+class SpeedGun::Middleware
+  BODY_END_REGEXP = /<\/(?:body|html)>/
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    return SpeedGun::App.call(env) if under_speed_gun?(env)
+
+    SpeedGun.current = SpeedGun::Profiler.new(env) if SpeedGun.enable?
+
+    call_with_speed_gun(env)
+  ensure
+    SpeedGun.current = nil
+  end
+
+  private
+
+  def call_with_speed_gun(env)
+    remove_conditional_get_headers(env)
+
+    status, headers, body = *SpeedGun.current.profile(:rack) { @app.call(env) }
+
+    if SpeedGun.active?
+      inject_header(headers)
+      SpeedGun.current.dump
+    end
+
+    if SpeedGun.config.auto_inject? && SpeedGun.active?
+      inject_body(status, headers, body)
+    else
+      return [status, headers, body]
+    end
+  end
+
+  def remove_conditional_get_headers(env)
+    return if !SpeedGun.config.force_profile? && SpeedGun.active?
+
+    env['HTTP_IF_MODIFIED_SINCE'] = ''
+    env['HTTP_IF_NONE_MATCH'] = ''
+  end
+
+  def inject_header(headers)
+    if SpeedGun.config.force_profile?
+      headers.delete('ETag')
+      headers.delete('Date')
+      headers['Cache-Control'] = 'must-revalidate, private, max-age=0'
+    end
+
+    headers['X-SPEEDGUN-ID'] = SpeedGun.current.id
+  end
+
+  def inject_body(status, headers, body)
+    unless headers['Content-Type'] =~ /text\/html/
+      return [status, headers, body]
+    end
+
+    response = Rack::Response.new([], status, headers)
+
+    body = [body] if body.kind_of?(String)
+    body.each { |fragment| response.write(inject_fragment(fragment)) }
+    body.close if body.respond_to?(:close)
+
+    response.finish
+  end
+
+  def inject_fragment(body)
+    return body unless body.match(BODY_END_REGEXP)
+
+    body.sub(BODY_END_REGEXP) do |matched|
+      SpeedGun::Template.render + matched
+    end
+  end
+
+  def under_speed_gun?(env)
+    if SpeedGun.config.prefix_regexp.match(env['PATH_INFO'])
+      env['PATH_INFO'] =
+        env['PATH_INFO'].sub(SpeedGun.config.prefix_regexp, '')
+      true
+    else
+      false
+    end
+  end
+end

data/lib/speed_gun/profiler/action_controller.rb

@@ -0,0 +1,12 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::ActionController < SpeedGun::Profiler::Base
+  hook_method ::ActionController::Base, :process
+
+  attr_reader :action_name
+  alias_method :title, :action_name
+
+  def before_profile(controller, action)
+    @action_name = "#{controller.class.name}##{action}"
+  end
+end

data/lib/speed_gun/profiler/action_view.rb

@@ -0,0 +1,12 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::ActionView < SpeedGun::Profiler::Base
+  hook_method ::ActionView::Template, :render
+
+  attr_reader :template_path
+  alias_method :title, :template_path
+
+  def before_profile(action_view, *args)
+    @template_path = action_view.instance_variable_get(:@virtual_path)
+  end
+end

data/lib/speed_gun/profiler/active_record.rb

@@ -0,0 +1,16 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::ActiveRecord < SpeedGun::Profiler::Base
+  def title
+    "#{@name}"
+  end
+
+  def html
+    %Q{<pre class="sql">#{@sql}</pre>}
+  end
+
+  def before_profile(adapter, sql, name = nil)
+    @sql = sql
+    @name = name
+  end
+end

data/lib/speed_gun/profiler/base.rb

@@ -0,0 +1,139 @@
+require 'speed_gun/profiler'
+require 'securerandom'
+
+class SpeedGun::Profiler::Base
+  def self.label
+    name.sub(/.*::/, '')
+  end
+
+  def self.profiler_type
+    name\
+      .sub(/.*::/, '')\
+      .gsub(/(.)([A-Z])/) { |m| "#{$1}_#{$2.downcase}" }\
+      .downcase\
+      .to_sym
+  end
+
+  def self.inherited(klass)
+    SpeedGun::Profiler::PROFILERS[klass.profiler_type] = klass
+  end
+
+  def self.hook_method(klass, method_name)
+    without_profiling = "#{method_name}_withtout_profile".intern
+    with_profiling = "#{method_name}_with_profile".intern
+    return unless klass.send(:method_defined?, method_name)
+    return if klass.send(:method_defined?, with_profiling)
+
+    profiler = profiler_type
+    klass.send(:alias_method, without_profiling, method_name)
+    klass.send(:define_method, with_profiling) do |*args, &block|
+      return send(without_profiling, *args, &block) unless SpeedGun.current
+
+      profile_args = [self] + args
+      SpeedGun.current.profile(profiler, *profile_args) do
+        send(without_profiling, *args, &block)
+      end
+    end
+    klass.send(:alias_method, method_name, with_profiling)
+  end
+
+  def self.load(data)
+    data.delete('label')
+    type = data.delete('type')
+    profiler = SpeedGun::Profiler::PROFILERS[type.to_sym]
+    profile = profiler.new
+
+    data.each_pair do |key, val|
+      profile.send(:instance_variable_set, :"@#{key}", val)
+    end
+
+    profile
+  end
+
+  def self.profile(profiler, *args, &block)
+    profile = new
+    profiler.profiles << profile
+    profile.profile(*args, &block)
+  end
+
+  def initialize
+    @id = SecureRandom.uuid
+    @parent_profile_id = nil
+    @elapsed_time = 0
+    @backtrace = []
+  end
+  attr_reader :id, :elapsed_time, :parent_profile_id, :backtrace
+
+  def title
+    warn 'Override this method'
+  end
+
+  def html
+    ''
+  end
+
+  def label
+    self.class.label
+  end
+
+  def type
+    self.class.profiler_type
+  end
+
+  def profile(*args, &block)
+    @backtrace = cleanup_caller(caller(3))
+    parent_profile = SpeedGun.current.now_profile
+    SpeedGun.current.now_profile = self
+    call_without_defined(:before_profile, *args, &block)
+    result = measure(&block)
+    call_without_defined(:after_profile, *args, &block)
+    return result
+  ensure
+    SpeedGun.current.now_profile = parent_profile
+    @parent_profile_id = parent_profile.id if parent_profile
+  end
+
+  def measure(&block)
+    now = Time.now
+    result = yield
+    @elapsed_time = Time.now - now
+
+    result
+  end
+
+  def as_msgpack(*args)
+    hash = {}
+    instance_variables.each do |key|
+      unless key.to_s =~ /^\@_/
+        hash[key.to_s.sub(/^\@/, '')] = instance_variable_get(key)
+      end
+    end
+    hash['type'] = type.to_s
+    hash['label'] = label
+    hash['title'] = title
+    hash
+  end
+
+  def to_msgpack(*args)
+    as_msgpack(*args).to_msgpack(*args)
+  end
+
+  private
+
+  def call_without_defined(method, *args)
+    send(method, *args) if respond_to?(method)
+  end
+
+  def cleanup_caller(caller)
+    backtraces = caller.map do |backtrace|
+      backtrace.sub(SpeedGun.config.backtrace_remove, '')
+    end
+    backtraces.reject! do |backtrace|
+      !SpeedGun.config.backtrace_includes.any? do |regexp|
+        backtrace =~ regexp
+      end
+    end
+
+    backtraces
+  end
+end

data/lib/speed_gun/profiler/js.rb

@@ -0,0 +1,17 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::Js < SpeedGun::Profiler::Base
+  def self.profile(profiler, title, elapsed_time, backtrace)
+    profile = new
+    profiler.profiles << profile
+    profile.save(title, elapsed_time, backtrace)
+  end
+
+  attr_reader :title
+
+  def save(title, elapsed_time, backtrace)
+    @title = title.to_s
+    @elapsed_time = elapsed_time.to_i * 0.001
+    @backtrace = backtrace
+  end
+end

data/lib/speed_gun/profiler/manual.rb

@@ -0,0 +1,14 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::Manual < SpeedGun::Profiler::Base
+  def self.label
+    'Manual'
+  end
+
+  attr_reader :html
+
+  def before_profile(title, html = '')
+    @title = title
+    @html = html
+  end
+end

data/lib/speed_gun/profiler/rack.rb

@@ -0,0 +1,7 @@
+require 'speed_gun/profiler/base'
+
+class SpeedGun::Profiler::Rack < SpeedGun::Profiler::Base
+  def title
+    'Rack Total'
+  end
+end

data/lib/speed_gun/profiler.rb

@@ -0,0 +1,124 @@
+require 'speed_gun'
+require 'speed_gun/store'
+require 'speed_gun/browser'
+require 'speed_gun/hook'
+require 'securerandom'
+require 'msgpack'
+require 'multi_json'
+
+class SpeedGun::Profiler
+  PROFILERS = {}
+
+  def self.load(id)
+    src = SpeedGun.store[id]
+
+    return nil unless src
+
+    data = MessagePack.unpack(src)
+
+    profiler = new({})
+    profiler.restore_by_hash(data)
+
+    profiler
+  end
+
+  def initialize(env)
+    @id = SecureRandom.uuid
+    @path = env['PATH_INFO']
+    @query = env['QUERY_STRING']
+    @env = env
+    @requested_at = Time.now
+    @profiles = []
+    @browser = nil
+    @active = true
+    @now_profile = nil
+  end
+  attr_reader :id, :path, :query, :env, :requested_at, :profiles, :browser
+  attr_accessor :now_profile
+
+  def profile(type, *args, &block)
+    profiler = PROFILERS[type]
+
+    if profiler
+      profiler.profile(self, *args, &block)
+    else
+      yield
+    end
+  end
+
+  def skip?
+    SpeedGun.config.skip_paths.any? { |prefix| prefix.match(@path) }
+  end
+
+  def active?
+    @active && !skip?
+  end
+
+  def activate!
+    @active = true
+  end
+
+  def deactivate!
+    @active = false
+  end
+
+  def dump
+    SpeedGun.store[id] = to_msgpack
+
+    SpeedGun::Hook.invoke_all(self)
+  end
+
+  def browser=(hash)
+    @browser = SpeedGun::Browser.new(hash)
+  end
+
+  def as_msgpack(*args)
+    {
+      id: @id,
+      path: @path,
+      query: @query,
+      env: msgpackable_env,
+      requested_at: @requested_at.to_i,
+      profiles: @profiles.map { |profile| profile.as_msgpack(*args) },
+      browser: @browser ? @browser.as_msgpack(*args) : nil,
+    }
+  end
+
+  def to_msgpack(*args)
+    as_msgpack(*args).to_msgpack(*args)
+  end
+
+  def to_json(*args)
+    MultiJson.dump(as_msgpack(*args))
+  end
+
+  def restore_by_hash(hash)
+    hash.each_pair do |key, val|
+      instance_variable_set(:"@#{key}", restore_attribute(key, val))
+    end
+  end
+
+  def restore_attribute(key, val)
+    case key
+    when 'requested_at'
+      Time.at(val)
+    when 'profiles'
+      val.map { |profile| SpeedGun::Profiler::Base.load(profile) }
+    when 'browser'
+      val ? SpeedGun::Browser.new(val) : val
+    else
+      val
+    end
+  end
+
+  private
+
+  def msgpackable_env
+    env = {}
+    @env.each_pair { |key, val| env[key] = val if key[0] =~ /[A-Z]/ }
+    env
+  end
+end
+
+require 'speed_gun/profiler/manual'
+require 'speed_gun/profiler/js'

data/lib/speed_gun/railtie.rb

@@ -0,0 +1,33 @@
+require 'speed_gun'
+require 'speed_gun/store/file'
+
+class SpeedGun::Railtie < ::Rails::Railtie
+  initializer 'speed_gun' do |app|
+    app.middleware.insert(0, SpeedGun::Middleware)
+
+    SpeedGun.config[:enable_if] = -> { Rails.env.development? }
+    SpeedGun.config[:backtrace_remove] = Rails.root.to_s + '/'
+    SpeedGun.config[:backtrace_includes] = [/^(app|config|lib|test|spec)/]
+    SpeedGun.config[:authorize_proc] = ->(request) { Rails.env.development? }
+    SpeedGun.config.skip_paths << /^#{Regexp.escape(app.config.assets.prefix)}/
+    SpeedGun.config[:store] =
+      SpeedGun::Store::File.new(path: Rails.root.join('tmp/speed_gun'))
+
+    ActiveSupport.on_load(:action_controller) do
+      require 'speed_gun/profiler/action_controller'
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      require 'speed_gun/profiler/action_view'
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      require 'speed_gun/profiler/active_record'
+
+      SpeedGun::Profiler::ActiveRecord.hook_method(
+        ActiveRecord::Base.connection.class,
+        :execute
+      )
+    end
+  end
+end