1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
require 'active_support/core_ext/module/delegation'
module ActiveSupport
# Notifications provides an instrumentation API for Ruby. To instrument an
# action in Ruby you just need to do:
#
# ActiveSupport::Notifications.instrument(:render, :extra => :information) do
# render :text => "Foo"
# end
#
# You can consume those events and the information they provide by registering
# a subscriber. For instance, let's store all instrumented events in an array:
#
# @events = []
#
# ActiveSupport::Notifications.subscribe do |*args|
# @events << ActiveSupport::Notifications::Event.new(*args)
# end
#
# ActiveSupport::Notifications.instrument(:render, :extra => :information) do
# render :text => "Foo"
# end
#
# event = @events.first
# event.name #=> :render
# event.duration #=> 10 (in miliseconds)
# event.result #=> "Foo"
# event.payload #=> { :extra => :information }
#
# When subscribing to Notifications, you can pass a pattern, to only consume
# events that match the pattern:
#
# ActiveSupport::Notifications.subscribe(/render/) do |event|
# @render_events << event
# end
#
# Notifications ships with a queue implementation that consumes and publish events
# to subscribers in a thread. You can use any queue implementation you want.
#
module Notifications
autoload :Instrumenter, 'active_support/notifications/instrumenter'
autoload :Event, 'active_support/notifications/instrumenter'
autoload :Fanout, 'active_support/notifications/fanout'
class << self
attr_writer :notifier
delegate :publish, :subscribe, :to => :notifier
delegate :instrument, :instrument!, :to => :instrumenter
def notifier
@notifier ||= Notifier.new
end
def instrumenter
Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
end
end
class Notifier
def initialize(queue = Fanout.new)
@queue = queue
end
def publish(*args)
@queue.publish(*args)
end
def subscribe(pattern = nil, &block)
@queue.bind(pattern).subscribe(&block)
end
def wait
@queue.wait
end
end
end
end
|
