logstash-integration-jdbc 5.0.3 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c64a823a0973adc161faebb9a8d71fbaa19b8815ebac92dbb5a85dca53a9941
-  data.tar.gz: effe43eb271c805374fd39084c54d4b522067a1cbaa6bc5f0efe5ad1a9264aa4
+  metadata.gz: 59bbd486f1af029b2e7fe07b9356ac1703d864fc9838c3e2275453bf669eae18
+  data.tar.gz: 7f2a890f71fe484bd36935491ca5797795b15bad86f9e52317e385c8546316a9
 SHA512:
-  metadata.gz: 43b515624423bd156a471b51ed83545b91875cb364277ef79e5685ab0a019744dbe37227ec230a20f11b164df76187e4df3b4f7961aa1672ee8b36d1338e8ec8
-  data.tar.gz: abf96d5cd6c97f3896e60395f5f390f6e67e308e168bdbc996d095ecb5a7e0eef6e89f224a91ee0f2908210b78e852b85ab3441f660fdda2cb6cd43b3374d74c
+  metadata.gz: dfb59eb31fd43a12e8baaa3c861f8558ed6158ed1693b7994f147ee035ee46e09c7f041648376cf11c510f86ef72221229944fdae1db3bdf3ec273318fbf6279
+  data.tar.gz: fae0dcec43219c1c98581ee0ff441818c4cafe8cb24d6cae08cc521f74ba4055a21178657fb3e989d9e9f2572c5a750bce975839f62f5309c70cbc096cb03e35

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 5.1.0
+  - Added `target` option to JDBC input, allowing the row columns to target a specific field instead of being expanded 
+    at the root of the event. This allows the input to play nicer with the Elastic Common Schema when 
+    the input does not follow the schema. [#69](https://github.com/logstash-plugins/logstash-integration-jdbc/issues/69)
+    
+  - Added `target` to JDBC filter static `local_lookups` to verify it's properly valued when ECS is enabled. 
+    [#71](https://github.com/logstash-plugins/logstash-integration-jdbc/issues/71)
+
+## 5.0.7
+  - Feat: try hard to log Java cause (chain) [#62](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/62)
+
+    This allows seeing a full trace from the JDBC driver in case of connection errors. 
+
+  - Refactored Lookup used in jdbc_streaming and jdbc_static to avoid code duplication. [#59](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/59)
+
+## 5.0.6
+  - DOC:Replaced plugin_header file with plugin_header-integration file. [#40](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/40)
+
+## 5.0.5
+  - Fixed user sequel_opts not being passed down properly [#37](https://github.com/logstash-plugins/logstash-integration-jdbc/pull/37)
+  - Refactored jdbc_streaming to share driver loading, so the fixes from the jdbc plugin also effect jdbc_streaming
+
+## 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/README.md

@@ -2,7 +2,7 @@
 Logstash Integration Plugin for JDBC, including Logstash Input and Filter Plugins
 # Logstash Plugin
 
-[![Travis Build Status](https://travis-ci.org/logstash-plugins/logstash-integration-jdbc.svg)](https://travis-ci.org/logstash-plugins/logstash-integration-jdbc)
+[![Travis Build Status](https://travis-ci.com/logstash-plugins/logstash-integration-jdbc.svg)](https://travis-ci.com/logstash-plugins/logstash-integration-jdbc)
 
 This is a plugin for [Logstash](https://github.com/elastic/logstash).
 

data/docs/filter-jdbc_static.asciidoc

@@ -1,3 +1,4 @@
+:integration: jdbc
 :plugin: jdbc_static
 :type: filter
 
@@ -16,7 +17,7 @@ END - GENERATED VARIABLES, DO NOT EDIT!
 
 === Jdbc_static filter plugin
 
-include::{include_path}/plugin_header.asciidoc[]
+include::{include_path}/plugin_header-integration.asciidoc[]
 
 ==== Description
 
@@ -421,7 +422,7 @@ according to the table below.
 |=======================================================================
 |Setting |Input type|Required
 | id|string|No
-| table|string|Yes
+| local_table|string|Yes
 | query|string|Yes
 | max_rows|number|No
 | jdbc_connection_string|string|No
@@ -437,7 +438,7 @@ id::
 An optional identifier. This is used to identify the loader that is
 generating error messages and log lines.
 
-table::
+local_table::
 The destination table in the local lookup database that the loader will fill.
 
 query::

data/docs/filter-jdbc_streaming.asciidoc

@@ -1,3 +1,4 @@
+:integration: jdbc
 :plugin: jdbc_streaming
 :type: filter
 
@@ -16,7 +17,7 @@ END - GENERATED VARIABLES, DO NOT EDIT!
 
 === Jdbc_streaming filter plugin
 
-include::{include_path}/plugin_header.asciidoc[]
+include::{include_path}/plugin_header-integration.asciidoc[]
 
 ==== Description
 

data/docs/input-jdbc.asciidoc

@@ -1,3 +1,4 @@
+:integration: jdbc
 :plugin: jdbc
 :type: input
 :default_codec: plain
@@ -17,7 +18,7 @@ END - GENERATED VARIABLES, DO NOT EDIT!
 
 === Jdbc input plugin
 
-include::{include_path}/plugin_header.asciidoc[]
+include::{include_path}/plugin_header-integration.asciidoc[]
 
 ==== Description
 
@@ -210,6 +211,7 @@ This plugin supports the following configuration options plus the <<plugins-{typ
 | <<plugins-{type}s-{plugin}-sql_log_level>> |<<string,string>>, one of `["fatal", "error", "warn", "info", "debug"]`|No
 | <<plugins-{type}s-{plugin}-statement>> |<<string,string>>|No
 | <<plugins-{type}s-{plugin}-statement_filepath>> |a valid filesystem path|No
+| <<plugins-{type}s-{plugin}-target>> | {logstash-ref}/field-references-deepdive.html[field reference] | No
 | <<plugins-{type}s-{plugin}-tracking_column>> |<<string,string>>|No
 | <<plugins-{type}s-{plugin}-tracking_column_type>> |<<string,string>>, one of `["numeric", "timestamp"]`|No
 | <<plugins-{type}s-{plugin}-use_column_value>> |<<boolean,boolean>>|No
@@ -534,6 +536,17 @@ with the `parameters` setting.
 
 Path of file containing statement to execute
 
+[id="plugins-{type}s-{plugin}-target"]
+===== `target`
+
+* Value type is {logstash-ref}/field-references-deepdive.html[field reference]
+* There is no default value for this setting.
+
+Without a `target`, events are created from each row column at the root level.
+When the `target` is set to a field reference, the column of each row is placed in the target field instead.
+
+This option can be useful to avoid populating unknown fields when a downstream schema such as ECS is enforced.
+
 [id="plugins-{type}s-{plugin}-tracking_column"]
 ===== `tracking_column`
 

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/filters/jdbc/lookup.rb

@@ -56,6 +56,12 @@ module LogStash module Filters module Jdbc
       @target = options["target"]
       @id_used_as_target = @target.nil?
       if @id_used_as_target
+        # target shouldn't be nil if ecs_compatibility is not :disabled
+        if globals[:ecs_compatibility] != :disabled
+          logger.info('ECS compatibility is enabled but no ``target`` option was specified, it is recommended'\
+                            ' to set the option to avoid potential schema conflicts (if your data is ECS compliant or'\
+                            ' non-conflicting feel free to ignore this message)')
+        end
         @target = @id
       end
       @options = options
@@ -66,6 +72,7 @@ module LogStash module Filters module Jdbc
       @prepared_statement = nil
       @symbol_parameters = nil
       parse_options
+      @load_method_ref = method(:load_data_from_local)
     end
 
     def id_used_as_target?
@@ -81,11 +88,7 @@ module LogStash module Filters module Jdbc
     end
 
     def enhance(local, event)
-      if @prepared_statement
-        result = call_prepared(local, event)
-      else
-        result = fetch(local, event) # should return a LookupResult
-      end
+      result = retrieve_local_data(local, event, &@load_method_ref) # return a LookupResult
       if result.failed? || result.parameters_invalid?
         tag_failure(event)
       end
@@ -112,6 +115,7 @@ module LogStash module Filters module Jdbc
       @prepared_parameters.each_with_index { |v, i| hash[:"$p#{i}"] = v }
       @prepared_param_placeholder_map = hash
       @prepared_statement = local.prepare(query, hash.keys)
+      @load_method_ref = method(:load_data_from_prepared)
     end
 
     private
@@ -128,34 +132,23 @@ module LogStash module Filters module Jdbc
       end
     end
 
-    def fetch(local, event)
-      result = LookupResult.new()
-      if @parameters_specified
-        params = prepare_parameters_from_event(event, result)
-        if result.parameters_invalid?
-          logger.warn? && logger.warn("Parameter field not found in event", :lookup_id => @id, :invalid_parameters => result.invalid_parameters)
-          return result
-        end
-      else
-        params = {}
+    def load_data_from_local(local, query, params, result)
+      local.fetch(query, params).each do |row|
+        stringified = row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
+        result.push(stringified)
       end
-      begin
-        logger.debug? && logger.debug("Executing Jdbc query", :lookup_id => @id, :statement => query, :parameters => params)
-        local.fetch(query, params).each do |row|
-          stringified = row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
-          result.push(stringified)
-        end
-      rescue ::Sequel::Error => e
-        # all sequel errors are a subclass of this, let all other standard or runtime errors bubble up
-        result.failed!
-        logger.warn? && logger.warn("Exception when executing Jdbc query", :lookup_id => @id, :exception => e.message, :backtrace => e.backtrace.take(8))
+    end
+
+    def load_data_from_prepared(_local, _query, params, result)
+      @prepared_statement.call(params).each do |row|
+        stringified = row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
+        result.push(stringified)
       end
-      # if either of: no records or a Sequel exception occurs the payload is
-      # empty and the default can be substituted later.
-      result
     end
 
-    def call_prepared(local, event)
+    # the &block is invoked with 4 arguments: local, query[String], params[Hash], result[LookupResult]
+    # the result is used as accumulator return variable
+    def retrieve_local_data(local, event, &proc)
       result = LookupResult.new()
       if @parameters_specified
         params = prepare_parameters_from_event(event, result)
@@ -168,10 +161,7 @@ module LogStash module Filters module Jdbc
       end
       begin
         logger.debug? && logger.debug("Executing Jdbc query", :lookup_id => @id, :statement => query, :parameters => params)
-        @prepared_statement.call(params).each do |row|
-          stringified = row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
-          result.push(stringified)
-        end
+        proc.call(local, query, params, result)
       rescue ::Sequel::Error => e
         # all sequel errors are a subclass of this, let all other standard or runtime errors bubble up
         result.failed!

data/lib/logstash/filters/jdbc_static.rb

@@ -2,6 +2,7 @@
 require "logstash-integration-jdbc_jars"
 require "logstash/filters/base"
 require "logstash/namespace"
+require "logstash/plugin_mixins/ecs_compatibility_support"
 require_relative "jdbc/loader"
 require_relative "jdbc/loader_schedule"
 require_relative "jdbc/repeating_load_runner"
@@ -14,6 +15,9 @@ require_relative "jdbc/lookup_processor"
 
 #
 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)
+
   config_name "jdbc_static"
 
   # Define the loaders, an Array of Hashes, to fetch remote data and create local tables.
@@ -214,6 +218,7 @@ module LogStash module Filters class JdbcStatic < LogStash::Filters::Base
     options["lookup_jdbc_driver_class"] = @lookup_jdbc_driver_class
     options["lookup_jdbc_driver_library"] = @lookup_jdbc_driver_library
     options["lookup_jdbc_connection_string"] = @lookup_jdbc_connection_string
+    options["ecs_compatibility"] = ecs_compatibility
     options
   end
 

data/lib/logstash/filters/jdbc_streaming.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 require "logstash/filters/base"
 require "logstash/namespace"
+require "logstash/plugin_mixins/jdbc/common"
 require "logstash/plugin_mixins/jdbc_streaming"
 require "logstash/plugin_mixins/jdbc_streaming/cache_payload"
 require "logstash/plugin_mixins/jdbc_streaming/statement_handler"
@@ -46,6 +47,7 @@ require "lru_redux"
 # }
 #
 module LogStash module Filters class JdbcStreaming < LogStash::Filters::Base
+  include LogStash::PluginMixins::Jdbc::Common
   include LogStash::PluginMixins::JdbcStreaming
 
   config_name "jdbc_streaming"

data/lib/logstash/inputs/jdbc.rb

@@ -1,7 +1,10 @@
 # encoding: utf-8
 require "logstash/inputs/base"
 require "logstash/namespace"
+require "logstash/plugin_mixins/jdbc/common"
 require "logstash/plugin_mixins/jdbc/jdbc"
+require "logstash/plugin_mixins/ecs_compatibility_support"
+require "logstash/plugin_mixins/validator_support/field_reference_validation_adapter"
 
 # 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"
@@ -126,7 +129,13 @@ require_relative "tzinfo_jruby_patch"
 # ---------------------------------------------------------------------------------------------------
 #
 module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
+  include LogStash::PluginMixins::Jdbc::Common
   include LogStash::PluginMixins::Jdbc::Jdbc
+  # adds ecs_compatibility config which could be :disabled or :v1
+  include LogStash::PluginMixins::ECSCompatibilitySupport(:disabled,:v1,:v8 => :v1)
+  # adds :field_reference validator adapter
+  extend LogStash::PluginMixins::ValidatorSupport::FieldReferenceValidationAdapter
+
   config_name "jdbc"
 
   # If undefined, Logstash will complain, even if codec is unused.
@@ -207,6 +216,9 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
 
   config :prepared_statement_bind_values, :validate => :array, :default => []
 
+  # Define the target field to store the loaded columns
+  config :target, :validate => :field_reference, :required => false
+
   attr_reader :database # for test mocking/stubbing
 
   public
@@ -258,6 +270,13 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
         converters[encoding] = converter
       end
     end
+
+    # target must be populated if ecs_compatibility is not :disabled
+    if @target.nil? && ecs_compatibility != :disabled
+      logger.info('ECS compatibility is enabled but no ``target`` option was specified, it is recommended'\
+                  ' to set the option to avoid potential schema conflicts (if your data is ECS compliant or'\
+                  ' non-conflicting feel free to ignore this message)')
+    end
   end # def register
 
   # test injection points
@@ -316,7 +335,12 @@ module LogStash module Inputs class Jdbc < LogStash::Inputs::Base
         ## do the necessary conversions to string elements
         row = Hash[row.map { |k, v| [k.to_s, convert(k, v)] }]
       end
-      event = LogStash::Event.new(row)
+      if @target
+        event = LogStash::Event.new
+        event.set(@target, row)
+      else
+        event = LogStash::Event.new(row)
+      end
       decorate(event)
       queue << event
     end

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

@@ -0,0 +1,66 @@
+
+module LogStash module PluginMixins module Jdbc
+  module Common
+
+    private
+
+    def complete_sequel_opts(defaults = {})
+      sequel_opts = @sequel_opts.
+          map { |key,val| [key.is_a?(String) ? key.to_sym : key, val] }.
+          map { |key,val| [key, val.eql?('true') ? true : (val.eql?('false') ? false : val)] }
+      sequel_opts = defaults.merge Hash[sequel_opts]
+      sequel_opts[:user] = @jdbc_user unless @jdbc_user.nil? || @jdbc_user.empty?
+      sequel_opts[:password] = @jdbc_password.value unless @jdbc_password.nil?
+      sequel_opts[:driver] = @driver_impl # Sequel uses this as a fallback, if given URI doesn't auto-load the driver correctly
+      sequel_opts
+    end
+
+    def load_driver
+      return @driver_impl if @driver_impl ||= nil
+
+      require "java"
+      require "sequel"
+      require "sequel/adapters/jdbc"
+
+      load_driver_jars
+      begin
+        @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?
+                    "Are you sure you've included the correct jdbc driver in :jdbc_driver_library?"
+                  else
+                    ":jdbc_driver_library is not set, are you sure you included " +
+                        "the proper driver client libraries in your classpath?"
+                  end
+        raise LogStash::PluginLoadingError, "#{e}. #{message}"
+      end
+    end
+
+    def load_driver_jars
+      if jdbc_driver_library_set?
+        @jdbc_driver_library.split(",").each do |driver_jar|
+          @logger.debug("loading #{driver_jar}")
+          # load 'driver.jar' is different than load 'some.rb' as it only causes the file to be added to
+          # JRuby's class-loader lookup (class) path - won't raise a LoadError when file is not readable
+          unless FileTest.readable?(driver_jar)
+            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, " +
+                "file not readable (please check user and group permissions for the path)"
+          end
+          begin
+            require driver_jar
+          rescue LoadError => e
+            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, #{e.message}"
+          rescue StandardError => e
+            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, #{e}"
+          end
+        end
+      end
+    end
+
+    def jdbc_driver_library_set?
+      !@jdbc_driver_library.nil? && !@jdbc_driver_library.empty?
+    end
+
+  end
+end end end

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

@@ -106,17 +106,12 @@ module LogStash  module PluginMixins module Jdbc
 
     private
     def jdbc_connect
-      opts = {
-      :user => @jdbc_user,
-      :password => @jdbc_password.nil? ? nil : @jdbc_password.value,
-      :pool_timeout => @jdbc_pool_timeout,
-      :keep_reference => false
-      }.merge(@sequel_opts)
+      sequel_opts = complete_sequel_opts(:pool_timeout => @jdbc_pool_timeout, :keep_reference => false)
       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, sequel_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.")
@@ -127,64 +122,30 @@ module LogStash  module PluginMixins module Jdbc
         # 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, )
+            log_java_exception(e.cause)
+            @logger.error("Unable to connect to database. Tried #{@connection_retry_attempts} times", error_details(e, trace: true))
             raise e
           else
-            @logger.error("Unable to connect to database. Trying again", :error_message => e.message)
+            @logger.error("Unable to connect to database. Trying again", error_details(e, trace: false))
           end
         end
         sleep(@connection_retry_attempts_wait_time)
       end
     end
 
-    private
-
-    def load_driver
-      if @drivers_loaded.false?
-        require "java"
-        require "sequel"
-        require "sequel/adapters/jdbc"
-
-        load_driver_jars
-        begin
-          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?
-                      "Are you sure you've included the correct jdbc driver in :jdbc_driver_library?"
-                    else
-                      ":jdbc_driver_library is not set, are you sure you included " +
-                          "the proper driver client libraries in your classpath?"
-                    end
-          raise LogStash::PluginLoadingError, "#{e}. #{message}"
-        end
-        @drivers_loaded.make_true
-      end
-    end
-
-    def load_driver_jars
-      if jdbc_driver_library_set?
-        @jdbc_driver_library.split(",").each do |driver_jar|
-          @logger.debug("loading #{driver_jar}")
-          # load 'driver.jar' is different than load 'some.rb' as it only causes the file to be added to
-          # JRuby's class-loader lookup (class) path - won't raise a LoadError when file is not readable
-          unless FileTest.readable?(driver_jar)
-            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, " +
-                "file not readable (please check user and group permissions for the path)"
-          end
-          begin
-            require driver_jar
-          rescue LoadError => e
-            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, #{e.message}"
-          rescue StandardError => e
-            raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, #{e}"
-          end
-        end
-      end
+    def error_details(e, trace: false)
+      details = { :message => e.message, :exception => e.class }
+      details[:cause] = e.cause if e.cause
+      details[:backtrace] = e.backtrace if trace || @logger.debug?
+      details
     end
 
-    def jdbc_driver_library_set?
-      !@jdbc_driver_library.nil? && !@jdbc_driver_library.empty?
+    def log_java_exception(e)
+      return unless e.is_a?(java.lang.Exception)
+      # @logger.name using the same convention as LS does
+      logger = self.class.name.gsub('::', '.').downcase
+      logger = org.apache.logging.log4j.LogManager.getLogger(logger)
+      logger.error('', e) # prints nested causes
     end
 
     def open_jdbc_connection
@@ -229,7 +190,6 @@ module LogStash  module PluginMixins module Jdbc
     public
     def prepare_jdbc_connection
       @connection_lock = ReentrantLock.new
-      @drivers_loaded = Concurrent::AtomicBoolean.new
     end
 
     public

data/lib/logstash/plugin_mixins/jdbc_streaming.rb

@@ -55,37 +55,11 @@ module LogStash module PluginMixins module JdbcStreaming
     config :jdbc_validation_timeout, :validate => :number, :default => 3600
   end
 
-  private
-
-  def load_driver_jars
-    unless @jdbc_driver_library.nil? || @jdbc_driver_library.empty?
-      @jdbc_driver_library.split(",").each do |driver_jar|
-        begin
-          @logger.debug("loading #{driver_jar}")
-          # Use https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby#from-jar-files to make classes from jar
-          # available
-          require driver_jar
-        rescue LoadError => e
-          raise LogStash::PluginLoadingError, "unable to load #{driver_jar} from :jdbc_driver_library, #{e.message}"
-        end
-      end
-    end
-  end
-
   public
   def prepare_jdbc_connection
-    require "sequel"
-    require "sequel/adapters/jdbc"
-    require "java"
-
-    load_driver_jars
-
-    @sequel_opts_symbols = @sequel_opts.inject({}) {|hash, (k,v)| hash[k.to_sym] = v; hash}
-    @sequel_opts_symbols[:user] = @jdbc_user unless @jdbc_user.nil? || @jdbc_user.empty?
-    @sequel_opts_symbols[:password] = @jdbc_password.value unless @jdbc_password.nil?
+    load_driver
 
-    Sequel::JDBC.load_driver(@jdbc_driver_class)
-    @database = Sequel.connect(@jdbc_connection_string, @sequel_opts_symbols)
+    @database = Sequel.connect(@jdbc_connection_string, complete_sequel_opts)
     if @jdbc_validate_connection
       @database.extension(:connection_validator)
       @database.pool.connection_validation_timeout = @jdbc_validation_timeout

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.1.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"
@@ -36,6 +36,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'tzinfo-data'
   # 3.5 limitation is required for jdbc-static loading schedule
   s.add_runtime_dependency 'rufus-scheduler', '< 3.5'
+  s.add_runtime_dependency 'logstash-mixin-ecs_compatibility_support', '~>1.2'
+  s.add_runtime_dependency "logstash-mixin-validator_support", '~> 1.0'
 
   s.add_development_dependency "childprocess"
   s.add_development_dependency 'logstash-devutils'

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
@@ -60,7 +59,7 @@ module LogStash module Filters
 
     let(:plugin) { JdbcStatic.new(settings) }
 
-    let(:event)      { ::LogStash::Event.new("message" => "some text", "ip" => ipaddr) }
+    let(:event) { ::LogStash::Event.new("message" => "some text", "ip" => ipaddr) }
 
     let(:ipaddr) { ".3.1.1" }
 
@@ -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/lookup_spec.rb

@@ -248,6 +248,37 @@ module LogStash module Filters module Jdbc
         expect(subject.valid?).to be_falsey
       end
     end
+
+    describe "validation of target option" do
+      let(:lookup_hash) do
+        {
+          "query" => "select * from servers WHERE ip LIKE ? AND os LIKE ?",
+          "prepared_parameters" => ["%%{[ip]}"],
+        }
+      end
+
+      it "should log a warn when ECS is enabled and target not defined" do
+
+        class LoggableLookup < Lookup
+
+          @@TEST_LOGGER = nil
+
+          def self.logger=(log)
+            @@TEST_LOGGER = log
+          end
+
+          def self.logger
+            @@TEST_LOGGER
+          end
+        end
+
+        spy_logger = double("logger")
+        expect(spy_logger).to receive(:info).once.with(/ECS compatibility is enabled but no .*?target.*? was specified/)
+        LoggableLookup.logger = spy_logger
+
+        LoggableLookup.new(lookup_hash, {:ecs_compatibility => 'v1'}, "lookup-1")
+      end
+    end
   end
 end 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

data/spec/inputs/integration/integ_spec.rb

@@ -45,7 +45,7 @@ describe LogStash::Inputs::Jdbc, :integration => true do
 
   context "when supplying a non-existent library" do
     let(:settings) do
-      super.merge(
+      super().merge(
           "jdbc_driver_library" => "/no/path/to/postgresql.jar"
       )
     end
@@ -61,13 +61,29 @@ describe LogStash::Inputs::Jdbc, :integration => true do
 
   context "when connecting to a non-existent server" do
     let(:settings) do
-      super.merge(
+      super().merge(
           "jdbc_connection_string" => "jdbc:postgresql://localhost:65000/somedb"
       )
     end
 
     it "should not register correctly" do
       plugin.register
+      allow( plugin ).to receive(:log_java_exception)
+      q = Queue.new
+      expect do
+        plugin.run(q)
+      end.to raise_error(::Sequel::DatabaseConnectionError)
+    end
+
+    it "should log (native) Java driver error" do
+      plugin.register
+      expect( org.apache.logging.log4j.LogManager ).to receive(:getLogger).and_wrap_original do |m, *args|
+        logger = m.call(*args)
+        expect( logger ).to receive(:error) do |_, e|
+          expect( e ).to be_a org.postgresql.util.PSQLException
+        end.and_call_original
+        logger
+      end
       q = Queue.new
       expect do
         plugin.run(q)

data/spec/inputs/jdbc_spec.rb

@@ -13,9 +13,13 @@ 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
+  let(:connection_string) { "jdbc:derby:memory:testdb;create=true" }
   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"}
+    {
+        "jdbc_user" => ENV['USER'],
+        "jdbc_driver_class" => "org.apache.derby.jdbc.EmbeddedDriver",
+        "jdbc_connection_string" => connection_string
+    }
   end
   let(:settings) { {} }
   let(:plugin) { LogStash::Inputs::Jdbc.new(mixin_settings.merge(settings)) }
@@ -112,6 +116,57 @@ describe LogStash::Inputs::Jdbc do
     end
   end
 
+  context "when sequel opts has user option" do
+    let(:settings) do
+      {
+          "jdbc_user" => 'system',
+          "statement" => "SELECT * from test_table",
+          "sequel_opts" => { "user" => 'from-opts' }
+      }
+    end
+
+    before do
+      plugin.register
+    end
+
+    after do
+      plugin.stop
+    end
+
+    it "should honor set jdbc-user when connecting" do
+      expect( Sequel ).to receive(:connect).with connection_string, hash_including(:user=>"system")
+      plugin.send(:jdbc_connect)
+    end
+  end
+
+  context "with sequel opts" do
+    let(:settings) do
+      {
+          "jdbc_user" => 'system',
+          "statement" => "SELECT * from test_table",
+          "sequel_opts" => {
+              "truthy" => 'true',
+              "falsey" => 'false',
+              "foo" => 'bar',
+              "jdbc_properties" => { "some" => 'true' }
+          }
+      }
+    end
+
+    before do
+      plugin.register
+    end
+
+    after do
+      plugin.stop
+    end
+
+    it "should symbolize keys" do
+      expect( Sequel ).to receive(:connect).with connection_string,
+          hash_including(:truthy => true, :falsey => false, :foo => 'bar', :jdbc_properties => { 'some' => 'true' })
+      plugin.send(:jdbc_connect)
+    end
+  end
 
   context "when neither statement and statement_filepath arguments are passed" do
     it "should fail to register" do
@@ -273,6 +328,48 @@ describe LogStash::Inputs::Jdbc do
 
   end
 
+  context "when using target option" do
+    let(:settings) do
+      {
+        "statement" => "SELECT * from test_table FETCH FIRST 1 ROWS ONLY",
+        "target" => "sub_field"
+      }
+    end
+
+    before do
+      plugin.register
+    end
+
+    after do
+      plugin.stop
+    end
+
+    it "should put all columns under sub-field" do
+      db[:test_table].insert(:num => 1, :custom_time => Time.now.utc, :created_at => Time.now.utc, :string => "Test target option")
+
+      plugin.run(queue)
+
+      expect(queue.size).to eq(1)
+      event = queue.pop
+      expect(event.get("[sub_field][string]")).to eq("Test target option")
+    end
+  end
+
+  context "when using target option is not set and ecs_compatibility is enabled" do
+    let(:settings) do
+      {
+        "statement" => "SELECT * from test_table FETCH FIRST 1 ROWS ONLY",
+        "ecs_compatibility" => :v1
+      }
+    end
+
+    it "should log a warn of missed target usage" do
+      expect(plugin.logger).to receive(:info).once.with(/ECS compatibility is enabled but no .*?target.*? was specified/)
+
+      plugin.register
+    end
+  end
+
   context "when fetching time data" do
 
     let(:settings) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-integration-jdbc
 version: !ruby/object:Gem::Version
-  version: 5.0.3
+  version: 5.1.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2021-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +142,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  name: logstash-mixin-ecs_compatibility_support
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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.0'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -234,6 +262,7 @@ files:
 - 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/common.rb
 - lib/logstash/plugin_mixins/jdbc/jdbc.rb
 - lib/logstash/plugin_mixins/jdbc/statement_handler.rb
 - lib/logstash/plugin_mixins/jdbc/value_tracking.rb