speed_gun 0.0.4 → 1.0.0.rc1

data/lib/speed_gun/browser/timing.rb

@@ -1,92 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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/hook.rb

@@ -1,25 +0,0 @@
-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/profiler/action_controller.rb

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

data/lib/speed_gun/profiler/rack.rb

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

data/lib/speed_gun/store/base.rb

@@ -1,9 +0,0 @@
-require 'speed_gun'
-
-class SpeedGun::Store::Base
-  def [](id)
-  end
-
-  def []=(id, value)
-  end
-end

data/lib/speed_gun/store/file.rb

@@ -1,62 +0,0 @@
-require 'speed_gun/store/base'
-require 'fileutils'
-
-class SpeedGun::Store::File
-  DEFAULT_PATH = '/tmp/speed_gun'
-  DEFAULT_EXPIRES_IN_SECONDS = 60 * 60 * 24
-  CLEANUP_INTERVAL = 60 * 60
-
-  def initialize(options = {})
-    @path = (options[:path] || DEFAULT_PATH).to_s
-    @expires = options[:expires] || DEFAULT_EXPIRES_IN_SECONDS
-    @lock = Mutex.new
-
-    this = self
-    Thread.new do
-      begin
-        while true
-          this.cleanup
-          sleep(CLEANUP_INTERVAL)
-        end
-      rescue
-      end
-    end
-  end
-
-  def [](id)
-    @lock.synchronize {
-      read(id) if exist?(id)
-    }
-  end
-
-  def []=(id, val)
-    @lock.synchronize {
-      write(id, val)
-    }
-  end
-
-  def cleanup
-    @lock.synchronize {
-      files = Dir.entries(@path)
-      files.each do |file|
-        file = File.join(@path, file)
-        File.delete(file) if (Time.now - File.mtime(file)) > @expires
-      end
-    }
-  end
-
-  private
-
-  def read(id)
-    File.open(File.join(@path, id), 'rb') { |f| f.read }
-  end
-
-  def write(id, val)
-    FileUtils.mkdir_p(@path)
-    File.open(File.join(@path, id), 'wb+') { |f| f.write(val) }
-  end
-
-  def exist?(id)
-    File.exist?(File.join(@path, id))
-  end
-end

data/lib/speed_gun/store/memcache.rb

@@ -1,27 +0,0 @@
-require 'speed_gun/store/base'
-
-class SpeedGun::Store::Memcache
-  DEFAULT_PREFIX = 'speed-gun-'
-  DEFAULT_EXPIRES_IN_SECONDS = 60 * 60 * 24
-
-  def initialize(options = {})
-    @prefix = options[:prefix] || DEFAULT_PREFIX
-    @client = options[:client] || default_dalli
-    @expires = options[:expires] || DEFAULT_EXPIRES_IN_SECONDS
-  end
-
-  def [](id)
-    @client.get("#{@prefix}#{id}")
-  end
-
-  def []=(id, val)
-    @client.set("#{@prefix}#{id}", val, @expires)
-  end
-
-  private
-
-  def default_dalli
-    require 'dalli' unless defined?(Dalli)
-    Dalli::Client.new
-  end
-end

data/lib/speed_gun/store/memory.rb

@@ -1,22 +0,0 @@
-require 'speed_gun/store/base'
-
-class SpeedGun::Store::Memory < SpeedGun::Store::Base
-  DEFAULT_MAX_ENTRIES = 100
-
-  def initialize(options = {})
-    @max_entries = options[:max_entries] || DEFAULT_MAX_ENTRIES
-    @store = {}
-    @stored_list = []
-  end
-
-  def [](id)
-    @store[id]
-  end
-
-  def []=(id, val)
-    @store[id] = val
-    @stored_list.push(id)
-
-    @store.delete(@stored_list.shift) while @stored_list.length > @max_entries
-  end
-end

data/lib/speed_gun/store/redis.rb

@@ -1,28 +0,0 @@
-require 'speed_gun/store/base'
-
-class SpeedGun::Store::Redis
-  DEFAULT_PREFIX = 'speed-gun-'
-  DEFAULT_EXPIRES_IN_SECONDS = 60 * 60 * 24
-
-  def initialize(options = {})
-    @prefix = options[:prefix] || DEFAULT_PREFIX
-    @client = options[:client] || default_redis(options)
-    @expires = options[:expires] || DEFAULT_EXPIRES_IN_SECONDS
-  end
-
-  def [](id)
-    @client.get("#{@prefix}#{id}")
-  end
-
-  def []=(id, val)
-    @client.setex("#{@prefix}#{id}", val, @expires)
-  end
-
-  private
-
-  def default_redis(args)
-    require 'redis' unless defined? Redis
-    Redis.new(args)
-  end
-end
-