Module: StepTrack

Extended by:
StepTrack
Included in:
StepTrack
Defined in:
lib/step_track.rb,
lib/step_track/version.rb

Constant Summary collapse

REF = 
"step_track/%{track}"
VERSION = 
"0.4.0"

Instance Method Summary collapse

Instance Method Details

#done(track) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/step_track.rb', line 32

def done(track)
  require_init!(track)
  track_ref = Thread.current[ref(track)]
  Thread.current[ref(track)] = nil
  steps = track_ref.delete(:steps)
  steps.each { |step| step.delete(:time) }
  result = {step_count: steps.count}
  last_step = steps.last&.dup || {}
  last_step[:final_step_name] = last_step.delete(:step_name)
  result.merge!(last_step)
  steps.each_with_index do |step, i|
    name = name_dupe = step.delete(:step_name)
    j = 0
    while result.key?("step_#{name_dupe}_i".to_sym)
      j += 1
      name_dupe = "#{name}_#{j}"
    end
    name = name_dupe
    [:split, :duration].each { |k| step[k] = (step[k] * 1000).to_i }
    result.merge!(step.merge(i: i + 1).
      map { |k, v| ["step_#{name}_#{k}".to_sym, v] }.to_h)
  end
  return track_ref[:callback].call(result)
end

#init(track, config = {merge_key: :merge, error_key: :error}) ⇒ Object

Raises:

  • (ArgumentError) 


8
9
10
11
12
13
14
15
 
# File 'lib/step_track.rb', line 8

def init(track, config={merge_key: :merge, error_key: :error})
  raise ArgumentError, "callback block required" unless block_given?
  Thread.current[ref(track)] = {
    steps: [],
    callback: Proc.new,
    time: Time.now
  }.merge(config)
end

#push(track, name, payload = {}) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/step_track.rb', line 17

def push(track, name, payload={})
  require_init!(track)
  track_ref = Thread.current[ref(track)]
  return if track_ref[:steps].last&.[](track_ref[:error_key])
  merge_step = track_ref[:steps].pop if payload.delete(track_ref[:merge_key])
  last_step = track_ref[:steps].last
  track_ref[:steps] << (merge_step || {}).merge(
    split: Time.now.to_f - (last_step&.[](:time) || track_ref[:time]).to_f,
    duration: Time.now.to_f - track_ref[:time].to_f,
    time: Time.now,
    caller: merge_step&.[](:caller) || caller[0].sub(Dir.pwd + "/", ""),
    step_name: merge_step&.[](:step_name) || name
  ).merge(payload)
end