skylight 0.3.21 → 0.4.0.alpha1

data/lib/skylight/metrics/process_mem_gauge.rb

@@ -1,34 +0,0 @@
-module Skylight
-  module Metrics
-    class ProcessMemGauge
-
-      def initialize(cache_for = 30, clock = Util::Clock.default)
-        @value = nil
-        @cache_for = cache_for
-        @last_check_at = 0
-        @clock = clock
-      end
-
-      def call(now = @clock.absolute_secs)
-        if !@value || should_check?(now)
-          @value = check
-          @last_check_at = now
-        end
-
-        @value
-      end
-
-    private
-
-      def check
-        `ps -o rss= -p #{Process.pid}`.to_i / 1024
-      rescue Errno::ENOENT, Errno::EINTR
-        0
-      end
-
-      def should_check?(now)
-        now >= @last_check_at + @cache_for
-      end
-    end
-  end
-end

data/lib/skylight/util/conversions.rb

@@ -1,9 +0,0 @@
-module Skylight
-  module Util
-    module Conversions
-      def secs_to_nanos(secs)
-        secs * 1_000_000_000
-      end
-    end
-  end
-end

data/lib/skylight/util/queue.rb

@@ -1,96 +0,0 @@
-require 'thread'
-
-module Skylight
-  module Util
-    # Simple thread-safe queue backed by a ring buffer. Will only block when
-    # poping. Single consumer only
-    class Queue
-
-      def initialize(max)
-        unless max > 0
-          raise ArgumentError, "queue size must be positive"
-        end
-
-        @max     = max
-        @values  = [nil] * max
-        @consume = 0
-        @produce = 0
-        @waiting = nil
-        @mutex   = Mutex.new
-      end
-
-      def empty?
-        @mutex.synchronize { __empty? }
-      end
-
-      def length
-        @mutex.synchronize { __length }
-      end
-
-      # Returns the number of items in the queue or nil if the queue is full
-      def push(obj)
-        ret = nil
-
-        @mutex.synchronize do
-          return if __length == @max
-          @values[@produce] = obj
-          @produce = (@produce + 1) % @max
-
-          ret = __length
-
-          # Wakeup a blocked thread
-          if t = @waiting
-            t.run rescue nil
-          end
-        end
-
-        ret
-      end
-
-      def pop(timeout = nil)
-        if timeout && timeout < 0
-          raise ArgumentError, "timeout must be nil or >= than 0"
-        end
-
-        @mutex.synchronize do
-          if __empty?
-            if !timeout || timeout > 0
-              return if @waiting
-              @waiting = Thread.current
-              begin
-                @mutex.sleep(timeout)
-              ensure
-                @waiting = nil
-              end
-            else
-              return
-            end
-          end
-
-          __pop unless __empty?
-        end
-      end
-
-    private
-
-      def __length
-        ((@produce - @consume) % @max)
-      end
-
-      def __empty?
-        @produce == @consume
-      end
-
-      def __pop
-        i = @consume
-        v = @values[i]
-
-        @values[i] = nil
-        @consume = (i + 1) % @max
-
-        return v
-      end
-
-    end
-  end
-end

data/lib/skylight/util/task.rb

@@ -1,172 +0,0 @@
-require 'thread'
-
-module Skylight
-  module Util
-    class Task
-      SHUTDOWN = :__SK_TASK_SHUTDOWN
-
-      # Requires the subclass to define `config`
-      include Util::Logging
-
-      attr_reader :queue_depth_metric
-
-      def initialize(size, timeout = 0.1, &blk)
-        @pid = Process.pid
-        @thread = nil
-        @size = size
-        @lock = Mutex.new
-        @timeout = timeout
-        @blk = blk
-
-        @queue_depth_metric = build_queue_depth_metric
-      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
-              prepare
-
-              unless work
-                @queue = nil
-              end
-
-              t { "shutting down task" }
-              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 prepare
-      end
-
-      def finish
-      end
-
-      def build_queue_depth_metric
-        lambda do
-          q = @queue
-          q ? @queue.length : 0
-        end
-      end
-
-    end
-  end
-end

data/lib/skylight/util/uniform_sample.rb

@@ -1,63 +0,0 @@
-module Skylight
-  module Util
-    class UniformSample
-      include Enumerable
-
-      attr_reader :size, :count
-
-      def initialize(size)
-        @size   = size
-        @count  = 0
-        @values = []
-      end
-
-      def clear
-        @count = 0
-        @values.clear
-        self
-      end
-
-      def length
-        @size < @count ? @size : @count
-      end
-
-      def empty?
-        @count == 0
-      end
-
-      def each
-        i  = 0
-        to = length
-
-        while i < to
-          yield @values[i]
-          i += 1
-        end
-
-        self
-      end
-
-      def <<(v)
-        if idx = increment!
-          @values[idx] = v
-        end
-
-        self
-      end
-
-    private
-
-      def increment!
-        c = (@count += 1)
-
-        if (c <= @size)
-          c - 1
-        else
-          r = rand(@count)
-          r if r < @size
-        end
-      end
-
-    end
-  end
-end

data/lib/skylight/worker.rb

@@ -1,19 +0,0 @@
-module Skylight
-  # @api private
-  module Worker
-
-    # === Constants
-    CHUNK_SIZE = 16 * 1024
-
-    # === Modules
-    autoload :Builder,         'skylight/worker/builder'
-    autoload :Collector,       'skylight/worker/collector'
-    autoload :Connection,      'skylight/worker/connection'
-    autoload :ConnectionSet,   'skylight/worker/connection_set'
-    autoload :Embedded,        'skylight/worker/embedded'
-    autoload :MetricsReporter, 'skylight/worker/metrics_reporter'
-    autoload :Server,          'skylight/worker/server'
-    autoload :Standalone,      'skylight/worker/standalone'
-
-  end
-end

data/lib/skylight/worker/builder.rb

@@ -1,73 +0,0 @@
-module Skylight
-  module Worker
-    class Builder
-      include Util::Logging
-
-      attr_reader :config
-
-      def initialize(config = Config.new)
-        if Hash === config
-          config = Config.new(config)
-        end
-
-        @config = config
-      end
-
-      def build
-        s = strategy.to_s
-
-        case s
-        when 'embedded'
-          trace "building embedded worker"
-          Embedded.new(Collector.build(config))
-        when 'standalone'
-          trace "building standalone worker"
-
-          unless config[:'agent.sockfile_path']
-            raise ConfigError, 'agent.sockfile_path required'
-          end
-
-          Standalone.new(
-            config,
-            lockfile,
-            server)
-        else
-          # We can assume that if it's unknown it's from the config
-          raise ConfigError, "unknown agent.strategy: `#{s}`"
-        end
-      end
-
-    private
-
-      def strategy
-        config.get(:'agent.strategy') || default_strategy
-      end
-
-      def default_strategy
-        ret = if jruby?
-          'embedded'
-        else
-          'standalone'
-        end
-
-        ret.downcase.strip
-      end
-
-      def lockfile
-        config.get(:'agent.lockfile') do
-          name = [ 'skylight', config.environment ].compact.join('-')
-          File.join(config[:'agent.sockfile_path'], "#{name}.pid")
-        end.to_s
-      end
-
-      def server
-        config.get(:'agent.server', Server)
-      end
-
-      def jruby?
-        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      end
-
-    end
-  end
-end