kubetailrb 0.1.0 → 0.2.0

data/lib/kubetailrb/reader/k8s_pod_reader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/validated'
+require 'kubetailrb/filter/log_filter'
+require 'kubetailrb/formatter/json_formatter'
+require 'kubetailrb/formatter/no_op_formatter'
+require 'kubetailrb/formatter/pod_metadata_formatter'
+require_relative 'with_k8s_client'
+
+module Kubetailrb
+  module Reader
+    # Read Kubernetes pod logs.
+    class K8sPodReader
+      include Validated
+      include WithK8sClient
+
+      attr_reader :pod_name, :opts
+
+      def initialize(pod_name:, container_name:, opts:, k8s_client: nil)
+        validate(pod_name, container_name, opts)
+
+        @k8s_client = k8s_client
+        @pod_name = pod_name
+        @container_name = container_name
+        @formatter = create_formatter(opts, pod_name, container_name)
+        @filter = Kubetailrb::Filter::LogFilter.create(opts.exclude)
+        @opts = opts
+      end
+
+      def read
+        pod_logs = read_pod_logs
+        unless @opts.follow?
+          print_logs pod_logs
+          return
+        end
+
+        # NOTE: The watch method from kubeclient does not accept `tail_lines`
+        # argument, so I had to resort to some hack... by using the first log to
+        # print out. Not ideal, since it's not really the N last nb lines, and
+        # assume every logs are different, which may not be true.
+        # But it does the job for most cases.
+        first_log_to_display = pod_logs.to_s.split("\n").first
+        should_print_logs = false
+
+        k8s_client.watch_pod_log(@pod_name, @opts.namespace, container: @container_name) do |line|
+          # NOTE: Is it good practice to update a variable that is outside of a
+          # block? Can we do better?
+          should_print_logs = true if line == first_log_to_display
+
+          print_logs(line) if should_print_logs
+        end
+      end
+
+      private
+
+      def validate(pod_name, container_name, opts)
+        raise_if_blank pod_name, 'Pod name not set.'
+        raise_if_blank container_name, 'Container name not set.'
+        raise_if_nil opts, 'Opts not set.'
+      end
+
+      def print_logs(logs)
+        if logs.to_s.include?("\n")
+          logs.to_s.split("\n").each { |log| print_logs(log) }
+          return
+        end
+
+        puts @formatter.format(logs) if @filter.test(logs)
+        $stdout.flush
+      end
+
+      def read_pod_logs
+        # The pod may still not up/ready, so small hack to retry 120 times (number
+        # taken randomly) until the pod returns its logs.
+        120.times do
+          pod_logs = k8s_client.get_pod_log(
+            @pod_name,
+            @opts.namespace,
+            container: @container_name,
+            tail_lines: @opts.last_nb_lines
+          )
+
+          if pod_logs.to_s.split("\n").empty?
+            raise PodNotReadyError, "No log returned from #{@pod_name}/#{@container_name}"
+          end
+
+          return pod_logs
+        rescue Kubeclient::HttpError, PodNotReadyError => e
+          puts e.message
+          sleep 1
+        end
+      end
+
+      def create_formatter(opts, pod_name, container_name)
+        formatter = if opts.raw?
+                      Kubetailrb::Formatter::NoOpFormatter.new
+                    else
+                      Kubetailrb::Formatter::JsonFormatter.new
+                    end
+
+        if opts.display_names?
+          formatter = Kubetailrb::Formatter::PodMetadataFormatter.new(
+            pod_name,
+            container_name, formatter
+          )
+        end
+
+        formatter
+      end
+    end
+
+    class PodNotReadyError < RuntimeError
+    end
+  end
+end

data/lib/kubetailrb/reader/k8s_pods_reader.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/validated'
+require 'kubetailrb/k8s_opts'
+require_relative 'k8s_pod_reader'
+require_relative 'with_k8s_client'
+
+module Kubetailrb
+  module Reader
+    # Read multiple pod logs.
+    class K8sPodsReader
+      include Validated
+      include WithK8sClient
+      include Painter
+
+      attr_reader :pod_query, :container_query, :opts
+
+      def initialize(pod_query:, container_query:, opts:, k8s_client: nil)
+        validate(pod_query, container_query, opts)
+
+        @k8s_client = k8s_client
+        @pod_query = Regexp.new(pod_query)
+        @container_query = Regexp.new(container_query)
+        @opts = opts
+      end
+
+      def read
+        pods = find_pods
+        watch_for_new_pod_events if @opts.follow?
+
+        threads = pods.flat_map do |pod|
+          pod.spec.containers.select { |container| applicable_container?(container.name) }.map do |container|
+            # NOTE: How much memory does a Ruby Thread takes? Can we spawn hundreds
+            # to thoudsands of Threads without issue?
+            start_reading_pod_logs(pod.metadata.name, container.name)
+          end
+        end
+
+        # NOTE: '&:' is a shorthand way of calling 'join' method on each thread.
+        # It's equivalent to: threads.each { |thread| thread.join }
+        threads.each(&:join)
+      end
+
+      private
+
+      def validate(pod_query, container_query, opts)
+        raise_if_blank pod_query, 'Pod query not set.'
+        raise_if_blank container_query, 'Container query not set.'
+        raise_if_nil opts, 'Opts not set.'
+      end
+
+      def find_pods
+        k8s_client
+          .get_pods(namespace: @opts.namespace)
+          .select { |pod| applicable_pod?(pod) }
+      end
+
+      def create_reader(pod_name, container_name)
+        K8sPodReader.new(
+          k8s_client: k8s_client,
+          pod_name: pod_name,
+          container_name: container_name,
+          opts: @opts
+        )
+      end
+
+      #
+      # Watch any pod events, and if there's another pod that validates the pod
+      # query, then let's read the pod logs!
+      #
+      def watch_for_new_pod_events
+        k8s_client.watch_pods(namespace: @opts.namespace) do |notice|
+          next unless applicable_pod?(notice.object)
+
+          on_new_pod_event notice if new_pod_event?(notice)
+          on_deleted_pod_event notice if deleted_pod_event?(notice)
+        end
+      end
+
+      def applicable_pod?(pod)
+        pod.metadata.name.match?(@pod_query)
+      end
+
+      def applicable_container?(container_name)
+        container_name.match?(@container_query)
+      end
+
+      def new_pod_event?(notice)
+        notice.type == 'ADDED' && notice.object.kind == 'Pod'
+      end
+
+      def on_new_pod_event(notice) # rubocop:disable Metrics/AbcSize
+        # NOTE: We are in another thread (are we?), so no sense to use
+        # 'Thread.join' here.
+
+        notice.object.spec.containers.map do |container|
+          next unless applicable_container?(container.name)
+
+          # NOTE: How much memory does a Ruby Thread takes? Can we spawn hundreds
+          # to thoudsands of Threads without issue?
+          puts blue("+ #{notice.object.metadata.name}/#{container.name}")
+          start_reading_pod_logs(notice.object.metadata.name, container.name)
+        end
+      end
+
+      def start_reading_pod_logs(pod_name, container_name)
+        Thread.new { create_reader(pod_name, container_name).read }
+      end
+
+      def deleted_pod_event?(notice)
+        notice.type == 'DELETED' && notice.object.kind == 'Pod'
+      end
+
+      def on_deleted_pod_event(notice)
+        notice.object.spec.containers.map do |container|
+          next unless applicable_container?(container.name)
+
+          puts red("- #{notice.object.metadata.name}/#{container.name}")
+        end
+      end
+    end
+  end
+end

data/lib/kubetailrb/reader/with_k8s_client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'kubeclient'
+
+module Kubetailrb
+  module Reader
+    # Add behavior to get a k8s client by using composition.
+    # NOTE: Is it the idiomatic way? Or shall I use a factory? Or is there a
+    # better way?
+    module WithK8sClient
+      def k8s_client
+        @k8s_client ||= create_k8s_client
+      end
+
+      def create_k8s_client
+        config = Kubeclient::Config.read(ENV['KUBECONFIG'] || "#{ENV["HOME"]}/.kube/config")
+        context = config.context
+        Kubeclient::Client.new(
+          context.api_endpoint,
+          'v1',
+          ssl_options: context.ssl_options,
+          auth_options: context.auth_options
+        )
+      end
+    end
+  end
+end

data/lib/kubetailrb/validated.rb

@@ -7,6 +7,10 @@ module Kubetailrb
       raise ArgumentError, error_message if arg.nil? || arg.strip&.empty?
     end
 
+    def raise_if_nil(arg, error_message)
+      raise ArgumentError, error_message if arg.nil?
+    end
+
     def validate_last_nb_lines(last_nb_lines)
       last_nb_lines_valid = last_nb_lines.is_a?(Integer) && last_nb_lines.positive?
       raise ArgumentError, "Invalid last_nb_lines: #{last_nb_lines}." unless last_nb_lines_valid

data/lib/kubetailrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kubetailrb
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubetailrb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Louis Lin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 2024-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kubeclient
@@ -112,30 +112,30 @@ dependencies:
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.14.2
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.10.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.10.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -253,16 +253,19 @@ files:
 - lib/kubetailrb/cmd/help.rb
 - lib/kubetailrb/cmd/k8s.rb
 - lib/kubetailrb/cmd/version.rb
-- lib/kubetailrb/file_reader.rb
-- lib/kubetailrb/json_formatter.rb
+- lib/kubetailrb/filter/log_filter.rb
+- lib/kubetailrb/formatter/json_formatter.rb
+- lib/kubetailrb/formatter/no_op_formatter.rb
+- lib/kubetailrb/formatter/pod_metadata_formatter.rb
 - lib/kubetailrb/k8s_opts.rb
-- lib/kubetailrb/k8s_pod_reader.rb
-- lib/kubetailrb/k8s_pods_reader.rb
-- lib/kubetailrb/no_op_formatter.rb
 - lib/kubetailrb/opts_parser.rb
+- lib/kubetailrb/painter.rb
+- lib/kubetailrb/reader/file_reader.rb
+- lib/kubetailrb/reader/k8s_pod_reader.rb
+- lib/kubetailrb/reader/k8s_pods_reader.rb
+- lib/kubetailrb/reader/with_k8s_client.rb
 - lib/kubetailrb/validated.rb
 - lib/kubetailrb/version.rb
-- lib/kubetailrb/with_k8s_client.rb
 - sig/kubetailrb.rbs
 homepage: https://github.com/l-lin/kubetailrb
 licenses:

data/lib/kubetailrb/file_reader.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'validated'
-
-module Kubetailrb
-  # Read file content
-  class FileReader
-    include Validated
-
-    attr_reader :filepath, :last_nb_lines
-
-    def initialize(filepath:, last_nb_lines:, follow:)
-      @filepath = filepath
-      @last_nb_lines = last_nb_lines
-      @follow = follow
-
-      validate
-    end
-
-    def read
-      # naive_read
-      read_with_fd
-    end
-
-    # NOTE: Is there something like `attr_reader` but for boolean?
-    # Nope, Ruby does not know if a variable is a boolean or not. So it cannot
-    # create a dedicated method for those booleans.
-    def follow?
-      @follow
-    end
-
-    private
-
-    def validate
-      raise NoSuchFileError, "#{@filepath} not found" unless File.exist?(@filepath)
-
-      validate_last_nb_lines @last_nb_lines
-      validate_boolean @follow, "Invalid follow: #{@follow}."
-    end
-
-    #
-    # Naive implementation to read the last N lines of a file.
-    # Does not support `--follow`.
-    # Took ~1.41s to read a 3.1G file (5M lines).
-    #
-    def naive_read
-      # Let's us `wc` optimized to count the number of lines!
-      nb_lines = `wc -l #{@filepath}`.split.first.to_i
-
-      start = nb_lines - @last_nb_lines
-      i = 0
-
-      File.open(@filepath, 'r').each_line do |line|
-        puts line if i >= start
-        i += 1
-      end
-    end
-
-    #
-    # Use `seek` to start from the EOF.
-    # Use `read` to read the content of the file from the given position.
-    # src: https://renehernandez.io/tutorials/implementing-tail-command-in-ruby/
-    # Took ~0.13s to read a 3.1G file (5M lines).
-    #
-    def read_with_fd
-      file = File.open(@filepath)
-      update_stats file
-      read_last_nb_lines file
-
-      if @follow
-        loop do
-          if file_changed?(file)
-            update_stats(file)
-            print file.read
-          end
-        end
-      end
-    ensure
-      file&.close
-    end
-
-    def read_last_nb_lines(file)
-      return if File.empty?(file)
-
-      pos = 0
-      current_line_nb = 0
-
-      loop do
-        pos -= 1
-        # Seek file position from the end.
-        file.seek(pos, IO::SEEK_END)
-
-        # If we have reached the begining of the file, read all the file.
-        # We need to do this check before reading the next byte, otherwise, the
-        # cursor will be moved to 1.
-        break if file.tell.zero?
-
-        # Read only one character (or is it byte?).
-        char = file.read(1)
-        current_line_nb += 1 if char == "\n"
-
-        break if current_line_nb > @last_nb_lines
-      end
-
-      update_stats file
-      puts file.read
-    end
-
-    def update_stats(file)
-      @mtime = file.stat.mtime
-      @size = file.size
-    end
-
-    def file_changed?(file)
-      @mtime != file.stat.mtime || @size != file.size
-    end
-  end
-
-  # NOTE: We can create custom exceptions by extending RuntimeError.
-  class NoSuchFileError < RuntimeError
-  end
-end

data/lib/kubetailrb/json_formatter.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Kubetailrb
-  # Format JSON to human readable.
-  class JsonFormatter
-    def format(log)
-      json = JSON.parse(log)
-
-      return format_access_log(json) if access_log?(json)
-
-      format_application_log(json)
-    rescue JSON::ParserError
-      log
-    end
-
-    private
-
-    def access_log?(json)
-      json.include?('http.response.status_code')
-    end
-
-    def format_access_log(json)
-      "#{json["@timestamp"]}#{http_status_code json}#{json["http.request.method"]} #{json["url.path"]}"
-    end
-
-    def format_application_log(json)
-      "#{json["@timestamp"]}#{log_level json}#{json["message"]}"
-    end
-
-    def http_status_code(json)
-      code = json['http.response.status_code']
-
-      return "#{blue(" I ")}[#{code}] " if code >= 200 && code < 400
-      return "#{yellow(" W ")}[#{code}] " if code >= 400 && code < 500
-      return "#{red(" E ")}[#{code}] " if code > 500
-
-      " #{code} "
-    end
-
-    def log_level(json)
-      level = json['log.level']
-      return '' if level.nil? || level.strip.empty?
-      return blue(' I ') if level == 'INFO'
-      return yellow(' W ') if level == 'WARN'
-      return red(' E ') if level == 'ERROR'
-
-      " #{level} "
-    end
-
-    def colorize(text, color_code)
-      " \e[#{color_code}m#{text}\e[0m "
-    end
-
-    def blue(text)
-      colorize(text, '1;30;44')
-    end
-
-    def yellow(text)
-      colorize(text, '1;30;43')
-    end
-
-    def red(text)
-      colorize(text, '1;30;41')
-    end
-  end
-end

data/lib/kubetailrb/k8s_pod_reader.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'with_k8s_client'
-require_relative 'validated'
-require_relative 'json_formatter'
-
-module Kubetailrb
-  # Read Kubernetes pod logs.
-  class K8sPodReader
-    include Validated
-    include WithK8sClient
-
-    attr_reader :pod_name, :opts
-
-    def initialize(pod_name:, formatter:, opts:, k8s_client: nil)
-      validate(pod_name, formatter, opts)
-
-      @k8s_client = k8s_client
-      @pod_name = pod_name
-      @formatter = formatter
-      @opts = opts
-    end
-
-    def read
-      pod_logs = read_pod_logs
-      unless @opts.follow?
-        print_logs pod_logs
-        return
-      end
-
-      # NOTE: The watch method from kubeclient does not accept `tail_lines`
-      # argument, so I had to resort to some hack... by using the first log to
-      # print out. Not ideal, since it's not really the N last nb lines, and
-      # assume every logs are different, which may not be true.
-      # But it does the job for most cases.
-      first_log_to_display = pod_logs.to_s.split("\n").first
-      should_print_logs = false
-
-      k8s_client.watch_pod_log(@pod_name, @opts.namespace) do |line|
-        # NOTE: Is it good practice to update a variable that is outside of a
-        # block? Can we do better?
-        should_print_logs = true if line == first_log_to_display
-
-        print_logs(line) if should_print_logs
-      end
-    end
-
-    private
-
-    def validate(pod_name, formatter, opts)
-      raise_if_blank pod_name, 'Pod name not set.'
-
-      raise ArgumentError, 'Formatter not set.' if formatter.nil?
-
-      raise ArgumentError, 'Opts not set.' if opts.nil?
-    end
-
-    def print_logs(logs)
-      if logs.to_s.include?("\n")
-        logs.to_s.split("\n").each { |log| print_logs(log) }
-        return
-      end
-
-      if @opts.raw?
-        puts @formatter.format(logs)
-      else
-        puts "#{@pod_name} - #{@formatter.format logs}"
-      end
-      $stdout.flush
-    end
-
-    def read_pod_logs
-      # The pod may still not up/ready, so small hack to retry 120 times (number
-      # taken randomly) until the pod returns its logs.
-      120.times do
-        return k8s_client.get_pod_log(@pod_name, @opts.namespace, tail_lines: @opts.last_nb_lines)
-      rescue Kubeclient::HttpError => e
-        puts e.message
-        sleep 1
-      end
-    end
-  end
-end