logstash-integration-jdbc 5.1.7 → 5.2.1

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 631bf72cc9e0bb40840f5e7537919e0501a766ddc020a970508004dbebe19d9e
4
- data.tar.gz: d712fc0933239f37b56c88b3cfb7de121452ea07901ed7a17ce6339b0f351fc5
3
+ metadata.gz: 5826d365fd1f0f71ef3562e40e51d68b9bf76585bbd536eb5868a56c5bb6aacb
4
+ data.tar.gz: 5ae08858db8043a0840d7a8578eae295e99b6a1da4ca3ec9239ee0730298188e
5
5
  SHA512:
6
- metadata.gz: 304d561709459feb36273bfb95cfb8dcc50aa86f2fe39d9f0af7153cdef5dbdbe91c934d8bf5c015f2c7b16ccba679042e8713f6460101b626bce79c7d2d1d3a
7
- data.tar.gz: 220f00788a142ec81d5b00b0fd370ae15a02709553a28679351e04d1551252c080f2a6f62a11d1a61fe832f2e77ca0259d31b570834242277d18a09670ee38c3
6
+ metadata.gz: 685637b889432ff5378e6c9873a90b183a90337a011d9719c17b6928721fbef01e393b111f35d2d4d19e7a8bc62eeffd98d93964e46494f486b93f7a9b45bff3
7
+ data.tar.gz: 30f804b0e420b7485da98805e80902ae2d8b33417256938706ba79f0f20fe62d8da2bec9a6c716e50a30f3455f0cb86f6757eef9811e631685f3e620c8c6a604
data/CHANGELOG.md CHANGED
@@ -1,3 +1,25 @@
1
+ ## 5.2.1
2
+ - Refactor: isolate paginated normal statement algorithm in a separate handler [#101](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/101)
3
+
4
+ ## 5.2.0
5
+ - Added `jdbc_paging_mode` option to choose if use `explicit` pagination in statements and avoid the initial count
6
+ query or use `auto` to delegate to the underlying library [#95](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/95)
7
+
8
+ ## 5.1.10
9
+ - Refactor: to explicit Java (driver) class name loading [#96](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/96),
10
+ the change is expected to provide a more robust fix for the driver loading issue [#83](https://github.com/logstash-plugins/logstash-integration-jdbc/issues/83).
11
+
12
+ NOTE: a fatal driver error will no longer keep reloading the pipeline and now leads to a system exit.
13
+
14
+ - Fix: regression due returning the Java driver class [#98](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/98)
15
+
16
+ ## 5.1.9 (yanked)
17
+ - Refactor: to explicit Java (driver) class name loading [#96](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/96),
18
+ the change is expected to provide a more robust fix for the driver loading issue [#83](https://github.com/logstash-plugins/logstash-integration-jdbc/issues/83).
19
+
20
+ ## 5.1.8
21
+ - Fix the blocking pipeline reload and shutdown when connectivity issues happen [#85](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/85)
22
+
1
23
  ## 5.1.7
2
24
  - Normalize jdbc_driver_class loading to support any top-level java packages [#86](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/86)
3
25
 
@@ -129,6 +129,9 @@ Here is the list:
129
129
  |sql_last_value | The value used to calculate which rows to query. Before any query is run,
130
130
  this is set to Thursday, 1 January 1970, or 0 if `use_column_value` is true and
131
131
  `tracking_column` is set. It is updated accordingly after subsequent queries are run.
132
+ |offset, size| Values used with manual paging mode to explicitly implement the paging.
133
+ Supported only if <<plugins-{type}s-{plugin}-jdbc_paging_enabled>> is enabled and
134
+ <<plugins-{type}s-{plugin}-jdbc_paging_mode>> has the `explicit` value.
132
135
  |==========================================================
133
136
 
134
137
  Example:
@@ -153,7 +156,7 @@ NOTE: Not all JDBC accessible technologies will support prepared statements.
153
156
  With the introduction of Prepared Statement support comes a different code execution path and some new settings. Most of the existing settings are still useful but there are several new settings for Prepared Statements to read up on.
154
157
  Use the boolean setting `use_prepared_statements` to enable this execution mode. Use the `prepared_statement_name` setting to specify a name for the Prepared Statement, this identifies the prepared statement locally and remotely and it should be unique in your config and on the database. Use the `prepared_statement_bind_values` array setting to specify the bind values, use the exact string `:sql_last_value` (multiple times if necessary) for the predefined parameter mentioned before. The `statement` (or `statement_path`) setting still holds the SQL statement but to use bind variables you must use the `?` character as a placeholder in the exact order found in the `prepared_statement_bind_values` array.
155
158
 
156
- NOTE: Building count queries around a prepared statement is not supported at this time and because jdbc paging uses count queries under the hood, jdbc paging is not supported with prepared statements at this time either. Therefore, `jdbc_paging_enabled`, `jdbc_page_size` settings are ignored when using prepared statements.
159
+ NOTE: Building count queries around a prepared statement is not supported at this time. Because jdbc paging uses count queries when `jdbc_paging_mode` has value `auto`,jdbc paging is not supported with prepared statements at this time either. Therefore, `jdbc_paging_enabled`, `jdbc_page_size` settings are ignored when using prepared statements.
157
160
 
158
161
  Example:
159
162
  [source,ruby]
@@ -193,6 +196,7 @@ This plugin supports the following configuration options plus the <<plugins-{typ
193
196
  | <<plugins-{type}s-{plugin}-jdbc_fetch_size>> |<<number,number>>|No
194
197
  | <<plugins-{type}s-{plugin}-jdbc_page_size>> |<<number,number>>|No
195
198
  | <<plugins-{type}s-{plugin}-jdbc_paging_enabled>> |<<boolean,boolean>>|No
199
+ | <<plugins-{type}s-{plugin}-jdbc_paging_mode>> |<<string,string>>, one of `["auto", "explicit"]`|No
196
200
  | <<plugins-{type}s-{plugin}-jdbc_password>> |<<password,password>>|No
197
201
  | <<plugins-{type}s-{plugin}-jdbc_password_filepath>> |a valid filesystem path|No
198
202
  | <<plugins-{type}s-{plugin}-jdbc_pool_timeout>> |<<number,number>>|No
@@ -373,6 +377,52 @@ result-set. The limit size is set with `jdbc_page_size`.
373
377
 
374
378
  Be aware that ordering is not guaranteed between queries.
375
379
 
380
+ [id="plugins-{type}s-{plugin}-jdbc_paging_mode"]
381
+ ===== `jdbc_paging_mode`
382
+
383
+ * Value can be any of: `auto`, `explicit`
384
+ * Default value is `"auto"`
385
+
386
+ Whether to use `explicit` or `auto` mode during the JDBC paging
387
+
388
+ If `auto`, your statement will be automatically surrounded by a count query and subsequent multiple paged queries (with `LIMIT` statement, etc.).
389
+
390
+ If `explicit`, multiple queries (without a count query ahead) will be performed with your statement, until no more rows are retrieved.
391
+ You have to write your own paging conditions in your statement configuration.
392
+ The `offset` and `size` parameters can be used in your statement (`size` equal to `jdbc_page_size`, and `offset` incremented by `size` for each query).
393
+ When the number of rows returned by the query is not equal to `size`, SQL paging will be ended.
394
+ Example:
395
+
396
+ [source, ruby]
397
+ ------------------------------------------------------
398
+ input {
399
+ jdbc {
400
+ statement => "SELECT id, mycolumn1, mycolumn2 FROM my_table WHERE id > :sql_last_value LIMIT :size OFFSET :offset",
401
+ jdbc_paging_enabled => true,
402
+ jdbc_paging_mode => "explicit",
403
+ jdbc_page_size => 100000
404
+ }
405
+ }
406
+ ------------------------------------------------------
407
+
408
+ [source, ruby]
409
+ ------------------------------------------------------
410
+ input {
411
+ jdbc {
412
+ statement => "CALL fetch_my_data(:sql_last_value, :offset, :size)",
413
+ jdbc_paging_enabled => true,
414
+ jdbc_paging_mode => "explicit",
415
+ jdbc_page_size => 100000
416
+ }
417
+ }
418
+ ------------------------------------------------------
419
+
420
+ This mode can be considered in the following situations:
421
+
422
+ . Performance issues encountered in default paging mode.
423
+ . Your SQL statement is complex, so simply surrounding it with paging statements is not what you want.
424
+ . Your statement is a stored procedure, and the actual paging statement is inside it.
425
+
376
426
  [id="plugins-{type}s-{plugin}-jdbc_password"]
377
427
  ===== `jdbc_password`
378
428
 
@@ -1,9 +1,12 @@
1
+ require 'jruby'
1
2
 
2
3
  module LogStash module PluginMixins module Jdbc
3
4
  module Common
4
5
 
5
6
  private
6
7
 
8
+ # NOTE: using the JRuby mechanism to load classes (through JavaSupport)
9
+ # makes the lock redundant although it does not hurt to have it around.
7
10
  DRIVERS_LOADING_LOCK = java.util.concurrent.locks.ReentrantLock.new()
8
11
 
9
12
  def complete_sequel_opts(defaults = {})
@@ -30,16 +33,16 @@ module LogStash module PluginMixins module Jdbc
30
33
  begin
31
34
  load_driver_jars
32
35
  begin
33
- @driver_impl = Sequel::JDBC.load_driver(normalized_driver_class)
34
- rescue Sequel::AdapterNotFound => e # Sequel::AdapterNotFound, "#{@jdbc_driver_class} not loaded"
35
- # fix this !!!
36
+ @driver_impl = load_jdbc_driver_class
37
+ rescue => e # catch java.lang.ClassNotFoundException, potential errors
38
+ # (e.g. ExceptionInInitializerError or LinkageError) won't get caught
36
39
  message = if jdbc_driver_library_set?
37
40
  "Are you sure you've included the correct jdbc driver in :jdbc_driver_library?"
38
41
  else
39
42
  ":jdbc_driver_library is not set, are you sure you included " +
40
43
  "the proper driver client libraries in your classpath?"
41
44
  end
42
- raise LogStash::PluginLoadingError, "#{e}. #{message} #{e.backtrace}"
45
+ raise LogStash::PluginLoadingError, "#{e.inspect}. #{message}"
43
46
  end
44
47
  ensure
45
48
  DRIVERS_LOADING_LOCK.unlock()
@@ -71,16 +74,16 @@ module LogStash module PluginMixins module Jdbc
71
74
  !@jdbc_driver_library.nil? && !@jdbc_driver_library.empty?
72
75
  end
73
76
 
74
- # normalizing the class name to always have a Java:: prefix
75
- # is helpful since JRuby is only able to directly load class names
76
- # whose top-level package is com, org, java, javax
77
- # There are many jdbc drivers that use cc, io, net, etc.
78
- def normalized_driver_class
79
- if @jdbc_driver_class.start_with?("Java::", "Java.")
80
- @jdbc_driver_class
81
- else
82
- "Java::#{@jdbc_driver_class}"
83
- end
77
+ def load_jdbc_driver_class
78
+ # sub a potential: 'Java::org::my.Driver' to 'org.my.Driver'
79
+ klass = @jdbc_driver_class.gsub('::', '.').sub(/^Java\./, '')
80
+ # NOTE: JRuby's Java::JavaClass.for_name which considers the custom class-loader(s)
81
+ # in 9.3 the API changed and thus to avoid surprises we go down to the Java API :
82
+ klass = JRuby.runtime.getJavaSupport.loadJavaClass(klass) # throws ClassNotFoundException
83
+ # unfortunately we can not simply return the wrapped java.lang.Class instance as
84
+ # Sequel assumes to be able to do a `driver_class.new` which only works on the proxy,
85
+ org.jruby.javasupport.Java.getProxyClass(JRuby.runtime, klass)
84
86
  end
87
+
85
88
  end
86
89
  end end end
@@ -55,6 +55,9 @@ module LogStash module PluginMixins module Jdbc
55
55
  # Be aware that ordering is not guaranteed between queries.
56
56
  config :jdbc_paging_enabled, :validate => :boolean, :default => false
57
57
 
58
+ # Which pagination mode to use, automatic pagination or explicitly defined in the query.
59
+ config :jdbc_paging_mode, :validate => [ "auto", "explicit" ], :default => "auto"
60
+
58
61
  # JDBC page size
59
62
  config :jdbc_page_size, :validate => :number, :default => 100000
60
63
 
@@ -168,8 +171,6 @@ module LogStash module PluginMixins module Jdbc
168
171
  @logger.warn("Failed test_connection with java.sql.SQLException.", :exception => e)
169
172
  rescue Sequel::DatabaseConnectionError => e
170
173
  @logger.warn("Failed test_connection.", :exception => e)
171
- close_jdbc_connection
172
-
173
174
  #TODO return false and let the plugin raise a LogStash::ConfigurationError
174
175
  raise e
175
176
  end
@@ -208,12 +209,12 @@ module LogStash module PluginMixins module Jdbc
208
209
  public
209
210
  def execute_statement
210
211
  success = false
211
- @connection_lock.lock
212
- open_jdbc_connection
213
212
  begin
213
+ @connection_lock.lock
214
+ open_jdbc_connection
214
215
  sql_last_value = @use_column_value ? @value_tracker.value : Time.now.utc
215
216
  @tracking_column_warning_sent = false
216
- @statement_handler.perform_query(@database, @value_tracker.value, @jdbc_paging_enabled, @jdbc_page_size) do |row|
217
+ @statement_handler.perform_query(@database, @value_tracker.value) do |row|
217
218
  sql_last_value = get_column_value(row) if @use_column_value
218
219
  yield extract_values_from(row)
219
220
  end
@@ -3,7 +3,19 @@
3
3
  module LogStash module PluginMixins module Jdbc
4
4
  class StatementHandler
5
5
  def self.build_statement_handler(plugin, logger)
6
- klass = plugin.use_prepared_statements ? PreparedStatementHandler : NormalStatementHandler
6
+ if plugin.use_prepared_statements
7
+ klass = PreparedStatementHandler
8
+ else
9
+ if plugin.jdbc_paging_enabled
10
+ if plugin.jdbc_paging_mode == "explicit"
11
+ klass = ExplicitPagingModeStatementHandler
12
+ else
13
+ klass = PagedNormalStatementHandler
14
+ end
15
+ else
16
+ klass = NormalStatementHandler
17
+ end
18
+ end
7
19
  klass.new(plugin, logger)
8
20
  end
9
21
 
@@ -25,22 +37,14 @@ module LogStash module PluginMixins module Jdbc
25
37
  end
26
38
 
27
39
  class NormalStatementHandler < StatementHandler
28
- # Performs the query, respecting our pagination settings, yielding once per row of data
40
+ # Performs the query, yielding once per row of data
29
41
  # @param db [Sequel::Database]
30
- # @param sql_last_value [Integet|DateTime|Time]
42
+ # @param sql_last_value [Integer|DateTime|Time]
31
43
  # @yieldparam row [Hash{Symbol=>Object}]
32
- def perform_query(db, sql_last_value, jdbc_paging_enabled, jdbc_page_size)
44
+ def perform_query(db, sql_last_value)
33
45
  query = build_query(db, sql_last_value)
34
- if jdbc_paging_enabled
35
- query.each_page(jdbc_page_size) do |paged_dataset|
36
- paged_dataset.each do |row|
37
- yield row
38
- end
39
- end
40
- else
41
- query.each do |row|
42
- yield row
43
- end
46
+ query.each do |row|
47
+ yield row
44
48
  end
45
49
  end
46
50
 
@@ -67,6 +71,48 @@ module LogStash module PluginMixins module Jdbc
67
71
  end
68
72
  end
69
73
 
74
+ class PagedNormalStatementHandler < NormalStatementHandler
75
+ attr_reader :jdbc_page_size
76
+
77
+ # Performs the query, respecting our pagination settings, yielding once per row of data
78
+ # @param db [Sequel::Database]
79
+ # @param sql_last_value [Integer|DateTime|Time]
80
+ # @yieldparam row [Hash{Symbol=>Object}]
81
+ def perform_query(db, sql_last_value)
82
+ query = build_query(db, sql_last_value)
83
+ query.each_page(@jdbc_page_size) do |paged_dataset|
84
+ paged_dataset.each do |row|
85
+ yield row
86
+ end
87
+ end
88
+ end
89
+
90
+ def post_init(plugin)
91
+ super(plugin)
92
+ @jdbc_page_size = plugin.jdbc_page_size
93
+ end
94
+ end
95
+
96
+ class ExplicitPagingModeStatementHandler < PagedNormalStatementHandler
97
+ # Performs the query, respecting our pagination settings, yielding once per row of data
98
+ # @param db [Sequel::Database]
99
+ # @param sql_last_value [Integer|DateTime|Time]
100
+ # @yieldparam row [Hash{Symbol=>Object}]
101
+ def perform_query(db, sql_last_value)
102
+ query = build_query(db, sql_last_value)
103
+ offset = 0
104
+ loop do
105
+ rows_in_page = 0
106
+ query.with_sql(query.sql, offset: offset, size: jdbc_page_size).each do |row|
107
+ yield row
108
+ rows_in_page += 1
109
+ end
110
+ break unless rows_in_page == jdbc_page_size
111
+ offset += jdbc_page_size
112
+ end
113
+ end
114
+ end
115
+
70
116
  class PreparedStatementHandler < StatementHandler
71
117
  attr_reader :name, :bind_values_array, :statement_prepared, :prepared
72
118
 
@@ -74,7 +120,7 @@ module LogStash module PluginMixins module Jdbc
74
120
  # @param db [Sequel::Database]
75
121
  # @param sql_last_value [Integet|DateTime|Time]
76
122
  # @yieldparam row [Hash{Symbol=>Object}]
77
- def perform_query(db, sql_last_value, jdbc_paging_enabled, jdbc_page_size)
123
+ def perform_query(db, sql_last_value)
78
124
  query = build_query(db, sql_last_value)
79
125
  query.each do |row|
80
126
  yield row
@@ -1,6 +1,6 @@
1
1
  Gem::Specification.new do |s|
2
2
  s.name = 'logstash-integration-jdbc'
3
- s.version = '5.1.7'
3
+ s.version = '5.2.1'
4
4
  s.licenses = ['Apache License (2.0)']
5
5
  s.summary = "Integration with JDBC - input and filter plugins"
6
6
  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"
@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
41
41
  s.add_runtime_dependency "logstash-mixin-event_support", '~> 1.0'
42
42
 
43
43
  s.add_development_dependency "childprocess"
44
- s.add_development_dependency 'logstash-devutils'
44
+ s.add_development_dependency 'logstash-devutils', '>= 2.3'
45
45
  s.add_development_dependency 'timecop'
46
46
  s.add_development_dependency 'jdbc-derby'
47
47
  end
@@ -66,13 +66,13 @@ describe LogStash::Inputs::Jdbc, :integration => true do
66
66
  )
67
67
  end
68
68
 
69
- it "should not register correctly" do
69
+ it "log warning msg when plugin run" do
70
70
  plugin.register
71
- allow( plugin ).to receive(:log_java_exception)
71
+ expect( plugin ).to receive(:log_java_exception)
72
+ expect(plugin.logger).to receive(:warn).once.with("Exception when executing JDBC query",
73
+ hash_including(:exception => instance_of(String)))
72
74
  q = Queue.new
73
- expect do
74
- plugin.run(q)
75
- end.to raise_error(::Sequel::DatabaseConnectionError)
75
+ expect{ plugin.run(q) }.not_to raise_error
76
76
  end
77
77
 
78
78
  it "should log (native) Java driver error" do
@@ -85,9 +85,7 @@ describe LogStash::Inputs::Jdbc, :integration => true do
85
85
  logger
86
86
  end
87
87
  q = Queue.new
88
- expect do
89
- plugin.run(q)
90
- end.to raise_error(::Sequel::DatabaseConnectionError)
88
+ expect{ plugin.run(q) }.not_to raise_error
91
89
  end
92
90
  end
93
91
  end
@@ -329,6 +329,39 @@ describe LogStash::Inputs::Jdbc do
329
329
 
330
330
  end
331
331
 
332
+ context "when iterating result-set via explicit paging mode" do
333
+
334
+ let(:settings) do
335
+ {
336
+ "statement" => "SELECT * from test_table OFFSET :offset ROWS FETCH NEXT :size ROWS ONLY",
337
+ "jdbc_paging_enabled" => true,
338
+ "jdbc_paging_mode" => "explicit",
339
+ "jdbc_page_size" => 10
340
+ }
341
+ end
342
+
343
+ let(:num_rows) { 15 }
344
+
345
+ before do
346
+ plugin.register
347
+ end
348
+
349
+ after do
350
+ plugin.stop
351
+ end
352
+
353
+ it "should fetch all rows" do
354
+ num_rows.times do
355
+ db[:test_table].insert(:num => 1, :custom_time => Time.now.utc, :created_at => Time.now.utc)
356
+ end
357
+
358
+ plugin.run(queue)
359
+
360
+ expect(queue.size).to eq(num_rows)
361
+ end
362
+
363
+ end
364
+
332
365
  context "when using target option" do
333
366
  let(:settings) do
334
367
  {
@@ -1393,10 +1426,8 @@ describe LogStash::Inputs::Jdbc do
1393
1426
  event = queue.pop
1394
1427
  expect(event.get("num")).to eq(1)
1395
1428
  expect(event.get("string")).to eq("A test")
1396
- expect(event.get("started_at")).to be_a(LogStash::Timestamp)
1397
- expect(event.get("started_at").to_s).to eq("1999-12-31T00:00:00.000Z")
1398
- expect(event.get("custom_time")).to be_a(LogStash::Timestamp)
1399
- expect(event.get("custom_time").to_s).to eq("1999-12-31T23:59:59.000Z")
1429
+ expect(event.get("started_at")).to be_a_logstash_timestamp_equivalent_to("1999-12-31T00:00:00.000Z")
1430
+ expect(event.get("custom_time")).to be_a_logstash_timestamp_equivalent_to("1999-12-31T23:59:59.000Z")
1400
1431
  expect(event.get("ranking").to_f).to eq(95.67)
1401
1432
  end
1402
1433
  end
@@ -1442,10 +1473,8 @@ describe LogStash::Inputs::Jdbc do
1442
1473
  event = queue.pop
1443
1474
  expect(event.get("num")).to eq(1)
1444
1475
  expect(event.get("string")).to eq("A test")
1445
- expect(event.get("started_at")).to be_a(LogStash::Timestamp)
1446
- expect(event.get("started_at").to_s).to eq("1999-12-31T00:00:00.000Z")
1447
- expect(event.get("custom_time")).to be_a(LogStash::Timestamp)
1448
- expect(event.get("custom_time").to_s).to eq("1999-12-31T23:59:59.000Z")
1476
+ expect(event.get("started_at")).to be_a_logstash_timestamp_equivalent_to("1999-12-31T00:00:00.000Z")
1477
+ expect(event.get("custom_time")).to be_a_logstash_timestamp_equivalent_to("1999-12-31T23:59:59.000Z")
1449
1478
  expect(event.get("ranking").to_f).to eq(95.67)
1450
1479
  end
1451
1480
  end
@@ -1624,16 +1653,35 @@ describe LogStash::Inputs::Jdbc do
1624
1653
  describe "jdbc_driver_class" do
1625
1654
  context "when not prefixed with Java::" do
1626
1655
  let(:jdbc_driver_class) { "org.apache.derby.jdbc.EmbeddedDriver" }
1627
- it "loads the class prefixed with Java::" do
1628
- expect(Sequel::JDBC).to receive(:load_driver).with(/^Java::/)
1629
- plugin.send(:load_driver)
1656
+ it "loads the class" do
1657
+ expect { plugin.send(:load_driver) }.not_to raise_error
1630
1658
  end
1631
1659
  end
1632
1660
  context "when prefixed with Java::" do
1633
1661
  let(:jdbc_driver_class) { "Java::org.apache.derby.jdbc.EmbeddedDriver" }
1634
- it "loads the class as-is" do
1635
- expect(Sequel::JDBC).to receive(:load_driver).with(jdbc_driver_class)
1636
- plugin.send(:load_driver)
1662
+ it "loads the class" do
1663
+ expect { plugin.send(:load_driver) }.not_to raise_error
1664
+ end
1665
+ end
1666
+ context "when prefixed with Java." do
1667
+ let(:jdbc_driver_class) { "Java.org::apache::derby::jdbc.EmbeddedDriver" }
1668
+ it "loads the class" do
1669
+ expect { plugin.send(:load_driver) }.not_to raise_error
1670
+ end
1671
+
1672
+ it "can instantiate the returned driver class" do
1673
+ # for drivers where the path through DriverManager fails, Sequel assumes
1674
+ # having a proxied Java class instance (instead of a java.lang.Class) and
1675
+ # does a driver.new.connect https://git.io/JDV6M
1676
+ driver = plugin.send(:load_driver)
1677
+ expect { driver.new }.not_to raise_error
1678
+ end
1679
+ end
1680
+ context "when class name invalid" do
1681
+ let(:jdbc_driver_class) { "org.apache.NonExistentDriver" }
1682
+ it "raises a loading error" do
1683
+ expect { plugin.send(:load_driver) }.to raise_error LogStash::PluginLoadingError,
1684
+ /java.lang.ClassNotFoundException: org.apache.NonExistentDriver/
1637
1685
  end
1638
1686
  end
1639
1687
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: logstash-integration-jdbc
3
3
  version: !ruby/object:Gem::Version
4
- version: 5.1.7
4
+ version: 5.2.1
5
5
  platform: ruby
6
6
  authors:
7
7
  - Elastic
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2021-10-28 00:00:00.000000000 Z
11
+ date: 2021-12-22 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  requirement: !ruby/object:Gem::Requirement
@@ -203,7 +203,7 @@ dependencies:
203
203
  requirements:
204
204
  - - ">="
205
205
  - !ruby/object:Gem::Version
206
- version: '0'
206
+ version: '2.3'
207
207
  name: logstash-devutils
208
208
  prerelease: false
209
209
  type: :development
@@ -211,7 +211,7 @@ dependencies:
211
211
  requirements:
212
212
  - - ">="
213
213
  - !ruby/object:Gem::Version
214
- version: '0'
214
+ version: '2.3'
215
215
  - !ruby/object:Gem::Dependency
216
216
  requirement: !ruby/object:Gem::Requirement
217
217
  requirements: