logstash-input-jdbc 4.3.13 → 4.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a9db4fd5ecf6e086baef74847693d14b42453b1aa21896dd28bca808c381887
-  data.tar.gz: cc0521b409922f40116438ed7237074bdabd63b7827d4dfc3df1059f990517f0
+  metadata.gz: da0726e9534ffb2d10744efb977233487a21fb9e05e047294d5d2349e5a789fc
+  data.tar.gz: 1ea1948f5846b04ef7ecff9c9088f6d1d8c823ac38eceb07b0d83641be01666d
 SHA512:
-  metadata.gz: 067a1e1a3f8f3087f1c857d7b09ed0d6090c00e6b4a456b5d93dc4c0e12626cc2e1ed1099d7a4aa84e1ded32540cff46a1ad8a1237f1aa867522aa217cb8d3b3
-  data.tar.gz: 6bc65ac1a15b71078953959ead697ae37afec46c9b02b2a7ceac0d34857476946ab5f17185eb9e3e894609b6ac7b59e3e64ad44a4e495e06a2792bf97f41dc82
+  metadata.gz: 1c5ea4dbfba07fb58625b7163740769c36b0288b8dae3a8877dc5feb2af089c71c8fc39982f17f48268bf30b290adf3f5ee942bfe7cba5bbc8f25157c538052b
+  data.tar.gz: a2d8a17d3f33a9c60fff84376566d909d2b29506a7b257c65ec739e9d1fcf953e832d039f9806698dcc34362281264c4f64b460cef41966ca95567996991cc39

data/docs/index.asciidoc

@@ -149,6 +149,7 @@ This plugin supports the following configuration options plus the <<plugins-{typ
 [cols="<,<,<",options="header",]
 |=======================================================================
 |Setting |Input type|Required
+| <<plugins-{type}s-{plugin}-plugin_timezone>> |<<string,string>>, one of `["local", "utc"]`|No
 | <<plugins-{type}s-{plugin}-clean_run>> |<<boolean,boolean>>|No
 | <<plugins-{type}s-{plugin}-columns_charset>> |<<hash,hash>>|No
 | <<plugins-{type}s-{plugin}-connection_retry_attempts>> |<<number,number>>|No
@@ -247,13 +248,35 @@ JDBC connection string
   * There is no default value for this setting.
 
 Timezone conversion.
-SQL does not allow for timezone data in timestamp fields.  This plugin will automatically
-convert your SQL timestamp fields to Logstash timestamps, in relative UTC time in ISO8601 format.
+Logstash (and Elasticsearch) expects that timestamps are 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
+timestamp fields we can't figure this out on a record by record basis.  This plugin
+will automatically convert your SQL timestamp fields to Logstash timestamps,
+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.
 
+[id="plugins-{type}s-{plugin}-plugin_timezone"]
+===== `plugin_timezone`
+
+  * Value can be any of: `utc`, `local`
+  * Default value is `"utc"`
+
+If you want this plugin to offset timestamps to a timezone other than UTC, you
+can set this setting to `local` and the plugin will use the OS timezone for offset
+adjustments.
+
+Note: when specifying `plugin_timezone` and/or `jdbc_default_timezone`, offset
+adjustments are made in two places, if `sql_last_value` is a timestamp and it
+is used as a parameter in the statement then offset adjustment is done from the
+plugin timezone into the data timezone and while records are processed, timestamps
+are offset adjusted from the database timezone to the plugin timezone. If your
+database timezone is UTC then you do not need to set either of these settings.
+
 [id="plugins-{type}s-{plugin}-jdbc_driver_class"]
 ===== `jdbc_driver_class`
 

data/lib/logstash/inputs/jdbc.rb

@@ -3,6 +3,8 @@ require "logstash/inputs/base"
 require "logstash/namespace"
 require "logstash/plugin_mixins/jdbc/jdbc"
 
+# this require_relative returns early unless the JRuby version is between 9.2.0.0 and 9.2.8.0
+require_relative "tzinfo_jruby_patch"
 
 # This plugin was created as a way to ingest data from any database
 # with a JDBC interface into Logstash. You can periodically schedule ingestion
@@ -84,19 +86,19 @@ require "logstash/plugin_mixins/jdbc/jdbc"
 # The file option only supports one SQL statement. The plugin will only accept one of the options.
 # It cannot read a statement from a file as well as from the `statement` configuration parameter.
 #
-# ==== Configuring multiple SQL statements 
+# ==== Configuring multiple SQL statements
 #
-# Configuring multiple SQL statements is useful when there is a need to query and ingest data 
-# from different database tables or views. It is possible to define separate Logstash 
-# configuration files for each statement or to define multiple statements in a single configuration 
-# file. When using multiple statements in a single Logstash configuration file, each statement 
-# has to be defined as a separate jdbc input (including jdbc driver, connection string and other 
-# required parameters). 
+# Configuring multiple SQL statements is useful when there is a need to query and ingest data
+# from different database tables or views. It is possible to define separate Logstash
+# configuration files for each statement or to define multiple statements in a single configuration
+# file. When using multiple statements in a single Logstash configuration file, each statement
+# has to be defined as a separate jdbc input (including jdbc driver, connection string and other
+# required parameters).
 #
-# Please note that if any of the statements use the `sql_last_value` parameter (e.g. for 
-# ingesting only data changed since last run), each input should define its own 
+# Please note that if any of the statements use the `sql_last_value` parameter (e.g. for
+# ingesting only data changed since last run), each input should define its own
 # `last_run_metadata_path` parameter. Failure to do so will result in undesired behaviour, as
-# all inputs will store their state to the same (default) metadata file, effectively 
+# all inputs will store their state to the same (default) metadata file, effectively
 # overwriting each other's `sql_last_value`.
 #
 # ==== Predefined Parameters
@@ -178,11 +180,11 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   # Whether to force the lowercasing of identifier fields
   config :lowercase_column_names, :validate => :boolean, :default => true
 
-  # The character encoding of all columns, leave empty if the columns are already properly UTF-8 
+  # The character encoding of all columns, leave empty if the columns are already properly UTF-8
   # encoded. Specific columns charsets using :columns_charset can override this setting.
   config :charset, :validate => :string
 
-  # The character encoding for specific columns. This option will override the `:charset` option 
+  # The character encoding for specific columns. This option will override the `:charset` option
   # for the specified columns.
   #
   # Example:
@@ -199,6 +201,8 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   # this will only convert column0 that has ISO-8859-1 as an original encoding.
   config :columns_charset, :validate => :hash, :default => {}
 
+  attr_reader :database # for test mocking/stubbing
+
   public
 
   def register

data/lib/logstash/inputs/tzinfo_jruby_patch.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# There is a bug in JRuby versions between 9.2.0.0 and 9.2.8.0
+# the TZinfo::Timestamp `new_datetime` can build Rational numbers having
+# numerators and denominators that are too large for Java longs.
+#
+# This patch reopens the TZinfo::Timestamp class and redefines
+# the `new_datetime method.
+# It scales down the numerator and denominator if they are larger than
+# Java Long. There is no appreciable precision loss at the microsecond level
+
+tzinfo_jruby_bugfixed_version = "9.2.8.0"
+tzinfo_jruby_bugadded_version = "9.2.0.0"
+
+current_jruby_version = Gem::Version.new(JRUBY_VERSION)
+broken_jruby_version = Gem::Version.new(tzinfo_jruby_bugadded_version)
+patched_jruby_version = Gem::Version.new(tzinfo_jruby_bugfixed_version)
+
+return unless current_jruby_version >= broken_jruby_version && current_jruby_version < patched_jruby_version
+
+require 'tzinfo'
+
+if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+  module TZInfo
+    # A time represented as an `Integer` number of seconds since 1970-01-01
+    # 00:00:00 UTC (ignoring leap seconds), the fraction through the second
+    # (sub_second as a `Rational`) and an optional UTC offset. Like Ruby's `Time`
+    # class, {Timestamp} can distinguish between a local time with a zero offset
+    # and a time specified explicitly as UTC.
+    class Timestamp
+
+      protected
+
+      def new_datetime(klass = DateTime)
+        val = JD_EPOCH + ((@value.to_r + @sub_second) / 86400)
+        datetime = klass.jd(jruby_scale_down_rational(val))
+        @utc_offset && @utc_offset != 0 ? datetime.new_offset(Rational(@utc_offset, 86400)) : datetime
+      end
+
+      private
+
+      # while this JRuby bug exists in 9.2.X.X https://github.com/jruby/jruby/issues/5791
+      # we must scale down the numerator and denominator to fit Java Long values.
+
+      def jruby_scale_down_rational(rat)
+        return rat if rat.numerator <= java.lang.Long::MAX_VALUE
+        [10, 100, 1000].each do |scale_by|
+          new_numerator = rat.numerator / scale_by
+          if new_numerator  <= java.lang.Long::MAX_VALUE
+            return Rational(new_numerator, rat.denominator / scale_by)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require "time"
 require "date"
 require_relative "value_tracking"
 require_relative "checked_count_logger"
+require_relative "wrapped_driver"
 
 java_import java.util.concurrent.locks.ReentrantLock
 
@@ -98,6 +99,9 @@ module LogStash  module PluginMixins module Jdbc
       config :connection_retry_attempts, :validate => :number, :default => 1
       # Number of seconds to sleep between connection attempts
       config :connection_retry_attempts_wait_time, :validate => :number, :default => 0.5
+
+      # give users the ability to force Sequel application side into using local timezone
+      config :plugin_timezone, :validate => ["local", "utc"], :default => "utc"
     end
 
     private
@@ -120,7 +124,8 @@ module LogStash  module PluginMixins module Jdbc
           else
             @logger.error("Failed to connect to database. #{@jdbc_pool_timeout} second timeout exceeded. Trying again.")
           end
-        rescue Sequel::Error => e
+        # rescue Java::JavaSql::SQLException, ::Sequel::Error => e
+        rescue ::Sequel::Error => e
           if retry_attempts <= 0
             @logger.error("Unable to connect to database. Tried #{@connection_retry_attempts} times", :error_message => e.message, )
             raise e
@@ -133,14 +138,29 @@ module LogStash  module PluginMixins module Jdbc
     end
 
     private
-    def load_drivers(drivers)
-      drivers.each do |driver|
-        begin
-          class_loader = java.lang.ClassLoader.getSystemClassLoader().to_java(java.net.URLClassLoader)
-          class_loader.add_url(java.io.File.new(driver).toURI().toURL())
-        rescue => e
-          @logger.error("Failed to load #{driver}", :exception => e)
-        end
+
+    def load_drivers
+      return if @jdbc_driver_library.nil? || @jdbc_driver_library.empty?
+
+      driver_jars = @jdbc_driver_library.split(",")
+
+      # Needed for JDK 11 as the DriverManager has a different ClassLoader than Logstash
+      urls = java.net.URL[driver_jars.length].new
+
+      driver_jars.each_with_index do |driver, idx|
+        urls[idx] = java.io.File.new(driver).toURI().toURL()
+      end
+      ucl = java.net.URLClassLoader.new_instance(urls)
+      begin
+        klass = java.lang.Class.forName(@jdbc_driver_class.to_java(:string), true, ucl);
+      rescue Java::JavaLang::ClassNotFoundException => e
+        raise LogStash::Error, "Unable to find driver class via URLClassLoader in given driver jars: #{@jdbc_driver_class}"
+      end
+      begin
+        driver = klass.getConstructor().newInstance();
+        java.sql.DriverManager.register_driver(WrappedDriver.new(driver.to_java(java.sql.Driver)).to_java(java.sql.Driver))
+      rescue Java::JavaSql::SQLException => e
+        raise LogStash::Error, "Unable to register driver with java.sql.DriverManager using WrappedDriver: #{@jdbc_driver_class}"
       end
     end
 
@@ -149,18 +169,24 @@ module LogStash  module PluginMixins module Jdbc
       require "java"
       require "sequel"
       require "sequel/adapters/jdbc"
-      load_drivers(@jdbc_driver_library.split(",")) if @jdbc_driver_library
+
+      Sequel.application_timezone = @plugin_timezone.to_sym
 
       begin
+        load_drivers
         Sequel::JDBC.load_driver(@jdbc_driver_class)
+      rescue LogStash::Error => e
+        # raised in load_drivers, e.cause should be the caught Java exceptions
+        raise LogStash::PluginLoadingError, "#{e.message} and #{e.cause.message}"
       rescue Sequel::AdapterNotFound => e
+        # fix this !!!
         message = if @jdbc_driver_library.nil?
           ":jdbc_driver_library is not set, are you sure you included
                     the proper driver client libraries in your classpath?"
         else
           "Are you sure you've included the correct jdbc driver in :jdbc_driver_library?"
         end
-        raise LogStash::ConfigurationError, "#{e}. #{message}"
+        raise LogStash::PluginLoadingError, "#{e}. #{message}"
       end
       @database = jdbc_connect()
       @database.extension(:pagination)
@@ -175,6 +201,8 @@ module LogStash  module PluginMixins module Jdbc
       @database.fetch_size = @jdbc_fetch_size unless @jdbc_fetch_size.nil?
       begin
         @database.test_connection
+      rescue Java::JavaSql::SQLException => e
+        @logger.warn("Failed test_connection with java.sql.SQLException.", :exception => e)
       rescue Sequel::DatabaseConnectionError => e
         @logger.warn("Failed test_connection.", :exception => e)
         close_jdbc_connection
@@ -216,13 +244,13 @@ module LogStash  module PluginMixins module Jdbc
 
     public
     def execute_statement(statement, parameters)
+      # sql_last_value has been set in params by caller
       success = false
       @connection_lock.lock
       open_jdbc_connection
       begin
         params = symbolized_params(parameters)
         query = @database[statement, params]
-
         sql_last_value = @use_column_value ? @value_tracker.value : Time.now.utc
         @tracking_column_warning_sent = false
         @statement_logger.log_statement_parameters(query, statement, params)
@@ -231,7 +259,7 @@ module LogStash  module PluginMixins module Jdbc
           yield extract_values_from(row)
         end
         success = true
-      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseError => e
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseError, Java::JavaSql::SQLException => e
         @logger.warn("Exception when executing JDBC query", :exception => e)
       else
         @value_tracker.set_value(sql_last_value)
@@ -267,8 +295,8 @@ module LogStash  module PluginMixins module Jdbc
           @logger.warn("tracking_column not found in dataset.", :tracking_column => @tracking_column)
           @tracking_column_warning_sent = true
         end
-        # If we can't find the tracking column, return the current value in the ivar
-        @sql_last_value
+        # If we can't find the tracking column, return the current value_tracker value
+        @value_tracker.value
       else
         # Otherwise send the updated tracking column
         row[@tracking_column.to_sym]
@@ -297,20 +325,16 @@ module LogStash  module PluginMixins module Jdbc
 
     private
     def decorate_value(value)
-      if value.is_a?(Time)
+      case value
+      when Time
         # transform it to LogStash::Timestamp as required by LS
         LogStash::Timestamp.new(value)
-      elsif value.is_a?(Date)
+      when Date, DateTime
         LogStash::Timestamp.new(value.to_time)
-      elsif value.is_a?(DateTime)
-        # Manual timezone conversion detected.
-        # This is slower, so we put it in as a conditional case.
-        LogStash::Timestamp.new(Time.parse(value.to_s))
       else
         value
       end
     end
-
   end
 end end end
 

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

@@ -33,10 +33,10 @@ module LogStash module PluginMixins module Jdbc
 
     def initialize(handler)
       @file_handler = handler
-      set_value(get_initial)
+      set_initial
     end
 
-    def get_initial
+    def set_initial
       # override in subclass
     end
 
@@ -47,12 +47,23 @@ module LogStash module PluginMixins module Jdbc
     def write
       @file_handler.write(@value)
     end
+
+    private
+    def common_set_initial(method_symbol, default)
+      persisted = @file_handler.read
+      if persisted && persisted.respond_to?(method_symbol)
+        @value = persisted
+      else
+        @file_handler.clean
+        @value = default
+      end
+    end
   end
 
 
   class NumericValueTracker < ValueTracking
-    def get_initial
-      @file_handler.read || 0
+    def set_initial
+      common_set_initial(:gcd, 0)
     end
 
     def set_value(value)
@@ -62,8 +73,8 @@ module LogStash module PluginMixins module Jdbc
   end
 
   class DateTimeValueTracker < ValueTracking
-    def get_initial
-      @file_handler.read || DateTime.new(1970)
+    def set_initial
+      common_set_initial(:to_datetime, DateTime.new(1970))
     end
 
     def set_value(value)
@@ -76,8 +87,8 @@ module LogStash module PluginMixins module Jdbc
   end
 
   class TimeValueTracker < ValueTracking
-    def get_initial
-      @file_handler.read || Time.at(0).utc
+    def set_initial
+      common_set_initial(:to_time, Time.at(0).utc)
     end
 
     def set_value(value)
@@ -90,6 +101,8 @@ module LogStash module PluginMixins module Jdbc
   end
 
   class FileHandler
+    attr_reader :path
+
     def initialize(path)
       @path = path
       @exists = ::File.exist?(@path)

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module LogStash module PluginMixins module Jdbc
+  class WrappedDriver
+    java_implements java.sql.Driver
+
+    def initialize(drv)
+      @driver = drv
+    end
+
+    java_signature 'boolean acceptsURL(String u) throws SQLException'
+    def accepts_url(u)
+      @driver.accepts_url(u)
+    end
+
+    java_signature 'Connection connect(String u, Properties p)'
+    def connect(url, props)
+      @driver.connect(url, props)
+    end
+
+    java_signature 'int getMajorVersion()'
+    def get_major_version()
+      @driver.get_major_version()
+    end
+
+    java_signature 'int getMinorVersion()'
+    def get_minor_version()
+      @driver.get_minor_version()
+    end
+
+    java_signature 'DriverPropertyInfo[] getPropertyInfo(String u, Properties p)'
+    def get_property_info(url, props)
+      @driver.get_property_info(url, props)
+    end
+
+    java_signature 'boolean jdbcCompliant()'
+    def jdbc_compliant()
+      @driver.jdbc_compliant
+    end
+
+    java_signature 'Logger getParentLogger() throws SQLFeatureNotSupportedException'
+    def get_parent_logger()
+      @driver.get_parent_logger
+    end
+  end
+end end end

data/logstash-input-jdbc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-input-jdbc'
-  s.version         = '4.3.13'
+  s.version         = '4.3.14'
   s.licenses = ['Apache License (2.0)']
   s.summary = "Creates events from JDBC data"
   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"

data/spec/inputs/jdbc_spec.rb

@@ -11,11 +11,9 @@ require "stud/temporary"
 require "time"
 require "date"
 
+# We do not need to set TZ env var anymore because we can have 'Sequel.application_timezone' set to utc by default now.
+
 describe LogStash::Inputs::Jdbc do
-  # This is a necessary change test-wide to guarantee that no local timezone
-  # is picked up.  It could be arbitrarily set to any timezone, but then the test
-  # would have to compensate differently.  That's why UTC is chosen.
-  ENV["TZ"] = "Etc/UTC"
   let(:mixin_settings) do
     { "jdbc_user" => ENV['USER'], "jdbc_driver_class" => "org.apache.derby.jdbc.EmbeddedDriver",
       "jdbc_connection_string" => "jdbc:derby:memory:testdb;create=true"}
@@ -64,22 +62,6 @@ describe LogStash::Inputs::Jdbc do
       plugin.stop
     end
 
-    it "should load all drivers when passing an array" do
-      mixin_settings['jdbc_driver_library'] = '/foo/bar,/bar/foo'
-      expect(plugin).to receive(:load_drivers).with(['/foo/bar', '/bar/foo'])
-      plugin.register
-      plugin.run(queue) # load when first run
-      plugin.stop
-    end
-
-    it "should load all drivers when using a single value" do
-      mixin_settings['jdbc_driver_library'] = '/foo/bar'
-      expect(plugin).to receive(:load_drivers).with(['/foo/bar'])
-      plugin.register
-      plugin.run(queue) # load when first run
-      plugin.stop
-    end
-
     it "should stop without raising exception" do
       plugin.register
       expect { plugin.stop }.to_not raise_error
@@ -371,17 +353,18 @@ describe LogStash::Inputs::Jdbc do
         }
       end
 
-      it "should convert the time to reflect the timezone " do
+      before do
         last_run_value = DateTime.iso8601("2000-01-01T12:00:00.000Z")
-        File.write(settings["last_run_metadata_path"], YAML.dump(last_run_value))
-
-        Timecop.travel(DateTime.iso8601("2015-01-01T15:50:00.000Z")) do
+        File.write(settings["last_run_metadata_path"], last_run_value)
+        Timecop.travel(DateTime.iso8601("2015-01-01T15:50:01.000Z")) do
           # simulate earlier records written
           hours.each do |i|
             db[:test_table].insert(:num => i, :custom_time => "2015-01-01 #{i}:00:00", :created_at => Time.now.utc)
           end
         end
+      end
 
+      it "should convert the time to reflect the timezone " do
         Timecop.travel(DateTime.iso8601("2015-01-02T02:10:00.000Z")) do
           # simulate the first plugin run after the custom time of the last record
           plugin.register
@@ -393,6 +376,7 @@ describe LogStash::Inputs::Jdbc do
         end
         Timecop.travel(DateTime.iso8601("2015-01-02T02:20:00.000Z")) do
           # simulate a run 10 minutes later
+          plugin.register
           plugin.run(queue)
           expect(queue.size).to eq(0) # no new records
           plugin.stop
@@ -402,6 +386,7 @@ describe LogStash::Inputs::Jdbc do
         end
         Timecop.travel(DateTime.iso8601("2015-01-02T03:30:00.000Z")) do
           # simulate another run later than the custom time of the last record
+          plugin.register
           plugin.run(queue)
           expect(queue.size).to eq(2)
           plugin.stop
@@ -432,9 +417,9 @@ describe LogStash::Inputs::Jdbc do
         # Sequel only does the *correct* timezone calc on a DateTime instance
         last_run_value = DateTime.iso8601("2000-01-01T00:00:00.987Z")
         File.write(settings["last_run_metadata_path"], YAML.dump(last_run_value))
-
         hours.each_with_index do |i, j|
-          db[:test1_table].insert(:num => i, :custom_time => "2015-01-01 #{i}:00:00.#{msecs[j]}", :created_at => Time.now.utc)
+          time_value = Time.utc(2015, 1, 1, i, 0, 0, msecs[j] * 1000)
+          db[:test1_table].insert(:num => i, :custom_time => time_value, :created_at => Time.now.utc)
         end
 
         plugin.register
@@ -444,7 +429,8 @@ describe LogStash::Inputs::Jdbc do
         actual = queue.size.times.map { queue.pop.get("custom_time").time }
         expect(actual).to eq(expected)
         plugin.stop
-        last_run_value = YAML.load(File.read(settings["last_run_metadata_path"]))
+        raw_last_run_value = File.read(settings["last_run_metadata_path"])
+        last_run_value = YAML.load(raw_last_run_value)
         expect(last_run_value).to be_a(DateTime)
         expect(last_run_value.strftime("%F %T.%N %Z")).to eq("2015-01-02 02:00:00.722000000 +00:00")
 
@@ -995,7 +981,7 @@ describe LogStash::Inputs::Jdbc do
       expect do
         plugin.register
         plugin.run(queue) # load when first run
-      end.to raise_error(LogStash::ConfigurationError)
+      end.to raise_error(LogStash::PluginLoadingError)
     end
   end
 
@@ -1136,7 +1122,14 @@ describe LogStash::Inputs::Jdbc do
     end
 
     before(:each) do
-      allow_any_instance_of(Sequel::JDBC::Derby::Dataset).to receive(:each).and_yield(row)
+      dataset = double("Dataset")
+      allow(dataset).to receive(:each).and_yield(row)
+      allow(plugin).to receive(:jdbc_connect).and_wrap_original do |m, *args|
+        _db = m.call(*args)
+        allow(_db).to receive(:[]).and_return(dataset)
+        _db
+      end
+      # allow_any_instance_of(Sequel::JDBC::Derby::Dataset).to receive(:each).and_yield(row)
       plugin.register
     end
 
@@ -1191,7 +1184,7 @@ describe LogStash::Inputs::Jdbc do
             next unless v.is_a?(String)
             expect(row[k].encoding).to eq(encoded_row[k].encoding)
           end
-          
+
           event
         end
         plugin.run(events)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-jdbc
 version: !ruby/object:Gem::Version
-  version: 4.3.13
+  version: 4.3.14
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-09-04 00:00:00.000000000 Z
+date: 2019-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -171,9 +171,11 @@ files:
 - README.md
 - docs/index.asciidoc
 - lib/logstash/inputs/jdbc.rb
+- lib/logstash/inputs/tzinfo_jruby_patch.rb
 - lib/logstash/plugin_mixins/jdbc/checked_count_logger.rb
 - lib/logstash/plugin_mixins/jdbc/jdbc.rb
 - lib/logstash/plugin_mixins/jdbc/value_tracking.rb
+- lib/logstash/plugin_mixins/jdbc/wrapped_driver.rb
 - logstash-input-jdbc.gemspec
 - spec/inputs/integ_spec.rb
 - spec/inputs/jdbc_spec.rb