logstash-output-elasticsearch 10.7.3-java → 10.8.0-java

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

@@ -286,6 +286,7 @@ module LogStash; module Outputs; class ElasticSearch;
       adapter = build_adapter(options)
 
       pool_options = {
+        :license_checker => options[:license_checker],
         :sniffing => sniffing,
         :sniffer_delay => options[:sniffer_delay],
         :sniffing_path => options[:sniffing_path],

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

@@ -1,3 +1,5 @@
+require "logstash/plugin_mixins/elasticsearch/noop_license_checker"
+
 module LogStash; module Outputs; class ElasticSearch; class HttpClient;
   class Pool
     class NoConnectionAvailableError < Error; end
@@ -29,6 +31,7 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
     end
 
     attr_reader :logger, :adapter, :sniffing, :sniffer_delay, :resurrect_delay, :healthcheck_path, :sniffing_path, :bulk_path
+    attr_reader :license_checker # license_checker is used by the pool specs
 
     ROOT_URI_PATH = '/'.freeze
     LICENSE_PATH = '/_license'.freeze
@@ -66,12 +69,10 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       # Holds metadata about all URLs
       @url_info = {}
       @stopping = false
-    end
 
-    def oss?
-     LogStash::Outputs::ElasticSearch.oss?
+      @license_checker = options.fetch(:license_checker) { LogStash::PluginMixins::ElasticSearch::NoopLicenseChecker::INSTANCE }
     end
-    
+
     def start
       update_initial_urls
       start_resurrectionist
@@ -210,7 +211,6 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       end
     end
 
-
     def sniff_2x_1x(nodes)
       nodes.map do |id,info|
         # TODO Make sure this works with shield. Does that listed
@@ -245,16 +245,15 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       end
     end
 
+    # Retrieve ES node license information
+    # @param url [LogStash::Util::SafeURI] ES node URL
+    # @return [Hash] deserialized license document or empty Hash upon any error
     def get_license(url)
       response = perform_request_to_url(url, :get, LICENSE_PATH)
       LogStash::Json.load(response.body)
-    end
-
-    def valid_es_license?(url)
-      license = get_license(url)
-      license.fetch("license", {}).fetch("status", nil) == "active"
     rescue => e
-      false
+      logger.error("Unable to get license information", url: url.sanitized.to_s, error_type: e.class, error: e.message)
+      {}
     end
 
     def health_check_request(url)
@@ -282,19 +281,9 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
               @logger.warn("Detected a node with a higher major version than previously observed. This could be the result of an elasticsearch cluster upgrade.", :previous_major => @maximum_seen_major_version, :new_major => major, :node_url => url.sanitized.to_s)
               set_new_major_version(major)
             end
-            if oss? || valid_es_license?(url)
-              meta[:state] = :alive
-            else
-              # As this version is to be shipped with Logstash 7.x we won't mark the connection as unlicensed
-              #
-              #  logger.error("Cannot connect to the Elasticsearch cluster configured in the Elasticsearch output. Logstash requires the default distribution of Elasticsearch. Please update to the default distribution of Elasticsearch for full access to all free features, or switch to the OSS distribution of Logstash.", :url => url.sanitized.to_s)
-              #  meta[:state] = :unlicensed
-              #
-              # Instead we'll log a deprecation warning and mark it as alive:
-              #
-              log_license_deprecation_warn(url)
-              meta[:state] = :alive
-            end
+
+            alive = @license_checker.appropriate_license?(self, url)
+            meta[:state] = alive ? :alive : :dead
           end
         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)
@@ -306,10 +295,6 @@ module LogStash; module Outputs; class ElasticSearch; class HttpClient;
       @resurrectionist.join if @resurrectionist
     end
 
-    def log_license_deprecation_warn(url)
-      logger.warn("DEPRECATION WARNING: Connecting to an OSS distribution of Elasticsearch using the default distribution of Logstash will stop working in Logstash 8.0.0. Please upgrade to the default distribution of Elasticsearch, or use the OSS distribution of Logstash", :url => url.sanitized.to_s)
-    end
-
     def resurrectionist_alive?
       @resurrectionist ? @resurrectionist.alive? : nil
     end

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

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

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

@@ -5,10 +5,10 @@ module LogStash; module Outputs; class ElasticSearch
 
     def setup_ilm
       return unless ilm_in_use?
-        logger.warn("Overwriting supplied index #{@index} with rollover alias #{@ilm_rollover_alias}") unless default_index?(@index)
-        @index = @ilm_rollover_alias
-        maybe_create_rollover_alias
-        maybe_create_ilm_policy
+      logger.warn("Overwriting supplied index #{@index} with rollover alias #{@ilm_rollover_alias}") unless default_index?(@index)
+      @index = @ilm_rollover_alias
+      maybe_create_rollover_alias
+      maybe_create_ilm_policy
     end
 
     def default_rollover_alias?(rollover_alias)
@@ -75,6 +75,10 @@ module LogStash; module Outputs; class ElasticSearch
 
     private
 
+    def default_index?(index)
+      index == @default_index
+    end
+
     def ilm_policy_default?
       ilm_policy == LogStash::Outputs::ElasticSearch::DEFAULT_POLICY
     end
@@ -110,4 +114,4 @@ module LogStash; module Outputs; class ElasticSearch
       LogStash::Json.load(::IO.read(policy_path))
     end
   end
- end end end
+end; end; end

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

@@ -0,0 +1,47 @@
+module LogStash; module Outputs; class ElasticSearch
+  class LicenseChecker
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    # Figure out if the provided license is appropriate or not
+    # The appropriate_license? methods is the method called from LogStash::Outputs::ElasticSearch::HttpClient::Pool#healthcheck!
+    # @param url [LogStash::Util::SafeURI] ES node URL
+    # @param license [Hash] ES node deserialized licence document
+    # @return [Boolean] true if provided license is deemed appropriate
+    def appropriate_license?(pool, url)
+      return true if oss?
+
+      license = pool.get_license(url)
+      if valid_es_license?(license)
+        true
+      else
+        # As this version is to be shipped with Logstash 7.x we won't mark the connection as unlicensed
+        #
+        #  @logger.error("Cannot connect to the Elasticsearch cluster configured in the Elasticsearch output. Logstash requires the default distribution of Elasticsearch. Please update to the default distribution of Elasticsearch for full access to all free features, or switch to the OSS distribution of Logstash.", :url => url.sanitized.to_s)
+        #  meta[:state] = :unlicensed
+        #
+        # Instead we'll log a deprecation warning and mark it as alive:
+        #
+        log_license_deprecation_warn(url)
+        true
+      end
+    end
+
+    # Note that oss? could be private but is used by the Pool specs
+    def oss?
+      LogStash::OSS
+    end
+
+    # Note that valid_es_license? could be private but is used by the Pool specs
+    def valid_es_license?(license)
+      license.fetch("license", {}).fetch("status", nil) == "active"
+    end
+
+    # Note that log_license_deprecation_warn could be private but is used by the Pool specs
+    def log_license_deprecation_warn(url)
+      @logger.warn("DEPRECATION WARNING: Connecting to an OSS distribution of Elasticsearch using the default distribution of Logstash will stop working in Logstash 8.0.0. Please upgrade to the default distribution of Elasticsearch, or use the OSS distribution of Logstash", :url => url.sanitized.to_s)
+    end
+  end
+end; end; end

data/lib/logstash/plugin_mixins/elasticsearch/api_configs.rb

@@ -0,0 +1,163 @@
+module LogStash; module PluginMixins; module ElasticSearch
+  module APIConfigs
+
+    # This module defines common options that can be reused by alternate elasticsearch output plugins such as the elasticsearch_data_streams output.
+
+    DEFAULT_HOST = ::LogStash::Util::SafeURI.new("//127.0.0.1")
+
+    def self.included(mod)
+      # Username to authenticate to a secure Elasticsearch cluster
+      mod.config :user, :validate => :string
+      # Password to authenticate to a secure Elasticsearch cluster
+      mod.config :password, :validate => :password
+
+      # Authenticate using Elasticsearch API key.
+      # format is id:api_key (as returned by https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-api-key.html[Create API key])
+      mod.config :api_key, :validate => :password
+
+      # Cloud authentication string ("<username>:<password>" format) is an alternative for the `user`/`password` configuration.
+      #
+      # For more details, check out the https://www.elastic.co/guide/en/logstash/current/connecting-to-cloud.html#_cloud_auth[cloud documentation]
+      mod.config :cloud_auth, :validate => :password
+
+      # The document ID for the index. Useful for overwriting existing entries in
+      # Elasticsearch with the same ID.
+      mod.config :document_id, :validate => :string
+
+      # HTTP Path at which the Elasticsearch server lives. Use this if you must run Elasticsearch behind a proxy that remaps
+      # the root path for the Elasticsearch HTTP API lives.
+      # Note that if you use paths as components of URLs in the 'hosts' field you may
+      # not also set this field. That will raise an error at startup
+      mod.config :path, :validate => :string
+
+      # HTTP Path to perform the _bulk requests to
+      # this defaults to a concatenation of the path parameter and "_bulk"
+      mod.config :bulk_path, :validate => :string
+
+      # Pass a set of key value pairs as the URL query string. This query string is added
+      # to every host listed in the 'hosts' configuration. If the 'hosts' list contains
+      # urls that already have query strings, the one specified here will be appended.
+      mod.config :parameters, :validate => :hash
+
+      # Enable SSL/TLS secured communication to Elasticsearch cluster. Leaving this unspecified will use whatever scheme
+      # is specified in the URLs listed in 'hosts'. If no explicit protocol is specified plain HTTP will be used.
+      # If SSL is explicitly disabled here the plugin will refuse to start if an HTTPS URL is given in 'hosts'
+      mod.config :ssl, :validate => :boolean
+
+      # Option to validate the server's certificate. Disabling this severely compromises security.
+      # For more information on disabling certificate verification please read
+      # https://www.cs.utexas.edu/~shmat/shmat_ccs12.pdf
+      mod.config :ssl_certificate_verification, :validate => :boolean, :default => true
+
+      # The .cer or .pem file to validate the server's certificate
+      mod.config :cacert, :validate => :path
+
+      # The JKS truststore to validate the server's certificate.
+      # Use either `:truststore` or `:cacert`
+      mod.config :truststore, :validate => :path
+
+      # Set the truststore password
+      mod.config :truststore_password, :validate => :password
+
+      # The keystore used to present a certificate to the server.
+      # It can be either .jks or .p12
+      mod.config :keystore, :validate => :path
+
+      # Set the keystore password
+      mod.config :keystore_password, :validate => :password
+
+      # This setting asks Elasticsearch for the list of all cluster nodes and adds them to the hosts list.
+      # Note: This will return ALL nodes with HTTP enabled (including master nodes!). If you use
+      # this with master nodes, you probably want to disable HTTP on them by setting
+      # `http.enabled` to false in their elasticsearch.yml. You can either use the `sniffing` option or
+      # manually enter multiple Elasticsearch hosts using the `hosts` parameter.
+      mod.config :sniffing, :validate => :boolean, :default => false
+
+      # How long to wait, in seconds, between sniffing attempts
+      mod.config :sniffing_delay, :validate => :number, :default => 5
+
+      # HTTP Path to be used for the sniffing requests
+      # the default value is computed by concatenating the path value and "_nodes/http"
+      # if sniffing_path is set it will be used as an absolute path
+      # do not use full URL here, only paths, e.g. "/sniff/_nodes/http"
+      mod.config :sniffing_path, :validate => :string
+
+      # Set the address of a forward HTTP proxy.
+      # This used to accept hashes as arguments but now only accepts
+      # arguments of the URI type to prevent leaking credentials.
+      mod.config :proxy, :validate => :uri # but empty string is allowed
+
+      # Set the timeout, in seconds, for network operations and requests sent Elasticsearch. If
+      # a timeout occurs, the request will be retried.
+      mod.config :timeout, :validate => :number, :default => 60
+
+      # Set the Elasticsearch errors in the whitelist that you don't want to log.
+      # A useful example is when you want to skip all 409 errors
+      # which are `document_already_exists_exception`.
+      mod.config :failure_type_logging_whitelist, :validate => :array, :default => []
+
+      # While the output tries to reuse connections efficiently we have a maximum.
+      # This sets the maximum number of open connections the output will create.
+      # Setting this too low may mean frequently closing / opening connections
+      # which is bad.
+      mod.config :pool_max, :validate => :number, :default => 1000
+
+      # While the output tries to reuse connections efficiently we have a maximum per endpoint.
+      # This sets the maximum number of open connections per endpoint the output will create.
+      # Setting this too low may mean frequently closing / opening connections
+      # which is bad.
+      mod.config :pool_max_per_route, :validate => :number, :default => 100
+
+      # HTTP Path where a HEAD request is sent when a backend is marked down
+      # the request is sent in the background to see if it has come back again
+      # before it is once again eligible to service requests.
+      # If you have custom firewall rules you may need to change this
+      mod.config :healthcheck_path, :validate => :string
+
+      # How frequently, in seconds, to wait between resurrection attempts.
+      # Resurrection is the process by which backend endpoints marked 'down' are checked
+      # to see if they have come back to life
+      mod.config :resurrect_delay, :validate => :number, :default => 5
+
+      # How long to wait before checking if the connection is stale before executing a request on a connection using keepalive.
+      # You may want to set this lower, if you get connection errors regularly
+      # Quoting the Apache commons docs (this client is based Apache Commmons):
+      # 'Defines period of inactivity in milliseconds after which persistent connections must
+      # be re-validated prior to being leased to the consumer. Non-positive value passed to
+      # this method disables connection validation. This check helps detect connections that
+      # have become stale (half-closed) while kept inactive in the pool.'
+      # See https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/org/apache/http/impl/conn/PoolingHttpClientConnectionManager.html#setValidateAfterInactivity(int)[these docs for more info]
+      mod.config :validate_after_inactivity, :validate => :number, :default => 10000
+
+      # Enable gzip compression on requests. Note that response compression is on by default for Elasticsearch v5.0 and beyond
+      mod.config :http_compression, :validate => :boolean, :default => false
+
+      # Custom Headers to send on each request to elasticsearch nodes
+      mod.config :custom_headers, :validate => :hash, :default => {}
+
+      # Sets the host(s) of the remote instance. If given an array it will load balance requests across the hosts specified in the `hosts` parameter.
+      # Remember the `http` protocol uses the http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-http.html#modules-http[http] address (eg. 9200, not 9300).
+      #     `"127.0.0.1"`
+      #     `["127.0.0.1:9200","127.0.0.2:9200"]`
+      #     `["http://127.0.0.1"]`
+      #     `["https://127.0.0.1:9200"]`
+      #     `["https://127.0.0.1:9200/mypath"]` (If using a proxy on a subpath)
+      # It is important to exclude http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-node.html[dedicated master nodes] from the `hosts` list
+      # to prevent LS from sending bulk requests to the master nodes.  So this parameter should only reference either data or client nodes in Elasticsearch.
+      #
+      # Any special characters present in the URLs here MUST be URL escaped! This means `#` should be put in as `%23` for instance.
+      mod.config :hosts, :validate => :uri, :default => [ DEFAULT_HOST ], :list => true
+
+      # Cloud ID, from the Elastic Cloud web console. If set `hosts` should not be used.
+      #
+      # For more details, check out the https://www.elastic.co/guide/en/logstash/current/connecting-to-cloud.html#_cloud_id[cloud documentation]
+      mod.config :cloud_id, :validate => :string
+
+      # Set initial interval in seconds between bulk retries. Doubled on each retry up to `retry_max_interval`
+      mod.config :retry_initial_interval, :validate => :number, :default => 2
+
+      # Set max interval in seconds between bulk retries.
+      mod.config :retry_max_interval, :validate => :number, :default => 64
+    end
+  end
+end; end; end

data/lib/logstash/{outputs → plugin_mixins}/elasticsearch/common.rb

@@ -1,7 +1,10 @@
 require "logstash/outputs/elasticsearch/template_manager"
 
-module LogStash; module Outputs; class ElasticSearch;
+module LogStash; module PluginMixins; module ElasticSearch
   module Common
+
+    # This module defines common methods that can be reused by alternate elasticsearch output plugins such as the elasticsearch_data_streams output.
+
     attr_reader :client, :hosts
 
     # These codes apply to documents, not at the request level
@@ -9,116 +12,26 @@ module LogStash; module Outputs; class ElasticSearch;
     DOC_SUCCESS_CODES = [200, 201]
     DOC_CONFLICT_CODE = 409
 
-    # When you use external versioning, you are communicating that you want
-    # to ignore conflicts. More obviously, since an external version is a
-    # constant part of the incoming document, we should not retry, as retrying
-    # will never succeed.
-    VERSION_TYPES_PERMITTING_CONFLICT = ["external", "external_gt", "external_gte"]
-
-    def register
-      @template_installed = Concurrent::AtomicBoolean.new(false)
-      @stopping = Concurrent::AtomicBoolean.new(false)
-      # To support BWC, we check if DLQ exists in core (< 5.4). If it doesn't, we use nil to resort to previous behavior.
-      @dlq_writer = dlq_enabled? ? execution_context.dlq_writer : nil
-      build_client
-      setup_after_successful_connection
-      check_action_validity
-      @bulk_request_metrics = metric.namespace(:bulk_requests)
-      @document_level_metrics = metric.namespace(:documents)
-      @logger.info("New Elasticsearch output", :class => self.class.name, :hosts => @hosts.map(&:sanitized).map(&:to_s))
-    end
-
-    # Receive an array of events and immediately attempt to index them (no buffering)
-    def multi_receive(events)
-      until @template_installed.true?
-        sleep 1
+    # Perform some ES options validations and Build the HttpClient.
+    # Note that this methods may sets the @user, @password, @hosts and @client ivars as a side effect.
+    # @param license_checker [#appropriate_license?] An optional license checker that will be used by the Pool class.
+    # @return [HttpClient] the new http client
+    def build_client(license_checker = nil)
+      params["license_checker"] = license_checker
+
+      # the following 3 options validation & setup methods are called inside build_client
+      # because they must be executed prior to building the client and logstash
+      # monitoring and management rely on directly calling build_client
+      # see https://github.com/logstash-plugins/logstash-output-elasticsearch/pull/934#pullrequestreview-396203307
+      validate_authentication
+      fill_hosts_from_cloud_id
+      setup_hosts
+
+      params["metric"] = metric
+      if @proxy.eql?('')
+        @logger.warn "Supplied proxy setting (proxy => '') has no effect"
       end
-      retrying_submit(events.map {|e| event_action_tuple(e)})
-    end
-
-    def setup_after_successful_connection
-      @template_installer ||= Thread.new do
-        sleep_interval = @retry_initial_interval
-        until successful_connection? || @stopping.true?
-          @logger.debug("Waiting for connectivity to Elasticsearch cluster. Retrying in #{sleep_interval}s")
-          Stud.stoppable_sleep(sleep_interval) { @stopping.true? }
-          sleep_interval = next_sleep_interval(sleep_interval)
-        end
-        if successful_connection?
-          discover_cluster_uuid
-          install_template
-          setup_ilm if ilm_in_use?
-        end
-      end
-    end
-
-    def stop_template_installer
-      @template_installer.join unless @template_installer.nil?
-    end
-
-    def successful_connection?
-      !!maximum_seen_major_version
-    end
-
-    ##
-    # WARNING: This method is overridden in a subclass in Logstash Core 7.7-7.8's monitoring,
-    #          where a `client` argument is both required and ignored. In later versions of
-    #          Logstash Core it is optional and ignored, but to make it optional here would
-    #          allow us to accidentally break compatibility with Logstashes where it was required.
-    # @param noop_required_client [nil]: required `nil` for legacy reasons.
-    # @return [Boolean]
-    def use_event_type?(noop_required_client)
-      maximum_seen_major_version < 8
-    end
-
-    # Convert the event into a 3-tuple of action, params, and event
-    def event_action_tuple(event)
-      action = event.sprintf(@action)
-
-      params = {
-        :_id => @document_id ? event.sprintf(@document_id) : nil,
-        :_index => event.sprintf(@index),
-        routing_field_name => @routing ? event.sprintf(@routing) : nil
-      }
-
-      params[:_type] = get_event_type(event) if use_event_type?(nil)
-
-      if @pipeline
-        value = event.sprintf(@pipeline)
-        # convention: empty string equates to not using a pipeline
-        # this is useful when using a field reference in the pipeline setting, e.g.
-        #      elasticsearch {
-        #        pipeline => "%{[@metadata][pipeline]}"
-        #      }
-        params[:pipeline] = value unless value.empty?
-      end
-
-      if @parent
-        if @join_field
-          join_value = event.get(@join_field)
-          parent_value = event.sprintf(@parent)
-          event.set(@join_field, { "name" => join_value, "parent" => parent_value })
-          params[routing_field_name] = event.sprintf(@parent)
-        else
-          params[:parent] = event.sprintf(@parent)
-        end
-      end
-
-      if action == 'update'
-        params[:_upsert] = LogStash::Json.load(event.sprintf(@upsert)) if @upsert != ""
-        params[:_script] = event.sprintf(@script) if @script != ""
-        params[retry_on_conflict_action_name] = @retry_on_conflict
-      end
-
-      if @version
-        params[:version] = event.sprintf(@version)
-      end
-
-      if @version_type
-        params[:version_type] = event.sprintf(@version_type)
-      end
-
-      [action, params, event]
+      @client ||= ::LogStash::Outputs::ElasticSearch::HttpClientBuilder.build(@logger, @hosts, params)
     end
 
     def validate_authentication
@@ -153,7 +66,7 @@ module LogStash; module Outputs; class ElasticSearch;
 
     def hosts_default?(hosts)
       # NOTE: would be nice if pipeline allowed us a clean way to detect a config default :
-      hosts.is_a?(Array) && hosts.size == 1 && hosts.first.equal?(CommonConfigs::DEFAULT_HOST)
+      hosts.is_a?(Array) && hosts.size == 1 && hosts.first.equal?(LogStash::PluginMixins::ElasticSearch::APIConfigs::DEFAULT_HOST)
     end
     private :hosts_default?
 
@@ -206,17 +119,23 @@ module LogStash; module Outputs; class ElasticSearch;
       client.maximum_seen_major_version
     end
 
-    def routing_field_name
-      maximum_seen_major_version >= 6 ? :routing : :_routing
-    end
-
-    def retry_on_conflict_action_name
-      maximum_seen_major_version >= 7 ? :retry_on_conflict : :_retry_on_conflict
+    def successful_connection?
+      !!maximum_seen_major_version
     end
 
-    def install_template
-      TemplateManager.install_template(self)
-      @template_installed.make_true
+    # launch a thread that waits for an initial successful connection to the ES cluster to call the given block
+    # @param block [Proc] the block to execute upon initial successful connection
+    # @return [Thread] the successful connection wait thread
+    def setup_after_successful_connection(&block)
+      Thread.new do
+        sleep_interval = @retry_initial_interval
+        until successful_connection? || @stopping.true?
+          @logger.debug("Waiting for connectivity to Elasticsearch cluster. Retrying in #{sleep_interval}s")
+          Stud.stoppable_sleep(sleep_interval) { @stopping.true? }
+          sleep_interval = next_sleep_interval(sleep_interval)
+        end
+        block.call if successful_connection?
+      end
     end
 
     def discover_cluster_uuid
@@ -228,22 +147,6 @@ module LogStash; module Outputs; class ElasticSearch;
       # @logger.error("Unable to retrieve elasticsearch cluster uuid", error => e.message)
     end
 
-    def check_action_validity
-      raise LogStash::ConfigurationError, "No action specified!" unless @action
-
-      # If we're using string interpolation, we're good!
-      return if @action =~ /%{.+}/
-      return if valid_actions.include?(@action)
-
-      raise LogStash::ConfigurationError, "Action '#{@action}' is invalid! Pick one of #{valid_actions} or use a sprintf style statement"
-    end
-
-    # To be overidden by the -java version
-    VALID_HTTP_ACTIONS=["index", "delete", "create", "update"]
-    def valid_actions
-      VALID_HTTP_ACTIONS
-    end
-
     def retrying_submit(actions)
       # Initially we submit the full list of actions
       submit_actions = actions
@@ -352,32 +255,6 @@ module LogStash; module Outputs; class ElasticSearch;
       end
     end
 
-    # Determine the correct value for the 'type' field for the given event
-    DEFAULT_EVENT_TYPE_ES6="doc".freeze
-    DEFAULT_EVENT_TYPE_ES7="_doc".freeze
-    def get_event_type(event)
-      # Set the 'type' value for the index.
-      type = if @document_type
-               event.sprintf(@document_type)
-             else
-               if maximum_seen_major_version < 6
-                 event.get("type") || DEFAULT_EVENT_TYPE_ES6
-               elsif maximum_seen_major_version == 6
-                 DEFAULT_EVENT_TYPE_ES6
-               elsif maximum_seen_major_version == 7
-                 DEFAULT_EVENT_TYPE_ES7
-               else
-                 nil
-               end
-             end
-
-      if !(type.is_a?(String) || type.is_a?(Numeric))
-        @logger.warn("Bad event type! Non-string/integer type value set!", :type_class => type.class, :type_value => type.to_s, :event => event)
-      end
-
-      type.to_s
-    end
-
     # Rescue retryable errors during bulk submission
     def safe_bulk(actions)
       sleep_interval = @retry_initial_interval
@@ -448,10 +325,6 @@ module LogStash; module Outputs; class ElasticSearch;
       end
     end
 
-    def default_index?(index)
-      @index == @default_index
-    end
-
     def dlq_enabled?
       # TODO there should be a better way to query if DLQ is enabled
       # See more in: https://github.com/elastic/logstash/issues/8064
@@ -459,4 +332,4 @@ module LogStash; module Outputs; class ElasticSearch;
         !execution_context.dlq_writer.inner_writer.is_a?(::LogStash::Util::DummyDeadLetterQueueWriter)
     end
   end
-end end end
+end; end; end