rack-mini-profiler 0.1.31 → 0.9.3

data/Ruby/lib/mini_profiler/config.rb

@@ -1,58 +0,0 @@
-module Rack
-  class MiniProfiler
-    class Config
-
-    def self.attr_accessor(*vars)
-      @attributes ||= []
-      @attributes.concat vars
-      super(*vars)
-    end
-
-    def self.attributes
-      @attributes
-    end
-
-    attr_accessor :auto_inject, :base_url_path, :pre_authorize_cb, :position,
-        :backtrace_remove, :backtrace_includes, :backtrace_ignores, :skip_schema_queries,
-        :storage, :user_provider, :storage_instance, :storage_options, :skip_paths, :authorization_mode,
-        :toggle_shortcut, :start_hidden, :backtrace_threshold_ms
-
-    # Deprecated options
-    attr_accessor :use_existing_jquery
-
-      def self.default
-        new.instance_eval {
-          @auto_inject = true # automatically inject on every html page
-          @base_url_path = "/mini-profiler-resources/"
-
-          # called prior to rack chain, to ensure we are allowed to profile
-          @pre_authorize_cb = lambda {|env| true}
-
-          # called after rack chain, to ensure we are REALLY allowed to profile
-          @position = 'left'  # Where it is displayed
-          @skip_schema_queries = false
-          @storage = MiniProfiler::MemoryStore
-          @user_provider = Proc.new{|env| Rack::Request.new(env).ip}
-          @authorization_mode = :allow_all
-          @toggle_shortcut = 'Alt+P'
-          @start_hidden = false
-          @backtrace_threshold_ms = 0
-          self
-        }
-      end
-
-      def merge!(config)
-        return unless config
-        if Hash === config
-          config.each{|k,v| instance_variable_set "@#{k}",v}
-        else
-          self.class.attributes.each{ |k|
-            v = config.send k
-            instance_variable_set "@#{k}", v if v
-          }
-        end
-      end
-
-    end
-  end
-end

data/Ruby/lib/mini_profiler/custom_timer_struct.rb

@@ -1,22 +0,0 @@
-require 'mini_profiler/timer_struct'
-
-module Rack
-  class MiniProfiler
-
-    # Timing system for a custom timers such as cache, redis, RPC, external API
-    # calls, etc.
-    class CustomTimerStruct < TimerStruct
-      def initialize(type, duration_ms, page, parent)
-        @parent = parent
-        @page = page
-        @type = type
-
-        super("Type" => type,
-              "StartMilliseconds" => ((Time.now.to_f * 1000).to_i - page['Started']) - duration_ms,
-              "DurationMilliseconds" => duration_ms,
-              "ParentTimingId" => nil)
-      end
-    end
-
-  end
-end

data/Ruby/lib/mini_profiler/gc_profiler.rb

@@ -1,107 +0,0 @@
-class Rack::MiniProfiler::GCProfiler
-  
-  def object_space_stats
-    stats = {}
-    ids = Set.new
-    i=0
-    ObjectSpace.each_object { |o|
-      begin
-        i = stats[o.class] || 0
-        i += 1
-        stats[o.class] = i
-        ids << o.object_id if Integer === o.object_id 
-      rescue NoMethodError
-        # Redis::Future undefines .class and .object_id super weird
-      end
-    }
-    {:stats => stats, :ids => ids}
-  end
-
-  def diff_object_stats(before,after)
-    diff = {}
-    after.each do |k,v|
-      diff[k] = v - (before[k] || 0)
-    end
-    before.each do |k,v|
-      diff[k] = 0 - v unless after[k]
-    end
-
-    diff
-  end
-
-  def analyze_strings(ids_before,ids_after)
-    result = {}
-    ids_after.each do |id|
-      obj = ObjectSpace._id2ref(id)
-      if String === obj && !ids_before.include?(obj.object_id) 
-        result[obj] ||= 0 
-        result[obj] += 1
-      end
-    end
-    result
-  end
-
-  def profile_gc_time(app,env)
-    body = []
-
-    begin
-      GC::Profiler.clear
-      GC::Profiler.enable
-      b = app.call(env)[2]
-      b.close if b.respond_to? :close
-      body << "GC Profiler ran during this request, if it fired you will see the cost below:\n\n"
-      body << GC::Profiler.result
-    ensure
-      GC.enable
-      GC::Profiler.disable
-    end
-
-    return [200, {'Content-Type' => 'text/plain'}, body]
-  end
-
-  def profile_gc(app,env)
-    
-    body = [];
-
-    stat_before,stat_after,diff,string_analysis = nil
-    begin
-      GC.disable
-      stat_before = object_space_stats
-      b = app.call(env)[2]
-      b.close if b.respond_to? :close
-      stat_after = object_space_stats
-      
-      diff = diff_object_stats(stat_before[:stats],stat_after[:stats])
-      string_analysis = analyze_strings(stat_before[:ids], stat_after[:ids])
-    ensure
-      GC.enable
-    end
-
-
-    body << "
-ObjectSpace delta caused by request:
---------------------------------------------\n"
-    diff.to_a.reject{|k,v| v == 0}.sort{|x,y| y[1] <=> x[1]}.each do |k,v|
-      body << "#{k} : #{v}\n" if v != 0
-    end
-
-    body << "\n
-ObjectSpace stats:
------------------\n"
-
-    stat_after[:stats].to_a.sort{|x,y| y[1] <=> x[1]}.each do |k,v|
-      body << "#{k} : #{v}\n" 
-    end
-
-
-    body << "\n
-String stats:
-------------\n"
-
-    string_analysis.to_a.sort{|x,y| y[1] <=> x[1] }.take(1000).each do |string,count|
-      body << "#{count} : #{string}\n"
-    end
-
-    return [200, {'Content-Type' => 'text/plain'}, body]
-  end
-end

data/Ruby/lib/mini_profiler/gc_profiler_ruby_head.rb

@@ -1,40 +0,0 @@
-require 'objspace'
-
-class Rack::MiniProfiler::GCProfilerRubyHead
-  def profile_rack(app,env)
-  end
-
-  def profile(&block)
-    GC.start
-    GC.disable
-
-    items = []
-    objs = []
-
-    ObjectSpace.trace_object_allocations do
-      block.call
-
-      ObjectSpace.each_object do |o|
-        objs << o
-      end
-
-      objs.each do |o|
-        g = ObjectSpace.allocation_generation(o)
-        if g
-          l = ObjectSpace.allocation_sourceline(o)
-          f = ObjectSpace.allocation_sourcefile(o)
-          c = ObjectSpace.allocation_class_path(o)
-          m = ObjectSpace.allocation_method_id(o)
-          items << "Allocated #{c} in #{m} #{f}:#{l}"
-        end
-      end
-    end
-
-    items.group_by{|x| x}.sort{|a,b| b[1].length <=> a[1].length}.each do |row, group|
-      puts "#{row} x #{group.length}"
-    end
-
-    GC.enable
-    profile_allocations(name, &block)
-  end
-end

data/Ruby/lib/mini_profiler/page_timer_struct.rb

@@ -1,58 +0,0 @@
-require 'mini_profiler/timer_struct'
-
-module Rack
-  class MiniProfiler
-
-    # PageTimerStruct
-    #   Root: RequestTimer
-    #     :has_many RequestTimer children
-    #     :has_many SqlTimer children
-    #     :has_many CustomTimer children
-    class PageTimerStruct < TimerStruct
-      def initialize(env)
-        super("Id" => MiniProfiler.generate_id,
-              "Name" => env['PATH_INFO'],
-              "Started" => (Time.now.to_f * 1000).to_i,
-              "MachineName" => env['SERVER_NAME'],
-              "Level" => 0,
-              "User" => "unknown user",
-              "HasUserViewed" => false,
-              "ClientTimings" => nil,
-              "DurationMilliseconds" => 0,
-              "HasTrivialTimings" => true,
-              "HasAllTrivialTimigs" => false,
-              "TrivialDurationThresholdMilliseconds" => 2,
-              "Head" => nil,
-              "DurationMillisecondsInSql" => 0,
-              "HasSqlTimings" => true,
-              "HasDuplicateSqlTimings" => false,
-              "ExecutedReaders" => 0,
-              "ExecutedScalars" => 0,
-              "ExecutedNonQueries" => 0,
-              "CustomTimingNames" => [],
-              "CustomTimingStats" => {}
-             )
-        name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
-        self['Root'] = RequestTimerStruct.createRoot(name, self)
-      end
-
-      def duration_ms
-        @attributes['Root']['DurationMilliseconds']
-      end
-
-      def root
-        @attributes['Root']
-      end
-
-      def to_json(*a)
-        attribs = @attributes.merge(
-          "Started" => '/Date(%d)/' % @attributes['Started'],
-          "DurationMilliseconds" => @attributes['Root']['DurationMilliseconds'],
-          "CustomTimingNames" => @attributes['CustomTimingStats'].keys.sort
-        )
-        ::JSON.generate(attribs, :max_nesting => 100)
-      end
-    end
-
-  end
-end

data/Ruby/lib/mini_profiler/request_timer_struct.rb

@@ -1,115 +0,0 @@
-require 'mini_profiler/timer_struct'
-
-module Rack
-  class MiniProfiler
-
-    class RequestTimerStruct < TimerStruct
-
-      def self.createRoot(name, page)
-        rt = RequestTimerStruct.new(name, page, nil)
-        rt["IsRoot"]= true
-        rt
-      end
-
-      attr_accessor :children_duration
-
-      def initialize(name, page, parent)
-        super("Id" => MiniProfiler.generate_id,
-              "Name" => name,
-              "DurationMilliseconds" => 0,
-              "DurationWithoutChildrenMilliseconds"=> 0,
-              "StartMilliseconds" => (Time.now.to_f * 1000).to_i - page['Started'],
-              "ParentTimingId" => nil,
-              "Children" => [],
-              "HasChildren"=> false,
-              "KeyValues" => nil,
-              "HasSqlTimings"=> false,
-              "HasDuplicateSqlTimings"=> false,
-              "TrivialDurationThresholdMilliseconds" => 2,
-              "SqlTimings" => [],
-              "SqlTimingsDurationMilliseconds"=> 0,
-              "IsTrivial"=> false,
-              "IsRoot"=> false,
-              "Depth"=> parent ? parent.depth + 1 : 0,
-              "ExecutedReaders"=> 0,
-              "ExecutedScalars"=> 0,
-              "ExecutedNonQueries"=> 0,
-              "CustomTimingStats" => {},
-              "CustomTimings" => {})
-        @children_duration = 0
-        @start = Time.now
-        @parent = parent
-        @page = page
-      end
-
-      def duration_ms
-        self['DurationMilliseconds']
-      end
-
-      def start_ms
-        self['StartMilliseconds']
-      end
-
-      def start
-        @start
-      end
-
-      def depth
-        self['Depth']
-      end
-
-      def children
-        self['Children']
-      end
-
-      def add_child(name)
-        request_timer =  RequestTimerStruct.new(name, @page, self)
-        self['Children'].push(request_timer)
-        self['HasChildren'] = true
-        request_timer['ParentTimingId'] = self['Id']
-        request_timer['Depth'] = self['Depth'] + 1
-        request_timer
-      end
-
-      def add_sql(query, elapsed_ms, page, skip_backtrace = false, full_backtrace = false)
-        timer = SqlTimerStruct.new(query, elapsed_ms, page, self , skip_backtrace, full_backtrace)
-        timer['ParentTimingId'] = self['Id']
-        self['SqlTimings'].push(timer)
-        self['HasSqlTimings'] = true
-        self['SqlTimingsDurationMilliseconds'] += elapsed_ms
-        page['DurationMillisecondsInSql'] += elapsed_ms
-        timer
-      end
-
-      def add_custom(type, elapsed_ms, page)
-        timer = CustomTimerStruct.new(type, elapsed_ms, page, self)
-        timer['ParentTimingId'] = self['Id']
-        self['CustomTimings'][type] ||= []
-        self['CustomTimings'][type].push(timer)
-
-        self['CustomTimingStats'][type] ||= {"Count" => 0, "Duration" => 0.0}
-        self['CustomTimingStats'][type]['Count'] += 1
-        self['CustomTimingStats'][type]['Duration'] += elapsed_ms
-
-        page['CustomTimingStats'][type] ||= {"Count" => 0, "Duration" => 0.0}
-        page['CustomTimingStats'][type]['Count'] += 1
-        page['CustomTimingStats'][type]['Duration'] += elapsed_ms
-
-        timer
-      end
-
-      def record_time(milliseconds = nil)
-        milliseconds ||= (Time.now - @start) * 1000
-        self['DurationMilliseconds'] = milliseconds
-        self['IsTrivial'] = true if milliseconds < self["TrivialDurationThresholdMilliseconds"]
-        self['DurationWithoutChildrenMilliseconds'] = milliseconds - @children_duration
-
-        if @parent
-          @parent.children_duration += milliseconds
-        end
-
-      end
-    end
-  end
-
-end

data/Ruby/lib/mini_profiler/sql_timer_struct.rb

@@ -1,58 +0,0 @@
-require 'mini_profiler/timer_struct'
-
-module Rack
-  class MiniProfiler
-
-    # Timing system for a SQL query
-    class SqlTimerStruct < TimerStruct
-      def initialize(query, duration_ms, page, parent, skip_backtrace = false, full_backtrace = false)
-
-        stack_trace = nil 
-        unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
-          # Allow us to filter the stack trace
-          stack_trace = ""
-           # Clean up the stack trace if there are options to do so
-          Kernel.caller.each do |ln|
-            ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove and !full_backtrace
-            if    full_backtrace or 
-                  (
-                    (
-                      Rack::MiniProfiler.config.backtrace_includes.nil? or 
-                      Rack::MiniProfiler.config.backtrace_includes.all?{|regex| ln =~ regex}
-                    ) and
-                    (
-                      Rack::MiniProfiler.config.backtrace_ignores.nil? or 
-                      Rack::MiniProfiler.config.backtrace_ignores.all?{|regex| !(ln =~ regex)}
-                    )
-                  ) 
-              stack_trace << ln << "\n" 
-            end
-          end
-        end
-
-        @parent = parent
-        @page = page
-
-        super("ExecuteType" => 3, # TODO
-              "FormattedCommandString" => query,
-              "StackTraceSnippet" => stack_trace, 
-              "StartMilliseconds" => ((Time.now.to_f * 1000).to_i - page['Started']) - duration_ms,
-              "DurationMilliseconds" => duration_ms,
-              "FirstFetchDurationMilliseconds" => duration_ms,
-              "Parameters" => nil,
-              "ParentTimingId" => nil,
-              "IsDuplicate" => false)
-      end
-
-      def report_reader_duration(elapsed_ms)
-        return if @reported
-        @reported = true
-        self["DurationMilliseconds"] += elapsed_ms
-        @parent["SqlTimingsDurationMilliseconds"] += elapsed_ms
-        @page["DurationMillisecondsInSql"] += elapsed_ms
-      end
-
-    end
-
-  end
-end