activesupport_notifications_backport 0.0.1

data/Rakefile

@@ -0,0 +1,134 @@
+#!/usr/bin/env rake
+
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/#{gem_file}"
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    #exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/activesupport_notifications_backport.gemspec

@@ -0,0 +1,62 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'activesupport_notifications_backport'
+  s.version           = '0.0.1'
+  s.date              = '2012-03-20'
+  s.rubyforge_project = 'activesupport_notifications_backport'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "ActiveSupport::Notifications backported for Rails 2.3"
+  s.description = "ActiveSupport::Notifications backported for Rails 2.3"
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Rick Olson"]
+  s.email    = 'technoweenie@gmail.com'
+  s.homepage = 'http://github.com/technoweenie/activesupport_notifications_backport'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  s.add_dependency 'activesupport', '~> 2.3.14'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'test-unit'
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Rakefile
+    activesupport_notifications_backport.gemspec
+    lib/active_support/log_subscriber.rb
+    lib/active_support/log_subscriber/test_helper.rb
+    lib/active_support/notifications.rb
+    lib/active_support/notifications/fanout.rb
+    lib/active_support/notifications/instrumenter.rb
+    lib/activesupport_notifications_backport.rb
+    test/abstract_unit.rb
+    test/log_subscriber_test.rb
+    test/notifications_test.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ %r{^test/*/.+\.rb} }
+end

data/lib/active_support/log_subscriber.rb

@@ -0,0 +1,122 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveSupport
+  # ActiveSupport::LogSubscriber is an object set to consume ActiveSupport::Notifications
+  # with the sole purpose of logging them. The log subscriber dispatches notifications to
+  # a registered object based on its given namespace.
+  #
+  # An example would be Active Record log subscriber responsible for logging queries:
+  #
+  #   module ActiveRecord
+  #     class LogSubscriber < ActiveSupport::LogSubscriber
+  #       def sql(event)
+  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #       end
+  #     end
+  #   end
+  #
+  # And it's finally registered as:
+  #
+  #   ActiveRecord::LogSubscriber.attach_to :active_record
+  #
+  # Since we need to know all instance methods before attaching the log subscriber,
+  # the line above should be called after your <tt>ActiveRecord::LogSubscriber</tt> definition.
+  #
+  # After configured, whenever a "sql.active_record" notification is published,
+  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
+  # the sql method.
+  #
+  # Log subscriber also has some helpers to deal with logging and automatically flushes
+  # all logs when the request finishes (via action_dispatch.callback notification) in
+  # a Rails environment.
+  class LogSubscriber
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR   = "\e[0m"
+    BOLD    = "\e[1m"
+
+    # Colors
+    BLACK   = "\e[30m"
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+    WHITE   = "\e[37m"
+
+    mattr_accessor :colorize_logging
+    self.colorize_logging = true
+
+    class_attribute :logger
+
+    class << self
+      remove_method :logger
+      def logger
+        @logger ||= Rails.logger if defined?(Rails)
+      end
+
+      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
+        log_subscribers << log_subscriber
+        @@flushable_loggers = nil
+
+        log_subscriber.public_methods(false).each do |event|
+          next if 'call' == event.to_s
+
+          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
+        end
+      end
+
+      def log_subscribers
+        @@log_subscribers ||= []
+      end
+
+      def flushable_loggers
+        @@flushable_loggers ||= begin
+          loggers = log_subscribers.map(&:logger)
+          loggers.uniq!
+          loggers.select! { |l| l.respond_to?(:flush) }
+          loggers
+        end
+      end
+
+      # Flush all log_subscribers' logger.
+      def flush_all!
+        flushable_loggers.each { |log| log.flush }
+      end
+    end
+
+    def call(message, *args)
+      return unless logger
+
+      method = message.split('.').first
+      begin
+        send(method, ActiveSupport::Notifications::Event.new(message, *args))
+      rescue Exception => e
+        logger.error "Could not log #{message.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
+      end
+    end
+
+  protected
+
+    %w(info debug warn error fatal unknown).each do |level|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{level}(progname = nil, &block)
+          logger.#{level}(progname, &block) if logger
+        end
+      METHOD
+    end
+
+    # Set color by using a string or one of the defined constants. If a third
+    # option is set to true, it also adds bold to the string. This is based
+    # on the Highline implementation and will automatically append CLEAR to the
+    # end of the returned String.
+    #
+    def color(text, color, bold=false)
+      return text unless colorize_logging
+      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+      bold  = bold ? BOLD : ""
+      "#{bold}#{color}#{text}#{CLEAR}"
+    end
+  end
+end

data/lib/active_support/log_subscriber/test_helper.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../../log_subscriber', __FILE__)
+require 'active_support/buffered_logger'
+require File.expand_path('../../notifications', __FILE__)
+
+module ActiveSupport
+  Logger = BufferedLogger
+  class LogSubscriber
+    # Provides some helpers to deal with testing log subscribers by setting up
+    # notifications. Take for instance Active Record subscriber tests:
+    #
+    #   class SyncLogSubscriberTest < ActiveSupport::TestCase
+    #     include ActiveSupport::LogSubscriber::TestHelper
+    #
+    #     def setup
+    #       ActiveRecord::LogSubscriber.attach_to(:active_record)
+    #     end
+    #
+    #     def test_basic_query_logging
+    #       Developer.all
+    #       wait
+    #       assert_equal 1, @logger.logged(:debug).size
+    #       assert_match(/Developer Load/, @logger.logged(:debug).last)
+    #       assert_match(/SELECT \* FROM "developers"/, @logger.logged(:debug).last)
+    #     end
+    #   end
+    #
+    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
+    # as in the second line of the code above. The test helpers are responsible for setting
+    # up the queue, subscriptions and turning colors in logs off.
+    #
+    # The messages are available in the @logger instance, which is a logger with limited
+    # powers (it actually does not send anything to your output), and you can collect them
+    # doing @logger.logged(level), where level is the level used in logging, like info,
+    # debug, warn and so on.
+    #
+    module TestHelper
+      def setup
+        @logger   = MockLogger.new
+        @notifier = ActiveSupport::Notifications::Fanout.new
+
+        ActiveSupport::LogSubscriber.colorize_logging = false
+
+        @old_notifier = ActiveSupport::Notifications.notifier
+        set_logger(@logger)
+        ActiveSupport::Notifications.notifier = @notifier
+      end
+
+      def teardown
+        set_logger(nil)
+        ActiveSupport::Notifications.notifier = @old_notifier
+      end
+
+      class MockLogger
+        include ActiveSupport::Logger::Severity
+
+        attr_reader :flush_count
+        attr_accessor :level
+
+        def initialize(level = DEBUG)
+          @flush_count = 0
+          @level = level
+          @logged = Hash.new { |h,k| h[k] = [] }
+        end
+
+        def method_missing(level, message)
+          @logged[level] << message
+        end
+
+        def logged(level)
+          @logged[level].compact.map { |l| l.to_s.strip }
+        end
+
+        def flush
+          @flush_count += 1
+        end
+
+        ActiveSupport::Logger::Severity.constants.each do |severity|
+          class_eval <<-EOT, __FILE__, __LINE__ + 1
+            def #{severity.downcase}?
+              #{severity} >= @level
+            end
+          EOT
+        end
+      end
+
+      # Wait notifications to be published.
+      def wait
+        @notifier.wait
+      end
+
+      # Overwrite if you use another logger in your log subscriber:
+      #
+      #   def logger
+      #     ActiveRecord::Base.logger = @logger
+      #   end
+      #
+      def set_logger(logger)
+        ActiveSupport::LogSubscriber.logger = logger
+      end
+    end
+  end
+end

data/lib/active_support/notifications.rb

@@ -0,0 +1,154 @@
+module ActiveSupport
+  # = Notifications
+  #
+  # +ActiveSupport::Notifications+ provides an instrumentation API for Ruby.
+  #
+  # == Instrumenters
+  #
+  # To instrument an event you just need to do:
+  #
+  #   ActiveSupport::Notifications.instrument("render", :extra => :information) do
+  #     render :text => "Foo"
+  #   end
+  #
+  # That executes the block first and notifies all subscribers once done.
+  #
+  # In the example above "render" is the name of the event, and the rest is called
+  # the _payload_. The payload is a mechanism that allows instrumenters to pass
+  # extra information to subscribers. Payloads consist of a hash whose contents
+  # are arbitrary and generally depend on the event.
+  #
+  # == Subscribers
+  #
+  # You can consume those events and the information they provide by registering
+  # a subscriber. For instance, let's store all "render" events in an array:
+  #
+  #   events = []
+  #
+  #   ActiveSupport::Notifications.subscribe("render") do |*args|
+  #     events << ActiveSupport::Notifications::Event.new(*args)
+  #   end
+  #
+  # That code returns right away, you are just subscribing to "render" events.
+  # The block will be called asynchronously whenever someone instruments "render":
+  #
+  #   ActiveSupport::Notifications.instrument("render", :extra => :information) do
+  #     render :text => "Foo"
+  #   end
+  #
+  #   event = events.first
+  #   event.name      # => "render"
+  #   event.duration  # => 10 (in milliseconds)
+  #   event.payload   # => { :extra => :information }
+  #
+  # The block in the +subscribe+ call gets the name of the event, start
+  # timestamp, end timestamp, a string with a unique identifier for that event
+  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
+  # that order.
+  #
+  # If an exception happens during that particular instrumentation the payload will
+  # have a key +:exception+ with an array of two elements as value: a string with
+  # the name of the exception class, and the exception message.
+  #
+  # As the previous example depicts, the class +ActiveSupport::Notifications::Event+
+  # is able to take the arguments as they come and provide an object-oriented
+  # interface to that data.
+  #
+  # You can also subscribe to all events whose name matches a certain regexp:
+  #
+  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
+  #     ...
+  #   end
+  #
+  # and even pass no argument to +subscribe+, in which case you are subscribing
+  # to all events.
+  #
+  # == Temporary Subscriptions
+  #
+  # Sometimes you do not want to subscribe to an event for the entire life of
+  # the application. There are two ways to unsubscribe.
+  #
+  # WARNING: The instrumentation framework is designed for long-running subscribers,
+  # use this feature sparingly because it wipes some internal caches and that has
+  # a negative impact on performance.
+  #
+  # === Subscribe While a Block Runs
+  #
+  # You can subscribe to some event temporarily while some block runs. For
+  # example, in
+  #
+  #   callback = lambda {|*args| ... }
+  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
+  #     ...
+  #   end
+  #
+  # the callback will be called for all "sql.active_record" events instrumented
+  # during the execution of the block. The callback is unsubscribed automatically
+  # after that.
+  #
+  # === Manual Unsubscription
+  #
+  # The +subscribe+ method returns a subscriber object:
+  #
+  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
+  #     ...
+  #   end
+  #
+  # To prevent that block from being called anymore, just unsubscribe passing
+  # that reference:
+  #
+  #   ActiveSupport::Notifications.unsubscribe(subscriber)
+  #
+  # == Default Queue
+  #
+  # Notifications ships with a queue implementation that consumes and publish events
+  # to log subscribers in a thread. You can use any queue implementation you want.
+  #
+  module Notifications
+    autoload :Instrumenter, File.expand_path('../notifications/instrumenter', __FILE__)
+    autoload :Event, File.expand_path('../notifications/instrumenter', __FILE__)
+    autoload :Fanout, File.expand_path('../notifications/fanout', __FILE__)
+
+    @instrumenters = Hash.new { |h,k| h[k] = notifier.listening?(k) }
+
+    class << self
+      attr_accessor :notifier
+
+      def publish(name, *args)
+        notifier.publish(name, *args)
+      end
+
+      def instrument(name, payload = {})
+        if @instrumenters[name]
+          instrumenter.instrument(name, payload) { yield payload if block_given? }
+        else
+          yield payload if block_given?
+        end
+      end
+
+      def subscribe(*args, &block)
+        notifier.subscribe(*args, &block).tap do
+          @instrumenters.clear
+        end
+      end
+
+      def subscribed(callback, *args, &block)
+        subscriber = subscribe(*args, &callback)
+        yield
+      ensure
+        unsubscribe(subscriber)
+      end
+
+      def unsubscribe(args)
+        notifier.unsubscribe(args)
+        @instrumenters.clear
+      end
+
+      def instrumenter
+        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
+      end
+    end
+
+    self.notifier = Fanout.new
+  end
+end

data/lib/active_support/notifications/fanout.rb

@@ -0,0 +1,60 @@
+module ActiveSupport
+  module Notifications
+    # This is a default queue implementation that ships with Notifications.
+    # It just pushes events to all registered log subscribers.
+    class Fanout
+      def initialize
+        @subscribers = []
+        @listeners_for = {}
+      end
+
+      def subscribe(pattern = nil, block = Proc.new)
+        subscriber = Subscriber.new(pattern, block)
+        @subscribers << subscriber
+        @listeners_for.clear
+        subscriber
+      end
+
+      def unsubscribe(subscriber)
+        @subscribers.reject! { |s| s.matches?(subscriber) }
+        @listeners_for.clear
+      end
+
+      def publish(name, *args)
+        listeners_for(name).each { |s| s.publish(name, *args) }
+      end
+
+      def listeners_for(name)
+        @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
+      end
+
+      def listening?(name)
+        listeners_for(name).any?
+      end
+
+      # This is a sync queue, so there is no waiting.
+      def wait
+      end
+
+      class Subscriber #:nodoc:
+        def initialize(pattern, delegate)
+          @pattern = pattern
+          @delegate = delegate
+        end
+
+        def publish(message, *args)
+          @delegate.call(message, *args)
+        end
+
+        def subscribed_to?(name)
+          !@pattern || @pattern === name.to_s
+        end
+
+        def matches?(subscriber_or_name)
+          self === subscriber_or_name ||
+            @pattern && @pattern === subscriber_or_name
+        end
+      end
+    end
+  end
+end

data/lib/active_support/notifications/instrumenter.rb

@@ -0,0 +1,51 @@
+module ActiveSupport
+  module Notifications
+    class Instrumenter
+      attr_reader :id
+
+      def initialize(notifier)
+        @id = unique_id
+        @notifier = notifier
+      end
+
+      # Instrument the given block by measuring the time taken to execute it
+      # and publish it. Notice that events get sent even if an error occurs
+      # in the passed-in block
+      def instrument(name, payload={})
+        started = Time.now
+
+        begin
+          yield
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          raise e
+        ensure
+          @notifier.publish(name, started, Time.now, @id, payload)
+        end
+      end
+
+      private
+        def unique_id
+          SecureRandom.hex(10)
+        end
+    end
+
+    class Event
+      attr_reader :name, :time, :end, :transaction_id, :payload, :duration
+
+      def initialize(name, start, ending, transaction_id, payload)
+        @name           = name
+        @payload        = payload.dup
+        @time           = start
+        @transaction_id = transaction_id
+        @end            = ending
+        @duration       = 1000.0 * (@end - @time)
+      end
+
+      def parent_of?(event)
+        start = (time - event.time) * 1000
+        start <= 0 && (start + duration >= event.duration)
+      end
+    end
+  end
+end

data/lib/activesupport_notifications_backport.rb

@@ -0,0 +1,12 @@
+require 'active_support/version'
+if ActiveSupport::VERSION::MAJOR > 2
+  raise "Can't use this with Rails 3+, silly!"
+end
+
+module ActiveSupportNotificationsBackport
+  VERSION = "0.0.1"
+end
+
+require 'active_support/secure_random'
+require File.expand_path('../active_support/notifications', __FILE__)
+require File.expand_path('../active_support/log_subscriber', __FILE__)

data/test/abstract_unit.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+require 'mocha'
+require 'active_support'
+require 'active_support/test_case'
+require File.expand_path('../../lib/activesupport_notifications_backport', __FILE__)

data/test/log_subscriber_test.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../abstract_unit', __FILE__)
+require File.expand_path('../../lib/active_support/log_subscriber/test_helper', __FILE__)
+
+class MyLogSubscriber < ActiveSupport::LogSubscriber
+  attr_reader :event
+
+  def some_event(event)
+    @event = event
+    info event.name
+  end
+
+  def foo(event)
+    debug "debug"
+    info "info"
+    warn "warn"
+  end
+
+  def bar(event)
+    info "#{color("cool", :red)}, #{color("isn't it?", :blue, true)}"
+  end
+
+  def puke(event)
+    raise "puke"
+  end
+end
+
+class SyncLogSubscriberTest < ActiveSupport::TestCase
+  include ActiveSupport::LogSubscriber::TestHelper
+
+  def setup
+    super
+    @log_subscriber = MyLogSubscriber.new
+  end
+
+  def teardown
+    super
+    ActiveSupport::LogSubscriber.log_subscribers.clear
+  end
+
+  def instrument(*args, &block)
+    ActiveSupport::Notifications.instrument(*args, &block)
+  end
+
+  def test_proxies_method_to_rails_logger
+    @log_subscriber.foo(nil)
+    assert_equal %w(debug), @logger.logged(:debug)
+    assert_equal %w(info), @logger.logged(:info)
+    assert_equal %w(warn), @logger.logged(:warn)
+  end
+
+  def test_set_color_for_messages
+    ActiveSupport::LogSubscriber.colorize_logging = true
+    @log_subscriber.bar(nil)
+    assert_equal "\e[31mcool\e[0m, \e[1m\e[34misn't it?\e[0m", @logger.logged(:info).last
+  end
+
+  def test_does_not_set_color_if_colorize_logging_is_set_to_false
+    @log_subscriber.bar(nil)
+    assert_equal "cool, isn't it?", @logger.logged(:info).last
+  end
+
+  def test_event_is_sent_to_the_registered_class
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "some_event.my_log_subscriber"
+    wait
+    assert_equal %w(some_event.my_log_subscriber), @logger.logged(:info)
+  end
+
+  def test_event_is_an_active_support_notifications_event
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "some_event.my_log_subscriber"
+    wait
+    assert_kind_of ActiveSupport::Notifications::Event, @log_subscriber.event
+  end
+
+  def test_does_not_send_the_event_if_it_doesnt_match_the_class
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "unknown_event.my_log_subscriber"
+    wait
+    # If we get here, it means that NoMethodError was not raised.
+  end
+
+  def test_does_not_send_the_event_if_logger_is_nil
+    ActiveSupport::LogSubscriber.logger = nil
+    @log_subscriber.expects(:some_event).never
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "some_event.my_log_subscriber"
+    wait
+  end
+
+  def test_does_not_fail_with_non_namespaced_events
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "whatever"
+    wait
+  end
+
+  def test_flushes_loggers
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    ActiveSupport::LogSubscriber.flush_all!
+    assert_equal 1, @logger.flush_count
+  end
+
+  def test_flushes_the_same_logger_just_once
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    ActiveSupport::LogSubscriber.attach_to :another, @log_subscriber
+    ActiveSupport::LogSubscriber.flush_all!
+    wait
+    assert_equal 1, @logger.flush_count
+  end
+
+  def test_logging_does_not_die_on_failures
+    ActiveSupport::LogSubscriber.attach_to :my_log_subscriber, @log_subscriber
+    instrument "puke.my_log_subscriber"
+    instrument "some_event.my_log_subscriber"
+    wait
+
+    assert_equal 1, @logger.logged(:info).size
+    assert_equal 'some_event.my_log_subscriber', @logger.logged(:info).last
+
+    assert_equal 1, @logger.logged(:error).size
+    assert_match 'Could not log "puke.my_log_subscriber" event. RuntimeError: puke', @logger.logged(:error).last
+  end
+end

data/test/notifications_test.rb

@@ -0,0 +1,242 @@
+require File.expand_path('../abstract_unit', __FILE__)
+require 'active_support/core_ext/module/delegation'
+
+module Notifications
+  class TestCase < ActiveSupport::TestCase
+    def setup
+      @old_notifier = ActiveSupport::Notifications.notifier
+      @notifier = ActiveSupport::Notifications::Fanout.new
+      ActiveSupport::Notifications.notifier = @notifier
+      @events = []
+      @named_events = []
+      @subscription = @notifier.subscribe { |*args| @events << event(*args) }
+      @named_subscription = @notifier.subscribe("named.subscription") { |*args| @named_events << event(*args) }
+    end
+
+    def teardown
+      ActiveSupport::Notifications.notifier = @old_notifier
+    end
+
+  private
+
+    def event(*args)
+      ActiveSupport::Notifications::Event.new(*args)
+    end
+  end
+
+  class SubscribedTest < TestCase
+    def test_subscribed
+      name     = "foo"
+      name2    = name * 2
+      expected = [name, name]
+
+      events   = []
+      callback = lambda {|*_| events << _.first}
+      ActiveSupport::Notifications.subscribed(callback, name) do
+        ActiveSupport::Notifications.instrument(name)
+        ActiveSupport::Notifications.instrument(name2)
+        ActiveSupport::Notifications.instrument(name)
+      end
+      assert_equal expected, events
+
+      ActiveSupport::Notifications.instrument(name)
+      assert_equal expected, events
+    end
+  end
+
+  class UnsubscribeTest < TestCase
+    def test_unsubscribing_removes_a_subscription
+      @notifier.publish :foo
+      @notifier.wait
+      assert_equal [[:foo]], @events
+      @notifier.unsubscribe(@subscription)
+      @notifier.publish :foo
+      @notifier.wait
+      assert_equal [[:foo]], @events
+    end
+
+    def test_unsubscribing_by_name_removes_a_subscription
+      @notifier.publish "named.subscription", :foo
+      @notifier.wait
+      assert_equal [["named.subscription", :foo]], @named_events
+      @notifier.unsubscribe("named.subscription")
+      @notifier.publish "named.subscription", :foo
+      @notifier.wait
+      assert_equal [["named.subscription", :foo]], @named_events
+    end
+
+    def test_unsubscribing_by_name_leaves_the_other_subscriptions
+      @notifier.publish "named.subscription", :foo
+      @notifier.wait
+      assert_equal [["named.subscription", :foo]], @events
+      @notifier.unsubscribe("named.subscription")
+      @notifier.publish "named.subscription", :foo
+      @notifier.wait
+      assert_equal [["named.subscription", :foo], ["named.subscription", :foo]], @events
+    end
+
+  private
+    def event(*args)
+      args
+    end
+  end
+
+  class SyncPubSubTest < TestCase
+    def test_events_are_published_to_a_listener
+      @notifier.publish :foo
+      @notifier.wait
+      assert_equal [[:foo]], @events
+    end
+
+    def test_publishing_multiple_times_works
+      @notifier.publish :foo
+      @notifier.publish :foo
+      @notifier.wait
+      assert_equal [[:foo], [:foo]], @events
+    end
+
+    def test_publishing_after_a_new_subscribe_works
+      @notifier.publish :foo
+      @notifier.publish :foo
+
+      @notifier.subscribe("not_existant") do |*args|
+        @events << ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      @notifier.publish :foo
+      @notifier.publish :foo
+      @notifier.wait
+
+      assert_equal [[:foo]] * 4, @events
+    end
+
+    def test_log_subscriber_with_string
+      events = []
+      @notifier.subscribe('1') { |*args| events << args }
+
+      @notifier.publish '1'
+      @notifier.publish '1.a'
+      @notifier.publish 'a.1'
+      @notifier.wait
+
+      assert_equal [['1']], events
+    end
+
+    def test_log_subscriber_with_pattern
+      events = []
+      @notifier.subscribe(/\d/) { |*args| events << args }
+
+      @notifier.publish '1'
+      @notifier.publish 'a.1'
+      @notifier.publish '1.a'
+      @notifier.wait
+
+      assert_equal [['1'], ['a.1'], ['1.a']], events
+    end
+
+    def test_multiple_log_subscribers
+      @another = []
+      @notifier.subscribe { |*args| @another << args }
+      @notifier.publish :foo
+      @notifier.wait
+
+      assert_equal [[:foo]], @events
+      assert_equal [[:foo]], @another
+    end
+
+    private
+      def event(*args)
+        args
+      end
+  end
+
+  class InstrumentationTest < TestCase
+    delegate :instrument, :to => ActiveSupport::Notifications
+
+    def test_instrument_returns_block_result
+      assert_equal 2, instrument(:awesome) { 1 + 1 }
+    end
+
+    def test_instrument_yields_the_paylod_for_further_modification
+      assert_equal 2, instrument(:awesome) { |p| p[:result] = 1 + 1 }
+      assert_equal 1, @events.size
+      assert_equal :awesome, @events.first.name
+      assert_equal Hash[:result => 2], @events.first.payload
+    end
+
+    def test_instrumenter_exposes_its_id
+      assert_equal 20, ActiveSupport::Notifications.instrumenter.id.size
+    end
+
+    def test_nested_events_can_be_instrumented
+      instrument(:awesome, :payload => "notifications") do
+        instrument(:wot, :payload => "child") do
+          1 + 1
+        end
+
+        assert_equal 1, @events.size
+        assert_equal :wot, @events.first.name
+        assert_equal Hash[:payload => "child"], @events.first.payload
+      end
+
+      assert_equal 2, @events.size
+      assert_equal :awesome, @events.last.name
+      assert_equal Hash[:payload => "notifications"], @events.last.payload
+    end
+
+    def test_instrument_publishes_when_exception_is_raised
+      begin
+        instrument(:awesome, :payload => "notifications") do
+          raise "FAIL"
+        end
+      rescue RuntimeError => e
+        assert_equal "FAIL", e.message
+      end
+
+      assert_equal 1, @events.size
+      assert_equal Hash[:payload => "notifications",
+        :exception => ["RuntimeError", "FAIL"]], @events.last.payload
+    end
+
+    def test_event_is_pushed_even_without_block
+      instrument(:awesome, :payload => "notifications")
+      assert_equal 1, @events.size
+      assert_equal :awesome, @events.last.name
+      assert_equal Hash[:payload => "notifications"], @events.last.payload
+    end
+  end
+
+  class EventTest < TestCase
+    def test_events_are_initialized_with_details
+      time = Time.now
+      event = event(:foo, time, time + 0.01, random_id, {})
+
+      assert_equal    :foo, event.name
+      assert_equal    time, event.time
+      assert_in_delta 10.0, event.duration, 0.00001
+    end
+
+    def test_events_consumes_information_given_as_payload
+      event = event(:foo, Time.now, Time.now + 1, random_id, :payload => :bar)
+      assert_equal Hash[:payload => :bar], event.payload
+    end
+
+    def test_event_is_parent_based_on_time_frame
+      time = Time.utc(2009, 01, 01, 0, 0, 1)
+
+      parent    = event(:foo, Time.utc(2009), Time.utc(2009) + 100, random_id, {})
+      child     = event(:foo, time, time + 10, random_id, {})
+      not_child = event(:foo, time, time + 100, random_id, {})
+
+      assert parent.parent_of?(child)
+      assert !child.parent_of?(parent)
+      assert !parent.parent_of?(not_child)
+      assert !not_child.parent_of?(parent)
+    end
+
+    protected
+      def random_id
+        @random_id ||= SecureRandom.hex(10)
+      end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: activesupport_notifications_backport
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rick Olson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70341193016060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: *70341193016060
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70341193015680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70341193015680
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70341193015220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70341193015220
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &70341193014800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70341193014800
+description: ActiveSupport::Notifications backported for Rails 2.3
+email: technoweenie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- activesupport_notifications_backport.gemspec
+- lib/active_support/log_subscriber.rb
+- lib/active_support/log_subscriber/test_helper.rb
+- lib/active_support/notifications.rb
+- lib/active_support/notifications/fanout.rb
+- lib/active_support/notifications/instrumenter.rb
+- lib/activesupport_notifications_backport.rb
+- test/abstract_unit.rb
+- test/log_subscriber_test.rb
+- test/notifications_test.rb
+homepage: http://github.com/technoweenie/activesupport_notifications_backport
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: activesupport_notifications_backport
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 2
+summary: ActiveSupport::Notifications backported for Rails 2.3
+test_files:
+- test/abstract_unit.rb
+- test/log_subscriber_test.rb
+- test/notifications_test.rb