speed_gun 0.0.4 → 1.0.0.rc1

data/lib/speed_gun/railtie.rb

@@ -1,33 +1,24 @@
 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'))
+    SpeedGun.config.logger = Rails.logger
+    SpeedGun.config.skip_paths.push(
+      /^#{Regexp.escape(app.config.assets.prefix)}/
+    )
 
     ActiveSupport.on_load(:action_controller) do
-      require 'speed_gun/profiler/action_controller'
+      require 'speed_gun/profiler/action_controller_profiler'
     end
 
     ActiveSupport.on_load(:action_view) do
-      require 'speed_gun/profiler/action_view'
+      require 'speed_gun/profiler/action_view_profiler'
     end
 
     ActiveSupport.on_load(:active_record) do
-      require 'speed_gun/profiler/active_record'
-
-      SpeedGun::Profiler::ActiveRecord.hook_method(
-        ActiveRecord::Base.connection.class,
-        :execute
-      )
+      require 'speed_gun/profiler/active_record_profiler'
     end
   end
 end

data/lib/speed_gun/store/elastic_search_store.rb

@@ -0,0 +1,64 @@
+require 'speed_gun/store'
+
+class SpeedGun::Store::ElasticSearchStore < SpeedGun::Store
+  DEFAULT_INDEX = 'speed_gun'
+
+  def initialize(options = {})
+    @index = options[:index] || DEFAULT_INDEX
+    @async = options.fetch(:async, true)
+    @client = options[:client] || default_clinet(options)
+  end
+
+  def save(object)
+    @async ? save_with_async(object) : save_without_async(object)
+  end
+
+  def load(klass, id)
+    hit = @client.search(
+      index: @index,
+      body: {
+        query: {
+          match: {
+            "_id" => id,
+            "_type" => underscore(klass.name)
+          }
+        }
+      }
+    )['hits']['hits'].first['_source']
+
+    klass.from_hash(id, hit)
+  end
+
+  private
+
+  def save_with_async(object)
+    Thread.new(object) { |object| save_without_async(object) }
+  end
+
+  def save_without_async(object)
+    @client.index(
+      index: @index,
+      type: underscore(object.class.name),
+      id: object.id,
+      body: object.to_hash.merge(
+        '@timestamp' => Time.now
+      )
+    )
+  end
+
+  def index(klass)
+    [@prefix, underscore(klass.name)].join('-')
+  end
+
+  def underscore(name)
+    name = name
+    name.sub!(/^[A-Z]/) { |c| c.downcase }
+    name.gsub!(/[A-Z]/) { |c| "_#{c.downcase}" }
+    name.gsub!('::', '')
+  end
+
+  def default_clinet(options)
+    require 'elasticsearch' unless defined?(Elasticsearch)
+    Elasticsearch::Client.new(options)
+  end
+end

data/lib/speed_gun/store/fluent_logger_store.rb

@@ -0,0 +1,29 @@
+require 'speed_gun/store'
+
+class SpeedGun::Store::FluentLoggerStore < SpeedGun::Store
+  DEFAULT_PREFIX = 'speed_gun'
+
+  def initialize(options = {})
+    @prefix = options[:prefix] || DEFAULT_PREFIX
+    @logger = options[:logger] || default_logger(options)
+  end
+
+  def save(object)
+    @logger.post(tag(object), object.to_hash.merge(id: object.id))
+  end
+
+  def load(klass, id)
+    nil
+  end
+
+  private
+
+  def tag(object)
+    object.class.name.sub(/.*::/, '').downcase
+  end
+
+  def default_logger(options)
+    require 'fluent-logger' unless defined?(Fluent::Logger)
+    Fluent::Logger::FluentLogger.new(@prefix, options)
+  end
+end

data/lib/speed_gun/store/memcache_store.rb

@@ -0,0 +1,40 @@
+require 'speed_gun/store'
+
+class SpeedGun::Store::MemcacheStroe < SpeedGun::Store
+  DEFAULT_PREFIX = 'speed-gun'
+  DEFAULT_EXPIRES_IN_SECONDS = 60 * 60 * 24
+
+  def initialize(options = {})
+    @prefix = options[:prefix] || DEFAULT_PREFIX
+    @client = options[:client] || default_client(options)
+    @expires = (options[:expires] || DEFAULT_EXPIRES_IN_SECONDS).to_i
+  end
+
+  def save(object)
+    @client.set(
+      key(object.class, object.id),
+      object.to_hash.to_msgpack,
+      @expires
+    )
+  end
+
+  def load(klass, id)
+    klass.from_hash(id, MessagePack.unpack(@client.get(key(klass, id))))
+  end
+
+  private
+
+  def key(klass, id)
+    klass_name = klass.name
+    klass_name.gsub!(/([a-z])([A-Z])/) { |c| "#{$1.to_s}_#{$2.to_s.downcase}" }
+    klass_name.gsub!(/[A-Z]/) { |c| "#{c.downcase}" }
+    klass_name.gsub!('::', '-')
+
+    [@prefix, klass_name, id].join('-')
+  end
+
+  def default_client(options)
+    require 'dalli' unless defined?(Dalli)
+    Dalli.new(options)
+  end
+end

data/lib/speed_gun/store/memory_store.rb

@@ -0,0 +1,23 @@
+require 'speed_gun/store'
+
+class SpeedGun::Store::MemoryStore < SpeedGun::Store
+  DEFAULT_MAX_ENTRIES = 1000
+
+  def initialize(options = {})
+    @max_entries = options[:max_entries] || DEFAULT_MAX_ENTRIES
+    @store = {}
+    @stored_list = []
+  end
+
+  def save(object)
+    id = "#{object.class.name}-#{object.id}"
+    @store[id] = object.to_hash
+    @stored_list.push(id)
+
+    @store.delete(@stored_list.shift) while @stored_list.length > @max_entries
+  end
+
+  def load(klass, id)
+    klass.from_hash(id, @store["#{klass.name}-#{id}"])
+  end
+end

data/lib/speed_gun/store/multiple_store.rb

@@ -0,0 +1,23 @@
+require 'speed_gun/store'
+
+class SpeedGun::Store::MultipleStore < SpeedGun::Store
+  def initialize(stores = [])
+    @stores = stores
+  end
+
+  def save(object)
+    @stores.each do |store|
+      store.save(object)
+    end
+  end
+
+  def load(klass, id)
+    @stores.each do |store|
+      ret = store.load(klass, id)
+
+      return ret if ret
+    end
+
+    nil
+  end
+end

data/lib/speed_gun/store/redis_store.rb

@@ -0,0 +1,41 @@
+require 'msgpack'
+require 'speed_gun/store'
+
+class SpeedGun::Store::RedisStore < SpeedGun::Store
+  DEFAULT_PREFIX = 'speed-gun'
+  DEFAULT_EXPIRES_IN_SECONDS = 60 * 60 * 24
+
+  def initialize(options = {})
+    @prefix = options[:prefix] || DEFAULT_PREFIX
+    @client = options[:client] || default_client(options)
+    @expires = (options[:expires] || DEFAULT_EXPIRES_IN_SECONDS).to_i
+  end
+
+  def save(object)
+    @client.setex(
+      key(object.class, object.id),
+      @expires,
+      object.to_hash.to_msgpack
+    )
+  end
+
+  def load(klass, id)
+    klass.from_hash(id, MessagePack.unpack(@client.get(key(klass, id))))
+  end
+
+  private
+
+  def key(klass, id)
+    klass_name = klass.name
+    klass_name.gsub!(/([a-z])([A-Z])/) { |c| "#{$1.to_s}_#{$2.to_s.downcase}" }
+    klass_name.gsub!(/[A-Z]/) { |c| "#{c.downcase}" }
+    klass_name.gsub!('::', '-')
+
+    [@prefix, klass_name, id].join('-')
+  end
+
+  def default_client(options)
+    require 'redis' unless defined? Redis
+    Redis.new(options)
+  end
+end

data/lib/speed_gun/store.rb

@@ -1,6 +1,10 @@
 require 'speed_gun'
 
-module SpeedGun::Store
-end
+# @abstract
+class SpeedGun::Store
+  def save(object)
+  end
 
-require 'speed_gun/store/memory'
+  def load(klass, id)
+  end
+end

data/lib/speed_gun/template.rb

@@ -6,7 +6,7 @@ class SpeedGun::Template < Slim::Template
     File.join(File.dirname(__FILE__), 'app/views/meter.html.slim')
 
   def self.render
-    new.render(SpeedGun.current)
+    new.render(SpeedGun.current_profile)
   end
 
   def initialize

data/lib/speed_gun/version.rb

@@ -1,3 +1,3 @@
 module SpeedGun
-  VERSION = '0.0.4'
+  VERSION = '1.0.0.rc1'.freeze
 end

data/lib/speed_gun.rb

@@ -1,52 +1,43 @@
+require 'forwardable'
 require 'thread'
+require 'speed_gun/version'
+require 'speed_gun/config'
+require 'speed_gun/profile'
+require 'speed_gun/middleware'
 
 module SpeedGun
   class << self
-    attr_writer :config
-  end
-
-  def self.current
-    Thread.current[:speed_gun_current]
-  end
-
-  def self.current=(profiler)
-    Thread.current[:speed_gun_current] = profiler
-  end
-
-  def self.config
-    @config ||= SpeedGun::Config.new
-  end
-
-  def self.active?
-    current && current.active?
-  end
-
-  def self.activate!
-    current && current.activate!
-  end
+    # @return [SpeedGun::Config] the config of speed gun
+    def config
+      @config ||= Config.new
+    end
 
-  def self.deactivate!
-    current && current.deactivate!
-  end
+    # @return [SpeedGun::Profile, nil] the profile of a current thread
+    def current_profile
+      Thread.current[:speed_gun_current_profile]
+    end
 
-  def self.enable?
-    config.enable?
-  end
+    # Set the profile of a current thread
+    #
+    # @param profile [SpeedGun::Profile] the profile
+    # @return [SpeedGun::Profile] the profile of a current thread
+    def current_profile=(profile)
+      Thread.current[:speed_gun_current_profile] = profile
+    end
 
-  def self.store
-    config.store
-  end
+    # Discard the profile of a current thread
+    #
+    # @return [nil]
+    def discard_profile!
+      self.current_profile = nil
+    end
 
-  def self.profile(title, *args, &block)
-    if title.kind_of?(String)
-      current && current.profile(:manual, title, &block)
-    else
-      current && current.profile(title, *args, &block)
+    # @see SpeedGun::Config#enabled?
+    # @return [Boolean] true if enabled speed gun
+    def enabled?
+      config.enabled?
     end
   end
 end
 
-require 'speed_gun/version'
-require 'speed_gun/config'
-require 'speed_gun/middleware'
 require 'speed_gun/railtie' if defined?(Rails)

data/spec/lib/speed_gun/config_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe SpeedGun::Config do
+  subject(:config) { described_class.new }
+
+  describe '#enable!' do
+    before do
+      config.disable!
+    end
+
+    it 'enables the config' do
+      expect(config).to_not be_enabled
+      config.enable!
+      expect(config).to be_enabled
+    end
+  end
+
+  describe '#disable!' do
+    it 'disables the config' do
+      expect(config).to_not be_disabled
+      config.disable!
+      expect(config).to be_disabled
+    end
+  end
+
+  describe '#enabled?' do
+    it 'defaults to true' do
+      expect(config.enabled?).to be_true
+    end
+  end
+
+  describe '#disabled?' do
+    it 'defaults to false' do
+      expect(config.disabled?).to be_false
+    end
+  end
+end

data/spec/lib/speed_gun/event_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe SpeedGun::Event do
+  let(:event_name) { 'spec.test' }
+
+  subject(:event) { described_class.new(event_name) }
+
+  describe '#id' do
+    subject { event.id }
+
+    it { should be_kind_of(String) }
+  end
+
+  describe '#name' do
+    subject { event.name }
+
+    it { should be_kind_of(String) }
+    it { should eq(event_name) }
+  end
+
+  describe '#started_at' do
+    subject { event.started_at }
+
+    it { should be_kind_of(Time) }
+  end
+
+  describe '#finished_at' do
+    subject { event.finished_at }
+
+    context 'when finished event' do
+      before { event.finish! }
+
+      it { should be_kind_of(Time) }
+    end
+
+    context 'when continues event' do
+      it { should be_nil }
+    end
+  end
+
+  describe '#finish!' do
+    it 'finishes the event' do
+      expect(event).to_not be_finished
+      event.finish!
+      expect(event).to be_finished
+    end
+  end
+
+  describe '#duration' do
+    subject(:duration) { event.duration }
+
+    context 'when continues event' do
+      it { should eq(-1) }
+    end
+
+    context 'when finished event' do
+      before { event.finish! }
+
+      it { should be_kind_of(Float) }
+    end
+  end
+
+  describe '#to_hash' do
+    it 'valid serialize' do
+      expect(
+        SpeedGun::Event.from_hash(event.id, event.to_hash).to_hash
+      ).to eq(event.to_hash)
+    end
+  end
+end

data/spec/lib/speed_gun/middleware_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe SpeedGun::Middleware do
+  include Rack::Test::Methods
+
+  before(:all) do
+    SpeedGun.config.skip_paths << '/skip'
+  end
+
+  let(:app) do
+    builder = Rack::Builder.new do
+      use SpeedGun::Middleware
+
+      map '/skip' do
+        process = lambda do |env|
+          [
+            200,
+            { 'Content-Type' => 'text/html' },
+            "<html><BODY><h1>Skip</h1></BODY>\n \t</html>"
+          ]
+        end
+
+        run process
+      end
+
+      map '/html' do
+        process = lambda do |env|
+          [
+            200,
+            { 'Content-Type' => 'text/html' },
+            "<html><BODY><h1>Hi</h1></BODY>\n \t</html>"
+          ]
+        end
+
+        run process
+      end
+    end
+    builder.to_app
+  end
+
+  describe 'GET /skip' do
+    subject(:response) { get '/skip' }
+
+    it { should be_ok }
+
+    describe '#headers' do
+      subject { response.headers }
+
+      it { should_not be_has_key('X-SpeedGun-Profile-Id') }
+    end
+  end
+
+  describe 'GET /html' do
+    subject(:response) { get '/html' }
+
+    it { should be_ok }
+
+    describe '#headers' do
+      subject { response.headers }
+
+      it { should be_has_key('X-SpeedGun-Profile-Id') }
+    end
+  end
+end

data/spec/lib/speed_gun/profile_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe SpeedGun::Profile do
+  subject(:profile) { described_class.new }
+
+  describe '#id' do
+    subject { profile.id }
+
+    it { should be_kind_of(String) }
+  end
+
+  describe '#events' do
+    subject { profile.events }
+
+    it { should be_kind_of(Array) }
+  end
+
+  describe '#record!' do
+    let(:logger) { double(debug: nil) }
+    let(:event) { SpeedGun::Event.new('spec.test') }
+
+    before { profile.config.logger = logger }
+
+    it 'records event' do
+      expect(profile.record!(event)).to eq(profile.events)
+      expect(profile.events).to include(event)
+    end
+  end
+
+  describe '#to_hash' do
+    let(:event) { SpeedGun::Event.new('spec.test') }
+
+    before { profile.record!(event) }
+
+    it 'valid serialize' do
+      expect(
+        SpeedGun::Profile.from_hash(profile.id, profile.to_hash).to_hash
+      ).to eq(profile.to_hash)
+    end
+  end
+end

data/spec/lib/speed_gun_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe SpeedGun do
+  subject { described_class }
+
+  describe '#config' do
+    subject { described_class.config }
+
+    it { should be_kind_of(SpeedGun::Config) }
+  end
+
+  describe '#current_profile' do
+    let(:profile) { double }
+    subject(:current_profile) { described_class.current_profile }
+
+    it 'defaults to be nil' do
+      expect(current_profile).to be_nil
+    end
+
+    it 'thread localy' do
+      described_class.current_profile = profile
+      expect(current_profile).to eq(profile)
+
+      thread = Thread.new { expect(described_class.current_profile).to be_nil }
+      thread.join
+    end
+  end
+
+  describe '#discard_profile!' do
+    let(:profile) { double }
+
+    it 'discards current profile' do
+      described_class.current_profile = profile
+      described_class.discard_profile!
+      expect(described_class.current_profile).to be_nil
+    end
+  end
+
+  describe '#enabled?' do
+    context 'when enabled' do
+      before { described_class.config.stub(enabled?: true) }
+
+      it { should be_enabled }
+    end
+
+    context 'when disabled' do
+      before { described_class.config.stub(enabled?: false) }
+
+      it { should_not be_enabled }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'support/simplecov'
+
+require 'speed_gun'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/support/simplecov.rb

@@ -0,0 +1,12 @@
+require 'simplecov'
+require 'simplecov-console'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::Console,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter('spec')
+end