logstash-input-elasticsearch 4.18.0 → 4.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 035d372d2fbedd9c038c2ad182ea8826ce35f73dab09d7c1534dde9b019e6c82
-  data.tar.gz: 04a65a4a915231720975f25d614d44bb9b3b8f5cdde77142178b66eb6678be1c
+  metadata.gz: 5d41981efcf200ca8ec3ae620594b87054b916f4aaf9dd93b58562b9a0207a95
+  data.tar.gz: 177f0fd263be1d0a6b14f9bd298e84e6fa440868bedd79cd189eba894b67eb08
 SHA512:
-  metadata.gz: beee15cfed06fbee80b9ac7b3bd389e8fb0c5ca6f290a81cdb2f6389293bc32859c555a00483c3456854fb5e04ff6d64e23f272a17995f5677f544bd0916d966
-  data.tar.gz: 7152b896548b45f1c1dbeb973e6c10efbed2e76a0c2a9082aa0c6f1e24475a04e6b4537cff1d5d2265b1ce249fb4dddfd136cbbeb5808e870ff70434a033fb43
+  metadata.gz: 724d042883e32d4db18e8d2ebb64bade15f2e8fd4e6e804d041265ab2fb115c4453a7751690452fd672018b0600859e2991b47eb1b1e63bebf8cb8f4c828e862
+  data.tar.gz: d8b1493958dcaca358883935d432f92afe80456d8e1fdcba09ea54f20c4487b381dc338a757da55a5f3c3362492d8dd4c530737573844673272b57b09e8ab09c

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 4.19.1
+  - Plugin version bump to pick up docs fix in  [#199](https://github.com/logstash-plugins/logstash-input-elasticsearch/pull/199) required to clear build error in docgen. [#200](https://github.com/logstash-plugins/logstash-input-elasticsearch/pull/200)
+
+## 4.19.0
+  - Added `search_api` option to support `search_after` and `scroll` [#198](https://github.com/logstash-plugins/logstash-input-elasticsearch/pull/198)
+    - The default value `auto` uses `search_after` for Elasticsearch >= 8, otherwise, fall back to `scroll` 
+
 ## 4.18.0
   - Added request header `Elastic-Api-Version` for serverless [#195](https://github.com/logstash-plugins/logstash-input-elasticsearch/pull/195)
 

data/docs/index.asciidoc

@@ -118,6 +118,7 @@ This plugin supports the following configuration options plus the <<plugins-{typ
 | <<plugins-{type}s-{plugin}-request_timeout_seconds>> | <<number,number>>|No
 | <<plugins-{type}s-{plugin}-schedule>> |<<string,string>>|No
 | <<plugins-{type}s-{plugin}-scroll>> |<<string,string>>|No
+| <<plugins-{type}s-{plugin}-search_api>> |<<string,string>>, one of `["auto", "search_after", "scroll"]`|No
 | <<plugins-{type}s-{plugin}-size>> |<<number,number>>|No
 | <<plugins-{type}s-{plugin}-slices>> |<<number,number>>|No
 | <<plugins-{type}s-{plugin}-ssl_certificate>> |<<path,path>>|No
@@ -333,6 +334,9 @@ environment variables e.g. `proxy => '${LS_PROXY:}'`.
 The query to be executed. Read the {ref}/query-dsl.html[Elasticsearch query DSL
 documentation] for more information.
 
+When <<plugins-{type}s-{plugin}-search_api>> resolves to `search_after` and the query does not specify `sort`,
+the default sort `'{ "sort": { "_shard_doc": "asc" } }'` will be added to the query. Please refer to the {ref}/paginate-search-results.html#search-after[Elasticsearch search_after] parameter to know more.
+
 [id="plugins-{type}s-{plugin}-request_timeout_seconds"]
 ===== `request_timeout_seconds`
 
@@ -377,6 +381,19 @@ This parameter controls the keepalive time in seconds of the scrolling
 request and initiates the scrolling process. The timeout applies per
 round trip (i.e. between the previous scroll request, to the next).
 
+[id="plugins-{type}s-{plugin}-search_api"]
+===== `search_api`
+
+* Value can be any of: `auto`, `search_after`, `scroll`
+* Default value is `auto`
+
+With `auto` the plugin uses the `search_after` parameter for Elasticsearch version `8.0.0` or higher, otherwise the `scroll` API is used instead.
+
+`search_after` uses {ref}/point-in-time-api.html#point-in-time-api[point in time] and sort value to search.
+The query requires at least one `sort` field, as described in the <<plugins-{type}s-{plugin}-query>> parameter.
+
+`scroll` uses {ref}/paginate-search-results.html#scroll-search-results[scroll] API to search, which is no longer recommended.
+
 [id="plugins-{type}s-{plugin}-size"]
 ===== `size` 
 

data/lib/logstash/inputs/elasticsearch/paginated_search.rb

@@ -0,0 +1,231 @@
+require 'logstash/helpers/loggable_try'
+
+module LogStash
+  module Inputs
+    class Elasticsearch
+      class PaginatedSearch
+        include LogStash::Util::Loggable
+
+        def initialize(client, plugin)
+          @client = client
+          @plugin_params = plugin.params
+
+          @index = @plugin_params["index"]
+          @query = LogStash::Json.load(@plugin_params["query"])
+          @scroll = @plugin_params["scroll"]
+          @size = @plugin_params["size"]
+          @slices = @plugin_params["slices"]
+          @retries = @plugin_params["retries"]
+
+          @plugin = plugin
+          @pipeline_id = plugin.pipeline_id
+        end
+
+        def do_run(output_queue)
+          return retryable_search(output_queue) if @slices.nil? || @slices <= 1
+
+          retryable_slice_search(output_queue)
+        end
+
+        def retryable(job_name, &block)
+          stud_try = ::LogStash::Helpers::LoggableTry.new(logger, job_name)
+          stud_try.try((@retries + 1).times) { yield }
+        rescue => e
+          error_details = {:message => e.message, :cause => e.cause}
+          error_details[:backtrace] = e.backtrace if logger.debug?
+          logger.error("Tried #{job_name} unsuccessfully", error_details)
+        end
+
+        def retryable_search(output_queue)
+          raise NotImplementedError
+        end
+
+        def retryable_slice_search(output_queue)
+          raise NotImplementedError
+        end
+      end
+
+      class Scroll < PaginatedSearch
+        SCROLL_JOB = "scroll paginated search"
+
+        def search_options(slice_id)
+          query = @query
+          query = @query.merge('slice' => { 'id' => slice_id, 'max' => @slices}) unless slice_id.nil?
+          {
+            :index => @index,
+            :scroll => @scroll,
+            :size => @size,
+            :body => LogStash::Json.dump(query)
+          }
+        end
+
+        def initial_search(slice_id)
+          options = search_options(slice_id)
+          @client.search(options)
+        end
+
+        def next_page(scroll_id)
+          @client.scroll(:body => { :scroll_id => scroll_id }, :scroll => @scroll)
+        end
+
+        def process_page(output_queue)
+          r = yield
+          r['hits']['hits'].each { |hit| @plugin.push_hit(hit, output_queue) }
+          [r['hits']['hits'].any?, r['_scroll_id']]
+        end
+
+        def search(output_queue, slice_id=nil)
+          log_details = {}
+          log_details = log_details.merge({ slice_id: slice_id, slices: @slices }) unless slice_id.nil?
+
+          logger.info("Query start", log_details)
+          has_hits, scroll_id = process_page(output_queue) { initial_search(slice_id) }
+
+          while has_hits && scroll_id && !@plugin.stop?
+            logger.debug("Query progress", log_details)
+            has_hits, scroll_id = process_page(output_queue) { next_page(scroll_id) }
+          end
+
+          logger.info("Query completed", log_details)
+        ensure
+          clear(scroll_id)
+        end
+
+        def retryable_search(output_queue, slice_id=nil)
+          retryable(SCROLL_JOB) do
+            search(output_queue, slice_id)
+          end
+        end
+
+        def retryable_slice_search(output_queue)
+          logger.warn("managed slices for query is very large (#{@slices}); consider reducing") if @slices > 8
+
+          @slices.times.map do |slice_id|
+            Thread.new do
+              LogStash::Util::set_thread_name("[#{@pipeline_id}]|input|elasticsearch|slice_#{slice_id}")
+              retryable_search(output_queue, slice_id)
+            end
+          end.map(&:join)
+
+          logger.trace("#{@slices} slices completed")
+        end
+
+        def clear(scroll_id)
+          @client.clear_scroll(:body => { :scroll_id => scroll_id }) if scroll_id
+        rescue => e
+          # ignore & log any clear_scroll errors
+          logger.debug("Ignoring clear_scroll exception", message: e.message, exception: e.class)
+        end
+      end
+
+      class SearchAfter < PaginatedSearch
+        PIT_JOB = "create point in time (PIT)"
+        SEARCH_AFTER_JOB = "search_after paginated search"
+
+        def pit?(id)
+          !!id&.is_a?(String)
+        end
+
+        def create_pit
+          logger.info("Create point in time (PIT)")
+          r = @client.open_point_in_time(index: @index, keep_alive: @scroll)
+          r['id']
+        end
+
+        def search_options(pit_id: , search_after: nil, slice_id: nil)
+          body = @query.merge({
+                                :pit => {
+                                  :id => pit_id,
+                                  :keep_alive => @scroll
+                                }
+                              })
+
+          # search_after requires at least a sort field explicitly
+          # we add default sort "_shard_doc": "asc" if the query doesn't have any sort field
+          # by default, ES adds the same implicitly on top of the provided "sort"
+          # https://www.elastic.co/guide/en/elasticsearch/reference/8.10/paginate-search-results.html#CO201-2
+          body = body.merge(:sort => {"_shard_doc": "asc"}) if @query&.dig("sort").nil?
+
+          body = body.merge(:search_after => search_after) unless search_after.nil?
+          body = body.merge(:slice => {:id => slice_id, :max => @slices}) unless slice_id.nil?
+          {
+            :size => @size,
+            :body => body
+          }
+        end
+
+        def next_page(pit_id: , search_after: nil, slice_id: nil)
+          options = search_options(pit_id: pit_id, search_after: search_after, slice_id: slice_id)
+          logger.trace("search options", options)
+          @client.search(options)
+        end
+
+        def process_page(output_queue)
+          r = yield
+          r['hits']['hits'].each { |hit| @plugin.push_hit(hit, output_queue) }
+
+          has_hits = r['hits']['hits'].any?
+          search_after = r['hits']['hits'][-1]['sort'] rescue nil
+          logger.warn("Query got data but the sort value is empty") if has_hits && search_after.nil?
+          [ has_hits, search_after ]
+        end
+
+        def with_pit
+          pit_id = retryable(PIT_JOB) { create_pit }
+          yield pit_id if pit?(pit_id)
+        ensure
+          clear(pit_id)
+        end
+
+        def search(output_queue:, slice_id: nil, pit_id:)
+          log_details = {}
+          log_details = log_details.merge({ slice_id: slice_id, slices: @slices }) unless slice_id.nil?
+          logger.info("Query start", log_details)
+
+          has_hits = true
+          search_after = nil
+
+          while has_hits && !@plugin.stop?
+            logger.debug("Query progress", log_details)
+            has_hits, search_after = process_page(output_queue) do
+              next_page(pit_id: pit_id, search_after: search_after, slice_id: slice_id)
+            end
+          end
+
+          logger.info("Query completed", log_details)
+        end
+
+        def retryable_search(output_queue)
+          with_pit do |pit_id|
+            retryable(SEARCH_AFTER_JOB) do
+              search(output_queue: output_queue, pit_id: pit_id)
+            end
+          end
+        end
+
+        def retryable_slice_search(output_queue)
+          with_pit do |pit_id|
+            @slices.times.map do |slice_id|
+              Thread.new do
+                LogStash::Util::set_thread_name("[#{@pipeline_id}]|input|elasticsearch|slice_#{slice_id}")
+                retryable(SEARCH_AFTER_JOB) do
+                  search(output_queue: output_queue, slice_id: slice_id, pit_id: pit_id)
+                end
+              end
+            end.map(&:join)
+          end
+
+          logger.trace("#{@slices} slices completed")
+        end
+
+        def clear(pit_id)
+          logger.info("Closing point in time (PIT)")
+          @client.close_point_in_time(:body => {:id => pit_id} ) if pit?(pit_id)
+        rescue => e
+          logger.debug("Ignoring close_point_in_time exception", message: e.message, exception: e.class)
+        end
+      end
+
+    end
+  end
+end

data/lib/logstash/inputs/elasticsearch.rb

@@ -11,7 +11,6 @@ require 'logstash/plugin_mixins/ca_trusted_fingerprint_support'
 require "logstash/plugin_mixins/scheduler"
 require "logstash/plugin_mixins/normalize_config_support"
 require "base64"
-require 'logstash/helpers/loggable_try'
 
 require "elasticsearch"
 require "elasticsearch/transport/transport/http/manticore"
@@ -74,6 +73,8 @@ require_relative "elasticsearch/patches/_elasticsearch_transport_connections_sel
 #
 class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
 
+  require 'logstash/inputs/elasticsearch/paginated_search'
+
   include LogStash::PluginMixins::ECSCompatibilitySupport(:disabled, :v1, :v8 => :v1)
   include LogStash::PluginMixins::ECSCompatibilitySupport::TargetCheck
 
@@ -106,6 +107,10 @@ class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
   # The number of retries to run the query. If the query fails after all retries, it logs an error message.
   config :retries, :validate => :number, :default => 0
 
+  # Default `auto` will use `search_after` api for Elasticsearch 8 and use `scroll` api for 7
+  # Set to scroll to fallback to previous version
+  config :search_api, :validate => %w[auto search_after scroll], :default => "auto"
+
   # This parameter controls the keepalive time in seconds of the scrolling
   # request and initiates the scrolling process. The timeout applies per
   # round trip (i.e. between the previous scroll request, to the next).
@@ -321,93 +326,21 @@ class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
 
     setup_serverless
 
+    setup_search_api
+
     @client
   end
 
 
   def run(output_queue)
     if @schedule
-      scheduler.cron(@schedule) { do_run(output_queue) }
+      scheduler.cron(@schedule) { @paginated_search.do_run(output_queue) }
       scheduler.join
     else
-      do_run(output_queue)
-    end
-  end
-
-  private
-  JOB_NAME = "run query"
-  def do_run(output_queue)
-    # if configured to run a single slice, don't bother spinning up threads
-    if @slices.nil? || @slices <= 1
-      return retryable(JOB_NAME) do
-        do_run_slice(output_queue)
-      end
-    end
-
-    logger.warn("managed slices for query is very large (#{@slices}); consider reducing") if @slices > 8
-
-
-    @slices.times.map do |slice_id|
-      Thread.new do
-        LogStash::Util::set_thread_name("[#{pipeline_id}]|input|elasticsearch|slice_#{slice_id}")
-        retryable(JOB_NAME) do
-          do_run_slice(output_queue, slice_id)
-        end
-      end
-    end.map(&:join)
-
-    logger.trace("#{@slices} slices completed")
-  end
-
-  def retryable(job_name, &block)
-    begin
-      stud_try = ::LogStash::Helpers::LoggableTry.new(logger, job_name)
-      stud_try.try((@retries + 1).times) { yield }
-    rescue => e
-      error_details = {:message => e.message, :cause => e.cause}
-      error_details[:backtrace] = e.backtrace if logger.debug?
-      logger.error("Tried #{job_name} unsuccessfully", error_details)
+      @paginated_search.do_run(output_queue)
     end
   end
 
-  def do_run_slice(output_queue, slice_id=nil)
-    slice_query = @base_query
-    slice_query = slice_query.merge('slice' => { 'id' => slice_id, 'max' => @slices}) unless slice_id.nil?
-
-    slice_options = @options.merge(:body => LogStash::Json.dump(slice_query) )
-
-    logger.info("Slice starting", slice_id: slice_id, slices: @slices) unless slice_id.nil?
-
-    begin
-      r = search_request(slice_options)
-
-      r['hits']['hits'].each { |hit| push_hit(hit, output_queue) }
-      logger.debug("Slice progress", slice_id: slice_id, slices: @slices) unless slice_id.nil?
-
-      has_hits = r['hits']['hits'].any?
-      scroll_id = r['_scroll_id']
-
-      while has_hits && scroll_id && !stop?
-        has_hits, scroll_id = process_next_scroll(output_queue, scroll_id)
-        logger.debug("Slice progress", slice_id: slice_id, slices: @slices) if logger.debug? && slice_id
-      end
-      logger.info("Slice complete", slice_id: slice_id, slices: @slices) unless slice_id.nil?
-    ensure
-      clear_scroll(scroll_id)
-    end
-  end
-
-  ##
-  # @param output_queue [#<<]
-  # @param scroll_id [String]: a scroll id to resume
-  # @return [Array(Boolean,String)]: a tuple representing whether the response
-  #
-  def process_next_scroll(output_queue, scroll_id)
-    r = scroll_request(scroll_id)
-    r['hits']['hits'].each { |hit| push_hit(hit, output_queue) }
-    [r['hits']['hits'].any?, r['_scroll_id']]
-  end
-
   def push_hit(hit, output_queue)
     event = targeted_event_factory.new_event hit['_source']
     set_docinfo_fields(hit, event) if @docinfo
@@ -433,20 +366,7 @@ class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
     event.set(@docinfo_target, docinfo_target)
   end
 
-  def clear_scroll(scroll_id)
-    @client.clear_scroll(:body => { :scroll_id => scroll_id }) if scroll_id
-  rescue => e
-    # ignore & log any clear_scroll errors
-    logger.warn("Ignoring clear_scroll exception", message: e.message, exception: e.class)
-  end
-
-  def scroll_request(scroll_id)
-    @client.scroll(:body => { :scroll_id => scroll_id }, :scroll => @scroll)
-  end
-
-  def search_request(options={})
-    @client.search(options)
-  end
+  private
 
   def hosts_default?(hosts)
     hosts.nil? || ( hosts.is_a?(Array) && hosts.empty? )
@@ -677,6 +597,18 @@ class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
     raise LogStash::ConfigurationError, "Could not connect to a compatible version of Elasticsearch"
   end
 
+  def es_info
+    @es_info ||= @client.info
+  end
+
+  def es_version
+    @es_version ||= es_info&.dig('version', 'number')
+  end
+
+  def es_major_version
+    @es_major_version ||= es_version.split('.').first.to_i
+  end
+
   # recreate client with default header when it is serverless
   # verify the header by sending GET /
   def setup_serverless
@@ -691,13 +623,35 @@ class LogStash::Inputs::Elasticsearch < LogStash::Inputs::Base
   end
 
   def build_flavor
-    @build_flavor ||= @client.info&.dig('version', 'build_flavor')
+    @build_flavor ||= es_info&.dig('version', 'build_flavor')
   end
 
   def serverless?
     @is_serverless ||= (build_flavor == BUILD_FLAVOR_SERVERLESS)
   end
 
+  def setup_search_api
+    @resolved_search_api = if @search_api == "auto"
+                             api = if es_major_version >= 8
+                                    "search_after"
+                                   else
+                                     "scroll"
+                                   end
+                             logger.info("`search_api => auto` resolved to `#{api}`", :elasticsearch => es_version)
+                             api
+                           else
+                             @search_api
+                           end
+
+
+    @paginated_search = if @resolved_search_api == "search_after"
+                          LogStash::Inputs::Elasticsearch::SearchAfter.new(@client, self)
+                        else
+                          logger.warn("scroll API is no longer recommended for pagination. Consider using search_after instead.") if es_major_version >= 8
+                          LogStash::Inputs::Elasticsearch::Scroll.new(@client, self)
+                        end
+  end
+
   module URIOrEmptyValidator
     ##
     # @override to provide :uri_or_empty validator

data/logstash-input-elasticsearch.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-input-elasticsearch'
-  s.version         = '4.18.0'
+  s.version         = '4.19.1'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Reads query results from an Elasticsearch cluster"
   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/inputs/elasticsearch_spec.rb

@@ -18,7 +18,8 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
   let(:plugin) { described_class.new(config) }
   let(:queue) { Queue.new }
   let(:build_flavor) { "default" }
-  let(:cluster_info) { {"version" => {"number" => "7.5.0", "build_flavor" => build_flavor}, "tagline" => "You Know, for Search"} }
+  let(:es_version) { "7.5.0" }
+  let(:cluster_info) { {"version" => {"number" => es_version, "build_flavor" => build_flavor}, "tagline" => "You Know, for Search"} }
 
   before(:each) do
     Elasticsearch::Client.send(:define_method, :ping) { } # define no-action ping method
@@ -102,6 +103,26 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
         expect { plugin.register }.to raise_error(LogStash::ConfigurationError)
       end
     end
+
+    context "search_api" do
+      before(:each) do
+        plugin.register
+      end
+
+      context "ES 8" do
+        let(:es_version) { "8.10.0" }
+        it "resolves `auto` to `search_after`" do
+          expect(plugin.instance_variable_get(:@paginated_search)).to be_a LogStash::Inputs::Elasticsearch::SearchAfter
+        end
+      end
+
+      context "ES 7" do
+        let(:es_version) { "7.17.0" }
+        it "resolves `auto` to `scroll`" do
+          expect(plugin.instance_variable_get(:@paginated_search)).to be_a LogStash::Inputs::Elasticsearch::Scroll
+        end
+      end
+    end
   end
 
   it_behaves_like "an interruptible input plugin" do
@@ -244,22 +265,24 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
 
     context 'with `slices => 1`' do
       let(:slices) { 1 }
+      before { plugin.register }
+
       it 'runs just one slice' do
-        expect(plugin).to receive(:do_run_slice).with(duck_type(:<<))
+        expect(plugin.instance_variable_get(:@paginated_search)).to receive(:search).with(duck_type(:<<), nil)
         expect(Thread).to_not receive(:new)
 
-        plugin.register
         plugin.run([])
       end
     end
 
     context 'without slices directive' do
       let(:config) { super().tap { |h| h.delete('slices') } }
+      before { plugin.register }
+
       it 'runs just one slice' do
-        expect(plugin).to receive(:do_run_slice).with(duck_type(:<<))
+        expect(plugin.instance_variable_get(:@paginated_search)).to receive(:search).with(duck_type(:<<), nil)
         expect(Thread).to_not receive(:new)
 
-        plugin.register
         plugin.run([])
       end
     end
@@ -267,13 +290,14 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
     2.upto(8) do |slice_count|
       context "with `slices => #{slice_count}`" do
         let(:slices) { slice_count }
+        before { plugin.register }
+
         it "runs #{slice_count} independent slices" do
           expect(Thread).to receive(:new).and_call_original.exactly(slice_count).times
           slice_count.times do |slice_id|
-            expect(plugin).to receive(:do_run_slice).with(duck_type(:<<), slice_id)
+            expect(plugin.instance_variable_get(:@paginated_search)).to receive(:search).with(duck_type(:<<), slice_id)
           end
 
-          plugin.register
           plugin.run([])
         end
       end
@@ -399,8 +423,8 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
           expect(client).to receive(:search).with(hash_including(:body => slice1_query)).and_return(slice1_response0)
           expect(client).to receive(:scroll).with(hash_including(:body => { :scroll_id => slice1_scroll1 })).and_return(slice1_response1)
 
-          synchronize_method!(plugin, :scroll_request)
-          synchronize_method!(plugin, :search_request)
+          synchronize_method!(plugin.instance_variable_get(:@paginated_search), :next_page)
+          synchronize_method!(plugin.instance_variable_get(:@paginated_search), :initial_search)
         end
 
         let(:client) { Elasticsearch::Client.new }
@@ -469,14 +493,14 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
           expect(client).to receive(:search).with(hash_including(:body => slice1_query)).and_return(slice1_response0)
           expect(client).to receive(:scroll).with(hash_including(:body => { :scroll_id => slice1_scroll1 })).and_raise("boom")
 
-          synchronize_method!(plugin, :scroll_request)
-          synchronize_method!(plugin, :search_request)
+          synchronize_method!(plugin.instance_variable_get(:@paginated_search), :next_page)
+          synchronize_method!(plugin.instance_variable_get(:@paginated_search), :initial_search)
         end
 
         let(:client) { Elasticsearch::Client.new }
 
         it 'insert event to queue without waiting other slices' do
-          expect(plugin).to receive(:do_run_slice).twice.and_wrap_original do |m, *args|
+          expect(plugin.instance_variable_get(:@paginated_search)).to receive(:search).twice.and_wrap_original do |m, *args|
             q = args[0]
             slice_id = args[1]
             if slice_id == 0
@@ -996,7 +1020,7 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
 
     it "should properly schedule" do
       begin
-        expect(plugin).to receive(:do_run) {
+        expect(plugin.instance_variable_get(:@paginated_search)).to receive(:do_run) {
           queue << LogStash::Event.new({})
         }.at_least(:twice)
         runner = Thread.start { plugin.run(queue) }
@@ -1013,46 +1037,7 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
   end
 
   context "retries" do
-    let(:mock_response) do
-      {
-        "_scroll_id" => "cXVlcnlUaGVuRmV0Y2g",
-        "took" => 27,
-        "timed_out" => false,
-        "_shards" => {
-          "total" => 169,
-          "successful" => 169,
-          "failed" => 0
-        },
-        "hits" => {
-          "total" => 1,
-          "max_score" => 1.0,
-          "hits" => [ {
-                        "_index" => "logstash-2014.10.12",
-                        "_type" => "logs",
-                        "_id" => "C5b2xLQwTZa76jBmHIbwHQ",
-                        "_score" => 1.0,
-                        "_source" => { "message" => ["ohayo"] }
-                      } ]
-        }
-      }
-    end
-
-    let(:mock_scroll_response) do
-      {
-        "_scroll_id" => "r453Wc1jh0caLJhSDg",
-        "hits" => { "hits" => [] }
-      }
-    end
-
-    before(:each) do
-      client = Elasticsearch::Client.new
-      allow(Elasticsearch::Client).to receive(:new).with(any_args).and_return(client)
-      allow(client).to receive(:search).with(any_args).and_return(mock_response)
-      allow(client).to receive(:scroll).with({ :body => { :scroll_id => "cXVlcnlUaGVuRmV0Y2g" }, :scroll=> "1m" }).and_return(mock_scroll_response)
-      allow(client).to receive(:clear_scroll).and_return(nil)
-      allow(client).to receive(:ping)
-    end
-
+    let(:client) { Elasticsearch::Client.new }
     let(:config) do
       {
         "hosts" => ["localhost"],
@@ -1061,29 +1046,98 @@ describe LogStash::Inputs::Elasticsearch, :ecs_compatibility_support do
       }
     end
 
-    it "retry and log error when all search request fail" do
-      expect(plugin.logger).to receive(:error).with(/Tried .* unsuccessfully/,
-                                                    hash_including(:message => 'Manticore::UnknownException'))
-      expect(plugin.logger).to receive(:warn).twice.with(/Attempt to .* but failed/,
-                                                         hash_including(:exception => "Manticore::UnknownException"))
-      expect(plugin).to receive(:search_request).with(instance_of(Hash)).and_raise(Manticore::UnknownException).at_least(:twice)
+    shared_examples "a retryable plugin" do
+      it "retry and log error when all search request fail" do
+        expect_any_instance_of(LogStash::Helpers::LoggableTry).to receive(:log_failure).with(instance_of(Manticore::UnknownException), instance_of(Integer), instance_of(String)).twice
+        expect(client).to receive(:search).with(instance_of(Hash)).and_raise(Manticore::UnknownException).at_least(:twice)
 
-      plugin.register
+        plugin.register
+
+        expect{ plugin.run(queue) }.not_to raise_error
+      end
+
+      it "retry successfully when search request fail for one time" do
+        expect_any_instance_of(LogStash::Helpers::LoggableTry).to receive(:log_failure).with(instance_of(Manticore::UnknownException), 1, instance_of(String))
+        expect(client).to receive(:search).with(instance_of(Hash)).once.and_raise(Manticore::UnknownException)
+        expect(client).to receive(:search).with(instance_of(Hash)).once.and_return(search_response)
 
-      expect{ plugin.run(queue) }.not_to raise_error
-      expect(queue.size).to eq(0)
+        plugin.register
+
+        expect{ plugin.run(queue) }.not_to raise_error
+      end
     end
 
-    it "retry successfully when search request fail for one time" do
-      expect(plugin.logger).to receive(:warn).once.with(/Attempt to .* but failed/,
-                                                         hash_including(:exception => "Manticore::UnknownException"))
-      expect(plugin).to receive(:search_request).with(instance_of(Hash)).once.and_raise(Manticore::UnknownException)
-      expect(plugin).to receive(:search_request).with(instance_of(Hash)).once.and_call_original
+    describe "scroll" do
+      let(:search_response) do
+        {
+          "_scroll_id" => "cXVlcnlUaGVuRmV0Y2g",
+          "took" => 27,
+          "timed_out" => false,
+          "_shards" => {
+            "total" => 169,
+            "successful" => 169,
+            "failed" => 0
+          },
+          "hits" => {
+            "total" => 1,
+            "max_score" => 1.0,
+            "hits" => [ {
+                          "_index" => "logstash-2014.10.12",
+                          "_type" => "logs",
+                          "_id" => "C5b2xLQwTZa76jBmHIbwHQ",
+                          "_score" => 1.0,
+                          "_source" => { "message" => ["ohayo"] }
+                        } ]
+          }
+        }
+      end
 
-      plugin.register
+      let(:empty_scroll_response) do
+        {
+          "_scroll_id" => "r453Wc1jh0caLJhSDg",
+          "hits" => { "hits" => [] }
+        }
+      end
+
+      before(:each) do
+        allow(Elasticsearch::Client).to receive(:new).with(any_args).and_return(client)
+        allow(client).to receive(:scroll).with({ :body => { :scroll_id => "cXVlcnlUaGVuRmV0Y2g" }, :scroll=> "1m" }).and_return(empty_scroll_response)
+        allow(client).to receive(:clear_scroll).and_return(nil)
+        allow(client).to receive(:ping)
+      end
+
+      it_behaves_like "a retryable plugin"
+    end
+
+    describe "search_after" do
+      let(:es_version) { "8.10.0" }
+      let(:config) { super().merge({ "search_api" => "search_after" }) }
+
+      let(:search_response) do
+        {
+          "took" => 27,
+          "timed_out" => false,
+          "_shards" => {
+            "total" => 169,
+            "successful" => 169,
+            "failed" => 0
+          },
+          "hits" => {
+            "total" => 1,
+            "max_score" => 1.0,
+            "hits" => [ ] # empty hits to break the loop
+          }
+        }
+      end
+
+      before(:each) do
+        expect(Elasticsearch::Client).to receive(:new).with(any_args).and_return(client)
+        expect(client).to receive(:open_point_in_time).once.and_return({ "id" => "cXVlcnlUaGVuRmV0Y2g"})
+        expect(client).to receive(:close_point_in_time).once.and_return(nil)
+        expect(client).to receive(:ping)
+      end
 
-      expect{ plugin.run(queue) }.not_to raise_error
-      expect(queue.size).to eq(1)
+      it_behaves_like "a retryable plugin"
     end
   end
 

data/spec/inputs/integration/elasticsearch_spec.rb

@@ -20,10 +20,7 @@ describe LogStash::Inputs::Elasticsearch, :integration => true do
   let(:password) { ENV['ELASTIC_PASSWORD'] || 'abc123' }
   let(:ca_file) { "spec/fixtures/test_certs/ca.crt" }
 
-  let(:es_url) do
-    es_url = ESHelper.get_host_port
-    SECURE_INTEGRATION ? "https://#{es_url}" : "http://#{es_url}"
-  end
+  let(:es_url) { "http#{SECURE_INTEGRATION ? 's' : nil}://#{ESHelper.get_host_port}" }
 
   let(:curl_args) do
     config['user'] ? "-u #{config['user']}:#{config['password']}" : ''
@@ -46,6 +43,8 @@ describe LogStash::Inputs::Elasticsearch, :integration => true do
     ESHelper.curl_and_get_json_response "#{es_url}/_index_template/*", method: 'DELETE', args: curl_args
     # This can fail if there are no indexes, ignore failure.
     ESHelper.curl_and_get_json_response( "#{es_url}/_index/*", method: 'DELETE', args: curl_args) rescue nil
+    ESHelper.curl_and_get_json_response( "#{es_url}/logs", method: 'DELETE', args: curl_args) rescue nil
+    ESHelper.curl_and_get_json_response "#{es_url}/_refresh", method: 'POST', args: curl_args
   end
 
   shared_examples 'an elasticsearch index plugin' do
@@ -56,6 +55,7 @@ describe LogStash::Inputs::Elasticsearch, :integration => true do
     it 'should retrieve json event from elasticsearch' do
       queue = []
       plugin.run(queue)
+      expect(queue.size).to eq(10)
       event = queue.pop
       expect(event).to be_a(LogStash::Event)
       expect(event.get("response")).to eql(404)
@@ -63,10 +63,6 @@ describe LogStash::Inputs::Elasticsearch, :integration => true do
   end
 
   describe 'against an unsecured elasticsearch', integration: true do
-    before(:each) do
-      plugin.register
-    end
-
     it_behaves_like 'an elasticsearch index plugin'
   end
 
@@ -136,4 +132,10 @@ describe LogStash::Inputs::Elasticsearch, :integration => true do
 
   end
 
+  describe 'slice', integration: true do
+    let(:config) { super().merge('slices' => 2, 'size' => 2) }
+    let(:plugin) { described_class.new(config) }
+
+    it_behaves_like 'an elasticsearch index plugin'
+  end
 end

data/spec/inputs/paginated_search_spec.rb

@@ -0,0 +1,129 @@
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/inputs/elasticsearch/paginated_search"
+
+describe "Paginated search" do
+  let(:es_client) { double("Elasticsearch::Client") }
+  let(:settings) { { "index" => "logs", "query" => "{ \"sort\": [ \"_doc\" ] }", "scroll" => "1m", "retries" => 0, "size" => 1000 } }
+  let(:plugin) { double("LogStash::Inputs::Elasticsearch", params: settings, pipeline_id: "main", stop?: false) }
+  let(:pit_id) { "08fsAwILcmVzaGFyZC0yZmIWdzFnbl" }
+
+  describe "search after" do
+    subject do
+      LogStash::Inputs::Elasticsearch::SearchAfter.new(es_client, plugin)
+    end
+
+    describe "search options" do
+      context "query without sort" do
+        let(:settings) { super().merge({"query" => "{\"match_all\": {} }"}) }
+
+        it "adds default sort" do
+          options = subject.search_options(pit_id: pit_id)
+          expect(options[:body][:sort]).to match({"_shard_doc": "asc"})
+        end
+      end
+
+      context "customize settings" do
+        let(:size) { 2 }
+        let(:slices) { 4 }
+        let(:settings) { super().merge({"slices" => slices, "size" => size}) }
+
+        it "gives updated options" do
+          slice_id = 1
+          search_after = [0, 0]
+          options = subject.search_options(pit_id: pit_id, slice_id: slice_id, search_after: search_after)
+          expect(options[:size]).to match(size)
+          expect(options[:body][:slice]).to match({:id => slice_id, :max => slices})
+          expect(options[:body][:search_after]).to match(search_after)
+        end
+      end
+    end
+
+    describe "search" do
+      let(:queue) { double("queue") }
+      let(:doc1) do
+        {
+          "_index" => "logstash",
+          "_type" => "logs",
+          "_id" => "C5b2xLQwTZa76jBmHIbwHQ",
+          "_score" => 1.0,
+          "_source" => { "message" => ["Halloween"] },
+          "sort" => [0, 0]
+        }
+      end
+      let(:first_resp) do
+        {
+          "pit_id" => pit_id,
+          "took" => 27,
+          "timed_out" => false,
+          "_shards" => {
+            "total" => 2,
+            "successful" => 2,
+            "skipped" => 0,
+            "failed" => 0
+          },
+          "hits" => {
+            "total" => {
+              "value" => 500,
+              "relation" => "eq"
+            },
+            "hits" => [ doc1 ]
+          }
+        }
+      end
+      let(:last_resp) do
+        {
+          "pit_id" => pit_id,
+          "took" => 27,
+          "timed_out" => false,
+          "_shards" => {
+            "total" => 2,
+            "successful" => 2,
+            "skipped" => 0,
+            "failed" => 0
+          },
+          "hits" => {
+            "total" => {
+              "value" => 500,
+              "relation" => "eq"
+            },
+            "hits" => [ ] # empty hits to break the loop
+          }
+        }
+      end
+
+      context "happy case" do
+        it "runs" do
+          expect(es_client).to receive(:search).with(instance_of(Hash)).and_return(first_resp, last_resp)
+          expect(plugin).to receive(:push_hit).with(doc1, queue).once
+          subject.search(output_queue: queue, pit_id: pit_id)
+        end
+      end
+
+      context "with exception" do
+        it "closes pit" do
+          expect(es_client).to receive(:open_point_in_time).once.and_return({ "id" => pit_id})
+          expect(plugin).to receive(:push_hit).with(doc1, queue).once
+          expect(es_client).to receive(:search).with(instance_of(Hash)).once.and_return(first_resp)
+          expect(es_client).to receive(:search).with(instance_of(Hash)).once.and_raise(Manticore::UnknownException)
+          expect(es_client).to receive(:close_point_in_time).with(any_args).once.and_return(nil)
+          subject.retryable_search(queue)
+        end
+      end
+
+      context "with slices" do
+        let(:slices) { 2 }
+        let(:settings) { super().merge({"slices" => slices}) }
+
+        it "runs two slices" do
+          expect(es_client).to receive(:open_point_in_time).once.and_return({ "id" => pit_id})
+          expect(plugin).to receive(:push_hit).with(any_args).twice
+          expect(Thread).to receive(:new).and_call_original.exactly(slices).times
+          expect(es_client).to receive(:search).with(instance_of(Hash)).and_return(first_resp, last_resp, first_resp, last_resp)
+          expect(es_client).to receive(:close_point_in_time).with(any_args).once.and_return(nil)
+          subject.retryable_slice_search(queue)
+        end
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-elasticsearch
 version: !ruby/object:Gem::Version
-  version: 4.18.0
+  version: 4.19.1
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-29 00:00:00.000000000 Z
+date: 2023-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -271,6 +271,7 @@ files:
 - docs/index.asciidoc
 - lib/logstash/helpers/loggable_try.rb
 - lib/logstash/inputs/elasticsearch.rb
+- lib/logstash/inputs/elasticsearch/paginated_search.rb
 - lib/logstash/inputs/elasticsearch/patches/_elasticsearch_transport_connections_selector.rb
 - lib/logstash/inputs/elasticsearch/patches/_elasticsearch_transport_http_manticore.rb
 - logstash-input-elasticsearch.gemspec
@@ -283,6 +284,7 @@ files:
 - spec/inputs/elasticsearch_spec.rb
 - spec/inputs/elasticsearch_ssl_spec.rb
 - spec/inputs/integration/elasticsearch_spec.rb
+- spec/inputs/paginated_search_spec.rb
 homepage: http://www.elastic.co/guide/en/logstash/current/index.html
 licenses:
 - Apache License (2.0)
@@ -318,3 +320,4 @@ test_files:
 - spec/inputs/elasticsearch_spec.rb
 - spec/inputs/elasticsearch_ssl_spec.rb
 - spec/inputs/integration/elasticsearch_spec.rb
+- spec/inputs/paginated_search_spec.rb