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.



131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/mini_profiler/profiling_methods.rb', line 131

def counter(type, duration_ms=nil)
  result = nil
  if block_given?
    start       = Time.now
    result      = yield
    duration_ms = (Time.now - 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 



55
56
57
 
# File 'lib/mini_profiler/profiling_methods.rb', line 55

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

#finish_step(obj) ⇒ Object 



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

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 



63
64
65
66
67
68
69
70
71
72
73
74
75
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
 
# File 'lib/mini_profiler/profiling_methods.rb', line 63

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 = Time.now
      begin
        self.send without_profiling, *args, &orig
      ensure
        duration_ms = (Time.now - 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
  klass.send :alias_method, method, with_profiling
end

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



112
113
114
 
# File 'lib/mini_profiler/profiling_methods.rb', line 112

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

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



5
6
7
8
9
 
# File 'lib/mini_profiler/profiling_methods.rb', line 5

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

#start_step(name) ⇒ Object 



11
12
13
14
15
16
 
# File 'lib/mini_profiler/profiling_methods.rb', line 11

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



26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/mini_profiler/profiling_methods.rb', line 26

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 



59
60
61
 
# File 'lib/mini_profiler/profiling_methods.rb', line 59

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

#unprofile_method(klass, method) ⇒ Object 



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

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 



116
117
118
 
# File 'lib/mini_profiler/profiling_methods.rb', line 116

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