logstash-output-elasticsearch 9.0.3-java → 9.1.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae7148b3b08c44548f172bc06c88ff48b94809ef756aeef21d4597efb2d50716
-  data.tar.gz: a6c62363e0d1f953cfe9ee9ef8ceed192f7d54f0e3421f2c403f1c110a11a1ed
+  metadata.gz: 8c72ac7c8b2bd9eb64be1be449a402d64d9808c33d4ad8c723c567d23704a4ae
+  data.tar.gz: e327128618734f8783150fb9e8d347e9fd56b5911ffadec3d042a29fc9f7ffc8
 SHA512:
-  metadata.gz: 420c2f66334764c1693936ca462cb45e8b196dec449ae7521373ba44c5521e6f82b76f9d3ac02a950dc597149b671701f16e2226f0070a8196c8946a2bdc9f92
-  data.tar.gz: 0f30be7f309a6734f6f0e050b8ff725db3ce71a7ce0c617997f35b0ec013410c7ca56991c59978ec147da8d87cb598d214272e7325ce84145257341fdfd4568c
+  metadata.gz: fa5f19f2277c551466016c91212ed04fa18a3d80d81dea618618c859f2c274f4fd673243c2719450401b7e861f3a197e1a66c8731eb9d8f95d61e9cc68730959
+  data.tar.gz: 393208c3c8911549d05ed94ba39471c982fc997858e22d54b5493b4a2fc008e01173cafbc8ea9e602a984cd41ac0012b555ab24817f0dd0d5dafaf95b468ce5f

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 9.1.1
+  - Docs: Set the default_codec doc attribute.
+
+## 9.1.0
+  - Set number_of_shards to 1 and document_type to '_doc' for es 7.x clusters #741 #747
+  - Fix usage of upsert and script when update action is interpolated #239
+  - Add metrics to track bulk level and document level responses #585
+
 ## 9.0.3
   - Ignore master-only nodes when using sniffing
 

data/docs/index.asciidoc

@@ -1,5 +1,6 @@
 :plugin: elasticsearch
 :type: output
+:default_codec: plain
 
 ///////////////////////////////////////////
 START - GENERATED VARIABLES, DO NOT EDIT!
@@ -105,8 +106,8 @@ not reevaluate its DNS value while the keepalive is in effect.
 
 This plugin supports request and response compression. Response compression is enabled by default and 
 for Elasticsearch versions 5.0 and later, the user doesn't have to set any configs in Elasticsearch for 
-it to send back compressed response. For versions before 5.0, `http.compression` must be set to `true` in 
-Elasticsearch[https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-http.html#modules-http] to take advantage of response compression when using this plugin
+it to send back compressed response. For versions before 5.0, `http.compression` must be set to `true` https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-http.html#modules-http[in 
+Elasticsearch] to take advantage of response compression when using this plugin
 
 For requests compression, regardless of the Elasticsearch version, users have to enable `http_compression` 
 setting in their Logstash config file.
@@ -238,7 +239,7 @@ Elasticsearch with the same ID.
   * There is no default value for this setting.
   * This option is deprecated
 
-Note: This option is deprecated due to the https://www.elastic.co/guide/en/elasticsearch/reference/6.0/removal-of-types.html[removal of types in Logstash 6.0].
+Note: This option is deprecated due to the https://www.elastic.co/guide/en/elasticsearch/reference/6.0/removal-of-types.html[removal of types in Elasticsearch 6.0].
 It will be removed in the next major version of Logstash.
 This sets the document type to write events to. Generally you should try to write only
 similar events to the same 'type'. String expansion `%{foo}` works here.
@@ -476,6 +477,14 @@ This can be dynamic using the `%{foo}` syntax.
 
 Set script name for scripted update mode
 
+Example:
+[source,ruby]
+    output {
+      elasticsearch {
+        script => "ctx._source.message = params.event.get('message')"
+      }
+    }
+
 [id="plugins-{type}s-{plugin}-script_lang"]
 ===== `script_lang` 
 
@@ -494,7 +503,7 @@ When using indexed (stored) scripts on Elasticsearch 6 and higher, you must set
 Define the type of script referenced by "script" variable
  inline : "script" contains inline script
  indexed : "script" contains the name of script directly indexed in elasticsearch
- file    : "script" contains the name of script stored in elasticseach's config directory
+ file    : "script" contains the name of script stored in elasticsearch's config directory
 
 [id="plugins-{type}s-{plugin}-script_var_name"]
 ===== `script_var_name` 
@@ -682,3 +691,5 @@ See also https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-in
 
 [id="plugins-{type}s-{plugin}-common-options"]
 include::{include_path}/{type}.asciidoc[]
+
+:default_codec!:

data/lib/logstash/outputs/elasticsearch.rb

@@ -227,6 +227,7 @@ class LogStash::Outputs::ElasticSearch < LogStash::Outputs::Base
   config :http_compression, :validate => :boolean, :default => false
 
   def build_client
+    params["metric"] = metric
     @client ||= ::LogStash::Outputs::ElasticSearch::HttpClientBuilder.build(@logger, @hosts, params)
   end
 

data/lib/logstash/outputs/elasticsearch/common.rb

@@ -10,9 +10,9 @@ module LogStash; module Outputs; class ElasticSearch;
     DOC_CONFLICT_CODE = 409
 
     # When you use external versioning, you are communicating that you want
-    # to ignore conflicts. More obviously, since an external version is a 
+    # to ignore conflicts. More obviously, since an external version is a
     # constant part of the incoming document, we should not retry, as retrying
-    # will never succeed. 
+    # will never succeed.
     VERSION_TYPES_PERMITTING_CONFLICT = ["external", "external_gt", "external_gte"]
 
     def register
@@ -25,6 +25,8 @@ module LogStash; module Outputs; class ElasticSearch;
 
       install_template
       check_action_validity
+      @bulk_request_metrics = metric.namespace(:bulk_requests)
+      @document_level_metrics = metric.namespace(:documents)
 
       @logger.info("New Elasticsearch output", :class => self.class.name, :hosts => @hosts.map(&:sanitized).map(&:to_s))
     end
@@ -36,8 +38,45 @@ module LogStash; module Outputs; class ElasticSearch;
 
     # Convert the event into a 3-tuple of action, params, and event
     def event_action_tuple(event)
-      params = event_action_params(event)
+
       action = event.sprintf(@action)
+
+      params = {
+        :_id => @document_id ? event.sprintf(@document_id) : nil,
+        :_index => event.sprintf(@index),
+        :_type => get_event_type(event),
+        :_routing => @routing ? event.sprintf(@routing) : nil
+      }
+
+      if @pipeline
+        params[:pipeline] = event.sprintf(@pipeline)
+      end
+
+      if @parent
+        if @join_field
+          join_value = event.get(@join_field)
+          parent_value = event.sprintf(@parent)
+          event.set(@join_field, { "name" => join_value, "parent" => parent_value })
+          params[:_routing] = event.sprintf(@parent)
+        else
+          params[:parent] = event.sprintf(@parent)
+        end
+      end
+
+      if action == 'update'
+        params[:_upsert] = LogStash::Json.load(event.sprintf(@upsert)) if @upsert != ""
+        params[:_script] = event.sprintf(@script) if @script != ""
+        params[:_retry_on_conflict] = @retry_on_conflict
+      end
+
+      if @version
+        params[:version] = event.sprintf(@version)
+      end
+
+      if @version_type
+        params[:version_type] = event.sprintf(@version_type)
+      end
+
       [action, params, event]
     end
 
@@ -119,8 +158,16 @@ module LogStash; module Outputs; class ElasticSearch;
 
       # If the response is nil that means we were in a retry loop
       # and aborted since we're shutting down
+      return if bulk_response.nil?
+
       # If it did return and there are no errors we're good as well
-      return if bulk_response.nil? || !bulk_response["errors"]
+      if bulk_response["errors"]
+        @bulk_request_metrics.increment(:with_errors)
+      else
+        @bulk_request_metrics.increment(:successes)
+        @document_level_metrics.increment(:successes, actions.size)
+        return
+      end
 
       actions_to_retry = []
       bulk_response["items"].each_with_index do |response,idx|
@@ -136,8 +183,10 @@ module LogStash; module Outputs; class ElasticSearch;
         # - For a mapping error, we send to dead letter queue for a human to intervene at a later point.
         # - For everything else there's mastercard. Yep, and we retry indefinitely. This should fix #572 and other transient network issues
         if DOC_SUCCESS_CODES.include?(status)
+          @document_level_metrics.increment(:successes)
           next
         elsif DOC_CONFLICT_CODE == status
+          @document_level_metrics.increment(:non_retryable_failures)
           @logger.warn "Failed action.", status: status, action: action, response: response if !failure_type_logging_whitelist.include?(failure["type"])
           next
         elsif DOC_DLQ_CODES.include?(status)
@@ -149,9 +198,11 @@ module LogStash; module Outputs; class ElasticSearch;
           else
             @logger.warn "Could not index event to Elasticsearch.", status: status, action: action, response: response
           end
+          @document_level_metrics.increment(:non_retryable_failures)
           next
         else
           # only log what the user whitelisted
+          @document_level_metrics.increment(:retryable_failures)
           @logger.info "retrying failed action with response code: #{status} (#{failure})" if !failure_type_logging_whitelist.include?(failure["type"])
           actions_to_retry << action
         end
@@ -160,60 +211,20 @@ module LogStash; module Outputs; class ElasticSearch;
       actions_to_retry
     end
 
-    # get the action parameters for the given event
-    def event_action_params(event)
-      type = get_event_type(event)
-
-      params = {
-        :_id => @document_id ? event.sprintf(@document_id) : nil,
-        :_index => event.sprintf(@index),
-        :_type => type,
-        :_routing => @routing ? event.sprintf(@routing) : nil
-      }
-
-      if @pipeline
-        params[:pipeline] = event.sprintf(@pipeline)
-      end
-
-      if @parent
-        if @join_field
-          join_value = event.get(@join_field)
-          parent_value = event.sprintf(@parent)
-          event.set(@join_field, { "name" => join_value, "parent" => parent_value })
-          params[:_routing] = event.sprintf(@parent)
-        else
-          params[:parent] = event.sprintf(@parent)
-        end
-      end
-
-      if @action == 'update'
-        params[:_upsert] = LogStash::Json.load(event.sprintf(@upsert)) if @upsert != ""
-        params[:_script] = event.sprintf(@script) if @script != ""
-        params[:_retry_on_conflict] = @retry_on_conflict
-      end
-
-      if @version
-        params[:version] = event.sprintf(@version)
-      end
-
-      if @version_type
-        params[:version_type] = event.sprintf(@version_type)
-      end
-
-      params
-    end
-
     # Determine the correct value for the 'type' field for the given event
-    DEFAULT_EVENT_TYPE="doc".freeze
+    DEFAULT_EVENT_TYPE_ES6="doc".freeze
+    DEFAULT_EVENT_TYPE_ES7="_doc".freeze
     def get_event_type(event)
       # Set the 'type' value for the index.
       type = if @document_type
                event.sprintf(@document_type)
              else
                if client.maximum_seen_major_version < 6
-                 event.get("type") || DEFAULT_EVENT_TYPE
+                 event.get("type") || DEFAULT_EVENT_TYPE_ES6
+               elsif client.maximum_seen_major_version == 6
+                 DEFAULT_EVENT_TYPE_ES6
                else
-                 DEFAULT_EVENT_TYPE
+                 DEFAULT_EVENT_TYPE_ES7
                end
              end
 
@@ -245,6 +256,7 @@ module LogStash; module Outputs; class ElasticSearch;
 
         # We retry until there are no errors! Errors should all go to the retry queue
         sleep_interval = sleep_for_interval(sleep_interval)
+        @bulk_request_metrics.increment(:failures)
         retry unless @stopping.true?
       rescue ::LogStash::Outputs::ElasticSearch::HttpClient::Pool::NoConnectionAvailableError => e
         @logger.error(
@@ -255,8 +267,10 @@ module LogStash; module Outputs; class ElasticSearch;
         )
         Stud.stoppable_sleep(sleep_interval) { @stopping.true? }
         sleep_interval = next_sleep_interval(sleep_interval)
+        @bulk_request_metrics.increment(:failures)
         retry unless @stopping.true?
       rescue ::LogStash::Outputs::ElasticSearch::HttpClient::Pool::BadResponseCodeError => e
+        @bulk_request_metrics.increment(:failures)
         log_hash = {:code => e.response_code, :url => e.url.sanitized.to_s}
         log_hash[:body] = e.response_body if @logger.debug? # Generally this is too verbose
         message = "Encountered a retryable error. Will Retry with exponential backoff "
@@ -286,6 +300,7 @@ module LogStash; module Outputs; class ElasticSearch;
         @logger.debug("Failed actions for last bad bulk request!", :actions => actions)
 
         sleep_interval = sleep_for_interval(sleep_interval)
+        @bulk_request_metrics.increment(:failures)
         retry unless @stopping.true?
       end
     end

data/lib/logstash/outputs/elasticsearch/elasticsearch-template-es7x.json

@@ -2,7 +2,8 @@
   "template" : "logstash-*",
   "version" : 60001,
   "settings" : {
-    "index.refresh_interval" : "5s"
+    "index.refresh_interval" : "5s",
+    "number_of_shards": 1
   },
   "mappings" : {
     "_doc" : {

data/lib/logstash/outputs/elasticsearch/http_client.rb

@@ -50,6 +50,9 @@ module LogStash; module Outputs; class ElasticSearch;
     #   through a special http path, such as using mod_rewrite.
     def initialize(options={})
       @logger = options[:logger]
+      @metric = options[:metric]
+      @bulk_request_metrics = @metric.namespace(:bulk_requests)
+      @bulk_response_metrics = @bulk_request_metrics.namespace(:responses)
       
       # Again, in case we use DEFAULT_OPTIONS in the future, uncomment this.
       # @options = DEFAULT_OPTIONS.merge(options)
@@ -142,9 +145,12 @@ module LogStash; module Outputs; class ElasticSearch;
         body_stream.seek(0)
       end
 
+      @bulk_response_metrics.increment(response.code.to_s)
+
       if response.code != 200
+        url = ::LogStash::Util::SafeURI.new(response.final_url)
         raise ::LogStash::Outputs::ElasticSearch::HttpClient::Pool::BadResponseCodeError.new(
-          response.code, @bulk_path, body_stream.to_s, response.body
+          response.code, url, body_stream.to_s, response.body
         )
       end
 
@@ -282,7 +288,8 @@ module LogStash; module Outputs; class ElasticSearch;
         :sniffing_path => options[:sniffing_path],
         :healthcheck_path => options[:healthcheck_path],
         :resurrect_delay => options[:resurrect_delay],
-        :url_normalizer => self.method(:host_to_url)
+        :url_normalizer => self.method(:host_to_url),
+        :metric => options[:metric]
       }
       pool_options[:scheme] = self.scheme if self.scheme
 

data/lib/logstash/outputs/elasticsearch/http_client/pool.rb

@@ -45,6 +45,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
     def initialize(logger, adapter, initial_urls=[], options={})
       @logger = logger
       @adapter = adapter
+      @metric = options[:metric]
       @initial_urls = initial_urls
       
       raise ArgumentError, "No URL Normalizer specified!" unless options[:url_normalizer]
@@ -161,8 +162,8 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
     # Sniffs and returns the results. Does not update internal URLs!
     def check_sniff
       _, url_meta, resp = perform_request(:get, @sniffing_path)
+      @metric.increment(:sniff_requests)
       parsed = LogStash::Json.load(resp.body)
-      
       nodes = parsed['nodes']
       if !nodes || nodes.empty?
         @logger.warn("Sniff returned no nodes! Will not update hosts.")

data/lib/logstash/outputs/elasticsearch/http_client_builder.rb

@@ -14,6 +14,7 @@ module LogStash; module Outputs; class ElasticSearch;
       
       common_options = {
         :client_settings => client_settings,
+        :metric => params["metric"],
         :resurrect_delay => params["resurrect_delay"]
       }
 

data/logstash-output-elasticsearch.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-output-elasticsearch'
-  s.version         = '9.0.3'
+  s.version         = '9.1.1'
   s.licenses        = ['apache-2.0']
   s.summary         = "Stores logs in Elasticsearch"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"

data/spec/integration/outputs/metrics_spec.rb

@@ -0,0 +1,70 @@
+require_relative "../../../spec/es_spec_helper"
+
+describe "metrics", :integration => true do
+  subject! do
+    require "logstash/outputs/elasticsearch"
+    settings = {
+      "manage_template" => false,
+      "hosts" => "#{get_host_port()}"
+    }
+    plugin = LogStash::Outputs::ElasticSearch.new(settings)
+  end
+
+  let(:metric) { subject.metric }
+  let(:bulk_request_metrics) { subject.instance_variable_get(:@bulk_request_metrics) }
+  let(:document_level_metrics) { subject.instance_variable_get(:@document_level_metrics) }
+
+  before :each do
+    require "elasticsearch"
+
+    # Clean ES of data before we start.
+    @es = get_client
+    @es.indices.delete_template(:name => "*")
+
+    # This can fail if there are no indexes, ignore failure.
+    @es.indices.delete(:index => "*") rescue nil
+    #@es.indices.refresh
+    subject.register
+  end
+
+  context "after a succesful bulk insert" do
+    let(:bulk) { [
+      LogStash::Event.new("message" => "sample message here"),
+      LogStash::Event.new("somemessage" => { "message" => "sample nested message here" }),
+      LogStash::Event.new("somevalue" => 100),
+      LogStash::Event.new("somevalue" => 10),
+      LogStash::Event.new("somevalue" => 1),
+      LogStash::Event.new("country" => "us"),
+      LogStash::Event.new("country" => "at"),
+      LogStash::Event.new("geoip" => { "location" => [ 0.0, 0.0 ] })
+    ]}
+
+    it "increases successful bulk request metric" do
+      expect(bulk_request_metrics).to receive(:increment).with(:successes).once
+      subject.multi_receive(bulk)
+    end
+
+    it "increases number of successful inserted documents" do
+      expect(document_level_metrics).to receive(:increment).with(:successes, bulk.size).once
+      subject.multi_receive(bulk)
+    end
+  end
+
+  context "after a bulk insert that generates errors" do
+    let(:bulk) { [
+      LogStash::Event.new("message" => "sample message here"),
+      LogStash::Event.new("message" => { "message" => "sample nested message here" }),
+    ]}
+    it "increases bulk request with error metric" do
+      expect(bulk_request_metrics).to receive(:increment).with(:with_errors).once
+      expect(bulk_request_metrics).to_not receive(:increment).with(:successes)
+      subject.multi_receive(bulk)
+    end
+
+    it "increases number of successful and non retryable documents" do
+      expect(document_level_metrics).to receive(:increment).with(:non_retryable_failures).once
+      expect(document_level_metrics).to receive(:increment).with(:successes).once
+      subject.multi_receive(bulk)
+    end
+  end
+end

data/spec/integration/outputs/sniffer_spec.rb

@@ -7,7 +7,13 @@ describe "pool sniffer", :integration => true do
   let(:logger) { Cabin::Channel.get }
   let(:adapter) { LogStash::Outputs::ElasticSearch::HttpClient::ManticoreAdapter.new(logger) }
   let(:initial_urls) { [::LogStash::Util::SafeURI.new("http://#{get_host_port}")] }
-  let(:options) { {:resurrect_delay => 2, :url_normalizer => proc {|u| u}} } # Shorten the delay a bit to speed up tests
+  let(:options) do
+    {
+      :resurrect_delay => 2, # Shorten the delay a bit to speed up tests
+      :url_normalizer => proc {|u| u},
+      :metric => ::LogStash::Instrument::NullMetric.new(:dummy).namespace(:alsodummy)
+    }
+  end
 
   subject { LogStash::Outputs::ElasticSearch::HttpClient::Pool.new(logger, adapter, initial_urls, options) }
 

data/spec/unit/outputs/elasticsearch/http_client_spec.rb

@@ -7,7 +7,8 @@ describe LogStash::Outputs::ElasticSearch::HttpClient do
   let(:base_options) do
     opts = {
       :hosts => [::LogStash::Util::SafeURI.new("127.0.0.1")],
-      :logger => Cabin::Channel.get
+      :logger => Cabin::Channel.get,
+      :metric => ::LogStash::Instrument::NamespacedNullMetric.new(:dummy_metric)
     }
 
     if !ssl.nil? # Shortcut to set this

data/spec/unit/outputs/elasticsearch_spec.rb

@@ -39,14 +39,17 @@ describe LogStash::Outputs::ElasticSearch do
 
     let(:manticore_urls) { subject.client.pool.urls }
     let(:manticore_url) { manticore_urls.first }
-    
-    describe "getting a document type" do
-      it "should default to 'doc'" do
-        expect(subject.send(:get_event_type, LogStash::Event.new)).to eql("doc")
-      end
 
+    describe "getting a document type" do
       context "if document_type isn't set" do
         let(:options) { super.merge("document_type" => nil)}
+        context "for 7.x elasticsearch clusters" do
+          let(:maximum_seen_major_version) { 7 }
+          it "should return '_doc'" do
+            expect(subject.send(:get_event_type, LogStash::Event.new("type" => "foo"))).to eql("_doc")
+          end
+        end
+
         context "for 6.x elasticsearch clusters" do
           let(:maximum_seen_major_version) { 6 }
           it "should return 'doc'" do
@@ -88,25 +91,25 @@ describe LogStash::Outputs::ElasticSearch do
         end
       end
     end
-    
+
     describe "with auth" do
       let(:user) { "myuser" }
       let(:password) { ::LogStash::Util::Password.new("mypassword") }
-      
+
       shared_examples "an authenticated config" do
         it "should set the URL auth correctly" do
           expect(manticore_url.user).to eq user
         end
       end
-        
+
       context "as part of a URL" do
         let(:options) {
           super.merge("hosts" => ["http://#{user}:#{password.value}@localhost:9200"])
         }
-        
+
         include_examples("an authenticated config")
       end
-      
+
       context "as a hash option" do
           let(:options) {
             super.merge!(
@@ -114,7 +117,7 @@ describe LogStash::Outputs::ElasticSearch do
               "password" => password
             )
         }
-        
+
         include_examples("an authenticated config")
       end
     end
@@ -218,7 +221,7 @@ describe LogStash::Outputs::ElasticSearch do
 
     context "429 errors" do
       let(:event) { ::LogStash::Event.new("foo" => "bar") }
-      let(:error) do 
+      let(:error) do
         ::LogStash::Outputs::ElasticSearch::HttpClient::Pool::BadResponseCodeError.new(
           429, double("url").as_null_object, double("request body"), double("response body")
         )
@@ -252,7 +255,7 @@ describe LogStash::Outputs::ElasticSearch do
       end
     end
   end
-  
+
   context "with timeout set" do
     let(:listener) { Flores::Random.tcp_listener }
     let(:port) { listener[2] }
@@ -290,6 +293,16 @@ describe LogStash::Outputs::ElasticSearch do
       end
     end
 
+    context "with a sprintf action equals to update" do
+      let(:options) { {"action" => "%{myactionfield}", "upsert" => '{"message": "some text"}' } }
+
+      let(:event) { LogStash::Event.new("myactionfield" => "update", "message" => "blah") }
+
+      it "should obtain specific action's params from event_action_tuple" do
+        expect(subject.event_action_tuple(event)[1]).to include(:_upsert)
+      end
+    end
+
     context "with an invalid action" do
       let(:options) { {"action" => "SOME Garbaaage"} }
       let(:do_register) { false } # this is what we want to test, so we disable the before(:each) call
@@ -301,8 +314,8 @@ describe LogStash::Outputs::ElasticSearch do
   end
 
   describe "SSL end to end" do
-    let(:manticore_double) do 
-      double("manticoreX#{self.inspect}") 
+    let(:manticore_double) do
+      double("manticoreX#{self.inspect}")
     end
 
     before(:each) do
@@ -311,18 +324,18 @@ describe LogStash::Outputs::ElasticSearch do
       allow(manticore_double).to receive(:head).with(any_args).and_return(response_double)
       allow(manticore_double).to receive(:get).with(any_args).and_return(response_double)
       allow(manticore_double).to receive(:close)
-        
+
       allow(::Manticore::Client).to receive(:new).and_return(manticore_double)
       subject.register
     end
-    
+
     shared_examples("an encrypted client connection") do
       it "should enable SSL in manticore" do
         expect(subject.client.pool.urls.map(&:scheme).uniq).to eql(['https'])
       end
     end
 
-      
+
     context "With the 'ssl' option" do
       let(:options) { {"ssl" => true}}
 
@@ -337,24 +350,34 @@ describe LogStash::Outputs::ElasticSearch do
 
   describe "retry_on_conflict" do
     let(:num_retries) { 123 }
-    let(:event) { LogStash::Event.new("message" => "blah") }
+    let(:event) { LogStash::Event.new("myactionfield" => "update", "message" => "blah") }
     let(:options) { { 'retry_on_conflict' => num_retries } }
 
     context "with a regular index" do
       let(:options) { super.merge("action" => "index") }
 
-      it "should interpolate the requested action value when creating an event_action_tuple" do
+      it "should not set the retry_on_conflict parameter when creating an event_action_tuple" do
         action, params, event_data = subject.event_action_tuple(event)
         expect(params).not_to include({:_retry_on_conflict => num_retries})
       end
     end
 
     context "using a plain update" do
-      let(:options) { super.merge("action" => "update", "retry_on_conflict" => num_retries, "document_id" => 1) } 
+      let(:options) { super.merge("action" => "update", "retry_on_conflict" => num_retries, "document_id" => 1) }
 
-      it "should interpolate the requested action value when creating an event_action_tuple" do
+      it "should set the retry_on_conflict parameter when creating an event_action_tuple" do
+        action, params, event_data = subject.event_action_tuple(event)
+        expect(params).to include({:_retry_on_conflict => num_retries})
+      end
+    end
+
+    context "with a sprintf action that resolves to update" do
+      let(:options) { super.merge("action" => "%{myactionfield}", "retry_on_conflict" => num_retries, "document_id" => 1) }
+
+      it "should set the retry_on_conflict parameter when creating an event_action_tuple" do
         action, params, event_data = subject.event_action_tuple(event)
         expect(params).to include({:_retry_on_conflict => num_retries})
+        expect(action).to eq("update")
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 9.0.3
+  version: 9.1.1
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-08 00:00:00.000000000 Z
+date: 2018-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -246,6 +246,7 @@ files:
 - spec/integration/outputs/index_spec.rb
 - spec/integration/outputs/index_version_spec.rb
 - spec/integration/outputs/ingest_pipeline_spec.rb
+- spec/integration/outputs/metrics_spec.rb
 - spec/integration/outputs/painless_update_spec.rb
 - spec/integration/outputs/parent_spec.rb
 - spec/integration/outputs/retry_spec.rb
@@ -285,7 +286,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.13
+rubygems_version: 2.6.11
 signing_key:
 specification_version: 4
 summary: Stores logs in Elasticsearch
@@ -312,6 +313,7 @@ test_files:
 - spec/integration/outputs/index_spec.rb
 - spec/integration/outputs/index_version_spec.rb
 - spec/integration/outputs/ingest_pipeline_spec.rb
+- spec/integration/outputs/metrics_spec.rb
 - spec/integration/outputs/painless_update_spec.rb
 - spec/integration/outputs/parent_spec.rb
 - spec/integration/outputs/retry_spec.rb