logstash-output-scalyr 0.1.4 → 0.1.9

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb

@@ -1,38 +0,0 @@
-require 'concurrent/thread_safe/util'
-require 'concurrent/tuple'
-
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-
-      # @!visibility private
-      class PowerOfTwoTuple < Concurrent::Tuple
-
-        def initialize(size)
-          raise ArgumentError, "size must be a power of 2 (#{size.inspect} provided)" unless size > 0 && size & (size - 1) == 0
-          super(size)
-        end
-
-        def hash_to_index(hash)
-          (size - 1) & hash
-        end
-
-        def volatile_get_by_hash(hash)
-          volatile_get(hash_to_index(hash))
-        end
-
-        def volatile_set_by_hash(hash, value)
-          volatile_set(hash_to_index(hash), value)
-        end
-
-        def next_in_size_table
-          self.class.new(size << 1)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb

@@ -1,246 +0,0 @@
-require 'concurrent/thread_safe/util'
-require 'concurrent/thread_safe/util/power_of_two_tuple'
-require 'concurrent/thread_safe/util/volatile'
-require 'concurrent/thread_safe/util/xor_shift_random'
-
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-
-      # A Ruby port of the Doug Lea's jsr166e.Striped64 class version 1.6
-      # available in public domain.
-      #
-      # Original source code available here:
-      # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/Striped64.java?revision=1.6
-      #
-      # Class holding common representation and mechanics for classes supporting
-      # dynamic striping on 64bit values.
-      #
-      # This class maintains a lazily-initialized table of atomically updated
-      # variables, plus an extra +base+ field. The table size is a power of two.
-      # Indexing uses masked per-thread hash codes. Nearly all methods on this
-      # class are private, accessed directly by subclasses.
-      #
-      # Table entries are of class +Cell+; a variant of AtomicLong padded to
-      # reduce cache contention on most processors. Padding is overkill for most
-      # Atomics because they are usually irregularly scattered in memory and thus
-      # don't interfere much with each other. But Atomic objects residing in
-      # arrays will tend to be placed adjacent to each other, and so will most
-      # often share cache lines (with a huge negative performance impact) without
-      # this precaution.
-      #
-      # In part because +Cell+s are relatively large, we avoid creating them until
-      # they are needed. When there is no contention, all updates are made to the
-      # +base+ field. Upon first contention (a failed CAS on +base+ update), the
-      # table is initialized to size 2. The table size is doubled upon further
-      # contention until reaching the nearest power of two greater than or equal
-      # to the number of CPUS. Table slots remain empty (+nil+) until they are
-      # needed.
-      #
-      # A single spinlock (+busy+) is used for initializing and resizing the
-      # table, as well as populating slots with new +Cell+s. There is no need for
-      # a blocking lock: When the lock is not available, threads try other slots
-      # (or the base). During these retries, there is increased contention and
-      # reduced locality, which is still better than alternatives.
-      #
-      # Per-thread hash codes are initialized to random values. Contention and/or
-      # table collisions are indicated by failed CASes when performing an update
-      # operation (see method +retry_update+). Upon a collision, if the table size
-      # is less than the capacity, it is doubled in size unless some other thread
-      # holds the lock. If a hashed slot is empty, and lock is available, a new
-      # +Cell+ is created. Otherwise, if the slot exists, a CAS is tried. Retries
-      # proceed by "double hashing", using a secondary hash (XorShift) to try to
-      # find a free slot.
-      #
-      # The table size is capped because, when there are more threads than CPUs,
-      # supposing that each thread were bound to a CPU, there would exist a
-      # perfect hash function mapping threads to slots that eliminates collisions.
-      # When we reach capacity, we search for this mapping by randomly varying the
-      # hash codes of colliding threads. Because search is random, and collisions
-      # only become known via CAS failures, convergence can be slow, and because
-      # threads are typically not bound to CPUS forever, may not occur at all.
-      # However, despite these limitations, observed contention rates are
-      # typically low in these cases.
-      #
-      # It is possible for a +Cell+ to become unused when threads that once hashed
-      # to it terminate, as well as in the case where doubling the table causes no
-      # thread to hash to it under expanded mask. We do not try to detect or
-      # remove such cells, under the assumption that for long-running instances,
-      # observed contention levels will recur, so the cells will eventually be
-      # needed again; and for short-lived ones, it does not matter.
-      #
-      # @!visibility private
-      class Striped64
-
-        # Padded variant of AtomicLong supporting only raw accesses plus CAS.
-        # The +value+ field is placed between pads, hoping that the JVM doesn't
-        # reorder them.
-        #
-        # Optimisation note: It would be possible to use a release-only
-        # form of CAS here, if it were provided.
-        #
-        # @!visibility private
-        class Cell < Concurrent::AtomicReference
-
-          alias_method :cas, :compare_and_set
-
-          def cas_computed
-            cas(current_value = value, yield(current_value))
-          end
-
-          # @!visibility private
-          def self.padding
-            # TODO: this only adds padding after the :value slot, need to find a way to add padding before the slot
-            # TODO (pitr-ch 28-Jul-2018): the padding instance vars may not be created
-            # hide from yardoc in a method
-            attr_reader *(12.times.collect{ |i| "padding_#{i}".to_sym })
-          end
-          padding
-        end
-
-        extend Volatile
-        attr_volatile :cells, # Table of cells. When non-null, size is a power of 2.
-          :base,  # Base value, used mainly when there is no contention, but also as a fallback during table initialization races. Updated via CAS.
-          :busy   # Spinlock (locked via CAS) used when resizing and/or creating Cells.
-
-        alias_method :busy?, :busy
-
-        def initialize
-          super()
-          self.busy = false
-          self.base = 0
-        end
-
-        # Handles cases of updates involving initialization, resizing,
-        # creating new Cells, and/or contention. See above for
-        # explanation. This method suffers the usual non-modularity
-        # problems of optimistic retry code, relying on rechecked sets of
-        # reads.
-        #
-        # Arguments:
-        # [+x+]
-        #   the value
-        # [+hash_code+]
-        #   hash code used
-        # [+x+]
-        #   false if CAS failed before call
-        def retry_update(x, hash_code, was_uncontended) # :yields: current_value
-          hash     = hash_code
-          collided = false # True if last slot nonempty
-          while true
-            if current_cells = cells
-              if !(cell = current_cells.volatile_get_by_hash(hash))
-                if busy?
-                  collided = false
-                else # Try to attach new Cell
-                  if try_to_install_new_cell(Cell.new(x), hash) # Optimistically create and try to insert new cell
-                    break
-                  else
-                    redo # Slot is now non-empty
-                  end
-                end
-              elsif !was_uncontended # CAS already known to fail
-                was_uncontended = true # Continue after rehash
-              elsif cell.cas_computed {|current_value| yield current_value}
-                break
-              elsif current_cells.size >= CPU_COUNT || cells != current_cells # At max size or stale
-                collided = false
-              elsif collided && expand_table_unless_stale(current_cells)
-                collided = false
-                redo # Retry with expanded table
-              else
-                collided = true
-              end
-              hash = XorShiftRandom.xorshift(hash)
-
-            elsif try_initialize_cells(x, hash) || cas_base_computed {|current_base| yield current_base}
-              break
-            end
-          end
-          self.hash_code = hash
-        end
-
-        private
-        # Static per-thread hash code key. Shared across all instances to
-        # reduce Thread locals pollution and because adjustments due to
-        # collisions in one table are likely to be appropriate for
-        # others.
-        THREAD_LOCAL_KEY = "#{name}.hash_code".to_sym
-
-        # A thread-local hash code accessor. The code is initially
-        # random, but may be set to a different value upon collisions.
-        def hash_code
-          Thread.current[THREAD_LOCAL_KEY] ||= XorShiftRandom.get
-        end
-
-        def hash_code=(hash)
-          Thread.current[THREAD_LOCAL_KEY] = hash
-        end
-
-        # Sets base and all +cells+ to the given value.
-        def internal_reset(initial_value)
-          current_cells = cells
-          self.base     = initial_value
-          if current_cells
-            current_cells.each do |cell|
-              cell.value = initial_value if cell
-            end
-          end
-        end
-
-        def cas_base_computed
-          cas_base(current_base = base, yield(current_base))
-        end
-
-        def free?
-          !busy?
-        end
-
-        def try_initialize_cells(x, hash)
-          if free? && !cells
-            try_in_busy do
-              unless cells # Recheck under lock
-                new_cells = PowerOfTwoTuple.new(2)
-                new_cells.volatile_set_by_hash(hash, Cell.new(x))
-                self.cells = new_cells
-              end
-            end
-          end
-        end
-
-        def expand_table_unless_stale(current_cells)
-          try_in_busy do
-            if current_cells == cells # Recheck under lock
-              new_cells = current_cells.next_in_size_table
-              current_cells.each_with_index {|x, i| new_cells.volatile_set(i, x)}
-              self.cells = new_cells
-            end
-          end
-        end
-
-        def try_to_install_new_cell(new_cell, hash)
-          try_in_busy do
-            # Recheck under lock
-            if (current_cells = cells) && !current_cells.volatile_get(i = current_cells.hash_to_index(hash))
-              current_cells.volatile_set(i, new_cell)
-            end
-          end
-        end
-
-        def try_in_busy
-          if cas_busy(false, true)
-            begin
-              yield
-            ensure
-              self.busy = false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/thread_safe/util/volatile.rb

@@ -1,75 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-      
-      # @!visibility private
-      module Volatile
-
-        # Provides +volatile+ (in the JVM's sense) attribute accessors implemented
-        # atop of +Concurrent::AtomicReference+.
-        #
-        # Usage:
-        #   class Foo
-        #     extend Concurrent::ThreadSafe::Util::Volatile
-        #     attr_volatile :foo, :bar
-        #
-        #     def initialize(bar)
-        #       super() # must super() into parent initializers before using the volatile attribute accessors
-        #       self.bar = bar
-        #     end
-        #
-        #     def hello
-        #       my_foo = foo # volatile read
-        #       self.foo = 1 # volatile write
-        #       cas_foo(1, 2) # => true | a strong CAS
-        #     end
-        #   end
-        def attr_volatile(*attr_names)
-          return if attr_names.empty?
-          include(Module.new do
-            atomic_ref_setup = attr_names.map {|attr_name| "@__#{attr_name} = Concurrent::AtomicReference.new"}
-            initialize_copy_setup = attr_names.zip(atomic_ref_setup).map do |attr_name, ref_setup|
-              "#{ref_setup}(other.instance_variable_get(:@__#{attr_name}).get)"
-            end
-            class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def initialize(*)
-              super
-            #{atomic_ref_setup.join('; ')}
-            end
-
-            def initialize_copy(other)
-              super
-            #{initialize_copy_setup.join('; ')}
-            end
-            RUBY_EVAL
-
-            attr_names.each do |attr_name|
-              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-              def #{attr_name}
-                @__#{attr_name}.get
-              end
-
-              def #{attr_name}=(value)
-                @__#{attr_name}.set(value)
-              end
-
-              def compare_and_set_#{attr_name}(old_value, new_value)
-                @__#{attr_name}.compare_and_set(old_value, new_value)
-              end
-              RUBY_EVAL
-
-              alias_method :"cas_#{attr_name}", :"compare_and_set_#{attr_name}"
-              alias_method :"lazy_set_#{attr_name}", :"#{attr_name}="
-            end
-          end)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb

@@ -1,50 +0,0 @@
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-
-  # @!visibility private
-  module ThreadSafe
-
-    # @!visibility private
-    module Util
-
-      # A xorshift random number (positive +Fixnum+s) generator, provides
-      # reasonably cheap way to generate thread local random numbers without
-      # contending for the global +Kernel.rand+.
-      #
-      # Usage:
-      #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
-      #   while true
-      #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
-      #       do_something_at_random
-      #     end
-      #   end
-      module XorShiftRandom
-        extend self
-        MAX_XOR_SHIFTABLE_INT = MAX_INT - 1
-
-        # Generates an initial non-zero positive +Fixnum+ via +Kernel.rand+.
-        def get
-          Kernel.rand(MAX_XOR_SHIFTABLE_INT) + 1 # 0 can't be xorshifted
-        end
-
-        # xorshift based on: http://www.jstatsoft.org/v08/i14/paper
-        if 0.size == 4
-          # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (3,1,14) to minimise Bignum overflows
-          def xorshift(x)
-            x ^= x >> 3
-            x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
-            x ^= x >> 14
-          end
-        else
-          # using the "yˆ=y>>a; yˆ=y<<b; yˆ=y>>c;" transform with the (a,b,c) tuple with values (1,1,54) to minimise Bignum overflows
-          def xorshift(x)
-            x ^= x >> 1
-            x ^= (x << 1) & MAX_INT # cut-off Bignum overflow
-            x ^= x >> 54
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/timer_task.rb

@@ -1,334 +0,0 @@
-require 'concurrent/collection/copy_on_notify_observer_set'
-require 'concurrent/concern/dereferenceable'
-require 'concurrent/concern/observable'
-require 'concurrent/atomic/atomic_boolean'
-require 'concurrent/executor/executor_service'
-require 'concurrent/executor/ruby_executor_service'
-require 'concurrent/executor/safe_task_executor'
-require 'concurrent/scheduled_task'
-
-module Concurrent
-
-  # A very common concurrency pattern is to run a thread that performs a task at
-  # regular intervals. The thread that performs the task sleeps for the given
-  # interval then wakes up and performs the task. Lather, rinse, repeat... This
-  # pattern causes two problems. First, it is difficult to test the business
-  # logic of the task because the task itself is tightly coupled with the
-  # concurrency logic. Second, an exception raised while performing the task can
-  # cause the entire thread to abend. In a long-running application where the
-  # task thread is intended to run for days/weeks/years a crashed task thread
-  # can pose a significant problem. `TimerTask` alleviates both problems.
-  #
-  # When a `TimerTask` is launched it starts a thread for monitoring the
-  # execution interval. The `TimerTask` thread does not perform the task,
-  # however. Instead, the TimerTask launches the task on a separate thread.
-  # Should the task experience an unrecoverable crash only the task thread will
-  # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
-  # `TimerTask` thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. `TimerTask` can also be
-  # configured with a timeout value allowing it to kill a task that runs too
-  # long.
-  #
-  # One other advantage of `TimerTask` is that it forces the business logic to
-  # be completely decoupled from the concurrency logic. The business logic can
-  # be tested separately then passed to the `TimerTask` for scheduling and
-  # running.
-  #
-  # In some cases it may be necessary for a `TimerTask` to affect its own
-  # execution cycle. To facilitate this, a reference to the TimerTask instance
-  # is passed as an argument to the provided block every time the task is
-  # executed.
-  #
-  # The `TimerTask` class includes the `Dereferenceable` mixin module so the
-  # result of the last execution is always available via the `#value` method.
-  # Dereferencing options can be passed to the `TimerTask` during construction or
-  # at any later time using the `#set_deref_options` method.
-  #
-  # `TimerTask` supports notification through the Ruby standard library
-  # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
-  # Observable} module. On execution the `TimerTask` will notify the observers
-  # with three arguments: time of execution, the result of the block (or nil on
-  # failure), and any raised exceptions (or nil on success). If the timeout
-  # interval is exceeded the observer will receive a `Concurrent::TimeoutError`
-  # object as the third argument.
-  #
-  # @!macro copy_options
-  #
-  # @example Basic usage
-  #   task = Concurrent::TimerTask.new{ puts 'Boom!' }
-  #   task.execute
-  #
-  #   task.execution_interval #=> 60 (default)
-  #   task.timeout_interval   #=> 30 (default)
-  #
-  #   # wait 60 seconds...
-  #   #=> 'Boom!'
-  #
-  #   task.shutdown #=> true
-  #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
-  #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
-  #          puts 'Boom!'
-  #        end
-  #
-  #   task.execution_interval #=> 5
-  #   task.timeout_interval   #=> 5
-  #
-  # @example Immediate execution with `:run_now`
-  #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
-  #   task.execute
-  #
-  #   #=> 'Boom!'
-  #
-  # @example Last `#value` and `Dereferenceable` mixin
-  #   task = Concurrent::TimerTask.new(
-  #     dup_on_deref: true,
-  #     execution_interval: 5
-  #   ){ Time.now }
-  #
-  #   task.execute
-  #   Time.now   #=> 2013-11-07 18:06:50 -0500
-  #   sleep(10)
-  #   task.value #=> 2013-11-07 18:06:55 -0500
-  #
-  # @example Controlling execution from within the block
-  #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
-  #     print "\n"
-  #     task.execution_interval += 1
-  #     if task.execution_interval > 5
-  #       puts 'Stopping...'
-  #       task.shutdown
-  #     end
-  #   end
-  #
-  #   timer_task.execute # blocking call - this task will stop itself
-  #   #=> Boom!
-  #   #=> Boom! Boom!
-  #   #=> Boom! Boom! Boom!
-  #   #=> Boom! Boom! Boom! Boom!
-  #   #=> Boom! Boom! Boom! Boom! Boom!
-  #   #=> Stopping...
-  #
-  # @example Observation
-  #   class TaskObserver
-  #     def update(time, result, ex)
-  #       if result
-  #         print "(#{time}) Execution successfully returned #{result}\n"
-  #       elsif ex.is_a?(Concurrent::TimeoutError)
-  #         print "(#{time}) Execution timed out\n"
-  #       else
-  #         print "(#{time}) Execution failed with error #{ex}\n"
-  #       end
-  #     end
-  #   end
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ 42 }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #   sleep 4
-  #
-  #   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
-  #   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
-  #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
-  #   task.shutdown
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ sleep }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #
-  #   #=> (2013-10-13 19:07:25 -0400) Execution timed out
-  #   #=> (2013-10-13 19:07:27 -0400) Execution timed out
-  #   #=> (2013-10-13 19:07:29 -0400) Execution timed out
-  #   task.shutdown
-  #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1){ raise StandardError }
-  #   task.add_observer(TaskObserver.new)
-  #   task.execute
-  #
-  #   #=> (2013-10-13 19:09:37 -0400) Execution failed with error StandardError
-  #   #=> (2013-10-13 19:09:38 -0400) Execution failed with error StandardError
-  #   #=> (2013-10-13 19:09:39 -0400) Execution failed with error StandardError
-  #   task.shutdown
-  #
-  # @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
-  # @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
-  class TimerTask < RubyExecutorService
-    include Concern::Dereferenceable
-    include Concern::Observable
-
-    # Default `:execution_interval` in seconds.
-    EXECUTION_INTERVAL = 60
-
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
-
-    # Create a new TimerTask with the given task and configuration.
-    #
-    # @!macro timer_task_initialize
-    #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
-    #     task executions (default: EXECUTION_INTERVAL)
-    #   @option opts [Integer] :timeout_interval number of seconds a task can
-    #     run before it is considered to have failed (default: TIMEOUT_INTERVAL)
-    #   @option opts [Boolean] :run_now Whether to run the task immediately
-    #     upon instantiation or to wait until the first #  execution_interval
-    #     has passed (default: false)
-    #
-    #   @!macro deref_options
-    #
-    #   @raise ArgumentError when no block is given.
-    #
-    #   @yield to the block after :execution_interval seconds have passed since
-    #     the last yield
-    #   @yieldparam task a reference to the `TimerTask` instance so that the
-    #     block can control its own lifecycle. Necessary since `self` will
-    #     refer to the execution context of the block rather than the running
-    #     `TimerTask`.
-    #
-    #   @return [TimerTask] the new `TimerTask`
-    def initialize(opts = {}, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      super
-      set_deref_options opts
-    end
-
-    # Is the executor running?
-    #
-    # @return [Boolean] `true` when running, `false` when shutting down or shutdown
-    def running?
-      @running.true?
-    end
-
-    # Execute a previously created `TimerTask`.
-    #
-    # @return [TimerTask] a reference to `self`
-    #
-    # @example Instance and execute in separate steps
-    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }
-    #   task.running? #=> false
-    #   task.execute
-    #   task.running? #=> true
-    #
-    # @example Instance and execute in one line
-    #   task = Concurrent::TimerTask.new(execution_interval: 10){ print "Hello World\n" }.execute
-    #   task.running? #=> true
-    def execute
-      synchronize do
-        if @running.false?
-          @running.make_true
-          schedule_next_task(@run_now ? 0 : @execution_interval)
-        end
-      end
-      self
-    end
-
-    # Create and execute a new `TimerTask`.
-    #
-    # @!macro timer_task_initialize
-    #
-    # @example
-    #   task = Concurrent::TimerTask.execute(execution_interval: 10){ print "Hello World\n" }
-    #   task.running? #=> true
-    def self.execute(opts = {}, &task)
-      TimerTask.new(opts, &task).execute
-    end
-
-    # @!attribute [rw] execution_interval
-    # @return [Fixnum] Number of seconds after the task completes before the
-    #   task is performed again.
-    def execution_interval
-      synchronize { @execution_interval }
-    end
-
-    # @!attribute [rw] execution_interval
-    # @return [Fixnum] Number of seconds after the task completes before the
-    #   task is performed again.
-    def execution_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @execution_interval = value }
-      end
-    end
-
-    # @!attribute [rw] timeout_interval
-    # @return [Fixnum] Number of seconds the task can run before it is
-    #   considered to have failed.
-    def timeout_interval
-      synchronize { @timeout_interval }
-    end
-
-    # @!attribute [rw] timeout_interval
-    # @return [Fixnum] Number of seconds the task can run before it is
-    #   considered to have failed.
-    def timeout_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @timeout_interval = value }
-      end
-    end
-
-    private :post, :<<
-
-    private
-
-    def ns_initialize(opts, &task)
-      set_deref_options(opts)
-
-      self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
-      @run_now = opts[:now] || opts[:run_now]
-      @executor = Concurrent::SafeTaskExecutor.new(task)
-      @running = Concurrent::AtomicBoolean.new(false)
-      @value = nil
-
-      self.observers = Collection::CopyOnNotifyObserverSet.new
-    end
-
-    # @!visibility private
-    def ns_shutdown_execution
-      @running.make_false
-      super
-    end
-
-    # @!visibility private
-    def ns_kill_execution
-      @running.make_false
-      super
-    end
-
-    # @!visibility private
-    def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
-      nil
-    end
-
-    # @!visibility private
-    def execute_task(completion)
-      return nil unless @running.true?
-      ScheduledTask.execute(timeout_interval, args: [completion], &method(:timeout_task))
-      _success, value, reason = @executor.execute(self)
-      if completion.try?
-        self.value = value
-        schedule_next_task
-        time = Time.now
-        observers.notify_observers do
-          [time, self.value, reason]
-        end
-      end
-      nil
-    end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      if completion.try?
-        self.value = value
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
-  end
-end