logstash-filter-jdbc_streaming 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6236e1d0673dff75c590651c8ff5814ecb9a76e4982869e1a331a17101f3a2a5
-  data.tar.gz: 942058abe67d1a453ad35b787e3767d72913664a8501fa104a38ab3bec1ca8fb
+  metadata.gz: 677e0e5ec0f5045d139d29bc159e197d7f771391e303a11f0de12b707e54d224
+  data.tar.gz: af5f3e19476f2789a65afd5e5e10faa48a632b667ba0c5ca2ffc030720a23562
 SHA512:
-  metadata.gz: dd503c13039572e885d9d8116e4ca64eaa68c3de5a548870228b4179ec4d6708ac1bf4f8e366fc4bbc03e1910f700392eb8ea21ab40ca5a52eda5e71f7aad559
-  data.tar.gz: c2a6829fb50246a6c67a22b0eedcc67e71e7ba5b290d12bf3880c9c89a67ec5e909734766e6c5337d8772ba26eda33c2e8d80b7c2b13a39f44d0fe03bfa41821
+  metadata.gz: 82b751b0170789cf6b27939030976f3c315d53221e82dcc5862ab1cbca43cdf7df2086ee2f9649aa2da469dbbac5a49d058fe6095c47e4f8228a4a6c0ba50c7a
+  data.tar.gz: a096d52b59659d6aee46c764567a9131bb077da1e13aed1e492884f10ace4050448f88750e433d689d509e3642286865d756df3e0d6e8713370cd9f6c2d3d2e3

data/CHANGELOG.md

@@ -1,5 +1,13 @@
+## 1.0.9
+  - Added support for prepared statements [PR 32](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/32)
+  - Added support for `sequel_opts` to pass options to the 3rd party Sequel library.
+
+## 1.0.8
+  - Added support for driver loading in JDK 9+ [Issue 25](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/issues/25)
+  - Added support for multiple driver jars [Issue #21](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/issues/21)
+
 ## 1.0.7
-  - Fixed formatting in documentation [#17](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/17) and [#28](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/28) 
+  - Fixed formatting in documentation [#17](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/17) and [#28](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/28)
 
 ## 1.0.6
   - Fixes connection leak in pipeline reloads by properly disconnecting on plugin close
@@ -8,7 +16,7 @@
    - [#11](https://github.com/logstash-plugins/logstash-filter-jdbc_streaming/pull/11) Swap out mysql for postgresql for testing
 
 ## 1.0.4
-   - [JDBC input - #263](https://github.com/logstash-plugins/logstash-input-jdbc/issues/263) Load the driver with the system class loader. Fixes issue loading some JDBC drivers in Logstash 6.2+ 
+   - [JDBC input - #263](https://github.com/logstash-plugins/logstash-input-jdbc/issues/263) Load the driver with the system class loader. Fixes issue loading some JDBC drivers in Logstash 6.2+
 
 ## 1.0.3
   - Update gemspec summary

data/docs/index.asciidoc

@@ -42,6 +42,47 @@ filter {
 }
 -----
 
+[id="plugins-{type}s-{plugin}-prepared_statements"]
+==== Prepared Statements
+
+Using server side prepared statements can speed up execution times as the server optimises the query plan and execution.
+
+NOTE: Not all JDBC accessible technologies will support prepared statements.
+
+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.
+
+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. Typically, these values are indirectly extracted from your event, i.e. the string in the array refers to a field name in your event. You can also use constant values like numbers or strings but ensure that any string constants (e.g. a locale constant of "en" or "de") is not also an event field name. It is a good idea to use the bracketed field reference syntax for fields and normal strings for constants, e.g. `prepared_statement_bind_values => ["[src_ip]", "tokyo"],`.
+
+There are 3 possible parameter schemes. Interpolated, field references and constants. Use interpolation when you are prefixing, suffixing or concatenating field values to create a value that exists in your database, e.g. "%{username}@%{domain}" -> "alice@example.org", "%{distance}km" -> "42km". Use field references for exact field values e.g. "[srcip]" -> "192.168.1.2". Use constants when a database column holds values that slice or categorise a number of similar records e.g. language translations.
+
+A boolean setting `prepared_statement_warn_on_constant_usage`, defaulting to true, controls whether you will see a WARN message logged that warns when constants could be missing the bracketed field reference syntax. If you have set your field references and constants correctly you should set `prepared_statement_warn_on_constant_usage` to false. This setting and code checks should be deprecated in a future major Logstash release.
+
+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.
+Some technologies may require connection string properties to be set, see MySQL example below.
+
+Example:
+[source,ruby]
+-----
+filter {
+  jdbc_streaming {
+    jdbc_driver_library => "/path/to/mysql-connector-java-5.1.34-bin.jar"
+    jdbc_driver_class => "com.mysql.jdbc.Driver"
+    jdbc_connection_string => "jdbc:mysql://localhost:3306/mydatabase?cachePrepStmts=true&prepStmtCacheSize=250&prepStmtCacheSqlLimit=2048&useServerPrepStmts=true"
+    jdbc_user => "me"
+    jdbc_password => "secret"
+    statement => "select * from WORLD.COUNTRY WHERE Code = ?"
+    use_prepared_statements => true
+    prepared_statement_name => "lookup_country_info"
+    prepared_statement_bind_values => ["[country_code]"]
+    target => "country_details"
+  }
+}
+-----
+
 [id="plugins-{type}s-{plugin}-options"]
 ==== Jdbc_streaming Filter Configuration Options
 
@@ -61,11 +102,16 @@ This plugin supports the following configuration options plus the <<plugins-{typ
 | <<plugins-{type}s-{plugin}-jdbc_validate_connection>> |<<boolean,boolean>>|No
 | <<plugins-{type}s-{plugin}-jdbc_validation_timeout>> |<<number,number>>|No
 | <<plugins-{type}s-{plugin}-parameters>> |<<hash,hash>>|No
+| <<plugins-{type}s-{plugin}-prepared_statement_bind_values>> |<<array,array>>|No
+| <<plugins-{type}s-{plugin}-prepared_statement_name>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-prepared_statement_warn_on_constant_usage>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-sequel_opts>> |<<hash,hash>>|No
 | <<plugins-{type}s-{plugin}-statement>> |<<string,string>>|Yes
 | <<plugins-{type}s-{plugin}-tag_on_default_use>> |<<array,array>>|No
 | <<plugins-{type}s-{plugin}-tag_on_failure>> |<<array,array>>|No
 | <<plugins-{type}s-{plugin}-target>> |<<string,string>>|Yes
 | <<plugins-{type}s-{plugin}-use_cache>> |<<boolean,boolean>>|No
+| <<plugins-{type}s-{plugin}-use_prepared_statements>> |<<boolean,boolean>>|No
 |=======================================================================
 
 Also see <<plugins-{type}s-{plugin}-common-options>> for a list of options supported by all
@@ -74,7 +120,7 @@ filter plugins.
 &nbsp;
 
 [id="plugins-{type}s-{plugin}-cache_expiration"]
-===== `cache_expiration` 
+===== `cache_expiration`
 
   * Value type is <<number,number>>
   * Default value is `5.0`
@@ -90,7 +136,7 @@ any external problem that would cause jdbc errors will not be noticed for the
 cache_expiration period.
 
 [id="plugins-{type}s-{plugin}-cache_size"]
-===== `cache_size` 
+===== `cache_size`
 
   * Value type is <<number,number>>
   * Default value is `500`
@@ -99,7 +145,7 @@ The maximum number of cache entries that will be stored. Defaults to 500 entries
 The least recently used entry will be evicted.
 
 [id="plugins-{type}s-{plugin}-default_hash"]
-===== `default_hash` 
+===== `default_hash`
 
   * Value type is <<hash,hash>>
   * Default value is `{}`
@@ -108,7 +154,7 @@ Define a default object to use when lookup fails to return a matching row.
 Ensure that the key names of this object match the columns from the statement.
 
 [id="plugins-{type}s-{plugin}-jdbc_connection_string"]
-===== `jdbc_connection_string` 
+===== `jdbc_connection_string`
 
   * This is a required setting.
   * Value type is <<string,string>>
@@ -117,7 +163,7 @@ Ensure that the key names of this object match the columns from the statement.
 JDBC connection string
 
 [id="plugins-{type}s-{plugin}-jdbc_driver_class"]
-===== `jdbc_driver_class` 
+===== `jdbc_driver_class`
 
   * This is a required setting.
   * Value type is <<string,string>>
@@ -126,19 +172,15 @@ JDBC connection string
 JDBC driver class to load, for example "oracle.jdbc.OracleDriver" or "org.apache.derby.jdbc.ClientDriver"
 
 [id="plugins-{type}s-{plugin}-jdbc_driver_library"]
-===== `jdbc_driver_library` 
+===== `jdbc_driver_library`
 
   * Value type is <<path,path>>
   * There is no default value for this setting.
 
-Tentative of abstracting JDBC logic to a mixin
-for potential reuse in other plugins (input/output).
-This method is called when someone includes this module.
-Add these methods to the 'base' given.
 JDBC driver library path to third party driver library.
 
 [id="plugins-{type}s-{plugin}-jdbc_password"]
-===== `jdbc_password` 
+===== `jdbc_password`
 
   * Value type is <<password,password>>
   * There is no default value for this setting.
@@ -146,7 +188,7 @@ JDBC driver library path to third party driver library.
 JDBC password
 
 [id="plugins-{type}s-{plugin}-jdbc_user"]
-===== `jdbc_user` 
+===== `jdbc_user`
 
   * Value type is <<string,string>>
   * There is no default value for this setting.
@@ -154,7 +196,7 @@ JDBC password
 JDBC user
 
 [id="plugins-{type}s-{plugin}-jdbc_validate_connection"]
-===== `jdbc_validate_connection` 
+===== `jdbc_validate_connection`
 
   * Value type is <<boolean,boolean>>
   * Default value is `false`
@@ -163,7 +205,7 @@ Connection pool configuration.
 Validate connection before use.
 
 [id="plugins-{type}s-{plugin}-jdbc_validation_timeout"]
-===== `jdbc_validation_timeout` 
+===== `jdbc_validation_timeout`
 
   * Value type is <<number,number>>
   * Default value is `3600`
@@ -172,15 +214,55 @@ Connection pool configuration.
 How often to validate a connection (in seconds).
 
 [id="plugins-{type}s-{plugin}-parameters"]
-===== `parameters` 
+===== `parameters`
 
   * Value type is <<hash,hash>>
   * Default value is `{}`
 
 Hash of query parameter, for example `{ "id" => "id_field" }`.
 
+[id="plugins-{type}s-{plugin}-prepared_statement_bind_values"]
+===== `prepared_statement_bind_values`
+
+  * Value type is <<array,array>>
+  * Default value is `[]`
+
+Array of bind values for the prepared statement. Use field references and constants. See the section on <<plugins-{type}s-{plugin}-prepared_statements,prepared_statements>> for more info.
+
+[id="plugins-{type}s-{plugin}-prepared_statement_name"]
+===== `prepared_statement_name`
+
+  * Value type is <<string,string>>
+  * Default value is `""`
+
+Name given to the prepared statement. It must be unique in your config and in the database.
+You need to supply this if `use_prepared_statements` is true.
+
+[id="plugins-{type}s-{plugin}-prepared_statement_warn_on_constant_usage"]
+===== `prepared_statement_warn_on_constant_usage`
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `true`
+
+A flag that controls whether a warning is logged if, in `prepared_statement_bind_values`,
+a String constant is detected that might be intended as a field reference.
+
+[id="plugins-{type}s-{plugin}-sequel_opts"]
+===== `sequel_opts`
+
+  * Value type is <<hash,hash>>
+  * Default value is `{}`
+
+General/Vendor-specific Sequel configuration options
+
+An example of an optional connection pool configuration
+   max_connections - The maximum number of connections the connection pool
+
+examples of vendor-specific options can be found in this documentation page:
+https://github.com/jeremyevans/sequel/blob/master/doc/opening_databases.rdoc
+
 [id="plugins-{type}s-{plugin}-statement"]
-===== `statement` 
+===== `statement`
 
   * This is a required setting.
   * Value type is <<string,string>>
@@ -190,7 +272,7 @@ Statement to execute.
 To use parameters, use named parameter syntax, for example "SELECT * FROM MYTABLE WHERE ID = :id".
 
 [id="plugins-{type}s-{plugin}-tag_on_default_use"]
-===== `tag_on_default_use` 
+===== `tag_on_default_use`
 
   * Value type is <<array,array>>
   * Default value is `["_jdbcstreamingdefaultsused"]`
@@ -198,7 +280,7 @@ To use parameters, use named parameter syntax, for example "SELECT * FROM MYTABL
 Append values to the `tags` field if no record was found and default values were used.
 
 [id="plugins-{type}s-{plugin}-tag_on_failure"]
-===== `tag_on_failure` 
+===== `tag_on_failure`
 
   * Value type is <<array,array>>
   * Default value is `["_jdbcstreamingfailure"]`
@@ -206,7 +288,7 @@ Append values to the `tags` field if no record was found and default values were
 Append values to the `tags` field if sql error occurred.
 
 [id="plugins-{type}s-{plugin}-target"]
-===== `target` 
+===== `target`
 
   * This is a required setting.
   * Value type is <<string,string>>
@@ -216,14 +298,20 @@ Define the target field to store the extracted result(s).
 Field is overwritten if exists.
 
 [id="plugins-{type}s-{plugin}-use_cache"]
-===== `use_cache` 
+===== `use_cache`
 
   * Value type is <<boolean,boolean>>
   * Default value is `true`
 
 Enable or disable caching, boolean true or false. Defaults to true.
 
+[id="plugins-{type}s-{plugin}-use_prepared_statements"]
+===== `use_prepared_statements`
+
+  * Value type is <<boolean,boolean>>
+  * Default value is `false`
 
+When set to `true`, enables prepare statement usage
 
 [id="plugins-{type}s-{plugin}-common-options"]
 include::{include_path}/{type}.asciidoc[]

data/lib/logstash/filters/jdbc_streaming.rb

@@ -2,6 +2,9 @@
 require "logstash/filters/base"
 require "logstash/namespace"
 require "logstash/plugin_mixins/jdbc_streaming"
+require "logstash/plugin_mixins/jdbc_streaming/cache_payload"
+require "logstash/plugin_mixins/jdbc_streaming/statement_handler"
+require "logstash/plugin_mixins/jdbc_streaming/parameter_handler"
 require "lru_redux"
 
 # This filter executes a SQL query and store the result set in the field
@@ -24,49 +27,25 @@ require "lru_redux"
 #   }
 # }
 #
+# Prepared Statement Mode example
+#
+# [source,ruby]
+# filter {
+#   jdbc_streaming {
+#     jdbc_driver_library => "/path/to/mysql-connector-java-5.1.34-bin.jar"
+#     jdbc_driver_class => "com.mysql.jdbc.Driver"
+#     jdbc_connection_string => ""jdbc:mysql://localhost:3306/mydatabase"
+#     jdbc_user => "me"
+#     jdbc_password => "secret"
+#     statement => "select * from WORLD.COUNTRY WHERE Code = ?"
+#     use_prepared_statements => true
+#     prepared_statement_name => "get_country_from_code"
+#     prepared_statement_bind_values => ["[country_code]"]
+#     target => "country_details"
+#   }
+# }
+#
 module LogStash module Filters class JdbcStreaming < LogStash::Filters::Base
-  class CachePayload
-    attr_reader :payload
-    def initialize
-      @failure = false
-      @payload = []
-    end
-
-    def push(data)
-      @payload << data
-    end
-
-    def failed!
-      @failure = true
-    end
-
-    def failed?
-      @failure
-    end
-
-    def empty?
-      @payload.empty?
-    end
-  end
-
-  class RowCache
-    def initialize(size, ttl)
-      @cache = ::LruRedux::TTL::ThreadSafeCache.new(size, ttl)
-    end
-
-    def get(parameters)
-      @cache.getset(parameters) { yield }
-    end
-  end
-
-  class NoCache
-    def initialize(size, ttl) end
-
-    def get(statement)
-      yield
-    end
-  end
-
   include LogStash::PluginMixins::JdbcStreaming
 
   config_name "jdbc_streaming"
@@ -108,16 +87,41 @@ module LogStash module Filters class JdbcStreaming < LogStash::Filters::Base
   # The least recently used entry will be evicted
   config :cache_size, :validate => :number, :default => 500
 
+  config :use_prepared_statements, :validate => :boolean, :default => false
+  config :prepared_statement_name, :validate => :string, :default => ""
+  config :prepared_statement_bind_values, :validate => :array, :default => []
+  config :prepared_statement_warn_on_constant_usage, :validate => :boolean, :default => true # deprecate in a future major LS release
+
+  # Options hash to pass to Sequel
+  config :sequel_opts, :validate => :hash, :default => {}
+
+  attr_reader :prepared_statement_constant_warned # for test verification, remove when warning is deprecated and removed
+
   # ----------------------------------------
   public
 
   def register
     convert_config_options
-    prepare_connected_jdbc_cache
+    if @use_prepared_statements
+      validation_errors = validate_prepared_statement_mode
+      unless validation_errors.empty?
+        raise(LogStash::ConfigurationError, "Prepared Statement Mode validation errors: " + validation_errors.join(", "))
+      end
+    else
+      # symbolise and wrap value in parameter handler
+      unless @parameters.values.all?{|v| v.is_a?(PluginMixins::JdbcStreaming::ParameterHandler)}
+        @parameters = parameters.inject({}) do |hash,(k,value)|
+          hash[k.to_sym] = PluginMixins::JdbcStreaming::ParameterHandler.build_parameter_handler(value)
+          hash
+        end
+      end
+    end
+    @statement_handler = LogStash::PluginMixins::JdbcStreaming::StatementHandler.build_statement_handler(self)
+    prepare_jdbc_connection
   end
 
   def filter(event)
-    result = cache_lookup(event) # should return a JdbcCachePayload
+    result = @statement_handler.cache_lookup(@database, event) # should return a CachePayload instance
 
     if result.failed?
       tag_failure(event)
@@ -140,35 +144,6 @@ module LogStash module Filters class JdbcStreaming < LogStash::Filters::Base
   # ----------------------------------------
   private
 
-  def cache_lookup(event)
-    params = prepare_parameters_from_event(event)
-    @cache.get(params) do
-      result = CachePayload.new
-      begin
-        query = @database[@statement, params] # returns a dataset
-        @logger.debug? && @logger.debug("Executing JDBC query", :statement => @statement, :parameters => params)
-        query.all do |row|
-          result.push row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
-        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", :exception => e)
-      end
-      # if either of: no records or a Sequel exception occurs the payload is
-      # empty and the default can be substituted later.
-      result
-    end
-  end
-
-  def prepare_parameters_from_event(event)
-    @symbol_parameters.inject({}) do |hash,(k,v)|
-      value = event.get(event.sprintf(v))
-      hash[k] = value.is_a?(::LogStash::Timestamp) ? value.time : value
-      hash
-    end
-  end
-
   def tag_failure(event)
     @tag_on_failure.each do |tag|
       event.tag(tag)
@@ -190,13 +165,32 @@ module LogStash module Filters class JdbcStreaming < LogStash::Filters::Base
   def convert_config_options
     # create these object once they will be cloned for every filter call anyway,
     # lets not create a new object for each
-    @symbol_parameters = @parameters.inject({}) {|hash,(k,v)| hash[k.to_sym] = v ; hash }
     @default_array = [@default_hash]
   end
 
-  def prepare_connected_jdbc_cache
-    klass = @use_cache ? RowCache : NoCache
-    @cache = klass.new(@cache_size, @cache_expiration)
-    prepare_jdbc_connection
+  def validate_prepared_statement_mode
+    @prepared_statement_constant_warned = false
+    error_messages = []
+    if @prepared_statement_name.empty?
+      error_messages << "must provide a name for the Prepared Statement, it must be unique for the db session"
+    end
+    if @statement.count("?") != @prepared_statement_bind_values.size
+      # mismatch in number of bind value elements to placeholder characters
+      error_messages << "there is a mismatch between the number of statement `?` placeholders and :prepared_statement_bind_values array setting elements"
+    end
+    unless @prepared_statement_bind_values.all?{|v| v.is_a?(PluginMixins::JdbcStreaming::ParameterHandler)}
+      @prepared_statement_bind_values = prepared_statement_bind_values.map do |value|
+        ParameterHandler.build_bind_value_handler(value)
+      end
+    end
+    if prepared_statement_warn_on_constant_usage
+      warnables = @prepared_statement_bind_values.select {|handler| handler.is_a?(PluginMixins::JdbcStreaming::ConstantParameter) && handler.given_value.is_a?(String)}
+      unless warnables.empty?
+        @prepared_statement_constant_warned = true
+        msg = "When using prepared statements, the following `prepared_statement_bind_values` will be treated as constants, if you intend them to be field references please use the square bracket field reference syntax e.g. '[field]'"
+        logger.warn(msg, :constants => warnables)
+      end
+    end
+    error_messages
   end
-end end end # class LogStash::Filters::Jdbc
+end end end # class LogStash::Filters::JdbcStreaming

data/lib/logstash/plugin_mixins/jdbc_streaming/cache_payload.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module LogStash module PluginMixins module JdbcStreaming
+  class CachePayload
+    attr_reader :payload
+
+    def initialize
+      @failure = false
+      @payload = []
+    end
+
+    def push(data)
+      @payload << data
+    end
+
+    def failed!
+      @failure = true
+    end
+
+    def failed?
+      @failure
+    end
+
+    def empty?
+      @payload.empty?
+    end
+  end
+end end end

data/lib/logstash/plugin_mixins/jdbc_streaming/parameter_handler.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module LogStash module PluginMixins module JdbcStreaming
+  class ParameterHandler
+
+    def self.build_parameter_handler(given_value)
+      # does it really make sense to deal with normal parameters differently?
+      handler = FieldParameter.new(given_value)
+      return handler unless given_value.is_a?(String)
+
+      first_percent_curly = given_value.index("%{")
+      if first_percent_curly && given_value.index("}", first_percent_curly)
+        return InterpolatedParameter.new(given_value)
+      end
+
+      handler
+    end
+
+    def self.build_bind_value_handler(given_value)
+      handler = ConstantParameter.new(given_value)
+
+      return handler unless given_value.is_a?(String) # allow non String constants
+
+      first_percent_curly = given_value.index("%{")
+      if first_percent_curly && given_value.index("}", first_percent_curly)
+        return InterpolatedParameter.new(given_value)
+      end
+
+      if given_value =~ /\A\s*\[[^\]]+\]\s*\z/
+        return FieldParameter.new(given_value)
+      end
+
+      handler
+    end
+
+    attr_reader :given_value
+
+    def initialize(given_value)
+      @given_value = given_value
+    end
+
+    def extract_from(event)
+      # override in subclass
+    end
+  end
+
+  class InterpolatedParameter < ParameterHandler
+    def extract_from(event)
+      event.sprintf(@given_value)
+    end
+  end
+
+  class FieldParameter < ParameterHandler
+    def extract_from(event)
+      event.get(@given_value)
+    end
+  end
+
+  class ConstantParameter < ParameterHandler
+    def extract_from(event)
+      @given_value
+    end
+  end
+end end end

data/lib/logstash/plugin_mixins/jdbc_streaming/statement_handler.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+require "logstash/util/loggable"
+
+module LogStash module PluginMixins module JdbcStreaming
+  # so as to not clash with the class of the same name and function in the jdbc input
+  # this is in the `module JdbcStreaming` namespace
+  # this duplication can be removed in a universal plugin
+
+  class StatementHandler
+    def self.build_statement_handler(plugin)
+      klass = plugin.use_prepared_statements ? PreparedStatementHandler : NormalStatementHandler
+      klass.new(plugin)
+    end
+
+    attr_reader :statement, :parameters, :cache
+
+    def initialize(plugin)
+      @statement = plugin.statement
+      klass = plugin.use_cache ? RowCache : NoCache
+      @cache = klass.new(plugin.cache_size, plugin.cache_expiration)
+      post_init(plugin)
+    end
+
+    # Get from cache or performs remote lookup and saves to cache
+    # @param db [Sequel::Database]
+    # @param event [LogStash::Event]
+    # @returnparam [CachePayload]
+    def cache_lookup(db, event)
+      # override in subclass
+    end
+
+    private
+
+    def common_cache_lookup(db, event)
+      params = prepare_parameters_from_event(event)
+      @cache.get(params) do
+        result = CachePayload.new
+        begin
+          logger.debug? && logger.debug("Executing JDBC query", :statement => statement, :parameters => params)
+          execute_extract_records(db, 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!
+          logger.warn? && logger.warn("Exception when executing JDBC query", :statement => statement, :parameters => params, :exception => e)
+        end
+        # if either of: no records or a Sequel exception occurs the payload is
+        # empty and the default can be substituted later.
+        result
+      end
+    end
+
+    def execute_extract_records(db, params, result)
+      # override in subclass
+    end
+
+    def post_init(plugin)
+      # override in subclass, if needed
+    end
+
+    def prepare_parameters_from_event(event)
+      @parameters.inject({}) do |hash, (k, parameter_handler)|
+        # defer to appropriate parameter handler
+        value = parameter_handler.extract_from(event)
+        hash[k] = value.is_a?(::LogStash::Timestamp) ? value.time : value
+        hash
+      end
+    end
+  end
+
+  class NormalStatementHandler < StatementHandler
+    include LogStash::Util::Loggable
+
+    # Get from cache or performs remote lookup and saves to cache
+    # @param db [Sequel::Database]
+    # @param event [LogStash::Event]
+    # @returnparam [CachePayload]
+    def cache_lookup(db, event)
+      common_cache_lookup(db, event)
+    end
+
+    private
+
+    def execute_extract_records(db, params, result)
+      dataset = db[statement, params] # returns a Sequel dataset
+      dataset.all do |row|
+        result.push row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} # Stringify row keys
+      end
+    end
+
+    def post_init(plugin)
+      @parameters = plugin.parameters
+    end
+  end
+
+  class PreparedStatementHandler < StatementHandler
+    include LogStash::Util::Loggable
+    attr_reader :name, :bind_values_array, :statement_prepared, :prepared
+
+    # Get from cache or performs remote lookup and saves to cache
+    # @param db [Sequel::Database]
+    # @param event [LogStash::Event]
+    # @returnparam [CachePayload]
+    def cache_lookup(db, event)
+      build_prepared_statement(db)
+      common_cache_lookup(db, event)
+    end
+
+    private
+
+    def execute_extract_records(db, params, result)
+      records = db.call(name, params) # returns an array of hashes
+      records.each do |row|
+        result.push row.inject({}){|hash,(k,v)| hash[k.to_s] = v; hash} #Stringify row keys
+      end
+    end
+
+    def post_init(plugin)
+      @name = plugin.prepared_statement_name.to_sym
+      @bind_values_array = plugin.prepared_statement_bind_values
+      @statement_prepared = Concurrent::AtomicBoolean.new(false)
+      @parameters = create_bind_values_hash
+    end
+
+    def build_prepared_statement(db)
+      # create prepared statement on first use
+      if statement_prepared.false?
+        prepended = parameters.keys.map{|v| v.to_s.prepend("$").to_sym}
+        @prepared = db[statement, *prepended].prepare(:select, name)
+        statement_prepared.make_true
+      end
+      # make sure the Sequel database instance has the prepared statement
+      if db.prepared_statement(name).nil?
+        db.set_prepared_statement(name, prepared)
+      end
+    end
+
+    def create_bind_values_hash
+      hash = {}
+      bind_values_array.each_with_index {|v,i| hash[:"p#{i}"] = v}
+      hash
+    end
+  end
+end end end

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

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

data/lib/logstash/plugin_mixins/jdbc_streaming.rb

@@ -1,9 +1,27 @@
 # encoding: utf-8
 require "logstash/config/mixin"
+require_relative "jdbc_streaming/wrapped_driver"
 
 # Tentative of abstracting JDBC logic to a mixin
 # for potential reuse in other plugins (input/output)
 module LogStash module PluginMixins module JdbcStreaming
+  class RowCache
+    def initialize(size, ttl)
+      @cache = ::LruRedux::TTL::ThreadSafeCache.new(size, ttl)
+    end
+
+    def get(parameters)
+      @cache.getset(parameters) { yield }
+    end
+  end
+
+  class NoCache
+    def initialize(size, ttl) end
+
+    def get(statement)
+      yield
+    end
+  end
 
   # This method is called when someone includes this module
   def self.included(base)
@@ -38,19 +56,46 @@ module LogStash module PluginMixins module JdbcStreaming
     config :jdbc_validation_timeout, :validate => :number, :default => 3600
   end
 
+  private
+
+  def load_drivers
+    return if @jdbc_driver_library.nil? || @jdbc_driver_library.empty?
+    driver_jars = @jdbc_driver_library.split(",")
+
+    # Needed for JDK 11 as the DriverManager has a different ClassLoader than Logstash
+    urls = java.net.URL[driver_jars.length].new
+    driver_jars.each_with_index do |driver, idx|
+        urls[idx] = java.io.File.new(driver).toURI().toURL()
+      end
+      ucl = java.net.URLClassLoader.new_instance(urls)
+      begin
+        klass = java.lang.Class.forName(@jdbc_driver_class.to_java(:string), true, ucl);
+      rescue Java::JavaLang::ClassNotFoundException => e
+        raise LogStash::Error, "Unable to find driver class via URLClassLoader in given driver jars: #{@jdbc_driver_class}"
+      end
+      begin
+        driver = klass.getConstructor().newInstance();
+        java.sql.DriverManager.register_driver(WrappedDriver.new(driver.to_java(java.sql.Driver)).to_java(java.sql.Driver))
+      rescue Java::JavaSql::SQLException => e
+        raise LogStash::Error, "Unable to register driver with java.sql.DriverManager using WrappedDriver: #{@jdbc_driver_class}"
+      end
+
+  end
+
   public
   def prepare_jdbc_connection
     require "sequel"
     require "sequel/adapters/jdbc"
     require "java"
 
-    if @jdbc_driver_library
-      class_loader = java.lang.ClassLoader.getSystemClassLoader().to_java(java.net.URLClassLoader)
-      class_loader.add_url(java.io.File.new(@jdbc_driver_library).toURI().toURL())
-    end
+    load_drivers
+
+    @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?
 
     Sequel::JDBC.load_driver(@jdbc_driver_class)
-    @database = Sequel.connect(@jdbc_connection_string, :user=> @jdbc_user, :password=>  @jdbc_password.nil? ? nil : @jdbc_password.value)
+    @database = Sequel.connect(@jdbc_connection_string, @sequel_opts_symbols)
     if @jdbc_validate_connection
       @database.extension(:connection_validator)
       @database.pool.connection_validation_timeout = @jdbc_validation_timeout

data/logstash-filter-jdbc_streaming.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-filter-jdbc_streaming'
-  s.version         = '1.0.7'
+  s.version         = '1.0.9'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Enrich events with your database data"
   s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"

data/spec/filters/jdbc_streaming_spec.rb

@@ -27,127 +27,91 @@ module LogStash module Filters
       let(:cache_expiration) { 3.0 }
       let(:use_cache) { true }
       let(:cache_size) { 10 }
-      let(:statement) { "SELECT name, location FROM reference_table WHERE ip = :ip" }
-      let(:settings) do
-        {
-          "statement" => statement,
-          "parameters" => {"ip" => "ip"},
-          "target" => "server",
-          "use_cache" => use_cache,
-          "cache_expiration" => cache_expiration,
-          "cache_size" => cache_size,
-          "tag_on_failure" => ["lookup_failed"],
-          "tag_on_default_use" => ["default_used_instead"],
-          "default_hash" => {"name" => "unknown", "location" => "unknown"}
-        }
-      end
 
       before :each do
         db.create_table :reference_table do
-          String :ip
+          String  :ip
           String  :name
           String  :location
+          Integer :gcode
         end
-        db[:reference_table].insert(:ip => "10.1.1.1", :name => "ldn-server-1", :location => "LDN-2-3-4")
-        db[:reference_table].insert(:ip => "10.2.1.1", :name => "nyc-server-1", :location => "NYC-5-2-8")
-        db[:reference_table].insert(:ip => "10.3.1.1", :name => "mv-server-1", :location => "MV-9-6-4")
-        plugin.register
+        db[:reference_table].insert(:ip => "10.1.1.1", :name => "ldn-server-1", :location => "LDN-2-3-4", :gcode => 3)
+        db[:reference_table].insert(:ip => "10.2.1.1", :name => "nyc-server-1", :location => "NYC-5-2-8", :gcode => 1)
+        db[:reference_table].insert(:ip => "10.3.1.1", :name => "mv-server-1", :location => "MV-9-6-4", :gcode => 1)
+        db[:reference_table].insert(:ip => "10.4.1.1", :name => "sf-server-1", :location => "SF-9-5-4", :gcode => 1)
+        db[:reference_table].insert(:ip => "10.4.1.1", :name => "mtl-server-1", :location => "MTL-9-3-4", :gcode => 2)
       end
 
       after :each do
         db.drop_table(:reference_table)
       end
 
-      describe "found record - uses row" do
-        let(:ipaddr)    { "10.1.1.1" }
-
-        it "fills in the target" do
-          plugin.filter(event)
-          expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
-          expect(event.get("tags") || []).not_to include("lookup_failed")
-          expect(event.get("tags") || []).not_to include("default_used_instead")
+      context "Normal Mode" do
+        before :each do
+          plugin.register
         end
-      end
-
-      describe "missing record - uses default" do
-        let(:ipaddr)    { "192.168.1.1" }
 
-        it "fills in the target with the default" do
-          plugin.filter(event)
-          expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
-          expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["default_used_instead"])
-        end
-      end
-
-      describe "database error - uses default" do
-        let(:ipaddr)    { "10.1.1.1" }
-        let(:statement) { "SELECT name, location FROM reference_table WHERE ip = :address" }
-        it "fills in the target with the default" do
-          plugin.filter(event)
-          expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
-          expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["lookup_failed", "default_used_instead"])
-        end
-      end
-
-      context "when fetching from cache" do
-        let(:plugin) { TestJdbcStreaming.new(mixin_settings.merge(settings)) }
-        let(:events) do
-          5.times.map{|i| ::LogStash::Event.new("message" => "some other text #{i}", "ip" => ipaddr) }
-        end
-        let(:call_count) { 1 }
-        before(:each) do
-          expect(plugin.database).to receive(:[]).exactly(call_count).times.and_call_original
-          plugin.filter(event)
+        let(:statement) { "SELECT name, location FROM reference_table WHERE ip = :ip" }
+        let(:settings) do
+          {
+            "statement" => statement,
+            "parameters" => {"ip" => "ip"},
+            "target" => "server",
+            "use_cache" => use_cache,
+            "cache_expiration" => cache_expiration,
+            "cache_size" => cache_size,
+            "tag_on_failure" => ["lookup_failed"],
+            "tag_on_default_use" => ["default_used_instead"],
+            "default_hash" => {"name" => "unknown", "location" => "unknown"},
+            "sequel_opts" => {"pool_timeout" => 600}
+          }
         end
 
-        describe "found record - caches row" do
+        describe "found record - uses row" do
           let(:ipaddr)    { "10.1.1.1" }
-          it "calls the database once then uses the cache" do
+
+          it "fills in the target" do
+            plugin.filter(event)
             expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
             expect(event.get("tags") || []).not_to include("lookup_failed")
             expect(event.get("tags") || []).not_to include("default_used_instead")
-            events.each do |evt|
-              plugin.filter(evt)
-              expect(evt.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
-            end
           end
         end
 
         describe "missing record - uses default" do
-          let(:ipaddr)    { "10.10.1.1" }
-          it "calls the database once then uses the cache" do
+          let(:ipaddr)    { "192.168.1.1" }
+
+          it "fills in the target with the default" do
+            plugin.filter(event)
             expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
             expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["default_used_instead"])
-            events.each do |evt|
-              plugin.filter(evt)
-              expect(evt.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
-            end
           end
         end
 
-        context "extremely small cache expiration" do
-          describe "found record - cache always expires" do
-            let(:ipaddr)    { "10.1.1.1" }
-            let(:call_count) { 6 }
-            let(:cache_expiration) { 0.0000001 }
-            it "calls the database each time because cache entry expired" do
-              expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
-              expect(event.get("tags") || []).not_to include("lookup_failed")
-              expect(event.get("tags") || []).not_to include("default_used_instead")
-              events.each do |evt|
-                plugin.filter(evt)
-                expect(evt.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
-              end
-            end
+        describe "database error - uses default" do
+          let(:ipaddr)    { "10.1.1.1" }
+          let(:statement) { "SELECT name, location FROM reference_table WHERE ip = :address" }
+          it "fills in the target with the default" do
+            plugin.filter(event)
+            expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
+            expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["lookup_failed", "default_used_instead"])
           end
         end
 
-        context "when cache is disabled" do
-          let(:call_count) { 6 }
-          let(:use_cache) { false }
-          describe "database is always called" do
+        context "when fetching from cache" do
+          let(:plugin) { TestJdbcStreaming.new(mixin_settings.merge(settings)) }
+          let(:events) do
+            5.times.map{|i| ::LogStash::Event.new("message" => "some other text #{i}", "ip" => ipaddr) }
+          end
+          let(:call_count) { 1 }
+          before(:each) do
+            expect(plugin.database).to receive(:[]).exactly(call_count).times.and_call_original
+            plugin.filter(event)
+          end
+
+          describe "found record - caches row" do
             let(:ipaddr)    { "10.1.1.1" }
-            it "calls the database each time" do
+            it "calls the database once then uses the cache" do
               expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
               expect(event.get("tags") || []).not_to include("lookup_failed")
               expect(event.get("tags") || []).not_to include("default_used_instead")
@@ -158,9 +122,9 @@ module LogStash module Filters
             end
           end
 
-          describe "database is always called but record is missing and default is used" do
-            let(:ipaddr)    { "10.11.1.1" }
-            it "calls the database each time" do
+          describe "missing record - uses default" do
+            let(:ipaddr)    { "10.10.1.1" }
+            it "calls the database once then uses the cache" do
               expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
               expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["default_used_instead"])
               events.each do |evt|
@@ -169,6 +133,113 @@ module LogStash module Filters
               end
             end
           end
+
+          context "extremely small cache expiration" do
+            describe "found record - cache always expires" do
+              let(:ipaddr)    { "10.1.1.1" }
+              let(:call_count) { 6 }
+              let(:cache_expiration) { 0.0000001 }
+              it "calls the database each time because cache entry expired" do
+                expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
+                expect(event.get("tags") || []).not_to include("lookup_failed")
+                expect(event.get("tags") || []).not_to include("default_used_instead")
+                events.each do |evt|
+                  plugin.filter(evt)
+                  expect(evt.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
+                end
+              end
+            end
+          end
+
+          context "when cache is disabled" do
+            let(:call_count) { 6 }
+            let(:use_cache) { false }
+            describe "database is always called" do
+              let(:ipaddr)    { "10.1.1.1" }
+              it "calls the database each time" do
+                expect(event.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
+                expect(event.get("tags") || []).not_to include("lookup_failed")
+                expect(event.get("tags") || []).not_to include("default_used_instead")
+                events.each do |evt|
+                  plugin.filter(evt)
+                  expect(evt.get("server")).to eq([{"name" => "ldn-server-1", "location" => "LDN-2-3-4"}])
+                end
+              end
+            end
+
+            describe "database is always called but record is missing and default is used" do
+              let(:ipaddr)    { "10.11.1.1" }
+              it "calls the database each time" do
+                expect(event.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
+                expect(event.get("tags") & ["lookup_failed", "default_used_instead"]).to eq(["default_used_instead"])
+                events.each do |evt|
+                  plugin.filter(evt)
+                  expect(evt.get("server")).to eq([{"name" => "unknown", "location" => "unknown"}])
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context "Prepared Statement Mode" do
+        let(:statement) { "SELECT name, location FROM reference_table WHERE (ip = ?) AND (gcode = ?)" }
+        let(:settings) do
+          {
+            "statement" => statement,
+            "use_prepared_statements" => true,
+            "prepared_statement_name" => "lookup_ip",
+            "prepared_statement_bind_values" => ["[ip]", 2],
+            "target" => "server",
+            "use_cache" => use_cache,
+            "cache_expiration" => cache_expiration,
+            "cache_size" => cache_size,
+            "tag_on_failure" => ["lookup_failed"],
+            "tag_on_default_use" => ["default_used_instead"],
+            "default_hash" => {"name" => "unknown", "location" => "unknown"},
+            "sequel_opts" => {"pool_timeout" => 600}
+          }
+        end
+
+        describe "using one variable and one constant, found record - uses row" do
+          let(:ipaddr)    { "10.4.1.1" }
+
+          it "fills in the target" do
+            plugin.register
+            expect(plugin.prepared_statement_constant_warned).to be_falsey
+            plugin.filter(event)
+            expect(event.get("server")).to eq([{"name" => "mtl-server-1", "location" => "MTL-9-3-4"}])
+            expect(event.get("tags") || []).not_to include("lookup_failed")
+            expect(event.get("tags") || []).not_to include("default_used_instead")
+          end
+        end
+
+        describe "fails empty name validation" do
+          before :each do
+            settings["prepared_statement_name"] = ""
+          end
+          it "should fail to register" do
+            expect{ plugin.register }.to raise_error(LogStash::ConfigurationError)
+          end
+        end
+
+        describe "fails parameter mismatch validation" do
+          before :each do
+            settings["prepared_statement_bind_values"] = ["[ip]"]
+          end
+          it "should fail to register" do
+            expect{ plugin.register }.to raise_error(LogStash::ConfigurationError)
+          end
+        end
+
+        describe "warns on constant usage" do
+          before :each do
+            settings["prepared_statement_bind_values"] = ["ip", 2]
+          end
+          it "should set the warning logged flag" do
+            plugin.register
+            expect(plugin.prepared_statement_constant_warned).to be_truthy
+          end
         end
       end
     end
@@ -273,5 +344,6 @@ module LogStash module Filters
         expect(subject.get('new_field')).to eq([{"1" => 'from_database'}])
       end
     end
+
   end
 end end

data/spec/integration/jdbcstreaming_spec.rb

@@ -14,13 +14,18 @@ module LogStash module Filters
     ::Jdbc::Postgres.load_driver
 
     ENV["TZ"] = "Etc/UTC"
+
+    # For Travis and CI based on docker, we source from ENV
+    jdbc_connection_string = ENV.fetch("PG_CONNECTION_STRING",
+      "jdbc:postgresql://localhost:5432") + "/jdbc_streaming_db?user=postgres"
+
     let(:mixin_settings) do
-      { "jdbc_user" => "postgres", "jdbc_driver_class" => "org.postgresql.Driver",
-        "jdbc_connection_string" => "jdbc:postgresql://localhost/jdbc_streaming_db?user=postgres"}
+      { "jdbc_driver_class" => "org.postgresql.Driver",
+        "jdbc_connection_string" => jdbc_connection_string
+      }
     end
-    let(:settings) { {} }
     let(:plugin) { JdbcStreaming.new(mixin_settings.merge(settings)) }
-    let (:db) do
+    let(:db) do
       ::Sequel.connect(mixin_settings['jdbc_connection_string'])
     end
     let(:event)      { ::LogStash::Event.new("message" => "some text", "ip" => ipaddr) }
@@ -38,7 +43,8 @@ module LogStash module Filters
         "cache_size" => cache_size,
         "tag_on_failure" => ["lookup_failed"],
         "tag_on_default_use" => ["default_used_instead"],
-        "default_hash" => {"name" => "unknown", "location" => "unknown"}
+        "default_hash" => {"name" => "unknown", "location" => "unknown"},
+        "sequel_opts" => {"pool_timeout" => 600}
       }
     end
     let(:ipaddr)    { "10.#{idx}.1.1" }
@@ -67,6 +73,32 @@ module LogStash module Filters
       end
     end
 
+    describe "In Prepared Statement mode, found record - uses row" do
+      let(:idx) { 200 }
+      let(:statement) { "SELECT name, location FROM reference_table WHERE ip = ?" }
+      let(:settings) do
+        {
+          "statement" => statement,
+          "use_prepared_statements" => true,
+          "prepared_statement_name" => "lookup_ip",
+          "prepared_statement_bind_values" => ["[ip]"],
+          "target" => "server",
+          "use_cache" => use_cache,
+          "cache_expiration" => cache_expiration,
+          "cache_size" => cache_size,
+          "tag_on_failure" => ["lookup_failed"],
+          "tag_on_default_use" => ["default_used_instead"],
+          "default_hash" => {"name" => "unknown", "location" => "unknown"},
+          "sequel_opts" => {"pool_timeout" => 600}
+        }
+      end
+      it "fills in the target" do
+        plugin.filter(event)
+        expect(event.get("server")).to eq([{"name" => "ldn-server-#{idx}", "location" => "LDN-#{idx}-2-3"}])
+        expect((event.get("tags") || []) & ["lookup_failed", "default_used_instead"]).to be_empty
+      end
+    end
+
     context "when fetching from cache" do
       let(:plugin) { TestJdbcStreaming.new(mixin_settings.merge(settings)) }
       let(:events) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-filter-jdbc_streaming
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.9
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-30 00:00:00.000000000 Z
+date: 2019-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -115,6 +115,10 @@ files:
 - docs/index.asciidoc
 - lib/logstash/filters/jdbc_streaming.rb
 - lib/logstash/plugin_mixins/jdbc_streaming.rb
+- lib/logstash/plugin_mixins/jdbc_streaming/cache_payload.rb
+- lib/logstash/plugin_mixins/jdbc_streaming/parameter_handler.rb
+- lib/logstash/plugin_mixins/jdbc_streaming/statement_handler.rb
+- lib/logstash/plugin_mixins/jdbc_streaming/wrapped_driver.rb
 - logstash-filter-jdbc_streaming.gemspec
 - spec/filters/jdbc_streaming_spec.rb
 - spec/integration/jdbcstreaming_spec.rb