fluent-plugin-kubernetes_metadata_filter 3.7.0 → 3.7.1

data/lib/fluent/plugin/kubernetes_metadata_cache_strategy.rb

@@ -18,14 +18,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 module KubernetesMetadata
   module CacheStrategy
-    def get_pod_metadata(key, namespace_name, pod_name, time, batch_miss_cache)
+    def get_pod_metadata(key, namespace_name, pod_name, time, batch_miss_cache) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       metadata = {}
       ids = @id_cache[key]
       if ids.nil?
         @stats.bump(:id_cache_miss)
-        return batch_miss_cache["#{namespace_name}_#{pod_name}"] if batch_miss_cache.key?("#{namespace_name}_#{pod_name}")
+        if batch_miss_cache.key?("#{namespace_name}_#{pod_name}")
+          return batch_miss_cache["#{namespace_name}_#{pod_name}"]
+        end
 
         pod_metadata = fetch_pod_metadata(namespace_name, pod_name)
         if @skip_namespace_metadata
@@ -33,27 +36,27 @@ module KubernetesMetadata
           @id_cache[key] = ids
           return pod_metadata
         end
+
         namespace_metadata = fetch_namespace_metadata(namespace_name)
         ids = { pod_id: pod_metadata['pod_id'], namespace_id: namespace_metadata['namespace_id'] }
         if !ids[:pod_id].nil? && !ids[:namespace_id].nil?
           # pod found and namespace found
-          metadata = pod_metadata
-          metadata.merge!(namespace_metadata)
+          metadata = pod_metadata.merge(namespace_metadata)
         else
-          if ids[:pod_id].nil? && !ids[:namespace_id].nil?
+          if ids[:pod_id].nil? && !ids[:namespace_id].nil? # rubocop:disable Style/IfInsideElse
             # pod not found, but namespace found
             @stats.bump(:id_cache_pod_not_found_namespace)
             ns_time = Time.parse(namespace_metadata['creation_timestamp'])
-            if ns_time <= Time.at(time.to_f)
+            if ns_time <= Time.at(time.to_f) # rubocop:disable Metrics/BlockNesting
               # namespace is older then record for pod
               ids[:pod_id] = key
               metadata = @cache.fetch(ids[:pod_id]) do
                 { 'pod_id' => ids[:pod_id] }
               end
             end
-            metadata.merge!(namespace_metadata)
+            metadata = metadata.merge(namespace_metadata)
           else
-            if !ids[:pod_id].nil? && ids[:namespace_id].nil?
+            if !ids[:pod_id].nil? && ids[:namespace_id].nil? # rubocop:disable Metrics/BlockNesting
               # pod found, but namespace NOT found
               # this should NEVER be possible since pod meta can
               # only be retrieved with a namespace
@@ -62,7 +65,7 @@ module KubernetesMetadata
               # nothing found
               @stats.bump(:id_cache_orphaned_record)
             end
-            if @allow_orphans
+            if @allow_orphans # rubocop:disable Metrics/BlockNesting
               log.trace("orphaning message for: #{namespace_name}/#{pod_name} ")
               metadata = {
                 'orphaned_namespace' => namespace_name,
@@ -83,13 +86,14 @@ module KubernetesMetadata
           m = fetch_pod_metadata(namespace_name, pod_name)
           m.nil? || m.empty? ? { 'pod_id' => ids[:pod_id] } : m
         end
-        metadata.merge!(@namespace_cache.fetch(ids[:namespace_id]) do
+        namespace_metadata = @namespace_cache.fetch(ids[:namespace_id]) do
           m = unless @skip_namespace_metadata
                 @stats.bump(:namespace_cache_miss)
                 fetch_namespace_metadata(namespace_name)
               end
           m.nil? || m.empty? ? { 'namespace_id' => ids[:namespace_id] } : m
-        end)
+        end
+        metadata = metadata.merge(namespace_metadata)
       end
 
       # remove namespace info that is only used for comparison

data/lib/fluent/plugin/kubernetes_metadata_common.rb

@@ -18,6 +18,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 module KubernetesMetadata
   module Common
     class GoneError < StandardError
@@ -30,18 +31,15 @@ module KubernetesMetadata
       result = {}
       @annotations_regexps.each do |regexp|
         annotations.each do |key, value|
-          if ::Fluent::StringUtil.match_regexp(regexp, key.to_s)
-            result[key] = value
-          end
+          result[key] = value if ::Fluent::StringUtil.match_regexp(regexp, key.to_s)
         end
       end
       result
     end
 
-    def parse_namespace_metadata(namespace_object)
+    def parse_namespace_metadata(namespace_object) # rubocop:disable Metrics/AbcSize
       labels = ''
-      labels = syms_to_strs(namespace_object[:metadata][:labels].to_h) unless (@skip_labels || @skip_namespace_labels)
-
+      labels = syms_to_strs(namespace_object[:metadata][:labels].to_h) unless @skip_labels || @skip_namespace_labels
       annotations = match_annotations(syms_to_strs(namespace_object[:metadata][:annotations].to_h))
 
       kubernetes_metadata = {
@@ -53,46 +51,48 @@ module KubernetesMetadata
       kubernetes_metadata
     end
 
-    def parse_pod_metadata(pod_object)
+    def parse_pod_metadata(pod_object) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       labels = ''
-      labels = syms_to_strs(pod_object[:metadata][:labels].to_h) unless (@skip_labels || @skip_pod_labels)
-
+      labels = syms_to_strs(pod_object[:metadata][:labels].to_h) unless @skip_labels || @skip_pod_labels
       annotations = match_annotations(syms_to_strs(pod_object[:metadata][:annotations].to_h))
 
       # collect container information
       container_meta = {}
       begin
-        pod_object[:status][:containerStatuses].each do |container_status|
-          container_id = (container_status[:containerID]||"").sub(%r{^[-_a-zA-Z0-9]+://}, '')
-          key = container_status[:name]
-          container_meta[key] = if @skip_container_metadata
-                                           {
-                                             'name' => container_status[:name]
-                                           }
-                                         else
-                                           {
-                                             'name' => container_status[:name],
-                                             'image' => container_status[:image],
-                                             'image_id' => container_status[:imageID],
-                                             :containerID => container_id
-                                           }
-                                         end
-        end if pod_object[:status] && pod_object[:status][:containerStatuses]
-      rescue StandardError=>e
-        log.warn("parsing container meta information failed for: #{pod_object[:metadata][:namespace]}/#{pod_object[:metadata][:name]}: #{e}")
+        if pod_object[:status] && pod_object[:status][:containerStatuses]
+          pod_object[:status][:containerStatuses].each do |container_status|
+            container_id = (container_status[:containerID] || '').sub(%r{^[-_a-zA-Z0-9]+://}, '')
+            key = container_status[:name]
+            container_meta[key] = if @skip_container_metadata
+                                    {
+                                      'name' => container_status[:name]
+                                    }
+                                  else
+                                    {
+                                      'name' => container_status[:name],
+                                      'image' => container_status[:image],
+                                      'image_id' => container_status[:imageID],
+                                      :containerID => container_id
+                                    }
+                                  end
+          end
+        end
+      rescue StandardError => e
+        log.warn("parsing container meta information failed for: #{pod_object[:metadata][:namespace]}/#{pod_object[:metadata][:name]}: #{e}") # rubocop:disable Layout/LineLength
       end
 
       ownerrefs_meta = []
-      begin
-        pod_object[:metadata][:ownerReferences].each do |owner_reference|
-          ownerrefs_meta.append({
-            'kind' => owner_reference[:kind],
-            'name' => owner_reference[:name]
-          })
+      if @include_ownerrefs_metadata && pod_object[:metadata][:ownerReferences]
+        begin
+          pod_object[:metadata][:ownerReferences].each do |owner_reference|
+            ownerrefs_meta.append({ 'kind' => owner_reference[:kind], 'name' => owner_reference[:name] })
+          end
+        rescue StandardError => e
+          log.warn(
+            "parsing ownerrefs meta information failed for: #{pod_object[:metadata][:namespace]}/#{pod_object[:metadata][:name]}: #{e}" # rubocop:disable Layout/LineLength
+          )
         end
-      rescue StandardError => e
-        log.warn("parsing ownerrefs meta information failed for: #{pod_object[:metadata][:namespace]}/#{pod_object[:metadata][:name]}: #{e}")
-      end if @include_ownerrefs_metadata && pod_object[:metadata][:ownerReferences]
+      end
 
       kubernetes_metadata = {
         'namespace_name' => pod_object[:metadata][:namespace],
@@ -103,8 +103,8 @@ module KubernetesMetadata
         'host' => pod_object[:spec][:nodeName],
         'ownerrefs' => (ownerrefs_meta if @include_ownerrefs_metadata)
       }.compact
-      kubernetes_metadata['annotations'] = annotations unless annotations.empty?
       kubernetes_metadata['labels'] = labels unless labels.empty?
+      kubernetes_metadata['annotations'] = annotations unless annotations.empty?
       kubernetes_metadata['master_url'] = @kubernetes_url unless @skip_master_url
       kubernetes_metadata
     end
@@ -112,9 +112,7 @@ module KubernetesMetadata
     def syms_to_strs(hsh)
       newhsh = {}
       hsh.each_pair do |kk, vv|
-        if vv.is_a?(Hash)
-          vv = syms_to_strs(vv)
-        end
+        vv = syms_to_strs(vv) if vv.is_a?(Hash)
         if kk.is_a?(Symbol)
           newhsh[kk.to_s] = vv
         else

data/lib/fluent/plugin/kubernetes_metadata_stats.rb

@@ -18,7 +18,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 require 'lru_redux'
+
 module KubernetesMetadata
   class Stats
     def initialize
@@ -38,15 +40,11 @@ module KubernetesMetadata
     end
 
     def to_s
-      'stats - ' + [].tap do |a|
-        @stats.each { |k, v| a << "#{k}: #{v}" }
-      end.join(', ')
+      "stats - #{@stats.to_a.map { |k, v| "#{k}: #{v}" }.join(', ')}"
     end
   end
-  class NoOpStats
-    def initialize
-    end
 
+  class NoOpStats
     def bump(key)
     end
 

data/lib/fluent/plugin/kubernetes_metadata_test_api_adapter.rb

@@ -18,51 +18,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 require 'kubeclient'
 
 module KubernetesMetadata
-    module TestApiAdapter
-      
-      def api_valid?
-        true
-      end
-      def get_namespace(namespace_name, unused, options)
-        return {
-          metadata: {
-            name: namespace_name,
-            uid: namespace_name + 'uuid',
-            labels: {
-              foo_ns: 'bar_ns'
-            }
+  module TestApiAdapter
+    def api_valid?
+      true
+    end
+
+    def get_namespace(namespace_name, _unused, _options)
+      {
+        metadata: {
+          name: namespace_name,
+          uid: "#{namespace_name}uuid",
+          labels: {
+            foo_ns: 'bar_ns'
           }
         }
-      end
+      }
+    end
 
-      def get_pod(pod_name, namespace_name, options)
-        return {
-          metadata: {
-            name: pod_name,
-            namespace: namespace_name,
-            uid: namespace_name + namespace_name + "uuid",
-            labels: {
-              foo: 'bar'
-            }
-          },
-          spec: {
-            nodeName: 'aNodeName',
-            containers: [{
+    def get_pod(pod_name, namespace_name, _options) # rubocop:disable Metrics/MethodLength
+      {
+        metadata: {
+          name: pod_name,
+          namespace: namespace_name,
+          uid: "#{namespace_name}#{namespace_name}uuid",
+          labels: {
+            foo: 'bar'
+          }
+        },
+        spec: {
+          nodeName: 'aNodeName',
+          containers: [
+            {
               name: 'foo',
               image: 'bar'
-            }, {
+            },
+            {
               name: 'bar',
               image: 'foo'
-            }]
-          },
-          status: {
-            podIP: '172.17.0.8'
-          }
+            }
+          ]
+        },
+        status: {
+          podIP: '172.17.0.8'
         }
-      end
-
+      }
     end
-end
+  end
+end

data/lib/fluent/plugin/kubernetes_metadata_watch_namespaces.rb

@@ -18,14 +18,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 # TODO: this is mostly copy-paste from kubernetes_metadata_watch_pods.rb unify them
 require_relative 'kubernetes_metadata_common'
 
 module KubernetesMetadata
-  module WatchNamespaces
+  module WatchNamespaces # rubocop:disable Metrics/ModuleLength
     include ::KubernetesMetadata::Common
 
-    def set_up_namespace_thread
+    def set_up_namespace_thread # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
       # Any failures / exceptions in the initial setup should raise
       # Fluent:ConfigError, so that users can inspect potential errors in
       # the configuration.
@@ -37,7 +38,7 @@ 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.
-      loop do
+      loop do # rubocop:disable Metrics/BlockLength
         namespace_watcher ||= get_namespaces_and_start_watcher
         process_namespace_watcher_notices(namespace_watcher)
       rescue GoneError => e
@@ -50,7 +51,7 @@ module KubernetesMetadata
         if e.error_code == 401
           # recreate client to refresh token
           log.info("Encountered '401 Unauthorized' exception in watch, recreating client to refresh token")
-          create_client()
+          create_client
           namespace_watcher = nil
         else
           # treat all other errors the same as StandardError, log, swallow and reset
@@ -62,7 +63,8 @@ module KubernetesMetadata
               'Exception encountered parsing namespace watch event. ' \
               'The connection might have been closed. Sleeping for ' \
               "#{Thread.current[:namespace_watch_retry_backoff_interval]} " \
-              'seconds and resetting the namespace watcher.', e
+              'seconds and resetting the namespace watcher.',
+              e
             )
             sleep(Thread.current[:namespace_watch_retry_backoff_interval])
             Thread.current[:namespace_watch_retry_count] += 1
@@ -88,7 +90,8 @@ module KubernetesMetadata
             'Exception encountered parsing namespace watch event. ' \
             'The connection might have been closed. Sleeping for ' \
             "#{Thread.current[:namespace_watch_retry_backoff_interval]} " \
-            'seconds and resetting the namespace watcher.', e
+            'seconds and resetting the namespace watcher.',
+            e
           )
           sleep(Thread.current[:namespace_watch_retry_backoff_interval])
           Thread.current[:namespace_watch_retry_count] += 1
@@ -121,11 +124,11 @@ module KubernetesMetadata
 
     # List all namespaces, record the resourceVersion and return a watcher
     # starting from that resourceVersion.
-    def get_namespaces_and_start_watcher
+    def get_namespaces_and_start_watcher # rubocop:disable Metrics/MethodLength, Naming/AccessorMethodName
       options = {
         resource_version: '0' # Fetch from API server cache instead of etcd quorum read
       }
-      namespaces = @client.get_namespaces(options)
+      namespaces = @client.get_namespaces(**options)
       namespaces[:items].each do |namespace|
         cache_key = namespace[:metadata][:uid]
         @namespace_cache[cache_key] = parse_namespace_metadata(namespace)
@@ -135,7 +138,7 @@ module KubernetesMetadata
       # continue watching from most recent resourceVersion
       options[:resource_version] = namespaces[:metadata][:resourceVersion]
 
-      watcher = @client.watch_namespaces(options)
+      watcher = @client.watch_namespaces(**options)
       reset_namespace_watch_retry_stats
       watcher
     end
@@ -148,13 +151,13 @@ module KubernetesMetadata
     end
 
     # Process a watcher notice and potentially raise an exception.
-    def process_namespace_watcher_notices(watcher)
-      watcher.each do |notice|
+    def process_namespace_watcher_notices(watcher) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      watcher.each do |notice| # rubocop:disable Metrics/BlockLength
         case notice[:type]
         when 'MODIFIED'
           reset_namespace_watch_retry_stats
           cache_key = notice[:object][:metadata][:uid]
-          cached    = @namespace_cache[cache_key]
+          cached = @namespace_cache[cache_key]
           if cached
             @namespace_cache[cache_key] = parse_namespace_metadata(notice[:object])
             @stats.bump(:namespace_cache_watch_updates)

data/lib/fluent/plugin/kubernetes_metadata_watch_pods.rb

@@ -18,14 +18,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 # TODO: this is mostly copy-paste from kubernetes_metadata_watch_namespaces.rb unify them
 require_relative 'kubernetes_metadata_common'
 
 module KubernetesMetadata
-  module WatchPods
+  module WatchPods # rubocop:disable Metrics/ModuleLength
     include ::KubernetesMetadata::Common
 
-    def set_up_pod_thread
+    def set_up_pod_thread # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
       # Any failures / exceptions in the initial setup should raise
       # Fluent:ConfigError, so that users can inspect potential errors in
       # the configuration.
@@ -38,7 +39,7 @@ 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.
-      loop do
+      loop do # rubocop:disable Metrics/BlockLength
         pod_watcher ||= get_pods_and_start_watcher
         process_pod_watcher_notices(pod_watcher)
       rescue GoneError => e
@@ -51,7 +52,7 @@ module KubernetesMetadata
         if e.error_code == 401
           # recreate client to refresh token
           log.info("Encountered '401 Unauthorized' exception in watch, recreating client to refresh token")
-          create_client()
+          create_client
           pod_watcher = nil
         else
           # treat all other errors the same as StandardError, log, swallow and reset
@@ -63,7 +64,8 @@ module KubernetesMetadata
               '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
+              'seconds and resetting the pod watcher.',
+              e
             )
             sleep(Thread.current[:pod_watch_retry_backoff_interval])
             Thread.current[:pod_watch_retry_count] += 1
@@ -89,7 +91,8 @@ module KubernetesMetadata
             '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
+            'seconds and resetting the pod watcher.',
+            e
           )
           sleep(Thread.current[:pod_watch_retry_backoff_interval])
           Thread.current[:pod_watch_retry_count] += 1
@@ -122,17 +125,15 @@ module KubernetesMetadata
 
     # List all pods, record the resourceVersion and return a watcher starting
     # from that resourceVersion.
-    def get_pods_and_start_watcher
+    def get_pods_and_start_watcher # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Naming/AccessorMethodName
       options = {
         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']
-      end
+      options[:field_selector] = "spec.nodeName=#{ENV['K8S_NODE_NAME']}" if ENV['K8S_NODE_NAME']
       if @last_seen_resource_version
         options[:resource_version] = @last_seen_resource_version
       else
-        pods = @client.get_pods(options)
+        pods = @client.get_pods(**options)
         pods[:items].each do |pod|
           cache_key = pod[:metadata][:uid]
           @cache[cache_key] = parse_pod_metadata(pod)
@@ -143,7 +144,7 @@ module KubernetesMetadata
         options[:resource_version] = pods[:metadata][:resourceVersion]
       end
 
-      watcher = @client.watch_pods(options)
+      watcher = @client.watch_pods(**options)
       reset_pod_watch_retry_stats
       watcher
     end
@@ -156,19 +157,19 @@ module KubernetesMetadata
     end
 
     # Process a watcher notice and potentially raise an exception.
-    def process_pod_watcher_notices(watcher)
-      watcher.each do |notice|
+    def process_pod_watcher_notices(watcher) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      watcher.each do |notice| # rubocop:disable Metrics/BlockLength
         # store version we processed to not reprocess it ... do not unset when there is no version in response
-        version = ( # TODO: replace with &.dig once we are on ruby 2.5+
+        version = # TODO: replace with &.dig once we are on ruby 2.5+
           notice[:object] && notice[:object][:metadata] && notice[:object][:metadata][:resourceVersion]
-        )
+
         @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]
+          cached = @cache[cache_key]
           if cached
             @cache[cache_key] = parse_pod_metadata(notice[:object])
             @stats.bump(:pod_cache_watch_updates)