logstash-output-elasticsearch 12.0.1-java → 12.0.3-java

data/spec/integration/outputs/ilm_spec.rb

@@ -102,7 +102,7 @@ shared_examples_for 'an ILM disabled Logstash' do
   it 'should not install the default policy' do
     subject.register
     sleep(1)
-    expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+    expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
   end
 
   it 'should not write the ILM settings into the template' do
@@ -282,12 +282,12 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
           subject.register
           sleep(1)
           expect(@es.indices.exists_alias(name: "logstash")).to be_truthy
-          expect(@es.get_alias(name: "logstash")).to include("logstash-000001")
+          expect(@es.indices.get_alias(name: "logstash")).to include("logstash-000001")
         end
       end
 
       it 'should install it if it is not present' do
-        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
         subject.register
         sleep(1)
         expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.not_to raise_error
@@ -298,7 +298,7 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
         subject.register
         sleep(1)
         expect(@es.indices.exists_alias(name: "logstash")).to be_truthy
-        expect(@es.get_alias(name: "logstash")).to include("logstash-#{todays_date}-000001")
+        expect(@es.indices.get_alias(name: "logstash")).to include("logstash-#{todays_date}-000001")
       end
 
       it 'should ingest into a single index' do
@@ -340,14 +340,14 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
       let (:policy) { small_max_doc_policy }
 
       before do
-        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
         put_policy(@es,ilm_policy_name, policy)
       end
 
       it 'should not install the default policy if it is not used' do
         subject.register
         sleep(1)
-        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
       end
     end
 
@@ -357,14 +357,14 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
       let (:policy) { max_age_policy("1d") }
 
       before do
-        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
         put_policy(@es,ilm_policy_name, policy)
       end
 
       it 'should not install the default policy if it is not used' do
         subject.register
         sleep(1)
-        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.to raise_error(get_expected_error_class)
       end
     end
 
@@ -374,7 +374,7 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
         subject.register
         sleep(1)
         expect(@es.indices.exists_alias(name: expected_index)).to be_truthy
-        expect(@es.get_alias(name: expected_index)).to include("#{expected_index}-#{todays_date}-000001")
+        expect(@es.indices.get_alias(name: expected_index)).to include("#{expected_index}-#{todays_date}-000001")
       end
 
       it 'should write the ILM settings into the template' do
@@ -443,17 +443,18 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
         subject.register
         sleep(1)
         expect(@es.indices.exists_alias(name: ilm_rollover_alias)).to be_truthy
-        expect(@es.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
+        expect(@es.indices.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
       end
 
       context 'when the custom rollover alias already exists' do
         it 'should ignore the already exists error' do
           expect(@es.indices.exists_alias(name: ilm_rollover_alias)).to be_falsey
-          put_alias(@es, "#{ilm_rollover_alias}-#{todays_date}-000001", ilm_rollover_alias)
+          @es.indices.create(index: "#{ilm_rollover_alias}-#{todays_date}-000001")
+          @es.indices.put_alias(name: ilm_rollover_alias, index: "#{ilm_rollover_alias}-#{todays_date}-000001")
           expect(@es.indices.exists_alias(name: ilm_rollover_alias)).to be_truthy
           subject.register
           sleep(1)
-          expect(@es.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
+          expect(@es.indices.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
         end
 
       end
@@ -532,3 +533,8 @@ describe 'Elasticsearch has index lifecycle management enabled', :integration =>
   end
 
 end
+
+def get_expected_error_class
+  return Elastic::Transport::Transport::Errors::NotFound if elastic_ruby_v8_client_available?
+  Elasticsearch::Transport::Transport::Errors::NotFound
+end

data/spec/integration/outputs/index_spec.rb

@@ -13,7 +13,7 @@ describe "TARGET_BULK_BYTES", :integration => true do
       }
   }
   let(:index) { 10.times.collect { rand(10).to_s }.join("") }
-  let(:type) { ESHelper.es_version_satisfies?("< 7") ? "doc" : "_doc" }
+  let(:type) { "_doc" }
 
   subject { LogStash::Outputs::ElasticSearch.new(config) }
 
@@ -82,7 +82,7 @@ describe "indexing with sprintf resolution", :integration => true do
   let(:message) { "Hello from #{__FILE__}" }
   let(:event) { LogStash::Event.new("message" => message, "type" => type) }
   let (:index) { "%{[index_name]}_dynamic" }
-  let(:type) { ESHelper.es_version_satisfies?("< 7") ? "doc" : "_doc" }
+  let(:type) { "_doc" }
   let(:event_count) { 1 }
   let(:user) { "simpleuser" }
   let(:password) { "abc123" }
@@ -151,7 +151,7 @@ describe "indexing" do
   let(:message) { "Hello from #{__FILE__}" }
   let(:event) { LogStash::Event.new("message" => message, "type" => type) }
   let(:index) { 10.times.collect { rand(10).to_s }.join("") }
-  let(:type) { ESHelper.es_version_satisfies?("< 7") ? "doc" : "_doc" }
+  let(:type) { "_doc" }
   let(:event_count) { 1 + rand(2) }
   let(:config) { "not implemented" }
   let(:events) { event_count.times.map { event }.to_a }
@@ -204,10 +204,10 @@ describe "indexing" do
       result["hits"]["hits"].each do |doc|
         expect(doc["_source"]["message"]).to eq(message)
 
-        if ESHelper.es_version_satisfies?("< 8")
-          expect(doc["_type"]).to eq(type)
-        else
+        if ESHelper.es_version_satisfies?(">= 8")
           expect(doc).not_to include("_type")
+        else
+          expect(doc["_type"]).to eq(type)
         end
         expect(doc["_index"]).to eq(index)
       end
@@ -346,7 +346,7 @@ describe "indexing" do
   end
 
   describe "an indexer with no type value set (default to doc)", :integration => true do
-    let(:type) { ESHelper.es_version_satisfies?("< 7") ? "doc" : "_doc" }
+    let(:type) { "_doc" }
     let(:config) {
       {
         "hosts" => get_host_port,

data/spec/integration/outputs/index_version_spec.rb

@@ -36,11 +36,11 @@ describe "Versioned indexing", :integration => true do
 
       it "should default to ES version" do
         subject.multi_receive([LogStash::Event.new("my_id" => "123", "message" => "foo")])
-        r = es.get(:index => 'logstash-index', :type => doc_type, :id => "123", :refresh => true)
+        r = es.get(:index => 'logstash-index', :id => '123', :refresh => true)
         expect(r["_version"]).to eq(1)
         expect(r["_source"]["message"]).to eq('foo')
         subject.multi_receive([LogStash::Event.new("my_id" => "123", "message" => "foobar")])
-        r2 = es.get(:index => 'logstash-index', :type => doc_type, :id => "123", :refresh => true)
+        r2 = es.get(:index => 'logstash-index', :id => '123', :refresh => true)
         expect(r2["_version"]).to eq(2)
         expect(r2["_source"]["message"]).to eq('foobar')
       end  
@@ -63,7 +63,7 @@ describe "Versioned indexing", :integration => true do
       it "should respect the external version" do
         id = "ev1"
         subject.multi_receive([LogStash::Event.new("my_id" => id, "my_version" => "99", "message" => "foo")])
-        r = es.get(:index => 'logstash-index', :type => doc_type, :id => id, :refresh => true)
+        r = es.get(:index => 'logstash-index', :id => id, :refresh => true)
         expect(r["_version"]).to eq(99)
         expect(r["_source"]["message"]).to eq('foo')
       end
@@ -71,12 +71,12 @@ describe "Versioned indexing", :integration => true do
       it "should ignore non-monotonic external version updates" do
         id = "ev2"
         subject.multi_receive([LogStash::Event.new("my_id" => id, "my_version" => "99", "message" => "foo")])
-        r = es.get(:index => 'logstash-index', :type => doc_type, :id => id, :refresh => true)
+        r = es.get(:index => 'logstash-index', :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_version" => "98", "message" => "foo")])
-        r2 = es.get(:index => 'logstash-index', :type => doc_type, :id => id, :refresh => true)
+        r2 = es.get(:index => 'logstash-index', :id => id, :refresh => true)
         expect(r2["_version"]).to eq(99)
         expect(r2["_source"]["message"]).to eq('foo')
       end
@@ -84,12 +84,12 @@ describe "Versioned indexing", :integration => true do
       it "should commit monotonic external version updates" do
         id = "ev3"
         subject.multi_receive([LogStash::Event.new("my_id" => id, "my_version" => "99", "message" => "foo")])
-        r = es.get(:index => 'logstash-index', :type => doc_type, :id => id, :refresh => true)
+        r = es.get(:index => 'logstash-index', :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_version" => "100", "message" => "foo")])
-        r2 = es.get(:index => 'logstash-index', :type => doc_type, :id => id, :refresh => true)
+        r2 = es.get(:index => 'logstash-index', :id => id, :refresh => true)
         expect(r2["_version"]).to eq(100)
         expect(r2["_source"]["message"]).to eq('foo')
       end

data/spec/integration/outputs/no_es_on_startup_spec.rb

@@ -74,5 +74,5 @@ describe "elasticsearch is down on startup", :integration => true do
     expect(r).to have_hits(2)
     expect(subject.plugin_metadata.get(:cluster_uuid)).not_to be_empty
     expect(subject.plugin_metadata.get(:cluster_uuid)).not_to eq("_na_")
-  end if ESHelper.es_version_satisfies?(">=7")
+  end
 end

data/spec/integration/outputs/painless_update_spec.rb

@@ -22,11 +22,12 @@ describe "Update actions using painless scripts", :integration => true, :update_
     # This can fail if there are no indexes, ignore failure.
     @es.indices.delete(:index => "*") rescue nil
     @es.index(
-      :index => 'logstash-update',
-      :type => doc_type,
-      :id => "123",
-      :body => { :message => 'Test', :counter => 1 }
-    )
+      {
+        :index => 'logstash-update',
+        :id => '123',
+        :body => { :message => 'Test', :counter => 1 },
+        :refresh => true
+      })
     @es.indices.refresh
   end
 
@@ -46,7 +47,7 @@ describe "Update actions using painless scripts", :integration => true, :update_
         subject = get_es_output(plugin_parameters)
         subject.register
         subject.multi_receive([LogStash::Event.new("count" => 4 )])
-        r = @es.get(:index => 'logstash-update', :type => doc_type, :id => "123", :refresh => true)
+        r = @es.get(:index => 'logstash-update', :id => "123", :refresh => true)
         expect(r["_source"]["counter"]).to eq(5)
       end
     end
@@ -57,7 +58,7 @@ describe "Update actions using painless scripts", :integration => true, :update_
       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 => doc_type, :id => "456", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => "456", :refresh => true)
       expect(r["_source"]["message"]).to eq('upsert message')
     end
 
@@ -65,7 +66,7 @@ describe "Update actions using painless scripts", :integration => true, :update_
       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 => doc_type, :id => "456", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => "456", :refresh => true)
       expect(r["_source"]["message"]).to eq('sample message here')
     end
 
@@ -82,7 +83,7 @@ describe "Update actions using painless scripts", :integration => true, :update_
         subject.register
 
         subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
-        r = @es.get(:index => 'logstash-update', :type => doc_type, :id => "456", :refresh => true)
+        r = @es.get(:index => 'logstash-update', :id => "456", :refresh => true)
         expect(r["_source"]["message"]).to eq('upsert message')
       end
 
@@ -91,7 +92,7 @@ describe "Update actions using painless scripts", :integration => true, :update_
         subject.register
         subject.multi_receive([LogStash::Event.new("counter" => 1)])
         @es.indices.refresh
-        r = @es.get(:index => 'logstash-update', :type => doc_type, :id => "456", :refresh => true)
+        r = @es.get(:index => 'logstash-update', :id => "456", :refresh => true)
         expect(r["_source"]["counter"]).to eq(1)
       end
     end

data/spec/integration/outputs/parent_spec.rb

@@ -6,7 +6,7 @@ describe "join type field", :integration => true do
   shared_examples "a join field based parent indexer" do
     let(:index) { 10.times.collect { rand(10).to_s }.join("") }
 
-    let(:type) { ESHelper.es_version_satisfies?("< 7") ? "doc" : "_doc" }
+    let(:type) { "_doc" }
 
     let(:event_count) { 10000 + rand(500) }
     let(:parent) { "not_implemented" }
@@ -33,8 +33,7 @@ describe "join type field", :integration => true do
         }
       }
 
-      mapping = ESHelper.es_version_satisfies?('<7') ? { "mappings" => { type => properties } }
-                                                     : { "mappings" => properties}
+      mapping = { "mappings" => properties}
 
       Manticore.put("#{index_url}", {:body => mapping.to_json, :headers => default_headers}).call
       pdoc = { "message" => "ohayo", join_field => parent_relation }

data/spec/integration/outputs/retry_spec.rb

@@ -5,19 +5,11 @@ describe "failures in bulk class expected behavior", :integration => true do
   let(:template) { '{"template" : "not important, will be updated by :index"}' }
   let(:event1) { LogStash::Event.new("somevalue" => 100, "@timestamp" => "2014-11-17T20:37:17.223Z", "@metadata" => {"retry_count" => 0}) }
   let(:action1) do
-    if ESHelper.es_version_satisfies?("< 7")
-      ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17", :_type=> doc_type }, event1.to_hash])
-    else
-      ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17" }, event1.to_hash])
-    end
+    ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17" }, event1.to_hash])
   end
   let(:event2) { LogStash::Event.new("geoip" => { "location" => [ 0.0, 0.0] }, "@timestamp" => "2014-11-17T20:37:17.223Z", "@metadata" => {"retry_count" => 0}) }
   let(:action2) do
-    if ESHelper.es_version_satisfies?("< 7")
-      ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17", :_type=> doc_type }, event2.to_hash])
-    else
-      ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17" }, event2.to_hash])
-    end
+    ESHelper.action_for_version(["index", {:_id=>nil, routing_field_name =>nil, :_index=>"logstash-2014.11.17" }, event2.to_hash])
   end
   let(:invalid_event) { LogStash::Event.new("geoip" => { "location" => "notlatlon" }, "@timestamp" => "2014-11-17T20:37:17.223Z") }
 

data/spec/integration/outputs/sniffer_spec.rb

@@ -33,48 +33,13 @@ describe "pool sniffer", :integration => true do
 
         expect(uris.size).to eq(1)
       end
-
-      it "should return the correct sniff URL" do
-        if ESHelper.es_version_satisfies?("<7")
-          # We do a more thorough check on these versions because we can more reliably guess the ip
-          uris = subject.check_sniff
-
-          expect(uris).to include(::LogStash::Util::SafeURI.new("//#{es_ip}:#{es_port}"))
-        else
-          # ES 1.x (and ES 7.x) returned the public hostname by default. This is hard to approximate
-          # so for ES1.x and 7.x we don't check the *exact* hostname
-          skip
-        end
-      end
     end
   end
 
-  if ESHelper.es_version_satisfies?(">= 7")
-    describe("Complex sniff parsing ES 7x") do
-      before(:each) do
-        response_double = double("_nodes/http", body: File.read("spec/fixtures/_nodes/7x.json"))
-        allow(subject).to receive(:perform_request).and_return([nil, { version: "7.0" }, response_double])
-        subject.start
-      end
-
-      context "with mixed master-only, data-only, and data + master nodes" do
-        it "should execute a sniff without error" do
-          expect { subject.check_sniff }.not_to raise_error
-        end
-
-        it "should return the correct sniff URLs" do
-          # ie. with the master-only node, and with the node name correctly set.
-          uris = subject.check_sniff
-
-          expect(uris).to include(::LogStash::Util::SafeURI.new("//dev-masterdata:9201"), ::LogStash::Util::SafeURI.new("//dev-data:9202"))
-        end
-      end
-    end
-  end
-  describe("Complex sniff parsing ES") do
+  describe("Complex sniff parsing") do
     before(:each) do
-      response_double = double("_nodes/http", body: File.read("spec/fixtures/_nodes/6x.json"))
-      allow(subject).to receive(:perform_request).and_return([nil, { version: "6.8" }, response_double])
+      response_double = double("_nodes/http", body: File.read("spec/fixtures/_nodes/7x.json"))
+      allow(subject).to receive(:perform_request).and_return([nil, { version: "7.0" }, response_double])
       subject.start
     end
 
@@ -84,10 +49,10 @@ describe "pool sniffer", :integration => true do
       end
 
       it "should return the correct sniff URLs" do
-        # ie. without the master-only node
+        # ie. with the master-only node, and with the node name correctly set.
         uris = subject.check_sniff
 
-        expect(uris).to include(::LogStash::Util::SafeURI.new("//127.0.0.1:9201"), ::LogStash::Util::SafeURI.new("//127.0.0.1:9202"), ::LogStash::Util::SafeURI.new("//127.0.0.1:9203"))
+        expect(uris).to include(::LogStash::Util::SafeURI.new("//dev-masterdata:9201"), ::LogStash::Util::SafeURI.new("//dev-data:9202"))
       end
     end
   end

data/spec/integration/outputs/unsupported_actions_spec.rb

@@ -27,16 +27,21 @@ describe "Unsupported actions testing...", :integration => true do
     @es.indices.delete(:index => "*") rescue nil
     # index single doc for update purpose
     @es.index(
-      :index => INDEX,
-      :type => doc_type,
-      :id => "2",
-      :body => { :message => 'Test to doc indexing', :counter => 1 }
+      {
+        :index => INDEX,
+        :id => '2',
+        :body => { :message => 'Test to doc indexing', :counter => 1 },
+        :refresh => true
+      }
     )
+
     @es.index(
-      :index => INDEX,
-      :type => doc_type,
-      :id => "3",
-      :body => { :message => 'Test to doc deletion', :counter => 2 }
+      {
+        :index => INDEX,
+        :id => '3',
+        :body => { :message => 'Test to doc deletion', :counter => 2 },
+        :refresh => true
+      }
     )
     @es.indices.refresh
   end
@@ -63,12 +68,12 @@ describe "Unsupported actions testing...", :integration => true do
       rejected_events = events.select { |event| !index_or_update.call(event) }
 
       indexed_events.each do |event|
-        response = @es.get(:index => INDEX, :type => doc_type, :id => event.get("doc_id"), :refresh => true)
+        response = @es.get(:index => INDEX, :id => event.get("doc_id"), :refresh => true)
         expect(response['_source']['message']).to eq(event.get("message"))
       end
 
       rejected_events.each do |event|
-        expect {@es.get(:index => INDEX, :type => doc_type, :id => event.get("doc_id"), :refresh => true)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+        expect {@es.get(:index => INDEX, :id => event.get("doc_id"), :refresh => true)}.to raise_error(get_expected_error_class)
       end
     end
   end

data/spec/integration/outputs/update_spec.rb

@@ -22,10 +22,12 @@ describe "Update actions without scripts", :integration => true do
     # This can fail if there are no indexes, ignore failure.
     @es.indices.delete(:index => "*") rescue nil
     @es.index(
-      :index => 'logstash-update',
-      :type => doc_type,
-      :id => "123",
-      :body => { :message => 'Test', :counter => 1 }
+      {
+        :index => 'logstash-update',
+        :id => '123',
+        :body => { :message => 'Test', :counter => 1 },
+        :refresh => true
+      }
     )
     @es.indices.refresh
   end
@@ -40,14 +42,14 @@ describe "Update actions without scripts", :integration => true do
       subject = get_es_output({ 'document_id' => "456" } )
       subject.register
       subject.multi_receive([LogStash::Event.new("message" => "sample message here")])
-      expect {@es.get(:index => 'logstash-update', :type => doc_type, :id => "456", :refresh => true)}.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound)
+      expect {@es.get(:index => 'logstash-update', :id => '456', :refresh => true)}.to raise_error(get_expected_error_class)
     end
 
     it "should update existing document" do
       subject = get_es_output({ 'document_id' => "123" })
       subject.register
       subject.multi_receive([LogStash::Event.new("message" => "updated message here")])
-      r = @es.get(:index => 'logstash-update', :type => doc_type, :id => "123", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => '123', :refresh => true)
       expect(r["_source"]["message"]).to eq('updated message here')
     end
 
@@ -57,7 +59,7 @@ describe "Update actions without scripts", :integration => true do
       subject = get_es_output({ 'document_id' => "123" })
       subject.register
       subject.multi_receive([LogStash::Event.new("data" => "updated message here", "message" => "foo")])
-      r = @es.get(:index => 'logstash-update', :type => doc_type, :id => "123", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => '123', :refresh => true)
       expect(r["_source"]["data"]).to eq('updated message here')
       expect(r["_source"]["message"]).to eq('foo')
     end
@@ -94,7 +96,7 @@ describe "Update actions without scripts", :integration => true 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 => doc_type, :id => "456", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => '456', :refresh => true)
       expect(r["_source"]["message"]).to eq('upsert message')
     end
 
@@ -102,7 +104,7 @@ describe "Update actions without scripts", :integration => true 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 => doc_type, :id => "456", :refresh => true)
+      r = @es.get(:index => 'logstash-update', :id => '456', :refresh => true)
       expect(r["_source"]["message"]).to eq('sample message here')
     end
 

data/spec/spec_helper.rb

@@ -8,3 +8,11 @@ end
 RSpec.configure do |config|
   config.include LogStash::Outputs::ElasticSearch::SpecHelper
 end
+
+# remove once plugin starts consuming elasticsearch-ruby v8 client
+def elastic_ruby_v8_client_available?
+  Elasticsearch::Transport
+  false
+rescue NameError # NameError: uninitialized constant Elasticsearch::Transport if Elastic Ruby client is not available
+  true
+end

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

@@ -286,29 +286,6 @@ describe LogStash::Outputs::ElasticSearch::DataStreamSupport do
       end
 
     end
-
-    context 'non-compatible ES' do
-
-      let(:es_version) { '6.8.11' }
-
-      it "prints an error (from after_successful_connection thread) on LS 7.x" do
-        change_constant :LOGSTASH_VERSION, '7.12.0' do
-          expect( subject.logger ).to receive(:error).with(/Elasticsearch version does not support data streams/,
-                                                           {:es_version=>"6.8.11"})
-          stub_plugin_register!
-        end
-      end
-
-      it "prints an error (from after_successful_connection thread) on LS 8.0" do
-        change_constant :LOGSTASH_VERSION, '8.0.5' do
-          expect( subject.logger ).to receive(:error).with(/Elasticsearch version does not support data streams/,
-                                                           {:es_version=>"6.8.11"})
-          stub_plugin_register!
-        end
-      end
-
-    end
-
   end
 
   describe "auto routing" do

data/spec/unit/outputs/elasticsearch/http_client/pool_spec.rb

@@ -203,29 +203,6 @@ describe LogStash::Outputs::ElasticSearch::HttpClient::Pool do
     let(:ip_address) { "192.168.1.0"}
     let(:port) { 9200 }
 
-    context 'in Elasticsearch 1.x format' do
-      context 'with host and ip address' do
-        let(:publish_address) { "inet[#{host}/#{ip_address}:#{port}]"}
-        it 'should correctly extract the host' do
-          expect(subject.address_str_to_uri(publish_address)).to eq (LogStash::Util::SafeURI.new("#{host}:#{port}"))
-        end
-      end
-      context 'with ip address' do
-        let(:publish_address) { "inet[/#{ip_address}:#{port}]"}
-        it 'should correctly extract the ip address' do
-          expect(subject.address_str_to_uri(publish_address)).to eq (LogStash::Util::SafeURI.new("#{ip_address}:#{port}"))
-        end
-      end
-    end
-
-    context 'in Elasticsearch 2.x-6.x format' do
-      let(:publish_address) { "#{ip_address}:#{port}"}
-      it 'should correctly extract the ip address' do
-        expect(subject.address_str_to_uri(publish_address)).to eq (LogStash::Util::SafeURI.new("//#{ip_address}:#{port}"))
-      end
-    end
-
-    context 'in Elasticsearch 7.x'
     context 'with host and ip address' do
       let(:publish_address) { "#{host}/#{ip_address}:#{port}"}
       it 'should correctly extract the host' do
@@ -367,14 +344,19 @@ describe LogStash::Outputs::ElasticSearch::HttpClient::Pool do
 
     let(:root_response) { MockResponse.new(200, {"tagline" => "You Know, for Search",
                                                   "version" => {
-                                                    "number" => '0.0.0',
-                                                    "build_flavor" => 'default'}
-    }) }
-    let(:root_response2) { MockResponse.new(200, {"tagline" => "You Know, for Search",
-                                                  "version" => {
-                                                    "number" => '6.0.0',
+                                                    "number" => '7.0.0',
                                                     "build_flavor" => 'default'}
     }) }
+    let(:root_response2) { MockResponse.new(200,
+                                            {
+                                              "tagline" => "You Know, for Search",
+                                              "version" => {
+                                                "number" => '8.0.0',
+                                                "build_flavor" => 'default'
+                                              }
+                                            },
+                                            { "x-elastic-product" => "Elasticsearch" }
+    ) }
 
     context "if there are nodes with multiple major versions" do
       before(:each) do
@@ -383,7 +365,7 @@ describe LogStash::Outputs::ElasticSearch::HttpClient::Pool do
       end
 
       it "picks the largest major version" do
-        expect(subject.maximum_seen_major_version).to eq(6)
+        expect(subject.maximum_seen_major_version).to eq(8)
       end
     end
   end
@@ -542,30 +524,6 @@ describe "#elasticsearch?" do
     end
   end
 
-  context "when connecting to a cluster with version < 6.0.0" do
-    it "should fail" do
-      resp = MockResponse.new(200, {"version" => { "number" => "5.0.0" }})
-      expect(subject.send(:elasticsearch?, resp)).to be false
-    end
-  end
-
-  context "when connecting to a cluster with version in [6.0.0..7.0.0)" do
-    it "must be successful with valid 'tagline'" do
-      resp = MockResponse.new(200, {"version" => {"number" => "6.5.0"}, "tagline" => "You Know, for Search"} )
-      expect(subject.send(:elasticsearch?, resp)).to be true
-    end
-
-    it "should fail if invalid 'tagline'" do
-      resp = MockResponse.new(200, {"version" => {"number" => "6.5.0"}, "tagline" => "You don't know"} )
-      expect(subject.send(:elasticsearch?, resp)).to be false
-    end
-
-    it "should fail if 'tagline' is not present" do
-      resp = MockResponse.new(200, {"version" => {"number" => "6.5.0"}} )
-      expect(subject.send(:elasticsearch?, resp)).to be false
-    end
-  end
-
   context "when connecting to a cluster with version in [7.0.0..7.14.0)" do
     it "must be successful is 'build_flavor' is 'default' and tagline is correct" do
       resp = MockResponse.new(200, {"version": {"number": "7.5.0", "build_flavor": "default"}, "tagline": "You Know, for Search"} )