rack-mini-profiler 0.10.6 → 2.3.0

data/lib/mini_profiler/storage/redis_store.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'digest'
+
 module Rack
   class MiniProfiler
     class RedisStore < AbstractStore
@@ -8,7 +12,7 @@ module Rack
 
       def initialize(args = nil)
         @args               = args || {}
-        @prefix             = @args.delete(:prefix)     || 'MPRedisStore'
+        @prefix             = @args.delete(:prefix) || 'MPRedisStore'
         @redis_connection   = @args.delete(:connection)
         @expires_in_seconds = @args.delete(:expires_in) || EXPIRES_IN_SECONDS
       end
@@ -31,8 +35,8 @@ module Rack
 
       def set_unviewed(user, id)
         key = user_key(user)
-        if redis.exists(prefixed_id(id))
-          expire_at = Time.now.to_i + redis.ttl(prefixed_id(id))
+        if redis.call([:exists, prefixed_id(id)]) == 1
+          expire_at = Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i + redis.ttl(prefixed_id(id))
           redis.zadd(key, expire_at, id)
         end
         redis.expire(key, @expires_in_seconds)
@@ -42,8 +46,8 @@ module Rack
         key = user_key(user)
         redis.del(key)
         ids.each do |id|
-          if redis.exists(prefixed_id(id))
-            expire_at = Time.now.to_i + redis.ttl(prefixed_id(id))
+          if redis.call([:exists, prefixed_id(id)]) == 1
+            expire_at = Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i + redis.ttl(prefixed_id(id))
             redis.zadd(key, expire_at, id)
           end
         end
@@ -57,7 +61,7 @@ module Rack
       # Remove expired ids from the unviewed sorted set and return the remaining ids
       def get_unviewed_ids(user)
         key = user_key(user)
-        redis.zremrangebyscore(key, '-inf', Time.now.to_i)
+        redis.zremrangebyscore(key, '-inf', Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i)
         redis.zrevrangebyscore(key, '+inf', '-inf')
       end
 
@@ -101,11 +105,111 @@ unviewed_ids: #{get_unviewed_ids(user)}
         end
 
         redis.setex "#{@prefix}-key1", timeout, key1
-        redis.setex "#{@prefix}-key1_old", timeout*2, key1
+        redis.setex "#{@prefix}-key1_old", timeout * 2, key1
 
         [key1, key2].compact
       end
 
+      COUNTER_LUA = <<~LUA
+        if redis.call("INCR", KEYS[1]) % ARGV[1] == 0 then
+          redis.call("DEL", KEYS[1])
+          return 1
+        else
+          return 0
+        end
+      LUA
+
+      COUNTER_LUA_SHA = Digest::SHA1.hexdigest(COUNTER_LUA)
+
+      def should_take_snapshot?(period)
+        1 == cached_redis_eval(
+          COUNTER_LUA,
+          COUNTER_LUA_SHA,
+          reraise: false,
+          keys: [snapshot_counter_key()],
+          argv: [period]
+        )
+      end
+
+      def push_snapshot(page_struct, config)
+        zset_key = snapshot_zset_key()
+        hash_key = snapshot_hash_key()
+
+        id = page_struct[:id]
+        score = page_struct.duration_ms
+        limit = config.snapshots_limit
+        bytes = Marshal.dump(page_struct)
+
+        lua = <<~LUA
+          local zset_key = KEYS[1]
+          local hash_key = KEYS[2]
+          local id = ARGV[1]
+          local score = tonumber(ARGV[2])
+          local bytes = ARGV[3]
+          local limit = tonumber(ARGV[4])
+          redis.call("ZADD", zset_key, score, id)
+          redis.call("HSET", hash_key, id, bytes)
+          if redis.call("ZCARD", zset_key) > limit then
+            local lowest_snapshot_id = redis.call("ZRANGE", zset_key, 0, 0)[1]
+            redis.call("ZREM", zset_key, lowest_snapshot_id)
+            redis.call("HDEL", hash_key, lowest_snapshot_id)
+          end
+        LUA
+        redis.eval(
+          lua,
+          keys: [zset_key, hash_key],
+          argv: [id, score, bytes, limit]
+        )
+      end
+
+      def fetch_snapshots(batch_size: 200, &blk)
+        zset_key = snapshot_zset_key()
+        hash_key = snapshot_hash_key()
+        iteration = 0
+        corrupt_snapshots = []
+        while true
+          ids = redis.zrange(
+            zset_key,
+            batch_size * iteration,
+            batch_size * iteration + batch_size - 1
+          )
+          break if ids.size == 0
+          batch = redis.mapped_hmget(hash_key, *ids).to_a
+          batch.map! do |id, bytes|
+            begin
+              Marshal.load(bytes)
+            rescue
+              corrupt_snapshots << id
+              nil
+            end
+          end
+          batch.compact!
+          blk.call(batch) if batch.size != 0
+          break if ids.size < batch_size
+          iteration += 1
+        end
+        if corrupt_snapshots.size > 0
+          redis.pipelined do
+            redis.zrem(zset_key, corrupt_snapshots)
+            redis.hdel(hash_key, corrupt_snapshots)
+          end
+        end
+      end
+
+      def load_snapshot(id)
+        hash_key = snapshot_hash_key()
+        bytes = redis.hget(hash_key, id)
+        begin
+          Marshal.load(bytes)
+        rescue
+          redis.pipelined do
+            redis.zrem(snapshot_zset_key(), id)
+            redis.hdel(hash_key, id)
+          end
+          nil
+        end
+      end
+
       private
 
       def user_key(user)
@@ -123,6 +227,38 @@ unviewed_ids: #{get_unviewed_ids(user)}
         end
       end
 
+      def snapshot_counter_key
+        @snapshot_counter_key ||= "#{@prefix}-mini-profiler-snapshots-counter"
+      end
+
+      def snapshot_zset_key
+        @snapshot_zset_key ||= "#{@prefix}-mini-profiler-snapshots-zset"
+      end
+
+      def snapshot_hash_key
+        @snapshot_hash_key ||= "#{@prefix}-mini-profiler-snapshots-hash"
+      end
+
+      def cached_redis_eval(script, script_sha, reraise: true, argv: [], keys: [])
+        begin
+          redis.evalsha(script_sha, argv: argv, keys: keys)
+        rescue ::Redis::CommandError => e
+          if e.message.start_with?('NOSCRIPT')
+            redis.eval(script, argv: argv, keys: keys)
+          else
+            raise e if reraise
+          end
+        end
+      end
+
+      # only used in tests
+      def wipe_snapshots_data
+        redis.pipelined do
+          redis.del(snapshot_counter_key())
+          redis.del(snapshot_zset_key())
+          redis.del(snapshot_hash_key())
+        end
+      end
     end
   end
 end

data/lib/mini_profiler/timer_struct/base.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module TimerStruct
       # A base class for timing structures
       class Base
 
-        def initialize(attrs={})
+        def initialize(attrs = {})
           @attributes = attrs
         end
 
@@ -24,7 +26,7 @@ module Rack
         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 )
+          ::JSON.generate(@attributes, max_nesting: 100)
         end
 
         def as_json(options = nil)

data/lib/mini_profiler/timer_struct/client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module TimerStruct
@@ -15,15 +17,14 @@ module Rack
 
         # used by Railtie to instrument asset_tag for JS / CSS
         def self.instrument(name, orig)
-          probe = "<script>mPt.probe('#{name}')</script>"
+          probe = "<script>mPt.probe('#{name}')</script>".dup
           wrapped = probe
           wrapped << orig
           wrapped << probe
           wrapped
         end
 
-
-        def initialize(env={})
+        def initialize(env = {})
           super
         end
 
@@ -60,21 +61,21 @@ module Rack
           end
 
           translated.each do |name, data|
-            h = {"Name" => name, "Start" => data[:start].to_i - baseTime}
+            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|
+          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
+            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|
+          clientTimes.keys.find_all { |k| !(k =~ /(End|Start)$/) }.each do |k|
             timings.push("Name" => k, "Start" => clientTimes[k].to_i - baseTime, "Duration" => -1)
           end
 

data/lib/mini_profiler/timer_struct/custom.rb

@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module TimerStruct
       # Timing system for a custom timers such as cache, redis, RPC, external API
       # calls, etc.
       class Custom < TimerStruct::Base
+        attr_accessor :parent
         def initialize(type, duration_ms, page, parent)
           @parent      = parent
           @page        = page
           @type        = type
-          start_millis = ((Time.now.to_f * 1000).to_i - page[:started]) - duration_ms
+          start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
           super(
-            :type                  => type,
-            :start_milliseconds    => start_millis,
-            :duration_milliseconds => duration_ms,
-            :parent_timing_id      => nil
+            type: type,
+            start_milliseconds: start_millis,
+            duration_milliseconds: duration_ms,
+            parent_timing_id: nil
           )
         end
       end

data/lib/mini_profiler/timer_struct/page.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module TimerStruct
@@ -8,34 +10,87 @@ module Rack
       #     :has_many TimerStruct::Sql children
       #     :has_many TimerStruct::Custom children
       class Page < TimerStruct::Base
+        class << self
+          def from_hash(hash)
+            hash = symbolize_hash(hash)
+            if hash.key?(:custom_timing_names)
+              hash[:custom_timing_names] = []
+            end
+            hash.delete(:started_formatted)
+            if hash.key?(:duration_milliseconds)
+              hash[:duration_milliseconds] = 0
+            end
+            page = self.allocate
+            page.instance_variable_set(:@attributes, hash)
+            page
+          end
+
+          private
+
+          def symbolize_hash(hash)
+            new_hash = {}
+            hash.each do |k, v|
+              sym_k = String === k ? k.to_sym : k
+              if Hash === v
+                new_hash[sym_k] = symbolize_hash(v)
+              elsif Array === v
+                new_hash[sym_k] = symbolize_array(v)
+              else
+                new_hash[sym_k] = v
+              end
+            end
+            new_hash
+          end
+
+          def symbolize_array(array)
+            array.map do |item|
+              if Array === item
+                symbolize_array(item)
+              elsif Hash === item
+                symbolize_hash(item)
+              else
+                item
+              end
+            end
+          end
+        end
+
+        attr_reader :attributes
+
         def initialize(env)
           timer_id     = MiniProfiler.generate_id
           page_name    = env['PATH_INFO']
           started_at   = (Time.now.to_f * 1000).to_i
+          started      = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i
           machine_name = env['SERVER_NAME']
           super(
-            :id                                      => timer_id,
-            :name                                    => page_name,
-            :started                                 => started_at,
-            :machine_name                            => machine_name,
-            :level                                   => 0,
-            :user                                    => "unknown user",
-            :has_user_viewed                         => false,
-            :client_timings                          => nil,
-            :duration_milliseconds                   => 0,
-            :has_trivial_timings                     => true,
-            :has_all_trivial_timings                 => false,
-            :trivial_duration_threshold_milliseconds => 2,
-            :head                                    => nil,
-            :duration_milliseconds_in_sql            => 0,
-            :has_sql_timings                         => true,
-            :has_duplicate_sql_timings               => false,
-            :executed_readers                        => 0,
-            :executed_scalars                        => 0,
-            :executed_non_queries                    => 0,
-            :custom_timing_names                     => [],
-            :custom_timing_stats                     => {}
+            id: timer_id,
+            name: page_name,
+            started: started,
+            started_at: started_at,
+            machine_name: machine_name,
+            level: 0,
+            user: "unknown user",
+            has_user_viewed: false,
+            client_timings: nil,
+            duration_milliseconds: 0,
+            has_trivial_timings: true,
+            has_all_trivial_timings: false,
+            trivial_duration_threshold_milliseconds: 2,
+            head: nil,
+            sql_count: 0,
+            duration_milliseconds_in_sql: 0,
+            has_sql_timings: true,
+            has_duplicate_sql_timings: false,
+            executed_readers: 0,
+            executed_scalars: 0,
+            executed_non_queries: 0,
+            custom_timing_names: [],
+            custom_timing_stats: {},
+            custom_fields: {}
           )
+          self[:request_method] = env['REQUEST_METHOD']
+          self[:request_path] = env['PATH_INFO']
           name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
           self[:root] = TimerStruct::Request.createRoot(name, self)
         end
@@ -66,9 +121,9 @@ module Rack
 
         def extra_json
           {
-            :started               => '/Date(%d)/' % @attributes[:started],
-            :duration_milliseconds => @attributes[:root][:duration_milliseconds],
-            :custom_timing_names   => @attributes[:custom_timing_stats].keys.sort
+            started_formatted: '/Date(%d)/' % @attributes[:started_at],
+            duration_milliseconds: @attributes[:root][:duration_milliseconds],
+            custom_timing_names: @attributes[:custom_timing_stats].keys.sort
           }
         end
       end

data/lib/mini_profiler/timer_struct/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class MiniProfiler
     module TimerStruct
@@ -9,37 +11,37 @@ module Rack
           end
         end
 
-        attr_accessor :children_duration
+        attr_accessor :children_duration, :start, :parent
 
         def initialize(name, page, parent)
-          start_millis = (Time.now.to_f * 1000).to_i - page[:started]
+          start_millis = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]
           depth        = parent ? parent.depth + 1 : 0
           super(
-            :id                                      => MiniProfiler.generate_id,
-            :name                                    => name,
-            :duration_milliseconds                   => 0,
-            :duration_without_children_milliseconds  => 0,
-            :start_milliseconds                      => start_millis,
-            :parent_timing_id                        => nil,
-            :children                                => [],
-            :has_children                            => false,
-            :key_values                              => nil,
-            :has_sql_timings                         => false,
-            :has_duplicate_sql_timings               => false,
-            :trivial_duration_threshold_milliseconds => 2,
-            :sql_timings                             => [],
-            :sql_timings_duration_milliseconds       => 0,
-            :is_trivial                              => false,
-            :is_root                                 => false,
-            :depth                                   => depth,
-            :executed_readers                        => 0,
-            :executed_scalars                        => 0,
-            :executed_non_queries                    => 0,
-            :custom_timing_stats                     => {},
-            :custom_timings                          => {}
+            id: MiniProfiler.generate_id,
+            name: name,
+            duration_milliseconds: 0,
+            duration_without_children_milliseconds: 0,
+            start_milliseconds: start_millis,
+            parent_timing_id: nil,
+            children: [],
+            has_children: false,
+            key_values: nil,
+            has_sql_timings: false,
+            has_duplicate_sql_timings: false,
+            trivial_duration_threshold_milliseconds: 2,
+            sql_timings: [],
+            sql_timings_duration_milliseconds: 0,
+            is_trivial: false,
+            is_root: false,
+            depth: depth,
+            executed_readers: 0,
+            executed_scalars: 0,
+            executed_non_queries: 0,
+            custom_timing_stats: {},
+            custom_timings: {}
           )
           @children_duration = 0
-          @start             = Time.now
+          @start             = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           @parent            = parent
           @page              = page
         end
@@ -60,10 +62,6 @@ module Rack
           self[:start_milliseconds]
         end
 
-        def start
-          @start
-        end
-
         def depth
           self[:depth]
         end
@@ -89,6 +87,20 @@ module Rack
           end
         end
 
+        def move_child(child, destination)
+          if index = self[:children].index(child)
+            self[:children].slice!(index)
+            self[:has_children] = self[:children].size > 0
+
+            destination[:children].push(child)
+            destination[:has_children] = true
+
+            child[:parent_timing_id] = destination[:id]
+            child.parent = destination
+            child.adjust_depth
+          end
+        end
+
         def add_sql(query, elapsed_ms, page, params = nil, skip_backtrace = false, full_backtrace = false)
           TimerStruct::Sql.new(query, elapsed_ms, page, self, params, skip_backtrace, full_backtrace).tap do |timer|
             self[:sql_timings].push(timer)
@@ -96,6 +108,20 @@ module Rack
             self[:has_sql_timings]   = true
             self[:sql_timings_duration_milliseconds] += elapsed_ms
             page[:duration_milliseconds_in_sql]      += elapsed_ms
+            page[:sql_count] += 1
+          end
+        end
+
+        def move_sql(sql, destination)
+          if index = self[:sql_timings].index(sql)
+            self[:sql_timings].slice!(index)
+            self[:has_sql_timings] = self[:sql_timings].size > 0
+            self[:sql_timings_duration_milliseconds] -= sql[:duration_milliseconds]
+            destination[:sql_timings].push(sql)
+            destination[:has_sql_timings] = true
+            destination[:sql_timings_duration_milliseconds] += sql[:duration_milliseconds]
+            sql[:parent_timing_id] = destination[:id]
+            sql.parent = destination
           end
         end
 
@@ -106,28 +132,47 @@ module Rack
             self[:custom_timings][type] ||= []
             self[:custom_timings][type].push(timer)
 
-            self[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            self[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
             self[:custom_timing_stats][type][:count]    += 1
             self[:custom_timing_stats][type][:duration] += elapsed_ms
 
-            page[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            page[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
             page[:custom_timing_stats][type][:count]    += 1
             page[:custom_timing_stats][type][:duration] += elapsed_ms
           end
         end
 
+        def move_custom(type, custom, destination)
+          if index = self[:custom_timings][type]&.index(custom)
+            custom[:parent_timing_id] = destination[:id]
+            custom.parent = destination
+            self[:custom_timings][type].slice!(index)
+            if self[:custom_timings][type].size == 0
+              self[:custom_timings].delete(type)
+              self[:custom_timing_stats].delete(type)
+            else
+              self[:custom_timing_stats][type][:count] -= 1
+              self[:custom_timing_stats][type][:duration] -= custom[:duration_milliseconds]
+            end
+            destination[:custom_timings][type] ||= []
+            destination[:custom_timings][type].push(custom)
+            destination[:custom_timing_stats][type] ||= { count: 0, duration: 0.0 }
+            destination[:custom_timing_stats][type][:count] += 1
+            destination[:custom_timing_stats][type][:duration] += custom[:duration_milliseconds]
+          end
+        end
+
         def record_time(milliseconds = nil)
-          milliseconds ||= (Time.now - @start) * 1000
+          milliseconds ||= (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start) * 1000
           self[:duration_milliseconds]                  = milliseconds
           self[:is_trivial]                             = true if milliseconds < self[:trivial_duration_threshold_milliseconds]
-          self[:duration_without_children_milliseconds] = milliseconds - @children_duration
-
-          if @parent
-            @parent.children_duration += milliseconds
-          end
-
+          self[:duration_without_children_milliseconds] = milliseconds - self[:children].sum(&:duration_ms)
         end
 
+        def adjust_depth
+          self[:depth] = self.parent ? self.parent[:depth] + 1 : 0
+          self[:children].each(&:adjust_depth)
+        end
       end
     end
   end