rack-mini-profiler 0.9.2 → 0.9.3

data/lib/rack-mini-profiler.rb

@@ -1,4 +1,32 @@
+require 'json'
+require 'timeout'
+require 'thread'
+
+require 'mini_profiler/version'
+require 'mini_profiler/asset_version'
+
+require 'mini_profiler/timer_struct/base'
+require 'mini_profiler/timer_struct/page'
+require 'mini_profiler/timer_struct/sql'
+require 'mini_profiler/timer_struct/custom'
+require 'mini_profiler/timer_struct/client'
+require 'mini_profiler/timer_struct/request'
+
+require 'mini_profiler/storage/abstract_store'
+require 'mini_profiler/storage/memcache_store'
+require 'mini_profiler/storage/memory_store'
+require 'mini_profiler/storage/redis_store'
+require 'mini_profiler/storage/file_store'
+
+require 'mini_profiler/config'
+require 'mini_profiler/profiling_methods'
+require 'mini_profiler/context'
+require 'mini_profiler/client_settings'
+require 'mini_profiler/gc_profiler'
 require 'mini_profiler/profiler'
+# TODO
+# require 'mini_profiler/gc_profiler_ruby_head' if Gem::Version.new('2.1.0') <= Gem::Version.new(RUBY_VERSION)
+
 require 'patches/sql_patches'
 require 'patches/net_patches'
 

data/rack-mini-profiler.gemspec

@@ -1,8 +1,12 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mini_profiler/version'
+
 Gem::Specification.new do |s|
   s.name = "rack-mini-profiler"
-  s.version = "0.9.2"
+  s.version = Rack::MiniProfiler::VERSION
   s.summary = "Profiles loading speed for rack applications."
-  s.authors = ["Sam Saffron", "Robin Ward","Aleks Totic"]
+  s.authors = ["Sam Saffron","Robin Ward","Aleks Totic"]
   s.description = "Profiling toolkit for Rack applications with Rails integration. Client Side profiling, DB profiling and Server profiling."
   s.email = "sam.saffron@gmail.com"
   s.homepage = "http://miniprofiler.com"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors:
 - Sam Saffron
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2015-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -202,25 +202,33 @@ files:
 - lib/html/list.tmpl
 - lib/html/profile_handler.js
 - lib/html/share.html
+- lib/mini_profiler/asset_version.rb
 - lib/mini_profiler/client_settings.rb
-- lib/mini_profiler/client_timer_struct.rb
 - lib/mini_profiler/config.rb
 - lib/mini_profiler/context.rb
-- lib/mini_profiler/custom_timer_struct.rb
 - lib/mini_profiler/gc_profiler.rb
-- lib/mini_profiler/page_timer_struct.rb
 - lib/mini_profiler/profiler.rb
 - lib/mini_profiler/profiling_methods.rb
-- lib/mini_profiler/request_timer_struct.rb
-- lib/mini_profiler/sql_timer_struct.rb
 - lib/mini_profiler/storage/abstract_store.rb
 - lib/mini_profiler/storage/file_store.rb
 - lib/mini_profiler/storage/memcache_store.rb
 - lib/mini_profiler/storage/memory_store.rb
 - lib/mini_profiler/storage/redis_store.rb
-- lib/mini_profiler/timer_struct.rb
+- lib/mini_profiler/timer_struct/base.rb
+- lib/mini_profiler/timer_struct/client.rb
+- lib/mini_profiler/timer_struct/custom.rb
+- lib/mini_profiler/timer_struct/page.rb
+- lib/mini_profiler/timer_struct/request.rb
+- lib/mini_profiler/timer_struct/sql.rb
 - lib/mini_profiler/version.rb
 - lib/mini_profiler_rails/railtie.rb
+- lib/patches/db/activerecord.rb
+- lib/patches/db/moped.rb
+- lib/patches/db/mysql2.rb
+- lib/patches/db/pg.rb
+- lib/patches/db/plucky.rb
+- lib/patches/db/rsolr.rb
+- lib/patches/db/sequel.rb
 - lib/patches/net_patches.rb
 - lib/patches/sql_patches.rb
 - lib/rack-mini-profiler.rb

data/lib/mini_profiler/client_timer_struct.rb

@@ -1,78 +0,0 @@
-require 'mini_profiler/timer_struct'
-
-module Rack
-  class MiniProfiler
-
-    # This class holds the client timings
-    class ClientTimerStruct < TimerStruct
-
-      def self.init_instrumentation
-        "<script type=\"text/javascript\">mPt=function(){var t=[];return{t:t,probe:function(n){t.push({d:new Date(),n:n})}}}()</script>"
-      end
-      
-      def self.instrument(name,orig)
-        probe = "<script>mPt.probe('#{name}')</script>"
-        wrapped = probe
-        wrapped << orig 
-        wrapped << probe 
-        wrapped
-      end
-
-
-      def initialize(env={})
-        super
-      end
-
-      def self.init_from_form_data(env, page_struct)
-        timings = []
-        clientTimes, clientPerf, baseTime = nil 
-        form = env['rack.request.form_hash']
-
-        clientPerf = form['clientPerformance'] if form 
-        clientTimes = clientPerf['timing'] if clientPerf 
-
-        baseTime = clientTimes['navigationStart'].to_i if clientTimes
-        return unless clientTimes && baseTime 
-
-        probes = form['clientProbes']
-        translated = {}
-        if probes && !["null", ""].include?(probes)
-          probes.each do |id, val|
-            name = val["n"]
-            translated[name] ||= {} 
-            if translated[name][:start]
-              translated[name][:finish] = val["d"]
-            else 
-              translated[name][:start] = val["d"]
-            end
-          end
-        end
-
-        translated.each do |name, data|
-          h = {"Name" => name, "Start" => data[:start].to_i - baseTime}
-          h["Duration"] = data[:finish].to_i - data[:start].to_i if data[:finish]
-          timings.push(h)
-        end
-
-        clientTimes.keys.find_all{|k| k =~ /Start$/ }.each do |k|
-          start = clientTimes[k].to_i - baseTime 
-          finish = clientTimes[k.sub(/Start$/, "End")].to_i - baseTime
-          duration = 0 
-          duration = finish - start if finish > start 
-          name = k.sub(/Start$/, "").split(/(?=[A-Z])/).map{|s| s.capitalize}.join(' ')
-          timings.push({"Name" => name, "Start" => start, "Duration" => duration}) if start >= 0
-        end
-
-        clientTimes.keys.find_all{|k| !(k =~ /(End|Start)$/)}.each do |k|
-          timings.push("Name" => k, "Start" => clientTimes[k].to_i - baseTime, "Duration" => -1)
-        end
-
-        rval = self.new
-        rval['RedirectCount'] = env['rack.request.form_hash']['clientPerformance']['navigation']['redirectCount']
-        rval['Timings'] = timings
-        rval
-      end
-    end
-
-  end
-end

data/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/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/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/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

data/lib/mini_profiler/timer_struct.rb

@@ -1,33 +0,0 @@
-module Rack
-  class MiniProfiler
-
-    # A base class for timing structures
-    class TimerStruct
-
-      def initialize(attrs={})
-        @attributes = attrs
-      end
-
-      def attributes
-        @attributes ||= {}
-      end
-
-      def [](name)
-        attributes[name]
-      end
-
-      def []=(name, val)
-        attributes[name] = val
-        self
-      end
-
-      def to_json(*a)
-        # this does could take in an option hash, but the only interesting there is max_nesting.
-        #   if this becomes an option we could increase
-        ::JSON.generate( @attributes, :max_nesting => 100 )
-      end
-
-    end
-
-  end
-end