Rename write alias to rollover alias for consistency with beats

Author: robbavey

lib/logstash/outputs/elasticsearch/common.rb

@@ -368,8 +368,9 @@ def dlq_enabled?
 
     def setup_ilm
       return unless ilm_enabled?
-      # As soon as the template is loaded, check for existence of write alias:
-      maybe_create_write_alias
+      logger.info("Using Index lifecycle management - this feature is currently in beta.")
+      # As soon as the template is loaded, check for existence of rollover alias:
+      maybe_create_rollover_alias
       maybe_create_ilm_policy
     end
 
@@ -403,9 +404,9 @@ def verify_ilm
     end
 
     def verify_ilm_config
-      # Overwrite the index with the write alias.
-      @logger.warn "Overwriting index name with rollover alias #{@ilm_write_alias}" if @index != LogStash::Outputs::ElasticSearch::CommonConfigs::DEFAULT_INDEX_NAME
-      @index = @ilm_write_alias
+      # Overwrite the index with the rollover alias.
+      @logger.warn "Overwriting index name with rollover alias #{@ilm_rollover_alias}" if @index != LogStash::Outputs::ElasticSearch::CommonConfigs::DEFAULT_INDEX_NAME
+      @index = @ilm_rollover_alias
       verify_ilm_policy unless ilm_policy_default?
     end
 
@@ -427,18 +428,18 @@ def maybe_create_ilm_policy
       end
     end
 
-    def maybe_create_write_alias
-      client.write_alias_put(write_alias_target, write_alias_payload) unless client.write_alias_exists?(ilm_write_alias)
+    def maybe_create_rollover_alias
+      client.rollover_alias_put(rollover_alias_target, rollover_alias_payload) unless client.rollover_alias_exists?(ilm_rollover_alias)
     end
 
-    def write_alias_target
-      "<#{ilm_write_alias}-#{ilm_pattern}>"
+    def rollover_alias_target
+      "<#{ilm_rollover_alias}-#{ilm_pattern}>"
     end
 
-    def write_alias_payload
+    def rollover_alias_payload
       {
           "aliases" => {
-              ilm_write_alias =>{
+              ilm_rollover_alias =>{
                   "is_write_index" =>  true
               }
           }

lib/logstash/outputs/elasticsearch/common_configs.rb

@@ -141,21 +141,21 @@ def self.included(mod)
 
 
       # -----
-      # ILM configurations
+      # ILM configurations (beta)
       # -----
       # Flag for enabling Index Lifecycle Management integration.
       mod.config :ilm_enabled, :validate => :boolean, :default => false
 
-      # Write alias used for indexing data. If write alias doesn't exist, Logstash will create it and map it to the relevant index
-      mod.config :ilm_write_alias, :validate => :string, :default => 'logstash'
+      # Rollover alias used for indexing data. If rollover alias doesn't exist, Logstash will create it and map it to the relevant index
+      mod.config :ilm_rollover_alias, :validate => :string, :default => 'logstash'
 
       # appends “{now/d}-000001” by default for new index creation, subsequent rollover indices will increment based on this pattern i.e. “000002”
+      # {now/d} is date math, and will insert the appropriate value automatically.
       mod.config :ilm_pattern, :validate => :string, :default => '{now/d}-000001'
 
       # ILM policy to use, if undefined the default policy will be used.
       mod.config :ilm_policy, :validate => :string, :default => 'logstash-policy'
 
-
     end
   end
 end end end

lib/logstash/outputs/elasticsearch/http_client.rb

@@ -354,28 +354,24 @@ def template_put(name, template)
 
     # ILM methods
 
-    # check whether write alias already exists
-    def write_alias_exists?(name)
+    # check whether rollover alias already exists
+    def rollover_alias_exists?(name)
       exists?(name)
     end
 
-    # Create a new write alias
-    def write_alias_put(alias_name, alias_definition)
-      logger.info("Creating write alias #{alias_name}")
+    # Create a new rollover alias
+    def rollover_alias_put(alias_name, alias_definition)
+      logger.info("Creating rollover alias #{alias_name}")
       begin
         @pool.put(CGI::escape(alias_name), nil, LogStash::Json.dump(alias_definition))
       # If the rollover alias already exists, ignore the error that comes back from Elasticsearch
       #
       rescue ::LogStash::Outputs::ElasticSearch::HttpClient::Pool::BadResponseCodeError => e
-        if e.response_code == 400 && e.response_body
-          error_body = LogStash::Json.load(e.response_bod)
-          if error_body['error'] && error_body['error']['root_cause'] &&
-            error_body['error']['root_cause'][0] && error_body['error']['root_cause'][0]['type'] == 'resource_already_exists_exception'
-            logger.info("Write Alias #{alias_name} already exists. Skipping")
+        if e.response_code == 400
+            logger.info("Rollover Alias #{alias_name} already exists. Skipping")
             return
-          end
         end
-      raise e
+        raise e
       end
     end
 

lib/logstash/outputs/elasticsearch/template_manager.rb

@@ -25,16 +25,16 @@ def self.install(client, template_name, template, template_overwrite)
     def self.add_ilm_settings_to_template(plugin, template)
       # Include ilm settings in template:
 			plugin.logger.info("Overwriting template name and pattern as ILM is enabled.")
-      template['template'] = "#{plugin.ilm_write_alias}-*"
+      template['template'] = "#{plugin.ilm_rollover_alias}-*"
       if template['settings'] && (template['settings']['index.lifecycle.name'] || template['settings']['index.lifecycle.rollover_alias'])
         plugin.logger.info("Overwriting index lifecycle name and rollover alias as ILM is enabled.")
       end
-      template['settings'].update({ 'index.lifecycle.name' => plugin.ilm_policy, 'index.lifecycle.rollover_alias' => plugin.ilm_write_alias})
+      template['settings'].update({ 'index.lifecycle.name' => plugin.ilm_policy, 'index.lifecycle.rollover_alias' => plugin.ilm_rollover_alias})
     end
 
     # TODO: Verify this is ok
     def self.template_name(plugin)
-      plugin.ilm_enabled? ? plugin.ilm_write_alias : plugin.template_name
+      plugin.ilm_enabled? ? plugin.ilm_rollover_alias : plugin.template_name
     end
 
     def self.default_template_path(es_major_version)

spec/integration/outputs/ilm_spec.rb

@@ -258,7 +258,7 @@
       context 'when using the default policy' do
         context 'with a custom pattern' do
           let (:settings) { super.merge("ilm_pattern" => "000001")}
-          it 'should create a write alias' do
+          it 'should create a rollover alias' do
             expect(@es.indices.exists_alias(index: "logstash")).to be_falsey
             subject.register
             sleep(1)
@@ -275,7 +275,7 @@
           expect{get_policy(@es, LogStash::Outputs::ElasticSearch::DEFAULT_POLICY)}.not_to raise_error
         end
 
-        it 'should create the default write alias' do
+        it 'should create the default rollover alias' do
           expect(@es.indices.exists_alias(index: "logstash")).to be_falsey
           subject.register
           sleep(1)
@@ -376,7 +376,7 @@
       context 'with the default template' do
         let(:expected_index) { "logstash" }
 
-        it 'should create the write alias' do
+        it 'should create the rollover alias' do
           expect(@es.indices.exists_alias(index: expected_index)).to be_falsey
           subject.register
           sleep(1)
@@ -396,13 +396,13 @@
       end
 
       context 'with a custom template' do
-        let (:ilm_write_alias) { "custom" }
-        let (:index) { ilm_write_alias }
+        let (:ilm_rollover_alias) { "custom" }
+        let (:index) { ilm_rollover_alias }
         let(:expected_index) { index }
         let (:settings) { super.merge("ilm_policy" => ilm_policy_name,
                                       "template" => template,
                                       "template_name" => template_name,
-                                      "ilm_write_alias" => ilm_write_alias)}
+                                      "ilm_rollover_alias" => ilm_rollover_alias)}
         let (:template_name) { "custom" }
 
         if ESHelper.es_version_satisfies?(">= 7.0")
@@ -418,32 +418,32 @@
           put_policy(@es,ilm_policy_name, policy)
         end
 
-        it 'should create the write alias' do
-          expect(@es.indices.exists_alias(index: ilm_write_alias)).to be_falsey
+        it 'should create the rollover alias' do
+          expect(@es.indices.exists_alias(index: ilm_rollover_alias)).to be_falsey
           subject.register
           sleep(1)
-          expect(@es.indices.exists_alias(index: ilm_write_alias)).to be_truthy
-          expect(@es.get_alias(name: ilm_write_alias)).to include("#{ilm_write_alias}-#{todays_date}-000001")
+          expect(@es.indices.exists_alias(index: ilm_rollover_alias)).to be_truthy
+          expect(@es.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
         end
 
-        context 'when the custom write alias already exists' do
+        context 'when the custom rollover alias already exists' do
           it 'should ignore the already exists error' do
-            expect(@es.indices.exists_alias(index: ilm_write_alias)).to be_falsey
-            put_alias(@es, "#{ilm_write_alias}-#{todays_date}-000001", ilm_write_alias)
-            expect(@es.indices.exists_alias(index: ilm_write_alias)).to be_truthy
+            expect(@es.indices.exists_alias(index: ilm_rollover_alias)).to be_falsey
+            put_alias(@es, "#{ilm_rollover_alias}-#{todays_date}-000001", ilm_rollover_alias)
+            expect(@es.indices.exists_alias(index: ilm_rollover_alias)).to be_truthy
             subject.register
             sleep(1)
-            expect(@es.get_alias(name: ilm_write_alias)).to include("#{ilm_write_alias}-#{todays_date}-000001")
+            expect(@es.get_alias(name: ilm_rollover_alias)).to include("#{ilm_rollover_alias}-#{todays_date}-000001")
           end
 
         end
 
         it 'should write the ILM settings into the template' do
           subject.register
           sleep(1)
-          expect(@es.indices.get_template(name: template_name)[template_name]["index_patterns"]).to eq(["#{ilm_write_alias}-*"])
+          expect(@es.indices.get_template(name: template_name)[template_name]["index_patterns"]).to eq(["#{ilm_rollover_alias}-*"])
           expect(@es.indices.get_template(name: template_name)[template_name]["settings"]['index']['lifecycle']['name']).to eq(ilm_policy_name)
-          expect(@es.indices.get_template(name: template_name)[template_name]["settings"]['index']['lifecycle']['rollover_alias']).to eq(ilm_write_alias)
+          expect(@es.indices.get_template(name: template_name)[template_name]["settings"]['index']['lifecycle']['rollover_alias']).to eq(ilm_rollover_alias)
         end
 
         it_behaves_like 'an ILM enabled Logstash'
@@ -453,7 +453,7 @@
     context 'with ilm disabled' do
       let (:ilm_enabled) { false }
 
-      it 'should not create a write alias' do
+      it 'should not create a rollover alias' do
         expect(@es.get_alias).to be_empty
         subject.register
         sleep(1)