fluent-plugin-kubernetes_metadata_filter 2.5.3 → 2.7.2

data/lib/fluent/plugin/kubernetes_metadata_cache_strategy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -21,31 +23,20 @@ module KubernetesMetadata
     def get_pod_metadata(key, namespace_name, pod_name, record_create_time, batch_miss_cache)
       metadata = {}
       ids = @id_cache[key]
-      if !ids.nil?
+      if ids.nil?
         # FAST PATH
         # Cache hit, fetch metadata from the cache
-        metadata = @cache.fetch(ids[:pod_id]) do
-          @stats.bump(:pod_cache_miss)
-          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
-          @stats.bump(:namespace_cache_miss)
-          m = fetch_namespace_metadata(namespace_name) unless @skip_namespace_metadata
-          (m.nil? || m.empty?) ?  {'namespace_id'=>ids[:namespace_id]} : m
-        end)
-      else
-        # SLOW PATH
         @stats.bump(:id_cache_miss)
         return batch_miss_cache["#{namespace_name}_#{pod_name}"] if batch_miss_cache.key?("#{namespace_name}_#{pod_name}")
+
         pod_metadata = fetch_pod_metadata(namespace_name, pod_name)
         if @skip_namespace_metadata
-          ids = { :pod_id=> pod_metadata['pod_id'] }
+          ids = { pod_id: pod_metadata['pod_id'] }
           @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'] }
+        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
@@ -59,7 +50,7 @@ module KubernetesMetadata
               # namespace is older then record for pod
               ids[:pod_id] = key
               metadata = @cache.fetch(ids[:pod_id]) do
-                m = { 'pod_id' => ids[:pod_id] }
+                { 'pod_id' => ids[:pod_id] }
               end
             end
             metadata.merge!(namespace_metadata)
@@ -87,12 +78,25 @@ module KubernetesMetadata
           end
         end
         @id_cache[key] = ids unless batch_miss_cache.key?("#{namespace_name}_#{pod_name}")
+      else
+        # SLOW PATH
+        metadata = @cache.fetch(ids[:pod_id]) do
+          @stats.bump(:pod_cache_miss)
+          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
+          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
 
       # remove namespace info that is only used for comparison
       metadata.delete('creation_timestamp')
-      metadata.delete_if{|k,v| v.nil?}
+      metadata.delete_if { |_k, v| v.nil? }
     end
-
   end
 end

data/lib/fluent/plugin/kubernetes_metadata_common.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -18,9 +20,8 @@
 #
 module KubernetesMetadata
   module Common
-
     class GoneError < StandardError
-      def initialize(msg="410 Gone")
+      def initialize(msg = '410 Gone')
         super
       end
     end
@@ -38,13 +39,13 @@ module KubernetesMetadata
     end
 
     def parse_namespace_metadata(namespace_object)
-      labels = String.new
+      labels = ''
       labels = syms_to_strs(namespace_object[:metadata][:labels].to_h) unless @skip_labels
 
       annotations = match_annotations(syms_to_strs(namespace_object[:metadata][:annotations].to_h))
       if @de_dot
-        self.de_dot!(labels) unless @skip_labels
-        self.de_dot!(annotations)
+        de_dot!(labels) unless @skip_labels
+        de_dot!(annotations)
       end
       kubernetes_metadata = {
         'namespace_id' => namespace_object[:metadata][:uid],
@@ -56,43 +57,44 @@ module KubernetesMetadata
     end
 
     def parse_pod_metadata(pod_object)
-      labels = String.new
+      labels = ''
       labels = syms_to_strs(pod_object[:metadata][:labels].to_h) unless @skip_labels
 
       annotations = match_annotations(syms_to_strs(pod_object[:metadata][:annotations].to_h))
       if @de_dot
-        self.de_dot!(labels) unless @skip_labels
-        self.de_dot!(annotations)
+        de_dot!(labels) unless @skip_labels
+        de_dot!(annotations)
       end
 
       # collect container information
       container_meta = {}
       begin
-        pod_object[:status][:containerStatuses].each do|container_status|
+        pod_object[:status][:containerStatuses].each do |container_status|
           # get plain container id (eg. docker://hash -> hash)
-          container_id = container_status[:containerID].sub /^[-_a-zA-Z0-9]+:\/\//, ''
-          unless @skip_container_metadata
-            container_meta[container_id] = {
-                'name' => container_status[:name],
-                'image' => container_status[:image],
-                'image_id' => container_status[:imageID]
-            }
-          else
-            container_meta[container_id] = {
-                'name' => container_status[:name]
-            }
-          end
+          container_id = container_status[:containerID].sub(%r{^[-_a-zA-Z0-9]+://}, '')
+          container_meta[container_id] = if @skip_container_metadata
+                                           {
+                                             'name' => container_status[:name]
+                                           }
+                                         else
+                                           {
+                                             'name' => container_status[:name],
+                                             'image' => container_status[:image],
+                                             'image_id' => container_status[:imageID]
+                                           }
+                                         end
         end
-      rescue
+      rescue StandardError
         log.debug("parsing container meta information failed for: #{pod_object[:metadata][:namespace]}/#{pod_object[:metadata][:name]} ")
       end
 
       kubernetes_metadata = {
-          'namespace_name' => pod_object[:metadata][:namespace],
-          'pod_id'         => pod_object[:metadata][:uid],
-          'pod_name'       => pod_object[:metadata][:name],
-          'containers'     => syms_to_strs(container_meta),
-          'host'           => pod_object[:spec][:nodeName]
+        'namespace_name' => pod_object[:metadata][:namespace],
+        'pod_id' => pod_object[:metadata][:uid],
+        'pod_name' => pod_object[:metadata][:name],
+        'pod_ip' => pod_object[:status][:podIP],
+        'containers' => syms_to_strs(container_meta),
+        'host' => pod_object[:spec][:nodeName]
       }
       kubernetes_metadata['annotations'] = annotations unless annotations.empty?
       kubernetes_metadata['labels'] = labels unless labels.empty?
@@ -102,7 +104,7 @@ module KubernetesMetadata
 
     def syms_to_strs(hsh)
       newhsh = {}
-      hsh.each_pair do |kk,vv|
+      hsh.each_pair do |kk, vv|
         if vv.is_a?(Hash)
           vv = syms_to_strs(vv)
         end
@@ -114,6 +116,5 @@ module KubernetesMetadata
       end
       newhsh
     end
-
   end
 end

data/lib/fluent/plugin/kubernetes_metadata_stats.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -19,17 +21,16 @@
 require 'lru_redux'
 module KubernetesMetadata
   class Stats
-
     def initialize
       @stats = ::LruRedux::TTL::ThreadSafeCache.new(1000, 3600)
     end
 
     def bump(key)
-        @stats[key] = @stats.getset(key) { 0 } + 1
+      @stats[key] = @stats.getset(key) { 0 } + 1
     end
 
     def set(key, value)
-       @stats[key] = value
+      @stats[key] = value
     end
 
     def [](key)
@@ -37,10 +38,9 @@ module KubernetesMetadata
     end
 
     def to_s
-      "stats - " + [].tap do |a|
-          @stats.each {|k,v| a << "#{k.to_s}: #{v}"}
+      'stats - ' + [].tap do |a|
+        @stats.each { |k, v| a << "#{k}: #{v}" }
       end.join(', ')
     end
-
   end
 end

data/lib/fluent/plugin/kubernetes_metadata_test_api_adapter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+#
+# Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
+# Kubernetes metadata
+#
+# Copyright 2021 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# 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)
+        return {
+          metadata: {
+            name: namespace_name,
+            uid: namespace_name + 'uuid',
+            labels: {
+              foo_ns: 'bar_ns'
+            }
+          }
+        }
+      end
+
+      def get_pod(pod_name, namespace_name)
+        return {
+          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'
+          }
+        }
+      end
+
+    end
+end

data/lib/fluent/plugin/kubernetes_metadata_util.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+#
+# Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
+# Kubernetes metadata
+#
+# Copyright 2021 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module KubernetesMetadata
+  module Util
+    def create_time_from_record(record, internal_time)
+      time_key = @time_fields.detect { |ii| record.key?(ii) }
+      time = record[time_key]
+      if time.nil? || time.is_a?(String) && time.chop.empty?
+        # `internal_time` is a Fluent::EventTime, it can't compare with Time.
+        return Time.at(internal_time.to_f)
+      end
+
+      if ['_SOURCE_REALTIME_TIMESTAMP', '__REALTIME_TIMESTAMP'].include?(time_key)
+        timei = time.to_i
+        return Time.at(timei / 1_000_000, timei % 1_000_000)
+      end
+      return Time.at(time) if time.is_a?(Numeric)
+
+      Time.parse(time)
+    end
+  end
+end
+
+#https://stackoverflow.com/questions/5622435/how-do-i-convert-a-ruby-class-name-to-a-underscore-delimited-symbol
+class String
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '_')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/fluent/plugin/kubernetes_metadata_watch_namespaces.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Fluentd Kubernetes Metadata Filter Plugin - Enrich Fluentd events with
 # Kubernetes metadata
@@ -21,7 +23,6 @@ require_relative 'kubernetes_metadata_common'
 
 module KubernetesMetadata
   module WatchNamespaces
-
     include ::KubernetesMetadata::Common
 
     def set_up_namespace_thread
@@ -36,48 +37,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
-          namespace_watcher ||= get_namespaces_and_start_watcher
-          process_namespace_watcher_notices(namespace_watcher)
-        rescue GoneError => e
-          # Expected error. Quietly go back through the loop in order to
-          # start watching from the latest resource versions
-          @stats.bump(:namespace_watch_gone_errors)
-          log.info("410 Gone encountered. Restarting namespace watch to reset resource versions.", e)
+      loop do
+        namespace_watcher ||= get_namespaces_and_start_watcher
+        process_namespace_watcher_notices(namespace_watcher)
+      rescue GoneError => e
+        # Expected error. Quietly go back through the loop in order to
+        # start watching from the latest resource versions
+        @stats.bump(:namespace_watch_gone_errors)
+        log.info('410 Gone encountered. Restarting namespace watch to reset resource versions.', e)
+        namespace_watcher = nil
+      rescue StandardError => e
+        @stats.bump(:namespace_watch_failures)
+        if Thread.current[:namespace_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 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
+          )
+          sleep(Thread.current[:namespace_watch_retry_backoff_interval])
+          Thread.current[:namespace_watch_retry_count] += 1
+          Thread.current[:namespace_watch_retry_backoff_interval] *= @watch_retry_exponential_backoff_base
           namespace_watcher = nil
-        rescue => e
-          @stats.bump(:namespace_watch_failures)
-          if Thread.current[:namespace_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 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)
-            sleep(Thread.current[:namespace_watch_retry_backoff_interval])
-            Thread.current[:namespace_watch_retry_count] += 1
-            Thread.current[:namespace_watch_retry_backoff_interval] *= @watch_retry_exponential_backoff_base
-            namespace_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 namespace 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 namespace 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_namespace_watch
       get_namespaces_and_start_watcher
-    rescue => e
-      message = "start_namespace_watch: Exception encountered setting up " \
+    rescue StandardError => e
+      message = 'start_namespace_watch: Exception encountered setting up ' \
                 "namespace watch from Kubernetes API #{@apiVersion} endpoint " \
                 "#{@kubernetes_url}: #{e.message}"
       message += " (#{e.response})" if e.respond_to?(:response)
@@ -90,7 +90,7 @@ module KubernetesMetadata
     # starting from that resourceVersion.
     def get_namespaces_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
       }
       namespaces = @client.get_namespaces(options)
       namespaces[:items].each do |namespace|
@@ -118,35 +118,35 @@ module KubernetesMetadata
     def process_namespace_watcher_notices(watcher)
       watcher.each do |notice|
         case notice[:type]
-          when 'MODIFIED'
-            reset_namespace_watch_retry_stats
-            cache_key = notice[:object][:metadata][:uid]
-            cached    = @namespace_cache[cache_key]
-            if cached
-              @namespace_cache[cache_key] = parse_namespace_metadata(notice[:object])
-              @stats.bump(:namespace_cache_watch_updates)
-            else
-              @stats.bump(:namespace_cache_watch_misses)
-            end
-          when 'DELETED'
-            reset_namespace_watch_retry_stats
-            # ignore and let age out for cases where
-            # deleted but still processing logs
-            @stats.bump(:namespace_cache_watch_deletes_ignored)
-          when 'ERROR'
-            if notice[:object] && notice[:object][:code] == 410
-              @stats.bump(:namespace_watch_gone_notices)
-              raise GoneError
-            else
-              @stats.bump(:namespace_watch_error_type_notices)
-              message = notice[:object][:message] if notice[:object] && notice[:object][:message]
-              raise "Error while watching namespaces: #{message}"
-            end
+        when 'MODIFIED'
+          reset_namespace_watch_retry_stats
+          cache_key = notice[:object][:metadata][:uid]
+          cached    = @namespace_cache[cache_key]
+          if cached
+            @namespace_cache[cache_key] = parse_namespace_metadata(notice[:object])
+            @stats.bump(:namespace_cache_watch_updates)
           else
-            reset_namespace_watch_retry_stats
-            # Don't pay attention to creations, since the created namespace may not
-            # be used by any namespace on this node.
-            @stats.bump(:namespace_cache_watch_ignored)
+            @stats.bump(:namespace_cache_watch_misses)
+          end
+        when 'DELETED'
+          reset_namespace_watch_retry_stats
+          # ignore and let age out for cases where
+          # deleted but still processing logs
+          @stats.bump(:namespace_cache_watch_deletes_ignored)
+        when 'ERROR'
+          if notice[:object] && notice[:object][:code] == 410
+            @stats.bump(:namespace_watch_gone_notices)
+            raise GoneError
+          else
+            @stats.bump(:namespace_watch_error_type_notices)
+            message = notice[:object][:message] if notice[:object] && notice[:object][:message]
+            raise "Error while watching namespaces: #{message}"
+          end
+        else
+          reset_namespace_watch_retry_stats
+          # Don't pay attention to creations, since the created namespace may not
+          # be used by any namespace on this node.
+          @stats.bump(:namespace_cache_watch_ignored)
         end
       end
     end