profile_it 0.2.4

data/lib/profile_it/metric_stats.rb

@@ -0,0 +1,50 @@
+# Stats that are associated with each instrumented method. 
+class ProfileIt::MetricStats
+  attr_accessor :call_count
+  attr_accessor :min_call_time
+  attr_accessor :max_call_time
+  attr_accessor :total_call_time
+  attr_accessor :total_exclusive_time
+  attr_accessor :sum_of_squares
+  
+  def initialize(scoped = false)
+    @scoped = scoped
+    self.call_count = 0
+    self.total_call_time = 0.0
+    self.total_exclusive_time = 0.0
+    self.min_call_time = 0.0
+    self.max_call_time = 0.0
+    self.sum_of_squares = 0.0
+  end
+  
+  def update!(call_time,exclusive_time)
+    # If this metric is scoped inside another, use exclusive time for min/max and sum_of_squares. Non-scoped metrics
+    # (like controller actions) track the total call time.
+    t = (@scoped ? exclusive_time : call_time)
+    self.min_call_time = t if self.call_count == 0 or t < min_call_time
+    self.max_call_time = t if self.call_count == 0 or t > max_call_time   
+    self.call_count +=1
+    self.total_call_time += call_time
+    self.total_exclusive_time += exclusive_time
+    self.sum_of_squares += (t * t)
+    self
+  end
+  
+  # combines data from another MetricStats object
+  def combine!(other)
+    self.call_count += other.call_count
+    self.total_call_time += other.total_call_time
+    self.total_exclusive_time += other.total_exclusive_time
+    self.min_call_time = other.min_call_time if self.min_call_time.zero? or other.min_call_time < self.min_call_time
+    self.max_call_time = other.max_call_time if other.max_call_time > self.max_call_time
+    self.sum_of_squares += other.sum_of_squares
+    self
+  end
+  
+  # THIS ISN'T USED ANYMORE. STILL A CONFLICT ISSUE?
+  # To avoid conflicts with different JSON libaries handle JSON ourselves. 
+  # Time-based metrics are converted to milliseconds from seconds.
+  def to_json(*a)
+    %Q[{"total_exclusive_time":#{total_exclusive_time*1000},"min_call_time":#{min_call_time*1000},"call_count":#{call_count},"sum_of_squares":#{sum_of_squares*1000},"total_call_time":#{total_call_time*1000},"max_call_time":#{max_call_time*1000}}]
+  end
+end # class MetricStats

data/lib/profile_it/profile.rb

@@ -0,0 +1,39 @@
+class ProfileIt::Profile
+  BACKTRACE_THRESHOLD = 0.5 # the minimum threshold to record the backtrace for a metric.
+  BACKTRACE_LIMIT = 5 # Max length of callers to display
+  MAX_SIZE = 100 # Limits the size of the metric hash to prevent a metric explosion.
+  attr_reader :metric_name, :total_call_time, :metrics, :meta, :uri, :request_id
+  
+  # Given a call stack, generates a filtered backtrace that:
+  # * Limits to the app/models, app/controllers, or app/views directories
+  # * Limits to 5 total callers
+  # * Makes the app folder the top-level folder used in trace info
+  def self.backtrace_parser(backtrace)
+    stack = []
+    backtrace.each do |c|
+      if m=c.match(/(\/app\/(controllers|models|views)\/.+)/)
+        stack << m[1]
+        break if stack.size == BACKTRACE_LIMIT
+      end
+    end
+    stack
+  end
+  
+  def initialize(uri,request_id,metric_name,total_call_time,metrics)
+    @uri = uri
+    @metric_name = metric_name
+    @total_call_time = total_call_time
+    @request_id = request_id
+    @metrics = metrics
+  end
+
+  def to_form_data
+    {
+      "profile[uri]" => uri,
+      "profile[metric_name]" => metric_name,
+      "profile[total_call_time]" => total_call_time,
+      "profile[id]" => request_id,
+      "profile[metrics]" => Marshal.dump(metrics)
+    }
+  end
+end

data/lib/profile_it/stack_item.rb

@@ -0,0 +1,18 @@
+class ProfileIt::StackItem
+  attr_accessor :children_time
+  attr_reader :metric_name, :start_time 
+  
+  def initialize(metric_name)
+    @metric_name = metric_name
+    @start_time = Time.now
+    @children_time = 0
+  end
+  
+  def ==(o)
+    self.eql?(o)
+  end
+
+  def eql?(o)
+    self.class == o.class && metric_name.eql?(o.metric_name)
+  end
+end # class StackItem

data/lib/profile_it/store.rb

@@ -0,0 +1,166 @@
+# The store encapsolutes the logic that (1) saves instrumented data by Metric name to memory and (2) maintains a stack (just an Array)
+# of instrumented methods that are being called. It's accessed via +ProfileIt::Agent.instance.store+. 
+class ProfileIt::Store
+  
+  # Limits the size of the metric hash to prevent a metric explosion. 
+  MAX_SIZE = 1000
+  
+  attr_accessor :metric_hash
+  attr_accessor :profile_hash
+  attr_accessor :stack
+  attr_accessor :sample
+  attr_reader :profile_sample_lock
+  
+  def initialize
+    @metric_hash = Hash.new
+    # Stores aggregate metrics for the current profile. When the profile is finished, metrics
+    # are merged with the +metric_hash+.
+    @profile_hash = Hash.new
+    @stack = Array.new
+    # ensure background thread doesn't manipulate profile sample while the store is.
+    @profile_sample_lock = Mutex.new
+  end
+  
+  # Called when the last stack item completes for the current profile to clear
+  # for the next run.
+  def reset_profile!
+    Thread::current[:profile_it_ignore] = nil
+    Thread::current[:profile_it_scope_name] = nil
+    @profile_hash = Hash.new
+    @stack = Array.new
+  end
+  
+  def ignore_profile!
+    Thread::current[:profile_it_ignore] = true
+  end
+  
+  # Called at the start of Tracer#instrument:
+  # (1) Either finds an existing MetricStats object in the metric_hash or 
+  # initialize a new one. An existing MetricStats object is present if this +metric_name+ has already been instrumented.
+  # (2) Adds a StackItem to the stack. This StackItem is returned and later used to validate the item popped off the stack
+  # when an instrumented code block completes.
+  def record(metric_name)
+    item = ProfileIt::StackItem.new(metric_name)
+    stack << item
+    item
+  end
+  
+  def stop_recording(sanity_check_item, options={})
+    item = stack.pop
+    stack_empty = stack.empty?
+
+    # if ignoring the profile, the item is popped but nothing happens. 
+    if Thread::current[:profile_it_ignore]
+      return
+    end
+    # unbalanced stack check - unreproducable cases have seen this occur. when it does, sets a Thread variable 
+    # so we ignore further recordings. +Store#reset_profile!+ resets this. 
+    if item != sanity_check_item
+      ProfileIt::Agent.instance.logger.warn "Scope [#{Thread::current[:profile_it_scope_name]}] Popped off stack: #{item.inspect} Expected: #{sanity_check_item.inspect}. Aborting."
+      ignore_profile!
+      return
+    end
+    duration = Time.now - item.start_time
+    if last=stack.last
+      last.children_time += duration
+    end
+    meta = ProfileIt::MetricMeta.new(item.metric_name, :desc => options[:desc])
+    meta.scope = nil if stack_empty
+    
+    # add backtrace for slow calls ... how is exclusive time handled?
+    if duration > ProfileIt::Profile::BACKTRACE_THRESHOLD and !stack_empty
+      meta.extra = {:backtrace => ProfileIt::Profile.backtrace_parser(caller)}
+    end
+    stat = profile_hash[meta] || ProfileIt::MetricStats.new(!stack_empty)
+    stat.update!(duration,duration-item.children_time)
+    profile_hash[meta] = stat if store_metric?(stack_empty)
+    # Uses controllers as the entry point for a profile. Otherwise, stats are ignored.
+    if stack_empty and meta.metric_name.match(/\AController\//)
+      aggs=aggregate_calls(profile_hash.dup,meta)
+      store_profile(options[:uri],options[:request_id],profile_hash.dup.merge(aggs),meta,stat)  
+      # deep duplicate  
+      duplicate = aggs.dup
+      duplicate.each_pair do |k,v|
+        duplicate[k.dup] = v.dup
+      end  
+      merge_data(duplicate.merge({meta.dup => stat.dup})) # aggregrates + controller 
+    end
+  end
+  
+  # TODO - Move more logic to Profile
+  #
+  # Limits the size of the profile hash to prevent a large profiles. The final item on the stack
+  # is allowed to be stored regardless of hash size to wrapup the profile sample w/the parent metric.
+  def store_metric?(stack_empty)
+    profile_hash.size < ProfileIt::Profile::MAX_SIZE or stack_empty
+  end
+  
+  # Returns the top-level category names used in the +metrics+ hash.
+  def categories(metrics)
+    cats = Set.new
+    metrics.keys.each do |meta|
+      next if meta.scope.nil? # ignore controller
+      if match=meta.metric_name.match(/\A([\w|\d]+)\//)
+        cats << match[1]
+      end
+    end # metrics.each
+    cats
+  end
+  
+  # Takes a metric_hash of calls and generates aggregates for ActiveRecord and View calls.
+  def aggregate_calls(metrics,parent_meta)
+    categories = categories(metrics)
+    aggregates = {}
+    categories.each do |cat|
+      agg_meta=ProfileIt::MetricMeta.new("#{cat}/all")
+      agg_meta.scope = parent_meta.metric_name
+      agg_stats = ProfileIt::MetricStats.new
+      metrics.each do |meta,stats|
+        if meta.metric_name =~ /\A#{cat}\//
+          agg_stats.combine!(stats) 
+        end
+      end # metrics.each
+      aggregates[agg_meta] = agg_stats unless agg_stats.call_count.zero?
+    end # categories.each    
+    aggregates
+  end
+
+  def store_profile(uri,request_id,profile_hash,parent_meta,parent_stat,options = {})
+    profile = ProfileIt::Profile.new(uri,request_id,parent_meta.metric_name,parent_stat.total_call_time,profile_hash.dup)
+    ProfileIt::Agent.instance.send_profile(profile)
+  end
+  
+  # Finds or creates the metric w/the given name in the metric_hash, and updates the time. Primarily used to 
+  # record sampled metrics. For instrumented methods, #record and #stop_recording are used.
+  #
+  # Options:
+  # :scope => If provided, overrides the default scope. 
+  # :exclusive_time => Sets the exclusive time for the method. If not provided, uses +call_time+.
+  def track!(metric_name,call_time,options = {})
+     meta = ProfileIt::MetricMeta.new(metric_name)
+     meta.scope = options[:scope] if options.has_key?(:scope)
+     stat = metric_hash[meta] || ProfileIt::MetricStats.new
+     stat.update!(call_time,options[:exclusive_time] || call_time)
+     metric_hash[meta] = stat
+  end
+  
+  # Combines old and current data
+  def merge_data(old_data)
+    old_data.each do |old_meta,old_stats|
+      if stats = metric_hash[old_meta]
+        metric_hash[old_meta] = stats.combine!(old_stats)
+      elsif metric_hash.size < MAX_SIZE
+        metric_hash[old_meta] = old_stats
+      end
+    end
+    metric_hash
+  end
+  
+  # Merges old and current data, clears the current in-memory metric hash, and returns
+  # the merged data
+  def merge_data_and_clear(old_data)
+    merged = merge_data(old_data)
+    self.metric_hash =  {}
+    merged
+  end
+end # class Store

data/lib/profile_it/tracer.rb

@@ -0,0 +1,105 @@
+# Contains the methods that instrument blocks of code. 
+# 
+# When a code block is wrapped inside #instrument(metric_name):
+# * The #instrument method pushes a StackItem onto Store#stack
+# * When a code block is finished, #instrument pops the last item off the stack and verifies it's the StackItem
+#   we created earlier. 
+# * Once verified, the metrics for the recording session are merged into the in-memory Store#metric_hash. The current scope
+#   is also set for the metric (if Thread::current[:profile_it_scope_name] isn't nil).
+module ProfileIt::Tracer
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  module ClassMethods
+    
+    # Use to trace a method call, possibly reporting slow profile traces to profile_it. 
+    def profile_request(metric_name, options = {}, &block)
+      ProfileIt::Agent.instance.store.reset_profile!      
+      profile_it_instrument(metric_name, options) do
+        Thread::current[:profile_it_scope_name] = metric_name
+        yield
+        Thread::current[:profile_it_scope_name] = nil
+      end
+    end
+    
+    # Options:
+    # - :scope => If specified, sets the sub-scope for the metric. We allow additional scope level. This is used
+    # when rendering the profile tree in the UI. 
+    def profile_it_instrument(metric_name, options={}, &block)
+      # why was this here? this would remove the scope name so the request wouldn't be instrumented.
+      #  ProfileIt::Agent.instance.store.reset_profile!      
+      # don't instrument if (1) NOT inside a profile and (2) NOT a Controller metric.
+      if !Thread::current[:profile_it_scope_name] and metric_name !~ /\AController\//
+        return yield
+      end
+      if options.delete(:scope)
+        Thread::current[:profile_it_sub_scope] = metric_name 
+      end
+      stack_item = ProfileIt::Agent.instance.store.record(metric_name)
+      begin
+        yield
+      ensure
+        Thread::current[:profile_it_sub_scope] = nil if Thread::current[:profile_it_sub_scope] == metric_name
+        ProfileIt::Agent.instance.store.stop_recording(stack_item,options)
+      end
+    end
+    
+    def profile_it_instrument_method(method,options = {})
+      metric_name = options[:metric_name] || default_metric_name(method)
+      return if !instrumentable?(method) or instrumented?(method,metric_name)
+      class_eval instrumented_method_string(method, {:metric_name => metric_name, :scope => options[:scope]}), __FILE__, __LINE__
+      
+      alias_method _profile_it_uninstrumented_method_name(method, metric_name), method
+      alias_method method, _profile_it_instrumented_method_name(method, metric_name)
+    end
+    
+    private
+    
+    def instrumented_method_string(method, options)
+      klass = (self === Module) ? "self" : "self.class"
+      "def #{_profile_it_instrumented_method_name(method, options[:metric_name])}(*args, &block)
+        result = #{klass}.profile_it_instrument(\"#{options[:metric_name]}\",{:scope => #{options[:scope] || false}}) do
+          #{_profile_it_uninstrumented_method_name(method, options[:metric_name])}(*args, &block)
+        end
+        result
+      end"
+    end
+    
+    # The method must exist to be instrumented.
+    def instrumentable?(method)
+      exists = method_defined?(method) || private_method_defined?(method)
+      ProfileIt::Agent.instance.logger.warn "The method [#{self.name}##{method}] does not exist and will not be instrumented" unless exists
+      exists
+    end
+    
+    # +True+ if the method is already instrumented. 
+    def instrumented?(method,metric_name)
+      instrumented = method_defined?(_profile_it_instrumented_method_name(method, metric_name))
+      ProfileIt::Agent.instance.logger.warn "The method [#{self.name}##{method}] has already been instrumented" if instrumented
+      instrumented
+    end
+    
+    def default_metric_name(method)
+      "Custom/#{self.name}/#{method.to_s}"
+    end
+    
+    # given a method and a metric, this method returns the
+    # untraced alias of the method name
+    def _profile_it_uninstrumented_method_name(method, metric_name)
+      "#{_sanitize_name(method)}_without_profile_it_instrument_#{_sanitize_name(metric_name)}"
+    end
+    
+    # given a method and a metric, this method returns the traced
+    # alias of the method name
+    def _profile_it_instrumented_method_name(method, metric_name)
+      name = "#{_sanitize_name(method)}_with_profile_it_instrument_#{_sanitize_name(metric_name)}"
+    end
+    
+    # Method names like +any?+ or +replace!+ contain a trailing character that would break when
+    # eval'd as ? and ! aren't allowed inside method names.
+    def _sanitize_name(name)
+      name.to_s.tr_s('^a-zA-Z0-9', '_')
+    end
+  end # ClassMethods
+end # module Tracer

data/lib/profile_it/version.rb

@@ -0,0 +1,3 @@
+module ProfileIt
+  VERSION = "0.2.4"
+end

data/lib/profile_it.rb

@@ -0,0 +1,34 @@
+module ProfileIt
+end
+require 'socket'
+require 'set'
+require 'net/http'
+require 'net/https'
+require 'logger'
+require 'yaml'
+require 'cgi'
+require File.expand_path('../profile_it/version.rb', __FILE__)
+require File.expand_path('../profile_it/agent.rb', __FILE__)
+require File.expand_path('../profile_it/agent/logging.rb', __FILE__)
+require File.expand_path('../profile_it/agent/reporting.rb', __FILE__)
+require File.expand_path('../profile_it/config.rb', __FILE__)
+require File.expand_path('../profile_it/environment.rb', __FILE__)
+require File.expand_path('../profile_it/metric_meta.rb', __FILE__)
+require File.expand_path('../profile_it/metric_stats.rb', __FILE__)
+require File.expand_path('../profile_it/stack_item.rb', __FILE__)
+require File.expand_path('../profile_it/store.rb', __FILE__)
+require File.expand_path('../profile_it/tracer.rb', __FILE__)
+require File.expand_path('../profile_it/profile.rb', __FILE__)
+
+if defined?(Rails) and Rails.respond_to?(:version) and Rails.version >= '3'
+  module ProfileIt
+    class Railtie < Rails::Railtie
+      initializer "profile_it.start" do |app|
+        ProfileIt::Agent.instance.start
+      end
+    end
+  end
+else
+  ProfileIt::Agent.instance.start
+end
+

data/profile_it.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "profile_it/version"
+
+Gem::Specification.new do |s|
+  s.name        = "profile_it"
+  s.version     = ProfileIt::VERSION
+  s.authors     = ["Derek Haynes",'Andre Lewis']
+  s.email       = ["support@scoutapp.com"]
+  s.homepage    = "https://github.com/scoutapp/profile_it"
+  s.summary     = "Rails Profiler UI"
+  s.description = "Profile a Ruby on Rails application in your browser and reports detailed metrics to profileit.io."
+
+  s.rubyforge_project = "profile_it"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: profile_it
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Derek Haynes
+- Andre Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-09 00:00:00.000000000 Z
+dependencies: []
+description: Profile a Ruby on Rails application in your browser and reports detailed
+  metrics to profileit.io.
+email:
+- support@scoutapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- CHANGELOG.markdown
+- Gemfile
+- LICENSE.markdown
+- README.markdown
+- Rakefile
+- data/cacert.pem
+- lib/profile_it.rb
+- lib/profile_it/agent.rb
+- lib/profile_it/agent/logging.rb
+- lib/profile_it/agent/reporting.rb
+- lib/profile_it/config.rb
+- lib/profile_it/environment.rb
+- lib/profile_it/instruments/active_record_instruments.rb
+- lib/profile_it/instruments/mongoid_instruments.rb
+- lib/profile_it/instruments/moped_instruments.rb
+- lib/profile_it/instruments/net_http.rb
+- lib/profile_it/instruments/rails/action_controller_instruments.rb
+- lib/profile_it/instruments/rails3_or_4/action_controller_instruments.rb
+- lib/profile_it/metric_meta.rb
+- lib/profile_it/metric_stats.rb
+- lib/profile_it/profile.rb
+- lib/profile_it/stack_item.rb
+- lib/profile_it/store.rb
+- lib/profile_it/tracer.rb
+- lib/profile_it/version.rb
+- profile_it.gemspec
+homepage: https://github.com/scoutapp/profile_it
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: profile_it
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rails Profiler UI
+test_files: []
+has_rdoc: