logstash-mixin-scheduler 1.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67978c6a1909fafc833c6b6ad0ea257274a7c6e9ae05dfd7c06e1a2b3d6820d0
+  data.tar.gz: cf0dada853778214e4bef783d356f921e0d153557912a6a00c787270decfaefe
+SHA512:
+  metadata.gz: db8106c162a7268c40c3bfde3f7ee888d002238a9081f94eb294fa23af97eb687502a7243fd79b4e12c006574324bc1815b114966af43e42d73a837c7a4e3816
+  data.tar.gz: 0caadfd21d2b8e49f51b2b77cc3858423b0ec7fb21ba5aeab0839e2c17d308de34ecdcdea93e26e15cbc09b4bfccc435f5a05182e93a34eac5f69c3b019247a2

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0
+  - Feat: a common scheduler interface [#1](https://github.com/logstash-plugins/logstash-mixin-scheduler/pull/1)

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2022 Elastic N.V. <http://www.elastic.co>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,50 @@
+# Scheduler Mixin
+
+[![Build Status](https://travis-ci.com/logstash-plugins/logstash-mixin-scheduler.svg?branch=main)](https://travis-ci.com/logstash-plugins/logstash-mixin-scheduler)
+
+
+## Usage
+
+1. Add this gem as a runtime dependency of your Logstash plugin's `gemspec`:
+
+    ~~~ ruby
+    Gem::Specification.new do |s|
+      # ...
+
+      s.add_runtime_dependency 'logstash-mixin-scheduler', '~> 1.0'
+    end
+    ~~~
+
+2. In your plugin code, require this library and include it into your plugin class
+   that already inherits `LogStash::Plugin`:
+
+    ~~~ ruby
+    require 'logstash/plugin_mixins/scheduler'
+
+    class LogStash::Inputs::Bar < Logstash::Inputs::Base
+
+      include LogStash::PluginMixins::Scheduler
+   
+      # Schedule of when to periodically run statement, in Cron format
+      # for example: "* * * * *" (execute query every minute, on the minute)
+      config :schedule, :validate => :string
+   
+      def run(queue)
+        if @schedule
+          scheduler.cron(@schedule) { serve_drinks(queue) }
+          scheduler.join
+        else
+          serve_drinks(queue)
+        end
+      end
+   
+      # def server_drinks ...
+   
+    end
+    ~~~
+
+## Development
+
+This gem:
+ - *MUST* remain API-stable at 1.x
+ - *MUST NOT* introduce additional runtime dependencies

data/lib/logstash/plugin_mixins/scheduler/rufus_impl.rb

@@ -0,0 +1,243 @@
+require 'rufus/scheduler'
+
+require 'logstash/util/loggable'
+
+module LogStash module PluginMixins module Scheduler module RufusImpl
+  # @private
+  class SchedulerAdapter
+    include SchedulerInterface
+
+    include LogStash::Util::Loggable
+
+    # @private
+    attr_reader :impl
+
+    def initialize(name, opts)
+      if name && !opts.key?(:thread_name)
+        opts[:thread_name] = name
+      end
+      opts[:max_work_threads] ||= 1
+      # amount the scheduler thread sleeps between checking whether jobs
+      # should trigger, default is 0.3 which is a bit too often ...
+      # in theory the cron expression '* * * * * *' supports running jobs
+      # every second but this is very rare, we could potentially go higher
+      opts[:frequency] ||= 1.0
+
+      logger = opts.delete(:logger) || self.logger
+      @impl = SchedulerImpl.new(opts, logger)
+    end
+
+    # @overload
+    def cron(schedule, opts = {}, &task); __schedule(:cron, schedule, opts, &task); end
+    # @overload
+    def every(period, opts = {}, &task); __schedule(:every, period, opts, &task); end
+    # @overload
+    def at(timestamp, opts = {}, &task); __schedule(:at, timestamp, opts, &task); end
+    # @overload
+    def in(delay, opts = {}, &task); __schedule(:in, delay, opts, &task); end
+    # @overload
+    def interval(interval, opts = {}, &task); __schedule(:interval, interval, opts, &task); end
+
+    # @overload
+    def release; @impl.shutdown end
+    # @overload
+    def release!; @impl.shutdown(:wait) end
+    # @overload
+    def running?; !@impl.down? end
+
+    # @overload
+    def join; @impl.join end
+
+    private
+
+    def __schedule(type, arg, opts, &task)
+      unless block_given?
+        raise ArgumentError, 'missing task - worker task to execute'
+      end
+      JobAdapter.new @impl.send(:"schedule_#{type}", arg, opts, &task)
+    end
+
+  end
+
+  # @private
+  class SchedulerImpl < ::Rufus::Scheduler
+
+    # Rufus::Scheduler >= 3.4 moved the Time impl into a gem EoTime = ::EtOrbi::EoTime`
+    # Rufus::Scheduler 3.1 - 3.3 using it's own Time impl `Rufus::Scheduler::ZoTime`
+    TimeImpl = defined?(::Rufus::Scheduler::EoTime) ? ::Rufus::Scheduler::EoTime :
+                   (defined?(::Rufus::Scheduler::ZoTime) ? ::Rufus::Scheduler::ZoTime : ::Time)
+
+    def initialize(opts, logger)
+      super(opts)
+      @_logger = logger
+    end
+
+    # @overload
+    def join
+      fail NotRunningError.new('cannot join scheduler that is not running') unless @thread
+      fail ThreadError.new('scheduler thread cannot join itself') if @thread == Thread.current
+      @thread.join # makes scheduler.join behavior consistent across 3.x versions
+    end
+
+    # @overload
+    def shutdown(opt=nil)
+      if @thread # do not fail when scheduler thread failed to start
+        super(opt)
+      else
+        @started_at = nil # bare minimum to look like the scheduler is down
+        # when the scheduler thread fails `@started_at = ...` might still be set
+      end
+    end
+
+    # @overload
+    def timeout_jobs
+      # Rufus relies on `Thread.list` which is a blocking operation and with many schedulers
+      # (and threads) within LS will have a negative impact on performance as scheduler
+      # threads will end up waiting to obtain the `Thread.list` lock.
+      #
+      # However, this isn't necessary we can easily detect whether there are any jobs
+      # that might need to timeout: only when `@opts[:timeout]` is set causes worker thread(s)
+      # to have a `Thread.current[:rufus_scheduler_timeout]` that is not nil
+      return unless @opts[:timeout]
+      super
+    end
+
+    # @overload
+    def work_threads(query = :all)
+      if query == :__all_no_cache__ # special case from JobDecorator#start_work_thread
+        @_work_threads = nil # when a new worker thread is being added reset
+        return super(:all)
+      end
+
+      # Gets executed every time a job is triggered, we're going to cache the
+      # worker threads for this scheduler (to avoid `Thread.list`) - they only
+      # change when a new thread is being started from #start_work_thread ...
+      work_threads = @_work_threads
+      if work_threads.nil?
+        work_threads = threads.select { |t| t[:rufus_scheduler_work_thread] }
+        @_work_threads = work_threads
+      end
+
+      case query
+      when :active then work_threads.select { |t| t[:rufus_scheduler_job] }
+      when :vacant then work_threads.reject { |t| t[:rufus_scheduler_job] }
+      else work_threads
+      end
+    end
+
+    # @overload
+    def on_error(job, err)
+      details = { exception: err.class, message: err.message, backtrace: err.backtrace }
+      details[:cause] = err.cause if err.cause
+
+      details[:now] = debug_format_time(TimeImpl.now)
+      details[:last_time] = (debug_format_time(job.last_time) rescue nil)
+      details[:next_time] = (debug_format_time(job.next_time) rescue nil)
+      details[:job] = job
+
+      details[:opts] = @opts
+      details[:started_at] = started_at
+      details[:thread] = thread.inspect
+      details[:jobs_size] = @jobs.size
+      details[:work_threads_size] = work_threads.size
+      details[:work_queue_size] = work_queue.size
+
+      logger.error("Scheduler intercepted an error:", details)
+
+    rescue => e
+      logger.error("Scheduler failed in #on_error #{e.inspect}")
+    end
+
+    def debug_format_time(time)
+      # EtOrbi::EoTime used by (newer) Rufus::Scheduler has to_debug_s https://git.io/JyiPj
+      time.respond_to?(:to_debug_s) ? time.to_debug_s : time.strftime("%Y-%m-%dT%H:%M:%S.%L")
+    end
+    private :debug_format_time
+
+    # @private helper used by JobDecorator
+    def work_thread_name_prefix
+      ( @opts[:thread_name] || "#{@thread_key}_scheduler" ) + '_worker-'
+    end
+
+    def logger; @_logger end
+    private :logger
+
+    protected
+
+    # @overload
+    def start
+      ret = super() # @thread[:name] = @opts[:thread_name] || "#{@thread_key}_scheduler"
+
+      # at least set thread.name for easier thread dump analysis
+      if @thread.is_a?(Thread) && @thread.respond_to?(:name=)
+        @thread.name = @thread[:name] if @thread[:name]
+      end
+
+      ret
+    end
+
+    # @overload
+    def do_schedule(job_type, t, callable, opts, return_job_instance, block)
+      job_or_id = super
+
+      job_or_id.extend JobDecorator if return_job_instance
+
+      job_or_id
+    end
+
+    module JobDecorator
+
+      def start_work_thread
+        prev_thread_count = @scheduler.work_threads.size
+
+        ret = super() # does not return Thread instance in 3.0
+
+        work_threads = @scheduler.work_threads(:__all_no_cache__)
+        while prev_thread_count == work_threads.size # very unlikely
+          Thread.pass
+          work_threads = @scheduler.work_threads(:__all_no_cache__)
+        end
+
+        work_thread_name_prefix = @scheduler.work_thread_name_prefix
+
+        work_threads.sort! do |t1, t2|
+          if t1[:name].nil?
+            t2[:name].nil? ? 0 : +1 # nils at the end
+          elsif t2[:name].nil?
+            t1[:name].nil? ? 0 : -1
+          else
+            t1[:name] <=> t2[:name]
+          end
+        end
+
+        work_threads.each_with_index do |thread, i|
+          unless thread[:name]
+            thread[:name] = "#{work_thread_name_prefix}#{sprintf('%02i', i)}"
+            thread.name = thread[:name] if thread.respond_to?(:name=)
+          end
+        end
+
+        ret
+      end
+
+    end
+    private_constant :JobDecorator
+
+  end
+
+  # @private
+  class JobAdapter
+    include JobInterface
+
+    # @private
+    attr_reader :impl
+
+    def initialize(job)
+      @impl = job
+    end
+
+    # @overload
+    def job_id; @impl.job_id end
+  end
+
+end end end end

data/lib/logstash/plugin_mixins/scheduler.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+require 'logstash/namespace'
+require 'logstash/plugin'
+require 'logstash/util/thread_safe_attributes'
+
+module LogStash
+  module PluginMixins
+    module Scheduler
+
+      extend LogStash::Util::ThreadSafeAttributes
+
+      ##
+      # @private
+      # @param base [Class]: a class that inherits `LogStash::Plugin`, typically one
+      #                      descending from one of the four plugin base classes
+      #                      (e.g., `LogStash::Inputs::Base`)
+      # @raise [ArgumentError]
+      # @return [void]
+      def self.included(base)
+        fail(ArgumentError, "`#{base}` must inherit LogStash::Plugin") unless base < LogStash::Plugin
+        instance_methods = base.instance_methods
+        base.send(:prepend, StopHook) if instance_methods.include?(:stop)
+        base.send(:prepend, CloseHook) if instance_methods.include?(:close)
+      end
+
+      # @private
+      module StopHook
+        def stop
+          release_scheduler! # wait till scheduler halts
+          super # plugin.stop
+        end
+      end
+      private_constant :StopHook
+
+      # @private
+      module CloseHook
+        def close
+          super # plugin.close
+          release_scheduler
+        end
+      end
+      private_constant :CloseHook
+
+      # def scheduler(); @_scheduler ||= new_scheduler({}) end
+      lazy_init_attr(:scheduler, variable: :@_scheduler) { start_scheduler({}) }
+
+      private
+
+      # Release jobs registered by the plugin from executing.
+      # This method executes from the plugin's #close method.
+      def release_scheduler
+        @_scheduler.release if @_scheduler
+      end
+
+      # Release jobs registered by the plugin from executing.
+      # This method executes from the plugin's #stop method.
+      # @note Might block until the scheduler operation completes!
+      def release_scheduler!
+        @_scheduler.release! if @_scheduler
+      end
+
+      # @param opts [Hash] scheduler options
+      # @return [SchedulerInterface] scheduler instance
+      def start_scheduler(opts, name: nil)
+        if name.nil?
+          unless self.class.name
+            raise ArgumentError, "can not generate a scheduler name for anonymous class: #{inspect}"
+          end
+          pipeline_id = (respond_to?(:execution_context) && execution_context&.pipeline_id) || 'main'
+          plugin_name = self.class.name.split('::').last # e.g. "jdbc"
+          name = "[#{pipeline_id}]|#{self.class.plugin_type}|#{plugin_name}|scheduler"
+          # thread naming convention: [psql1]|input|jdbc|scheduler
+        end
+        RufusImpl::SchedulerAdapter.new name, { logger: logger }.merge(opts)
+      end
+
+      # Scheduler interface usable by plugins.
+      module SchedulerInterface
+
+        # All scheduling methods return a `Scheduler::JobInterface`
+
+        # @return a job object which responds to a #job_id method
+        # @abstract
+        def cron(schedule, opts = {}, &task); fail NotImplementedError end
+        # @return a job object which responds to a #job_id method
+        # @abstract
+        def every(period, opts = {}, &task); fail NotImplementedError end
+        # @return a job object which responds to a #job_id method
+        # @abstract
+        def at(timestamp, opts = {}, &task); fail NotImplementedError end
+        # @return a job object which responds to a #job_id method
+        # @abstract
+        def in(delay, opts = {}, &task); fail NotImplementedError end
+        # @return a job object which responds to a #job_id method
+        # @abstract
+        def interval(interval, opts = {}, &task); fail NotImplementedError; end
+
+        # Blocks until _all_ jobs are joined, including jobs
+        # that are scheduled after this join has begun blocking.
+        # @abstract
+        def join; fail NotImplementedError end
+
+        # Release the scheduler:
+        #  - prevents additional jobs from being registered,
+        #  - and unschedules all future invocations of jobs previously registered
+        #
+        # This operation does not block until the scheduler stops executing jobs.
+        # @abstract
+        def release; fail NotImplementedError end
+
+        # Release the scheduler:
+        #  - prevents additional jobs from being registered,
+        #  - and unschedules all future invocations of jobs previously registered
+        #
+        # This operation attempts to WAIT until the scheduler operation completes (if supported).
+        # @abstract
+        def release!; release end
+
+        # Is this scheduler potentially executing our jobs.
+        #
+        # @abstract
+        # @see #release
+        def running?; fail NotImplementedError end
+
+      end
+
+      # Interface provided by a scheduled job.
+      module JobInterface
+
+        def job_id; fail NotImplementedError end
+
+      end
+
+    end
+  end
+end
+
+require 'logstash/plugin_mixins/scheduler/rufus_impl'

data/spec/logstash/plugin_mixins/scheduler/rufus_impl_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/plugin_mixins/scheduler"
+
+describe LogStash::PluginMixins::Scheduler::RufusImpl do
+
+  let(:name) { '[test]<jdbc_scheduler' }
+
+  let(:opts) do
+    { :max_work_threads => 2 }
+  end
+
+  subject(:scheduler) do
+    LogStash::PluginMixins::Scheduler::RufusImpl::SchedulerAdapter.new(name, opts)
+  end
+
+  after { scheduler.impl.shutdown }
+
+  it "sets scheduler thread name" do
+    expect( scheduler.impl.thread.name ).to include name
+  end
+
+  it "gets interrupted from join" do
+    scheduler.every('1s') { 42**1000 }
+    join_thread = Thread.start { scheduler.join }
+    sleep 1.1
+    expect(join_thread).to be_alive
+    expect(scheduler.impl.down?).to be false
+    scheduler.release
+    Thread.pass
+    expect(scheduler.impl.down?).to be true
+    sleep 0.1
+    try(10) { expect(join_thread).to_not be_alive }
+  end
+
+  it "gets interrupted from join (wait shutdown)" do
+    scheduler.cron('* * * * * *') { 42**1000 }
+    expect(scheduler.impl.down?).to be false
+    join_thread = Thread.start { scheduler.join }
+    sleep 1.1
+    expect(join_thread).to be_alive
+    scheduler.release!
+    expect(scheduler.impl.down?).to be true
+    sleep 0.1
+    try(10) { expect(join_thread).to_not be_alive }
+  end
+
+  context 'cron schedule' do
+
+    before do
+      scheduler.cron('* * * * * *') { sleep 1.25 } # every second
+    end
+
+    it "sets worker thread names" do
+      sleep 3.0
+      threads = scheduler.impl.work_threads
+      threads.sort! { |t1, t2| (t1.name || '') <=> (t2.name || '') }
+
+      expect( threads.size ).to eql 2
+      expect( threads.first.name ).to eql "#{name}_worker-00"
+      expect( threads.last.name ).to eql "#{name}_worker-01"
+    end
+
+  end
+
+  context 'every 1s' do
+
+    before do
+      scheduler.in('1s') { raise 'TEST' } # every second
+    end
+
+    it "logs errors handled" do
+      expect( scheduler.impl.send(:logger) ).to receive(:error).with /Scheduler intercepted an error/, hash_including(:message => 'TEST')
+      sleep 2.25
+    end
+
+  end
+
+  context 'work threads' do
+
+    let(:opts) { super().merge :max_work_threads => 3 }
+
+    let(:counter) { java.util.concurrent.atomic.AtomicLong.new(0) }
+
+    before do
+      scheduler.cron('* * * * * *') { counter.increment_and_get; sleep 3.25 } # every second
+    end
+
+    it "are working" do
+      sleep(0.05) while counter.get == 0
+      expect( scheduler.impl.work_threads.size ).to eql 1
+      sleep(0.05) while counter.get == 1
+      expect( scheduler.impl.work_threads.size ).to eql 2
+      sleep(0.05) while counter.get == 2
+      expect( scheduler.impl.work_threads.size ).to eql 3
+
+      sleep 1.25
+      expect( scheduler.impl.work_threads.size ).to eql 3
+      sleep 1.25
+      expect( scheduler.impl.work_threads.size ).to eql 3
+    end
+
+  end
+
+end

data/spec/logstash/plugin_mixins/scheduler_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/plugin_mixins/scheduler"
+
+module LogStash
+  module Inputs
+    class Foo < LogStash::Inputs::Base
+      include LogStash::PluginMixins::Scheduler
+      config_name 'foo'
+    end
+  end
+end
+
+module LogStash
+  module Filters
+    class Bar < LogStash::Inputs::Base
+      include LogStash::PluginMixins::Scheduler
+      config_name 'bar'
+    end
+  end
+end
+
+describe LogStash::PluginMixins::Scheduler do
+
+  subject(:mixin) { described_class }
+
+  context 'included into a class' do
+    context 'that does not inherit from `LogStash::Plugin`' do
+      let(:plugin_class) { Class.new }
+      it 'fails with an ArgumentError' do
+        expect do
+          plugin_class.send(:include, mixin)
+        end.to raise_error(ArgumentError, /LogStash::Plugin/)
+      end
+    end
+
+    [ LogStash::Inputs::Foo, LogStash::Filters::Bar ].each do |base_class|
+      context "#{base_class} plugin" do
+
+        let(:plugin_class) { base_class }
+
+        it 'works when mixin is includes and provides a scheduler method' do
+          plugin = plugin_class.new Hash.new
+          expect( plugin.scheduler ).to be_a LogStash::PluginMixins::Scheduler::SchedulerInterface
+        end
+
+        context 'hooks' do
+
+          let(:plugin) { plugin_class.new Hash.new }
+
+          it 'shuts-down the scheduler on close' do
+            scheduler = plugin.scheduler
+            expect( scheduler.running? ).to be true
+            plugin.do_close
+            expect( scheduler.running? ).to be false
+          end
+
+          it 'shuts-down the scheduler on stop' do
+            scheduler = plugin.scheduler
+            plugin.stop
+            expect( scheduler.running? ).to be false
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/logstash/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+require "logstash-core"

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: logstash-mixin-scheduler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: java
+authors:
+- Elastic
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.16'
+  name: logstash-core
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.16'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.9
+  name: rufus-scheduler
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.9
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: logstash-devutils
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: logstash-codec-plain
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description:
+email: info@elastic.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/logstash/plugin_mixins/scheduler.rb
+- lib/logstash/plugin_mixins/scheduler/rufus_impl.rb
+- spec/logstash/plugin_mixins/scheduler/rufus_impl_spec.rb
+- spec/logstash/plugin_mixins/scheduler_spec.rb
+- spec/logstash/spec_helper.rb
+homepage: https://github.com/logstash-plugins/logstash-mixin-scheduler
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Scheduler for Logstash plugins
+test_files:
+- spec/logstash/plugin_mixins/scheduler/rufus_impl_spec.rb
+- spec/logstash/plugin_mixins/scheduler_spec.rb
+- spec/logstash/spec_helper.rb