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 



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

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

#finish_step(obj) ⇒ Object 



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

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

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



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
111
112
113
114
115
116
117
118
 
# File 'lib/mini_profiler/profiling_methods.rb', line 66

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

    result = nil
    parent_timer = Rack::MiniProfiler.current.current_timer

    if type == :counter
      start = Time.now
      begin
        result = 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
      page_struct = Rack::MiniProfiler.current.page_struct

      Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name)
      begin
        result = self.send without_profiling, *args, &orig
      ensure
        current_timer.record_time
        Rack::MiniProfiler.current.current_timer = parent_timer
      end
    end

    result
  end
  klass.send :alias_method, method, with_profiling
end

#record_sql(query, elapsed_ms) ⇒ Object 



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

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

#start_step(name) ⇒ Object 



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

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

#step(name, opts = nil) ⇒ Object

perform a profiling step on given block



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

def step(name, opts = nil)
  if current
    parent_timer = current.current_timer
    result = nil
    current.current_timer = current_timer = current.current_timer.add_child(name)
    begin
      result = 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 



62
63
64
 
# File 'lib/mini_profiler/profiling_methods.rb', line 62

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

#unprofile_method(klass, method) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/mini_profiler/profiling_methods.rb', line 44

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