greenhat 0.5.0 → 0.6.2

data/lib/greenhat/reports/internal_methods.rb

@@ -0,0 +1,156 @@
+# GreenHat Namespace
+module GreenHat
+  # Reports Parent Class
+  module Reports
+    # Method Helper Module
+    module InternalMethods
+      # Archive Header Printer
+      def archive_header(color = :blue)
+        puts archive.friendly_name.pastel(color)
+      end
+
+      # Header Printer
+      def header(text, color = :bright_yellow, bold = :bold)
+        puts text.pastel(color, bold)
+      end
+
+      # Raw Print
+      def cat(name, show_output, block)
+        thing = archive.thing? name
+        return unless thing
+
+        output = instance_exec(thing.raw_full, &block)
+        show output if show_output
+      end
+
+      # Parsed Print
+      def info(name, show_output, block)
+        thing = archive.thing? name
+        return unless thing
+
+        output = instance_exec(thing.data, &block)
+        show output if show_output
+      end
+
+      # Help
+      def help(block)
+        instance_exec(&block)
+      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
+
+        # Default to everything
+        files = archive.things if files.empty?
+
+        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 / Assume Format
+      def query_format(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
+        query_flags = archive.things if files.empty?
+
+        # Filter
+        results = GreenHat::Query.start(files, query_flags, query_args)
+
+        # Print and Exit of No Block / Show
+        return show(results) if block.nil? && show_output
+
+        block_output = instance_exec(results, &block)
+        show block_output if show_output
+      end
+
+      def faststats(raw, subcmd)
+        return true unless TTY::Which.exist? 'fast-stats'
+
+        files, _flags, cmd = ShellHelper::Faststats.parse(Shellwords.split(raw))
+
+        results = ShellHelper.file_process(files) do |file|
+          output = `fast-stats #{subcmd} #{cmd} #{file.file} 2>&1`
+          result = $CHILD_STATUS.success?
+
+          next unless result
+
+          [
+            file.name.pastel(:green),
+            output.split("\n"),
+            "\n"
+          ]
+        end
+
+        show results.compact.flatten
+      end
+
+      # TODO
+      # results = GreenHat::ShellHelper::Faststats.run(thing, 'top') # JSON FORMAT
+
+      # Paper Render Helper
+      def show(value)
+        if value.instance_of?(Array)
+          value.each do |x|
+            output.push GreenHat::Paper.new(data: x, flags: flags).render
+          end
+        else
+          output.push GreenHat::Paper.new(data: value, flags: flags).render
+        end
+      end
+
+      # Line Break Helper
+      def br(_ = nil)
+        puts
+      end
+
+      # Store for potential Paginated Response
+      def puts(text = '')
+        output.push text
+      end
+
+      # Accessor Helper
+      def archive
+        archive
+      end
+
+      def gitlab_version
+        thing = archive.thing? 'gitlab/version-manifest.json'
+        return unless thing
+
+        puts "#{'GitLab Version'.pastel(:cyan)}: #{thing.data.build_version}"
+      end
+
+      # ==============================================================================
+      # General Helpers
+      # ==============================================================================
+      # Indentation Helper
+      def indent(text, indent_value = 2)
+        if indent_value.zero?
+          text
+        else
+          "#{' ' * indent_value}#{text}"
+        end
+      end
+
+      def percent(value, total)
+        ((value / total.to_f) * 100).round
+      end
+
+      # Number Helper
+      def human_size_to_number(value)
+        GreenHat::ShellHelper.human_size_to_number value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+archive_header
+
+help do
+  header 'Error Reports'
+  puts 'This will collect errors from the exceptions, production, application, api, workhorse, and sidekiq logs'
+  puts 'Without arguments it will count and unique the error messages'
+  br
+  puts indent("#{'--verbose'.pastel(:green)} Print all of the error messages")
+  puts indent("#{'--filter'.pastel(:green)}  Filter Error messages")
+  puts indent('Ex: --filter=exception,production'.pastel(:cyan), 4)
+  puts indent('Ex: --filter!=api'.pastel(:cyan), 4)
+end
+
+entries = [
+  { header: 'Exceptions', base: 'gitlab-rails/exceptions_json.log', stats: 'exception.message,exception.class' },
+  { header: 'Production', base: 'gitlab-rails/production_json.log --status=500 ',
+    stats: 'exception.message,exception.class' },
+  {
+    header: 'Application',
+    base: 'gitlab-rails/application_json.log --message!="Cannot obtain an exclusive lease" --severity=error',
+    stats: 'message'
+  },
+  { 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' },
+  { 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|
+      !filter.bang if filter.value.split(',').any? { |x| entry.header.downcase.include? x }
+    end
+  end
+end
+
+# Return output
+entries.each do |entry|
+  query_string = flags[:verbose] ? entry.base : entry.base + " --stats=#{entry.stats}"
+  query(query_string, false) do |results|
+    next if results.empty?
+    next if !flags[:verbose] && results.map(&:values).map(&:first).sum.zero?
+
+    header entry.header
+
+    show results
+  end
+end

data/lib/greenhat/reports/reports/faststats.rb

@@ -0,0 +1,42 @@
+archive_header
+
+help do
+  header 'FastStats'
+  puts 'Run against all the things'
+  br
+  puts indent("#{'--filter'.pastel(:green)}  Filter for specific files")
+  puts indent('Ex: --filter=gitaly,production'.pastel(:cyan), 4)
+  puts indent('Ex: --filter!=api'.pastel(:cyan), 4)
+  br
+  puts indent("#{'--top'.pastel(:green)} switch to `fast-stats top [filename]`")
+  puts indent("#{'--errors'.pastel(:green)} switch to `fast-stats errors [filename]`")
+  br
+  puts indent("#{'--all'.pastel(:green)} to attempt to faststats everything")
+  br
+  puts 'Combine all the args: `faststats --filter=sidekiq --top --errors`'
+end
+
+cmds = []
+cmds.push 'top' if flags.top
+cmds.push 'errors' if flags.errors
+cmds.push nil if cmds.empty? # Assume Default
+
+filters = args_select(:filter).flat_map { |x| x.value.split(',') }
+
+if filters.empty?
+  # Add Defaults
+  filters = [
+    'gitaly/current',
+    'gitlab-rails/api_json.log',
+    'gitlab-rails/production_json.log',
+    'sidekiq/current'
+  ]
+end
+
+filters = ['*'] if flags.all
+
+filters.each do |filter|
+  cmds.each do |cmd|
+    faststats filter, cmd
+  end
+end

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

@@ -0,0 +1,143 @@
+quiet!
+archive_header
+header 'OS'
+
+cat 'hostname' do |data|
+  indent "#{'Hostname:'.pastel(:cyan)} #{data.join}"
+end
+
+info 'etc/os-release' do |data|
+  ident = "[#{data.ID}] ".pastel(:bright_black)
+  pretty_name = data.PRETTY_NAME
+  "  #{'Distro'.pastel(:cyan)} #{ident} #{pretty_name}"
+end
+
+cat 'uname' do |data|
+  value, build = data.first.split[2].split('-')
+  build = "(#{build})".pastel(:bright_black)
+  "  #{'Kernel'.pastel(:cyan)} #{value} #{build}"
+end
+
+cat 'uptime' do |data|
+  init = data.join.split(',  load average').first.strip.split('up ', 2).last
+  "  #{'Uptime'.pastel(:cyan)} #{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)
+    color = value > 100 ? :red : :green
+    [
+      interval,
+      ' (',
+      "#{value}%".pastel(color),
+      ')'
+    ].join
+  end
+
+  "  #{'LoadAvg'.pastel(:cyan)} #{"[CPU #{cpu_count}] ".pastel(:bright_white)} #{intervals_text.join(', ')}"
+end
+
+br
+header 'Memory'
+
+info('meminfo') do |data|
+  total = human_size_to_number(data['MemTotal'])
+  free = human_size_to_number(data['MemFree'])
+  used = percent((total - free), total)
+
+  [
+    '  ',
+    ljust('Usage', 13, :yellow),
+    '['.pastel(:bright_black),
+    '='.pastel(:green) * (used / 2),
+    ' ' * (50 - (used / 2)),
+    ']'.pastel(:bright_black),
+    " #{100 - percent(free, total)}%".pastel(:green) # Inverse
+  ].join
+end
+
+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, :cyan)} #{size}"
+  end
+
+  unless free.used.blank?
+    size = number_to_human_size(free.used.to_i * (1024**2))
+
+    puts "  #{ljust('Used', 12, :yellow)} #{size}"
+  end
+
+  unless free.free.blank?
+    size = number_to_human_size(free.free.to_i * (1024**2))
+    puts "  #{ljust('Free', 12, :blue)} #{size}"
+  end
+
+  unless free.available.blank?
+    size = number_to_human_size(free.available.to_i * (1024**2))
+    puts "  #{ljust('Available', 12, :green)} #{size}"
+  end
+
+  br
+  data.map { |x| GreenHat::Memory.memory_row x }.each do |row|
+    puts indent(row)
+  end
+end
+
+br
+header 'GitLab'
+info 'gitlab/version-manifest.json' do |data|
+  indent("#{'Version'.pastel(:cyan)}: #{data.build_version}")
+end
+
+info 'gitlab_status' do
+  indent(GreenHat::GitLab.services(archive, 3), 3)
+end
+
+br
+puts indent('Errors'.pastel(:cyan))
+
+query '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|
+  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|
+  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|
+  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|
+  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|
+  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|
+  color = data.count.zero? ? :green : :red
+  indent("#{ljust('Exceptions:', 14, :magenta)} #{data.count.to_s.pastel(color)}", 4)
+end

data/lib/greenhat/reports/runner.rb

@@ -0,0 +1,58 @@
+# GreenHat Namespace
+module GreenHat
+  # Reports NameSpace
+  module Reports
+    # This guy actually runs the reports
+    class Runner
+      include ActionView::Helpers::DateHelper
+      include ActionView::Helpers::NumberHelper
+
+      include InternalMethods
+      include Shared
+      attr_accessor :store, :archive, :flags, :args, :output
+
+      # Make Pry Easier
+      def inspect
+        "#<Runner archive: '#{archive}'>"
+      end
+
+      def initialize(archive:, store:, flags:, args:)
+        self.store = store
+        self.archive = archive
+        self.flags = flags
+        self.args = args
+        self.output = []
+
+        # Don't render paper new lines
+        # flags[:skip_new_line] = true
+      end
+
+      # Main Entrypoint for Triggering Reports Run
+      def run!
+        if flags.help
+          # Check for Help Flag
+          help_flag = store.find { |x| x.first == :help }
+          help_flag ? run_entry(help_flag) : puts('No Help :(')
+          return true
+        end
+
+        store.each do |entry|
+          next if entry.first == :help # Skip if no flags
+
+          run_entry(entry)
+        end
+
+        puts
+      rescue StandardError => e
+        puts e.message
+        puts e.backtrace
+      end
+
+      # Helper to evaluate Entry
+      def run_entry(entry)
+        method = entry[0]
+        send(method, *entry[1..])
+      end
+    end
+  end
+end

data/lib/greenhat/reports/shared.rb

@@ -0,0 +1,37 @@
+# GreenHat Namespace
+module GreenHat
+  # Reports Parent Class
+  module Reports
+    # Method Helper Module
+    module Shared
+      # Indentation Helper
+      def indent(text, indent_value = 2)
+        if indent_value.zero?
+          text
+        else
+          "#{' ' * indent_value}#{text}"
+        end
+      end
+
+      def percent(value, total)
+        ((value / total.to_f) * 100).round
+      end
+
+      # Justify Text Helper / With Color!
+      def ljust(text, value = 14, color = nil)
+        color ? text.ljust(value).pastel(color) : text.ljust(value)
+      end
+
+      # Number Helper
+      def human_size_to_number(value)
+        GreenHat::ShellHelper.human_size_to_number value
+      end
+
+      # Helper to filter arg selection
+      def args_select(field)
+        args.select { |x| x.field == field.to_sym }
+      end
+      # -=-=-=-=-=-
+    end
+  end
+end

data/lib/greenhat/reports/shell_helper.rb

@@ -0,0 +1,34 @@
+module GreenHat
+  module ShellHelper
+    # 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)
+        output = Archive.all.map do |archive|
+          runner = GreenHat::Reports::Runner.new(
+            archive: archive,
+            store: report.store.clone,
+            flags: flags,
+            args: args
+          )
+
+          runner.run!
+
+          runner
+        end
+
+        # Check for Pagination
+        flags[:page] = ENV['GREENHAT_PAGE'] == 'true' if ENV['GREENHAT_PAGE']
+
+        ShellHelper.show(output.flat_map(&:output), flags)
+      end
+
+      # Collect everything from Built-in and local reports
+      def self.list
+        path = "#{File.dirname(__FILE__)}/reports"
+        Dir["#{path}/*.rb"] + Dir["#{GreenHat::Settings.reports_dir}/*.rb"]
+      end
+    end
+  end
+end

data/lib/greenhat/reports.rb

@@ -0,0 +1,79 @@
+require 'greenhat'
+require 'greenhat/reports/internal_methods'
+require 'greenhat/reports/helpers'
+require 'greenhat/reports/runner'
+
+GreenHat::Cli.quiet!
+
+# GreenHat Namespace
+module GreenHat
+  # Reports Parent Class
+  module Reports
+    # Method Storing
+    def self.store
+      @store ||= []
+
+      @store
+    end
+
+    def self.output
+      @output ||= []
+    end
+
+    # Adding Methods
+    def self.add(*params)
+      store.push params
+    end
+
+    # Main Entrypoint for Triggering Reports Run
+    def self.run!
+      _list, flags, args = Args.parse(ARGV)
+
+      output = Archive.all.map do |archive|
+        runner = GreenHat::Reports::Runner.new(
+          archive: archive,
+          store: store.clone,
+          flags: flags,
+          args: args
+        )
+
+        runner.run!
+
+        break if flags.help # Only Run Once
+
+        runner
+      end
+
+      # Check for Pagination
+      flags[:page] = ENV['GREENHAT_PAGE'] == 'true' if ENV['GREENHAT_PAGE']
+
+      ShellHelper.show(output.flat_map(&:output), flags)
+    end
+
+    def self.archive_run(archive)
+      store.each do |entry|
+        method = entry[0]
+        # Skip anything for Shim'd Puts
+        if method == :puts
+          send(method, *entry[1..])
+        else
+          send(method, archive, *entry[1..])
+        end
+      end
+    rescue StandardError => e
+      puts e.message
+      puts e.backtrace
+    end
+    # ==
+  end
+end
+
+at_exit do
+  Dir.mktmpdir('greenhat-sauce') do |tmp|
+    $TMP = tmp
+    $STDOUT_CLONE = $stdout.clone
+    ENV['GREENHAT_REPORT'] = 'true' # Flag to allow skipping of different entypoints
+    GreenHat::Entrypoint.start(ARGV, false, false)
+    GreenHat::Reports.run!
+  end
+end

data/lib/greenhat/settings.rb

@@ -83,6 +83,7 @@ module GreenHat
 
     def self.start
       Dir.mkdir dir unless Dir.exist? dir
+      Dir.mkdir reports_dir unless Dir.exist? reports_dir
 
       # Load User Settings
       settings_load
@@ -92,7 +93,11 @@ module GreenHat
     end
 
     def self.dir
-      "#{ENV['HOME']}/.greenhat"
+      "#{Dir.home}/.greenhat"
+    end
+
+    def self.reports_dir
+      "#{dir}/reports"
     end
 
     # ----------------------------------

data/lib/greenhat/shell/args.rb

@@ -70,11 +70,18 @@ module GreenHat
       end
     end
 
+    # Arguments that Accept multiple options / Comma Delimted
+    def self.arg_special_split
+      %i[
+        slice except uniq pluck sort archive stats exists transform
+      ]
+    end
+
     # Flags Anything that isn't sent as a key/filter
     def self.arg_to_flag_list
       %i[
-        archive end except exists json limit pluck reverse round slice sort start
-        stats truncate uniq page time_zone table_style
+        archive end except exists json limit pluck reverse round slice sort start total
+        stats truncate uniq page time_zone table_style percentile interval percentile transform
       ]
     end
 
@@ -136,13 +143,6 @@ module GreenHat
       end
     end
 
-    # Arguments that Accept multiple options / Comma Delimted
-    def self.arg_special_split
-      %i[
-        slice except uniq pluck sort archive stats exists
-      ]
-    end
-
     # Arg Defaults
     def self.flag_arg_defaults(field)
       case field

data/lib/greenhat/shell/color_string.rb

@@ -3,7 +3,7 @@ module GreenHat
     # Helper to colorize and make outtput easier to read
     module StringColor
       def self.do(key, entry)
-        LogBot.debug('Unknown Format', entry.class) if ENV['DEBUG'] && !entry.instance_of?(String)
+        LogBot.debug('Unknown Format', entry.class) if ENV.fetch('DEBUG', nil) && !entry.instance_of?(String)
 
         # Other Helpful colorizers
         if pastel?(key)