greenhat 0.5.1 → 0.6.1

data/lib/greenhat/shell/reports.rb

@@ -0,0 +1,41 @@
+# Reporting
+require 'greenhat/reports/shared' # Methods for Shell and Builder
+require 'greenhat/reports/internal_methods' # Class / Execution Only
+require 'greenhat/reports/runner' # Class execution
+require 'greenhat/reports/builder' # CLI Reports
+require 'greenhat/reports/shell_helper'
+
+module GreenHat
+  # CLI Helper
+  module Shell
+    # Logs
+    module Reports
+      # Easy Show All
+      def self.ls(raw = [])
+        filter, _flags, _args = Args.parse(raw)
+
+        list = GreenHat::ShellHelper::Reports.list
+        list.select! { |x| x.include? filter.first } unless filter.blank?
+
+        list.each do |x|
+          puts "- #{File.basename(x, '.rb').pastel(:yellow)}"
+        end
+      end
+
+      def self.default(raw = [])
+        list, flags, args = Args.parse(raw)
+
+        # Collect Reporst to Run
+        run_list = GreenHat::ShellHelper::Reports.list.select do |entry|
+          list.include? File.basename(entry, '.rb')
+        end
+
+        run_list.uniq!
+
+        run_list.each do |file|
+          GreenHat::ShellHelper::Reports.run(file: file, args: args, flags: flags)
+        end
+      end
+    end
+  end
+end

data/lib/greenhat/shell/shell_helper.rb

@@ -48,35 +48,64 @@ module GreenHat
 
       # Check if content needs to paged, or if auto_height is off
       if Page.skip?(flags, data)
-        puts data.map { |entry| entry_show(flags, entry) }.compact.join("\n")
+        create_ledger(data, flags).each { |entry| puts entry.render }
         return true
       end
 
-      # Default Pager
+      # Create Jobs
+      # Generate List of Formatted Output
+      ledger = create_ledger(data, flags)
+
+      # Start Thread
+      # TODO: Confirm / Test or Remove
+      unless flags.no_paper_thread
+        thread = Thread.new do
+          pending = ledger.clone
+          loop do
+            pending = pending.reject(&:done)
+            break if pending.empty?
+
+            pending.first.async
+          end
+        end
+      end
+
       TTY::Pager.page do |pager|
-        data.each do |entry|
-          output = "\n#{entry_show(flags, entry)}"
+        ledger.each do |paper|
+          # New Line is only needed on pager.write
+          pager.write "#{paper.render}\n"
+        end
+      end
 
-          # output += "\n" if flags[:table_style] == 'basic'
+      # Terminate
+      thread.kill unless flags.no_paper_thread
 
-          # Breaks any intentional spaces
-          # next if output.blank?
+      # -----------------
+    end
 
-          pager.write(output) # write line to the pager
-        end
+    # Collect Class Objects for output
+    def self.create_ledger(data, flags)
+      data.map do |x|
+        Paper.new(data: x, flags: flags)
       end
     end
 
+    def self.puts(text = '')
+      $stdout.puts text
+    end
+
     # Entry Shower / Top Level
     def self.entry_show(flags, entry, key = nil)
       LogBot.debug('Entry Show', entry.class) if ENV['DEBUG']
       case entry
       when Hash then render_table(entry, flags)
-      when Float, Integer, Array
+      when Float, Integer
         format_table_entry(flags, entry, key)
         # Ignore Special Formatting for Strings / Usually already formatted
       when String
         entry
+      when Array
+        render_array_table(entry, flags)
       else
         LogBot.warn('Shell Show', "Unknown #{entry.class}")
         nil
@@ -117,6 +146,22 @@ module GreenHat
       end
     end
 
+    def self.render_array_table(entry, flags)
+      table_style = flags[:table_style]&.to_sym || :unicode
+      header, rows = entry
+      table = TTY::Table.new(header: header, rows: rows)
+
+      LogBot.debug('Rendering Entries') if ENV['DEBUG']
+      output = table.render(table_style, padding: [0, 1, 0, 1], multiline: true) do |renderer|
+        renderer.border.style = :cyan
+      end
+
+      # Line breaks for basic tables
+      output += "\n" if flags[:table_style] == 'basic'
+
+      output
+    end
+
     # Print the Table in a Nice way
     def self.render_table(entry, flags)
       entry = entry.to_h { |k, v| [k, format_table_entry(flags, v, k)] }
@@ -135,9 +180,6 @@ module GreenHat
       output += "\n" if flags[:table_style] == 'basic'
 
       output
-
-      # LogBot.debug('Finish Render Table') if ENV['DEBUG']
-      # Fall Back to Amazing Inspect
     rescue StandardError => e
       if ENV['DEBUG']
         LogBot.warn('Table', message: e.message)
@@ -183,28 +225,42 @@ module GreenHat
 
     # Total Count Helper
     def self.total_count(results, flags)
-      results.map do |k, v|
-        puts k
-        # puts "Total: #{v.count.to_s.pastel(:blue)}"
-        # puts "Time Covered: #{calculate_duration(v).pastel(:cyan)}"
-
-        output = {}
-        output[:total] = v.count
-        output[:duration] = Query.calculate_duration(v)
-
-        # Sort / Get first and Last
-        list = v.select(&:time).map(&:time)
-        unless list.blank?
-          output[:start] = list.first
-          output[:end] = list.last
-        end
+      # Support Combine Helper
+      # TODO I Believe this should be removed now
+      # total_count_hash(results, flags) if results.instance_of? Hash
 
-        puts render_table(output, flags)
+      total_count_array(results, flags) if results.instance_of? Array
+    end
 
-        puts
+    # Hash Iteration
+    def self.total_count_hash(results, flags)
+      results.flat_map do |k, values|
+        [k, total_count_array(values, flags)]
       end
     end
 
+    # List Calculation
+    def self.total_count_array(results, flags)
+      # Option to only return the count
+      return results.count if flags[:total] == 'simple'
+
+      output = {}
+      output[:total] = results.count
+      output[:duration] = Query.calculate_duration(results)
+
+      # Sort / Get first and Last
+      list = results.select(&:time).map(&:time)
+      unless list.blank?
+        output[:start] = list.first
+        output[:end] = list.last
+      end
+
+      # Hide empty results
+      output.reject! { |_k, v| v.blank? }
+
+      render_table(output, flags)
+    end
+
     # Table Printer Helper
     def self.fields_print(results)
       results.each do |k, v|
@@ -239,7 +295,7 @@ module GreenHat
       file_list = prepare_list(file_list, base_list)
 
       # Convert to Things
-      find_things(file_list, flags)
+      find_things(file_list, flags, base_list)
     end
 
     # Total Log List Manipulator
@@ -263,13 +319,15 @@ module GreenHat
     end
 
     # Shortcut find things
-    def self.find_things(files, flags = {})
-      things = files.uniq.flat_map do |file|
+    def self.find_things(file_list, flags = {}, base_list = nil)
+      base_list ||= Thing.all
+
+      things = file_list.uniq.flat_map do |file|
         # If Thing, Return Thing
         return file if file.instance_of?(Thing)
 
         if flags.fuzzy_file_match
-          Thing.list.select { |x| x.name.include?(file) || x.type.include?(file) }
+          base_list.select { |x| x.name.include?(file) || x.type.include?(file) }
         else
           Thing.where name: file
         end

data/lib/greenhat/shell.rb

@@ -18,6 +18,12 @@ module GreenHat
       GreenHat::Web.toggle
     end
 
+    # Append Log Location so follow up commands are executed there
+    def self.default(raw_list = [])
+      Cli.move_shell Shell::Log
+      Log.default(raw_list)
+    end
+
     def self.df
       Disk.df
     end
@@ -101,8 +107,13 @@ module GreenHat
       end
     end
 
-    def self.ls
-      GreenHat::Cli.help(false)
+    def self.ls(raw = [])
+      if raw.empty?
+        GreenHat::Cli.help(false)
+      else
+        Cli.move_shell Shell::Log
+        Log.ls(raw)
+      end
     end
 
     def self.ll

data/lib/greenhat/thing/file_types.rb

@@ -65,6 +65,13 @@ module GreenHat
             %r{log/syslog}
           ]
         },
+        'gitlab-runner.log' => {
+          format: :runner_log,
+          log: true,
+          pattern: [
+            /gitlab-runner.log/
+          ]
+        },
         'etc/fstab' => {
           format: :clean_raw,
           pattern: [
@@ -124,6 +131,13 @@ module GreenHat
             %r{consul/current}
           ]
         },
+        'gitlab-kas/current' => {
+          format: :time_space,
+          log: true,
+          pattern: [
+            %r{gitlab-kas/current}
+          ]
+        },
         'sentinel/current' => {
           format: :time_space,
           log: true,

data/lib/greenhat/thing/formatters/clean_raw.rb

@@ -4,7 +4,7 @@ module GreenHat
   module Formatters
     # Remove Comments / Empty Lines
     def format_clean_raw
-      staging = raw.clone
+      staging = raw_full.clone
 
       # Empty
       staging.reject!(&:empty?)

data/lib/greenhat/thing/formatters/runner_log.rb

@@ -0,0 +1,70 @@
+# Top
+module GreenHat
+  # Log
+  module Formatters
+    # Attempt to make runner logs easier to parse
+    def format_runner_log
+      self.result = raw.map do |row|
+        next if row.empty? || row == "\n"
+        next if row.include? '-- Logs begin at' # Skip Header
+
+        process_runner_log_row(row)
+      end
+
+      result.compact!
+    end
+
+    # Split / Parse Time
+    # TODO: Better sys log parsing? Cannot find ready-made regex/ruby parser
+    def process_runner_log_row(row)
+      month, day, time, device, service, message = row.split(' ', 6)
+      service&.gsub!(':', '')
+      pid = service&.match(/\[(.*?)\]/)&.captures&.first
+
+      entry = {
+        time: format_time_parse("#{month} #{day} #{time}"),
+        device: device,
+        service: service,
+        message: message,
+        pid: pid,
+        row: row # Insert full row for different timestamp formats
+      }
+
+      # Remove Empty Keys
+      entry.compact!
+
+      # Shellwords split - Skip Blank
+      process_runner_row_message(message, entry) unless message.blank?
+
+      entry
+
+    # Return everything incase of error
+    rescue StandardError => e
+      LogBot.warn('Runner Log Parse', e.message)
+      {
+        message: row
+      }
+    end
+
+    def process_runner_row_message(message, entry)
+      # Insert Keywords / Format Time if Possible
+      Shellwords.split(message).select { |x| x.include? '=' }.each do |x|
+        key, value = x.split('=', 2)
+
+        # Don't overwrite stuff
+        case key
+        when 'time'
+          entry["#{key}-msg".to_sym] = format_time_parse value
+        when 'message', :message
+          entry["#{key}-msg".to_sym] = value
+        else
+          entry[key.to_sym] = value
+        end
+      end
+    rescue StandardError
+      # LogBot.debug('Runner Log Parse', e.message)
+      nil
+    end
+    # --
+  end
+end

data/lib/greenhat/thing/formatters/time_json.rb

@@ -10,10 +10,21 @@ module GreenHat
       self.result = raw.map do |row|
         time, msg = row.split(' ', 2)
 
-        result =  Oj.load msg
+        # Be mo fault tolerant
+        result =  begin
+          Oj.load msg
+        rescue StandardError
+          { msg: msg }
+        end
+
         result.time = time
 
         result
+      rescue StandardError => e
+        # TODO: Background Logger?
+        e.message
+        LogBot.warn('Time JSON Parse', e.message)
+        next
       end
     end
     # ==========================================================================

data/lib/greenhat/thing/kind.rb

@@ -84,7 +84,7 @@ module GreenHat
       option = prompt.select('Wat is this?', prompt_list.keys.sort_by(&:length), filter: true)
 
       # Store for later
-      ThingHistory.add(name, option)
+      ThingHistory.add(name.to_sym, option)
 
       self.type = option
     end

data/lib/greenhat/version.rb

@@ -1,3 +1,3 @@
 module GreenHat
-  VERSION = '0.5.1'.freeze
+  VERSION = '0.6.1'.freeze
 end

data/lib/greenhat.rb

@@ -24,6 +24,7 @@ require 'tty-table'
 require 'tty-which'
 require 'warning'
 require 'ruby_native_statistics'
+require 'gitlab_chronic_duration'
 
 # Custom Gem
 require 'teron'
@@ -54,8 +55,12 @@ require 'greenhat/logbot'
 require 'greenhat/settings'
 require 'greenhat/color'
 
+# Printer Helpers
+require 'greenhat/paper/paper_helper'
+require 'greenhat/paper/flag_helper'
+require 'greenhat/paper'
+
 # Formatters - Loads Required Files Automatically
-require 'greenhat/thing/super_log'
 require 'greenhat/thing/file_types'
 require 'greenhat/thing/kind'
 require 'greenhat/thing/history'
@@ -68,14 +73,7 @@ require 'greenhat/thing'
 # Shell - Loads Required Files Automatically
 require 'greenhat/shell'
 
-# TODO: Confirm
-# require 'greenhat/host'
-# require 'greenhat/web'
-
-require 'greenhat/pry_helpers'
-
 ## TTY Shims
-
 require 'greenhat/tty/line'
 require 'greenhat/tty/reader'
 require 'greenhat/tty/custom_line'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: greenhat
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.1
 platform: ruby
 authors:
 - Davin Walker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-17 00:00:00.000000000 Z
+date: 2022-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amazing_print
@@ -164,6 +164,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: gitlab_chronic_duration
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.6
 - !ruby/object:Gem::Dependency
   name: hash_dot
   requirement: !ruby/object:Gem::Requirement
@@ -454,7 +468,19 @@ files:
 - lib/greenhat/entrypoint.rb
 - lib/greenhat/host.rb
 - lib/greenhat/logbot.rb
-- lib/greenhat/pry_helpers.rb
+- lib/greenhat/paper.rb
+- lib/greenhat/paper/flag_helper.rb
+- lib/greenhat/paper/paper_helper.rb
+- lib/greenhat/reports.rb
+- lib/greenhat/reports/builder.rb
+- lib/greenhat/reports/helpers.rb
+- lib/greenhat/reports/internal_methods.rb
+- lib/greenhat/reports/reports/errors.rb
+- lib/greenhat/reports/reports/faststats.rb
+- lib/greenhat/reports/reports/full.rb
+- lib/greenhat/reports/runner.rb
+- lib/greenhat/reports/shared.rb
+- lib/greenhat/reports/shell_helper.rb
 - lib/greenhat/settings.rb
 - lib/greenhat/shell.rb
 - lib/greenhat/shell/args.rb
@@ -478,6 +504,7 @@ files:
 - lib/greenhat/shell/process.rb
 - lib/greenhat/shell/query.rb
 - lib/greenhat/shell/report.rb
+- lib/greenhat/shell/reports.rb
 - lib/greenhat/shell/shell_helper.rb
 - lib/greenhat/thing.rb
 - lib/greenhat/thing/file_types.rb
@@ -499,6 +526,7 @@ files:
 - lib/greenhat/thing/formatters/nginx.rb
 - lib/greenhat/thing/formatters/raw.rb
 - lib/greenhat/thing/formatters/registry.rb
+- lib/greenhat/thing/formatters/runner_log.rb
 - lib/greenhat/thing/formatters/shellwords.rb
 - lib/greenhat/thing/formatters/syslog.rb
 - lib/greenhat/thing/formatters/table.rb
@@ -510,7 +538,6 @@ files:
 - lib/greenhat/thing/info_format.rb
 - lib/greenhat/thing/kind.rb
 - lib/greenhat/thing/spinner.rb
-- lib/greenhat/thing/super_log.rb
 - lib/greenhat/tty/columns.rb
 - lib/greenhat/tty/custom_line.rb
 - lib/greenhat/tty/line.rb

data/lib/greenhat/pry_helpers.rb

@@ -1,51 +0,0 @@
-def show(data)
-  pastel = Pastel.new
-  TTY::Pager.page do |pager|
-    data.each do |e|
-      table = TTY::Table.new(header: e.keys, rows: [e], orientation: :vertical)
-      # do some work with the line
-
-      output = table.render(:unicode, multiline: false) do |renderer|
-        renderer.border.style = :cyan
-        # renderer.filter = ->(val, row_index, col_index) do
-        #   val.ai
-        # end
-
-        renderer.filter = lambda { |val, _row_index, col_index|
-          puts val.class unless val.instance_of? String
-          if col_index == 1
-            if val.numeric?
-              pastel.red.blue(val)
-            else
-              val
-            end
-          else
-            val
-          end
-          # .ai(raw: true).gsub('"','')
-        }
-      end
-
-      pager.write("\n#{output}") # write line to the pager
-    end
-  end
-end
-
-def filter(data, params = {})
-  result = data.clone
-  params.each do |k, v|
-    result.select! do |row|
-      if row.key? k.to_sym
-        row[k.to_sym].include? v
-      else
-        false
-      end
-    end
-  end
-
-  result
-end
-
-def version
-  Thing.find_by(name: 'gitlab_version_manifest_json').data.build_version
-end

data/lib/greenhat/thing/super_log.rb

@@ -1 +0,0 @@
-