kubetailrb 0.1.0

data/lib/kubetailrb/cmd/help.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kubetailrb
+  module Cmd
+    # Display help.
+    class Help
+      FLAGS = %w[-h --help].freeze
+
+      def execute
+        puts <<~HELP
+          Tail your Kubernetes pod logs at the same time.
+
+          Usage:
+            kubetailrb pod-query [flags]
+
+          Flags:
+            -v, --version   Display version.
+            -h, --help      Display help.
+                --tail      The number of lines from the end of the logs to show. Defaults to 10.
+            -f, --follow    Output appended data as the file grows.
+                --file      Display file content.
+            -p, --pretty    Pretty print JSON logs.
+            -r, --raw       Only display pod logs.
+            -n, --namespace Kubernetes namespace to use.
+        HELP
+      end
+
+      class << self
+        def applicable?(*args)
+          missing_args?(*args) || contains_flags?(*args)
+        end
+
+        private
+
+        def missing_args?(*args)
+          args.nil? || args.empty?
+        end
+
+        def contains_flags?(*args)
+          args.any? { |arg| FLAGS.include?(arg) }
+        end
+      end
+    end
+  end
+end

data/lib/kubetailrb/cmd/k8s.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/k8s_pods_reader'
+require 'kubetailrb/json_formatter'
+require 'kubetailrb/no_op_formatter'
+
+module Kubetailrb
+  module Cmd
+    # Command to read k8s pod logs.
+    class K8s
+      DEFAULT_NB_LINES = 10
+      DEFAULT_NAMESPACE = 'default'
+
+      NAMESPACE_FLAGS = %w[-n --namespace].freeze
+      TAIL_FLAG = '--tail'
+      FOLLOW_FLAGS = %w[-f --follow].freeze
+      RAW_FLAGS = %w[-r --raw].freeze
+      PRETTY_PRINT_FLAGS = %w[-p --pretty].freeze
+
+      attr_reader :reader
+
+      def initialize(pod_query:, opts:, formatter:)
+        @reader = Kubetailrb::K8sPodsReader.new(pod_query: pod_query, formatter: formatter, opts: opts)
+      end
+
+      def execute
+        @reader.read
+      end
+
+      class << self
+        def create(*args)
+          new(
+            pod_query: parse_pod_query(*args),
+            formatter: parse_pretty_print(*args) ? Kubetailrb::JsonFormatter.new : Kubetailrb::NoOpFormatter.new,
+            opts: K8sOpts.new(
+              namespace: parse_namespace(*args),
+              last_nb_lines: parse_nb_lines(*args),
+              follow: parse_follow(*args),
+              raw: parse_raw(*args)
+            )
+          )
+        end
+
+        def parse_pod_query(*args)
+          # TODO: We could be smarter here? For example, if the pod names are
+          # provided at the end of the command, like this:
+          #   kubetailrb --tail 3 some-pod
+          # The above command will not work because this method will return 3
+          # instead of 'some-pod'...
+          args.find { |arg| !arg.start_with? '-' }
+        end
+
+        #
+        # Parse k8s namespace from arguments provided in the CLI, e.g.
+        #
+        #   kubetailrb some-pod -n sandbox
+        #
+        # will return 'sandbox'.
+        #
+        # Will raise `MissingNamespaceValueError` if the value is not provided:
+        #
+        #   kubetailrb some-pod -n
+        #
+        def parse_namespace(*args)
+          return DEFAULT_NAMESPACE unless args.any? { |arg| NAMESPACE_FLAGS.include?(arg) }
+
+          index = args.find_index { |arg| NAMESPACE_FLAGS.include?(arg) }.to_i
+
+          raise MissingNamespaceValueError, "Missing #{NAMESPACE_FLAGS} value." if args[index + 1].nil?
+
+          args[index + 1]
+        end
+
+        #
+        # Parse nb lines from arguments provided in the CLI, e.g.
+        #
+        #   kubetailrb some-pod --tail 3
+        #
+        # will return 3.
+        #
+        # Will raise `MissingNbLinesValueError` if the value is not provided:
+        #
+        #   kubetailrb some-pod --tail
+        #
+        # Will raise `InvalidNbLinesValueError` if the provided value is not a
+        # number:
+        #
+        #   kubetailrb some-pod --tail some-string
+        #
+        def parse_nb_lines(*args)
+          return DEFAULT_NB_LINES unless args.include?(TAIL_FLAG)
+
+          index = args.find_index { |arg| arg == TAIL_FLAG }.to_i
+
+          raise MissingNbLinesValueError, "Missing #{TAIL_FLAG} value." if args[index + 1].nil?
+
+          last_nb_lines = args[index + 1].to_i
+
+          raise InvalidNbLinesValueError, "Invalid #{TAIL_FLAG} value: #{args[index + 1]}." if last_nb_lines.zero?
+
+          last_nb_lines
+        end
+
+        def parse_follow(*args)
+          args.any? { |arg| FOLLOW_FLAGS.include?(arg) }
+        end
+
+        def parse_raw(*args)
+          args.any? { |arg| RAW_FLAGS.include?(arg) }
+        end
+
+        def parse_pretty_print(*args)
+          args.any? { |arg| PRETTY_PRINT_FLAGS.include?(arg) }
+        end
+      end
+    end
+
+    class MissingNbLinesValueError < RuntimeError
+    end
+
+    class MissingNamespaceValueError < RuntimeError
+    end
+
+    class InvalidNbLinesValueError < RuntimeError
+    end
+  end
+end

data/lib/kubetailrb/cmd/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kubetailrb
+  module Cmd
+    # Get application version.
+    class Version
+      FLAGS = %w[-v --version].freeze
+
+      def execute
+        puts VERSION
+      end
+
+      def self.applicable?(*args)
+        args.any? { |arg| FLAGS.include?(arg) }
+      end
+    end
+  end
+end

data/lib/kubetailrb/file_reader.rb

@@ -0,0 +1,122 @@
+# 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

@@ -0,0 +1,66 @@
+# 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_opts.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'validated'
+
+module Kubetailrb
+  # Options to use for reading k8s pod logs.
+  class K8sOpts
+    include Validated
+
+    attr_reader :namespace, :last_nb_lines
+
+    def initialize(namespace:, last_nb_lines:, follow:, raw:)
+      @namespace = namespace
+      @last_nb_lines = last_nb_lines
+      @follow = follow
+      @raw = raw
+
+      validate
+    end
+
+    def follow?
+      @follow
+    end
+
+    def raw?
+      @raw
+    end
+
+    private
+
+    def validate
+      raise_if_blank @namespace, 'Namespace not set.'
+      validate_last_nb_lines @last_nb_lines
+      validate_boolean @follow, "Invalid follow: #{@follow}."
+      validate_boolean @raw, "Invalid raw: #{@raw}."
+    end
+  end
+end

data/lib/kubetailrb/k8s_pod_reader.rb

@@ -0,0 +1,83 @@
+# 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

data/lib/kubetailrb/k8s_pods_reader.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'k8s_opts'
+require_relative 'k8s_pod_reader'
+require_relative 'with_k8s_client'
+
+module Kubetailrb
+  # Read multiple pod logs.
+  class K8sPodsReader
+    include Validated
+    include WithK8sClient
+
+    attr_reader :pod_query, :opts
+
+    def initialize(pod_query:, formatter:, opts:, k8s_client: nil)
+      validate(pod_query, formatter, opts)
+
+      @k8s_client = k8s_client
+      @pod_query = Regexp.new(pod_query)
+      @formatter = formatter
+      @opts = opts
+    end
+
+    def read
+      pods = find_pods
+      watch_for_new_pod_events if @opts.follow?
+
+      threads = pods.map do |pod|
+        # NOTE: How much memory does a Ruby Thread takes? Can we spawn hundreds
+        # to thoudsands of Threads without issue?
+        Thread.new { create_reader(pod.metadata.name).read }
+      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, formatter, opts)
+      raise_if_blank pod_query, 'Pod query not set.'
+
+      raise ArgumentError, 'Formatter not set.' if formatter.nil?
+
+      raise ArgumentError, 'Opts not set.' if opts.nil?
+    end
+
+    def find_pods
+      k8s_client
+        .get_pods(namespace: @opts.namespace)
+        .select { |pod| applicable?(pod) }
+    end
+
+    def create_reader(pod_name)
+      K8sPodReader.new(
+        k8s_client: k8s_client,
+        pod_name: pod_name,
+        formatter: @formatter,
+        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|
+        if new_pod_event?(notice) && applicable?(notice.object)
+          # NOTE: We are in another thread (are we?), so no sense to use
+          # 'Thread.join' here.
+          Thread.new { create_reader(notice.object.metadata.name).read }
+        end
+      end
+    end
+
+    def applicable?(pod)
+      pod.metadata.name.match?(@pod_query)
+    end
+
+    def new_pod_event?(notice)
+      notice.type == 'ADDED' && notice.object.kind == 'Pod'
+    end
+  end
+end

data/lib/kubetailrb/no_op_formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kubetailrb
+  # Formatter that does nothing except return what's given to it.
+  class NoOpFormatter
+    def format(log)
+      log
+    end
+  end
+end

data/lib/kubetailrb/opts_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'cmd/file'
+require_relative 'cmd/help'
+require_relative 'cmd/k8s'
+require_relative 'cmd/version'
+
+module Kubetailrb
+  # Parse CLI arguments and flags.
+  # NOTE: We could use the standard library optparse (OptionParser) or a more
+  # comprehensive tool like Thor to achieve this, but that would defeat the
+  # purpose of learning by implementing it ourselves.
+  class OptsParser
+    def initialize(*args)
+      @args = *args
+    end
+
+    def parse
+      return Cmd::Help.new if Cmd::Help.applicable?(*@args)
+
+      return Cmd::Version.new if Cmd::Version.applicable?(*@args)
+
+      return Cmd::File.create(*@args) if Cmd::File.applicable?(*@args)
+
+      Cmd::K8s.create(*@args)
+    end
+  end
+end

data/lib/kubetailrb/validated.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kubetailrb
+  # Add behaviors to validate the invariants.
+  module Validated
+    def raise_if_blank(arg, error_message)
+      raise ArgumentError, error_message if arg.nil? || arg.strip&.empty?
+    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
+    end
+
+    def validate_boolean(follow, error_message)
+      raise ArgumentError, error_message unless follow.is_a?(Boolean)
+    end
+  end
+end

data/lib/kubetailrb/version.rb

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

data/lib/kubetailrb/with_k8s_client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'kubeclient'
+
+module Kubetailrb
+  # 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

data/lib/kubetailrb.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'boolean'
+require_relative 'kubetailrb/cli'
+require_relative 'kubetailrb/version'
+
+# Main module
+module Kubetailrb
+end

data/sig/kubetailrb.rbs

@@ -0,0 +1,4 @@
+module Kubetailrb
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end