speed_gun 1.0.0.rc1 → 2.0.0.pre.alpha.1

data/lib/speed_gun/profiler/active_support_profiler.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'speed_gun/profiler/active_support_notifications_profiler'
+
+class SpeedGun::Profiler::ActiveSupportProfiler < SpeedGun::Profiler::ActiveSupportNotificatiosProfiler
+  subscribe %r{\.active_support$}
+end
+
+

data/lib/speed_gun/profiler/line_profiler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'rblineprof'
+require 'speed_gun/source'
+require 'speed_gun/profiler'
+
+class SpeedGun::Profiler::LineProfiler < SpeedGun::Profiler
+  def self.regexp
+    if SpeedGun.config.lineprof_paths.empty?
+      %r{.}
+    else
+      Regexp.union(*SpeedGun.config.lineprof_paths)
+    end
+  end
+
+  def profile(*_args)
+    return yield if self.class.ignore?
+
+    result = nil
+    lineprofiled = lineprof(self.class.regexp) do
+      result = yield
+    end
+    store(lineprofiled) if SpeedGun.current_report
+    result
+  end
+
+  def store(lineprofiled)
+    lineprofiled.each_pair do |file, linesamples|
+      source = SpeedGun::Source.new(file, linesamples)
+      SpeedGun.current_report.source(source) unless source.lines.empty?
+    end
+  end
+end

data/lib/speed_gun/profiler/rack_profiler.rb

@@ -1,7 +1,5 @@
+# frozen_string_literal: true
 require 'speed_gun/profiler'
 
-class SpeedGun::Profiler::RackProfier < SpeedGun::Profiler
-  def self.name
-    'rack.total'
-  end
+class SpeedGun::Profiler::RackProfiler < SpeedGun::Profiler
 end

data/lib/speed_gun/profiler.rb

@@ -1,21 +1,27 @@
+# frozen_string_literal: true
 require 'speed_gun'
+require 'speed_gun/event'
 
-# @abstract
 class SpeedGun::Profiler
   def self.profile(*args, &block)
     new.profile(*args, &block)
   end
 
-  def profile(name = self.class.name, payload = {}, &block)
-    starts_at = Time.now
+  def self.ignore?
+    SpeedGun.config.ignored_profilers.any? do |ignore|
+      name.include?(ignore)
+    end
+  end
+
+  def profile(name = self.class.name, payload = {})
+    started_at = Time.now
 
-    ret = yield
+    event = SpeedGun::Event.new(name, payload, started_at)
+    result = yield(event)
+    event.finish!
 
-    event = SpeedGun::Event.new(
-      name, payload, starts_at, Time.now
-    )
-    SpeedGun.current_profile.record!(event)
+    SpeedGun.record(event) unless self.class.ignore?
 
-    return ret
+    result
   end
 end

data/lib/speed_gun/railtie.rb

@@ -1,13 +1,21 @@
+# frozen_string_literal: true
 require 'speed_gun'
+require 'speed_gun/store/file_store'
+require 'rack/speed_gun'
+require 'rails/railtie'
 
 class SpeedGun::Railtie < ::Rails::Railtie
   initializer 'speed_gun' do |app|
-    app.middleware.insert(0, SpeedGun::Middleware)
+    app.middleware.insert(0, Rack::SpeedGun)
 
-    SpeedGun.config.logger = Rails.logger
-    SpeedGun.config.skip_paths.push(
-      /^#{Regexp.escape(app.config.assets.prefix)}/
-    )
+    SpeedGun.configure do |config|
+      config.logger = Rails.logger
+      config.store = SpeedGun::Store::FileStore.new(Rails.root.join('tmp/speed_gun').to_s)
+      config.lineprof_paths.push(Rails.root.to_s)
+      config.skip_paths.push(app.config.assets.prefix)
+    end
+
+    require 'speed_gun/profiler/active_support_profiler'
 
     ActiveSupport.on_load(:action_controller) do
       require 'speed_gun/profiler/action_controller_profiler'
@@ -20,5 +28,13 @@ class SpeedGun::Railtie < ::Rails::Railtie
     ActiveSupport.on_load(:active_record) do
       require 'speed_gun/profiler/active_record_profiler'
     end
+
+    ActiveSupport.on_load(:action_mailer) do
+      require 'speed_gun/profiler/action_mailer_profiler'
+    end
+
+    ActiveSupport.on_load(:active_job) do
+      require 'speed_gun/profiler/active_job_profiler'
+    end
   end
 end

data/lib/speed_gun/report.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require 'securerandom'
+require 'speed_gun'
+
+class SpeedGun::Report
+  # @return [String] Report ID
+  attr_reader :id
+
+  # @return [Array<SpeedGun::Source>] Profiled source codes
+  attr_reader :sources
+
+  # @return [Array<SpeedGun::Event>] Recorded events
+  attr_reader :events
+
+  def self.from_hash(hash)
+    report = new
+
+    hash['sources'].map! do |source_id, hash|
+      SpeedGun::Source.from_hash(hash, source_id)
+    end
+
+    hash['events'].map! do |event_id, hash|
+      SpeedGun::Event.from_hash(hash, event_id)
+    end
+
+    hash.each_pair do |key, val|
+      report.instance_variable_set(:"@#{key}", val)
+    end
+
+    report
+  end
+
+  def initialize
+    @id = SecureRandom.uuid
+    @sources = []
+    @events = []
+  end
+
+  def record(event)
+    @events.push(event)
+  end
+
+  def source(source)
+    @sources.push(source)
+  end
+
+  def nearlest_event_started_at
+    @events.sort_by(&:started_at).first.started_at
+  end
+
+  def latest_event_finished_at
+    @events.sort_by { |event| event.roughly_finished_at.to_f * -1 }.first.roughly_finished_at
+  end
+
+  def duration
+    latest_event_finished_at.to_f - nearlest_event_started_at.to_f
+  end
+
+  def to_hash
+    {
+      sources: sources.map { |source| [ source.id, source.to_hash ] },
+      events: events.map { |event| [event.id, event.to_hash] }
+    }
+  end
+end

data/lib/speed_gun/source.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+require 'securerandom'
+require 'speed_gun'
+
+class SpeedGun::Source
+  KEEP_RANGE = 3
+
+  class Line
+    attr_reader :id, :line, :code, :wall, :cpu, :calls, :allocations
+
+    def self.from_hash(hash, id = nil)
+      keys = %w(line code wall cpu calls allocations)
+      vals = keys.map { |k| hash[k] }
+      new(*vals).tap do |line|
+        line.instance_variable_set(:@id, id) if id
+      end
+    end
+
+    def initialize(line, code, wall, cpu, calls, allocations)
+      @id = SecureRandom.uuid
+      @line, @code, @wall, @cpu, @calls, @allocations = line, code, wall, cpu, calls, allocations
+    end
+
+    def to_s
+      format('% 8.1fms + % 8.1fms (% 5d) % 5d allocs | %04d %s', cpu / 1000.0, (wall - cpu) / 1000.0, calls, allocations, line, code)
+    end
+
+    def to_hash
+      {
+        line: line,
+        code: code,
+        wall: wall,
+        cpu: cpu,
+        calls: calls,
+        allocations: allocations
+      }
+    end
+  end
+
+  attr_reader :id, :file, :lines
+
+  def self.from_hash(hash, id = nil)
+    source = new(hash['file'], nil)
+
+    lines = (hash['lines'] || []).map do |line_id, hash|
+      Line.from_hash(hash, line_id)
+    end
+
+    source.instance_variable_set(:@lines, lines)
+    source.instance_variable_set(:@id, id) if id
+
+    source
+  end
+
+  def initialize(file, linesamples)
+    @id = SecureRandom.uuid
+    @file = file
+    @lines = []
+    analyze(file, linesamples) if linesamples
+  end
+
+  def analyze(file, linesamples)
+    code_lines = File.exist?(file) ? File.readlines(file) : []
+
+    keep_lines = []
+    code_lines.each_with_index do |line, idx|
+      sample = linesamples[idx + 1] || [0, 0, 0, 0]
+      wall, cpu, calls, allocations = *sample
+
+      keep_lines.push(idx) if calls > 0
+      @lines.push(Line.new(idx + 1, line, wall, cpu, calls, allocations))
+    end
+
+    @lines.select! do |line|
+      idx = line.line - 1
+      ((KEEP_RANGE * -1)..KEEP_RANGE).any? { |n| keep_lines.include?(idx + n) }
+    end
+  end
+
+  def to_s
+    "#{file}====\n#{lines.map(&:to_s).join('')}"
+  end
+
+  def to_hash
+    {
+      file: file,
+      lines: lines.map { |line| [ line.id, line.to_hash ] }
+    }
+  end
+end

data/lib/speed_gun/store/file_store.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+require 'speed_gun/store'
+
+class SpeedGun::Store::FileStore < SpeedGun::Store
+  def initialize(basedir)
+    @basedir = basedir
+  end
+
+  def store(obj)
+    key, val = serialize(obj)
+
+    filepath = pathnize(key)
+    dirname = File.dirname(filepath)
+    FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    File.open(filepath, 'wb') do |fp|
+      fp.write(val)
+    end
+  end
+
+  def load(key)
+    filepath = pathnize(key)
+    return nil unless File.exist?(filepath)
+
+    msg = File.open(filepath, 'rb', &:read)
+    deserialize(key, msg)
+  end
+
+  private
+
+  def pathnize(key)
+    klass, id = *key.split('/', 2)
+
+    File.join(@basedir, *klass.split('::'), id)
+  end
+end

data/lib/speed_gun/store/memory_store.rb

@@ -1,23 +1,16 @@
 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 = []
+  def initialize
+    @data = {}
   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
+  def store(obj)
+    key, val = serialize(obj)
+    @data[key] = val
   end
 
-  def load(klass, id)
-    klass.from_hash(id, @store["#{klass.name}-#{id}"])
+  def load(key)
+    deserialize(key, @data[key])
   end
 end

data/lib/speed_gun/store.rb

@@ -1,10 +1,17 @@
+require 'msgpack'
 require 'speed_gun'
 
-# @abstract
 class SpeedGun::Store
-  def save(object)
+  def serialize(obj)
+    ["#{obj.class.name}/#{obj.id}", MessagePack.pack(obj.to_hash)]
   end
 
-  def load(klass, id)
+  def deserialize(key, msg)
+    return nil if msg.nil? || msg.empty?
+    hash = MessagePack.unpack(msg)
+    klass, id = *key.split('/', 2)
+    obj = Object.const_get(klass).from_hash(hash)
+    obj.instance_variable_set(:@id, id)
+    obj
   end
 end

data/lib/speed_gun/version.rb

@@ -1,3 +1,11 @@
+# frozen_string_literal: true
+require 'semantic'
+
 module SpeedGun
-  VERSION = '1.0.0.rc1'.freeze
+  VERSION = '2.0.0-alpha.1'
+
+  # @return [Semantic::Version] Version
+  def self.version
+    @version ||= Semantic::Version.new(VERSION)
+  end
 end

data/lib/speed_gun.rb

@@ -1,43 +1,38 @@
-require 'forwardable'
-require 'thread'
+# frozen_string_literal: true
 require 'speed_gun/version'
 require 'speed_gun/config'
-require 'speed_gun/profile'
-require 'speed_gun/middleware'
+require 'speed_gun/report'
+require 'rack/speed_gun'
+require 'speed_gun/railtie' if defined?(::Rails)
 
 module SpeedGun
   class << self
-    # @return [SpeedGun::Config] the config of speed gun
+    # @return [SpeedGun::Config]
     def config
-      @config ||= Config.new
+      @config ||= SpeedGun::Config.new
     end
 
-    # @return [SpeedGun::Profile, nil] the profile of a current thread
-    def current_profile
-      Thread.current[:speed_gun_current_profile]
+    # @yield [config] Configure speed gun
+    # @yieldparam config [SpeedGun::Config]
+    def configure
+      yield config
     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
+    # @return [SpeedGun::Report, nil]
+    def current_report
+      Thread.current[:speed_gun_report]
     end
 
-    # Discard the profile of a current thread
-    #
-    # @return [nil]
-    def discard_profile!
-      self.current_profile = nil
+    def current_report=(report)
+      Thread.current[:speed_gun_report] = report
     end
 
-    # @see SpeedGun::Config#enabled?
-    # @return [Boolean] true if enabled speed gun
-    def enabled?
-      config.enabled?
+    def record(event)
+      current_report && current_report.record(event)
+    end
+
+    def get_report(id)
+      config.store.load("SpeedGun::Report/#{id}")
     end
   end
 end
-
-require 'speed_gun/railtie' if defined?(Rails)

data/speed_gun.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'speed_gun/version'
@@ -7,26 +8,30 @@ Gem::Specification.new do |spec|
   spec.name          = 'speed_gun'
   spec.version       = SpeedGun::VERSION
   spec.authors       = ['Sho Kusano']
-  spec.email         = ['rosylilly@aduca.org']
-  spec.summary       = %q{Better web app profiler for Rails apps}
-  spec.description   = %q{Better web app profiler for Rails apps}
-  spec.homepage      = 'https://github.com/rosylilly/speed_gun'
+  spec.email         = ['sho-kusano@zeny.io']
+
+  spec.summary       = 'Better web app profiler for Rails apps'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/zeny-io/speed_gun'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 2.14.1'
-  spec.add_development_dependency 'simplecov', '~> 0.8.2'
-  spec.add_development_dependency 'simplecov-console'
-  spec.add_development_dependency 'rack-test'
-  spec.add_development_dependency 'coveralls'
-
-  spec.add_dependency 'hashie'
   spec.add_dependency 'msgpack'
+  spec.add_dependency 'rack'
+  spec.add_dependency 'rblineprof'
+  spec.add_dependency 'sass'
+  spec.add_dependency 'semantic'
+  spec.add_dependency 'sinatra'
+  spec.add_dependency 'sinatra-partial'
   spec.add_dependency 'slim'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'yard'
 end