logstash-integration-jdbc 5.2.6 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9cc41a07a8cb2f7e4b9a6993dd4d0cd69761b3fa95ba81238d0dd6267367311
-  data.tar.gz: 32866a340d87d91734586b3324a1349437abc624deb6ff9883ab998b0a4524a6
+  metadata.gz: 28cba197157488c1839fc9a948c3f27916b26af07f28c592f537434bd84722a6
+  data.tar.gz: fe2263ea7ed36abdeb9fd3d9597958724be77a8653950e9d554a212c1e3dd106
 SHA512:
-  metadata.gz: b3513ba2d9ade38a829ec0b0c47ad6c0978d0256e03fb4ac26e136a064db65b08a19b7ee8dd7dabe26851739877b82f0f9a550b2328473b8ffd62f194d569ebb
-  data.tar.gz: bf71a208f07bc00c213724cbcf175a9ede2f87bf4eaf85a926ee8e9f87b322e2dd79164db1db84ec60633a0b1cfa961e8fc6d3889c8ca25ea220fa437285af5d
+  metadata.gz: 76543ead6834631efaca25d154abe7ee7594943dff0c27d90e7588ed3aa651de427fc3372cffac348f6f810f11cfe13864d8f26af7d09fd34470491a6a4c66b3
+  data.tar.gz: de71ae5f8c54dfa08d67e1e848e59fc1779477c41246cee120debf633301829e931b7103546de0bef482002eb7b5296b748d6ad6caf0bb5457abe7205db79b6e

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 5.4.0
+  - Ambiguous Timestamp Support [#92](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/92)
+    - FIX: when encountering an ambiguous timestamp, the JDBC Input no longer crashes
+    - Added support for disambiguating timestamps in daylight saving time (DST) overlap periods
+
+## 5.3.0
+  - Refactor: start using scheduler mixin [#110](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/110)
+
 ## 5.2.6
   - Fix: change default path of 'last_run_metadata_path' to be rooted in the LS data.path folder and not in $HOME [#106](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/106)
 

data/docs/filter-jdbc_streaming.asciidoc

@@ -21,7 +21,7 @@ include::{include_path}/plugin_header-integration.asciidoc[]
 
 ==== Description
 
-This filter executes a SQL query and store the result set in the field
+This filter executes a SQL query and stores the result set in the field
 specified as `target`.
 It will cache the results locally in an LRU cache with expiry.
 

data/docs/input-jdbc.asciidoc

@@ -286,10 +286,14 @@ JDBC connection string
 ===== `jdbc_default_timezone`
 
   * Value type is <<string,string>>
+  ** Value should be a canonical timezone or offset, such as `Europe/Paris` or `Etc/GMT+3`
+  ** Value _may_ include square-bracketed extensions, such as `America/Denver[dst_enabled_on_overlap:true]`
   * There is no default value for this setting.
 
-Timezone conversion.
-Logstash (and Elasticsearch) expects that timestamps are expressed in UTC terms.
+[id="plugins-{type}s-{plugin}-jdbc_timezone_conv"]
+====== Timezone conversion
+
+Logstash and Elasticsearch expect timestamps to be expressed in UTC terms.
 If your database has recorded timestamps that are relative to another timezone,
 the database timezone if you will, then set this setting to be the timezone that
 the database is using. However, as SQL does not allow for timezone data in
@@ -299,7 +303,15 @@ in relative UTC time in ISO8601 format.
 
 Using this setting will manually assign a specified timezone offset, instead
 of using the timezone setting of the local machine.  You must use a canonical
-timezone, *America/Denver*, for example.
+timezone, `America/Denver`, for example.
+
+[id="plugins-{type}s-{plugin}-jdbc_ambiguous_timestamps"]
+===== Ambiguous timestamps
+
+While it is common to store local times in SQL's timestamp column type, many timezones change their offset during the course of a calendar year and therefore cannot be used with SQL's timestamp type to represent an ordered, continuous timeline.
+For example in the `America/Chicago` zone when daylight saving time (DST) ends in the autumn, the clock rolls from `01:59:59` back to `01:00:00`, making any timestamp in the 2-hour period between `01:00:00CDT` and `02:00:00CST` on that day ambiguous.
+
+When encountering an ambiguous timestamp caused by a DST transition, the query will fail unless the timezone specified here includes a square-bracketed instruction for how to handle overlapping periods (such as: `America/Chicago[dst_enabled_on_overlap:true]` or `Australia/Melbourne[dst_enabled_on_overlap:false]`).
 
 [id="plugins-{type}s-{plugin}-plugin_timezone"]
 ===== `plugin_timezone`

data/lib/logstash/filters/jdbc_static.rb

@@ -3,7 +3,7 @@ require "logstash-integration-jdbc_jars"
 require "logstash/filters/base"
 require "logstash/namespace"
 require "logstash/plugin_mixins/ecs_compatibility_support"
-require "logstash/plugin_mixins/jdbc/scheduler"
+require "logstash/plugin_mixins/scheduler"
 require_relative "jdbc/loader"
 require_relative "jdbc/loader_schedule"
 require_relative "jdbc/repeating_load_runner"
@@ -19,6 +19,8 @@ module LogStash module Filters class JdbcStatic < LogStash::Filters::Base
   # adds ecs_compatibility config which could be :disabled or :v1
   include LogStash::PluginMixins::ECSCompatibilitySupport(:disabled, :v1, :v8 => :v1)
 
+  include LogStash::PluginMixins::Scheduler
+
   config_name "jdbc_static"
 
   # Define the loaders, an Array of Hashes, to fetch remote data and create local tables.
@@ -162,7 +164,6 @@ module LogStash module Filters class JdbcStatic < LogStash::Filters::Base
   end
 
   def close
-    @scheduler.stop if @scheduler
     @parsed_loaders.each(&:close)
     @processor.close
   end
@@ -208,13 +209,7 @@ module LogStash module Filters class JdbcStatic < LogStash::Filters::Base
     if @loader_schedule
       @loader_runner = Jdbc::RepeatingLoadRunner.new(*runner_args)
       @loader_runner.initial_load
-      @scheduler = LogStash::PluginMixins::Jdbc::Scheduler.
-          start_cron_scheduler(@loader_schedule, thread_name: "[#{id}]-jdbc_static__scheduler") { @loader_runner.repeated_load }
-      cron_job = @scheduler.cron_jobs.first
-      if cron_job
-        frequency = cron_job.respond_to?(:rough_frequency) ? cron_job.rough_frequency : cron_job.frequency
-        logger.info("Loaders will execute every #{frequency} seconds", loader_schedule: @loader_schedule)
-      end
+      scheduler.cron(@loader_schedule) { @loader_runner.repeated_load }
     else
       @loader_runner = Jdbc::SingleLoadRunner.new(*runner_args)
       @loader_runner.initial_load

data/lib/logstash/inputs/jdbc.rb

@@ -3,12 +3,11 @@ require "logstash/inputs/base"
 require "logstash/namespace"
 require "logstash/plugin_mixins/jdbc/common"
 require "logstash/plugin_mixins/jdbc/jdbc"
-require "logstash/plugin_mixins/jdbc/scheduler"
 require "logstash/plugin_mixins/ecs_compatibility_support"
 require "logstash/plugin_mixins/ecs_compatibility_support/target_check"
 require "logstash/plugin_mixins/validator_support/field_reference_validation_adapter"
-
 require "logstash/plugin_mixins/event_support/event_factory_adapter"
+require "logstash/plugin_mixins/scheduler"
 require "fileutils"
 
 # this require_relative returns early unless the JRuby version is between 9.2.0.0 and 9.2.8.0
@@ -147,6 +146,8 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   # adds :field_reference validator adapter
   extend LogStash::PluginMixins::ValidatorSupport::FieldReferenceValidationAdapter
 
+  include LogStash::PluginMixins::Scheduler
+
   config_name "jdbc"
 
   # If undefined, Logstash will complain, even if codec is unused.
@@ -260,7 +261,6 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
       end
     end
 
-    require "rufus/scheduler"
     prepare_jdbc_connection
 
     if @use_column_value
@@ -319,22 +319,16 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   def run(queue)
     load_driver
     if @schedule
-      # input thread (Java) name example "[my-oracle]<jdbc"
-      @scheduler = LogStash::PluginMixins::Jdbc::Scheduler.
-          start_cron_scheduler(@schedule, thread_name: "[#{id}]<jdbc__scheduler") { execute_query(queue) }
-      @scheduler.join
+      # scheduler input thread name example: "[my-oracle]|input|jdbc|scheduler"
+      scheduler.cron(@schedule) { execute_query(queue) }
+      scheduler.join
     else
       execute_query(queue)
     end
   end # def run
 
-  def close
-    @scheduler.shutdown if @scheduler
-  end
-
   def stop
     close_jdbc_connection
-    @scheduler.shutdown(:wait) if @scheduler
   end
 
   private

data/lib/logstash/plugin_mixins/jdbc/jdbc.rb

@@ -4,6 +4,7 @@ require "logstash/config/mixin"
 require "time"
 require "date"
 require_relative "value_tracking"
+require_relative "timezone_proxy"
 require_relative "statement_handler"
 
 java_import java.util.concurrent.locks.ReentrantLock
@@ -82,7 +83,8 @@ module LogStash  module PluginMixins module Jdbc
       # Using this setting will manually assign a specified timezone offset, instead
       # of using the timezone setting of the local machine.  You must use a canonical
       # timezone, *America/Denver*, for example.
-      config :jdbc_default_timezone, :validate => :string
+      config :jdbc_default_timezone, :validate => :jdbc_timezone_spec
+      extend TimezoneProxy::JDBCTimezoneSpecValidator
 
       # General/Vendor-specific Sequel configuration options.
       #
@@ -157,7 +159,7 @@ module LogStash  module PluginMixins module Jdbc
       @database.extension(:pagination)
       if @jdbc_default_timezone
         @database.extension(:named_timezones)
-        @database.timezone = @jdbc_default_timezone
+        @database.timezone = TimezoneProxy.load(@jdbc_default_timezone)
       end
       if @jdbc_validate_connection
         @database.extension(:connection_validator)
@@ -218,7 +220,10 @@ module LogStash  module PluginMixins module Jdbc
           yield extract_values_from(row)
         end
         success = true
-      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseError, Java::JavaSql::SQLException => e
+      rescue Sequel::DatabaseConnectionError,
+             Sequel::DatabaseError,
+             Sequel::InvalidValue,
+             Java::JavaSql::SQLException => e
         details = { exception: e.class, message: e.message }
         details[:cause] = e.cause.inspect if e.cause
         details[:backtrace] = e.backtrace if @logger.debug?

data/lib/logstash/plugin_mixins/jdbc/timezone_proxy.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'tzinfo'
+
+module LogStash module PluginMixins module Jdbc
+  ##
+  # This `TimezoneProxy` allows timezone specs to include extensions indicating preference for ambiguous handling.
+  # @see TimezoneProxy::parse
+  module TimezoneProxy
+    ##
+    # @param timezone_spec [String]: a timezone spec, consisting of any valid timezone identifier
+    #                                followed by square-bracketed extensions. Currently-supported
+    #                                extensions are:
+    #                                `dst_enabled_on_overlap:(true|false)`: when encountering an ambiguous time
+    #                                                                       due to daylight-savings transition,
+    #                                                                       assume DST to be either enabled or
+    #                                                                       disabled instead of raising an
+    #                                                                       AmbiguousTime exception
+    # @return [TZInfo::Timezone]
+    def self.load(timezone_spec)
+      # re-load pass-through
+      return timezone_spec if timezone_spec.kind_of?(::TZInfo::Timezone)
+
+      parsed_spec = /\A(?<name>[^\[]+)(\[(?<extensions>[^\]]*)\])?\z/.match(timezone_spec)
+
+      timezone = ::TZInfo::Timezone.get(parsed_spec[:name])
+      return timezone unless parsed_spec[:extensions]
+
+      parsed_spec[:extensions].split(';').each do |extension_spec|
+        timezone = case extension_spec
+                   when 'dst_enabled_on_overlap:true'  then timezone.dup.extend(PeriodForLocalWithDSTPreference::ON)
+                   when 'dst_enabled_on_overlap:false' then timezone.dup.extend(PeriodForLocalWithDSTPreference::OFF)
+                   else fail(ArgumentError, "Invalid timezone extension `#{extension_spec}`")
+                   end
+      end
+
+      timezone
+    end
+
+    module JDBCTimezoneSpecValidator
+      def validate_value(value, validator_name)
+        return super(value, validator_name) unless validator_name == :jdbc_timezone_spec
+
+        [true, TimezoneProxy.load(value)] rescue [false, $!.message]
+      end
+    end
+
+    ##
+    # @api private
+    class PeriodForLocalWithDSTPreference < Module
+      def initialize(default_dst_enabled_on_overlap)
+        define_method(:period_for_local) do |localtime, dst_enabled_on_overlap=nil, &dismabiguation_block|
+          super(localtime, dst_enabled_on_overlap.nil? ? default_dst_enabled_on_overlap : dst_enabled_on_overlap, &dismabiguation_block)
+        end
+      end
+
+      ON = new(true)
+      OFF = new(false)
+    end
+  end
+end; end; end

data/lib/logstash/plugin_mixins/jdbc/value_tracking.rb

@@ -14,7 +14,7 @@ module LogStash module PluginMixins module Jdbc
         # use this irrespective of the jdbc_default_timezone setting
         NumericValueTracker.new(handler)
       else
-        if plugin.jdbc_default_timezone.nil? || plugin.jdbc_default_timezone.empty?
+        if plugin.jdbc_default_timezone.nil?
           # no TZ stuff for Sequel, use Time
           TimeValueTracker.new(handler)
         else

data/logstash-integration-jdbc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-integration-jdbc'
-  s.version         = '5.2.6'
+  s.version         = '5.4.0'
   s.licenses = ['Apache License (2.0)']
   s.summary         = "Integration with JDBC - input and filter plugins"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"
@@ -34,12 +34,11 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'tzinfo'
   s.add_runtime_dependency 'tzinfo-data'
-  # plugin maintains compatibility with < 3.5 (3.0.9)
-  # but works with newer rufus-scheduler >= 3.5 as well
-  s.add_runtime_dependency 'rufus-scheduler'
+
   s.add_runtime_dependency 'logstash-mixin-ecs_compatibility_support', '~>1.3'
   s.add_runtime_dependency "logstash-mixin-validator_support", '~> 1.0'
   s.add_runtime_dependency "logstash-mixin-event_support", '~> 1.0'
+  s.add_runtime_dependency "logstash-mixin-scheduler", '~> 1.0'
 
   s.add_development_dependency "childprocess"
   s.add_development_dependency 'logstash-devutils', '>= 2.3'

data/spec/inputs/jdbc_spec.rb

@@ -251,18 +251,6 @@ describe LogStash::Inputs::Jdbc do
       Timecop.return
     end
 
-    it "cleans up scheduler resources on close" do
-      runner = Thread.new do
-        plugin.run(queue)
-      end
-      sleep 1
-      plugin.do_close
-
-      scheduler = plugin.instance_variable_get(:@scheduler)
-      expect(scheduler).to_not be_nil
-      expect(scheduler.down?).to be_truthy
-    end
-
   end
 
   context "when scheduling and previous runs are to be preserved" do
@@ -708,7 +696,7 @@ describe LogStash::Inputs::Jdbc do
         "last_run_metadata_path" => Stud::Temporary.pathname }
     end
 
-    let(:nums) { [BigDecimal.new(10), BigDecimal.new(20), BigDecimal.new(30), BigDecimal.new(40), BigDecimal.new(50)] }
+    let(:nums) { [BigDecimal(10), BigDecimal(20), BigDecimal(30), BigDecimal(40), BigDecimal(50)] }
 
     before do
       plugin.register
@@ -1516,6 +1504,49 @@ describe LogStash::Inputs::Jdbc do
     end
   end
 
+  context "when retrieving records with ambiguous timestamps" do
+
+    let(:settings) do
+      {
+        "statement" => "SELECT * from types_table",
+        "jdbc_default_timezone" => jdbc_default_timezone
+      }
+    end
+
+    before(:each) do
+      db << "INSERT INTO types_table (num, string, started_at, custom_time, ranking) VALUES (1, 'A test', '1999-12-31', '2021-11-07 01:23:45', 95.67)"
+      plugin.register
+    end
+
+    context "when initialized with a preference for DST being enabled" do
+      let(:jdbc_default_timezone) { 'America/Chicago[dst_enabled_on_overlap:true]' }
+
+      it 'treats the timestamp column as if DST was enabled' do
+        plugin.run(queue)
+        event = queue.pop
+        expect(event.get("custom_time")).to be_a_logstash_timestamp_equivalent_to("2021-11-07T06:23:45Z")
+      end
+    end
+    context "when initialized with a preference for DST being disabled" do
+      let(:jdbc_default_timezone) { 'America/Chicago[dst_enabled_on_overlap:false]' }
+
+      it 'treats the timestamp column as if DST was disabled' do
+        plugin.run(queue)
+        event = queue.pop
+        expect(event.get("custom_time")).to be_a_logstash_timestamp_equivalent_to("2021-11-07T07:23:45Z")
+      end
+    end
+    context "when initialized without a preference for DST being enabled or disabled" do
+      before(:each) { allow(plugin.logger).to receive(:warn) }
+      let(:jdbc_default_timezone) { 'America/Chicago' }
+
+      it 'the error results in helpful log warning' do
+        plugin.run(queue)
+        expect(plugin.logger).to have_received(:warn).with(a_string_including("Exception when executing JDBC query"), a_hash_including(:message => a_string_including("2021-11-07 01:23:45 is an ambiguous local time")))
+      end
+    end
+  end
+
   context "when an unreadable jdbc_driver_path entry is present" do
     let(:driver_jar_path) do
       jar_file = $CLASSPATH.find { |name| name.index(Jdbc::Derby.driver_jar) }
@@ -1717,7 +1748,7 @@ describe LogStash::Inputs::Jdbc do
       let(:jdbc_driver_class) { "org.apache.NonExistentDriver" }
       it "raises a loading error" do
         expect { plugin.send(:load_driver) }.to raise_error LogStash::PluginLoadingError,
-                                                            /java.lang.ClassNotFoundException: org.apache.NonExistentDriver/
+                                                            /ClassNotFoundException: org.apache.NonExistentDriver/
       end
     end
   end

data/spec/plugin_mixins/jdbc/timezone_proxy_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/plugin_mixins/jdbc/timezone_proxy"
+
+describe LogStash::PluginMixins::Jdbc::TimezoneProxy do
+  subject(:timezone) { described_class.load(timezone_spec) }
+
+  context 'when handling a daylight-savings ambiguous time' do
+    context 'without extensions' do
+      let(:timezone_spec) { 'America/Los_Angeles[]' }
+      it 'raises an AmbiguousTime error' do
+        expect { timezone.local_time(2021,11,7,1,17) }.to raise_error(::TZInfo::AmbiguousTime)
+      end
+    end
+    context 'with extension `dst_enabled_on_overlap:true`' do
+      let(:timezone_spec) { 'America/Los_Angeles[dst_enabled_on_overlap:true]' }
+      it 'resolves as if DST were enabled' do
+        timestamp = timezone.local_time(2021,11,7,1,17)
+        aggregate_failures do
+          expect(timestamp.dst?).to be true
+          expect(timestamp.zone).to eq('PDT') # Pacific Daylight Time
+          expect(timestamp.getutc).to eq(Time.utc(2021,11,7,8,17))
+          expect(timestamp.utc_offset).to eq( -7 * 3600 )
+        end
+      end
+      end
+    context 'with extension `dst_enabled_on_overlap:false`' do
+      let(:timezone_spec) { 'America/Los_Angeles[dst_enabled_on_overlap:false]' }
+      it 'resolves as if DST were disabled' do
+        timestamp = timezone.local_time(2021,11,7,1,17)
+        aggregate_failures do
+          expect(timestamp.dst?).to be false
+          expect(timestamp.zone).to eq('PST') # Pacific Standard Time
+          expect(timestamp.getutc).to eq(Time.utc(2021,11,7,9,17))
+          expect(timestamp.utc_offset).to eq( -8 * 3600 )
+        end
+      end
+    end
+  end
+
+  context '#load' do
+    context 'when spec is a normal timezone instance' do
+      let(:timezone_spec) { ::TZInfo::Timezone.get('America/Los_Angeles') }
+      it 'returns that instance' do
+        expect(timezone).to be(timezone_spec)
+      end
+    end
+    context 'when spec is a valid unextended timezone spec' do
+      let(:timezone_spec) { 'America/Los_Angeles' }
+      it 'returns the canonical timezone' do
+        expect(timezone).to eq(::TZInfo::Timezone.get('America/Los_Angeles'))
+      end
+    end
+    context 'when spec is an invalid timezone spec' do
+      let(:timezone_spec) { 'NotAValidTimezoneIdentifier' }
+
+      it 'propagates the TZInfo exception' do
+        expect { timezone }.to raise_exception(::TZInfo::InvalidTimezoneIdentifier)
+      end
+    end
+    context 'with invalid extension' do
+      let(:timezone_spec) { 'America/Los_Angeles[dst_enabled_on_overlap:false;nope:wrong]' }
+      it 'raises an exception with a helpful message' do
+        expect { timezone }.to raise_exception(ArgumentError, a_string_including("Invalid timezone extension `nope:wrong`"))
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-integration-jdbc
 version: !ruby/object:Gem::Version
-  version: 5.2.6
+  version: 5.4.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-19 00:00:00.000000000 Z
+date: 2022-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -131,38 +131,38 @@ dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-  name: rufus-scheduler
+        version: '1.3'
+  name: logstash-mixin-ecs_compatibility_support
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-  name: logstash-mixin-ecs_compatibility_support
+        version: '1.0'
+  name: logstash-mixin-validator_support
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  name: logstash-mixin-validator_support
+  name: logstash-mixin-event_support
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
@@ -176,7 +176,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  name: logstash-mixin-event_support
+  name: logstash-mixin-scheduler
   prerelease: false
   type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
@@ -277,8 +277,8 @@ files:
 - lib/logstash/inputs/tzinfo_jruby_patch.rb
 - lib/logstash/plugin_mixins/jdbc/common.rb
 - lib/logstash/plugin_mixins/jdbc/jdbc.rb
-- lib/logstash/plugin_mixins/jdbc/scheduler.rb
 - lib/logstash/plugin_mixins/jdbc/statement_handler.rb
+- lib/logstash/plugin_mixins/jdbc/timezone_proxy.rb
 - lib/logstash/plugin_mixins/jdbc/value_tracking.rb
 - lib/logstash/plugin_mixins/jdbc_streaming.rb
 - lib/logstash/plugin_mixins/jdbc_streaming/cache_payload.rb
@@ -306,7 +306,7 @@ files:
 - spec/helpers/derbyrun.jar
 - spec/inputs/integration/integ_spec.rb
 - spec/inputs/jdbc_spec.rb
-- spec/plugin_mixins/jdbc/scheduler_spec.rb
+- spec/plugin_mixins/jdbc/timezone_proxy_spec.rb
 - spec/plugin_mixins/jdbc_streaming/parameter_handler_spec.rb
 - vendor/jar-dependencies/org/apache/derby/derby/10.14.1.0/derby-10.14.1.0.jar
 - vendor/jar-dependencies/org/apache/derby/derbyclient/10.14.1.0/derbyclient-10.14.1.0.jar
@@ -359,5 +359,5 @@ test_files:
 - spec/helpers/derbyrun.jar
 - spec/inputs/integration/integ_spec.rb
 - spec/inputs/jdbc_spec.rb
-- spec/plugin_mixins/jdbc/scheduler_spec.rb
+- spec/plugin_mixins/jdbc/timezone_proxy_spec.rb
 - spec/plugin_mixins/jdbc_streaming/parameter_handler_spec.rb

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

@@ -1,175 +0,0 @@
-require 'rufus/scheduler'
-
-require 'logstash/util/loggable'
-
-module LogStash module PluginMixins module Jdbc
-  class Scheduler < Rufus::Scheduler
-
-    include LogStash::Util::Loggable
-
-    # 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)
-
-    # @param cron [String] cron-line
-    # @param opts [Hash] scheduler options
-    # @return scheduler instance
-    def self.start_cron_scheduler(cron, opts = {}, &block)
-      unless block_given?
-        raise ArgumentError, 'missing (cron scheduler) block - worker task to execute'
-      end
-      scheduler = new_scheduler(opts)
-      scheduler.schedule_cron(cron, &block)
-      scheduler
-    end
-
-    # @param opts [Hash] scheduler options
-    # @return scheduler instance
-    def self.new_scheduler(opts)
-      unless opts.key?(:thread_name)
-        raise ArgumentError, 'thread_name: option is required to be able to distinguish multiple scheduler threads'
-      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
-
-      new(opts)
-    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
-
-    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=)
-            # e.g. "[oracle]<jdbc_scheduler_worker-00"
-          end
-        end
-
-        ret
-      end
-
-    end
-
-  end
-end end end

data/spec/plugin_mixins/jdbc/scheduler_spec.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-require "logstash/devutils/rspec/spec_helper"
-require "logstash/plugin_mixins/jdbc/scheduler"
-
-describe LogStash::PluginMixins::Jdbc::Scheduler do
-
-  let(:thread_name) { '[test]<jdbc_scheduler' }
-
-  let(:opts) do
-    { :max_work_threads => 2, :thread_name => thread_name }
-  end
-
-  subject(:scheduler) { LogStash::PluginMixins::Jdbc::Scheduler.new(opts) }
-
-  after { scheduler.stop(:wait) }
-
-  it "sets scheduler thread name" do
-    expect( scheduler.thread.name ).to include thread_name
-  end
-
-  context 'cron schedule' do
-
-    before do
-      scheduler.schedule_cron('* * * * * *') { sleep 1.25 } # every second
-    end
-
-    it "sets worker thread names" do
-      sleep 3.0
-      threads = scheduler.work_threads
-      threads.sort! { |t1, t2| (t1.name || '') <=> (t2.name || '') }
-
-      expect( threads.size ).to eql 2
-      expect( threads.first.name ).to eql "#{thread_name}_worker-00"
-      expect( threads.last.name ).to eql "#{thread_name}_worker-01"
-    end
-
-  end
-
-  context 'every 1s' do
-
-    before do
-      scheduler.schedule_in('1s') { raise 'TEST' } # every second
-    end
-
-    it "logs errors handled" do
-      expect( scheduler.logger ).to receive(:error).with /Scheduler intercepted an error/, hash_including(:message => 'TEST')
-      sleep 1.5
-    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.schedule_cron('* * * * * *') { counter.increment_and_get; sleep 3.25 } # every second
-    end
-
-    it "are working" do
-      sleep(0.05) while counter.get == 0
-      expect( scheduler.work_threads.size ).to eql 1
-      sleep(0.05) while counter.get == 1
-      expect( scheduler.work_threads.size ).to eql 2
-      sleep(0.05) while counter.get == 2
-      expect( scheduler.work_threads.size ).to eql 3
-
-      sleep 1.25
-      expect( scheduler.work_threads.size ).to eql 3
-      sleep 1.25
-      expect( scheduler.work_threads.size ).to eql 3
-    end
-
-  end
-
-end