skylight 0.0.16 → 0.1.0.alpha1

data/lib/skylight/util/queue.rb

@@ -27,13 +27,17 @@ module Skylight
         @mutex.synchronize { __length }
       end
 
-      # Returns true if the item was queued, false otherwise
+      # Returns the number of items in the queue or nil if the queue is full
       def push(obj)
+        ret = nil
+
         @mutex.synchronize do
-          return false if __length == @max
+          return if __length == @max
           @values[@produce] = obj
           @produce = (@produce + 1) % @max
 
+          ret = __length
+
           # Wakeup a blocked thread
           begin
             t = @waiting.shift
@@ -43,7 +47,7 @@ module Skylight
           end
         end
 
-        true
+        ret
       end
 
       def pop(timeout = nil)

data/lib/skylight/util/task.rb

@@ -0,0 +1,154 @@
+require 'thread'
+
+module Skylight
+  module Util
+    class Task
+      SHUTDOWN = :__SK_TASK_SHUTDOWN
+
+      include Util::Logging
+
+      def initialize(size, timeout = 0.1, &blk)
+        @pid     = Process.pid
+        @thread  = nil
+        @size    = size
+        @lock    = Mutex.new
+        @timeout = timeout
+        @blk     = blk
+      end
+
+      def submit(msg, pid = Process.pid)
+        return unless @pid
+
+        spawn(pid)
+
+        return unless q = @queue
+
+        !!q.push(msg)
+      end
+
+      def spawn(pid = Process.pid)
+        unless spawned?
+          __spawn(pid)
+        end
+
+        true
+      end
+
+      def spawned?
+        !!@thread
+      end
+
+      def running?
+        spawned? && @pid
+      end
+
+      def shutdown(timeout = 5)
+        t = nil
+        m = false
+
+        @lock.synchronize do
+          t = @thread
+
+          if q = @queue
+            m = true
+            q.push(SHUTDOWN)
+            @pid = nil
+          end
+        end
+
+        return true if timeout && timeout < 0
+        return true unless t
+
+        ret = nil
+
+        begin
+          ret = !!t.join(timeout)
+        ensure
+          if !ret && m
+            begin
+              t.kill # FORCE KILL!!!
+            rescue ThreadError
+            end
+          end
+        end
+
+        ret
+      end
+
+    private
+
+      def __spawn(pid)
+        @lock.synchronize do
+          return if spawned? && @pid == pid
+          @pid    = Process.pid
+          @queue  = Util::Queue.new(@size)
+          @thread = Thread.new do
+            begin
+              unless work
+                @queue = nil
+              end
+
+              finish
+            rescue Exception => e
+              error "failed to execute task; msg=%s", e.message
+              t { e.backtrace.join("\n") }
+            end
+          end
+        end
+
+        true
+      end
+
+      def work
+        return unless q = @queue
+
+        while @pid
+          if msg = q.pop(@timeout)
+            return true if SHUTDOWN == msg
+
+            unless __handle(msg)
+              return false
+            end
+          else
+            return unless @queue
+            # just a tick
+            unless __handle(msg)
+              return false
+            end
+          end
+        end
+
+        # Drain the queue
+        while msg = q.pop(0)
+          return true if SHUTDOWN == msg
+
+          unless __handle(msg)
+            return false
+          end
+        end
+
+        true
+      end
+
+      def __handle(msg)
+        begin
+          handle(msg)
+        rescue Exception => e
+          error "error handling event; msg=%s; event=%p", e.message, msg
+          t { e.backtrace.join("\n") }
+          sleep 1
+          true
+        end
+      end
+
+      def handle(msg)
+        return true unless @blk
+        @blk.call(msg)
+      end
+
+      def finish
+      end
+
+    end
+  end
+end

data/lib/skylight/{compat → vendor/active_support}/notifications.rb

@@ -1,22 +1,24 @@
-require 'skylight/compat/notifications/instrumenter'
-require 'skylight/compat/notifications/fanout'
+require 'skylight/vendor/active_support/notifications/instrumenter'
+require 'skylight/vendor/active_support/notifications/fanout'
+require 'skylight/vendor/active_support/per_thread_registry'
 
 module ActiveSupport
   # = Notifications
   #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for Ruby.
+  # <tt>ActiveSupport::Notifications</tt> 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"
+  #   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
+  # 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.
@@ -24,25 +26,35 @@ module ActiveSupport
   # == 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:
+  # a subscriber.
+  #
+  #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
+  #     name    # => String, name of the event (such as 'render' from above)
+  #     start   # => Time, when the instrumented block started execution
+  #     finish  # => Time, when the instrumented block ended execution
+  #     id      # => String, unique ID for this notification
+  #     payload # => Hash, the payload
+  #   end
+  #
+  # For instance, let's store all "render" events in an array:
   #
   #   events = []
   #
-  #   ActiveSupport::Notifications.subscribe("render") do |*args|
+  #   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 is saved and will be called whenever someone instruments "render":
   #
-  #   ActiveSupport::Notifications.instrument("render", :extra => :information) do
-  #     render :text => "Foo"
+  #   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 }
+  #   event.payload   # => { extra: :information }
   #
   # The block in the <tt>subscribe</tt> call gets the name of the event, start
   # timestamp, end timestamp, a string with a unique identifier for that event
@@ -63,7 +75,7 @@ module ActiveSupport
   #   module ActionController
   #     class PageRequest
   #       def call(name, started, finished, unique_id, payload)
-  #         Rails.logger.debug ["notification:", name, started, finished, unique_id, payload].join(" ")
+  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
   #       end
   #     end
   #   end
@@ -73,15 +85,15 @@ module ActiveSupport
   # resulting in the following output within the logs including a hash with the payload:
   #
   #   notification: process_action.action_controller 2012-04-13 01:08:35 +0300 2012-04-13 01:08:35 +0300 af358ed7fab884532ec7 {
-  #      :controller=>"Devise::SessionsController",
-  #      :action=>"new",
-  #      :params=>{"action"=>"new", "controller"=>"devise/sessions"},
-  #      :format=>:html,
-  #      :method=>"GET",
-  #      :path=>"/login/sign_in",
-  #      :status=>200,
-  #      :view_runtime=>279.3080806732178,
-  #      :db_runtime=>40.053
+  #      controller: "Devise::SessionsController",
+  #      action: "new",
+  #      params: {"action"=>"new", "controller"=>"devise/sessions"},
+  #      format: :html,
+  #      method: "GET",
+  #      path: "/login/sign_in",
+  #      status: 200,
+  #      view_runtime: 279.3080806732178,
+  #      db_runtime: 40.053
   #    }
   #
   # You can also subscribe to all events whose name matches a certain regexp:
@@ -142,9 +154,9 @@ module ActiveSupport
         notifier.publish(name, *args)
       end
 
-      def instrument(name, payload = {}, &blk)
+      def instrument(name, payload = {})
         if notifier.listening?(name)
-          instrumenter.instrument(name, payload, &blk)
+          instrumenter.instrument(name, payload) { yield payload if block_given? }
         else
           yield payload if block_given?
         end
@@ -166,7 +178,27 @@ module ActiveSupport
       end
 
       def instrumenter
-        Thread.current[:"instrumentation_#{notifier.object_id}"] ||= Instrumenter.new(notifier)
+        InstrumentationRegistry.instrumenter_for(notifier)
+      end
+    end
+
+    # This class is a registry which holds all of the +Instrumenter+ objects
+    # in a particular thread local. To access the +Instrumenter+ object for a
+    # particular +notifier+, you can call the following method:
+    #
+    #   InstrumentationRegistry.instrumenter_for(notifier)
+    #
+    # The instrumenters for multiple notifiers are held in a single instance of
+    # this class.
+    class InstrumentationRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      def initialize
+        @registry = {}
+      end
+
+      def instrumenter_for(notifier)
+        @registry[notifier] ||= Instrumenter.new(notifier)
       end
     end
 

data/lib/skylight/{compat → vendor/active_support}/notifications/fanout.rb

@@ -1,4 +1,9 @@
 require 'mutex_m'
+begin
+  require 'thread_safe'
+rescue LoadError
+  require 'skylight/vendor/thread_safe'
+end
 
 module ActiveSupport
   module Notifications
@@ -11,7 +16,7 @@ module ActiveSupport
 
       def initialize
         @subscribers = []
-        @listeners_for = {}
+        @listeners_for = ThreadSafe::Cache.new
         super
       end
 
@@ -39,16 +44,14 @@ module ActiveSupport
         listeners_for(name).each { |s| s.finish(name, id, payload) }
       end
 
-      def measure(name, id, payload)
-        listeners_for(name).each { |s| s.measure(name, id, payload) }
-      end
-
       def publish(name, *args)
         listeners_for(name).each { |s| s.publish(name, *args) }
       end
 
       def listeners_for(name)
-        synchronize do
+        # this is correctly done double-checked locking (ThreadSafe::Cache's lookups have volatile semantics)
+        @listeners_for[name] || synchronize do
+          # use synchronisation when accessing @subscribers
           @listeners_for[name] ||= @subscribers.select { |s| s.subscribed_to?(name) }
         end
       end
@@ -63,12 +66,10 @@ module ActiveSupport
 
       module Subscribers # :nodoc:
         def self.new(pattern, listener)
-          if listener.respond_to?(:call)
-            subscriber = Timed.new pattern, listener
-          elsif listener.respond_to?(:measure)
+          if listener.respond_to?(:start) and listener.respond_to?(:finish)
             subscriber = Evented.new pattern, listener
           else
-            subscriber = LegacyEvented.new pattern, listener
+            subscriber = Timed.new pattern, listener
           end
 
           unless pattern
@@ -82,6 +83,13 @@ module ActiveSupport
           def initialize(pattern, delegate)
             @pattern = pattern
             @delegate = delegate
+            @can_publish = delegate.respond_to?(:publish)
+          end
+
+          def publish(name, *args)
+            if @can_publish
+              @delegate.publish name, *args
+            end
           end
 
           def start(name, id, payload)
@@ -92,10 +100,6 @@ module ActiveSupport
             @delegate.finish name, id, payload
           end
 
-          def measure(name, id, payload)
-            @delegate.measure(name, id, payload)
-          end
-
           def subscribed_to?(name)
             @pattern === name.to_s
           end
@@ -106,14 +110,7 @@ module ActiveSupport
           end
         end
 
-        class LegacyEvented < Evented
-          def measure(name, id, payload)
-            start(name, id, payload)
-            finish(name, id, payload)
-          end
-        end
-
-        class Timed < LegacyEvented
+        class Timed < Evented
           def initialize(pattern, delegate)
             @timestack = []
             super
@@ -146,10 +143,6 @@ module ActiveSupport
             @delegate.finish name, id, payload
           end
 
-          def measure(name, id, payload)
-            @delegate.measure name, id, payload
-          end
-
           def publish(name, *args)
             @delegate.publish name, *args
           end

data/lib/skylight/{compat → vendor/active_support}/notifications/instrumenter.rb

@@ -2,38 +2,45 @@ require 'securerandom'
 
 module ActiveSupport
   module Notifications
-    # Instrumentors are stored in a thread local.
+    # Instrumenters are stored in a thread local.
     class Instrumenter
       attr_reader :id
 
       def initialize(notifier)
-        @id = unique_id
+        @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
+      # in the passed-in block.
       def instrument(name, payload={})
-        if block_given?
-          @notifier.start(name, @id, payload)
-          begin
-            yield payload
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            raise e
-          ensure
-            @notifier.finish(name, @id, payload)
-          end
-        else
-          @notifier.measure(name, @id, payload)
+        start name, payload
+        begin
+          yield payload
+        rescue Exception => e
+          payload[:exception] = [e.class.name, e.message]
+          raise e
+        ensure
+          finish name, payload
         end
       end
 
+      # Send a start notification with +name+ and +payload+.
+      def start(name, payload)
+        @notifier.start name, @id, payload
+      end
+
+      # Send a finish notification with +name+ and +payload+.
+      def finish(name, payload)
+        @notifier.finish name, @id, payload
+      end
+
       private
-        def unique_id
-          SecureRandom.hex(10)
-        end
+
+      def unique_id
+        SecureRandom.hex(10)
+      end
     end
 
     class Event