skylight-core 2.0.0.beta1

data/lib/skylight/core/vendor/active_support/notifications.rb

@@ -0,0 +1,207 @@
+require 'skylight/core/vendor/active_support/notifications/instrumenter'
+require 'skylight/core/vendor/active_support/notifications/fanout'
+require 'skylight/core/vendor/active_support/per_thread_registry'
+
+module ActiveSupport
+  # = Notifications
+  #
+  # <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'
+  #   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.
+  #
+  #   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|
+  #     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'
+  #   end
+  #
+  #   event = events.first
+  #   event.name      # => "render"
+  #   event.duration  # => 10 (in milliseconds)
+  #   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
+  # (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 <tt>:exception</tt> 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 <tt>ActiveSupport::Notifications::Event</tt>
+  # is able to take the arguments as they come and provide an object-oriented
+  # interface to that data.
+  #
+  # It is also possible to pass an object as the second parameter passed to the
+  # <tt>subscribe</tt> method instead of a block:
+  #
+  #   module ActionController
+  #     class PageRequest
+  #       def call(name, started, finished, unique_id, payload)
+  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
+  #       end
+  #     end
+  #   end
+  #
+  #   ActiveSupport::Notifications.subscribe('process_action.action_controller', ActionController::PageRequest.new)
+  #
+  # 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
+  #    }
+  #
+  # 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 <tt>subscribe</tt>, 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
+    class << self
+      attr_accessor :notifier
+
+      def publish(name, *args)
+        notifier.publish(name, *args)
+      end
+
+      def instrument(name, payload = {})
+        if notifier.listening?(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)
+      end
+
+      def subscribed(callback, *args, &block)
+        subscriber = subscribe(*args, &callback)
+        yield
+      ensure
+        unsubscribe(subscriber)
+      end
+
+      def unsubscribe(args)
+        notifier.unsubscribe(args)
+      end
+
+      def instrumenter
+        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
+
+    self.notifier = Fanout.new
+  end
+end

data/lib/skylight/core/vendor/active_support/per_thread_registry.rb

@@ -0,0 +1,52 @@
+module ActiveSupport
+  # This module is used to encapsulate access to thread local variables.
+  #
+  # Instead of polluting the thread locals namespace:
+  #
+  #   Thread.current[:connection_handler]
+  #
+  # you define a class that extends this module:
+  #
+  #   module ActiveRecord
+  #     class RuntimeRegistry
+  #       extend ActiveSupport::PerThreadRegistry
+  #
+  #       attr_accessor :connection_handler
+  #     end
+  #   end
+  #
+  # and invoke the declared instance accessors as class methods. So
+  #
+  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
+  #
+  # sets a connection handler local to the current thread, and
+  #
+  #   ActiveRecord::RuntimeRegistry.connection_handler
+  #
+  # returns a connection handler local to the current thread.
+  #
+  # This feature is accomplished by instantiating the class and storing the
+  # instance as a thread local keyed by the class name. In the example above
+  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
+  # The class methods proxy to said thread local instance.
+  #
+  # If the class has an initializer, it must accept no arguments.
+  module PerThreadRegistry
+    protected
+
+      def method_missing(name, *args, &block) # :nodoc:
+        # Caches the method definition as a singleton method of the receiver.
+        define_singleton_method(name) do |*a, &b|
+          per_thread_registry_instance.public_send(name, *a, &b)
+        end
+
+        send(name, *args, &block)
+      end
+
+    private
+
+      def per_thread_registry_instance
+        Thread.current[name] ||= new
+      end
+  end
+end

data/lib/skylight/core/vendor/thread_safe/non_concurrent_cache_backend.rb

@@ -0,0 +1,133 @@
+module ThreadSafe
+  class NonConcurrentCacheBackend
+    # WARNING: all public methods of the class must operate on the @backend directly without calling each other. This is important
+    # because of the SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance reasons.
+    def initialize(options = nil)
+      @backend = {}
+    end
+
+    def [](key)
+      @backend[key]
+    end
+
+    def []=(key, value)
+      @backend[key] = value
+    end
+
+    def compute_if_absent(key)
+      if NULL != (stored_value = @backend.fetch(key, NULL))
+        stored_value
+      else
+        @backend[key] = yield
+      end
+    end
+
+    def replace_pair(key, old_value, new_value)
+      if pair?(key, old_value)
+        @backend[key] = new_value
+        true
+      else
+        false
+      end
+    end
+
+    def replace_if_exists(key, new_value)
+      if NULL != (stored_value = @backend.fetch(key, NULL))
+        @backend[key] = new_value
+        stored_value
+      end
+    end
+
+    def compute_if_present(key)
+      if NULL != (stored_value = @backend.fetch(key, NULL))
+        store_computed_value(key, yield(stored_value))
+      end
+    end
+
+    def compute(key)
+      store_computed_value(key, yield(@backend[key]))
+    end
+
+    def merge_pair(key, value)
+      if NULL == (stored_value = @backend.fetch(key, NULL))
+        @backend[key] = value
+      else
+        store_computed_value(key, yield(stored_value))
+      end
+    end
+
+    def get_and_set(key, value)
+      stored_value = @backend[key]
+      @backend[key] = value
+      stored_value
+    end
+
+    def key?(key)
+      @backend.key?(key)
+    end
+
+    def value?(value)
+      @backend.value?(value)
+    end
+
+    def delete(key)
+      @backend.delete(key)
+    end
+
+    def delete_pair(key, value)
+      if pair?(key, value)
+        @backend.delete(key)
+        true
+      else
+        false
+      end
+    end
+
+    def clear
+      @backend.clear
+      self
+    end
+
+    def each_pair
+      dupped_backend.each_pair do |k, v|
+        yield k, v
+      end
+      self
+    end
+
+    def size
+      @backend.size
+    end
+
+    def get_or_default(key, default_value)
+      @backend.fetch(key, default_value)
+    end
+
+    alias_method :_get, :[]
+    alias_method :_set, :[]=
+    private :_get, :_set
+    private
+    def initialize_copy(other)
+      super
+      @backend = {}
+      self
+    end
+
+    def dupped_backend
+      @backend.dup
+    end
+
+    def pair?(key, expected_value)
+      NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value)
+    end
+
+    def store_computed_value(key, new_value)
+      if new_value.nil?
+        @backend.delete(key)
+        nil
+      else
+        @backend[key] = new_value
+      end
+    end
+  end
+end

data/lib/skylight/core/vendor/thread_safe/synchronized_cache_backend.rb

@@ -0,0 +1,76 @@
+module ThreadSafe
+  class SynchronizedCacheBackend < NonConcurrentCacheBackend
+    require 'mutex_m'
+    include Mutex_m
+    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are not allowed to call each other.
+
+    def [](key)
+      synchronize { super }
+    end
+
+    def []=(key, value)
+      synchronize { super }
+    end
+
+    def compute_if_absent(key)
+      synchronize { super }
+    end
+
+    def compute_if_present(key)
+      synchronize { super }
+    end
+
+    def compute(key)
+      synchronize { super }
+    end
+
+    def merge_pair(key, value)
+      synchronize { super }
+    end
+
+    def replace_pair(key, old_value, new_value)
+      synchronize { super }
+    end
+
+    def replace_if_exists(key, new_value)
+      synchronize { super }
+    end
+
+    def get_and_set(key, value)
+      synchronize { super }
+    end
+
+    def key?(key)
+      synchronize { super }
+    end
+
+    def value?(value)
+      synchronize { super }
+    end
+
+    def delete(key)
+      synchronize { super }
+    end
+
+    def delete_pair(key, value)
+      synchronize { super }
+    end
+
+    def clear
+      synchronize { super }
+    end
+
+    def size
+      synchronize { super }
+    end
+
+    def get_or_default(key, default_value)
+      synchronize { super }
+    end
+
+    private
+    def dupped_backend
+      synchronize { super }
+    end
+  end
+end

data/lib/skylight/core/vendor/thread_safe.rb

@@ -0,0 +1,126 @@
+require 'thread'
+
+module ThreadSafe
+  autoload :NonConcurrentCacheBackend, 'skylight/core/vendor/thread_safe/non_concurrent_cache_backend'
+  autoload :SynchronizedCacheBackend,  'skylight/core/vendor/thread_safe/synchronized_cache_backend'
+
+  ConcurrentCacheBackend = SynchronizedCacheBackend
+
+  class Cache < ConcurrentCacheBackend
+    KEY_ERROR = defined?(KeyError) ? KeyError : IndexError # there is no KeyError in 1.8 mode
+
+    def initialize(options = nil, &block)
+      if options.kind_of?(::Hash)
+        validate_options_hash!(options)
+      else
+        options = nil
+      end
+
+      super(options)
+      @default_proc = block
+    end
+
+    def [](key)
+      if value = super
+        value
+      elsif @default_proc && !key?(key)
+        @default_proc.call(self, key)
+      else
+        value
+      end
+    end
+
+    def fetch(key, default_value = NULL)
+      if NULL != (value = get_or_default(key, NULL))
+        value
+      elsif block_given?
+        yield key
+      elsif NULL != default_value
+        default_value
+      else
+        raise KEY_ERROR, 'key not found'
+      end
+    end
+
+    def put_if_absent(key, value)
+      computed = false
+      result = compute_if_absent(key) do
+        computed = true
+        value
+      end
+      computed ? nil : result
+    end unless method_defined?(:put_if_absent)
+
+    def value?(value)
+      each_value do |v|
+        return true if value.equal?(v)
+      end
+      false
+    end unless method_defined?(:value?)
+
+    def keys
+      arr = []
+      each_pair {|k, v| arr << k}
+      arr
+    end unless method_defined?(:keys)
+
+    def values
+      arr = []
+      each_pair {|k, v| arr << v}
+      arr
+    end unless method_defined?(:values)
+
+    def each_key
+      each_pair {|k, v| yield k}
+    end unless method_defined?(:each_key)
+
+    def each_value
+      each_pair {|k, v| yield v}
+    end unless method_defined?(:each_value)
+
+    def empty?
+      each_pair {|k, v| return false}
+      true
+    end unless method_defined?(:empty?)
+
+    def size
+      count = 0
+      each_pair {|k, v| count += 1}
+      count
+    end unless method_defined?(:size)
+
+    def marshal_dump
+      raise TypeError, "can't dump hash with default proc" if @default_proc
+      h = {}
+      each_pair {|k, v| h[k] = v}
+      h
+    end
+
+    def marshal_load(hash)
+      initialize
+      populate_from(hash)
+    end
+
+    undef :freeze
+
+    private
+    def initialize_copy(other)
+      super
+      populate_from(other)
+    end
+
+    def populate_from(hash)
+      hash.each_pair {|k, v| self[k] = v}
+      self
+    end
+
+    def validate_options_hash!(options)
+      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Fixnum) || initial_capacity < 0)
+        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
+      end
+      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
+        raise ArgumentError, ":load_factor must be a number between 0 and 1"
+      end
+    end
+  end
+end

data/lib/skylight/core/version.rb

@@ -0,0 +1,6 @@
+module Skylight
+  module Core
+    VERSION = '2.0.0-beta1'
+  end
+end
+

data/lib/skylight/core/vm/gc.rb

@@ -0,0 +1,70 @@
+
+module Skylight::Core
+  # @api private
+  module VM
+    if defined?(JRUBY_VERSION)
+
+      # This doesn't quite work as we would like it. I believe that the GC
+      # statistics includes time that is not stop-the-world, this does not
+      # necessarily take time away from the application.
+      #
+      # require 'java'
+      # class GC
+      #   def initialize
+      #     @factory = Java::JavaLangManagement::ManagementFactory
+      #   end
+      #
+      #   def enable
+      #   end
+      #
+      #   def total_time
+      #     res = 0.0
+      #
+      #     @factory.garbage_collector_mx_beans.each do |mx|
+      #       res += (mx.collection_time.to_f / 1_000.0)
+      #     end
+      #
+      #     res
+      #   end
+      # end
+
+    elsif defined?(::GC::Profiler)
+
+      class GC
+        def initialize
+          @total = 0
+        end
+
+        def enable
+          ::GC::Profiler.enable
+        end
+
+        def total_time
+          # Reported in seconds
+          run = (::GC::Profiler.total_time * 1_000_000).to_i
+
+          if run > 0
+            ::GC::Profiler.clear
+          end
+
+          @total += run
+        end
+      end
+
+    end
+
+    # Fallback
+    unless defined?(VM::GC)
+
+      class GC
+        def enable
+        end
+
+        def total_time
+          0
+        end
+      end
+
+    end
+  end
+end