class ActiveSupport::Subscriber

ActiveRecord::StatsSubscriber.detach_from(:active_record)
We can detach a subscriber as well:
the sql method.
it will properly dispatch the event (ActiveSupport::Notifications::Event) to
After configured, whenever a “sql.active_record” notification is published,
end
end
end
Statsd.timing(“sql.#{event.payload}”, event.duration)
def sql(event)
attach_to :active_record
class StatsSubscriber < ActiveSupport::Subscriber
module ActiveRecord
statistics about queries:
An example would be an Active Record subscriber responsible for collecting
a registered object based on its given namespace.
ActiveSupport::Notifications. The subscriber dispatches notifications to
ActiveSupport::Subscriber is an object set to consume

def add_event_subscriber(event) # :doc:

:doc:

def add_event_subscriber(event) # :doc:
  return if invalid_event?(event)
  pattern = prepare_pattern(event)
  # Don't add multiple subscribers (e.g. if methods are redefined).
  return if pattern_subscribed?(pattern)
  subscriber.patterns[pattern] = notifier.subscribe(pattern, subscriber)
end

def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications, inherit_all: false)

Attach the subscriber to a namespace.

def attach_to(namespace, subscriber = new, notifier = ActiveSupport::Notifications, inherit_all: false)
  @namespace  = namespace
  @subscriber = subscriber
  @notifier   = notifier
  @inherit_all = inherit_all
  subscribers << subscriber
  # Add event subscribers for all existing methods on the class.
  fetch_public_methods(subscriber, inherit_all).each do |event|
    add_event_subscriber(event)
  end
end

def detach_from(namespace, notifier = ActiveSupport::Notifications)

Detach the subscriber from a namespace.

def detach_from(namespace, notifier = ActiveSupport::Notifications)
  @namespace  = namespace
  @subscriber = find_attached_subscriber
  @notifier   = notifier
  return unless subscriber
  subscribers.delete(subscriber)
  # Remove event subscribers of all existing methods on the class.
  fetch_public_methods(subscriber, true).each do |event|
    remove_event_subscriber(event)
  end
  # Reset notifier so that event subscribers will not add for new methods added to the class.
  @notifier = nil
end

def event_stack

def event_stack
  registry = ActiveSupport::IsolatedExecutionState[:active_support_subscriber_queue_registry] ||= {}
  registry[@queue_key] ||= []
end

def fetch_public_methods(subscriber, inherit_all)

def fetch_public_methods(subscriber, inherit_all)
  subscriber.public_methods(inherit_all) - Subscriber.public_instance_methods(true)
end

def find_attached_subscriber

def find_attached_subscriber
  subscribers.find { |attached_subscriber| attached_subscriber.instance_of?(self) }
end

def finish(name, id, payload)

def finish(name, id, payload)
  event = event_stack.pop
  event.finish!
  event.payload.merge!(payload)
  method = name.split(".").first
  send(method, event)
end

def initialize

def initialize
  @queue_key = [self.class.name, object_id].join "-"
  @patterns  = {}
  super
end

def invalid_event?(event)

def invalid_event?(event)
  %i{ start finish }.include?(event.to_sym)
end

def method_added(event)

Adds event subscribers for all new methods added to the class.

def method_added(event)
  # Only public methods are added as subscribers, and only if a notifier
  # has been set up. This means that subscribers will only be set up for
  # classes that call #attach_to.
  if public_method_defined?(event) && notifier
    add_event_subscriber(event)
  end
end

def pattern_subscribed?(pattern)

def pattern_subscribed?(pattern)
  subscriber.patterns.key?(pattern)
end

def prepare_pattern(event)

def prepare_pattern(event)
  "#{event}.#{namespace}"
end

def publish_event(event) # :nodoc:

:nodoc:

def publish_event(event) # :nodoc:
  method = event.name.split(".").first
  send(method, event)
end

def remove_event_subscriber(event) # :doc: