logstash-output-elasticsearch 7.4.3-java → 8.0.0-java

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

@@ -66,7 +66,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
 
       request_uri = format_url(url, path)
 
-      resp = @manticore.send(method.downcase, request_uri.to_s, params)
+      resp = @manticore.send(method.downcase, request_uri, params)
 
       # Manticore returns lazy responses by default
       # We want to block for our usage, this will wait for the repsonse
@@ -106,7 +106,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       
       request_uri.path = "#{request_uri.path}/#{parsed_path_and_query.path}".gsub(/\/{2,}/, "/")
         
-      request_uri
+      request_uri.to_s
     end
 
     def close

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

@@ -107,12 +107,6 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       @state_mutex.synchronize { @url_info }
     end
 
-    def connected_es_versions
-      @state_mutex.synchronize do
-        @url_info.values.select {|v| v[:state] == :alive }.map {|v| v[:version] }
-      end
-    end
-
     def urls
       url_info.keys
     end
@@ -160,7 +154,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
     ES2_SNIFF_RE_URL  = /([^\/]*)?\/?([^:]*):([0-9]+)/
     # Sniffs and returns the results. Does not update internal URLs!
     def check_sniff
-      _, url_meta, resp = perform_request(:get, @sniffing_path)
+      _, resp = perform_request(:get, @sniffing_path)
       parsed = LogStash::Json.load(resp.body)
       
       nodes = parsed['nodes']
@@ -168,10 +162,12 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
         @logger.warn("Sniff returned no nodes! Will not update hosts.")
         return nil
       else
-        case major_version(url_meta[:version])
+        case major_version(nodes)
         when 5, 6
           sniff_5x_and_above(nodes)
-        when 2, 1
+        when 2
+          sniff_2x_1x(nodes)
+        when 1
           sniff_2x_1x(nodes)
         else
           @logger.warn("Could not determine version for nodes in ES cluster!")
@@ -180,8 +176,8 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       end
     end
     
-    def major_version(version_string)
-      version_string.split('.').first.to_i
+    def major_version(nodes)
+      k,v = nodes.first; v['version'].split('.').first.to_i
     end
     
     def sniff_5x_and_above(nodes)
@@ -241,12 +237,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
           response = perform_request_to_url(url, :head, @healthcheck_path)
           # If no exception was raised it must have succeeded!
           logger.warn("Restored connection to ES instance", :url => url.sanitized.to_s)
-          # We reconnected to this node, check its ES version
-          es_version = get_es_version(url)
-          @state_mutex.synchronize do
-            meta[:version] = es_version
-            meta[:state] = :alive
-          end
+          @state_mutex.synchronize { meta[:state] = :alive }
         rescue HostUnreachableError, BadResponseCodeError => e
           logger.warn("Attempted to resurrect connection to dead ES instance, but got an error.", url: url.sanitized.to_s, error_type: e.class, error: e.message)
         end
@@ -262,16 +253,15 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
     end
 
     def perform_request(method, path, params={}, body=nil)
-      with_connection do |url, url_meta|
+      with_connection do |url|
         resp = perform_request_to_url(url, method, path, params, body)
-        [url, url_meta, resp]
+        [url, resp]
       end
     end
 
     [:get, :put, :post, :delete, :patch, :head].each do |method|
       define_method(method) do |path, params={}, body=nil|
-        _, _, response = perform_request(method, path, params, body)
-        response
+        perform_request(method, path, params, body)
       end
     end
 
@@ -333,10 +323,6 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       @state_mutex.synchronize { @url_info.size }
     end
 
-    def es_versions
-      @state_mutex.synchronize { @url_info.size }
-    end
-
     def add_url(url)
       @url_info[url] ||= empty_url_meta
     end
@@ -358,7 +344,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       # Custom error class used here so that users may retry attempts if they receive this error
       # should they choose to
       raise NoConnectionAvailableError, "No Available connections" unless url
-      yield url, url_meta
+      yield url
     rescue HostUnreachableError => e
       # Mark the connection as dead here since this is likely not transient
       mark_dead(url, e)
@@ -429,10 +415,5 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
         end
       end
     end
-
-    def get_es_version(url)
-      request = perform_request_to_url(url, :get, ROOT_URI_PATH)
-      LogStash::Json.load(request.body)["version"]["number"]
-    end
   end
 end; end; end; end;

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

@@ -12,10 +12,12 @@ module LogStash; module Outputs; class ElasticSearch
     end
 
     private
+    def self.get_es_version(client)
+      client.get_version
+    end
+
     def self.get_es_major_version(client)
-      # get the elasticsearch version of each node in the pool and
-      # pick the biggest major version
-      client.connected_es_versions.uniq.map {|version| version.split(".").first.to_i}.max
+      get_es_version(client)["number"][0]
     end
 
     def self.get_template(path, es_major_version)
@@ -28,7 +30,7 @@ module LogStash; module Outputs; class ElasticSearch
     end
 
     def self.default_template_path(es_major_version)
-      template_version = es_major_version == 1 ? 2 : es_major_version
+      template_version = es_major_version == "1" ? "2" : es_major_version
       default_template_name = "elasticsearch-template-es#{template_version}x.json"
       ::File.expand_path(default_template_name, ::File.dirname(__FILE__))
     end

data/logstash-output-elasticsearch.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-output-elasticsearch'
-  s.version         = '7.4.3'
+  s.version         = '8.0.0'
   s.licenses        = ['apache-2.0']
   s.summary         = "Logstash Output to 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/es_spec_helper.rb

@@ -10,12 +10,6 @@ module ESHelper
   def get_client
     Elasticsearch::Client.new(:hosts => [get_host_port])
   end
-
-  def self.es_version_satisfies?(*requirement)
-    es_version = RSpec.configuration.filter[:es_version] || ENV['ES_VERSION']
-    es_release_version = Gem::Version.new(es_version).release
-    Gem::Requirement.new(requirement).satisfied_by?(es_release_version)
-  end
 end
 
 RSpec.configure do |config|

data/spec/integration/outputs/compressed_indexing_spec.rb

@@ -9,60 +9,58 @@ RSpec::Matchers.define :a_valid_gzip_encoded_string do
   }
 end
 
-if ESHelper.es_version_satisfies?(">= 5")
-  describe "indexing with http_compression turned on", :integration => true do
-    let(:event) { LogStash::Event.new("message" => "Hello World!", "type" => type) }
-    let(:index) { 10.times.collect { rand(10).to_s }.join("") }
-    let(:type) { 10.times.collect { rand(10).to_s }.join("") }
-    let(:event_count) { 10000 + rand(500) }
-    let(:events) { event_count.times.map { event }.to_a }
-    let(:config) {
-      {
-        "hosts" => get_host_port,
-        "index" => index,
-        "http_compression" => true
-      }
+describe "indexing with http_compression turned on", :integration => true, :version_greater_than_equal_to_5x => true do
+  let(:event) { LogStash::Event.new("message" => "Hello World!", "type" => type) }
+  let(:index) { 10.times.collect { rand(10).to_s }.join("") }
+  let(:type) { 10.times.collect { rand(10).to_s }.join("") }
+  let(:event_count) { 10000 + rand(500) }
+  let(:events) { event_count.times.map { event }.to_a }
+  let(:config) {
+    {
+      "hosts" => get_host_port,
+      "index" => index,
+      "http_compression" => true
     }
-    subject { LogStash::Outputs::ElasticSearch.new(config) }
-
-    let(:es_url) { "http://#{get_host_port}" }
-    let(:index_url) {"#{es_url}/#{index}"}
-    let(:http_client_options) { {} }
-    let(:http_client) do
-      Manticore::Client.new(http_client_options)
-    end
+  }
+  subject { LogStash::Outputs::ElasticSearch.new(config) }
 
-    before do
-      subject.register
-    end
+  let(:es_url) { "http://#{get_host_port}" }
+  let(:index_url) {"#{es_url}/#{index}"}
+  let(:http_client_options) { {} }
+  let(:http_client) do
+    Manticore::Client.new(http_client_options)
+  end
 
-    shared_examples "an indexer" do
-      it "ships events" do
-        subject.multi_receive(events)
+  before do
+    subject.register
+  end
+  
+  shared_examples "an indexer" do
+    it "ships events" do
+      subject.multi_receive(events)
 
-        http_client.post("#{es_url}/_refresh").call
+      http_client.post("#{es_url}/_refresh").call
 
-        response = http_client.get("#{index_url}/_count?q=*")
-        result = LogStash::Json.load(response.body)
-        cur_count = result["count"]
-        expect(cur_count).to eq(event_count)
+      response = http_client.get("#{index_url}/_count?q=*")
+      result = LogStash::Json.load(response.body)
+      cur_count = result["count"]
+      expect(cur_count).to eq(event_count)
 
-        response = http_client.get("#{index_url}/_search?q=*&size=1000")
-        result = LogStash::Json.load(response.body)
-        result["hits"]["hits"].each do |doc|
-          expect(doc["_type"]).to eq(type)
-          expect(doc["_index"]).to eq(index)
-        end
+      response = http_client.get("#{index_url}/_search?q=*&size=1000")
+      result = LogStash::Json.load(response.body)
+      result["hits"]["hits"].each do |doc|
+        expect(doc["_type"]).to eq(type)
+        expect(doc["_index"]).to eq(index)
       end
     end
+  end
 
-    it "sets the correct content-encoding header and body is compressed" do
-      expect(subject.client.pool.adapter.client).to receive(:send).
-        with(anything, anything, {:headers=>{"Content-Encoding"=>"gzip", "Content-Type"=>"application/json"}, :body => a_valid_gzip_encoded_string}).
-        and_call_original
-      subject.multi_receive(events)
-    end
-
-    it_behaves_like("an indexer")
+  it "sets the correct content-encoding header and body is compressed" do
+    expect(subject.client.pool.adapter.client).to receive(:send).
+      with(anything, anything, {:headers=>{"Content-Encoding"=>"gzip", "Content-Type"=>"application/json"}, :body => a_valid_gzip_encoded_string}).
+      and_call_original
+    subject.multi_receive(events)
   end
+
+  it_behaves_like("an indexer")
 end

data/spec/integration/outputs/delete_spec.rb

@@ -2,64 +2,62 @@ require_relative "../../../spec/es_spec_helper"
 require "logstash/outputs/elasticsearch"
 
 
-if ESHelper.es_version_satisfies?(">= 2")
-  describe "Versioned delete", :integration => true do
-    require "logstash/outputs/elasticsearch"
+describe "Versioned delete", :integration => true, :version_greater_than_equal_to_2x => true do
+  require "logstash/outputs/elasticsearch"
+
+  let(:es) { get_client }
+
+  before :each do
+    # Delete all templates first.
+    # Clean ES of data before we start.
+    es.indices.delete_template(:name => "*")
+    # This can fail if there are no indexes, ignore failure.
+    es.indices.delete(:index => "*") rescue nil
+    es.indices.refresh
+  end
 
-    let(:es) { get_client }
+  context "when delete only" do
+    subject { LogStash::Outputs::ElasticSearch.new(settings) }
 
-    before :each do
-      # Delete all templates first.
-      # Clean ES of data before we start.
-      es.indices.delete_template(:name => "*")
-      # This can fail if there are no indexes, ignore failure.
-      es.indices.delete(:index => "*") rescue nil
-      es.indices.refresh
+    before do
+      subject.register
     end
 
-    context "when delete only" do
-      subject { LogStash::Outputs::ElasticSearch.new(settings) }
-
-      before do
-        subject.register
-      end
-
-      let(:settings) do
-        {
-          "manage_template" => true,
-          "index" => "logstash-delete",
-          "template_overwrite" => true,
-          "hosts" => get_host_port(),
-          "document_id" => "%{my_id}",
-          "version" => "%{my_version}",
-          "version_type" => "external",
-          "action" => "%{my_action}"
-        }
-      end
-
-      it "should ignore non-monotonic external version updates" do
-        id = "ev2"
-        subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "index", "message" => "foo", "my_version" => 99)])
-        r = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
-        expect(r['_version']).to eq(99)
-        expect(r['_source']['message']).to eq('foo')
+    let(:settings) do
+      {
+        "manage_template" => true,
+        "index" => "logstash-delete",
+        "template_overwrite" => true,
+        "hosts" => get_host_port(),
+        "document_id" => "%{my_id}",
+        "version" => "%{my_version}",
+        "version_type" => "external",
+        "action" => "%{my_action}"
+      }
+    end
 
-        subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "delete", "message" => "foo", "my_version" => 98)])
-        r2 = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
-        expect(r2['_version']).to eq(99)
-        expect(r2['_source']['message']).to eq('foo')
-      end
+    it "should ignore non-monotonic external version updates" do
+      id = "ev2"
+      subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "index", "message" => "foo", "my_version" => 99)])
+      r = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
+      expect(r['_version']).to eq(99)
+      expect(r['_source']['message']).to eq('foo')
+
+      subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "delete", "message" => "foo", "my_version" => 98)])
+      r2 = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
+      expect(r2['_version']).to eq(99)
+      expect(r2['_source']['message']).to eq('foo')
+    end
 
-      it "should commit monotonic external version updates" do
-        id = "ev3"
-        subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "index", "message" => "foo", "my_version" => 99)])
-        r = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
-        expect(r['_version']).to eq(99)
-        expect(r['_source']['message']).to eq('foo')
+    it "should commit monotonic external version updates" do
+      id = "ev3"
+      subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "index", "message" => "foo", "my_version" => 99)])
+      r = es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true)
+      expect(r['_version']).to eq(99)
+      expect(r['_source']['message']).to eq('foo')
 
-        subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "delete", "message" => "foo", "my_version" => 100)])
-        expect { es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
-      end
+      subject.multi_receive([LogStash::Event.new("my_id" => id, "my_action" => "delete", "message" => "foo", "my_version" => 100)])
+      expect { es.get(:index => 'logstash-delete', :type => 'logs', :id => id, :refresh => true) }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
     end
   end
 end

data/spec/integration/outputs/groovy_update_spec.rb

@@ -1,150 +1,148 @@
 require_relative "../../../spec/es_spec_helper"
 
-if ESHelper.es_version_satisfies?('>= 2', '< 6')
-  describe "Update actions using groovy scripts", :integration => true, :update_tests => 'groovy' do
-    require "logstash/outputs/elasticsearch"
+describe "Update actions using groovy scripts", :integration => true, :update_tests => 'groovy', :version_greater_than_equal_to_2x => true do
+  require "logstash/outputs/elasticsearch"
 
-    def get_es_output( options={} )
-      settings = {
-        "manage_template" => true,
-        "index" => "logstash-update",
-        "template_overwrite" => true,
-        "hosts" => get_host_port(),
-        "action" => "update",
-        "script_lang" => "groovy"
-      }
-      LogStash::Outputs::ElasticSearch.new(settings.merge!(options))
-    end
-
-    before :each do
-      @es = get_client
-      # Delete all templates first.
-      # Clean ES of data before we start.
-      @es.indices.delete_template(:name => "*")
-      # This can fail if there are no indexes, ignore failure.
-      @es.indices.delete(:index => "*") rescue nil
-      @es.index(
-        :index => 'logstash-update',
-        :type => 'logs',
-        :id => "123",
-        :body => { :message => 'Test', :counter => 1 }
-      )
-      @es.indices.refresh
-    end
+  def get_es_output( options={} )
+    settings = {
+      "manage_template" => true,
+      "index" => "logstash-update",
+      "template_overwrite" => true,
+      "hosts" => get_host_port(),
+      "action" => "update",
+      "script_lang" => "groovy"
+    }
+    LogStash::Outputs::ElasticSearch.new(settings.merge!(options))
+  end
 
-    context "scripted updates" do
-      it "should increment a counter with event/doc 'count' variable" do
-        subject = get_es_output({ 'document_id' => "123", 'script' => 'scripted_update', 'script_type' => 'file' })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("count" => 2)])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
-        insist { r["_source"]["counter"] } == 3
-      end
+  before :each do
+    @es = get_client
+    # Delete all templates first.
+    # Clean ES of data before we start.
+    @es.indices.delete_template(:name => "*")
+    # This can fail if there are no indexes, ignore failure.
+    @es.indices.delete(:index => "*") rescue nil
+    @es.index(
+      :index => 'logstash-update',
+      :type => 'logs',
+      :id => "123",
+      :body => { :message => 'Test', :counter => 1 }
+    )
+    @es.indices.refresh
+  end
 
-      it "should increment a counter with event/doc '[data][count]' nested variable" do
-        subject = get_es_output({ 'document_id' => "123", 'script' => 'scripted_update_nested', 'script_type' => 'file' })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("data" => { "count" => 3 })])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
-        insist { r["_source"]["counter"] } == 4
-      end
+  context "scripted updates" do
+    it "should increment a counter with event/doc 'count' variable" do
+      subject = get_es_output({ 'document_id' => "123", 'script' => 'scripted_update', 'script_type' => 'file' })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("count" => 2)])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
+      insist { r["_source"]["counter"] } == 3
+    end
 
-      it "should increment a counter with event/doc 'count' variable with inline script" do
-        subject = get_es_output({
-          'document_id' => "123",
-          'script' => 'ctx._source.counter += event["counter"]',
-          'script_lang' => 'groovy',
-          'script_type' => 'inline'
-        })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("counter" => 3 )])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
-        insist { r["_source"]["counter"] } == 4
-      end
+    it "should increment a counter with event/doc '[data][count]' nested variable" do
+      subject = get_es_output({ 'document_id' => "123", 'script' => 'scripted_update_nested', 'script_type' => 'file' })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("data" => { "count" => 3 })])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
+      insist { r["_source"]["counter"] } == 4
+    end
 
-      it "should increment a counter with event/doc 'count' variable with event/doc as upsert and inline script" do
-        subject = get_es_output({
-          'document_id' => "123",
-          'doc_as_upsert' => true,
-          'script' => 'if( ctx._source.containsKey("counter") ){ ctx._source.counter += event["counter"]; } else { ctx._source.counter = event["counter"]; }',
-          'script_lang' => 'groovy',
-          'script_type' => 'inline'
-        })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("counter" => 3 )])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
-        insist { r["_source"]["counter"] } == 4
-      end
+    it "should increment a counter with event/doc 'count' variable with inline script" do
+      subject = get_es_output({
+        'document_id' => "123",
+        'script' => 'ctx._source.counter += event["counter"]',
+        'script_lang' => 'groovy',
+        'script_type' => 'inline'
+      })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("counter" => 3 )])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
+      insist { r["_source"]["counter"] } == 4
+    end
 
-      it "should, with new doc, set a counter with event/doc 'count' variable with event/doc as upsert and inline script" do
-        subject = get_es_output({
-          'document_id' => "456",
-          'doc_as_upsert' => true,
-          'script' => 'if( ctx._source.containsKey("counter") ){ ctx._source.counter += event["count"]; } else { ctx._source.counter = event["count"]; }',
-          'script_lang' => 'groovy',
-          'script_type' => 'inline'
-        })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("counter" => 3 )])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
-        insist { r["_source"]["counter"] } == 3
-      end
+    it "should increment a counter with event/doc 'count' variable with event/doc as upsert and inline script" do
+      subject = get_es_output({
+        'document_id' => "123",
+        'doc_as_upsert' => true,
+        'script' => 'if( ctx._source.containsKey("counter") ){ ctx._source.counter += event["counter"]; } else { ctx._source.counter = event["counter"]; }',
+        'script_lang' => 'groovy',
+        'script_type' => 'inline'
+      })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("counter" => 3 )])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
+      insist { r["_source"]["counter"] } == 4
+    end
 
-      it "should increment a counter with event/doc 'count' variable with indexed script" do
-        @es.put_script lang: 'groovy', id: 'indexed_update', body: { script: 'ctx._source.counter += event["count"]' }
-        subject = get_es_output({
-          'document_id' => "123",
-          'script' => 'indexed_update',
-          'script_lang' => 'groovy',
-          'script_type' => 'indexed'
-        })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("count" => 4 )])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
-        insist { r["_source"]["counter"] } == 5
-      end
+    it "should, with new doc, set a counter with event/doc 'count' variable with event/doc as upsert and inline script" do
+      subject = get_es_output({
+        'document_id' => "456",
+        'doc_as_upsert' => true,
+        'script' => 'if( ctx._source.containsKey("counter") ){ ctx._source.counter += event["count"]; } else { ctx._source.counter = event["count"]; }',
+        'script_lang' => 'groovy',
+        'script_type' => 'inline'
+      })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("counter" => 3 )])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
+      insist { r["_source"]["counter"] } == 3
     end
 
-    context "when update with upsert" do
-      it "should create new documents with provided upsert" do
-        subject = get_es_output({ 'document_id' => "456", 'upsert' => '{"message": "upsert message"}' })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
-        insist { r["_source"]["message"] } == 'upsert message'
-      end
+    it "should increment a counter with event/doc 'count' variable with indexed script" do
+      @es.put_script lang: 'groovy', id: 'indexed_update', body: { script: 'ctx._source.counter += event["count"]' }
+      subject = get_es_output({
+        'document_id' => "123",
+        'script' => 'indexed_update',
+        'script_lang' => 'groovy',
+        'script_type' => 'indexed'
+      })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("count" => 4 )])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "123", :refresh => true)
+      insist { r["_source"]["counter"] } == 5
+    end
+  end
+    
+  context "when update with upsert" do
+    it "should create new documents with provided upsert" do
+      subject = get_es_output({ 'document_id' => "456", 'upsert' => '{"message": "upsert message"}' })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
+      insist { r["_source"]["message"] } == 'upsert message'
+    end
 
-      it "should create new documents with event/doc as upsert" do
-        subject = get_es_output({ 'document_id' => "456", 'doc_as_upsert' => true })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
-        insist { r["_source"]["message"] } == 'sample message here'
-      end
+    it "should create new documents with event/doc as upsert" do
+      subject = get_es_output({ 'document_id' => "456", 'doc_as_upsert' => true })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
+      insist { r["_source"]["message"] } == 'sample message here'
+    end
 
-      it "should fail on documents with event/doc as upsert at external version" do
-        subject = get_es_output({ 'document_id' => "456", 'doc_as_upsert' => true, 'version' => 999, "version_type" => "external" })
-        expect { subject.register }.to raise_error(LogStash::ConfigurationError)
-      end
+    it "should fail on documents with event/doc as upsert at external version" do
+      subject = get_es_output({ 'document_id' => "456", 'doc_as_upsert' => true, 'version' => 999, "version_type" => "external" })
+      expect { subject.register }.to raise_error(LogStash::ConfigurationError)
     end
+  end
 
-    context "updates with scripted upsert" do
-      it "should create new documents with upsert content" do
-        subject = get_es_output({ 'document_id' => "456", 'script' => 'scripted_update', 'upsert' => '{"message": "upsert message"}', 'script_type' => 'file' })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
-        insist { r["_source"]["message"] } == 'upsert message'
-      end
+  context "updates with scripted upsert" do
+    it "should create new documents with upsert content" do
+      subject = get_es_output({ 'document_id' => "456", 'script' => 'scripted_update', 'upsert' => '{"message": "upsert message"}', 'script_type' => 'file' })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
+      insist { r["_source"]["message"] } == 'upsert message'
+    end
 
-      it "should create new documents with event/doc as script params" do
-        subject = get_es_output({ 'document_id' => "456", 'script' => 'scripted_upsert', 'scripted_upsert' => true, 'script_type' => 'file' })
-        subject.register
-        subject.multi_receive([LogStash::Event.new("counter" => 1)])
-        @es.indices.refresh
-        r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
-        insist { r["_source"]["counter"] } == 1
-      end
+    it "should create new documents with event/doc as script params" do
+      subject = get_es_output({ 'document_id' => "456", 'script' => 'scripted_upsert', 'scripted_upsert' => true, 'script_type' => 'file' })
+      subject.register
+      subject.multi_receive([LogStash::Event.new("counter" => 1)])
+      @es.indices.refresh
+      r = @es.get(:index => 'logstash-update', :type => 'logs', :id => "456", :refresh => true)
+      insist { r["_source"]["counter"] } == 1
     end
   end
 end