greenhat 0.2.0 → 0.3.3

data/lib/greenhat/shell/filter.rb

@@ -1,128 +0,0 @@
-module GreenHat
-  # CLI Helper
-  module ShellHelper
-    # Unify Filter / Filter Help
-    module Filter
-      # rubocop:disable Metrics/MethodLength
-      def self.help
-        puts "\u2500".colorize(:cyan) * 20
-        puts 'Filter'.colorize(:yellow)
-        puts "\u2500".colorize(:cyan) * 20
-
-        puts 'Options'.colorize(:blue)
-        puts '--raw'.colorize(:green)
-        puts '  Do not use less/paging'
-        puts
-
-        puts '--page'.colorize(:green)
-        puts '  Specifically enable or disable paging'
-        puts '  E.g. --page (default to true), --page=true, --page=false'
-        puts
-
-        puts '--round'.colorize(:green)
-        puts '  Attempt to round all integers. Default: 2.'
-        puts '  E.g. --round, --round=3, --round=0'
-        puts
-
-        puts '--truncate'.colorize(:green)
-        puts '  Limit output values. Defaults to 4 lines. 0 to disable'
-        puts '  E.g. --truncate=100 or --truncate=0'
-        puts
-
-        puts '--json'.colorize(:green)
-        puts '  Print output back into JSON'
-        puts
-
-        puts '--or'.colorize(:green)
-        puts '  Filters will use OR instead of AND'
-        puts
-
-        puts '--total'.colorize(:green)
-        puts '  Print only total count of matching entries'
-        puts
-
-        puts '--slice'.colorize(:green)
-        puts '  Extract specific fields from entries (slice multiple with comma)'
-        puts '  Ex: --slice=path or --slice=path,params'
-        puts
-
-        puts '--except'.colorize(:green)
-        puts '  Exclude specific fields (except multiple with comma)'
-        puts '  Ex: --except=params --except=params,path'
-        puts
-
-        puts '--stats'.colorize(:green)
-        puts '  Order/Count occurrances by field'
-        puts '  Ex: --stats=params --except=params,path'
-        puts
-
-        puts '--uniq'.colorize(:green)
-        puts '  Show unique values only'
-        puts '  Ex: --uniq=params --uniq=params,path'
-        puts
-
-        puts '--pluck'.colorize(:green)
-        puts '  Extract values from entries'
-        puts '  Ex: --pluck=params --pluck=params,path'
-        puts
-
-        puts '--archive'.colorize(:green)
-        puts '  Limit to specific archvie name (inclusive). Matching SOS tar.gz name'
-        puts '  Ex: --archive=dev-gitlab_20210622154626, --archive=202106,202107'
-        puts
-
-        puts '--sort'.colorize(:green)
-        puts '  Sort by multiple fields'
-        puts '  Ex: --sort=duration_s,db_duration_s'
-        puts
-
-        puts '--reverse'.colorize(:green)
-        puts '  Reverse all results'
-        puts '  Ex: --reverse'
-        puts
-
-        puts '--combine'.colorize(:green)
-        puts '  Omit archive identifier dividers. Useful with sort or time filters'
-        puts '  Ex: --combine'
-        puts
-
-        puts '--start'.colorize(:green)
-        puts '  Show events after specified time. Filtered by the `time` field'
-        puts '  Use with `--end` for between selections'
-        puts '  Ex: log filter --start="2021-06-22 14:44 UTC" --end="2021-06-22 14:45 UTC"'
-        puts
-
-        puts '--end'.colorize(:green)
-        puts '  Show events before specified time. Filtered by the `time` field'
-        puts '  Use with `--start` for between selections'
-        puts '  Ex: log filter --end="2021-06-22"'
-        puts
-
-        puts '--truncate'.colorize(:green)
-        puts '  Truncate field length. On by default (4 rows). Performance issues!'
-        puts '  Disable with --truncate=0'.colorize(:light_red)
-        puts '  Ex: --truncate=200, --truncate=2048"'
-        puts
-
-        puts 'Field Searching'.colorize(:blue)
-        puts '  --[key]=[value]'
-        puts '  Search in key for value'
-        puts '  Example: --path=mirror/pull'
-        puts
-
-        puts 'Search specific logs'.colorize(:blue)
-        puts '  Any non dash parameters will be the log list to search from'
-        puts "  Ex: log filter --path=api sidekiq/current (hint: use  `#{'ls'.colorize(:yellow)}` for log names"
-        puts
-
-        puts 'Example Queries'.colorize(:blue)
-        puts "  Also see #{'examples'.colorize(:light_blue)} for even more examples"
-        puts '  log filter --class=BuildFinishedWorker sidekiq/current --slice=time,message'
-        puts '  log filter gitlab-rails/api_json.log --slice=ua --uniq=ua --ua=gitlab-runner'
-
-        puts
-      end
-      # rubocop:enable Metrics/MethodLength
-    end
-  end
-end

data/lib/greenhat/shell/helper.rb

@@ -1,584 +0,0 @@
-module GreenHat
-  # Common Helpers
-  # rubocop:disable Metrics/ModuleLength
-  module ShellHelper
-    # Generic Parameter Parsing
-    def self.param_parse(params, skip_args = [])
-      # Turn Params into Hash
-      opts = params.flat_map { |param| param_opt_scan(param) }
-
-      # Collect and Remove Args
-      args = params.each_with_object({}) { |param, obj| param_arg_scan(param, obj) }
-
-      # Move Special Arguments
-      opts.reject! do |opt|
-        if param_special_opts.include? opt.field
-          args[opt.field] = opt.value.split(',').map(&:to_sym)
-          true
-        end
-      end
-
-      # Remove Opts and Args
-      params.reject! do |param|
-        opt_field_remove?(opts, param) || arg_field_remove?(args, param)
-      end
-
-      # Update other user defaults
-      Settings.default_log_args(args, skip_args)
-
-      [params, opts, args]
-    end
-
-    def self.opt_field_remove?(opts, param)
-      opts.any? do |opt|
-        param.include? "--#{opt.field}#{opt.bang ? '!' : nil}=#{opt.value}"
-      end
-    end
-
-    def self.arg_field_remove?(args, param)
-      args.keys.any? { |field| param.include? "--#{field}" }
-    end
-
-    # Def Param Scan (Split -- values into keys)
-    def self.param_opt_scan(param)
-      param.scan(/--([^=]+)=(.*)/).map do |field, value|
-        bang = false
-        if field.include? '!'
-          field.delete!('!')
-          bang = true
-        end
-
-        { field: field.to_sym, value: value, bang: bang }
-      end
-    end
-
-    # Params that should be set as Args
-    # Comma Delimited
-    # --slice=thing,thing2
-    # --except=time,params
-    # --round=2
-
-    def self.param_special_opts
-      %i[
-        slice except stats uniq pluck round archive start end sort limit truncate page case
-      ]
-    end
-
-    # Parameter Extraction
-    # Special Opts: --slice, --except
-    def self.param_arg_scan(param, obj)
-      # TODO: Why is capture group doing two arrays
-      param.scan(/--([^=]+)$/).flatten.each do |field|
-        obj[field.to_sym] = param_arg_defaults(field.to_sym)
-      end
-
-      obj
-    end
-
-    # Arg Defaults
-    def self.param_arg_defaults(field)
-      case field
-      when :round then [2]
-      when :limit then [TTY::Screen.height / 2]
-      when :truncate then [TTY::Screen.width * 4]
-      when :page, :case then [:true]
-      when *param_special_opts then []
-      else
-        true
-      end
-    end
-
-    # Use File Process for Output
-    def self.file_output(files)
-      results = file_process(files) do |file|
-        [
-          file.friendly_name,
-          file.output(false),
-          "\n"
-        ]
-      end
-
-      ShellHelper.show(results.flatten)
-    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, args = {})
-      # If Block of String
-      if data.instance_of?(String)
-        TTY::Pager.page data
-        return true
-      end
-
-      # If raw just print out
-      if args.raw
-        puts data.join("\n")
-        return true
-      end
-
-      # Check if content needs to paged, or if auto_height is off
-      if Page.skip?(args, data)
-        puts data.map { |entry| entry_show(args, entry) }.compact.join("\n")
-        return true
-      end
-
-      # Default Pager
-      TTY::Pager.page do |pager|
-        data.each do |entry|
-          output = entry_show(args, entry)
-
-          next if output.blank?
-
-          pager.write("\n#{output}") # write line to the pager
-        end
-      end
-    end
-
-    # Entry Shower / Top Level
-    def self.entry_show(args, entry, key = nil)
-      LogBot.debug('Entry Show', entry.class) if ENV['DEBUG']
-      case entry
-      when Hash then render_table(entry, args)
-      when Float, Integer, Array
-        format_table_entry(args, 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(args, entry, key = nil)
-      formatted_entry = case entry
-                        # Rounding
-                        when Float, Integer || entry.numeric?
-                          args.round ? entry.to_f.round(args.round.first.to_s.to_i).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(args, x) }.join("\n")
-
-                        when Time
-                          entry.to_s.colorize(:light_white)
-
-                        # Default String Formatting
-                        else
-                          StringColor.do(key, entry)
-                        end
-
-      if args[:truncate]
-        entry_truncate(formatted_entry, args[:truncate].join.to_i)
-      else
-        formatted_entry
-      end
-    rescue StandardError => e
-      binding.pry
-    end
-
-    # Print the Table in a Nice way
-    def self.render_table(entry, args)
-      entry = entry.map { |k, v| [k, format_table_entry(args, 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
-
-        # renderer.filter = lambda do |val, _row_index, col_index|
-        #   render_table_entry(val, col_index, args)
-        # end
-      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)).colorize(:cyan),
-        "\n"
-      ].join("\n")
-    end
-
-    def self.render_table_entry(val, col_index, args)
-      return val.to_s unless col_index == 1
-
-      format_table_entry(args, val)
-    end
-
-    # Main Entry Point for Filtering
-    def self.filter_start(log_list, filter_type, args, opts)
-      # Convert to Things
-      logs = ShellHelper.find_things(log_list, args).select(&:processed?)
-
-      # Ignore Archive/Host Dividers
-      if args[:combine]
-        results = logs.reject(&:blank?).map(&:data).flatten.compact
-        ShellHelper.filter(results, filter_type, args, opts)
-      else
-        # Iterate and Preserve Archive/Host Index
-        logs.each_with_object({}) do |log, obj|
-          # Ignore Empty Results / No Thing
-          next if log&.blank?
-
-          obj[log.friendly_name] = ShellHelper.filter(log.data, filter_type, args, opts)
-
-          obj
-        end
-      end
-    end
-
-    # Filter Logic
-    # TODO: Simplify
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def self.filter(data, type = :all?, args = {}, opts = {})
-      results = data.clone.flatten.compact
-      results.select! do |row|
-        opts.send(type) do |opt|
-          filter_row_key(row, opt, args)
-        end
-      end
-
-      # Time Filtering
-      results = filter_time(results, args) if args[:start] || args[:end]
-
-      # Strip Results if Slice is defined
-      results = filter_slice(results, args[:slice]) if args[:slice]
-
-      # Strip Results if Except is defined
-      results = filter_except(results, args[:except]) if args[:except]
-
-      # Remove Blank from either slice or except
-      results.reject!(&:empty?)
-
-      # Sort
-      results.sort_by! { |x| x.slice(*args[:sort]).values } if args[:sort]
-
-      # JSON Formatting
-      results = results.map { |x| Oj.dump(x) } if args[:json]
-
-      # Show Unique Only
-      results = filter_uniq(results, args[:uniq]) if args.key?(:uniq)
-
-      # Reverse
-      results.reverse! if args[:reverse]
-
-      # Count occurrences / Skip Results
-      return filter_stats(results, args[:stats]) if args[:stats]
-
-      # Pluck
-      results = filter_pluck(results, args[:pluck]) if args.key?(:pluck)
-
-      # Truncate
-      # filter_truncate(results, args[:truncate].join.to_i) if args.key?(:truncate)
-
-      # Limit
-      if args[:limit]
-        results[0..args[:limit].map(&:to_s).join.to_i - 1]
-      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, args)
-      if args.start
-        begin
-          time_start = Time.parse(args.start.first.to_s)
-
-          results.select! do |x|
-            if x.time
-              time_start < x.time
-            else
-              true
-            end
-          end
-        rescue StandardError
-          puts 'Unable to Process Start Time Filter'.colorize(:red)
-        end
-      end
-
-      if args.end
-        begin
-          time_start = Time.parse(args.end.first.to_s)
-
-          results.select! do |x|
-            if x.time
-              time_start > x.time
-            else
-              true
-            end
-          end
-        rescue StandardError
-          puts 'Unable to Process End Time Filter'.colorize(:red)
-        end
-      end
-
-      results
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def self.filter_except(results, except)
-      # Avoid Empty Results
-      if slice.empty?
-        filter_empty_arg('slice')
-        return results
-      end
-
-      results.map { |row| row.except(*except) }
-    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]} #{'...'.colorize(:light_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.flatten
-    end
-
-    def self.filter_stats(results, stats)
-      # Avoid Empty Results
-      if stats.empty?
-        filter_empty_arg('stats')
-        return results
-      end
-
-      stats.map do |stat|
-        occurrences = filter_count_occurrences(results, stat)
-        occurrences.sort_by(&:last).to_h
-      end
-    end
-
-    # Helper to Count occurrences
-    def self.filter_count_occurrences(results, stat)
-      results.each_with_object(Hash.new(0)) do |entry, counts|
-        next unless entry.key? stat
-
-        counts[entry[stat]] += 1
-
-        counts
-      end
-    end
-
-    def self.filter_empty_arg(arg)
-      puts [
-        'Ignoring'.colorize(:light_yellow),
-        "--#{arg}".colorize(:cyan),
-        'it requires an argument'.colorize(:red)
-      ].join(' ')
-    end
-
-    # Break out filter row logic into separate method
-    def self.filter_row_key(row, param, args)
-      # Ignore Other Logic if Field isn't even included
-      return false unless row.key? param.field
-
-      # Sensitivity Check / Check for Match
-      included = if args.key?(:case)
-                   row[param.field].to_s.include? param.value.to_s
-                 else
-                   row[param.field].to_s.downcase.include? param.value.to_s.downcase
-                 end
-
-      # Pivot of off include vs exclude
-      if param.bang
-        !included
-      else
-        included
-      end
-    end
-
-    # Total Count Helper
-    def self.total_count(results)
-      results.each do |k, v|
-        puts k
-        puts "Total: #{v.count.to_s.colorize(:blue)}"
-        puts
-      end
-    end
-
-    # Total Log List Manipulator
-    def self.prepare_list(log_list, base_list = nil)
-      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
-
-    # Shortcut find things
-    def self.find_things(log_list, args = {})
-      things = log_list.uniq.flat_map do |log|
-        Thing.where name: log
-      end
-
-      # Host / Archive
-      things.select! { |x| x.archive? args.archive } if args.archive
-
-      things
-    end
-
-    # Main Entry Point for Searching
-    def self.search_start(log_list, filter_type, args, opts)
-      # Convert to Things
-      logs = ShellHelper.find_things(log_list, args)
-
-      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, filter_type, args, opts)
-
-        obj
-      end
-    end
-
-    # Generic Search Helper / String/Regex
-    def self.search(data, type = :all?, args = {}, opts = {})
-      results = data.clone.flatten.compact
-
-      results.select! do |row|
-        opts.send(type) do |opt|
-          search_row(row, opt)
-        end
-      end
-
-      # Strip Results if Slice is defined
-      results.map! { |row| row.slice(*args[:slice]) } if args[:slice]
-
-      # Strip Results if Except is defined
-      results.map! { |row| row.except(*args[:except]) } if args[: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, param)
-      # Not Included Param
-      included = row.to_s.include? param.value
-
-      if param.bang
-        !included
-      else
-        included
-      end
-    end
-
-    # 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
-  end
-  # rubocop:enable Metrics/ModuleLength
-end