logstash-integration-jdbc 5.2.4 → 5.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad77fc92ab07e1da7e4c6285075b6583f9f293c073199b614e3852cd22bbc6a9
-  data.tar.gz: 9e7b2c0f0c16930903bdee1f22b2651db7cf9f80d01a12f212b7a40155d4ebea
+  metadata.gz: 7604bb8967c9d63f585d14622ab18b70bc0d9e9b34e43bca6b6c59c9d05a6b76
+  data.tar.gz: 2e9d142376d12bbd1313142e79174d540d53e098e481330262e784c8177e4898
 SHA512:
-  metadata.gz: 2928a01bbe1ef418f36d6ddc7847416fc6d43278b20242926037bef02e8a429ba1d4587f1bd88f8d52de2ec1fef26e749aeb358de82a8bf69c36e5c3c9d42f8e
-  data.tar.gz: 8aae596826ec1d9155e0f8bdfad9a882e92fa2be610f89d7c67a7b3f44f0e6937bcbafd78900457d92b20a5a28188163f7b4f25040d8deb229f505ab6faf2c22
+  metadata.gz: 165749e33fed7d98b9635f6a1d74cdb05623563a3942d34c093ef761cd8e4f4784e6eb467a699909e5420ceef8fb4779c00e1b154845838052aa278a592ddc2a
+  data.tar.gz: b9a4e7822ea60c3dde25edd6a1a6e72837069a993046a050a05aa32e92172d4689624df12e85c31b79f62c40fd0f45f98700e07a678a7ea2656d9730f2f14a8e

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## 5.4.11
+  - Fixes an issue in which any one instance of a JDBC input plugin using `jdbc_default_timezone` changes the behaviour of plugin instances that do _not_ use `jdbc_default_timezone`, ensuring that timezone offsets remain consistent for each instance of the plugin _as configured_ [#151](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/151)
+  - Fixes an exception that could occur while reloading `jdbc_static` databases when the underlying connection to the remote has been broken [#165](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/165)
+
+## 5.4.10
+  - Adds retry mechanism when checkout Derby from SVN repository [#158](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/158)
+  - [DOC] add known limitations and settings for connection issue [#167](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/167)
+
+## 5.4.9
+  - Fix Derby missed driver classes when built locally for version 10.15 [#160](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/160)
+
+## 5.4.8
+  - Update Derby with locally built 10.15.2.1 version [#155](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/155) 
+
+## 5.4.7
+  - Update sequel version to >= 5.74.0. It fixes the generic jdbc adapter to properly handle disconnect errors [#153](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/153)
+
+## 5.4.6
+  - Update sequel version to >= 5.73.0. The ibmdb and jdbc/db2 adapters were fixed to properly handle disconnect errors, removing the related connection from the pool [#144](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/144)
+
+## 5.4.5
+  - Pin sequel to < 5.72.0 due to ruby/bigdecimal#169 [#141](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/141)
+
+## 5.4.4
+  - Fix: adaptations for JRuby 9.4 [#125](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/125)
+
+## 5.4.3
+  - Fix crash when metadata file can't be deleted after moving under path.data [#136](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/136)
+
+## 5.4.2
+  - Doc: described default_hash and tag_on_default_use interaction filter plugin [#122](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/122)
+  - Added new settings `statement_retry_attempts` and `statement_retry_attempts_wait_time` for retry of failed sql statement execution [#123](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/123)
+
+## 5.4.1
+  - Bugfix leak which happened in creating a new Database pool for every query. The pool is now crated on registration and closed on plugin's `stop` [#119](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/119)
+ 
+## 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)
+
+## 5.2.5
+  - Fix: do not execute more queries with debug logging [#109](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/109)
+
 ## 5.2.4
   - Fix: compatibility with all (>= 3.0) rufus-scheduler versions [#97](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/97) 
 

data/docs/filter-jdbc_static.asciidoc

@@ -111,10 +111,14 @@ filter {
         query => "SELECT firstname, lastname FROM users WHERE userid = ? AND country = ?"
         prepared_parameters => ["[loggedin_userid]", "[user_nation]"] <4>
         target => "user" <5>
+        default_hash => { <6>
+          firstname => nil
+          lastname => nil
+        }
       }
     ]
     # using add_field here to add & rename values to the event root
-    add_field => { server_name => "%{[server][0][description]}" } <6>
+    add_field => { server_name => "%{[server][0][description]}" } <7>
     add_field => { user_firstname => "%{[user][0][firstname]}" }
     add_field => { user_lastname => "%{[user][0][lastname]}" }
     remove_field => ["server", "user"]
@@ -127,6 +131,13 @@ filter {
     jdbc_connection_string => "jdbc:postgresql://remotedb:5432/ls_test_2"
   }
 }
+
+output {
+  if "_jdbcstaticdefaultsused" in [tags] {
+    # Print all the not found users
+    stdout { }
+  }
+}
 -----
 <1> Queries an external database to fetch the dataset that will be cached
 locally.
@@ -139,7 +150,8 @@ See <<plugins-{type}s-{plugin}-object_order>>.
 follow the positional ordering.
 <5> Specifies the event field that will store the looked-up data. If the lookup
 returns multiple columns, the data is stored as a JSON object within the field.
-<6> Takes data from the JSON object and stores it in top-level event fields for
+<6> When the user is not found in the database, an event is created using data from the <<plugins-{type}s-{plugin}-local_lookups>> `default hash` setting, and the event is tagged with the list set in <<plugins-{type}s-{plugin}-tag_on_default_use>>.
+<7> Takes data from the JSON object and stores it in top-level event fields for
 easier analysis in Kibana.
 
 Here's a full example:

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

@@ -176,6 +176,29 @@ input {
 }
 ---------------------------------------------------------------------------------------------------
 
+==== Database-specific considerations
+
+The JDBC input plugin leverages the https://github.com/jeremyevans/sequel[sequel] library to query databases through their JDBC drivers.
+The implementation of drivers will vary, however, potentially leading to unexpected behavior.
+
+===== Unable to reuse connections
+
+Some databases - such as Sybase or SQL Anywhere - may have issues with stale connections, timing out between scheduled runs and never reconnecting.
+
+To ensure connections are valid before queries are executed, enable <<plugins-{type}s-{plugin}-jdbc_validate_connection>> and set <<plugins-{type}s-{plugin}-jdbc_validation_timeout>> to a shorter interval than the <<plugins-{type}s-{plugin}-schedule>>.
+
+[source,ruby]
+---------------------------------------------------------------------------------------------------
+input {
+  jdbc {
+    schedule => "* * * * *"       # run every minute
+    jdbc_validate_connection => true
+    jdbc_validation_timeout => 50 # 50 seconds
+  }
+}
+---------------------------------------------------------------------------------------------------
+
+
 
 [id="plugins-{type}s-{plugin}-options"]
 ==== Jdbc Input Configuration Options
@@ -286,10 +309,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 +326,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`
@@ -479,10 +514,12 @@ How often to validate a connection (in seconds)
 ===== `last_run_metadata_path`
 
   * Value type is <<string,string>>
-  * Default value is `"$HOME/.logstash_jdbc_last_run"`
+  * Default value is `"<path.data>/plugins/inputs/jdbc/logstash_jdbc_last_run"`
 
 Path to file with last run time
 
+In versions prior to 5.2.6 the metadata file was written to `$HOME/.logstash_jdbc_last_run`. If during a Logstash upgrade the file is found in "$HOME" it will be moved to the default location under "path.data". If the path is defined by the user then no automatic move is performed.
+
 [id="plugins-{type}s-{plugin}-lowercase_column_names"]
 ===== `lowercase_column_names`
 

data/lib/logstash/filters/jdbc/basic_database.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 require "fileutils"
-require "sequel"
+require "logstash/plugin_mixins/jdbc/sequel_bootstrap"
 require "sequel/adapters/jdbc"
 require "java"
 require "logstash/util/loggable"

data/lib/logstash/filters/jdbc/read_only_database.rb

@@ -12,7 +12,7 @@ module LogStash module Filters module Jdbc
         if connected?
           result = @db[statement].count
         else
-          debug_log_messages.concat("and there is no connection to the remote db at this time")
+          debug_log_messages << "and there is no connection to the remote db at this time"
         end
       rescue ::Sequel::Error => err
         # a fatal issue
@@ -32,7 +32,7 @@ module LogStash module Filters module Jdbc
         if connected?
           result = @db[statement].all
         else
-          debug_log_messages.concat("and there is no connection to the remote db at this time")
+          debug_log_messages << "and there is no connection to the remote db at this time"
         end
       rescue ::Sequel::Error => err
         # a fatal issue

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
@@ -175,9 +176,23 @@ module LogStash module Filters class JdbcStatic < LogStash::Filters::Base
   private
 
   def prepare_data_dir
+    # cleanup existing Derby file left behind in $HOME
+    derby_log = "#{ENV['HOME']}/derby.log"
+    if ::File.exist?(derby_log)
+      begin
+        ::File.delete(derby_log)
+      rescue Errno::EPERM => e
+        @logger.warn("Can't delete temporary file #{derby_log} due to access permissions")
+      rescue e
+        @logger.warn("Can't delete temporary file #{derby_log}", {message => e.message})
+      end
+    end
+
     # later, when local persistent databases are allowed set this property to LS_HOME/data/jdbc-static/
     # must take multi-pipelines into account and more than one config using the same jdbc-static settings
-    java.lang.System.setProperty("derby.system.home", ENV["HOME"])
+    path_data = Pathname.new(LogStash::SETTINGS.get_value("path.data")).join("plugins", "shared", "derby_home")
+    path_data.mkpath
+    java.lang.System.setProperty("derby.system.home", path_data.to_path)
     logger.info("derby.system.home is: #{java.lang.System.getProperty("derby.system.home")}")
   end
 
@@ -194,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,12 @@ 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
 require_relative "tzinfo_jruby_patch"
@@ -146,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.
@@ -178,8 +180,10 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   # exactly once.
   config :schedule, :validate => :string
 
-  # Path to file with last run time
-  config :last_run_metadata_path, :validate => :string, :default => "#{ENV['HOME']}/.logstash_jdbc_last_run"
+  # Path to file with last run time.
+  # The default will write file to `<path.data>/plugins/inputs/jdbc/logstash_jdbc_last_run`
+  # NOTE: it must be a file path and not a directory path
+  config :last_run_metadata_path, :validate => :string
 
   # Use an incremental column value rather than a timestamp
   config :use_column_value, :validate => :boolean, :default => false
@@ -230,13 +234,32 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   config :target, :validate => :field_reference, :required => false
 
   attr_reader :database # for test mocking/stubbing
+  attr_reader :last_run_metadata_file_path # path to the file used as last run storage
 
   public
 
   def register
     @logger = self.logger
-    require "rufus/scheduler"
-    prepare_jdbc_connection
+
+    if @record_last_run
+      if @last_run_metadata_path.nil?
+        logstash_data_path = LogStash::SETTINGS.get_value("path.data")
+        logstash_data_path = Pathname.new(logstash_data_path).join("plugins", "inputs", "jdbc")
+        # Ensure that the filepath exists before writing, since it's deeply nested.
+        logstash_data_path.mkpath
+        logstash_data_file_path = logstash_data_path.join("logstash_jdbc_last_run")
+
+        ensure_default_metadatafile_location(logstash_data_file_path)
+
+        @last_run_metadata_file_path = logstash_data_file_path.to_path
+      else
+        #  validate the path is a file and not a directory
+        if Pathname.new(@last_run_metadata_path).directory?
+          raise LogStash::ConfigurationError.new("The \"last_run_metadata_path\" argument must point to a file, received a directory: \"#{last_run_metadata_path}\"")
+        end
+        @last_run_metadata_file_path = @last_run_metadata_path
+      end
+    end
 
     if @use_column_value
       # Raise an error if @use_column_value is true, but no @tracking_column is set
@@ -259,8 +282,8 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
       end
     end
 
-    set_value_tracker(LogStash::PluginMixins::Jdbc::ValueTracking.build_last_value_tracker(self))
-    set_statement_logger(LogStash::PluginMixins::Jdbc::CheckedCountLogger.new(@logger))
+    set_value_tracker LogStash::PluginMixins::Jdbc::ValueTracking.build_last_value_tracker(self)
+    set_statement_handler LogStash::PluginMixins::Jdbc::StatementHandler.build_statement_handler(self)
 
     @enable_encoding = !@charset.nil? || !@columns_charset.empty?
 
@@ -280,11 +303,25 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
         converters[encoding] = converter
       end
     end
+
+    load_driver
+    begin
+      open_jdbc_connection
+    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?
+      @logger.warn("Exception when executing JDBC query", details)
+      raise(LogStash::ConfigurationError, "Can't create a connection pool to the database")
+    end
   end # def register
 
   # test injection points
-  def set_statement_logger(instance)
-    @statement_handler = LogStash::PluginMixins::Jdbc::StatementHandler.build_statement_handler(self, instance)
+  def set_statement_handler(handler)
+    @statement_handler = handler
   end
 
   def set_value_tracker(instance)
@@ -292,24 +329,17 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
   end
 
   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
@@ -363,4 +393,23 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
       value
     end
   end
+
+  def ensure_default_metadatafile_location(metadata_new_path)
+    old_default_path = Pathname.new("#{ENV['HOME']}/.logstash_jdbc_last_run")
+
+    if old_default_path.exist? && !metadata_new_path.exist?
+      # Previous versions of the plugin hosted the state file into $HOME/.logstash_jdbc_last_run.
+      # Copy in the new location
+      FileUtils.cp(old_default_path.to_path, metadata_new_path.to_path)
+      begin
+        # If there is a permission error in the delete of the old file inform the user to give
+        # the correct access rights
+        ::File.delete(old_default_path.to_path)
+        @logger.info("Successfully moved the #{old_default_path.to_path} into #{metadata_new_path.to_path}")
+      rescue => e
+        @logger.warn("Using new metadata file at #{metadata_new_path.to_path} but #{old_default_path} can't be removed.")
+      end
+    end
+  end
+
 end end end # class LogStash::Inputs::Jdbc

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

@@ -24,7 +24,8 @@ module LogStash module PluginMixins module Jdbc
       return @driver_impl if @driver_impl ||= nil
 
       require "java"
-      require "sequel"
+
+      require_relative "sequel_bootstrap"
       require "sequel/adapters/jdbc"
 
       # execute all the driver loading related duties in a serial fashion to avoid

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

@@ -4,7 +4,7 @@ require "logstash/config/mixin"
 require "time"
 require "date"
 require_relative "value_tracking"
-require_relative "checked_count_logger"
+require_relative "timezone_proxy"
 require_relative "statement_handler"
 
 java_import java.util.concurrent.locks.ReentrantLock
@@ -83,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.
       #
@@ -103,6 +104,11 @@ module LogStash  module PluginMixins module Jdbc
       # Number of seconds to sleep between connection attempts
       config :connection_retry_attempts_wait_time, :validate => :number, :default => 0.5
 
+      # Maximum number of times to try running statement
+      config :statement_retry_attempts, :validate => :number, :default => 1
+      # Number of seconds to sleep between statement execution
+      config :statement_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
@@ -158,7 +164,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)
@@ -187,31 +193,24 @@ module LogStash  module PluginMixins module Jdbc
       end
     end
 
-    public
-    def prepare_jdbc_connection
-      @connection_lock = ReentrantLock.new
-    end
-
     public
     def close_jdbc_connection
       begin
         # pipeline restarts can also close the jdbc connection, block until the current executing statement is finished to avoid leaking connections
         # connections in use won't really get closed
-        @connection_lock.lock
         @database.disconnect if @database
       rescue => e
         @logger.warn("Failed to close connection", :exception => e)
-      ensure
-        @connection_lock.unlock
       end
     end
 
     public
     def execute_statement
       success = false
+      retry_attempts = @statement_retry_attempts
+
       begin
-        @connection_lock.lock
-        open_jdbc_connection
+        retry_attempts -= 1
         sql_last_value = @use_column_value ? @value_tracker.value : Time.now.utc
         @tracking_column_warning_sent = false
         @statement_handler.perform_query(@database, @value_tracker.value) do |row|
@@ -219,17 +218,23 @@ 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::Error, 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?
         @logger.warn("Exception when executing JDBC query", details)
+
+        if retry_attempts == 0
+          @logger.error("Unable to execute statement. Tried #{@statement_retry_attempts} times.")
+        else
+          @logger.error("Unable to execute statement. Trying again.")
+          sleep(@statement_retry_attempts_wait_time)
+          retry
+        end
       else
         @value_tracker.set_value(sql_last_value)
-      ensure
-        close_jdbc_connection
-        @connection_lock.unlock
       end
+
       return success
     end
 

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require "sequel"
+
+# prevent Sequel's datetime_class from being modified,
+# and ensure behaviour is restored to the library's default
+# if something else in the Ruby VM has already changed it.
+Sequel.synchronize do
+  def Sequel.datetime_class=(klass)
+    # noop
+  end
+  def Sequel.datetime_class
+    ::Time
+  end
+end
+
+# load the named_timezones extension, which will attempt to
+# override the global Sequel::datetime_class; for safety,
+# we reset it once more.
+Sequel.extension(:named_timezones)
+Sequel.datetime_class = ::Time