mini-sharp-hub 0.0.1

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    module TimerStruct
+
+      # This class holds the client timings
+      class Client < TimerStruct::Base
+
+        def self.init_instrumentation
+          %Q{
+            <script type="text/javascript">
+              mPt=function(){var t=[];return{t:t,probe:function(n){t.push({d:new Date(),n:n})}}}()
+            </script>
+          }
+        end
+
+        # used by Railtie to instrument asset_tag for JS / CSS
+        def self.instrument(name, orig)
+          probe = "<script>mPt.probe('#{name}')</script>".dup
+          wrapped = probe
+          wrapped << orig
+          wrapped << probe
+          wrapped
+        end
+
+        def initialize(env = {})
+          super
+        end
+
+        def redirect_count
+          self[:redirect_count]
+        end
+
+        def timings
+          self[:timings]
+        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
+
+          TimerStruct::Client.new.tap do |rval|
+            rval[:redirect_count] = env['rack.request.form_hash']['clientPerformance']['navigation']['redirect_count']
+            rval[:timings]        = timings
+          end
+        end
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct/custom.rb

@@ -0,0 +1,25 @@
+# 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 = ((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
+          )
+        end
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct/page.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    module TimerStruct
+
+      # TimerStruct::Page
+      #   Root: TimerStruct::Request
+      #     :has_many TimerStruct::Request children
+      #     :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
+          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(env),
+            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,
+            cached_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: {},
+            has_flamegraph: false,
+            flamegraph: nil
+          )
+          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']}#{page_name(env)}"
+          self[:root] = TimerStruct::Request.createRoot(name, self)
+        end
+
+        def name
+          @attributes[:name]
+        end
+
+        def page_name(env)
+          if env['QUERY_STRING'] && env['QUERY_STRING'] != ""
+            env['PATH_INFO'] + "?" + env['QUERY_STRING']
+          else
+            env['PATH_INFO']
+          end
+        end
+
+        def duration_ms
+          @attributes[:root][:duration_milliseconds]
+        end
+
+        def duration_ms_in_sql
+          @attributes[:duration_milliseconds_in_sql]
+        end
+
+        def root
+          @attributes[:root]
+        end
+
+        def attributes_to_serialize
+          @attributes.keys - [:flamegraph]
+        end
+
+        def to_json(*a)
+          ::JSON.generate(@attributes.slice(*attributes_to_serialize).merge(extra_json))
+        end
+
+        def as_json(options = nil)
+          super(options).slice(*attributes_to_serialize.map(&:to_s)).merge!(extra_json)
+        end
+
+        def extra_json
+          {
+            started_formatted: '/Date(%d)/' % @attributes[:started_at],
+            duration_milliseconds: @attributes[:root][:duration_milliseconds],
+            custom_timing_names: @attributes[:custom_timing_stats].keys.sort
+          }
+        end
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct/request.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      class Request < TimerStruct::Base
+
+        def self.createRoot(name, page)
+          TimerStruct::Request.new(name, page, nil).tap do |timer|
+            timer[:is_root] = true
+          end
+        end
+
+        attr_accessor :children_duration, :start, :parent
+
+        def initialize(name, page, parent)
+          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: {}
+          )
+          @children_duration = 0
+          @start             = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @parent            = parent
+          @page              = page
+        end
+
+        def name
+          @attributes[:name]
+        end
+
+        def duration_ms
+          self[:duration_milliseconds]
+        end
+
+        def duration_ms_in_sql
+          @attributes[:duration_milliseconds_in_sql]
+        end
+
+        def start_ms
+          self[:start_milliseconds]
+        end
+
+        def depth
+          self[:depth]
+        end
+
+        def children
+          self[:children]
+        end
+
+        def custom_timings
+          self[:custom_timings]
+        end
+
+        def sql_timings
+          self[:sql_timings]
+        end
+
+        def add_child(name)
+          TimerStruct::Request.new(name, @page, self).tap do |timer|
+            self[:children].push(timer)
+            self[:has_children]      = true
+            timer[:parent_timing_id] = self[:id]
+            timer[:depth]            = self[:depth] + 1
+          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, cached = false)
+          TimerStruct::Sql.new(query, elapsed_ms, page, self, params, skip_backtrace, full_backtrace, cached).tap do |timer|
+            self[:sql_timings].push(timer)
+            timer[:parent_timing_id] = self[:id]
+            self[:has_sql_timings]   = true
+            self[:sql_timings_duration_milliseconds] += elapsed_ms
+            page[:duration_milliseconds_in_sql]      += elapsed_ms
+            page[:sql_count] += 1
+            page[:cached_sql_count] += 1 if cached
+          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
+
+        # please call SqlTiming#report_reader_duration instead
+        def report_reader_duration(elapsed_ms, row_count = nil, class_name = nil)
+          last_time = self[:sql_timings]&.last
+          last_time&.report_reader_duration(elapsed_ms, row_count, class_name)
+        end
+
+        def add_custom(type, elapsed_ms, page)
+          TimerStruct::Custom.new(type, elapsed_ms, page, self).tap do |timer|
+            timer[:parent_timing_id] = self[:id]
+
+            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]    += 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]    += 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 ||= (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 - 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
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct/sql.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Rack
+  class MiniProfiler
+
+    # Timing system for a SQL query
+    module TimerStruct
+      class Sql < TimerStruct::Base
+        attr_accessor :parent
+
+        def initialize(query, duration_ms, page, parent, params = nil, skip_backtrace = false, full_backtrace = false, cached = false)
+
+          stack_trace = nil
+          unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
+            # Allow us to filter the stack trace
+            stack_trace = "".dup
+            # 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 && !full_backtrace
+              if    full_backtrace ||
+                    (
+                      (
+                        Rack::MiniProfiler.config.backtrace_includes.nil? ||
+                        Rack::MiniProfiler.config.backtrace_includes.any? { |regex| ln =~ regex }
+                      ) &&
+                      (
+                        Rack::MiniProfiler.config.backtrace_ignores.nil? ||
+                        Rack::MiniProfiler.config.backtrace_ignores.none? { |regex| ln =~ regex }
+                      )
+                    )
+                stack_trace << ln << "\n"
+              end
+            end
+          end
+
+          @parent      = parent
+          @page        = page
+          start_millis = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i - page[:started]) - duration_ms
+          super(
+            execute_type: 3, # TODO
+            formatted_command_string: query ? ERB::Util.html_escape(query) : nil,
+            stack_trace_snippet: stack_trace,
+            start_milliseconds: start_millis,
+            duration_milliseconds: duration_ms,
+            first_fetch_duration_milliseconds: duration_ms,
+            parameters: query ? trim_binds(params) : nil,
+            row_count: 0,
+            class_name: nil,
+            parent_timing_id: nil,
+            cached: cached,
+            is_duplicate: false
+          )
+        end
+
+        def report_reader_duration(elapsed_ms, row_count = nil, class_name = nil)
+          return if @reported
+          @reported = true
+          self[:duration_milliseconds]                += elapsed_ms
+          @parent[:sql_timings_duration_milliseconds] += elapsed_ms
+          @page[:duration_milliseconds_in_sql]        += elapsed_ms
+          self[:row_count] = self[:row_count].to_i + row_count if row_count
+          self[:class_name] = class_name if class_name
+        end
+
+        def trim_binds(binds)
+          max_len = Rack::MiniProfiler.config.max_sql_param_length
+          return if binds.nil? || max_len == 0
+          return binds.map { |(name, val)| [name, val] } if max_len.nil?
+          binds.map do |(name, val)|
+            val ||= name
+            if val.nil? || val == true || val == false || val.kind_of?(Numeric)
+              # keep these parameters as is
+            elsif val.kind_of?(String)
+              val = val[0...max_len] + (max_len < val.length ? '...' : '') if max_len
+            else
+              val = val.class.name
+            end
+            if name.kind_of?(String)
+              name = name[0...max_len] + (max_len < name.length ? '...' : '') if max_len
+            end
+            [name, val]
+          end
+        end
+      end
+    end
+  end
+end

data/rack-mini-profiler-4.0.1/lib/mini_profiler/timer_struct.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+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'

data/rack-mini-profiler-4.0.1/lib/mini_profiler/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rack
+  class MiniProfiler
+    VERSION = "4.0.1"
+    SOURCE_CODE_URI = "https://github.com/MiniProfiler/rack-mini-profiler"
+  end
+end