Module: Rack::MiniProfiler::ProfilingMethods

Included in:
Rack::MiniProfiler
Defined in:
lib/mini_profiler/profiling_methods.rb

Instance Method Summary collapse

Instance Method Details

#counter(type, duration_ms = nil) ⇒ Object

Add a custom timing. These are displayed similar to SQL/query time in columns expanding to the right.

type - String counter type. Each distinct type gets its own column. duration_ms - Duration of the call in ms. Either this or a block must be

given but not both.

When a block is given, calculate the duration by yielding to the block and keeping a record of its run time.

Returns the result of the block, or nil when no block is given.



147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/mini_profiler/profiling_methods.rb', line 147

def counter(type, duration_ms = nil)
  result = nil
  if block_given?
    start       = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    result      = yield
    duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start).to_f * 1000
  end
  return result if current.nil? || !request_authorized?
  current.current_timer.add_custom(type, duration_ms, current.page_struct)
  result
end

#counter_method(klass, method, &blk) ⇒ Object 



68
69
70
 
# File 'lib/mini_profiler/profiling_methods.rb', line 68

def counter_method(klass, method, &blk)
  self.profile_method(klass, method, :counter, &blk)
end

#finish_step(obj) ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/mini_profiler/profiling_methods.rb', line 31

def finish_step(obj)
  return unless obj && current
  current_timer, parent_timer = obj
  current_timer.record_time
  current.current_timer = parent_timer
end

#profile_method(klass, method, type = :profile, &blk) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/mini_profiler/profiling_methods.rb', line 76

def profile_method(klass, method, type = :profile, &blk)
  default_name = type == :counter ? method.to_s : klass.to_s + " " + method.to_s
  clean        = clean_method_name(method)

  with_profiling    = ("#{clean}_with_mini_profiler").intern
  without_profiling = ("#{clean}_without_mini_profiler").intern

  if klass.send :method_defined?, with_profiling
    return # dont double profile
  end

  klass.send :alias_method, without_profiling, method
  klass.send :define_method, with_profiling do |*args, &orig|
    return self.send without_profiling, *args, &orig unless Rack::MiniProfiler.current

    name = default_name
    if blk
      name =
        if respond_to?(:instance_exec)
          instance_exec(*args, &blk)
        else
          # deprecated in Rails 4.x
          blk.bind(self).call(*args)
        end
    end

    parent_timer = Rack::MiniProfiler.current.current_timer

    if type == :counter
      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
      begin
        self.send without_profiling, *args, &orig
      ensure
        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start).to_f * 1000
        parent_timer.add_custom(name, duration_ms, Rack::MiniProfiler.current.page_struct)
      end
    else
      Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
      begin
        self.send without_profiling, *args, &orig
      ensure
        current_timer.record_time
        Rack::MiniProfiler.current.current_timer = parent_timer
      end
    end
  end
  if klass.respond_to?(:ruby2_keywords, true)
    klass.send(:ruby2_keywords, with_profiling)
  end
  klass.send :alias_method, method, with_profiling
end

#profile_singleton_method(klass, method, type = :profile, &blk) ⇒ Object 



128
129
130
 
# File 'lib/mini_profiler/profiling_methods.rb', line 128

def profile_singleton_method(klass, method, type = :profile, &blk)
  profile_method(klass.singleton_class, method, type, &blk)
end

#record_sql(query, elapsed_ms, params = nil) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/mini_profiler/profiling_methods.rb', line 7

def record_sql(query, elapsed_ms, params = nil)
  return unless current && current.current_timer
  c = current
  c.current_timer.add_sql(
    redact_sql_queries? ? nil : query,
    elapsed_ms,
    c.page_struct,
    redact_sql_queries? ? nil : params,
    c.skip_backtrace,
    c.full_backtrace
  )
end

#report_reader_duration(elapsed_ms, row_count = nil, class_name = nil) ⇒ Object 



20
21
22
 
# File 'lib/mini_profiler/profiling_methods.rb', line 20

def report_reader_duration(elapsed_ms, row_count = nil, class_name = nil)
  current&.current_timer&.report_reader_duration(elapsed_ms, row_count, class_name)
end

#start_step(name) ⇒ Object 



24
25
26
27
28
29
 
# File 'lib/mini_profiler/profiling_methods.rb', line 24

def start_step(name)
  return unless current
  parent_timer          = current.current_timer
  current.current_timer = current_timer = current.current_timer.add_child(name)
  [current_timer, parent_timer]
end

#step(name, opts = nil) ⇒ Object

perform a profiling step on given block



39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/mini_profiler/profiling_methods.rb', line 39

def step(name, opts = nil)
  if current
    parent_timer          = current.current_timer
    current.current_timer = current_timer = current.current_timer.add_child(name)
    begin
      yield if block_given?
    ensure
      current_timer.record_time
      current.current_timer = parent_timer
    end
  else
    yield if block_given?
  end
end

#uncounter_method(klass, method) ⇒ Object 



72
73
74
 
# File 'lib/mini_profiler/profiling_methods.rb', line 72

def uncounter_method(klass, method)
  self.unprofile_method(klass, method)
end

#unprofile_method(klass, method) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/mini_profiler/profiling_methods.rb', line 54

def unprofile_method(klass, method)

  clean = clean_method_name(method)

  with_profiling = ("#{clean}_with_mini_profiler").intern
  without_profiling = ("#{clean}_without_mini_profiler").intern

  if klass.send :method_defined?, with_profiling
    klass.send :alias_method, method, without_profiling
    klass.send :remove_method, with_profiling
    klass.send :remove_method, without_profiling
  end
end

#unprofile_singleton_method(klass, method) ⇒ Object 



132
133
134
 
# File 'lib/mini_profiler/profiling_methods.rb', line 132

def unprofile_singleton_method(klass, method)
  unprofile_method(klass.singleton_class, method)
end