greenhat 0.3.4 → 0.5.0

data/lib/greenhat/shell/query.rb

@@ -0,0 +1,378 @@
+# NameSpace
+module GreenHat
+  # Query Handlers
+  # rubocop:disable Metrics/ModuleLength
+  module Query
+    # Main Entry Point for Filtering
+    def self.start(files, flags = {}, args = {})
+      # Convert to Things
+      files = ShellHelper.find_things(files, flags).select(&:query?)
+
+      # Ignore Archive/Host Dividers
+      if flags[:combine]
+        results = files.reject(&:blank?).map(&:data).flatten.compact
+        Query.filter(results, flags, args)
+      else
+        # Iterate and Preserve Archive/Host Index
+        files.each_with_object({}) do |file, obj|
+          # Ignore Empty Results / No Thing
+          next if file&.blank?
+
+          # Include Total Count in Name
+          results = Query.filter(file.data, flags, args)
+          duration = calculate_duration(results)
+
+          title = [
+            file.friendly_name,
+            " #{results.count}".pastel(:bright_black)
+
+          ]
+
+          # Append Duration
+          title.push(" #{duration.pastel(:cyan, :dim)}") unless duration.blank?
+
+          # Save unless empty
+          obj[title.join] = results unless results.count.zero?
+
+          obj
+        end
+      end
+    end
+
+    def self.calculate_duration(results)
+      # Skip for Pluck
+      only_with_time = results.select { |x| x.instance_of?(Hash) && x.key?(:time) }
+
+      # If slice is used ignore
+      return nil if only_with_time.empty?
+
+      sorted = only_with_time.map(&:time).sort
+      humanize_time(sorted.first, sorted.last)
+    end
+
+    # Replace TimeDifference with https://stackoverflow.com/a/4136485/1678507
+    def self.humanize_time(time_start, time_end, increments = 2)
+      miliseconds = (time_end - time_start) * 1000
+
+      list = [[1000, :ms], [60, :s], [60, :m], [24, :h]].map do |count, name|
+        next unless miliseconds.positive?
+
+        miliseconds, n = miliseconds.divmod(count)
+
+        "#{n.to_i}#{name}" unless n.to_i.zero?
+      end
+
+      list.compact.reverse[0..increments - 1].join(' ')
+    end
+
+    # Filter Logic
+    # TODO: Simplify
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.filter(data, flags = {}, args = {})
+      # Experimenting with deep clone
+      # results = Marshal.load(Marshal.dump(data))
+      results = data.clone
+      # results = data
+
+      results.select! do |row|
+        args.send(flags.logic || :all?) 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 Zone
+      results = filter_modify_timezone(results, flags[:time_zone]) if flags.key?(:time_zone)
+
+      # 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) if flags.key?(:stats)
+
+      # Limit before Pluck / Flattening
+      results = filter_limit(results, flags[:limit]) if flags.key?(:limit)
+
+      # Pluck
+      results = filter_pluck(results, flags[:pluck]) if flags.key?(:pluck)
+
+      results
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # Limit / Ensure Exists and Valid Number
+    def self.filter_limit(results, limit)
+      return results unless limit.integer? && limit.positive?
+
+      results.shift limit
+    end
+
+    def self.filter_modify_timezone(results, time_zone)
+      results.map do |x|
+        next unless x.key? :time
+
+        x = x.clone # Prevent Top Level Modification
+        x[:time] = x[:time].in_time_zone time_zone
+
+        x
+      end
+    end
+
+    # Filter Start and End Times
+    # 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
+
+    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.filter_slice(results, slice)
+      # Avoid Empty Results
+      if slice.empty?
+        filter_empty_arg('slice')
+        return results
+      end
+
+      results.compact.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, flags)
+      stats = flags[: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, flags)
+
+        # Use Truncate For Long Keys
+        occurrences.transform_keys! { |key| key.to_s[0..flags[:truncate]] } if flags[:truncate]
+
+        # 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, flags = {})
+      results.each_with_object(Hash.new(0)) do |entry, counts|
+        if entry.key? field
+          # Rounding in pagination breaks stats
+          key = if flags.key?(:round) && entry[field].numeric?
+                  entry[field].to_f.round(flags.round)
+                else
+                  entry[field]
+                end
+
+          counts[key] += 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)
+      return false if row.nil? # Nothing to filter if row empty
+
+      # 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
+      search_data = arg[:field] == :text ? row : row[arg.field]
+      match = filter_row_entry(search_data.to_s, arg, flags)
+
+      # Pivot of off include vs exclude
+      if arg.bang
+        !match
+      else
+        match
+      end
+    end
+
+    # Field Partial / Case / Exact search
+    def self.filter_row_entry(entry, arg, flags)
+      # Exact Matching / Unless doing full text search
+      return entry == arg.value.to_s if flags.key?(:exact) && arg.field != :text
+
+      # Cast to String/Integer Helper
+      entry, value = filter_entry_cast(entry, arg, flags)
+
+      entry.send(arg.logic, value)
+    end
+
+    # Handle casting to strings or integers
+    def self.filter_entry_cast(entry, arg, flags)
+      # Cast to String
+      value = arg.value.to_s
+
+      # No Logic on Empty Entries
+      return [entry, value] if entry.empty?
+
+      case arg.logic
+      when :include?
+
+        # Exact Case argument
+        unless flags.key?(:case)
+          entry = entry.downcase
+          value = value.downcase
+        end
+      when :>=, :<=
+        entry = entry.to_i if entry.numeric?
+        value = value.to_i if value&.numeric?
+      end
+
+      [entry, value]
+    end
+
+    def self.filter_entry_logic(entry, arg)
+      entry.send(arg.logic, arg.value)
+    end
+  end
+
+  # Internal Query Helper
+  # query = 'gitlab-rails/application_json.log --message!="Cannot obtain an exclusive lease" --severity=error'
+  # Query.filter_internal(query)
+  def self.filter_internal(search = '')
+    files, flags, args = Args.parse(Shellwords.split(search))
+    flags[:combine] = true
+
+    # Default to everything
+    files = Thing.all.map(&:name) if files.empty?
+
+    Query.start(files, flags, args)
+  end
+
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/greenhat/shell/report.rb

@@ -12,7 +12,11 @@ module GreenHat
                    Archive.all
                  end
 
-      ShellHelper.show(archives.map(&:report).map(&:show).flatten, flags)
+      output = archives.map { |x| x.report(flags) }.map(&:show).flatten
+
+      flags[:page] = true if flags.full && !flags.raw
+
+      ShellHelper.show(output, flags)
     end
   end
 end
@@ -23,15 +27,16 @@ module GreenHat
   class Report
     include ActionView::Helpers::NumberHelper
 
-    attr_accessor :archive, :host, :os_release, :selinux_status, :cpu, :uname,
+    attr_accessor :archive, :flags, :host, :os_release, :selinux_status, :cpu, :uname,
                   :timedatectl, :uptime, :meminfo, :gitlab_manifest, :gitlab_status,
-                  :production_log, :api_log, :application_log, :sidekiq_log,
+                  :production_log, :api_log, :sidekiq_log,
                   :exceptions_log, :gitaly_log, :free_m, :disk_free
 
     # Find Needed Files for Report
     # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-    def initialize(archive)
+    def initialize(archive, flags)
       self.archive = archive
+      self.flags = flags
       self.host = archive.things.find { |x| x.name == 'hostname' }
       self.os_release = archive.things.find { |x| x.name == 'etc/os-release' }
       self.selinux_status = archive.things.find { |x| x.name == 'sestatus' }
@@ -45,7 +50,6 @@ module GreenHat
       self.gitlab_status = archive.things.find { |x| x.name == 'gitlab_status' }
       self.production_log = archive.things.find { |x| x.name == 'gitlab-rails/production_json.log' }
       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.exceptions_log = archive.things.find { |x| x.name == 'gitlab-rails/exceptions_json.log' }
       self.gitaly_log = archive.things.find { |x| x.name == 'gitaly/current' }
       self.sidekiq_log = archive.things.find { |x| x.name == 'sidekiq/current' }
@@ -87,13 +91,16 @@ module GreenHat
       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
+      output << title('Errors') if production_log || api_log || sidekiq_log
       output << production_errors if production_log
-      output << application_errors if application_log
+      output << application_errors if archive.thing?('gitlab-rails/application_json.log')
       output << sidekiq_errors if sidekiq_log
       output << api_errors if api_log
       output << exception_errors if exceptions_log
       output << gitaly_errors if gitaly_log
+      output << workhorse_errors if archive.thing?('gitlab-workhorse/current')
+
+      full(output) if flags.full
 
       # Final Space / Return
       output << ''
@@ -101,6 +108,17 @@ module GreenHat
     end
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
 
+    def full(output)
+      output << ''
+      output << 'FastStats Top'
+      Shell::Faststats.top(['--raw'], true).each { |x| output << x } # Page Row Helper
+      output << ''
+
+      output << 'FastStats Errors'
+      Shell::Faststats.errors(['--raw'], true).each { |x| output << x } # Page Row Helper
+      output << ''
+    end
+
     def exception_errors
       count = exceptions_log.data.count
       color = count.zero? ? :green : :red
@@ -111,6 +129,21 @@ module GreenHat
       ].join
     end
 
+    def workhorse_errors
+      results = ShellHelper.filter_internal([
+        'gitlab-workhorse/current',
+        '--level=error',
+        "--archive=#{archive.name}"
+      ].join(' '))
+
+      color = results.count.zero? ? :green : :red
+
+      [
+        title('  Workhorse', :bright_red, 18),
+        results.count.to_s.pastel(color)
+      ].join
+    end
+
     def gitaly_errors
       count = gitaly_log.data.count { |x| x.level == 'error' }
       color = count.zero? ? :green : :red
@@ -145,7 +178,8 @@ module GreenHat
       results = ShellHelper.filter_internal([
         'gitlab-rails/application_json.log',
         '--message!="Cannot obtain an exclusive lease"',
-        '--severity=error'
+        '--severity=error',
+        "--archive=#{archive.name}"
       ].join(' '))
 
       count = results.count { |x| x&.severity == 'ERROR' }
@@ -200,6 +234,8 @@ module GreenHat
     end
 
     def selinux
+      return nil if selinux_status.data.nil?
+
       status = selinux_status.data['SELinux status']
       status_color = status == 'enabled' ?  :green : :red
 
@@ -300,7 +336,7 @@ module GreenHat
         title('Usage'),
         '  ['.pastel(:bright_black),
         '='.pastel(:green) * (used / 2),
-        ' ' * (50 - used / 2),
+        ' ' * (50 - (used / 2)),
         ']'.pastel(:bright_black),
         " #{100 - percent(free, total)}%".pastel(:green) # Inverse
       ].join
@@ -313,21 +349,37 @@ module GreenHat
 
       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),
-        "\n",
-        title('Used', :yellow, 14),
-        number_to_human_size(free.used.to_i * 1024**2),
-        "\n",
-        title('Free', :blue, 14),
-        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),
-        "\n\n",
-        formatted_mem.map { |x| x.prepend ' ' * 2 }.join("\n")
-      ].join
+      output = []
+      unless free.total.blank?
+        output << title('Total', :cyan, 14)
+        output << number_to_human_size(free.total.to_i * (1024**2))
+        output << "\n"
+      end
+
+      unless free.total.blank?
+        output << title('Used', :yellow, 14)
+        output << number_to_human_size(free.used.to_i * (1024**2))
+        output << "\n"
+      end
+
+      unless free.total.blank?
+        output << title('Free', :blue, 14)
+        output << number_to_human_size(free.free.to_i * (1024**2))
+        output << "\n"
+      end
+
+      unless free.total.blank?
+        output << title('Available', :green, 14)
+        output << number_to_human_size(free.available.to_i * (1024**2))
+        output << "\n"
+      end
+
+      output << "\n"
+      output << formatted_mem.map { |x| x.prepend ' ' * 2 }.join("\n")
+
+      output.join
+    rescue StandardError => e
+      LogBot.fatal('Memory', message: e.message, backtrace: e.backtrace.first)
     end
 
     def disks