fluent-plugin-kubernetes_metadata_filter 2.6.0 → 2.7.0

data/lib/fluent/plugin/kubernetes_metadata_watch_pods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -20,9 +22,7 @@
 require_relative 'kubernetes_metadata_common'
 
 module KubernetesMetadata
-
   module WatchPods
-
     include ::KubernetesMetadata::Common
 
     def set_up_pod_thread
@@ -38,48 +38,47 @@ module KubernetesMetadata
       # processing will be swallowed and retried. These failures /
       # exceptions could be caused by Kubernetes API being temporarily
       # down. We assume the configuration is correct at this point.
-      while true
-        begin
-          pod_watcher ||= get_pods_and_start_watcher
-          process_pod_watcher_notices(pod_watcher)
-        rescue GoneError => e
-          # Expected error. Quietly go back through the loop in order to
-          # start watching from the latest resource versions
-          @stats.bump(:pod_watch_gone_errors)
-          log.info("410 Gone encountered. Restarting pod watch to reset resource versions.", e)
+      loop do
+        pod_watcher ||= get_pods_and_start_watcher
+        process_pod_watcher_notices(pod_watcher)
+      rescue GoneError => e
+        # Expected error. Quietly go back through the loop in order to
+        # start watching from the latest resource versions
+        @stats.bump(:pod_watch_gone_errors)
+        log.info('410 Gone encountered. Restarting pod watch to reset resource versions.', e)
+        pod_watcher = nil
+      rescue StandardError => e
+        @stats.bump(:pod_watch_failures)
+        if Thread.current[:pod_watch_retry_count] < @watch_retry_max_times
+          # Instead of raising exceptions and crashing Fluentd, swallow
+          # the exception and reset the watcher.
+          log.info(
+            'Exception encountered parsing pod watch event. The ' \
+            'connection might have been closed. Sleeping for ' \
+            "#{Thread.current[:pod_watch_retry_backoff_interval]} " \
+            'seconds and resetting the pod watcher.', e
+          )
+          sleep(Thread.current[:pod_watch_retry_backoff_interval])
+          Thread.current[:pod_watch_retry_count] += 1
+          Thread.current[:pod_watch_retry_backoff_interval] *= @watch_retry_exponential_backoff_base
           pod_watcher = nil
-        rescue => e
-          @stats.bump(:pod_watch_failures)
-          if Thread.current[:pod_watch_retry_count] < @watch_retry_max_times
-            # Instead of raising exceptions and crashing Fluentd, swallow
-            # the exception and reset the watcher.
-            log.info(
-              "Exception encountered parsing pod watch event. The " \
-              "connection might have been closed. Sleeping for " \
-              "#{Thread.current[:pod_watch_retry_backoff_interval]} " \
-              "seconds and resetting the pod watcher.", e)
-            sleep(Thread.current[:pod_watch_retry_backoff_interval])
-            Thread.current[:pod_watch_retry_count] += 1
-            Thread.current[:pod_watch_retry_backoff_interval] *= @watch_retry_exponential_backoff_base
-            pod_watcher = nil
-          else
-            # Since retries failed for many times, log as errors instead
-            # of info and raise exceptions and trigger Fluentd to restart.
-            message =
-              "Exception encountered parsing pod watch event. The " \
-              "connection might have been closed. Retried " \
-              "#{@watch_retry_max_times} times yet still failing. Restarting."
-            log.error(message, e)
-            raise Fluent::UnrecoverableError.new(message)
-          end
+        else
+          # Since retries failed for many times, log as errors instead
+          # of info and raise exceptions and trigger Fluentd to restart.
+          message =
+            'Exception encountered parsing pod watch event. The ' \
+            'connection might have been closed. Retried ' \
+            "#{@watch_retry_max_times} times yet still failing. Restarting."
+          log.error(message, e)
+          raise Fluent::UnrecoverableError, message
         end
       end
     end
 
     def start_pod_watch
       get_pods_and_start_watcher
-    rescue => e
-      message = "start_pod_watch: Exception encountered setting up pod watch " \
+    rescue StandardError => e
+      message = 'start_pod_watch: Exception encountered setting up pod watch ' \
                 "from Kubernetes API #{@apiVersion} endpoint " \
                 "#{@kubernetes_url}: #{e.message}"
       message += " (#{e.response})" if e.respond_to?(:response)
@@ -92,7 +91,7 @@ module KubernetesMetadata
     # from that resourceVersion.
     def get_pods_and_start_watcher
       options = {
-        resource_version: '0'  # Fetch from API server cache instead of etcd quorum read
+        resource_version: '0' # Fetch from API server cache instead of etcd quorum read
       }
       if ENV['K8S_NODE_NAME']
         options[:field_selector] = 'spec.nodeName=' + ENV['K8S_NODE_NAME']
@@ -133,39 +132,39 @@ module KubernetesMetadata
         @last_seen_resource_version = version if version
 
         case notice[:type]
-          when 'MODIFIED'
-            reset_pod_watch_retry_stats
-            cache_key = notice.dig(:object, :metadata, :uid)
-            cached    = @cache[cache_key]
-            if cached
-              @cache[cache_key] = parse_pod_metadata(notice[:object])
-              @stats.bump(:pod_cache_watch_updates)
-            elsif ENV['K8S_NODE_NAME'] == notice[:object][:spec][:nodeName] then
-              @cache[cache_key] = parse_pod_metadata(notice[:object])
-              @stats.bump(:pod_cache_host_updates)
-            else
-              @stats.bump(:pod_cache_watch_misses)
-            end
-          when 'DELETED'
-            reset_pod_watch_retry_stats
-            # ignore and let age out for cases where pods
-            # deleted but still processing logs
-            @stats.bump(:pod_cache_watch_delete_ignored)
-          when 'ERROR'
-            if notice[:object] && notice[:object][:code] == 410
-              @last_seen_resource_version = nil # requested resourceVersion was too old, need to reset
-              @stats.bump(:pod_watch_gone_notices)
-              raise GoneError
-            else
-              @stats.bump(:pod_watch_error_type_notices)
-              message = notice[:object][:message] if notice[:object] && notice[:object][:message]
-              raise "Error while watching pods: #{message}"
-            end
+        when 'MODIFIED'
+          reset_pod_watch_retry_stats
+          cache_key = notice.dig(:object, :metadata, :uid)
+          cached    = @cache[cache_key]
+          if cached
+            @cache[cache_key] = parse_pod_metadata(notice[:object])
+            @stats.bump(:pod_cache_watch_updates)
+          elsif ENV['K8S_NODE_NAME'] == notice[:object][:spec][:nodeName]
+            @cache[cache_key] = parse_pod_metadata(notice[:object])
+            @stats.bump(:pod_cache_host_updates)
+          else
+            @stats.bump(:pod_cache_watch_misses)
+          end
+        when 'DELETED'
+          reset_pod_watch_retry_stats
+          # ignore and let age out for cases where pods
+          # deleted but still processing logs
+          @stats.bump(:pod_cache_watch_delete_ignored)
+        when 'ERROR'
+          if notice[:object] && notice[:object][:code] == 410
+            @last_seen_resource_version = nil # requested resourceVersion was too old, need to reset
+            @stats.bump(:pod_watch_gone_notices)
+            raise GoneError
           else
-            reset_pod_watch_retry_stats
-            # Don't pay attention to creations, since the created pod may not
-            # end up on this node.
-            @stats.bump(:pod_cache_watch_ignored)
+            @stats.bump(:pod_watch_error_type_notices)
+            message = notice[:object][:message] if notice[:object] && notice[:object][:message]
+            raise "Error while watching pods: #{message}"
+          end
+        else
+          reset_pod_watch_retry_stats
+          # Don't pay attention to creations, since the created pod may not
+          # end up on this node.
+          @stats.bump(:pod_cache_watch_ignored)
         end
       end
     end

data/test/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -65,16 +67,16 @@ def ipv6_enabled?
   begin
     TCPServer.open('::1', 0)
     true
-  rescue
+  rescue StandardError
     false
   end
 end
 
 # TEST_NAME='foo' ruby test_file.rb to run a single test case
-if ENV["TEST_NAME"]
+if ENV['TEST_NAME']
   (class << Test::Unit::TestCase; self; end).prepend(Module.new do
     def test(name)
-      super if name == ENV["TEST_NAME"]
+      super if name == ENV['TEST_NAME']
     end
   end)
 end

data/test/plugin/test_cache_stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -19,15 +21,13 @@
 require_relative '../helper'
 
 class KubernetesMetadataCacheStatsTest < Test::Unit::TestCase
+  test 'watch stats' do
+    require 'lru_redux'
+    stats = KubernetesMetadata::Stats.new
+    stats.bump(:missed)
+    stats.bump(:deleted)
+    stats.bump(:deleted)
 
-    test 'watch stats' do
-      require 'lru_redux'
-      stats = KubernetesMetadata::Stats.new
-      stats.bump(:missed)
-      stats.bump(:deleted)
-      stats.bump(:deleted)
-
-      assert_equal("stats - deleted: 2, missed: 1", stats.to_s)
-    end
-
+    assert_equal('stats - deleted: 2, missed: 1', stats.to_s)
+  end
 end

data/test/plugin/test_cache_strategy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -19,175 +21,174 @@
 require_relative '../helper'
 
 class TestCacheStrategy
-    include KubernetesMetadata::CacheStrategy
-
-    def initialize
-      @stats = KubernetesMetadata::Stats.new
-      @cache = LruRedux::TTL::ThreadSafeCache.new(100,3600)
-      @id_cache = LruRedux::TTL::ThreadSafeCache.new(100,3600)
-      @namespace_cache = LruRedux::TTL::ThreadSafeCache.new(100,3600)
-      @orphaned_namespace_name = '.orphaned'
-      @orphaned_namespace_id = 'orphaned'
-    end
-
-    attr_accessor :stats, :cache, :id_cache, :namespace_cache, :allow_orphans
-
-    def fetch_pod_metadata(namespace_name, pod_name)
-        {}
-    end
-
-    def fetch_namespace_metadata(namespace_name)
-        {}
+  include KubernetesMetadata::CacheStrategy
+
+  def initialize
+    @stats = KubernetesMetadata::Stats.new
+    @cache = LruRedux::TTL::ThreadSafeCache.new(100, 3600)
+    @id_cache = LruRedux::TTL::ThreadSafeCache.new(100, 3600)
+    @namespace_cache = LruRedux::TTL::ThreadSafeCache.new(100, 3600)
+    @orphaned_namespace_name = '.orphaned'
+    @orphaned_namespace_id = 'orphaned'
+  end
+
+  attr_accessor :stats, :cache, :id_cache, :namespace_cache, :allow_orphans
+
+  def fetch_pod_metadata(_namespace_name, _pod_name)
+    {}
+  end
+
+  def fetch_namespace_metadata(_namespace_name)
+    {}
+  end
+
+  def log
+    logger = {}
+    def logger.trace?
+      true
     end
 
-    def log
-        logger = {}
-        def logger.trace?
-          true
-        end
-        def logger.trace(message)
-        end
-        logger
+    def logger.trace(message)
     end
-
+    logger
+  end
 end
 
 class KubernetesMetadataCacheStrategyTest < Test::Unit::TestCase
-
-    def setup
-       @strategy = TestCacheStrategy.new
-       @cache_key = 'some_long_container_id'
-       @namespace_name = 'some_namespace_name'
-       @namespace_uuid = 'some_namespace_uuid'
-       @pod_name = 'some_pod_name'
-       @pod_uuid = 'some_pod_uuid'
-       @time = Time.now
-       @pod_meta = {'pod_id'=> @pod_uuid, 'labels'=> {'meta'=>'pod'}}
-       @namespace_meta = {'namespace_id'=> @namespace_uuid, 'creation_timestamp'=>@time.to_s}
+  def setup
+    @strategy = TestCacheStrategy.new
+    @cache_key = 'some_long_container_id'
+    @namespace_name = 'some_namespace_name'
+    @namespace_uuid = 'some_namespace_uuid'
+    @pod_name = 'some_pod_name'
+    @pod_uuid = 'some_pod_uuid'
+    @time = Time.now
+    @pod_meta = { 'pod_id' => @pod_uuid, 'labels' => { 'meta' => 'pod' } }
+    @namespace_meta = { 'namespace_id' => @namespace_uuid, 'creation_timestamp' => @time.to_s }
+  end
+
+  test 'when cached metadata is found' do
+    exp = @pod_meta.merge(@namespace_meta)
+    exp.delete('creation_timestamp')
+    @strategy.id_cache[@cache_key] = {
+      pod_id: @pod_uuid,
+      namespace_id: @namespace_uuid
+    }
+    @strategy.cache[@pod_uuid] = @pod_meta
+    @strategy.namespace_cache[@namespace_uuid] = @namespace_meta
+    assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, {}))
+  end
+
+  test 'when previously processed record for pod but metadata is not cached and can not be fetched' do
+    exp = {
+      'pod_id' => @pod_uuid,
+      'namespace_id' => @namespace_uuid
+    }
+    @strategy.id_cache[@cache_key] = {
+      pod_id: @pod_uuid,
+      namespace_id: @namespace_uuid
+    }
+    @strategy.stub :fetch_pod_metadata, {} do
+      @strategy.stub :fetch_namespace_metadata, nil do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, {}))
+      end
     end
-
-    test 'when cached metadata is found' do
-        exp = @pod_meta.merge(@namespace_meta)
-        exp.delete('creation_timestamp')
-        @strategy.id_cache[@cache_key] = {
-            pod_id: @pod_uuid,
-            namespace_id: @namespace_uuid
-        }
-        @strategy.cache[@pod_uuid] = @pod_meta
-        @strategy.namespace_cache[@namespace_uuid] = @namespace_meta
-        assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, {}))
+  end
+
+  test 'when metadata is not cached and is fetched' do
+    exp = @pod_meta.merge(@namespace_meta)
+    exp.delete('creation_timestamp')
+    @strategy.stub :fetch_pod_metadata, @pod_meta do
+      @strategy.stub :fetch_namespace_metadata, @namespace_meta do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, {}))
+        assert_true(@strategy.id_cache.key?(@cache_key))
+      end
     end
-
-    test 'when previously processed record for pod but metadata is not cached and can not be fetched' do
-        exp = {
-            'pod_id'=> @pod_uuid,
-            'namespace_id'=> @namespace_uuid
-        }
-        @strategy.id_cache[@cache_key] = {
-            pod_id: @pod_uuid,
-            namespace_id: @namespace_uuid
-        }
-        @strategy.stub :fetch_pod_metadata, {} do
-            @strategy.stub :fetch_namespace_metadata, nil do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, {}))
-            end
-        end
+  end
+
+  test 'when metadata is not cached and pod is deleted and namespace metadata is fetched' do
+    # this is the case for a record from a deleted pod where no other
+    # records were read.  using the container hash since that is all
+    # we ever will have and should allow us to process all the deleted
+    # pod records
+    exp = {
+      'pod_id' => @cache_key,
+      'namespace_id' => @namespace_uuid
+    }
+    @strategy.stub :fetch_pod_metadata, {} do
+      @strategy.stub :fetch_namespace_metadata, @namespace_meta do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, {}))
+        assert_true(@strategy.id_cache.key?(@cache_key))
+      end
     end
-
-    test 'when metadata is not cached and is fetched' do
-        exp = @pod_meta.merge(@namespace_meta)
-        exp.delete('creation_timestamp')
-        @strategy.stub :fetch_pod_metadata, @pod_meta do
-            @strategy.stub :fetch_namespace_metadata, @namespace_meta do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, {}))
-                assert_true(@strategy.id_cache.key?(@cache_key))
-            end
-        end
+  end
+
+  test 'when metadata is not cached and pod is deleted and namespace is for a different namespace with the same name' do
+    # this is the case for a record from a deleted pod from a deleted namespace
+    # where new namespace was created with the same name
+    exp = {
+      'namespace_id' => @namespace_uuid
+    }
+    @strategy.stub :fetch_pod_metadata, {} do
+      @strategy.stub :fetch_namespace_metadata, @namespace_meta do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time - 1 * 86_400, {}))
+        assert_true(@strategy.id_cache.key?(@cache_key))
+      end
     end
-
-    test 'when metadata is not cached and pod is deleted and namespace metadata is fetched' do
-        # this is the case for a record from a deleted pod where no other
-        # records were read.  using the container hash since that is all
-        # we ever will have and should allow us to process all the deleted
-        # pod records
-        exp = {
-            'pod_id'=> @cache_key,
-            'namespace_id'=> @namespace_uuid
-        }
-        @strategy.stub :fetch_pod_metadata, {} do
-            @strategy.stub :fetch_namespace_metadata, @namespace_meta do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, {}))
-                assert_true(@strategy.id_cache.key?(@cache_key))
-            end
-        end
+  end
+
+  test 'when metadata is not cached and no metadata can be fetched and not allowing orphans' do
+    # we should never see this since pod meta should not be retrievable
+    # unless the namespace exists
+    @strategy.stub :fetch_pod_metadata, @pod_meta do
+      @strategy.stub :fetch_namespace_metadata, {} do
+        assert_equal({}, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time - 1 * 86_400, {}))
+      end
     end
-
-    test 'when metadata is not cached and pod is deleted and namespace is for a different namespace with the same name' do
-        # this is the case for a record from a deleted pod from a deleted namespace
-        # where new namespace was created with the same name
-        exp = {
-            'namespace_id'=> @namespace_uuid
-        }
-        @strategy.stub :fetch_pod_metadata, {} do
-            @strategy.stub :fetch_namespace_metadata, @namespace_meta do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time - 1*86400, {}))
-                assert_true(@strategy.id_cache.key?(@cache_key))
-            end
-        end
+  end
+
+  test 'when metadata is not cached and no metadata can be fetched and allowing orphans' do
+    # we should never see this since pod meta should not be retrievable
+    # unless the namespace exists
+    @strategy.allow_orphans = true
+    exp = {
+      'orphaned_namespace' => 'namespace',
+      'namespace_name' => '.orphaned',
+      'namespace_id' => 'orphaned'
+    }
+    @strategy.stub :fetch_pod_metadata, @pod_meta do
+      @strategy.stub :fetch_namespace_metadata, {} do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time - 1 * 86_400, {}))
+      end
     end
-
-    test 'when metadata is not cached and no metadata can be fetched and not allowing orphans' do
-        # we should never see this since pod meta should not be retrievable
-        # unless the namespace exists
-        @strategy.stub :fetch_pod_metadata, @pod_meta do
-            @strategy.stub :fetch_namespace_metadata, {} do
-                assert_equal({}, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time - 1*86400, {}))
-            end
-        end
+  end
+
+  test 'when metadata is not cached and no metadata can be fetched and not allowing orphans for multiple records' do
+    # processing a batch of records with no meta. ideally we only hit the api server once
+    batch_miss_cache = {}
+    @strategy.stub :fetch_pod_metadata, {} do
+      @strategy.stub :fetch_namespace_metadata, {} do
+        assert_equal({}, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, batch_miss_cache))
+      end
     end
-
-    test 'when metadata is not cached and no metadata can be fetched and allowing orphans' do
-        # we should never see this since pod meta should not be retrievable
-        # unless the namespace exists
-        @strategy.allow_orphans = true
-        exp = {
-            'orphaned_namespace' => 'namespace',
-            'namespace_name' => '.orphaned',
-            'namespace_id' => 'orphaned'
-        }
-        @strategy.stub :fetch_pod_metadata, @pod_meta do
-            @strategy.stub :fetch_namespace_metadata, {} do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time - 1*86400, {}))
-            end
-        end
-    end
-
-    test 'when metadata is not cached and no metadata can be fetched and not allowing orphans for multiple records' do
-        # processing a batch of records with no meta. ideally we only hit the api server once
-        batch_miss_cache = {}
-        @strategy.stub :fetch_pod_metadata, {} do
-            @strategy.stub :fetch_namespace_metadata, {} do
-                assert_equal({}, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, batch_miss_cache))
-            end
-        end
-        assert_equal({}, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, batch_miss_cache))
-    end
-
-    test 'when metadata is not cached and no metadata can be fetched and allowing orphans for multiple records' do
-        # we should never see this since pod meta should not be retrievable
-        # unless the namespace exists
-        @strategy.allow_orphans = true
-        exp = {
-            'orphaned_namespace' => 'namespace',
-            'namespace_name' => '.orphaned',
-            'namespace_id' => 'orphaned'
-        }
-        batch_miss_cache = {}
-        @strategy.stub :fetch_pod_metadata, {}  do
-            @strategy.stub :fetch_namespace_metadata, {} do
-                assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, batch_miss_cache))
-            end
-        end
-        assert_equal(exp, @strategy.get_pod_metadata(@cache_key,'namespace', 'pod', @time, batch_miss_cache))
+    assert_equal({}, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, batch_miss_cache))
+  end
+
+  test 'when metadata is not cached and no metadata can be fetched and allowing orphans for multiple records' do
+    # we should never see this since pod meta should not be retrievable
+    # unless the namespace exists
+    @strategy.allow_orphans = true
+    exp = {
+      'orphaned_namespace' => 'namespace',
+      'namespace_name' => '.orphaned',
+      'namespace_id' => 'orphaned'
+    }
+    batch_miss_cache = {}
+    @strategy.stub :fetch_pod_metadata, {} do
+      @strategy.stub :fetch_namespace_metadata, {} do
+        assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, batch_miss_cache))
+      end
     end
+    assert_equal(exp, @strategy.get_pod_metadata(@cache_key, 'namespace', 'pod', @time, batch_miss_cache))
+  end
 end