kubetailrb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b945e0de1dfdd765db891edb1a5e8c59a6cf7c1940a81147a4cd3c31b398003
-  data.tar.gz: bbebd5de583b686f18750f26bb2b9b52f3505da68285286e91f20417c0ecfa23
+  metadata.gz: 427b49a8499da9f1c69481130560ba2b783dc122b1a89146e4b2e6ce2f516ec9
+  data.tar.gz: 6be87b2d3529725ef21c2acaee397ddf1989dec3e91bd98f9b99494c6531b9e2
 SHA512:
-  metadata.gz: 871dc15cb59a8b657d4488fa08f78a04db28910b9aac8ff1938944d943d7a9a99b895164d6fe39f1ce8541a41730da3e34a84c09a89486bf73c2870fea13885d
-  data.tar.gz: 86d562f6163e7206a5c7a95f52bf8dd2e56de246590b35b4fdd338c1bc1624aacdbd2a7df91475f9612e737e320bdc7ba53ea86cb7bdb0f54ea6d0c89baaf6fc
+  metadata.gz: a63a5917935cda345eab9b35f918efdd84778bc58ababf1ede52425cbb71760ac40738cf24ae11596b0c71b373c7aee00b25ec4fc343d0b58deb226e072919f6
+  data.tar.gz: '08b4cb3695fb7704010a0bf868fa3465fe6ee7f0a1b5dafc5e90de3fd83295e8b266aec4555ab2f2840becffcb9f5137564781dbfa8edd69698dff091ebb5d98'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
-## [Unreleased]
+## [0.2.0] - 2024-12-05
+
+- remove `--pretty` flag
+  - now by default, it's displayed in pretty mode
+  - to display the log without formatting, use `--raw` flag
+- add possibility to filter out the access and datadog logs
+- support displaying stack trace in pretty mode
+- support formatting rails logs
+- fix color when receiving HTTP 500 in access logs
+- add `--display-names` flag to display the pod and container names
+- colorize pod events (blue for new pod events, red for deleted pod events)
 
 ## [0.1.0] - 2024-10-27
 
 - Initial release
+
+## [Unreleased]

data/README.md

@@ -1,5 +1,8 @@
 # Kubetailrb
 
+[![License](http://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/HazAT/badge/blob/master/LICENSE)
+[![Gem](https://img.shields.io/gem/v/kubetailrb?style=flat)](http://rubygems.org/gems/kubetailrb)
+
 > Tail your Kubernetes pod logs at the same time.
 
 > [!NOTE]
@@ -16,6 +19,12 @@
 
 ## Installation
 
+```sh
+gem install kubetailrb
+```
+
+If you want to install directly from the repository instead:
+
 ```sh
 # Install dependencies.
 ./bin/setup
@@ -31,16 +40,18 @@ bundle exec rake install
 kubetailrb -h
 
 # follow pod logs
-kubetailrb 'clock' --namespace sandbox
+kubetailrb 'clock' --namespace sandbox --raw
 
 # follow pod structured JSON logs and display in human friendly way
-kubetailrb 'clock-json' --namespace sandbox --pretty --raw --follow
+kubetailrb 'clock-json' --namespace sandbox --follow
 # or with shorter flags
-kubetailrb 'clock-json' -n sandbox -p -r -f
+kubetailrb 'clock-json' -n sandbox -f
 
 # you can filter the pods using regex on the pod names
-kubetailrb '^clock(?!-json)' -n sandbox -p -r
+kubetailrb '^clock(?!-json)' -n sandbox -f
 
+# you can also filter the containers using regex on the container names
+kubetailrb 'clock' -n sandbox -f -c 'json'
 ```
 
 ## Development
@@ -64,6 +75,21 @@ bundle exec rake test:watch
 bundle exec rake
 ```
 
+## Release a new version
+
+Update the version in
+[`lib/kubetailrb/version.rb`](./lib/kubetailrb/version.rb).
+
+> [!WARNING]
+> You may have to update the tests...
+> Too lazy to update the script to also update the tests...
+
+Then execute the script:
+
+```sh
+./bin/release
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/l-lin/kubetailrb.

data/Rakefile

@@ -66,6 +66,17 @@ namespace :k8s do
     puts `kubectl run #{app_name} --image #{docker_image}`
   end
 
+  desc 'Delete application from k8s.'
+  task :delete, [:app_name] do |_, args|
+    next unless k8s_up?
+
+    app_name = args[:app_name]
+
+    next if app_name.nil? || app_name.strip.empty?
+
+    puts `kubectl delete po #{app_name} --force true` if pod_up?(app_name)
+  end
+
   desc 'Deploy all applications to k8s.'
   task :deploy_all do
     Rake::Task['k8s:deploy'].invoke('clock')

data/journey_log.md

@@ -4,12 +4,6 @@
 > tribulations, and triumphs as I navigated the world of this dynamic
 > programming language.
 
-
-## 🤔 Things that I'm curious about
-
-
----
-
 ## 2024-10-27
 ### Context
 
@@ -90,7 +84,7 @@ It seems the convention is:
 - `features` contains the cucumber scenarios, i.e. integration tests.
 - `bin/` contains some scripts that can help the developer experience,
   - Rails projects also have scripts in this `bin/` directory.
-- `exec/` contains the executables that will be installed to the user system if
+- `exe/` contains the executables that will be installed to the user system if
   the latter is installing the gem
   - It seems to be a convention from Bundler, but that is configurable in the
   `gemspec` file.

data/lib/kubetailrb/cmd/file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'kubetailrb/file_reader'
+require 'kubetailrb/reader/file_reader'
 
 module Kubetailrb
   module Cmd
@@ -13,7 +13,7 @@ module Kubetailrb
       attr_reader :reader
 
       def initialize(filepath:, last_nb_lines: DEFAULT_NB_LINES, follow: DEFAULT_FOLLOW)
-        @reader = Kubetailrb::FileReader.new(filepath: filepath, last_nb_lines: last_nb_lines, follow: follow)
+        @reader = Kubetailrb::Reader::FileReader.new(filepath: filepath, last_nb_lines: last_nb_lines, follow: follow)
       end
 
       def execute

data/lib/kubetailrb/cmd/help.rb

@@ -14,14 +14,15 @@ module Kubetailrb
             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.
+            -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.
+            -r, --raw           Only display pod logs, without any special formatting.
+                --display-names Display pod and container names.
+            -n, --namespace     Kubernetes namespace to use.
+            -c, --container     Container name when multiple containers in pod. Default to '.'.
         HELP
       end
 

data/lib/kubetailrb/cmd/k8s.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'kubetailrb/k8s_pods_reader'
-require 'kubetailrb/json_formatter'
-require 'kubetailrb/no_op_formatter'
+require 'kubetailrb/reader/k8s_pods_reader'
 
 module Kubetailrb
   module Cmd
@@ -10,17 +8,25 @@ module Kubetailrb
     class K8s
       DEFAULT_NB_LINES = 10
       DEFAULT_NAMESPACE = 'default'
+      DEFAULT_CONTAINER_QUERY = '.*'
 
       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
+      DISPLAY_NAMES_FLAG = '--display-names'
+
+      CONTAINER_FLAGS = %w[-c --container].freeze
+      EXCLUDE_FLAGS = %w[-e --exclude].freeze
 
       attr_reader :reader
 
-      def initialize(pod_query:, opts:, formatter:)
-        @reader = Kubetailrb::K8sPodsReader.new(pod_query: pod_query, formatter: formatter, opts: opts)
+      def initialize(pod_query:, container_query:, opts:)
+        @reader = Kubetailrb::Reader::K8sPodsReader.new(
+          pod_query: pod_query,
+          container_query: container_query,
+          opts: opts
+        )
       end
 
       def execute
@@ -31,12 +37,14 @@ module Kubetailrb
         def create(*args)
           new(
             pod_query: parse_pod_query(*args),
-            formatter: parse_pretty_print(*args) ? Kubetailrb::JsonFormatter.new : Kubetailrb::NoOpFormatter.new,
+            container_query: parse_container_query(*args),
             opts: K8sOpts.new(
               namespace: parse_namespace(*args),
               last_nb_lines: parse_nb_lines(*args),
               follow: parse_follow(*args),
-              raw: parse_raw(*args)
+              raw: parse_raw(*args),
+              display_names: parse_display_names(*args),
+              exclude: parse_exclude(*args)
             )
           )
         end
@@ -109,8 +117,39 @@ module Kubetailrb
           args.any? { |arg| RAW_FLAGS.include?(arg) }
         end
 
-        def parse_pretty_print(*args)
-          args.any? { |arg| PRETTY_PRINT_FLAGS.include?(arg) }
+        def parse_container_query(*args)
+          return DEFAULT_CONTAINER_QUERY unless args.any? { |arg| CONTAINER_FLAGS.include?(arg) }
+
+          index = args.find_index { |arg| CONTAINER_FLAGS.include?(arg) }.to_i
+
+          raise MissingContainerQueryValueError, "Missing #{CONTAINER_FLAGS} value." if args[index + 1].nil?
+
+          args[index + 1]
+        end
+
+        def parse_display_names(*args)
+          args.include?(DISPLAY_NAMES_FLAG)
+        end
+
+        #
+        # Parse log exclusion from arguments provided in the CLI, e.g.
+        #
+        #   kubetailrb some-pod --exclude access-logs,dd-logs
+        #
+        # will return [access-logs, dd-logs].
+        #
+        # Will raise `MissingExcludeValueError` if the value is not provided:
+        #
+        #   kubetailrb some-pod --exclude
+        #
+        def parse_exclude(*args)
+          return [] unless args.any? { |arg| EXCLUDE_FLAGS.include?(arg) }
+
+          index = args.find_index { |arg| EXCLUDE_FLAGS.include?(arg) }.to_i
+
+          raise MissingExcludeValueError, "Missing #{EXCLUDE_FLAGS} value." if args[index + 1].nil?
+
+          args[index + 1].split(',')
         end
       end
     end
@@ -121,6 +160,12 @@ module Kubetailrb
     class MissingNamespaceValueError < RuntimeError
     end
 
+    class MissingContainerQueryValueError < RuntimeError
+    end
+
+    class MissingExcludeValueError < RuntimeError
+    end
+
     class InvalidNbLinesValueError < RuntimeError
     end
   end

data/lib/kubetailrb/filter/log_filter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/validated'
+
+module Kubetailrb
+  module Filter
+    # Filter the logs that we do not want to see.
+    # Currently only supporting excluding access logs and datadog logs.
+    class LogFilter
+      include Validated
+
+      def self.create(exclude)
+        new(exclude.include?('access-logs'), exclude.include?('dd-logs'))
+      end
+
+      def initialize(exclude_access_logs, exclude_dd_logs)
+        @exclude_access_logs = exclude_access_logs
+        @exclude_dd_logs = exclude_dd_logs
+
+        validate
+      end
+
+      # Returns true if the log should be print, false otherwise.
+      def test(log)
+        return false if @exclude_access_logs && access_log?(log)
+        return false if @exclude_dd_logs && dd_log?(log)
+
+        true
+      end
+
+      def exclude_access_logs?
+        @exclude_access_logs
+      end
+
+      def exclude_dd_logs?
+        @exclude_dd_logs
+      end
+
+      private
+
+      def validate
+        validate_boolean @exclude_access_logs, "Invalid exclude_access_logs: #{@exclude_access_logs}."
+        validate_boolean @exclude_dd_logs, "Invalid exclude_dd_logs: #{@exclude_dd_logs}."
+      end
+
+      def access_log?(log)
+        json = JSON.parse(log)
+        # NOTE: Shall I mutualize this function, as it's also used in
+        # JsonFormatter? It's only implemented in 2 places... Maybe I shall wait
+        # until there's a third one before applying DRY.
+        json.include?('http.response.status_code') || json.include?('http_status')
+      rescue JSON::ParserError
+        false
+      end
+
+      def dd_log?(log)
+        # NOTE: Is there's a better way to detect if it's a datadog log?
+        log.include?('[dd') || log.include?('[datadog]')
+      end
+    end
+  end
+end

data/lib/kubetailrb/formatter/json_formatter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/painter'
+
+module Kubetailrb
+  module Formatter
+    # Format JSON to human readable.
+    class JsonFormatter
+      include Painter
+
+      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') || json.include?('http_status')
+      end
+
+      def format_access_log(json)
+        "#{json["@timestamp"]}#{http_status_code json}#{http_method json} #{url_path json}"
+      end
+
+      def format_application_log(json)
+        "#{json["@timestamp"]}#{log_level json}#{json["message"]}#{format_stack_trace json}"
+      end
+
+      def format_stack_trace(json)
+        stack_trace = json['error.stack_trace']
+
+        return '' if stack_trace.nil? || stack_trace.strip&.empty?
+
+        "\n#{stack_trace}"
+      end
+
+      def http_status_code(json)
+        code = json['http.response.status_code'] || json['http_status']
+
+        return " #{highlight_blue(" I ")} [#{code}] " if code >= 200 && code < 400
+        return " #{highlight_yellow(" W ")} [#{code}] " if code >= 400 && code < 500
+        return " #{highlight_red(" E ")} [#{code}] " if code >= 500
+
+        " #{code} "
+      end
+
+      def log_level(json)
+        level = json['log.level'] || json.dig('log', 'level')
+        return ' ' if level.nil? || level.strip.empty?
+        return " #{highlight_blue(" I ")} " if level == 'INFO'
+        return " #{highlight_yellow(" W ")} " if level == 'WARN'
+        return " #{highlight_red(" E ")} " if level == 'ERROR'
+
+        " #{level} "
+      end
+
+      def http_method(json)
+        json['http.request.method'] || json['http_method']
+      end
+
+      def url_path(json)
+        json['url.path'] || json['http_path']
+      end
+    end
+  end
+end

data/lib/kubetailrb/formatter/no_op_formatter.rb

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

data/lib/kubetailrb/formatter/pod_metadata_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/validated'
+
+module Kubetailrb
+  module Formatter
+    # Display the pod and container name.
+    class PodMetadataFormatter
+      include Validated
+
+      def initialize(pod_name, container_name, formatter)
+        @pod_name = pod_name
+        @container_name = container_name
+        @formatter = formatter
+
+        validate
+      end
+
+      def format(log)
+        "#{@pod_name}/#{@container_name} | #{@formatter.format(log)}"
+      end
+
+      private
+
+      def validate
+        raise_if_blank @pod_name, 'Pod name not set.'
+        raise_if_blank @container_name, 'Container name not set.'
+        raise_if_nil @formatter, 'Formatter not set.'
+      end
+    end
+  end
+end

data/lib/kubetailrb/k8s_opts.rb

@@ -7,13 +7,15 @@ module Kubetailrb
   class K8sOpts
     include Validated
 
-    attr_reader :namespace, :last_nb_lines
+    attr_reader :namespace, :last_nb_lines, :exclude
 
-    def initialize(namespace:, last_nb_lines:, follow:, raw:)
+    def initialize(namespace:, last_nb_lines:, follow:, raw:, display_names:, exclude:) # rubocop:disable Metrics/ParameterLists
       @namespace = namespace
       @last_nb_lines = last_nb_lines
       @follow = follow
       @raw = raw
+      @display_names = display_names
+      @exclude = exclude
 
       validate
     end
@@ -26,6 +28,10 @@ module Kubetailrb
       @raw
     end
 
+    def display_names?
+      @display_names
+    end
+
     private
 
     def validate
@@ -33,6 +39,8 @@ module Kubetailrb
       validate_last_nb_lines @last_nb_lines
       validate_boolean @follow, "Invalid follow: #{@follow}."
       validate_boolean @raw, "Invalid raw: #{@raw}."
+      validate_boolean @display_names, "Invalid display names: #{@display_names}."
+      raise_if_nil @exclude, 'Exclude not set'
     end
   end
 end

data/lib/kubetailrb/painter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kubetailrb
+  # Add behaviors to colorize console output.
+  module Painter
+    def blue(text)
+      colorize(text, '34')
+    end
+
+    def red(text)
+      colorize(text, '31')
+    end
+
+    def highlight_blue(text)
+      colorize(text, '1;30;44')
+    end
+
+    def highlight_yellow(text)
+      colorize(text, '1;30;43')
+    end
+
+    def highlight_red(text)
+      colorize(text, '1;30;41')
+    end
+
+    private
+
+    def colorize(text, color_code)
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+  end
+end

data/lib/kubetailrb/reader/file_reader.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'kubetailrb/validated'
+
+module Kubetailrb
+  module Reader
+    # 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
+end