greenhat 0.1.4 → 0.3.1

data/lib/greenhat/shell/page.rb

@@ -0,0 +1,39 @@
+module GreenHat
+  module ShellHelper
+    # Helper to organize page check / methods
+    module Page
+      # Check if paging should be skipped
+      # True / False / Not Set
+      def self.skip?(flags, data)
+        # Pass if Explicitly Set / Inverse for skip
+        return !flags[:page] if flags.key? :page
+
+        LogBot.debug('Page', count_rows(data, flags)) if ENV['DEBUG']
+
+        count_rows(data, flags)
+      end
+
+      # Array/Hash and String pagination check. Don't unncessarily loop through everything
+      def self.count_rows(data, flags)
+        height = TTY::Screen.height
+        size = 0
+
+        data.each do |entry|
+          size += case entry
+                  when Hash then entry.keys.count
+                  when Array then entry.count
+                  else
+                    # Each Boxed Entry is 3 Lines
+                    flags.key?(:row_size) ? flags[:row_size] : 1
+
+                  end
+
+          break if size > height
+        end
+
+        size < height
+      end
+    end
+    # ----
+  end
+end

data/lib/greenhat/shell/process.rb

@@ -4,8 +4,63 @@ module GreenHat
     # Logs
     module Process
       # Easy Show All
-      def self.ps
-        ShellHelper.file_output GreenHat::Ps.ps
+      # Filter --archive
+
+      def self.ls
+        help
+      end
+
+      def self.help
+        puts "\u2500".pastel(:cyan) * 22
+        puts "#{'Process'.pastel(:yellow)} -  ps helper"
+        puts "\u2500".pastel(:cyan) * 22
+
+        ShellHelper.common_opts
+
+        puts 'Command Summary'.pastel(:blue)
+        puts '  ps'.pastel(:green)
+        puts '    Raw `ps`'
+        puts
+        puts '  filter'.pastel(:green)
+        puts "    Key/Field Filtering.  See #{'filter_help'.pastel(:blue)}"
+        puts '    Examples'
+        puts '      filter --sort=mem --reverse'.pastel(:green)
+        puts '      filter --user=gitlab'.pastel(:green)
+
+        puts
+      end
+
+      def self.filter_help
+        ShellHelper::Filter.help
+      end
+
+      def self.ps(raw = {})
+        # Extract Args
+        files_list, flags, _args = Args.parse(raw)
+
+        # Collect Files
+        files = ShellHelper.files(files_list, GreenHat::Ps.things, flags)
+
+        # Output
+        ShellHelper.file_output(files, flags)
+      end
+
+      def self.filter(raw = {})
+        # Argument Parsing
+        files, flags, args = Args.parse(raw)
+
+        # Prepare Log List
+        file_list = ShellHelper.prepare_list(files, GreenHat::Ps.things)
+
+        results = ShellHelper.filter_start(file_list, flags, args)
+
+        # Check Search Results
+        if results.instance_of?(Hash) && results.values.flatten.empty?
+          puts 'No results'.pastel(:red)
+        else
+          # This causes the key 'colorized' output to also be included
+          ShellHelper.show(results.to_a.compact.flatten, flags)
+        end
       end
     end
   end

data/lib/greenhat/shell/report.rb

@@ -2,11 +2,17 @@ module GreenHat
   # Root Level Shell / Report Helper
   module Shell
     def self.report(raw)
-      args = {
-        raw: raw.include?('--raw')
-      }
+      _files, flags, _args = Args.parse(raw)
 
-      ShellHelper.show(Archive.all.map(&:report).map(&:show).flatten, args)
+      archives = if flags.archive
+                   Archive.all.select do |archive|
+                     flags.archive.any? { |x| archive.name.include? x.to_s }
+                   end
+                 else
+                   Archive.all
+                 end
+
+      ShellHelper.show(archives.map(&:report).map(&:show).flatten, flags)
     end
   end
 end
@@ -19,7 +25,7 @@ module GreenHat
 
     attr_accessor :archive, :host, :os_release, :selinux_status, :cpu, :uname,
                   :timedatectl, :uptime, :meminfo, :gitlab_manifest, :gitlab_status,
-                  :production_log, :api_log, :application_log, :sidekiq_log, :free_m
+                  :production_log, :api_log, :application_log, :sidekiq_log, :free_m, :disk_free
 
     # Find Needed Files for Report
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
@@ -40,15 +46,16 @@ module GreenHat
       self.api_log = archive.things.find { |x| x.name == 'gitlab-rails/api_json.log' }
       self.application_log = archive.things.find { |x| x.name == 'gitlab-rails/application_json.log' }
       self.sidekiq_log = archive.things.find { |x| x.name == 'sidekiq/current' }
+      self.disk_free = archive.things.find { |x| x.name == 'df_h' }
     end
 
     def show
       output = [
-        archive.friendly_name.colorize(:blue)
+        archive.friendly_name.pastel(:blue)
       ]
 
       # OS
-      output << 'OS'.colorize(:light_yellow)
+      output << 'OS'.pastel(:bright_yellow)
       output << hostname if host
       output << distro if os_release
       output << selinux if selinux_status
@@ -61,14 +68,20 @@ module GreenHat
 
       # Memory
       if meminfo || free_m
-        output << 'Memory'.colorize(:light_yellow)
-        output << memory if meminfo
+        output << 'Memory'.pastel(:bright_yellow)
+        output << memory_perc if meminfo
         output << memory_free if free_m
         output << ''
       end
 
+      # Disk
+      if disk_free
+        output << disks
+        output << ''
+      end
+
       # Gitlab
-      output << 'GitLab'.colorize(:light_yellow) if gitlab_manifest
+      output << 'GitLab'.pastel(:bright_yellow) if gitlab_manifest
       output << gitlab_version if gitlab_manifest
       output << gitlab_services if gitlab_status
       output << title('Errors') if production_log || api_log || application_log || sidekiq_log
@@ -88,8 +101,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Production', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Production', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -98,8 +111,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  API', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  API', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -108,8 +121,8 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Application', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Application', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
@@ -118,32 +131,16 @@ module GreenHat
       color = count.zero? ? :green : :red
 
       [
-        title('  Sidekiq', :light_red, 18),
-        count.to_s.colorize(color)
+        title('  Sidekiq', :bright_red, 18),
+        count.to_s.pastel(color)
       ].join
     end
 
     def gitlab_services
-      list = gitlab_status.data.keys.sort.map do |service|
-        color = gitlab_status.data.dig(service, 0, :status) == 'run' ? :green : :red
-        service.colorize(color)
-      end
-
-      # Keep Alphabetical Sort
-      groups = list.each_slice((list.size / 3.to_f).round).to_a
-
-      table = TTY::Table.new do |t|
-        loop do
-          break if groups.all?(&:empty?)
-
-          t << groups.map(&:shift)
-        end
-      end
-
       [
         title('Services'),
         "\n   ",
-        table.render(:unicode, padding: [0, 1, 0, 1], indent: 3)
+        GitLab.services(archive, 3)
       ].join
     rescue StandardError => e
       LogBot.fatal('GitLab Services', message: e.message, backtrace: e.backtrace.first)
@@ -166,7 +163,7 @@ module GreenHat
     def distro
       [
         title('Distro'),
-        "[#{os_release.data.ID}] ".colorize(:light_black),
+        "[#{os_release.data.ID}] ".pastel(:bright_black),
         os_release.data.PRETTY_NAME
       ].join
     end
@@ -177,7 +174,7 @@ module GreenHat
 
       [
         title('SeLinux'),
-        status.colorize(status_color),
+        status.pastel(status_color),
         ' (',
         selinux_status.data['Current mode'],
         ')'
@@ -197,7 +194,7 @@ module GreenHat
       [
         title('Kernel'),
         value,
-        " (#{build})".colorize(:light_black)
+        " (#{build})".pastel(:bright_black)
       ].join
     end
 
@@ -209,6 +206,9 @@ module GreenHat
     end
 
     def sys_time
+      # Ignore if Empty
+      return false if timedatectl.data.nil?
+
       ntp_statuses = timedatectl.data.slice(*ntp_keys).values.compact
 
       enabled = %w[active yes] & ntp_statuses
@@ -221,9 +221,9 @@ module GreenHat
       [
         title('Sys Time'),
         timedatectl.data['Local time'],
-        ' (ntp: '.colorize(:light_black),
-        ntp_status.colorize(ntp_color),
-        ')'.colorize(:light_black)
+        ' (ntp: '.pastel(:bright_black),
+        ntp_status.pastel(ntp_color),
+        ')'.pastel(:bright_black)
       ].join
     end
 
@@ -248,38 +248,30 @@ module GreenHat
         [
           interval,
           ' (',
-          "#{value}%".colorize(color),
+          "#{value}%".pastel(color),
           ')'
         ].join
       end
 
       [
         title('LoadAvg'),
-        "[CPU #{cpu_count}] ".colorize(:light_white),
+        "[CPU #{cpu_count}] ".pastel(:bright_white),
         intervals_text.join(', ')
       ].join
     end
 
-    def memory
+    def memory_perc
       total = ShellHelper.human_size_to_number(meminfo.data['MemTotal'])
       free = ShellHelper.human_size_to_number(meminfo.data['MemFree'])
       used = percent((total - free), total)
+
       [
-        title('MemUsed'),
-        '['.colorize(:light_black),
-        '='.colorize(:green) * (used / 2),
+        title('Usage'),
+        '  ['.pastel(:bright_black),
+        '='.pastel(:green) * (used / 2),
         ' ' * (50 - used / 2),
-        ']'.colorize(:light_black),
-        " #{100 - percent(free, total)}%".colorize(:green), # Inverse
-        "\n",
-        title('Total'),
-        number_to_human_size(total).colorize(:light_white),
-        "\n",
-        title('Used'),
-        number_to_human_size(total - free),
-        "\n",
-        title('Free'),
-        number_to_human_size(free)
+        ']'.pastel(:bright_black),
+        " #{100 - percent(free, total)}%".pastel(:green) # Inverse
       ].join
     end
 
@@ -288,6 +280,8 @@ module GreenHat
 
       return unless free
 
+      formatted_mem = free_m.data.map { |x| GreenHat::Memory.memory_row x }
+
       [
         title('Total', :cyan, 14),
         number_to_human_size(free.total.to_i * 1024**2),
@@ -299,7 +293,23 @@ module GreenHat
         number_to_human_size(free.free.to_i * 1024**2),
         "\n",
         title('Available', :green, 14),
-        number_to_human_size(free.available.to_i * 1024**2)
+        number_to_human_size(free.available.to_i * 1024**2),
+        "\n\n",
+        formatted_mem.map { |x| x.prepend ' ' * 2 }.join("\n")
+      ].join
+    end
+
+    def disks
+      # GreenHat::Disk.df({archive: []})
+      file = GreenHat::Disk.df({ archive: [archive.name] })
+
+      disk_list = GreenHat::Disk.format_output(file.first, false, 3)
+
+      # Preapre / Indent List
+      [
+        'Disks'.pastel(:bright_yellow) + ' (Top % Usage)'.pastel(:bright_black),
+        "\n",
+        disk_list.each { |x| x.prepend(' ' * 4) }.join("\n")
       ].join
     end
 
@@ -312,7 +322,7 @@ module GreenHat
 
     # Helper to Make Cyan Titles
     def title(name, color = :cyan, ljust = 12)
-      "  #{name}:".ljust(ljust).colorize(color)
+      "  #{name}:".ljust(ljust).pastel(color)
     end
   end
   # rubocop:enable Metrics/ClassLength

data/lib/greenhat/shell/shell_helper.rb

@@ -0,0 +1,601 @@
+module GreenHat
+  # Common Helpers
+  # rubocop:disable Metrics/ModuleLength
+  module ShellHelper
+    # Use File Process for Output
+    def self.file_output(files, flags = {})
+      results = file_process(files) do |file|
+        [
+          file.friendly_name,
+          file.output(false),
+          "\n"
+        ]
+      end
+
+      ShellHelper.show(results.flatten, flags)
+    end
+
+    def self.file_process(files, &block)
+      files.map do |file|
+        next if file.output(false).empty?
+
+        block.call(file)
+      end.flatten
+    end
+
+    # Pagination Helper
+    def self.page(data)
+      TTY::Pager.page do |pager|
+        data.flatten.each do |output|
+          pager.write("\n#{output}") # write line to the pager
+        end
+      end
+    end
+
+    # Show Data / Auto Paginate Helper
+    def self.show(data, flags = {})
+      # If Block of String
+      if data.instance_of?(String)
+        TTY::Pager.page data
+        return true
+      end
+
+      # If raw just print out
+      if flags[:raw]
+        puts data.join("\n")
+        return true
+      end
+
+      # 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")
+        return true
+      end
+
+      # Default Pager
+      TTY::Pager.page do |pager|
+        data.each do |entry|
+          output = entry_show(flags, entry)
+
+          # Breaks any intentional spaces
+          # next if output.blank?
+
+          pager.write("\n#{output}") # write line to the pager
+        end
+      end
+    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
+        format_table_entry(flags, entry, key)
+      # Ignore Special Formatting for Strings / Usually already formatted
+      when String
+        entry
+      else
+        LogBot.warn('Shell Show', "Unknown #{entry.class}")
+        nil
+      end
+    end
+
+    # Format Table Entries
+    def self.format_table_entry(flags, entry, key = nil)
+      formatted_entry = case entry
+                        # Rounding
+                        when Float, Integer || entry.numeric?
+                          flags.key?(:round) ? entry.to_f.round(flags.round).ai : entry.ai
+
+                          # General Inspecting
+                        when Hash then entry.ai(ruby19_syntax: true)
+
+                        # Arrays often contain Hashes. Dangerous Recursive?
+                        when Array
+                          entry.map { |x| format_table_entry(flags, x) }.join("\n")
+
+                        when Time
+                          entry.to_s.pastel(:bright_white)
+
+                        # Default String Formatting
+                        else
+                          StringColor.do(key, entry)
+                        end
+
+      if flags[:truncate]
+        entry_truncate(formatted_entry, flags[:truncate])
+      else
+        formatted_entry
+      end
+    rescue StandardError => e
+      if ENV['DEBUG']
+        LogBot.warn('Table Format Entry', message: e.message)
+        ap e.backtrace
+      end
+    end
+
+    # Print the Table in a Nice way
+    def self.render_table(entry, flags)
+      entry = entry.map { |k, v| [k, format_table_entry(flags, v, k)] }.to_h
+      # Pre-format Entry
+
+      table = TTY::Table.new(header: entry.keys, rows: [entry], orientation: :vertical)
+
+      LogBot.debug('Rendering Entries') if ENV['DEBUG']
+      table.render(:unicode, padding: [0, 1, 0, 1], multiline: true) do |renderer|
+        renderer.border.style = :cyan
+      end
+
+      # 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)
+        ap e.backtrace
+      end
+
+      [
+        entry.ai,
+        ('_' * (TTY::Screen.width / 3)).pastel(:cyan),
+        "\n"
+      ].join("\n")
+    end
+
+    def self.render_table_entry(val, col_index, flags)
+      return val.to_s unless col_index == 1
+
+      format_table_entry(flags, val)
+    end
+
+    # Main Entry Point for Filtering
+    def self.filter_start(files, flags, args)
+      # Convert to Things
+      logs = ShellHelper.find_things(files, flags).select(&:processed?)
+
+      # Ignore Archive/Host Dividers
+      if flags[:combine]
+        results = logs.reject(&:blank?).map(&:data).flatten.compact
+        ShellHelper.filter(results, flags, args)
+      else
+        # Iterate and Preserve Archive/Host Index
+        logs.each_with_object({}) do |log, obj|
+          # Ignore Empty Results / No Thing
+          next if log&.blank?
+
+          # Include Total Count in Name
+          results = ShellHelper.filter(log.data, flags, args)
+          title = [
+            log.friendly_name,
+            " #{results.count}".pastel(:bright_black)
+          ]
+
+          # Save unless empty
+          obj[title.join] = results unless results.count.zero?
+
+          obj
+        end
+      end
+    end
+
+    # Filter Logic
+    # TODO: Simplify
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.filter(data, flags = {}, args = {})
+      results = data.clone.flatten.compact
+      results.select! do |row|
+        args.send(flags.logic) do |arg|
+          filter_row_key(row, arg, flags)
+        end
+      end
+
+      # Ensure presecense of a specific field
+      results = filter_exists(results, flags[:exists]) if flags.key?(:exists)
+
+      # Time Filtering
+      results = filter_time(results, flags) if flags.key?(:start) || flags.key?(:end)
+
+      # Strip Results if Slice is defined
+      results = filter_slice(results, flags[:slice]) if flags.key?(:slice)
+
+      # Strip Results if Except is defined
+      results = filter_except(results, flags[:except]) if flags.key?(:except)
+
+      # Remove Blank from either slice or except
+      results.reject!(&:empty?)
+
+      # Sort
+      results.sort_by! { |x| x.slice(*flags[:sort]).values } if flags.key?(:sort)
+
+      # JSON Formatting
+      results = results.map { |x| Oj.dump(x) } if flags.key?(:json)
+
+      # Show Unique Only
+      results = filter_uniq(results, flags[:uniq]) if flags.key?(:uniq)
+
+      # Reverse
+      results.reverse! if flags[:reverse]
+
+      # Count occurrences / Skip Results
+      return filter_stats(results, flags[:stats]) if flags.key?(:stats)
+
+      # Pluck
+      results = filter_pluck(results, flags[:pluck]) if flags.key?(:pluck)
+
+      # Limit / Ensure Exists and Valid Number
+      if flags.key?(:limit) && flags[:limit]
+        # Old
+        # results[0..flags[:limit].map(&:to_s).join.to_i - 1]
+
+        # New
+        results.shift flags[:limit]
+
+      else
+        results
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # Filter Start and End Times
+    # rubocop:disable Metrics/MethodLength
+    # TODO: This is a bit icky, simplify/dry
+    def self.filter_time(results, flags)
+      if flags.key?(:start)
+        begin
+          time_start = Time.parse(flags[:start])
+
+          results.select! do |x|
+            if x.time
+              time_start < x.time
+            else
+              true
+            end
+          end
+        rescue StandardError
+          puts 'Unable to Process Start Time Filter'.pastel(:red)
+        end
+      end
+
+      if flags.key?(:end)
+        begin
+          time_start = Time.parse(flags[:end])
+
+          results.select! do |x|
+            if x.time
+              time_start > x.time
+            else
+              true
+            end
+          end
+        rescue StandardError
+          puts 'Unable to Process End Time Filter'.pastel(:red)
+        end
+      end
+
+      results
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.filter_except(results, except)
+      # Avoid Empty Results
+      if except.empty?
+        filter_empty_arg('except')
+        return results
+      end
+
+      results.map { |row| row.except(*except) }
+    end
+
+    def self.filter_exists(results, exists)
+      # Avoid Empty Results
+      if exists.empty?
+        filter_empty_arg('exists')
+        return results
+      end
+
+      results.select { |row| (exists - row.keys).empty? }
+    end
+
+    def self.entry_truncate(entry, truncate)
+      # Ignore if Truncation Off
+      return entry if truncate.zero?
+
+      # Only truncate large strings
+      return entry unless entry.instance_of?(String) && entry.size > truncate
+
+      # Include  '...' to indicate truncation
+      "#{entry.to_s[0..truncate]} #{'...'.pastel(:bright_blue)}"
+    end
+
+    def self.filter_slice(results, slice)
+      # Avoid Empty Results
+      if slice.empty?
+        filter_empty_arg('slice')
+        return results
+      end
+
+      results.map { |row| row.slice(*slice) }
+    end
+
+    def self.filter_pluck(results, pluck)
+      # Avoid Empty Results
+      if pluck.empty?
+        filter_empty_arg('pluck')
+        return results
+      end
+
+      results.map { |x| x.slice(*pluck).values }.flatten
+    end
+
+    def self.filter_uniq(results, unique)
+      # Avoid Empty Results
+      if unique.empty?
+        filter_empty_arg('uniq')
+        return results
+      end
+
+      unique.map do |field|
+        results.uniq { |x| x[field] }
+      end.inject(:&)
+    end
+
+    def self.filter_stats(results, stats)
+      # Avoid Empty Results
+      if stats.empty?
+        filter_empty_arg('stats')
+        return results
+      end
+
+      # Loop through Stats, Separate Hash/Tables
+      stats.map do |field|
+        occurrences = filter_count_occurrences(results, field)
+
+        # Total Occurences
+        total = occurrences.values.sum
+
+        # Percs
+        occurrences.transform_values! do |count|
+          [
+            count,
+            " #{percent(count, total)}%".pastel(:bright_black)
+          ]
+        end
+
+        # Sort by total occurances / New Variable for Total
+        output = occurrences.sort_by(&:last).to_h.transform_values!(&:join).to_a
+
+        # Append Header / Total with field name
+        output.unshift([field.to_s.pastel(:bright_black), total])
+
+        # Format
+        output.to_h
+      end
+    end
+
+    # Percent Helper
+    def self.percent(value, total)
+      ((value / total.to_f) * 100).round
+    end
+
+    # Helper to Count occurrences
+    def self.filter_count_occurrences(results, field)
+      results.each_with_object(Hash.new(0)) do |entry, counts|
+        if entry.key? field
+          counts[entry[field]] += 1
+        else
+          counts['None'.pastel(:bright_black)] += 1
+        end
+
+        counts
+      end
+    end
+
+    def self.filter_empty_arg(arg)
+      puts [
+        'Ignoring'.pastel(:bright_yellow),
+        "--#{arg}".pastel(:cyan),
+        'it requires an argument'.pastel(:red)
+      ].join(' ')
+    end
+
+    # Break out filter row logic into separate method
+
+    def self.filter_row_key(row, arg, flags)
+      # Ignore Other Logic if Field isn't even included / Full Text Searching
+      return false unless row.key?(arg[:field]) || arg[:field] == :text
+
+      # Sensitivity Check / Check for Match / Full Text Searching
+      included = if arg[:field] == :text
+                   filter_row_entry(row.to_s, arg, flags)
+                 else
+                   filter_row_entry(row[arg.field].to_s, arg, flags)
+                 end
+
+      # Pivot of off include vs exclude
+      if arg.bang
+        !included
+      else
+        included
+      end
+    end
+
+    # Field Partial / Case / Exact search
+    def self.filter_row_entry(entry, arg, flags)
+      # Exact Matching / Unless doing full text search
+      return entry.to_s == arg.value.to_s if flags.key?(:exact) && arg.field != :text
+
+      if flags.key?(:case)
+        entry.include? arg.value.to_s
+      else
+        entry.downcase.include? arg.value.to_s.downcase
+      end
+    end
+
+    # Total Count Helper
+    def self.total_count(results)
+      results.each do |k, v|
+        puts k
+        puts "Total: #{v.count.to_s.pastel(:blue)}"
+        puts
+      end
+    end
+
+    # Unified Files Interface
+    def self.files(file_list, base_list = nil, flags = {})
+      base_list ||= Thing.all
+
+      # Prepare Log List
+      file_list = prepare_list(file_list, base_list)
+
+      # Convert to Things
+      find_things(file_list, flags)
+    end
+
+    # Total Log List Manipulator
+    def self.prepare_list(log_list, base_list = nil, _flags = {})
+      base_list ||= GreenHat::ShellHelper::Log.list
+
+      # Assume all
+      log_list.push '*' if log_list.empty?
+
+      # Map for All
+      log_list = base_list.map(&:name) if log_list == ['*']
+
+      log_list
+    end
+
+    # Fuzzy match for things
+    def self.thing_list
+      @thing_list ||= Thing.all.map(&:name)
+
+      @thing_list
+    end
+
+    # Shortcut find things
+    def self.find_things(files, flags = {})
+      things = files.uniq.flat_map do |file|
+        # If Thing, Return Thing
+        return file if file.instance_of?(Thing)
+
+        if flags.fuzzy_file_match
+          Thing.all.select { |x| x.name.include? file }
+        else
+          Thing.where name: file
+        end
+      end.uniq
+
+      # Host / Archive
+      things.select! { |x| x.archive? flags.archive } if flags.key?(:archive)
+
+      things
+    end
+
+    # Main Entry Point for Searching
+    # def self.search_start(log_list, filter_type, args, opts)
+    def self.search_start(files, flags, args)
+      # Convert to Things
+      logs = ShellHelper.find_things(files, flags)
+
+      logs.each_with_object({}) do |log, obj|
+        # Ignore Empty Results / No Thing
+        next if log&.data.blank?
+
+        obj[log.friendly_name] = ShellHelper.search(log.data, flags, args)
+
+        obj
+      end
+    end
+
+    # Generic Search Helper / String/Regex
+    def self.search(data, flags = {}, args = {})
+      results = data.clone.flatten.compact
+      results.select! do |row|
+        args.send(flags.logic) do |arg|
+          search_row(row, arg, flags)
+        end
+      end
+
+      # Strip Results if Slice is defined
+      results.map! { |row| row.slice(*flags[:slice]) } if flags[:slice]
+
+      # Strip Results if Except is defined
+      results.map! { |row| row.except(*flags[:except]) } if flags[:except]
+
+      # Remove Blank from either slice or except
+      results.reject!(&:empty?)
+
+      results
+    end
+
+    # Break out filter row logic into separate method
+    def self.search_row(row, arg, flags)
+      # Sensitivity Check / Check for Match
+      included = filter_row_entry(row.to_s, arg, flags)
+
+      # Pivot of off include vs exclude
+      if arg.bang
+        !included
+      else
+        included
+      end
+    end
+
+    # TODO: Remove?
+    # Color Reader Helper
+    # def self.pastel
+    #   @pastel ||= Pastel.new
+    # end
+
+    # Number Helper
+    # https://gitlab.com/zedtux/human_size_to_number/-/blob/master/lib/human_size_to_number/helper.rb
+    def self.human_size_to_number(string)
+      size, unit = string.scan(/(\d*\.?\d+)\s?(Bytes?|KB|MB|GB|TB)/i).first
+      number = size.to_f
+
+      number = case unit.downcase
+               when 'byte', 'bytes'
+                 number
+               when 'kb'
+                 number * 1024
+               when 'mb'
+                 number * 1024 * 1024
+               when 'gb'
+                 number * 1024 * 1024 * 1024
+               when 'tb'
+                 number * 1024 * 1024 * 1024 * 1024
+               end
+      number.round
+    end
+
+    # TODO: Needed?
+    def self.filter_and(data, params = {})
+      result = data.clone.flatten.compact
+      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
+        next
+      end
+
+      result
+    end
+
+    # General Helper for `show`
+    def self.common_opts
+      puts 'Common Options'.pastel(:blue)
+      puts '  --raw'.pastel(:green)
+      puts '    Do not use less/paging'
+      puts
+
+      puts '  --archive'.pastel(:green)
+      puts '    Limit to specific archive name (inclusive). Matching SOS tar.gz name'
+      puts '    Ex: --archive=dev-gitlab_20210622154626, --archive=202106,202107'
+      puts
+    end
+  end
+  # rubocop:enable Metrics/ModuleLength
+end