greenhat 0.6.1 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4787b5c739b568b8f6f5d22bab609f685ed4e4ed725085c432809102174e9dd5
-  data.tar.gz: 7fcedca5675835ae177c58418dc2ddcaf25bae27333aeea9430e5a36d92a0b01
+  metadata.gz: 2bdaa3adc8b035c2b528472f1176e8104e75e369c0191926f2277a69170759b5
+  data.tar.gz: 9d5d1811e7efe201a93a2385ec08bb5f280adbf0e00b3e02dc70eab4d6fafe47
 SHA512:
-  metadata.gz: c54a1054bd1c38b8514d4cd4c2b38f1c851a463134399c6c5c1af4c81ae9ffe6dbde083856b4dcabd1f09b9b68c5632240fdce5f135b5f8c763d5c72dc7047b0
-  data.tar.gz: 894307efe02d22b50a4a6ca8674700409611e24cf8b46b9653b7f4b24f242b65a0f1649f4fd881bc636c92afea4d42085043b4a8cf3c4662b4535127f9e70b85
+  metadata.gz: 4bd0b3e175659ff78f984dea7cae51fcd3b5cce01171db9a74e6e77c0c3fd2b5bad48a2e52a8a0941674ed39858893a8035fe7f2582279752d07f25c0db06821
+  data.tar.gz: 35a342acfbea1e1dbcd70285f458cbed15822668fc06ae77a05ef8658667768be25560a1676bd3536bb2a80945bb9ea87d5b179aefc81c049ba4d951617b6f4f

data/lib/greenhat/accessors/disk.rb

@@ -11,7 +11,7 @@ module GreenHat
         x.slice(key)
       end
 
-      list.map(&:values).flatten.max_by(&:size).size + 4
+      list.map(&:values).flatten.max_by(&:size).size + 5
     end
 
     def self.padding(disks, keys = %i[mounted_on size used avail])
@@ -29,6 +29,44 @@ module GreenHat
       things
     end
 
+    def self.report_output(data, filter = %w[tmpfs loop])
+      output = []
+
+      disks = data.sort_by { |x| x.use.to_i }.reverse
+      disks.reject! { |x| filter.any? { |y| x.filesystem.include? y } }
+      pad_mount, pad_size, pad_used, pad_avail = GreenHat::Disk.padding(disks)
+
+      output << [
+        'Mount'.ljust(pad_mount).pastel(:blue),
+        'Size'.ljust(pad_size).pastel(:magenta),
+        'Used'.ljust(pad_used).pastel(:cyan),
+        'Avail'.ljust(pad_avail).pastel(:white),
+        '% Use'.ljust(pad_avail).pastel(:green)
+      ].join
+
+      disks.map do |disk|
+        # Pretty Disk Use
+        use = [
+          disk.use.rjust(5).ljust(5).pastel(:green),
+          '  ['.pastel(:blue),
+          ('=' * (disk.use.to_i / 2)).pastel(:green),
+          ' ' * (50 - (disk.use.to_i / 2)),
+          ']'.pastel(:blue)
+        ].join
+
+        # Whole Thing
+        output << [
+          disk.mounted_on.ljust(pad_mount).pastel(:blue),
+          disk[:size].to_s.ljust(pad_size).pastel(:magenta),
+          disk.used.to_s.ljust(pad_used).pastel(:cyan),
+          disk.avail.to_s.ljust(pad_avail).pastel(:white),
+          use
+        ].join
+      end
+
+      output.join("\n  ")
+    end
+
     # Unified Output Handler
     def self.format_output(file, name = false, limit = nil, filter = %w[tmpfs loop])
       output = []
@@ -79,13 +117,11 @@ module GreenHat
     end
 
     # Unified Output Handler
-    def self.markdown_format(file, name = false, limit = nil, filter = %w[tmpfs loop])
+    def self.markdown_format(data, _name = false, limit = nil, filter = %w[tmpfs loop])
       output = []
 
-      output << file.friendly_name if name
-
       # Reject TMPFS
-      disks = file.data.sort_by { |x| x.use.to_i }.reverse
+      disks = data.sort_by { |x| x.use.to_i }.reverse
 
       # Filter
       disks.reject! { |x| filter.any? { |y| x.filesystem.include? y } }
@@ -115,7 +151,7 @@ module GreenHat
         ].join
       end
 
-      output
+      output.join("\n")
     end
     # =
   end

data/lib/greenhat/accessors/gitlab.rb

@@ -26,7 +26,7 @@ module GreenHat
 
     def self.identify_node(archive)
       gitlab_status = archive.things.find { |x| x.name == 'gitlab_status' }&.data&.keys
-      hostname = archive.things.find { |x| x.type == 'hostname' }.data.first
+      hostname = archive.things.find { |x| x.type == 'hostname' }.data.first.chomp
 
       {
         host: hostname,

data/lib/greenhat/cli.rb

@@ -169,8 +169,6 @@ module GreenHat
     def self.did_you_mean
       dictionary = current_methods + current_submodules + cmd_list
 
-      # all.select! { |x| x.include? cmd }
-
       all = DidYouMean::SpellChecker.new(dictionary: dictionary).correct(cmd)
 
       if all.empty?

data/lib/greenhat/reports/builder.rb

@@ -6,12 +6,13 @@ module GreenHat
     class Builder
       include GreenHat::Reports::Shared
 
-      attr_accessor :store, :flags, :args
+      attr_accessor :store, :flags, :args, :raw_args
 
-      def initialize(file:, flags:, args:)
+      def initialize(file:, flags:, args:, raw_args:)
         self.store = []
         self.flags = flags
         self.args = args
+        self.raw_args = raw_args
         instance_eval File.read(file)
       rescue StandardError => e
         print "#{e.message}\n"
@@ -88,6 +89,10 @@ module GreenHat
         add(:query_format, query, show_output, block)
       end
 
+      def query_if_exists(query, show_output = true, &block)
+        add(:query_if_exists, query, show_output, block)
+      end
+
       # FastStats Helper
       def faststats(query, subcmd = '')
         add(:faststats, query, subcmd)

data/lib/greenhat/reports/helpers.rb

@@ -52,6 +52,10 @@ def query(query, show_output = true, &block)
   add(:query, query, show_output, block)
 end
 
+def query_if_exists(query, show_output = true, &block)
+  add(:query_if_exists, query, show_output, block)
+end
+
 # Log Query / Assume Format
 def query_format(query, show_output = true, &block)
   add(:query_format, query, show_output, block)

data/lib/greenhat/reports/internal_methods.rb

@@ -37,9 +37,32 @@ module GreenHat
         instance_exec(&block)
       end
 
+      # Log Query Ignore if no Files
+      def query_if_exists(query, show_output, block)
+        files, query_flags, query_args = GreenHat::Args.parse(Shellwords.split(query))
+
+        query_flags[:archive] = [archive.name] # Limit query to archive
+        query_flags[:combine] = true
+
+        # Default to everything
+        files = archive.things if files.empty?
+
+        # Ignore if no files are found
+        return unless ShellHelper.any_things?(files, query_flags)
+
+        results = Query.start(files, query_flags, query_args)
+
+        # Print and Exit of No Block / Show
+        return show(results) if block.nil? && show_output
+
+        output = instance_exec(results, &block)
+        show output if show_output
+      end
+
       # Log Query
       def query(query, show_output, block)
         files, query_flags, query_args = GreenHat::Args.parse(Shellwords.split(query))
+
         query_flags[:archive] = [archive.name] # Limit query to archive
         query_flags[:combine] = true
 

data/lib/greenhat/reports/reports/errors.rb

@@ -23,11 +23,13 @@ entries = [
   { header: 'Workhorse', base: 'gitlab-workhorse/current --level=error', stats: 'error' },
   { header: 'Sidekiq', base: 'sidekiq/current --severity=error', stats: 'message' },
   { header: 'API', base: 'gitlab-rails/api_json.log --severity=error',
-    stats: 'exception.class,exception.message,status' }
+    stats: 'exception.class,exception.message,status' },
+  { header: 'Gitaly', base: 'gitaly/current --level=error --truncate=99', stats: 'error' }
 ]
 
 # Filter Logic
 filters = args_select(:filter)
+
 unless filters.empty?
   entries.select! do |entry|
     filters.any? do |filter|
@@ -36,11 +38,23 @@ unless filters.empty?
   end
 end
 
+# Fuzzy Filter Match
+unless raw_args.empty?
+  entries.select! do |entry|
+    # Create a pattern with the file and title
+    globby = [entry.header.downcase, entry.base.split(' ', 2).first].join(' ')
+
+    # Check any Matches
+    raw_args.any? { |x| globby.include? x }
+  end
+end
+
 # Return output
 entries.each do |entry|
-  query_string = flags.verbose ? entry.base : entry.base + " --stats=#{entry.stats}"
+  query_string = flags[:verbose] ? entry.base : entry.base + " --stats=#{entry.stats}"
   query(query_string, false) do |results|
-    next if results.map(&:values).map(&:first).sum.zero?
+    next if results.empty?
+    next if !flags[:verbose] && results.map(&:values).map(&:first).sum.zero?
 
     header entry.header
 

data/lib/greenhat/reports/reports/full.rb

@@ -94,6 +94,13 @@ info('free_m', false) do |data|
   end
 end
 
+br
+header 'Disk'
+
+info 'df_hT' do |data|
+  indent GreenHat::Disk.report_output(data)
+end
+
 br
 header 'GitLab'
 info 'gitlab/version-manifest.json' do |data|
@@ -107,37 +114,43 @@ end
 br
 puts indent('Errors'.pastel(:cyan))
 
-query 'gitlab-rails/production_json.log --status=500' do |data|
+query_if_exists 'gitlab-rails/production_json.log --status=500' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Production:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'gitlab-rails/application_json.log --message!="Cannot obtain an exclusive lease" --severity=error' do |data|
+app_query = 'gitlab-rails/application_json.log --message!="Cannot obtain an exclusive lease" --severity=error'
+query_if_exists app_query do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Application:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'sidekiq/current --severity=error' do |data|
+query_if_exists 'sidekiq/current --severity=error' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Sidekiq:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'gitlab-rails/api_json.log --status=500' do |data|
+query_if_exists 'gitlab-rails/api_json.log --status=500' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('API:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'gitaly/current --level=error' do |data|
+query_if_exists 'gitaly/current --level=error' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Gitaly:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'gitlab-workhorse/current --level=error' do |data|
+query_if_exists 'gitlab-workhorse/current --level=error' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Workhorse:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
 
-query 'gitlab-rails/exceptions_json.log' do |data|
+query_if_exists 'gitlab-rails/exceptions_json.log' do |data|
   color = data.count.zero? ? :green : :red
   indent("#{ljust('Exceptions:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
 end
+
+query_if_exists('praefect/current --level=error') do |data|
+  color = data.count.zero? ? :green : :red
+  indent("#{ljust('Praefect:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
+end

data/lib/greenhat/reports/reports/full_markdown.rb

@@ -0,0 +1,140 @@
+quiet!
+
+puts '**OS**'
+br
+
+puts '```'
+cat 'hostname' do |data|
+  "Hostname: #{data.join}"
+end
+
+info 'etc/os-release' do |data|
+  ident = "[#{data.ID}] "
+  pretty_name = data.PRETTY_NAME
+  "  Distro: #{ident} #{pretty_name}"
+end
+
+cat 'uname' do |data|
+  value, build = data.first.split[2].split('-')
+  build = "(#{build})"
+  " Kernel: #{value} #{build}"
+end
+
+cat 'uptime' do |data|
+  init = data.join.split(',  load average').first.strip.split('up ', 2).last
+  "  Uptime: #{init}"
+end
+
+# Load Average
+info 'lscpu' do |data|
+  uptime = archive.thing? 'uptime'
+  return unless uptime
+
+  cpu_count = data['CPU(s)'].to_i
+  intervals = uptime.data.first.split('load average: ', 2).last.split(', ').map(&:to_f)
+
+  intervals_text = intervals.map do |interval|
+    value = percent(interval, cpu_count)
+    [
+      interval,
+      ' (',
+      "#{value}%",
+      ')'
+    ].join
+  end
+
+  "  LoadAvg: [CPU #{cpu_count}] #{intervals_text.join(', ')}"
+end
+puts '```'
+
+br
+puts '**Memory**'
+br
+
+puts '```'
+info('free_m', false) do |data|
+  free = data.first
+
+  unless free.total.blank?
+    size = number_to_human_size(free.total.to_i * (1024**2))
+    puts "  #{ljust('Total', 12)} #{size}"
+  end
+
+  unless free.used.blank?
+    size = number_to_human_size(free.used.to_i * (1024**2))
+
+    puts "  #{ljust('Used', 12)} #{size}"
+  end
+
+  unless free.free.blank?
+    size = number_to_human_size(free.free.to_i * (1024**2))
+    puts "  #{ljust('Free', 12)} #{size}"
+  end
+
+  unless free.available.blank?
+    size = number_to_human_size(free.available.to_i * (1024**2))
+    puts "  #{ljust('Available', 12)} #{size}"
+  end
+
+  # br
+  # data.map { |x| GreenHat::Memory.memory_row x }.each do |row|
+  #   puts row
+  # end
+end
+puts '```'
+
+br
+puts '**Disks**'
+br
+
+puts '```'
+info 'df_hT' do |data|
+  GreenHat::Disk.markdown_format(data, false, 3)
+end
+puts '```'
+
+br
+puts '**GitLab**'
+info 'gitlab/version-manifest.json' do |data|
+  "Version: #{data.build_version}"
+end
+
+br
+
+info 'gitlab_status' do
+  GreenHat::GitLab.services_markdown(archive)
+end
+
+br
+puts '**Errors**'
+br
+
+puts '```'
+query 'gitlab-rails/production_json.log --status=500' do |data|
+  ljust('Production', 14) + data.count.to_s
+end
+
+query 'gitlab-rails/application_json.log --message!="Cannot obtain an exclusive lease" --severity=error' do |data|
+  ljust('Application', 14) + data.count.to_s
+end
+
+query 'sidekiq/current --severity=error' do |data|
+  ljust('Sidekiq', 14) + data.count.to_s
+end
+
+query 'gitlab-rails/api_json.log --status=500' do |data|
+  ljust('API', 14) + data.count.to_s
+end
+
+query 'gitaly/current --level=error' do |data|
+  ljust('Gitaly', 14) + data.count.to_s
+end
+
+query 'gitlab-workhorse/current --level=error' do |data|
+  ljust('Workhorse', 14) + data.count.to_s
+end
+
+query 'gitlab-rails/exceptions_json.log' do |data|
+  ljust('Exceptions', 14) + data.count.to_s
+end
+puts '```'

data/lib/greenhat/reports/runner.rb

@@ -9,18 +9,19 @@ module GreenHat
 
       include InternalMethods
       include Shared
-      attr_accessor :store, :archive, :flags, :args, :output
+      attr_accessor :store, :archive, :flags, :args, :raw_args, :output
 
       # Make Pry Easier
       def inspect
         "#<Runner archive: '#{archive}'>"
       end
 
-      def initialize(archive:, store:, flags:, args:)
+      def initialize(archive:, store:, flags:, args:, raw_args:)
         self.store = store
         self.archive = archive
         self.flags = flags
         self.args = args
+        self.raw_args = raw_args
         self.output = []
 
         # Don't render paper new lines

data/lib/greenhat/reports/shared.rb

@@ -31,6 +31,7 @@ module GreenHat
       def args_select(field)
         args.select { |x| x.field == field.to_sym }
       end
+
       # -=-=-=-=-=-
     end
   end

data/lib/greenhat/reports/shell_helper.rb

@@ -3,14 +3,15 @@ module GreenHat
     # Log Helpers
     module Reports
       # Make Running more consistent
-      def self.run(file:, args:, flags:)
-        report = GreenHat::Reports::Builder.new(file: file, args: args, flags: flags)
+      def self.run(file:, args:, flags:, raw_args:)
+        report = GreenHat::Reports::Builder.new(file: file, args: args, flags: flags, raw_args: raw_args)
         output = Archive.all.map do |archive|
           runner = GreenHat::Reports::Runner.new(
             archive: archive,
             store: report.store.clone,
             flags: flags,
-            args: args
+            args: args,
+            raw_args: raw_args
           )
 
           runner.run!
@@ -29,6 +30,17 @@ module GreenHat
         path = "#{File.dirname(__FILE__)}/reports"
         Dir["#{path}/*.rb"] + Dir["#{GreenHat::Settings.reports_dir}/*.rb"]
       end
+
+      # Collect everything from Built-in and local reports
+      def self.auto_complete_list
+        path = "#{File.dirname(__FILE__)}/reports"
+        list = Dir["#{path}/*.rb"] + Dir["#{GreenHat::Settings.reports_dir}/*.rb"]
+
+        list.map do |entry|
+          File.basename(entry, '.rb')
+        end
+      end
+      # --
     end
   end
 end

data/lib/greenhat/settings.rb

@@ -82,8 +82,8 @@ module GreenHat
     # rubocop:enable Style/GuardClause
 
     def self.start
-      Dir.mkdir dir unless Dir.exist? dir
-      Dir.mkdir reports_dir unless Dir.exist? reports_dir
+      FileUtils.mkdir_p dir
+      FileUtils.mkdir_p reports_dir
 
       # Load User Settings
       settings_load

data/lib/greenhat/shell/gitlab.rb

@@ -35,7 +35,7 @@ module GreenHat
         results = Archive.all.map { |x| GitLab.identify_node(x) }
 
         GitLab.node_types.each do |entry|
-          list = results.select { |x| (x.services & entry.pattern).any? }.map(&:host).join(', ')
+          list = results.select { |x| (x.services & entry.pattern).any? }.map(&:host).join("\n")
           next if list.blank?
 
           puts entry.name.pastel(:bright_green)
@@ -88,7 +88,6 @@ module GreenHat
                 "#{service.status}:",
                 service.name.ljust(pad).pastel(color),
                 "#{service.pid_uptime};".ljust(pad)
-
               ]
             end
 

data/lib/greenhat/shell/log.rb

@@ -125,10 +125,18 @@ module GreenHat
           return false
         end
 
-        Thing.new.query_save(results, name)
+        Thing.new.query_save(save_greenhat_query_info + results, name)
         puts "#{name.pastel(:green)} Saved!"
       end
 
+      def self.save_greenhat_query_info
+        [{
+          time: Time.now,
+          query: ShellHelper::Log.last,
+          msg: 'GreenHat Save/Write'
+        }]
+      end
+
       def self.write(raw = [])
         if ShellHelper::Log.last.nil?
           puts 'No previous query found'.pastel(:red)
@@ -158,7 +166,7 @@ module GreenHat
           return false
         end
 
-        all = results.map { |row| Oj.dump(row) }
+        all = (save_greenhat_query_info + results).map { |row| Oj.dump(row) }
         File.write(name, all.join("\n"))
         puts "#{name.pastel(:green)} File Written!"
       end

data/lib/greenhat/shell/platform.rb

@@ -12,12 +12,19 @@ module GreenHat
     end
 
     def self.open(url = 'http://localhost:4567/chart/time')
-      cmd = if platform.linux? || platform.unix?
-              'xdg-open'
-            elsif platform.mac?
+      cmd = if platform.mac?
               'open'
+            elsif platform.linux? || platform.unix?
+              'xdg-open'
             end
 
+      # See if anything was detected -- ignore system call if nothing was
+      if cmd.nil?
+        puts "Unknown OS! #{RbConfig::CONFIG['arch']}"
+        puts url
+        return
+      end
+
       # platform.windows?  # => false
       # platform.unix?     # => true
       # platform.linux?    # => false

data/lib/greenhat/shell/query.rb

@@ -215,7 +215,7 @@ module GreenHat
       results = filter_pluck(results, flags[:pluck]) if flags.key?(:pluck)
 
       # Total Counter
-      return [ShellHelper.total_count(results, flags)] if flags.key?(:total)
+      results = ShellHelper.total_count(results, flags) if flags.key?(:total)
 
       results
     end

data/lib/greenhat/shell/reports.rb

@@ -10,6 +10,20 @@ module GreenHat
   module Shell
     # Logs
     module Reports
+      def self.auto_complete(_list, word)
+        matches = GreenHat::ShellHelper::Reports.auto_complete_list.select do |x|
+          x.include? word
+        end
+
+        if matches.count > 1
+          puts "#{'Report Options:'.pastel(:bright_blue)} #{matches.join(' ').pastel(:bright_green)}"
+
+          Cli.common_substr(matches.map(&:to_s))
+        elsif matches.count == 1
+          matches.first
+        end
+      end
+
       # Easy Show All
       def self.ls(raw = [])
         filter, _flags, _args = Args.parse(raw)
@@ -33,7 +47,8 @@ module GreenHat
         run_list.uniq!
 
         run_list.each do |file|
-          GreenHat::ShellHelper::Reports.run(file: file, args: args, flags: flags)
+          raw_args = list.reject { |x| file.include? x }
+          GreenHat::ShellHelper::Reports.run(file: file, args: args, flags: flags, raw_args: raw_args)
         end
       end
     end