skylight 1.7.2 → 2.0.0.beta1

data/lib/skylight/util/platform.rb

@@ -1,75 +0,0 @@
-require 'rbconfig'
-
-# Used from extconf and to load libskylight
-module Skylight
-  module Util
-    module Platform
-      # Normalize the platform OS
-      OS = case os = RbConfig::CONFIG['host_os'].downcase
-      when /linux/
-        # The official ruby-alpine Docker containers pre-build Ruby. As a result,
-        #   Ruby doesn't know that it's on a musl-based platform. `ldd` is the
-        #   only reliable way to detect musl that we've found.
-        # See https://github.com/skylightio/skylight-ruby/issues/92
-        if ENV['SKYLIGHT_MUSL'] || `ldd --version 2>&1` =~ /musl/
-          "linux-musl"
-        else
-          "linux"
-        end
-      when /darwin/
-        "darwin"
-      when /freebsd/
-        "freebsd"
-      when /netbsd/
-        "netbsd"
-      when /openbsd/
-        "openbsd"
-      when /sunos|solaris/
-        "solaris"
-      when /mingw|mswin/
-        "windows"
-      else
-        os
-      end
-
-      # Normalize the platform CPU
-      ARCH = case cpu = RbConfig::CONFIG['host_cpu'].downcase
-      when /amd64|x86_64/
-        "x86_64"
-      when /i?86|x86|i86pc/
-        "x86"
-      when /ppc|powerpc/
-        "powerpc"
-      when /^arm/
-        "arm"
-      else
-        cpu
-      end
-
-      LIBEXT = case OS
-      when /darwin/
-        'dylib'
-      when /linux|bsd|solaris/
-        'so'
-      when /windows|cygwin/
-        'dll'
-      else
-        'so'
-      end
-
-      TUPLE = "#{ARCH}-#{OS}"
-
-      def self.tuple
-        TUPLE
-      end
-
-      def self.libext
-        LIBEXT
-      end
-
-      def self.dlext
-        RbConfig::CONFIG['DLEXT']
-      end
-    end
-  end
-end

data/lib/skylight/util/proxy.rb

@@ -1,13 +0,0 @@
-module Skylight
-  module Util
-    module Proxy
-      def self.detect_url(env)
-        u = env['HTTP_PROXY'] || env['http_proxy']
-        if u && !u.empty?
-          u = "http://#{u}" unless u =~ %r[://]
-          u
-        end
-      end
-    end
-  end
-end

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

@@ -1,207 +0,0 @@
-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.
-  #
-  # == 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/vendor/active_support/notifications/fanout.rb

@@ -1,159 +0,0 @@
-require 'mutex_m'
-begin
-  require 'thread_safe'
-rescue LoadError
-  require 'skylight/vendor/thread_safe'
-end
-
-module ActiveSupport
-  module Notifications
-    # This is a default queue implementation that ships with Notifications.
-    # It just pushes events to all registered log subscribers.
-    #
-    # This class is thread safe. All methods are reentrant.
-    class Fanout
-      include Mutex_m
-
-      def initialize
-        @subscribers = []
-        @listeners_for = ThreadSafe::Cache.new
-        super
-      end
-
-      def subscribe(pattern = nil, block = Proc.new)
-        subscriber = Subscribers.new pattern, block
-        synchronize do
-          @subscribers << subscriber
-          @listeners_for.clear
-        end
-        subscriber
-      end
-
-      def unsubscribe(subscriber)
-        synchronize do
-          @subscribers.reject! { |s| s.matches?(subscriber) }
-          @listeners_for.clear
-        end
-      end
-
-      def start(name, id, payload)
-        listeners_for(name).each { |s| s.start(name, id, payload) }
-      end
-
-      def finish(name, id, payload)
-        listeners_for(name).each { |s| s.finish(name, id, payload) }
-      end
-
-      def publish(name, *args)
-        listeners_for(name).each { |s| s.publish(name, *args) }
-      end
-
-      def listeners_for(name)
-        # 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
-
-      def listening?(name)
-        listeners_for(name).any?
-      end
-
-      # This is a sync queue, so there is no waiting.
-      def wait
-      end
-
-      module Subscribers # :nodoc:
-        def self.new(pattern, listener)
-          if listener.respond_to?(:start) and listener.respond_to?(:finish)
-            subscriber = Evented.new pattern, listener
-          else
-            subscriber = Timed.new pattern, listener
-          end
-
-          unless pattern
-            AllMessages.new(subscriber)
-          else
-            subscriber
-          end
-        end
-
-        class Evented #:nodoc:
-          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)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def subscribed_to?(name)
-            @pattern === name.to_s
-          end
-
-          def matches?(subscriber_or_name)
-            self === subscriber_or_name ||
-              @pattern && @pattern === subscriber_or_name
-          end
-        end
-
-        class Timed < Evented
-          def initialize(pattern, delegate)
-            @timestack = []
-            super
-          end
-
-          def publish(name, *args)
-            @delegate.call name, *args
-          end
-
-          def start(name, id, payload)
-            @timestack.push Time.now
-          end
-
-          def finish(name, id, payload)
-            started = @timestack.pop
-            @delegate.call(name, started, Time.now, id, payload)
-          end
-        end
-
-        class AllMessages # :nodoc:
-          def initialize(delegate)
-            @delegate = delegate
-          end
-
-          def start(name, id, payload)
-            @delegate.start name, id, payload
-          end
-
-          def finish(name, id, payload)
-            @delegate.finish name, id, payload
-          end
-
-          def publish(name, *args)
-            @delegate.publish name, *args
-          end
-
-          def subscribed_to?(name)
-            true
-          end
-
-          alias :matches? :===
-        end
-      end
-    end
-  end
-end