logstash-integration-jdbc 5.0.3 → 5.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c64a823a0973adc161faebb9a8d71fbaa19b8815ebac92dbb5a85dca53a9941
-  data.tar.gz: effe43eb271c805374fd39084c54d4b522067a1cbaa6bc5f0efe5ad1a9264aa4
+  metadata.gz: c112f66e8224282b05dd0d43c1eb864164629951ebd9f2fdbc5d08514731057f
+  data.tar.gz: 69ee8e0cf79f4f4be6d4f0aae5b3f95a1fae46e3458c6a840e23722f9bbb8a60
 SHA512:
-  metadata.gz: 43b515624423bd156a471b51ed83545b91875cb364277ef79e5685ab0a019744dbe37227ec230a20f11b164df76187e4df3b4f7961aa1672ee8b36d1338e8ec8
-  data.tar.gz: abf96d5cd6c97f3896e60395f5f390f6e67e308e168bdbc996d095ecb5a7e0eef6e89f224a91ee0f2908210b78e852b85ab3441f660fdda2cb6cd43b3374d74c
+  metadata.gz: 8cc11af1a041fbb7784603be07de4243844bffbdfb980bf0f3ff4394af95d3ea2ed9da8543673f7fa866d999c9ba3df772567b64f31538eb8336cbf68283d39d
+  data.tar.gz: 9bc94ac7a6575a5ac797a44f8a8d987978a1bd0816733f252d80924e945a89b54383df101b2381b3d95afa2090149b7bdbdac1fb7dce06f34bd3fa987fba3354

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 5.0.4
+  - Fixed issue where JDBC Drivers that don't correctly register with Java's DriverManager fail to load (such as Sybase) [#34](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/34)
+
 ## 5.0.3
   - Fixed issue where a lost connection to the database can cause errors when using prepared statements with the scheduler [#25](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/25)
 

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

@@ -95,7 +95,7 @@ module LogStash module Filters module Jdbc
       end
       begin
         db = nil
-        ::Sequel::JDBC.load_driver(driver_class)
+        @options_hash[:driver] = ::Sequel::JDBC.load_driver(driver_class)
         @connection_string = connection_string
         if user
           @options_hash[:user] = user

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

@@ -110,13 +110,14 @@ module LogStash  module PluginMixins module Jdbc
       :user => @jdbc_user,
       :password => @jdbc_password.nil? ? nil : @jdbc_password.value,
       :pool_timeout => @jdbc_pool_timeout,
+      :driver => @driver_impl, # Sequel uses this as a fallback, if given URI doesn't auto-load the driver correctly
       :keep_reference => false
       }.merge(@sequel_opts)
       retry_attempts = @connection_retry_attempts
       loop do
         retry_attempts -= 1
         begin
-          return Sequel.connect(@jdbc_connection_string, opts=opts)
+          return Sequel.connect(@jdbc_connection_string, opts)
         rescue Sequel::PoolTimeout => e
           if retry_attempts <= 0
             @logger.error("Failed to connect to database. #{@jdbc_pool_timeout} second timeout exceeded. Tried #{@connection_retry_attempts} times.")
@@ -147,7 +148,7 @@ module LogStash  module PluginMixins module Jdbc
 
         load_driver_jars
         begin
-          Sequel::JDBC.load_driver(@jdbc_driver_class)
+          @driver_impl = Sequel::JDBC.load_driver(@jdbc_driver_class)
         rescue Sequel::AdapterNotFound => e # Sequel::AdapterNotFound, "#{@jdbc_driver_class} not loaded"
           # fix this !!!
           message = if jdbc_driver_library_set?

data/lib/logstash/plugin_mixins/jdbc_streaming.rb

@@ -84,7 +84,7 @@ module LogStash module PluginMixins module JdbcStreaming
     @sequel_opts_symbols[:user] = @jdbc_user unless @jdbc_user.nil? || @jdbc_user.empty?
     @sequel_opts_symbols[:password] = @jdbc_password.value unless @jdbc_password.nil?
 
-    Sequel::JDBC.load_driver(@jdbc_driver_class)
+    @sequel_opts_symbols[:driver] = Sequel::JDBC.load_driver(@jdbc_driver_class)
     @database = Sequel.connect(@jdbc_connection_string, @sequel_opts_symbols)
     if @jdbc_validate_connection
       @database.extension(:connection_validator)

data/logstash-integration-jdbc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-integration-jdbc'
-  s.version         = '5.0.3'
+  s.version         = '5.0.4'
   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"

data/spec/filters/integration/jdbc_static_spec.rb

@@ -4,7 +4,6 @@ require "logstash/filters/jdbc_static"
 require "sequel"
 require "sequel/adapters/jdbc"
 require "stud/temporary"
-require "timecop"
 
 module LogStash module Filters
   describe JdbcStatic, :integration => true do
@@ -136,18 +135,16 @@ module LogStash module Filters
     describe "scheduled operation" do
       context "given a loader_schedule" do
         it "should properly schedule" do
-          settings["loader_schedule"] = "*/10 * * * * * UTC"
-          Timecop.travel(Time.now.utc - 3600)
-          Timecop.scale(60)
+          settings["loader_schedule"] = "*/3 * * * * * UTC"
           static_filter = JdbcStatic.new(settings)
           runner = Thread.new(static_filter) do |filter|
             filter.register
           end
-          sleep 3
+          runner.join(4)
+          sleep 4
           static_filter.filter(event)
           expect(static_filter.loader_runner.reload_count).to be > 1
           static_filter.close
-          Timecop.return
           expect(event.get("server")).to eq([{"ip"=>"10.3.1.1", "name"=>"mv-server-1", "location"=>"MV-9-6-4"}])
         end
       end

data/spec/filters/jdbc/read_only_database_spec.rb

@@ -10,28 +10,37 @@ module LogStash module Filters module Jdbc
     let(:driver_class) { "org.apache.derby.jdbc.EmbeddedDriver" }
     let(:driver_library) { nil }
     subject(:read_only_db) { described_class.create(connection_string, driver_class, driver_library) }
+    let(:stub_driver_class) { double(driver_class).as_null_object }
 
     describe "basic operations" do
       describe "initializing" do
+        before(:each) do
+          allow(Sequel::JDBC).to receive(:load_driver).and_return(stub_driver_class)
+        end
+
         it "tests the connection with defaults" do
           expect(Sequel::JDBC).to receive(:load_driver).once.with(driver_class)
-          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true})
+          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true, :driver => stub_driver_class})
           expect(read_only_db.empty_record_set).to eq([])
         end
 
-        it "tests the connection with fully specified arguments" do
-          connection_str = "a connection string"
-          user = "a user"
-          password = Util::Password.new("secret")
-          expect(Sequel::JDBC).to receive(:load_driver).once.with("a driver class")
-          expect(Sequel).to receive(:connect).once.with(connection_str, {:user => user, :password =>  password.value, :test => true}).and_return(db)
-          described_class.create(connection_str, "a driver class", nil, user, password)
+        context 'with fully-specified arguments' do
+          let(:connection_string) { "a connection string" }
+          let(:user) { "a user" }
+          let(:password) { Util::Password.new("secret") }
+          let(:driver_class) { "a driver class" }
+
+          it "tests the connection" do
+            expect(Sequel::JDBC).to receive(:load_driver).once.with(driver_class)
+            expect(Sequel).to receive(:connect).once.with(connection_string, {:user => user, :password =>  password.value, :test => true, :driver => stub_driver_class}).and_return(db)
+            described_class.create(connection_string, driver_class, nil, user, password)
+          end
         end
 
         it "connects with defaults" do
           expect(Sequel::JDBC).to receive(:load_driver).once.with(driver_class)
-          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true}).and_return(db)
-          expect(Sequel).to receive(:connect).once.with(connection_string, {}).and_return(db)
+          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true, :driver => stub_driver_class}).and_return(db)
+          expect(Sequel).to receive(:connect).once.with(connection_string, {:driver => stub_driver_class}).and_return(db)
           expect(read_only_db.connected?).to be_falsey
           read_only_db.connect("a caller specific error message")
           expect(read_only_db.connected?).to be_truthy

data/spec/filters/jdbc/read_write_database_spec.rb

@@ -16,10 +16,11 @@ module LogStash module Filters module Jdbc
     describe "basic operations" do
       context "connecting  to a db" do
         it "connects with defaults" do
-          expect(::Sequel::JDBC).to receive(:load_driver).once.with("org.apache.derby.jdbc.EmbeddedDriver")
+          stub_driver_class = double('org.apache.derby.jdbc.EmbeddedDriver').as_null_object
+          expect(::Sequel::JDBC).to receive(:load_driver).once.with("org.apache.derby.jdbc.EmbeddedDriver").and_return(stub_driver_class)
           # two calls to connect because ReadWriteDatabase does verify_connection and connect
-          expect(::Sequel).to receive(:connect).once.with(connection_string_regex, {:test => true}).and_return(db)
-          expect(::Sequel).to receive(:connect).once.with(connection_string_regex, {}).and_return(db)
+          expect(::Sequel).to receive(:connect).once.with(connection_string_regex, {:driver => stub_driver_class, :test => true}).and_return(db)
+          expect(::Sequel).to receive(:connect).once.with(connection_string_regex, {:driver => stub_driver_class}).and_return(db)
           expect(read_write_db.empty_record_set).to eq([])
         end
 
@@ -27,9 +28,10 @@ module LogStash module Filters module Jdbc
           connection_str = "a connection string"
           user = "a user"
           password = Util::Password.new("secret")
-          expect(::Sequel::JDBC).to receive(:load_driver).once.with("a driver class")
-          expect(::Sequel).to receive(:connect).once.with(connection_str, {:user => user, :password => password.value, :test => true}).and_return(db)
-          expect(::Sequel).to receive(:connect).once.with(connection_str, {:user => user, :password => password.value}).and_return(db)
+          stub_driver_class = double('com.example.Driver')
+          expect(::Sequel::JDBC).to receive(:load_driver).once.with("a driver class").and_return(stub_driver_class)
+          expect(::Sequel).to receive(:connect).once.with(connection_str, {:driver => stub_driver_class, :user => user, :password => password.value, :test => true}).and_return(db)
+          expect(::Sequel).to receive(:connect).once.with(connection_str, {:driver => stub_driver_class, :user => user, :password => password.value}).and_return(db)
           described_class.create(connection_str, "a driver class", nil, user, password)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-integration-jdbc
 version: !ruby/object:Gem::Version
-  version: 5.0.3
+  version: 5.0.4
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2020-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement